summaryrefslogtreecommitdiffstats
path: root/src/widgets
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-27 16:29:01 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-27 16:29:01 +0000
commit35a96bde514a8897f6f0fcc41c5833bf63df2e2a (patch)
tree657d15a03cc46bd099fc2c6546a7a4ad43815d9f /src/widgets
parentInitial commit. (diff)
downloadinkscape-35a96bde514a8897f6f0fcc41c5833bf63df2e2a.tar.xz
inkscape-35a96bde514a8897f6f0fcc41c5833bf63df2e2a.zip
Adding upstream version 1.0.2.upstream/1.0.2upstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'src/widgets')
-rw-r--r--src/widgets/CMakeLists.txt45
-rw-r--r--src/widgets/README10
-rw-r--r--src/widgets/desktop-widget.cpp2570
-rw-r--r--src/widgets/desktop-widget.h354
-rw-r--r--src/widgets/ege-paint-def.cpp316
-rw-r--r--src/widgets/ege-paint-def.h112
-rw-r--r--src/widgets/fill-n-stroke-factory.h38
-rw-r--r--src/widgets/fill-style.cpp832
-rw-r--r--src/widgets/fill-style.h39
-rw-r--r--src/widgets/gradient-image.cpp285
-rw-r--r--src/widgets/gradient-image.h65
-rw-r--r--src/widgets/gradient-selector.cpp660
-rw-r--r--src/widgets/gradient-selector.h152
-rw-r--r--src/widgets/gradient-vector.cpp1314
-rw-r--r--src/widgets/gradient-vector.h90
-rw-r--r--src/widgets/ink-action.cpp200
-rw-r--r--src/widgets/ink-action.h61
-rw-r--r--src/widgets/mappings.xml334
-rw-r--r--src/widgets/paint-selector.cpp1601
-rw-r--r--src/widgets/paint-selector.h171
-rw-r--r--src/widgets/sp-attribute-widget.cpp303
-rw-r--r--src/widgets/sp-attribute-widget.h172
-rw-r--r--src/widgets/sp-color-selector.cpp334
-rw-r--r--src/widgets/sp-color-selector.h105
-rw-r--r--src/widgets/sp-xmlview-tree.cpp866
-rw-r--r--src/widgets/sp-xmlview-tree.h64
-rw-r--r--src/widgets/spinbutton-events.cpp163
-rw-r--r--src/widgets/spinbutton-events.h32
-rw-r--r--src/widgets/spw-utilities.cpp160
-rw-r--r--src/widgets/spw-utilities.h48
-rw-r--r--src/widgets/stroke-marker-selector.cpp567
-rw-r--r--src/widgets/stroke-marker-selector.h118
-rw-r--r--src/widgets/stroke-style.cpp1346
-rw-r--r--src/widgets/stroke-style.h227
-rw-r--r--src/widgets/style-utils.h35
-rw-r--r--src/widgets/swatch-selector.cpp168
-rw-r--r--src/widgets/swatch-selector.h68
-rw-r--r--src/widgets/toolbox.cpp842
-rw-r--r--src/widgets/toolbox.h84
-rw-r--r--src/widgets/widget-sizes.h57
40 files changed, 15008 insertions, 0 deletions
diff --git a/src/widgets/CMakeLists.txt b/src/widgets/CMakeLists.txt
new file mode 100644
index 0000000..3ed2a37
--- /dev/null
+++ b/src/widgets/CMakeLists.txt
@@ -0,0 +1,45 @@
+# SPDX-License-Identifier: GPL-2.0-or-later
+
+set(widgets_SRC
+ desktop-widget.cpp
+ ege-paint-def.cpp
+ fill-style.cpp
+ gradient-image.cpp
+ gradient-selector.cpp
+ gradient-vector.cpp
+ ink-action.cpp
+ paint-selector.cpp
+ sp-attribute-widget.cpp
+ sp-color-selector.cpp
+ sp-xmlview-tree.cpp
+ spinbutton-events.cpp
+ spw-utilities.cpp
+ stroke-marker-selector.cpp
+ stroke-style.cpp
+ swatch-selector.cpp
+ toolbox.cpp
+
+ # -------
+ # Headers
+ desktop-widget.h
+ ege-paint-def.h
+ fill-n-stroke-factory.h
+ fill-style.h
+ gradient-image.h
+ gradient-selector.h
+ gradient-vector.h
+ ink-action.h
+ paint-selector.h
+ sp-attribute-widget.h
+ sp-color-selector.h
+ sp-xmlview-tree.h
+ spinbutton-events.h
+ spw-utilities.h
+ stroke-marker-selector.h
+ stroke-style.h
+ swatch-selector.h
+ toolbox.h
+ widget-sizes.h
+)
+
+add_inkscape_source("${widgets_SRC}")
diff --git a/src/widgets/README b/src/widgets/README
new file mode 100644
index 0000000..b1c905a
--- /dev/null
+++ b/src/widgets/README
@@ -0,0 +1,10 @@
+
+
+This directory contains widgets written in 'C'.
+
+To do:
+
+* Replace 'C' widgets by 'C++' widgets.
+* Temporary move to 'ui/widgets/legacy'.
+
+
diff --git a/src/widgets/desktop-widget.cpp b/src/widgets/desktop-widget.cpp
new file mode 100644
index 0000000..491ce41
--- /dev/null
+++ b/src/widgets/desktop-widget.cpp
@@ -0,0 +1,2570 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/** \file
+ * Desktop widget implementation
+ */
+/* Authors:
+ * Lauris Kaplinski <lauris@kaplinski.com>
+ * MenTaLguY <mental@rydia.net>
+ * bulia byak <buliabyak@users.sf.net>
+ * Ralf Stephan <ralf@ark.in-berlin.de>
+ * John Bintz <jcoswell@coswellproductions.org>
+ * Johan Engelen <j.b.c.engelen@ewi.utwente.nl>
+ * Jon A. Cruz <jon@joncruz.org>
+ * Abhishek Sharma
+ *
+ * Copyright (C) 2007 Johan Engelen
+ * Copyright (C) 2006 John Bintz
+ * Copyright (C) 2004 MenTaLguY
+ * Copyright (C) 1999-2002 Lauris Kaplinski
+ * Copyright (C) 2000-2001 Ximian, Inc.
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#ifdef HAVE_CONFIG_H
+# include "config.h" // only include where actually required!
+#endif
+
+#include <2geom/rect.h>
+
+#include "attributes.h"
+#include "cms-system.h"
+#include "conn-avoid-ref.h"
+#include "desktop-events.h"
+#include "desktop-widget.h"
+#include "desktop.h"
+#include "document-undo.h"
+#include "ege-color-prof-tracker.h"
+#include "file.h"
+#include "inkscape-version.h"
+#include "verbs.h"
+
+#include "display/canvas-arena.h"
+#include "display/canvas-axonomgrid.h"
+#include "display/guideline.h"
+#include "display/sp-canvas.h"
+
+#include "extension/db.h"
+
+#include "helper/action.h"
+
+#include "object/sp-image.h"
+#include "object/sp-namedview.h"
+#include "object/sp-root.h"
+
+#include "ui/dialog/dialog-manager.h"
+#include "ui/dialog/swatches.h"
+#include "ui/icon-loader.h"
+#include "ui/icon-names.h"
+#include "ui/tools/box3d-tool.h"
+#include "ui/uxmanager.h"
+#include "ui/widget/button.h"
+#include "ui/widget/dock.h"
+#include "ui/widget/ink-ruler.h"
+#include "ui/widget/layer-selector.h"
+#include "ui/widget/selected-style.h"
+#include "ui/widget/spin-button-tool-item.h"
+#include "ui/widget/unit-tracker.h"
+
+// TEMP
+#include "ui/desktop/menubar.h"
+
+#include "util/ege-appear-time-tracker.h"
+#include "util/units.h"
+
+// We're in the "widgets" directory, so no need to explicitly prefix these:
+#include "spinbutton-events.h"
+#include "spw-utilities.h"
+#include "toolbox.h"
+#include "widget-sizes.h"
+
+#ifdef GDK_WINDOWING_QUARTZ
+#include <gtkosxapplication.h>
+#endif
+
+using Inkscape::DocumentUndo;
+using Inkscape::UI::Widget::UnitTracker;
+using Inkscape::UI::UXManager;
+using Inkscape::UI::ToolboxFactory;
+using ege::AppearTimeTracker;
+using Inkscape::Util::unit_table;
+
+
+//---------------------------------------------------------------------
+/* SPDesktopWidget */
+
+static void sp_desktop_widget_class_init (SPDesktopWidgetClass *klass);
+
+static void sp_desktop_widget_size_allocate (GtkWidget *widget, GtkAllocation *allocation);
+static void sp_desktop_widget_realize (GtkWidget *widget);
+
+static void sp_desktop_widget_adjustment_value_changed (GtkAdjustment *adj, SPDesktopWidget *dtw);
+
+static gdouble sp_dtw_zoom_value_to_display (gdouble value);
+static gdouble sp_dtw_zoom_display_to_value (gdouble value);
+static void sp_dtw_zoom_menu_handler (SPDesktop *dt, gdouble factor);
+
+SPViewWidgetClass *dtw_parent_class;
+
+class CMSPrefWatcher {
+public:
+ CMSPrefWatcher() :
+ _dpw(*this),
+ _spw(*this),
+ _tracker(ege_color_prof_tracker_new(nullptr))
+ {
+ Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+ g_signal_connect( G_OBJECT(_tracker), "modified", G_CALLBACK(hook), this );
+ prefs->addObserver(_dpw);
+ prefs->addObserver(_spw);
+ }
+ virtual ~CMSPrefWatcher() = default;
+
+ //virtual void notify(PrefValue &);
+ void add( SPDesktopWidget* dtw ) {
+ _widget_list.push_back(dtw);
+ }
+ void remove( SPDesktopWidget* dtw ) {
+ _widget_list.remove(dtw);
+ }
+
+private:
+ static void hook(EgeColorProfTracker *tracker, gint b, CMSPrefWatcher *watcher);
+
+ class DisplayProfileWatcher : public Inkscape::Preferences::Observer {
+ public:
+ DisplayProfileWatcher(CMSPrefWatcher &pw) : Observer("/options/displayprofile"), _pw(pw) {}
+ void notify(Inkscape::Preferences::Entry const &/*val*/) override {
+ Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+ _pw._setCmsSensitive(!prefs->getString("/options/displayprofile/uri").empty());
+ _pw._refreshAll();
+ }
+ private:
+ CMSPrefWatcher &_pw;
+ };
+
+ DisplayProfileWatcher _dpw;
+
+ class SoftProofWatcher : public Inkscape::Preferences::Observer {
+ public:
+ SoftProofWatcher(CMSPrefWatcher &pw) : Observer("/options/softproof"), _pw(pw) {}
+ void notify(Inkscape::Preferences::Entry const &) override {
+ _pw._refreshAll();
+ }
+ private:
+ CMSPrefWatcher &_pw;
+ };
+
+ SoftProofWatcher _spw;
+
+ void _refreshAll();
+ void _setCmsSensitive(bool value);
+
+ std::list<SPDesktopWidget*> _widget_list;
+ EgeColorProfTracker *_tracker;
+
+ friend class DisplayProfileWatcher;
+ friend class SoftproofWatcher;
+};
+
+#if defined(HAVE_LIBLCMS2)
+void CMSPrefWatcher::hook(EgeColorProfTracker * /*tracker*/, gint monitor, CMSPrefWatcher * /*watcher*/)
+{
+ unsigned char* buf = nullptr;
+ guint len = 0;
+
+ ege_color_prof_tracker_get_profile_for( monitor, reinterpret_cast<gpointer*>(&buf), &len );
+ Glib::ustring id = Inkscape::CMSSystem::setDisplayPer( buf, len, monitor );
+}
+#else
+void CMSPrefWatcher::hook(EgeColorProfTracker * /*tracker*/, gint /*monitor*/, CMSPrefWatcher * /*watcher*/)
+{
+}
+#endif // defined(HAVE_LIBLCMS2)
+
+/// @todo Use conditional compilation in saner places. The whole PrefWatcher
+/// object is unnecessary if defined(HAVE_LIBLCMS2) is not defined.
+void CMSPrefWatcher::_refreshAll()
+{
+#if defined(HAVE_LIBLCMS2)
+ for (auto & it : _widget_list) {
+ it->requestCanvasUpdate();
+ }
+#endif // defined(HAVE_LIBLCMS2)
+}
+
+void CMSPrefWatcher::_setCmsSensitive(bool enabled)
+{
+#if defined(HAVE_LIBLCMS2)
+ for ( auto dtw : _widget_list ) {
+ auto cms_adj = dtw->get_cms_adjust();
+ if ( cms_adj->get_sensitive() != enabled ) {
+ dtw->cms_adjust_set_sensitive(enabled);
+ }
+ }
+#else
+ (void) enabled;
+#endif // defined(HAVE_LIBLCMS2)
+}
+
+static CMSPrefWatcher* watcher = nullptr;
+
+void
+SPDesktopWidget::setMessage (Inkscape::MessageType type, const gchar *message)
+{
+ _select_status->set_markup(message ? message : "");
+
+ // make sure the important messages are displayed immediately!
+ if (type == Inkscape::IMMEDIATE_MESSAGE && _select_status->get_is_drawable()) {
+ _select_status->queue_draw();
+ }
+
+ _select_status->set_tooltip_text(_select_status->get_text());
+}
+
+Geom::Point
+SPDesktopWidget::window_get_pointer()
+{
+ int x, y;
+ auto window = Glib::wrap(GTK_WIDGET(_canvas))->get_window();
+ auto display = window->get_display();
+ auto seat = display->get_default_seat();
+ auto device = seat->get_pointer();
+ Gdk::ModifierType m;
+ window->get_device_position(device, x, y, m);
+
+ return Geom::Point(x, y);
+}
+
+static GTimer *overallTimer = nullptr;
+
+/**
+ * Registers SPDesktopWidget class and returns its type number.
+ */
+GType SPDesktopWidget::getType()
+{
+ static GType type = 0;
+ if (!type) {
+ GTypeInfo info = {
+ sizeof(SPDesktopWidgetClass),
+ nullptr, // base_init
+ nullptr, // base_finalize
+ (GClassInitFunc)sp_desktop_widget_class_init,
+ nullptr, // class_finalize
+ nullptr, // class_data
+ sizeof(SPDesktopWidget),
+ 0, // n_preallocs
+ (GInstanceInitFunc)SPDesktopWidget::init,
+ nullptr // value_table
+ };
+ type = g_type_register_static(SP_TYPE_VIEW_WIDGET, "SPDesktopWidget", &info, static_cast<GTypeFlags>(0));
+ // Begin a timer to watch for the first desktop to appear on-screen
+ overallTimer = g_timer_new();
+ }
+ return type;
+}
+
+/**
+ * SPDesktopWidget vtable initialization
+ */
+static void
+sp_desktop_widget_class_init (SPDesktopWidgetClass *klass)
+{
+ dtw_parent_class = SP_VIEW_WIDGET_CLASS(g_type_class_peek_parent(klass));
+
+ GObjectClass *object_class = G_OBJECT_CLASS(klass);
+ GtkWidgetClass *widget_class = GTK_WIDGET_CLASS(klass);
+
+ object_class->dispose = SPDesktopWidget::dispose;
+
+ widget_class->size_allocate = sp_desktop_widget_size_allocate;
+ widget_class->realize = sp_desktop_widget_realize;
+}
+
+/**
+ * Callback for changes in size of the canvas table (i.e. the container for
+ * the canvas, the rulers etc).
+ *
+ * This adjusts the range of the rulers when the dock container is adjusted
+ * (fixes lp:950552)
+ *
+ * This fix was causing the rulers to be completely redrawn when not needed.
+ * Added check to see if allocation really changed.
+ *
+ *(Question, why is the callback being called when allocation not changed?)
+ */
+void
+SPDesktopWidget::canvas_tbl_size_allocate(Gtk::Allocation& allocation)
+{
+ if (_allocation == allocation) {
+ return;
+ }
+
+ _allocation = allocation;
+ update_rulers();
+}
+
+/**
+ * Callback for SPDesktopWidget object initialization.
+ */
+void SPDesktopWidget::init( SPDesktopWidget *dtw )
+{
+ Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+
+ new (&dtw->modified_connection) sigc::connection();
+
+ dtw->_ruler_clicked = false;
+ dtw->_ruler_dragged = false;
+ dtw->_active_guide = nullptr;
+ dtw->_xp = 0;
+ dtw->_yp = 0;
+ dtw->window = nullptr;
+ dtw->desktop = nullptr;
+ dtw->_interaction_disabled_counter = 0;
+
+ /* Main table */
+ dtw->_vbox = Gtk::manage(new Gtk::Box(Gtk::ORIENTATION_VERTICAL));
+ dtw->_vbox->set_name("DesktopMainTable");
+ gtk_container_add( GTK_CONTAINER(dtw), GTK_WIDGET(dtw->_vbox->gobj()) );
+
+ /* Status bar */
+ dtw->_statusbar = Gtk::manage(new Gtk::Box());
+ dtw->_statusbar->set_name("DesktopStatusBar");
+ dtw->_vbox->pack_end(*dtw->_statusbar, false, true);
+
+ /* Swatches panel */
+ {
+ dtw->_panels = new Inkscape::UI::Dialog::SwatchesPanel("/embedded/swatches");
+ dtw->_panels->set_vexpand(false);
+ dtw->_vbox->pack_end(*dtw->_panels, false, true);
+ }
+
+ /* DesktopHBox (Vertical toolboxes, canvas) */
+ dtw->_hbox = Gtk::manage(new Gtk::Box());
+ dtw->_hbox->set_name("DesktopHbox");
+ dtw->_vbox->pack_end(*dtw->_hbox, true, true);
+
+ /* Toolboxes */
+ dtw->aux_toolbox = ToolboxFactory::createAuxToolbox();
+ dtw->_vbox->pack_end(*Glib::wrap(dtw->aux_toolbox), false, true);
+
+ dtw->snap_toolbox = ToolboxFactory::createSnapToolbox();
+ ToolboxFactory::setOrientation( dtw->snap_toolbox, GTK_ORIENTATION_VERTICAL );
+ dtw->_hbox->pack_end(*Glib::wrap(dtw->snap_toolbox), false, true);
+
+ dtw->commands_toolbox = ToolboxFactory::createCommandsToolbox();
+ dtw->_vbox->pack_end(*Glib::wrap(dtw->commands_toolbox), false, true);
+
+ dtw->tool_toolbox = ToolboxFactory::createToolToolbox();
+ ToolboxFactory::setOrientation( dtw->tool_toolbox, GTK_ORIENTATION_VERTICAL );
+ dtw->_hbox->pack_start(*Glib::wrap(dtw->tool_toolbox), false, true);
+
+ /* Canvas table wrapper */
+ auto tbl_wrapper = Gtk::manage(new Gtk::Grid()); // Is this widget really needed? No!
+ tbl_wrapper->set_name("CanvasTableWrapper");
+ dtw->_hbox->pack_start(*tbl_wrapper, true, true, 1);
+
+ /* Canvas table */
+ dtw->_canvas_tbl = Gtk::manage(new Gtk::Grid());
+ dtw->_canvas_tbl->set_name("CanvasTable");
+ // Added to table wrapper later either directly or via paned window shared with dock.
+
+
+
+ // Lock guides button
+ dtw->_guides_lock = Gtk::manage(new Inkscape::UI::Widget::Button(GTK_ICON_SIZE_MENU,
+ Inkscape::UI::Widget::BUTTON_TYPE_TOGGLE,
+ nullptr,
+ INKSCAPE_ICON("object-locked"),
+ _("Toggle lock of all guides in the document")));
+
+ auto guides_lock_style_provider = Gtk::CssProvider::create();
+ guides_lock_style_provider->load_from_data("GtkWidget { padding-left: 0; padding-right: 0; padding-top: 0; padding-bottom: 0; }");
+ dtw->_guides_lock->set_name("LockGuides");
+ auto context = dtw->_guides_lock->get_style_context();
+ context->add_provider(guides_lock_style_provider, GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
+ dtw->_guides_lock->signal_toggled().connect(sigc::mem_fun(dtw, &SPDesktopWidget::update_guides_lock));
+ dtw->_canvas_tbl->attach(*dtw->_guides_lock, 0, 0, 1, 1);
+
+ /* Rulers */
+ Inkscape::Util::Unit const *pt = unit_table.getUnit("pt");
+
+ /* Horizontal ruler */
+ dtw->_hruler = Gtk::manage(new Inkscape::UI::Widget::Ruler(Gtk::ORIENTATION_HORIZONTAL));
+ dtw->_hruler->set_unit(pt);
+
+ // We should probably get rid of this and attach the signals directly rulers.
+ dtw->_hruler_box = Gtk::manage(new Gtk::EventBox());
+ dtw->_hruler_box->set_tooltip_text(gettext(pt->name_plural.c_str()));
+ dtw->_hruler_box->add(*dtw->_hruler);
+ dtw->_hruler_box->signal_button_press_event().connect(sigc::bind(sigc::mem_fun(*dtw, &SPDesktopWidget::on_ruler_box_button_press_event), dtw->_hruler_box, true));
+ dtw->_hruler_box->signal_button_release_event().connect(sigc::bind(sigc::mem_fun(*dtw, &SPDesktopWidget::on_ruler_box_button_release_event), dtw->_hruler_box, true));
+ dtw->_hruler_box->signal_motion_notify_event().connect(sigc::bind(sigc::mem_fun(*dtw, &SPDesktopWidget::on_ruler_box_motion_notify_event), dtw->_hruler_box, true));
+
+ dtw->_canvas_tbl->attach(*dtw->_hruler_box, 1, 0, 1, 1);
+
+ /* Vertical ruler */
+ dtw->_vruler = Gtk::manage(new Inkscape::UI::Widget::Ruler(Gtk::ORIENTATION_VERTICAL));
+ dtw->_vruler->set_unit(pt);
+
+ dtw->_vruler_box = Gtk::manage(new Gtk::EventBox());
+ dtw->_vruler_box->set_tooltip_text(gettext(pt->name_plural.c_str()));
+ dtw->_vruler_box->add(*dtw->_vruler);
+ dtw->_vruler_box->signal_button_press_event().connect(sigc::bind(sigc::mem_fun(*dtw, &SPDesktopWidget::on_ruler_box_button_press_event), dtw->_vruler_box, false));
+ dtw->_vruler_box->signal_button_release_event().connect(sigc::bind(sigc::mem_fun(*dtw, &SPDesktopWidget::on_ruler_box_button_release_event), dtw->_vruler_box, false));
+ dtw->_vruler_box->signal_motion_notify_event().connect(sigc::bind(sigc::mem_fun(*dtw, &SPDesktopWidget::on_ruler_box_motion_notify_event), dtw->_vruler_box, false));
+
+ dtw->_canvas_tbl->attach(*dtw->_vruler_box, 0, 1, 1, 1);
+
+ // Horizontal scrollbar
+ dtw->_hadj = Gtk::Adjustment::create(0.0, -4000.0, 4000.0, 10.0, 100.0, 4.0);
+ dtw->_hscrollbar = Gtk::manage(new Gtk::Scrollbar(dtw->_hadj));
+ dtw->_hscrollbar->set_name("HorizontalScrollbar");
+ dtw->_canvas_tbl->attach(*dtw->_hscrollbar, 1, 2, 1, 1);
+
+ // By packing the sticky zoom button and vertical scrollbar in a box it allows the canvas to
+ // expand fully to the top if the rulers are hidden.
+ // (Otherwise, the canvas is pushed down by the height of the sticky zoom button.)
+
+ // Vertical Scrollbar box
+ dtw->_vscrollbar_box = Gtk::manage(new Gtk::Box(Gtk::ORIENTATION_VERTICAL));
+ dtw->_canvas_tbl->attach(*dtw->_vscrollbar_box, 2, 0, 1, 2);
+
+ // Sticky zoom button
+ dtw->_sticky_zoom = Gtk::manage(new Inkscape::UI::Widget::Button(GTK_ICON_SIZE_MENU,
+ Inkscape::UI::Widget::BUTTON_TYPE_TOGGLE,
+ nullptr,
+ INKSCAPE_ICON("zoom-original"),
+ _("Zoom drawing if window size changes")));
+ dtw->_sticky_zoom->set_name("StickyZoom");
+ dtw->_sticky_zoom->set_active(prefs->getBool("/options/stickyzoom/value"));
+ dtw->_sticky_zoom->signal_toggled().connect(sigc::mem_fun(dtw, &SPDesktopWidget::sticky_zoom_toggled));
+ dtw->_vscrollbar_box->pack_start(*dtw->_sticky_zoom, false, false);
+
+ // Vertical scrollbar
+ dtw->_vadj = Gtk::Adjustment::create(0.0, -4000.0, 4000.0, 10.0, 100.0, 4.0);
+ dtw->_vscrollbar = Gtk::manage(new Gtk::Scrollbar(dtw->_vadj, Gtk::ORIENTATION_VERTICAL));
+ dtw->_vscrollbar->set_name("VerticalScrollbar");
+ dtw->_vscrollbar_box->pack_start(*dtw->_vscrollbar, true, true, 0);
+
+ gchar const* tip = "";
+ Inkscape::Verb* verb = Inkscape::Verb::get( SP_VERB_VIEW_CMS_TOGGLE );
+ if ( verb ) {
+ SPAction *act = verb->get_action( Inkscape::ActionContext( dtw->viewwidget.view ) );
+ if ( act && act->tip ) {
+ tip = act->tip;
+ }
+ }
+ dtw->_cms_adjust = Gtk::manage(new Inkscape::UI::Widget::Button(GTK_ICON_SIZE_MENU,
+ Inkscape::UI::Widget::BUTTON_TYPE_TOGGLE,
+ nullptr,
+ INKSCAPE_ICON("color-management"),
+ tip ));
+ dtw->_cms_adjust->set_name("CMS_Adjust");
+
+#if defined(HAVE_LIBLCMS2)
+ {
+ Glib::ustring current = prefs->getString("/options/displayprofile/uri");
+ bool enabled = current.length() > 0;
+ dtw->cms_adjust_set_sensitive(enabled );
+ if ( enabled ) {
+ bool active = prefs->getBool("/options/displayprofile/enable");
+ if ( active ) {
+ dtw->_cms_adjust->toggle_set_down(true);
+ }
+ }
+ }
+ g_signal_connect_after( G_OBJECT(dtw->_cms_adjust->gobj()), "clicked", G_CALLBACK(SPDesktopWidget::cms_adjust_toggled), dtw );
+#else
+ dtw->cms_adjust_set_sensitive(false);
+#endif // defined(HAVE_LIBLCMS2)
+
+ dtw->_canvas_tbl->attach(*dtw->_cms_adjust, 2, 2, 1, 1);
+ {
+ if (!watcher) {
+ watcher = new CMSPrefWatcher();
+ }
+ watcher->add(dtw);
+ }
+ /* Canvas */
+ dtw->_canvas = SP_CANVAS(SPCanvas::createAA());
+#if defined(HAVE_LIBLCMS2)
+ dtw->_canvas->_enable_cms_display_adj = prefs->getBool("/options/displayprofile/enable");
+#endif // defined(HAVE_LIBLCMS2)
+ gtk_widget_set_can_focus (GTK_WIDGET (dtw->_canvas), TRUE);
+
+ dtw->_hruler->add_track_widget(*Glib::wrap(GTK_WIDGET(dtw->_canvas)));
+ dtw->_vruler->add_track_widget(*Glib::wrap(GTK_WIDGET(dtw->_canvas)));
+
+ auto css_provider = gtk_css_provider_new();
+ auto style_context = gtk_widget_get_style_context(GTK_WIDGET(dtw->_canvas));
+
+ gtk_css_provider_load_from_data(css_provider,
+ "SPCanvas {\n"
+ " background-color: white;\n"
+ "}\n",
+ -1, nullptr);
+
+ gtk_style_context_add_provider(style_context,
+ GTK_STYLE_PROVIDER(css_provider),
+ GTK_STYLE_PROVIDER_PRIORITY_USER);
+ g_signal_connect(G_OBJECT(dtw->_canvas), "event", G_CALLBACK(SPDesktopWidget::event), dtw);
+
+ gtk_widget_set_hexpand(GTK_WIDGET(dtw->_canvas), TRUE);
+ gtk_widget_set_vexpand(GTK_WIDGET(dtw->_canvas), TRUE);
+ dtw->_canvas_tbl->attach(*Glib::wrap(GTK_WIDGET(dtw->_canvas)), 1, 1, 1, 1);
+
+ /* Dock */
+ bool create_dock =
+ prefs->getIntLimited("/options/dialogtype/value", Inkscape::UI::Dialog::FLOATING, 0, 1) ==
+ Inkscape::UI::Dialog::DOCK;
+
+ if (create_dock) {
+ dtw->_dock = new Inkscape::UI::Widget::Dock();
+ auto paned = new Gtk::Paned();
+ paned->set_name("Canvas_and_Dock");
+
+ paned->pack1(*dtw->_canvas_tbl);
+ paned->pack2(dtw->_dock->getWidget(), Gtk::FILL);
+
+ /* Prevent the paned from catching F6 and F8 by unsetting the default callbacks */
+ if (GtkPanedClass *paned_class = GTK_PANED_CLASS (G_OBJECT_GET_CLASS (paned->gobj()))) {
+ paned_class->cycle_child_focus = nullptr;
+ paned_class->cycle_handle_focus = nullptr;
+ }
+
+ paned->set_hexpand(true);
+ paned->set_vexpand(true);
+ tbl_wrapper->attach(*paned, 1, 1, 1, 1);
+ } else {
+ dtw->_canvas_tbl->set_hexpand(true);
+ dtw->_canvas_tbl->set_vexpand(true);
+ tbl_wrapper->attach(*(dtw->_canvas_tbl), 1, 1, 1, 1);
+ }
+
+ // connect scrollbar signals
+ dtw->_hadj->signal_value_changed().connect(sigc::mem_fun(dtw, &SPDesktopWidget::on_adjustment_value_changed));
+ dtw->_vadj->signal_value_changed().connect(sigc::mem_fun(dtw, &SPDesktopWidget::on_adjustment_value_changed));
+
+ // --------------- Status Tool Bar ------------------//
+
+ // Selected Style (Fill/Stroke/Opacity)
+ dtw->_selected_style = new Inkscape::UI::Widget::SelectedStyle(true);
+ dtw->_statusbar->pack_start(*dtw->_selected_style, false, false);
+
+ // Separator
+ dtw->_statusbar->pack_start(*Gtk::manage(new Gtk::Separator(Gtk::ORIENTATION_VERTICAL)),
+ false, false);
+
+ // Layer Selector
+ dtw->layer_selector = new Inkscape::UI::Widget::LayerSelector(nullptr);
+ // FIXME: need to unreference on container destruction to avoid leak
+ dtw->layer_selector->reference();
+ dtw->_statusbar->pack_start(*dtw->layer_selector, false, false, 1);
+
+ // Select Status
+ dtw->_select_status = Gtk::manage(new Gtk::Label());
+ dtw->_select_status->set_name("SelectStatus");
+ dtw->_select_status->set_ellipsize(Pango::ELLIPSIZE_END);
+ dtw->_select_status->set_line_wrap(true);
+ dtw->_select_status->set_lines(2);
+ dtw->_select_status->set_halign(Gtk::ALIGN_START);
+ dtw->_select_status->set_size_request(1, -1);
+
+ // Display the initial welcome message in the statusbar
+ dtw->_select_status->set_markup(_("<b>Welcome to Inkscape!</b> Use shape or freehand tools to create objects; use selector (arrow) to move or transform them."));
+
+ dtw->_statusbar->pack_start(*dtw->_select_status, true, true);
+
+
+ // Zoom status spinbutton ---------------
+ auto zoom_adj = Gtk::Adjustment::create(100.0, log(SP_DESKTOP_ZOOM_MIN)/log(2), log(SP_DESKTOP_ZOOM_MAX)/log(2), 0.1);
+ dtw->_zoom_status = Gtk::manage(new Gtk::SpinButton(zoom_adj));
+
+ dtw->_zoom_status->set_data("dtw", dtw->_canvas);
+ dtw->_zoom_status->set_tooltip_text(_("Zoom"));
+ dtw->_zoom_status->set_size_request(STATUS_ZOOM_WIDTH, -1);
+ dtw->_zoom_status->set_width_chars(6);
+ dtw->_zoom_status->set_numeric(false);
+ dtw->_zoom_status->set_update_policy(Gtk::UPDATE_ALWAYS);
+
+ // Callbacks
+ dtw->_zoom_status_input_connection = dtw->_zoom_status->signal_input().connect(sigc::mem_fun(dtw, &SPDesktopWidget::zoom_input));
+ dtw->_zoom_status_output_connection = dtw->_zoom_status->signal_output().connect(sigc::mem_fun(dtw, &SPDesktopWidget::zoom_output));
+ g_signal_connect (G_OBJECT (dtw->_zoom_status->gobj()), "focus-in-event", G_CALLBACK (spinbutton_focus_in), dtw->_zoom_status->gobj());
+ g_signal_connect (G_OBJECT (dtw->_zoom_status->gobj()), "key-press-event", G_CALLBACK (spinbutton_keypress), dtw->_zoom_status->gobj());
+ dtw->_zoom_status_value_changed_connection = dtw->_zoom_status->signal_value_changed().connect(sigc::mem_fun(dtw, &SPDesktopWidget::zoom_value_changed));
+ dtw->_zoom_status_populate_popup_connection = dtw->_zoom_status->signal_populate_popup().connect(sigc::mem_fun(dtw, &SPDesktopWidget::zoom_populate_popup));
+
+ // Style
+ auto css_provider_spinbutton = Gtk::CssProvider::create();
+ css_provider_spinbutton->load_from_data("* { padding-left: 2px; padding-right: 2px; padding-top: 0px; padding-bottom: 0px;}"); // Shouldn't this be in a style sheet? Used also by rotate.
+
+ dtw->_zoom_status->set_name("ZoomStatus");
+ auto context_zoom = dtw->_zoom_status->get_style_context();
+ context_zoom->add_provider(css_provider_spinbutton, GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
+
+ // Rotate status spinbutton ---------------
+ auto rotation_adj = Gtk::Adjustment::create(0, -360.0, 360.0, 1.0);
+ dtw->_rotation_status = Gtk::manage(new Gtk::SpinButton(rotation_adj));
+ dtw->_rotation_status->set_data("dtw", dtw->_canvas);
+ dtw->_rotation_status->set_tooltip_text(_("Rotation. (Also Ctrl+Shift+Scroll)"));
+ dtw->_rotation_status->set_size_request(STATUS_ROTATION_WIDTH, -1);
+ dtw->_rotation_status->set_width_chars(7);
+ dtw->_rotation_status->set_numeric(false);
+ dtw->_rotation_status->set_digits(2);
+ dtw->_rotation_status->set_increments(1.0, 15.0);
+ dtw->_rotation_status->set_update_policy(Gtk::UPDATE_ALWAYS);
+
+ // Callbacks
+ dtw->_rotation_status_input_connection = dtw->_rotation_status->signal_input().connect(sigc::mem_fun(dtw, &SPDesktopWidget::rotation_input));
+ dtw->_rotation_status_output_connection = dtw->_rotation_status->signal_output().connect(sigc::mem_fun(dtw, &SPDesktopWidget::rotation_output));
+ g_signal_connect (G_OBJECT (dtw->_rotation_status->gobj()), "focus-in-event", G_CALLBACK (spinbutton_focus_in), dtw->_rotation_status->gobj());
+ g_signal_connect (G_OBJECT (dtw->_rotation_status->gobj()), "key-press-event", G_CALLBACK (spinbutton_keypress), dtw->_rotation_status->gobj());
+ dtw->_rotation_status_value_changed_connection = dtw->_rotation_status->signal_value_changed().connect(sigc::mem_fun(dtw, &SPDesktopWidget::rotation_value_changed));
+ dtw->_rotation_status_populate_popup_connection = dtw->_rotation_status->signal_populate_popup().connect(sigc::mem_fun(dtw, &SPDesktopWidget::rotation_populate_popup));
+
+ // Style
+ dtw->_rotation_status->set_name("RotationStatus");
+ auto context_rotation = dtw->_rotation_status->get_style_context();
+ context_rotation->add_provider(css_provider_spinbutton, GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
+
+
+ // Cursor coordinates
+ dtw->_coord_status = Gtk::manage(new Gtk::Grid());
+ dtw->_coord_status->set_name("CoordinateAndZStatus");
+ dtw->_coord_status->set_row_spacing(0);
+ dtw->_coord_status->set_column_spacing(10);
+ dtw->_coord_status->set_margin_end(10);
+ auto sep = Gtk::manage(new Gtk::Separator(Gtk::ORIENTATION_VERTICAL));
+ sep->set_name("CoordinateSeparator");
+ dtw->_coord_status->attach(*sep, 0, 0, 1, 2);
+
+ dtw->_coord_status->set_tooltip_text(_("Cursor coordinates"));
+ auto label_x = Gtk::manage(new Gtk::Label(_("X:")));
+ auto label_y = Gtk::manage(new Gtk::Label(_("Y:")));
+ label_x->set_halign(Gtk::ALIGN_START);
+ label_y->set_halign(Gtk::ALIGN_START);
+ dtw->_coord_status->attach(*label_x, 1, 0, 1, 1);
+ dtw->_coord_status->attach(*label_y, 1, 1, 1, 1);
+ dtw->_coord_status_x = Gtk::manage(new Gtk::Label());
+ dtw->_coord_status_y = Gtk::manage(new Gtk::Label());
+ dtw->_coord_status_x->set_name("CoordinateStatusX");
+ dtw->_coord_status_y->set_name("CoordinateStatusY");
+ dtw->_coord_status_x->set_markup(" 0.00 ");
+ dtw->_coord_status_y->set_markup(" 0.00 ");
+
+ auto label_z = Gtk::manage(new Gtk::Label(_("Z:")));
+ label_z->set_name("ZLabel");
+ auto label_r = Gtk::manage(new Gtk::Label(_("R:")));
+ label_r->set_name("RLabel");
+
+ dtw->_coord_status_x->set_halign(Gtk::ALIGN_END);
+ dtw->_coord_status_y->set_halign(Gtk::ALIGN_END);
+ dtw->_coord_status->attach(*dtw->_coord_status_x, 2, 0, 1, 1);
+ dtw->_coord_status->attach(*dtw->_coord_status_y, 2, 1, 1, 1);
+
+ dtw->_coord_status->attach(*label_z, 3, 0, 1, 2);
+ dtw->_coord_status->attach(*dtw->_zoom_status, 4, 0, 1, 2);
+
+ dtw->_coord_status->attach(*label_r, 5, 0, 1, 2);
+ dtw->_coord_status->attach(*dtw->_rotation_status, 6, 0, 1, 2);
+
+ dtw->_statusbar->pack_end(*dtw->_coord_status, false, false);
+
+ // --------------- Color Management ---------------- //
+ dtw->_tracker = ege_color_prof_tracker_new(GTK_WIDGET(dtw->layer_selector->gobj()));
+#if defined(HAVE_LIBLCMS2)
+ bool fromDisplay = prefs->getBool( "/options/displayprofile/from_display");
+ if ( fromDisplay ) {
+ Glib::ustring id = Inkscape::CMSSystem::getDisplayId( 0 );
+
+ bool enabled = false;
+ dtw->_canvas->_cms_key = id;
+ enabled = !dtw->_canvas->_cms_key.empty();
+ dtw->cms_adjust_set_sensitive(enabled);
+ }
+ g_signal_connect( G_OBJECT(dtw->_tracker), "changed", G_CALLBACK(SPDesktopWidget::color_profile_event), dtw );
+#endif // defined(HAVE_LIBLCMS2)
+
+ // ------------------ Finish Up -------------------- //
+ dtw->_vbox->show_all();
+
+ gtk_widget_grab_focus (GTK_WIDGET(dtw->_canvas));
+
+ // If this is the first desktop created, report the time it takes to show up
+ if ( overallTimer ) {
+ if ( prefs->getBool("/dialogs/debug/trackAppear", false) ) {
+ // Time tracker takes ownership of the timer.
+ AppearTimeTracker *tracker = new AppearTimeTracker(overallTimer, GTK_WIDGET(dtw), "first SPDesktopWidget");
+ tracker->setAutodelete(true);
+ } else {
+ g_timer_destroy(overallTimer);
+ }
+ overallTimer = nullptr;
+ }
+ // Ensure that ruler ranges are updated correctly whenever the canvas table
+ // is resized
+ dtw->_canvas_tbl_size_allocate_connection = dtw->_canvas_tbl->signal_size_allocate().connect(sigc::mem_fun(dtw, &SPDesktopWidget::canvas_tbl_size_allocate));
+}
+
+/**
+ * Called before SPDesktopWidget destruction.
+ */
+void
+SPDesktopWidget::dispose(GObject *object)
+{
+ SPDesktopWidget *dtw = SP_DESKTOP_WIDGET (object);
+
+ if (dtw == nullptr) {
+ return;
+ }
+
+ UXManager::getInstance()->delTrack(dtw);
+
+ if (dtw->desktop) {
+ if ( watcher ) {
+ watcher->remove(dtw);
+ }
+
+ // Zoom
+ dtw->_zoom_status_input_connection.disconnect();
+ dtw->_zoom_status_output_connection.disconnect();
+ g_signal_handlers_disconnect_matched (G_OBJECT (dtw->_zoom_status->gobj()), G_SIGNAL_MATCH_DATA, 0, 0, nullptr, nullptr, dtw->_zoom_status);
+ dtw->_zoom_status_value_changed_connection.disconnect();
+ dtw->_zoom_status_populate_popup_connection.disconnect();
+
+ // Rotation
+ dtw->_rotation_status_input_connection.disconnect();
+ dtw->_rotation_status_output_connection.disconnect();
+ g_signal_handlers_disconnect_matched (G_OBJECT (dtw->_rotation_status->gobj()), G_SIGNAL_MATCH_DATA, 0, 0, nullptr, nullptr, dtw->_rotation_status);
+ dtw->_rotation_status_value_changed_connection.disconnect();
+ dtw->_rotation_status_populate_popup_connection.disconnect();
+
+ // Canvas
+ g_signal_handlers_disconnect_by_func (G_OBJECT (dtw->_canvas), (gpointer) G_CALLBACK (SPDesktopWidget::event), dtw);
+ dtw->_canvas_tbl_size_allocate_connection.disconnect();
+
+ dtw->layer_selector->setDesktop(nullptr);
+ dtw->layer_selector->unreference();
+ INKSCAPE.remove_desktop(dtw->desktop); // clears selection and event_context
+ dtw->modified_connection.disconnect();
+ dtw->desktop->destroy();
+ Inkscape::GC::release (dtw->desktop);
+ dtw->desktop = nullptr;
+ }
+
+ dtw->modified_connection.~connection();
+
+ if (G_OBJECT_CLASS (dtw_parent_class)->dispose) {
+ (* G_OBJECT_CLASS (dtw_parent_class)->dispose) (object);
+ }
+}
+
+/**
+ * Set the title in the desktop-window (if desktop has an own window).
+ *
+ * The title has form file name: desktop number - Inkscape.
+ * The desktop number is only shown if it's 2 or higher,
+ */
+void
+SPDesktopWidget::updateTitle(gchar const* uri)
+{
+ if (window) {
+
+ SPDocument *doc = this->desktop->doc();
+
+ std::string Name;
+ if (doc->isModifiedSinceSave()) {
+ Name += "*";
+ }
+
+ Name += uri;
+
+ if (desktop->number > 1) {
+ Name += ": ";
+ Name += std::to_string(desktop->number);
+ }
+ Name += " (";
+
+ if (desktop->getMode() == Inkscape::RENDERMODE_OUTLINE) {
+ Name += N_("outline");
+ } else if (desktop->getMode() == Inkscape::RENDERMODE_NO_FILTERS) {
+ Name += N_("no filters");
+ } else if (desktop->getMode() == Inkscape::RENDERMODE_VISIBLE_HAIRLINES) {
+ Name += N_("visible hairlines");
+ }
+
+ if (desktop->getColorMode() != Inkscape::COLORMODE_NORMAL &&
+ desktop->getMode() != Inkscape::RENDERMODE_NORMAL) {
+ Name += ", ";
+ }
+
+ if (desktop->getColorMode() == Inkscape::COLORMODE_GRAYSCALE) {
+ Name += N_("grayscale");
+ } else if (desktop->getColorMode() == Inkscape::COLORMODE_PRINT_COLORS_PREVIEW) {
+ Name += N_("print colors preview");
+ }
+
+ if (*Name.rbegin() == '(') { // Can not use C++11 .back() or .pop_back() with ustring!
+ Name.erase(Name.size() - 2);
+ } else {
+ Name += ")";
+ }
+
+ Name += " - Inkscape";
+
+ // Name += " (";
+ // Name += Inkscape::version_string;
+ // Name += ")";
+
+ window->set_title (Name);
+ }
+}
+
+Inkscape::UI::Widget::Dock*
+SPDesktopWidget::getDock()
+{
+ return _dock;
+}
+
+/**
+ * Callback to allocate space for desktop widget.
+ */
+static void
+sp_desktop_widget_size_allocate (GtkWidget *widget, GtkAllocation *allocation)
+{
+ SPDesktopWidget *dtw = SP_DESKTOP_WIDGET (widget);
+ GtkAllocation widg_allocation;
+ gtk_widget_get_allocation(widget, &widg_allocation);
+
+ if ((allocation->x == widg_allocation.x) &&
+ (allocation->y == widg_allocation.y) &&
+ (allocation->width == widg_allocation.width) &&
+ (allocation->height == widg_allocation.height)) {
+ if (GTK_WIDGET_CLASS (dtw_parent_class)->size_allocate)
+ GTK_WIDGET_CLASS (dtw_parent_class)->size_allocate (widget, allocation);
+ return;
+ }
+
+ if (gtk_widget_get_realized (widget)) {
+ Geom::Rect const area = dtw->desktop->get_display_area();
+ Geom::Rect const d_canvas = dtw->desktop->getCanvas()->getViewbox();
+ Geom::Point midpoint = dtw->desktop->w2d(d_canvas.midpoint());
+
+ double zoom = dtw->desktop->current_zoom();
+
+ if (GTK_WIDGET_CLASS(dtw_parent_class)->size_allocate) {
+ GTK_WIDGET_CLASS(dtw_parent_class)->size_allocate (widget, allocation);
+ }
+
+ if (dtw->get_sticky_zoom_active()) {
+ /* Find new visible area */
+ Geom::Rect newarea = dtw->desktop->get_display_area();
+ /* Calculate adjusted zoom */
+ double oldshortside = MIN( area.width(), area.height());
+ double newshortside = MIN(newarea.width(), newarea.height());
+ zoom *= newshortside / oldshortside;
+ }
+ dtw->desktop->zoom_absolute_center_point (midpoint, zoom);
+
+ // TODO - Should call show_dialogs() from sp_namedview_window_from_document only.
+ // But delaying the call to here solves dock sizing issues on OS X, (see #171579)
+ dtw->desktop->show_dialogs();
+
+ } else {
+ if (GTK_WIDGET_CLASS (dtw_parent_class)->size_allocate) {
+ GTK_WIDGET_CLASS (dtw_parent_class)->size_allocate (widget, allocation);
+ }
+// this->size_allocate (widget, allocation);
+ }
+}
+
+#ifdef GDK_WINDOWING_QUARTZ
+static GtkMenuItem *_get_help_menu(GtkMenuShell *menu)
+{
+ // Assume "Help" is the last child in menu
+ GtkMenuItem *last = nullptr;
+ auto callback = [](GtkWidget *widget, gpointer data) {
+ *static_cast<GtkMenuItem **>(data) = GTK_MENU_ITEM(widget);
+ };
+ gtk_container_foreach(GTK_CONTAINER(menu), callback, &last);
+ return last;
+}
+#endif
+
+/**
+ * Callback to realize desktop widget.
+ */
+static void
+sp_desktop_widget_realize (GtkWidget *widget)
+{
+
+ SPDesktopWidget *dtw = SP_DESKTOP_WIDGET (widget);
+ Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+
+ if (GTK_WIDGET_CLASS (dtw_parent_class)->realize)
+ (* GTK_WIDGET_CLASS (dtw_parent_class)->realize) (widget);
+
+ Geom::Rect d = Geom::Rect::from_xywh(Geom::Point(0,0), (dtw->desktop->doc())->getDimensions());
+
+ if (d.width() < 1.0 || d.height() < 1.0) return;
+
+ dtw->desktop->set_display_area (d, 10);
+
+ dtw->updateNamedview();
+ gchar *gtkThemeName;
+ gboolean gtkApplicationPreferDarkTheme;
+ GtkSettings *settings = gtk_settings_get_default();
+ Gtk::Window *window = SP_ACTIVE_DESKTOP->getToplevel();
+ if (settings && window) {
+ g_object_get(settings, "gtk-theme-name", &gtkThemeName, NULL);
+ g_object_get(settings, "gtk-application-prefer-dark-theme", &gtkApplicationPreferDarkTheme, NULL);
+ bool dark = Glib::ustring(gtkThemeName).find(":dark") != std::string::npos;
+ if (!dark) {
+ Glib::RefPtr<Gtk::StyleContext> stylecontext = window->get_style_context();
+ Gdk::RGBA rgba;
+ bool background_set = stylecontext->lookup_color("theme_bg_color", rgba);
+ if (background_set && (0.299 * rgba.get_red() + 0.587 * rgba.get_green() + 0.114 * rgba.get_blue()) < 0.5) {
+ dark = true;
+ }
+ }
+ if (dark) {
+ window->get_style_context()->add_class("dark");
+ window->get_style_context()->remove_class("bright");
+ } else {
+ window->get_style_context()->add_class("bright");
+ window->get_style_context()->remove_class("dark");
+ }
+ if (prefs->getBool("/theme/symbolicIcons", false)) {
+ window->get_style_context()->add_class("symbolic");
+ window->get_style_context()->remove_class("regular");
+ } else {
+ window->get_style_context()->add_class("regular");
+ window->get_style_context()->remove_class("symbolic");
+ }
+ INKSCAPE.signal_change_theme.emit();
+ }
+
+#ifdef GDK_WINDOWING_QUARTZ
+ // native macOS menu
+ auto osxapp = gtkosx_application_get();
+ auto menushell = static_cast<Gtk::MenuShell *>(dtw->menubar());
+ if (osxapp && menushell && window) {
+ menushell->set_parent(*window);
+ gtkosx_application_set_menu_bar(osxapp, menushell->gobj());
+ // using quartz accelerators gives menu shortcuts priority over everything else,
+ // messes up text input because Inkscape has single key shortcuts (e.g. 1-6).
+ gtkosx_application_set_use_quartz_accelerators(osxapp, false);
+ gtkosx_application_set_help_menu(osxapp, _get_help_menu(menushell->gobj()));
+
+ // Window menu disabled because hidden windows which are brought back
+ // from the menu are non-functional.
+ // https://gitlab.com/inkscape/inkscape/-/issues/1105
+#if 0
+ gtkosx_application_set_window_menu(osxapp, nullptr);
+#endif
+
+ // move some items to "Inkscape" menu
+ unsigned app_menu_verbs[] = {
+ SP_VERB_NONE,
+ SP_VERB_DIALOG_INPUT,
+ SP_VERB_DIALOG_DISPLAY,
+ SP_VERB_NONE,
+ SP_VERB_HELP_ABOUT,
+ };
+ for (auto verb : app_menu_verbs) {
+ GtkWidget *menuitem = nullptr;
+ if (verb == SP_VERB_NONE) {
+ menuitem = gtk_separator_menu_item_new();
+ } else if (auto item = get_menu_item_for_verb(verb, dtw->desktop)) {
+ menuitem = static_cast<Gtk::Widget *>(item)->gobj();
+ } else {
+ continue;
+ }
+ // Don't use index 0 because it appends the app name. Index 1
+ // seems to work perfectly with inserting items in reverse order.
+ gtkosx_application_insert_app_menu_item(osxapp, menuitem, 1);
+ }
+ }
+#endif
+}
+
+/* This is just to provide access to common functionality from sp_desktop_widget_realize() above
+ as well as from SPDesktop::change_document() */
+void SPDesktopWidget::updateNamedview()
+{
+ // Listen on namedview modification
+ // originally (prior to the sigc++ conversion) the signal was simply
+ // connected twice rather than disconnecting the first connection
+ modified_connection.disconnect();
+
+ modified_connection = desktop->namedview->connectModified(sigc::mem_fun(*this, &SPDesktopWidget::namedviewModified));
+ namedviewModified(desktop->namedview, SP_OBJECT_MODIFIED_FLAG);
+
+ updateTitle( desktop->doc()->getDocumentName() );
+}
+
+/**
+ * Callback to handle desktop widget event.
+ */
+gint
+SPDesktopWidget::event(GtkWidget *widget, GdkEvent *event, SPDesktopWidget *dtw)
+{
+ if (event->type == GDK_BUTTON_PRESS) {
+ // defocus any spinbuttons
+ gtk_widget_grab_focus (GTK_WIDGET(dtw->_canvas));
+ }
+
+ if ((event->type == GDK_BUTTON_PRESS) && (event->button.button == 3)) {
+ if (event->button.state & GDK_SHIFT_MASK) {
+ sp_canvas_arena_set_sticky (SP_CANVAS_ARENA (dtw->desktop->drawing), TRUE);
+ } else {
+ sp_canvas_arena_set_sticky (SP_CANVAS_ARENA (dtw->desktop->drawing), FALSE);
+ }
+ }
+
+ if (GTK_WIDGET_CLASS (dtw_parent_class)->event) {
+ return (* GTK_WIDGET_CLASS (dtw_parent_class)->event) (widget, event);
+ } else {
+ // The key press/release events need to be passed to desktop handler explicitly,
+ // because otherwise the event contexts only receive key events when the mouse cursor
+ // is over the canvas. This redirection is only done for key events and only if there's no
+ // current item on the canvas, because item events and all mouse events are caught
+ // and passed on by the canvas acetate (I think). --bb
+
+ if ((event->type == GDK_KEY_PRESS || event->type == GDK_KEY_RELEASE)
+ && !dtw->_canvas->_current_item) {
+ return sp_desktop_root_handler (nullptr, event, dtw->desktop);
+ }
+ }
+
+ return FALSE;
+}
+
+#if defined(HAVE_LIBLCMS2)
+void
+SPDesktopWidget::color_profile_event(EgeColorProfTracker */*tracker*/, SPDesktopWidget *dtw)
+{
+ // Handle profile changes
+ GdkScreen* screen = gtk_widget_get_screen(GTK_WIDGET(dtw));
+ GdkWindow *window = gtk_widget_get_window(gtk_widget_get_toplevel(GTK_WIDGET(dtw)));
+
+ // Figure out the ID for the monitor
+ auto display = gdk_display_get_default();
+ auto monitor = gdk_display_get_monitor_at_window(display, window);
+
+ int n_monitors = gdk_display_get_n_monitors(display);
+
+ int monitorNum = -1;
+
+ // Now loop through the set of monitors and figure out whether this monitor matches
+ for (int i_monitor = 0; i_monitor < n_monitors; ++i_monitor) {
+ auto monitor_at_index = gdk_display_get_monitor(display, i_monitor);
+ if(monitor_at_index == monitor) monitorNum = i_monitor;
+ }
+
+ Glib::ustring id = Inkscape::CMSSystem::getDisplayId( monitorNum );
+ bool enabled = false;
+ dtw->_canvas->_cms_key = id;
+ dtw->requestCanvasUpdate();
+ enabled = !dtw->_canvas->_cms_key.empty();
+ dtw->cms_adjust_set_sensitive(enabled);
+}
+#else // defined(HAVE_LIBLCMS2)
+void sp_dtw_color_profile_event(EgeColorProfTracker */*tracker*/, SPDesktopWidget * /*dtw*/)
+{
+}
+#endif // defined(HAVE_LIBLCMS2)
+
+void
+SPDesktopWidget::update_guides_lock()
+{
+ bool down = _guides_lock->get_active();
+
+ auto doc = desktop->getDocument();
+ auto nv = desktop->getNamedView();
+ auto repr = nv->getRepr();
+
+ if ( down != nv->lockguides ) {
+ nv->lockguides = down;
+ sp_namedview_guides_toggle_lock(doc, nv);
+ if (down) {
+ setMessage (Inkscape::NORMAL_MESSAGE, _("Locked all guides"));
+ } else {
+ setMessage (Inkscape::NORMAL_MESSAGE, _("Unlocked all guides"));
+ }
+ }
+}
+
+#if defined(HAVE_LIBLCMS2)
+void
+SPDesktopWidget::cms_adjust_toggled( GtkWidget */*button*/, gpointer data )
+{
+ SPDesktopWidget *dtw = SP_DESKTOP_WIDGET(data);
+
+ bool down = dtw->_cms_adjust->get_active();
+ if ( down != dtw->_canvas->_enable_cms_display_adj ) {
+ dtw->_canvas->_enable_cms_display_adj = down;
+ dtw->desktop->redrawDesktop();
+ Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+ prefs->setBool("/options/displayprofile/enable", down);
+ if (down) {
+ dtw->setMessage (Inkscape::NORMAL_MESSAGE, _("Color-managed display is <b>enabled</b> in this window"));
+ } else {
+ dtw->setMessage (Inkscape::NORMAL_MESSAGE, _("Color-managed display is <b>disabled</b> in this window"));
+ }
+ }
+}
+#endif // defined(HAVE_LIBLCMS2)
+
+void
+SPDesktopWidget::cms_adjust_set_sensitive(bool enabled)
+{
+ Inkscape::Verb* verb = Inkscape::Verb::get( SP_VERB_VIEW_CMS_TOGGLE );
+ if ( verb ) {
+ SPAction *act = verb->get_action( Inkscape::ActionContext(viewwidget.view) );
+ if ( act ) {
+ sp_action_set_sensitive( act, enabled );
+ }
+ }
+ _cms_adjust->set_sensitive(enabled);
+}
+
+void
+sp_dtw_desktop_activate (SPDesktopWidget */*dtw*/)
+{
+ /* update active desktop indicator */
+}
+
+void
+sp_dtw_desktop_deactivate (SPDesktopWidget */*dtw*/)
+{
+ /* update inactive desktop indicator */
+}
+
+/**
+ * Shuts down the desktop object for the view being closed. It checks
+ * to see if the document has been edited, and if so prompts the user
+ * to save, discard, or cancel. Returns TRUE if the shutdown operation
+ * is cancelled or if the save is cancelled or fails, FALSE otherwise.
+ */
+bool
+SPDesktopWidget::shutdown()
+{
+ g_assert(desktop != nullptr);
+
+ if (INKSCAPE.sole_desktop_for_document(*desktop)) {
+ SPDocument *doc = desktop->doc();
+ if (doc->isModifiedSinceSave()) {
+ Gtk::Window *toplevel_window = Glib::wrap(GTK_WINDOW(gtk_widget_get_toplevel(GTK_WIDGET(this))));
+ Glib::ustring message = g_markup_printf_escaped(
+ _("<span weight=\"bold\" size=\"larger\">Save changes to document \"%s\" before closing?</span>\n\n"
+ "If you close without saving, your changes will be discarded."),
+ doc->getDocumentName());
+ Gtk::MessageDialog dialog = Gtk::MessageDialog(*toplevel_window, message, true, Gtk::MESSAGE_WARNING, Gtk::BUTTONS_NONE);
+ dialog.property_destroy_with_parent() = true;
+
+ // fix for bug lp:168809
+ Gtk::Container *ma = dialog.get_message_area();
+ std::vector<Gtk::Widget*> ma_labels = ma->get_children();
+ ma_labels[0]->set_can_focus(false);
+
+ Gtk::Button close_button(_("Close _without saving"), true);
+ close_button.show();
+ dialog.add_action_widget(close_button, Gtk::RESPONSE_NO);
+
+ dialog.add_button(_("_Cancel"), Gtk::RESPONSE_CANCEL);
+ dialog.add_button(_("_Save"), Gtk::RESPONSE_YES);
+ dialog.set_default_response(Gtk::RESPONSE_YES);
+
+ gint response = dialog.run();
+
+ switch (response) {
+ case GTK_RESPONSE_YES:
+ {
+ doc->doRef();
+ sp_namedview_document_from_window(desktop);
+ if (sp_file_save_document(*window, doc)) {
+ doc->doUnref();
+ } else { // save dialog cancelled or save failed
+ doc->doUnref();
+ return TRUE;
+ }
+
+ break;
+ }
+ case GTK_RESPONSE_NO:
+ break;
+ default: // cancel pressed, or dialog was closed
+ return TRUE;
+ break;
+ }
+ }
+ /* Code to check data loss */
+ bool allow_data_loss = FALSE;
+ while (doc->getReprRoot()->attribute("inkscape:dataloss") != nullptr && allow_data_loss == FALSE) {
+ Gtk::Window *toplevel_window = Glib::wrap(GTK_WINDOW(gtk_widget_get_toplevel(GTK_WIDGET(this))));
+ Glib::ustring message = g_markup_printf_escaped(
+ _("<span weight=\"bold\" size=\"larger\">The file \"%s\" was saved with a format that may cause data loss!</span>\n\n"
+ "Do you want to save this file as Inkscape SVG?"),
+ doc->getDocumentName() ? doc->getDocumentName() : "Unnamed");
+ Gtk::MessageDialog dialog = Gtk::MessageDialog(*toplevel_window, message, true, Gtk::MESSAGE_WARNING, Gtk::BUTTONS_NONE);
+ dialog.property_destroy_with_parent() = true;
+
+ // fix for bug lp:168809
+ Gtk::Container *ma = dialog.get_message_area();
+ std::vector<Gtk::Widget*> ma_labels = ma->get_children();
+ ma_labels[0]->set_can_focus(false);
+
+ Gtk::Button close_button(_("Close _without saving"), true);
+ close_button.show();
+ dialog.add_action_widget(close_button, Gtk::RESPONSE_NO);
+
+ dialog.add_button(_("_Cancel"), Gtk::RESPONSE_CANCEL);
+
+ Gtk::Button save_button(_("_Save as Inkscape SVG"), true);
+ save_button.set_can_default(true);
+ save_button.show();
+ dialog.add_action_widget(save_button, Gtk::RESPONSE_YES);
+ dialog.set_default_response(Gtk::RESPONSE_YES);
+
+ gint response = dialog.run();
+
+ switch (response) {
+ case GTK_RESPONSE_YES:
+ {
+ doc->doRef();
+
+ if (sp_file_save_dialog(*window, doc, Inkscape::Extension::FILE_SAVE_METHOD_INKSCAPE_SVG)) {
+ doc->doUnref();
+ } else { // save dialog cancelled or save failed
+ doc->doUnref();
+ return TRUE;
+ }
+
+ break;
+ }
+ case GTK_RESPONSE_NO:
+ allow_data_loss = TRUE;
+ break;
+ default: // cancel pressed, or dialog was closed
+ return TRUE;
+ break;
+ }
+ }
+ }
+
+ /* Save window geometry to prefs for use as a default.
+ * Use depends on setting of "options.savewindowgeometry".
+ * But we save the info here regardless of the setting.
+ */
+ storeDesktopPosition();
+
+ return FALSE;
+}
+
+/**
+ * \store dessktop position
+ */
+void SPDesktopWidget::storeDesktopPosition()
+{
+ Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+ bool maxed = desktop->is_maximized();
+ bool full = desktop->is_fullscreen();
+ prefs->setBool("/desktop/geometry/fullscreen", full);
+ prefs->setBool("/desktop/geometry/maximized", maxed);
+ gint w, h, x, y;
+ desktop->getWindowGeometry(x, y, w, h);
+ // Don't save geom for maximized windows. It
+ // just tells you the current maximized size, which is not
+ // as useful as whatever value it had previously.
+ if (!maxed && !full) {
+ prefs->setInt("/desktop/geometry/width", w);
+ prefs->setInt("/desktop/geometry/height", h);
+ prefs->setInt("/desktop/geometry/x", x);
+ prefs->setInt("/desktop/geometry/y", y);
+ }
+}
+
+/**
+ * \pre this->desktop->main != 0
+ */
+void
+SPDesktopWidget::requestCanvasUpdate() {
+ // ^^ also this->desktop != 0
+ g_return_if_fail(this->desktop != nullptr);
+ g_return_if_fail(this->desktop->main != nullptr);
+ gtk_widget_queue_draw (GTK_WIDGET (SP_CANVAS_ITEM (this->desktop->main)->canvas));
+}
+
+void
+SPDesktopWidget::requestCanvasUpdateAndWait() {
+ requestCanvasUpdate();
+
+ while (gtk_events_pending())
+ gtk_main_iteration_do(FALSE);
+
+}
+
+void
+SPDesktopWidget::enableInteraction()
+{
+ g_return_if_fail(_interaction_disabled_counter > 0);
+
+ _interaction_disabled_counter--;
+
+ if (_interaction_disabled_counter == 0) {
+ gtk_widget_set_sensitive(GTK_WIDGET(this), TRUE);
+ }
+}
+
+void
+SPDesktopWidget::disableInteraction()
+{
+ if (_interaction_disabled_counter == 0) {
+ gtk_widget_set_sensitive(GTK_WIDGET(this), FALSE);
+ }
+
+ _interaction_disabled_counter++;
+}
+
+void
+SPDesktopWidget::setCoordinateStatus(Geom::Point p)
+{
+ gchar *cstr;
+ cstr = g_strdup_printf("%7.2f", _dt2r * p[Geom::X]);
+ _coord_status_x->set_markup(cstr);
+ g_free(cstr);
+
+ cstr = g_strdup_printf("%7.2f", _dt2r * p[Geom::Y]);
+ _coord_status_y->set_markup(cstr);
+ g_free(cstr);
+}
+
+void
+SPDesktopWidget::letZoomGrabFocus()
+{
+ if (_zoom_status) _zoom_status->grab_focus();
+}
+
+void
+SPDesktopWidget::getWindowGeometry (gint &x, gint &y, gint &w, gint &h)
+{
+ if (window)
+ {
+ window->get_size (w, h);
+ window->get_position (x, y);
+ }
+}
+
+void
+SPDesktopWidget::setWindowPosition (Geom::Point p)
+{
+ if (window)
+ {
+ window->move (gint(round(p[Geom::X])), gint(round(p[Geom::Y])));
+ }
+}
+
+void
+SPDesktopWidget::setWindowSize (gint w, gint h)
+{
+ if (window)
+ {
+ window->set_default_size (w, h);
+ window->resize (w, h);
+ }
+}
+
+#ifdef __APPLE__
+/**
+ * This should be a no-op, but on macOS it raises the given transient window to the
+ * top of other transient windows from the same parent.
+ */
+static gboolean transient_focus_in_callback(GtkWindow *window, GdkEvent *, gpointer)
+{
+ gtk_window_set_transient_for(window, gtk_window_get_transient_for(window));
+ return FALSE;
+}
+#endif
+
+/**
+ * \note transientizing does not work on windows; when you minimize a document
+ * and then open it back, only its transient emerges and you cannot access
+ * the document window. The document window must be restored by rightclicking
+ * the taskbar button and pressing "Restore"
+ */
+void
+SPDesktopWidget::setWindowTransient (void *p, int transient_policy)
+{
+ if (window)
+ {
+ GtkWindow *w = GTK_WINDOW(window->gobj());
+
+#ifdef __APPLE__
+ // Workaround for https://gitlab.gnome.org/GNOME/gtk/issues/2436
+ // The first time this window is made transient, connect the focus-in event to
+ // re-transientize the window in order to raise it above other transient windows.
+ if (gtk_window_get_transient_for(GTK_WINDOW(p)) == nullptr) {
+ g_signal_connect(GTK_WIDGET(p), "focus-in-event", G_CALLBACK(transient_focus_in_callback), nullptr);
+ }
+#endif
+
+ gtk_window_set_transient_for (GTK_WINDOW(p), w);
+
+ /*
+ * This enables "aggressive" transientization,
+ * i.e. dialogs always emerging on top when you switch documents. Note
+ * however that this breaks "click to raise" policy of a window
+ * manager because the switched-to document will be raised at once
+ * (so that its transients also could raise)
+ */
+ if (transient_policy == 2)
+ // without this, a transient window not always emerges on top
+ gtk_window_present (w);
+ }
+}
+
+void
+SPDesktopWidget::presentWindow()
+{
+ GtkWindow *w =GTK_WINDOW(gtk_widget_get_toplevel(GTK_WIDGET(this)));
+ if (w)
+ gtk_window_present (w);
+}
+
+bool SPDesktopWidget::showInfoDialog( Glib::ustring const &message )
+{
+ bool result = false;
+ Gtk::Window *window = Glib::wrap(GTK_WINDOW(gtk_widget_get_toplevel(GTK_WIDGET(this))));
+ if (window)
+ {
+ Gtk::MessageDialog dialog(*window, message, false, Gtk::MESSAGE_INFO, Gtk::BUTTONS_OK);
+ dialog.property_destroy_with_parent() = true;
+ dialog.set_name("InfoDialog");
+ dialog.set_title(_("Note:")); // probably want to take this as a parameter.
+ dialog.run();
+ }
+ return result;
+}
+
+bool SPDesktopWidget::warnDialog (Glib::ustring const &text)
+{
+ Gtk::MessageDialog dialog (*window, text, false, Gtk::MESSAGE_WARNING, Gtk::BUTTONS_OK_CANCEL);
+ gint response = dialog.run();
+ if (response == Gtk::RESPONSE_OK)
+ return true;
+ else
+ return false;
+}
+
+void
+SPDesktopWidget::iconify()
+{
+ GtkWindow *topw = GTK_WINDOW(gtk_widget_get_toplevel(GTK_WIDGET(_canvas)));
+ if (GTK_IS_WINDOW(topw)) {
+ if (desktop->is_iconified()) {
+ gtk_window_deiconify(topw);
+ } else {
+ gtk_window_iconify(topw);
+ }
+ }
+}
+
+void
+SPDesktopWidget::maximize()
+{
+ GtkWindow *topw = GTK_WINDOW(gtk_widget_get_toplevel(GTK_WIDGET(_canvas)));
+ if (GTK_IS_WINDOW(topw)) {
+ if (desktop->is_maximized()) {
+ gtk_window_unmaximize(topw);
+ } else {
+ // Save geometry to prefs before maximizing so that
+ // something useful is stored there, because GTK doesn't maintain
+ // a separate non-maximized size.
+ if (!desktop->is_iconified() && !desktop->is_fullscreen())
+ {
+ Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+ gint w = -1;
+ gint h, x, y;
+ getWindowGeometry(x, y, w, h);
+ g_assert(w != -1);
+ prefs->setInt("/desktop/geometry/width", w);
+ prefs->setInt("/desktop/geometry/height", h);
+ prefs->setInt("/desktop/geometry/x", x);
+ prefs->setInt("/desktop/geometry/y", y);
+ }
+ gtk_window_maximize(topw);
+ }
+ }
+}
+
+void
+SPDesktopWidget::fullscreen()
+{
+ GtkWindow *topw = GTK_WINDOW(gtk_widget_get_toplevel(GTK_WIDGET(_canvas)));
+ if (GTK_IS_WINDOW(topw)) {
+ if (desktop->is_fullscreen()) {
+ gtk_window_unfullscreen(topw);
+ // widget layout is triggered by the resulting window_state_event
+ } else {
+ // Save geometry to prefs before maximizing so that
+ // something useful is stored there, because GTK doesn't maintain
+ // a separate non-maximized size.
+ if (!desktop->is_iconified() && !desktop->is_maximized())
+ {
+ Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+ gint w, h, x, y;
+ getWindowGeometry(x, y, w, h);
+ prefs->setInt("/desktop/geometry/width", w);
+ prefs->setInt("/desktop/geometry/height", h);
+ prefs->setInt("/desktop/geometry/x", x);
+ prefs->setInt("/desktop/geometry/y", y);
+ }
+ gtk_window_fullscreen(topw);
+ // widget layout is triggered by the resulting window_state_event
+ }
+ }
+}
+
+/**
+ * Hide whatever the user does not want to see in the window
+ */
+void SPDesktopWidget::layoutWidgets()
+{
+ SPDesktopWidget *dtw = this;
+ Glib::ustring pref_root;
+ Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+
+ if (dtw->desktop->is_focusMode()) {
+ pref_root = "/focus/";
+ } else if (dtw->desktop->is_fullscreen()) {
+ pref_root = "/fullscreen/";
+ } else {
+ pref_root = "/window/";
+ }
+
+ if (!prefs->getBool(pref_root + "commands/state", true)) {
+ gtk_widget_hide (dtw->commands_toolbox);
+ } else {
+ gtk_widget_show_all (dtw->commands_toolbox);
+ }
+
+ if (!prefs->getBool(pref_root + "snaptoolbox/state", true)) {
+ gtk_widget_hide (dtw->snap_toolbox);
+ } else {
+ gtk_widget_show_all (dtw->snap_toolbox);
+ }
+
+ if (!prefs->getBool(pref_root + "toppanel/state", true)) {
+ gtk_widget_hide (dtw->aux_toolbox);
+ } else {
+ // we cannot just show_all because that will show all tools' panels;
+ // this is a function from toolbox.cpp that shows only the current tool's panel
+ ToolboxFactory::showAuxToolbox(dtw->aux_toolbox);
+ }
+
+ if (!prefs->getBool(pref_root + "toolbox/state", true)) {
+ gtk_widget_hide (dtw->tool_toolbox);
+ } else {
+ gtk_widget_show_all (dtw->tool_toolbox);
+ }
+
+ if (!prefs->getBool(pref_root + "statusbar/state", true)) {
+ dtw->_statusbar->hide();
+ } else {
+ dtw->_statusbar->show_all();
+ }
+
+ if (!prefs->getBool(pref_root + "panels/state", true)) {
+ dtw->_panels->hide();
+ } else {
+ dtw->_panels->show_all();
+ }
+
+ if (!prefs->getBool(pref_root + "scrollbars/state", true)) {
+ dtw->_hscrollbar->hide();
+ dtw->_vscrollbar_box->hide();
+ dtw->_cms_adjust->hide();
+ } else {
+ dtw->_hscrollbar->show_all();
+ dtw->_vscrollbar_box->show_all();
+ dtw->_cms_adjust->show_all();
+ }
+
+ if (!prefs->getBool(pref_root + "rulers/state", true)) {
+ dtw->_guides_lock->hide();
+ dtw->_hruler->hide();
+ dtw->_vruler->hide();
+ } else {
+ dtw->_guides_lock->show_all();
+ dtw->_hruler->show_all();
+ dtw->_vruler->show_all();
+ }
+}
+
+Gtk::Toolbar *
+SPDesktopWidget::get_toolbar_by_name(const Glib::ustring& name)
+{
+ // The name is actually attached to the GtkGrid that contains
+ // the toolbar, so we need to get the grid first
+ auto widget = sp_search_by_name_recursive(Glib::wrap(aux_toolbox), name);
+ auto grid = dynamic_cast<Gtk::Grid*>(widget);
+
+ if (!grid) return nullptr;
+
+ auto child = grid->get_child_at(0,0);
+ auto tb = dynamic_cast<Gtk::Toolbar*>(child);
+
+ return tb;
+}
+
+void
+SPDesktopWidget::setToolboxFocusTo (const gchar* label)
+{
+ // First try looking for a named widget
+ auto hb = sp_search_by_name_recursive(Glib::wrap(aux_toolbox), label);
+
+ // Fallback to looking for a named data member (deprecated)
+ if (!hb) {
+ hb = Glib::wrap(GTK_WIDGET(sp_search_by_data_recursive(aux_toolbox, (gpointer) label)));
+ }
+
+ if (hb)
+ {
+ hb->grab_focus();
+ }
+}
+
+void
+SPDesktopWidget::setToolboxAdjustmentValue (gchar const *id, double value)
+{
+ // First try looking for a named widget
+ auto hb = sp_search_by_name_recursive(Glib::wrap(aux_toolbox), id);
+
+ // Fallback to looking for a named data member (deprecated)
+ if (!hb) {
+ hb = Glib::wrap(GTK_WIDGET(sp_search_by_data_recursive(aux_toolbox, (gpointer)id)));
+ }
+
+ if (hb) {
+ auto sb = dynamic_cast<Inkscape::UI::Widget::SpinButtonToolItem *>(hb);
+ auto a = sb->get_adjustment();
+
+ if(a) a->set_value(value);
+ }
+
+ else g_warning ("Could not find GtkAdjustment for %s\n", id);
+}
+
+
+bool
+SPDesktopWidget::isToolboxButtonActive (const gchar* id)
+{
+ bool isActive = false;
+ gpointer thing = sp_search_by_data_recursive(aux_toolbox, (gpointer) id);
+ if ( !thing ) {
+ //g_message( "Unable to locate item for {%s}", id );
+ } else if ( GTK_IS_TOGGLE_BUTTON(thing) ) {
+ GtkToggleButton *b = GTK_TOGGLE_BUTTON(thing);
+ isActive = gtk_toggle_button_get_active( b ) != 0;
+ } else if ( GTK_IS_TOGGLE_ACTION(thing) ) {
+ GtkToggleAction* act = GTK_TOGGLE_ACTION(thing);
+ isActive = gtk_toggle_action_get_active( act ) != 0;
+ } else if ( GTK_IS_TOGGLE_TOOL_BUTTON(thing) ) {
+ GtkToggleToolButton *b = GTK_TOGGLE_TOOL_BUTTON(thing);
+ isActive = gtk_toggle_tool_button_get_active( b ) != 0;
+ } else {
+ //g_message( "Item for {%s} is of an unsupported type", id );
+ }
+
+ return isActive;
+}
+
+void SPDesktopWidget::setToolboxPosition(Glib::ustring const& id, GtkPositionType pos)
+{
+ // Note - later on these won't be individual member variables.
+ GtkWidget* toolbox = nullptr;
+ if (id == "ToolToolbar") {
+ toolbox = tool_toolbox;
+ } else if (id == "AuxToolbar") {
+ toolbox = aux_toolbox;
+ } else if (id == "CommandsToolbar") {
+ toolbox = commands_toolbox;
+ } else if (id == "SnapToolbar") {
+ toolbox = snap_toolbox;
+ }
+
+
+ if (toolbox) {
+ switch(pos) {
+ case GTK_POS_TOP:
+ case GTK_POS_BOTTOM:
+ if ( gtk_widget_is_ancestor(toolbox, GTK_WIDGET(_hbox->gobj())) ) {
+ // Removing a widget can reduce ref count to zero
+ g_object_ref(G_OBJECT(toolbox));
+ _hbox->remove(*Glib::wrap(toolbox));
+ _vbox->add(*Glib::wrap(toolbox));
+ g_object_unref(G_OBJECT(toolbox));
+
+ // Function doesn't seem to be in Gtkmm wrapper yet
+ gtk_box_set_child_packing(_vbox->gobj(), toolbox, FALSE, TRUE, 0, GTK_PACK_START);
+ }
+ ToolboxFactory::setOrientation(toolbox, GTK_ORIENTATION_HORIZONTAL);
+ break;
+ case GTK_POS_LEFT:
+ case GTK_POS_RIGHT:
+ if ( !gtk_widget_is_ancestor(toolbox, GTK_WIDGET(_hbox->gobj())) ) {
+ g_object_ref(G_OBJECT(toolbox));
+ _vbox->remove(*Glib::wrap(toolbox));
+ _hbox->add(*Glib::wrap(toolbox));
+ g_object_unref(G_OBJECT(toolbox));
+
+ // Function doesn't seem to be in Gtkmm wrapper yet
+ gtk_box_set_child_packing(_hbox->gobj(), toolbox, FALSE, TRUE, 0, GTK_PACK_START);
+ if (pos == GTK_POS_LEFT) {
+ _hbox->reorder_child(*Glib::wrap(toolbox), 0 );
+ }
+ }
+ ToolboxFactory::setOrientation(toolbox, GTK_ORIENTATION_VERTICAL);
+ break;
+ }
+ }
+}
+
+
+SPDesktopWidget *sp_desktop_widget_new(SPDocument *document)
+{
+ SPDesktopWidget* dtw = SPDesktopWidget::createInstance(document);
+ return dtw;
+}
+
+SPDesktopWidget* SPDesktopWidget::createInstance(SPDocument *document)
+{
+ SPDesktopWidget *dtw = static_cast<SPDesktopWidget*>(g_object_new(SP_TYPE_DESKTOP_WIDGET, nullptr));
+
+ SPNamedView *namedview = sp_document_namedview(document, nullptr);
+
+ dtw->_dt2r = 1. / namedview->display_units->factor;
+
+ dtw->_ruler_origin = Geom::Point(0,0); //namedview->gridorigin; Why was the grid origin used here?
+
+ dtw->desktop = new SPDesktop();
+ dtw->stub = new SPDesktopWidget::WidgetStub (dtw);
+ dtw->desktop->init (namedview, dtw->_canvas, dtw->stub);
+ INKSCAPE.add_desktop (dtw->desktop);
+
+ // Add the shape geometry to libavoid for autorouting connectors.
+ // This needs desktop set for its spacing preferences.
+ init_avoided_shape_geometry(dtw->desktop);
+
+ dtw->_selected_style->setDesktop(dtw->desktop);
+
+ /* Once desktop is set, we can update rulers */
+ dtw->update_rulers();
+
+ sp_view_widget_set_view (SP_VIEW_WIDGET (dtw), dtw->desktop);
+
+ /* Listen on namedview modification */
+ dtw->modified_connection = namedview->connectModified(sigc::mem_fun(*dtw, &SPDesktopWidget::namedviewModified));
+
+ dtw->layer_selector->setDesktop(dtw->desktop);
+
+ // TEMP
+ dtw->_menubar = build_menubar(dtw->desktop);
+ dtw->_menubar->set_name("MenuBar");
+ dtw->_menubar->show_all();
+
+#ifdef GDK_WINDOWING_QUARTZ
+ // native macOS menu: do this later because we don't have the window handle yet
+#else
+ dtw->_vbox->pack_start(*dtw->_menubar, false, false);
+#endif
+
+ dtw->layoutWidgets();
+
+ std::vector<GtkWidget *> toolboxes;
+ toolboxes.push_back(dtw->tool_toolbox);
+ toolboxes.push_back(dtw->aux_toolbox);
+ toolboxes.push_back(dtw->commands_toolbox);
+ toolboxes.push_back(dtw->snap_toolbox);
+
+ dtw->_panels->setDesktop( dtw->desktop );
+
+ UXManager::getInstance()->addTrack(dtw);
+ UXManager::getInstance()->connectToDesktop( toolboxes, dtw->desktop );
+
+ return dtw;
+}
+
+
+void
+SPDesktopWidget::update_rulers()
+{
+ Geom::Rect viewbox = desktop->get_display_area(true);
+ // "true" means: Use integer values of the canvas for calculating the display area, similar
+ // to the integer values used for positioning the grid lines. (see SPCanvas::scrollTo(),
+ // where ix and iy are rounded integer values; these values are stored in SPCanvasBuf->rect,
+ // and used for drawing the grid). By using the integer values here too, the ruler ticks
+ // will be perfectly aligned to the grid
+
+ double lower_x = _dt2r * (viewbox.left() - _ruler_origin[Geom::X]);
+ double upper_x = _dt2r * (viewbox.right() - _ruler_origin[Geom::X]);
+ _hruler->set_range(lower_x, upper_x);
+
+ double lower_y = _dt2r * (viewbox.bottom() - _ruler_origin[Geom::Y]);
+ double upper_y = _dt2r * (viewbox.top() - _ruler_origin[Geom::Y]);
+ if (desktop->is_yaxisdown()) {
+ std::swap(lower_y, upper_y);
+ }
+ _vruler->set_range(lower_y, upper_y);
+}
+
+
+void SPDesktopWidget::namedviewModified(SPObject *obj, guint flags)
+{
+ SPNamedView *nv=SP_NAMEDVIEW(obj);
+
+ if (flags & SP_OBJECT_MODIFIED_FLAG) {
+ _dt2r = 1. / nv->display_units->factor;
+ _ruler_origin = Geom::Point(0,0); //nv->gridorigin; Why was the grid origin used here?
+
+ _vruler->set_unit(nv->getDisplayUnit());
+ _hruler->set_unit(nv->getDisplayUnit());
+
+ /* 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
+ * all toolboxes to refer to the unit selector). The default document units
+ * is then selected within these unit selectors.
+ *
+ * Of course it would be nice to be able to refer to the toolbox and the
+ * unit selector directly by name, but I don't yet see a way to do that.
+ *
+ * This should solve: https://bugs.launchpad.net/inkscape/+bug/362995
+ */
+ if (GTK_IS_CONTAINER(aux_toolbox)) {
+ std::vector<Gtk::Widget*> ch = Glib::wrap(GTK_CONTAINER(aux_toolbox))->get_children();
+ for (auto i:ch) {
+ if (GTK_IS_CONTAINER(i->gobj())) {
+ std::vector<Gtk::Widget*> grch = dynamic_cast<Gtk::Container*>(i)->get_children();
+ for (auto j:grch) {
+
+ if (!GTK_IS_WIDGET(j->gobj())) // wasn't a widget
+ continue;
+
+ // Don't apply to text toolbar. We want to be able to
+ // use different units for text. (Bug 1562217)
+ const Glib::ustring name = j->get_name();
+ if ( name == "TextToolbar" || name == "MeasureToolbar")
+ continue;
+
+ gpointer t = sp_search_by_data_recursive(GTK_WIDGET(j->gobj()), (gpointer) "unit-tracker");
+ if (t == nullptr) // didn't find any tracker data
+ continue;
+
+ UnitTracker *tracker = reinterpret_cast<UnitTracker*>( t );
+ if (tracker == nullptr) // it's null when inkscape is first opened
+ continue;
+
+ tracker->setActiveUnit( nv->display_units );
+ } // grandchildren
+ } // if child is a container
+ } // children
+ } // if aux_toolbox is a container
+
+ _hruler_box->set_tooltip_text(gettext(nv->display_units->name_plural.c_str()));
+ _vruler_box->set_tooltip_text(gettext(nv->display_units->name_plural.c_str()));
+
+ update_rulers();
+ ToolboxFactory::updateSnapToolbox(this->desktop, nullptr, this->snap_toolbox);
+ }
+}
+
+void
+SPDesktopWidget::on_adjustment_value_changed()
+{
+ if (update)
+ return;
+
+ update = 1;
+
+ // Do not call canvas->scrollTo directly... messes up 'offset'.
+ desktop->scroll_absolute( Geom::Point(_hadj->get_value(),
+ _vadj->get_value()), false);
+
+ update = 0;
+}
+
+/* we make the desktop window with focus active, signal is connected in interface.c */
+bool SPDesktopWidget::onFocusInEvent(GdkEventFocus*)
+{
+ Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+ if (prefs->getBool("/options/bitmapautoreload/value", true)) {
+ std::vector<SPObject *> imageList = (desktop->doc())->getResourceList("image");
+ for (auto it : imageList) {
+ SPImage* image = SP_IMAGE(it);
+ image->refresh_if_outdated();
+ }
+ }
+
+ INKSCAPE.activate_desktop (desktop);
+
+ return false;
+}
+
+// ------------------------ Zoom ------------------------
+static gdouble
+sp_dtw_zoom_value_to_display (gdouble value)
+{
+ return floor (10 * (pow (2, value) * 100.0 + 0.05)) / 10;
+}
+
+static gdouble
+sp_dtw_zoom_display_to_value (gdouble value)
+{
+ return log (value / 100.0) / log (2);
+}
+
+int
+SPDesktopWidget::zoom_input(double *new_val)
+{
+ gchar *b = g_strdup(_zoom_status->get_text().c_str());
+
+ gchar *comma = g_strstr_len (b, -1, ",");
+ if (comma) {
+ *comma = '.';
+ }
+
+ char *oldlocale = g_strdup (setlocale(LC_NUMERIC, nullptr));
+ setlocale (LC_NUMERIC, "C");
+ gdouble new_typed = atof (b);
+ setlocale (LC_NUMERIC, oldlocale);
+ g_free (oldlocale);
+ g_free (b);
+
+ *new_val = sp_dtw_zoom_display_to_value (new_typed);
+ return TRUE;
+}
+
+bool
+SPDesktopWidget::zoom_output()
+{
+ gchar b[64];
+ double val = sp_dtw_zoom_value_to_display (_zoom_status->get_value());
+ if (val < 10) {
+ g_snprintf (b, 64, "%4.1f%%", val);
+ } else {
+ g_snprintf (b, 64, "%4.0f%%", val);
+ }
+ _zoom_status->set_text(b);
+ return true;
+}
+
+void
+SPDesktopWidget::zoom_value_changed()
+{
+ double const zoom_factor = pow (2, _zoom_status->get_value());
+
+ // Zoom around center of window
+ Geom::Rect const d_canvas = desktop->getCanvas()->getViewbox();
+ Geom::Point midpoint = desktop->w2d(d_canvas.midpoint());
+ _zoom_status_value_changed_connection.block();
+ desktop->zoom_absolute_center_point (midpoint, zoom_factor);
+ _zoom_status_value_changed_connection.unblock();
+
+ spinbutton_defocus(GTK_WIDGET(_zoom_status->gobj()));
+}
+
+void
+SPDesktopWidget::zoom_menu_handler(double factor)
+{
+ Geom::Rect const d = desktop->get_display_area();
+ desktop->zoom_absolute_center_point (d.midpoint(), factor);
+}
+
+void
+SPDesktopWidget::zoom_populate_popup(Gtk::Menu *menu)
+{
+ for ( auto iter : menu->get_children()) {
+ menu->remove(*iter);
+ }
+
+ auto item_1000 = Gtk::manage(new Gtk::MenuItem("1000%"));
+ auto item_500 = Gtk::manage(new Gtk::MenuItem("500%"));
+ auto item_200 = Gtk::manage(new Gtk::MenuItem("200%"));
+ auto item_100 = Gtk::manage(new Gtk::MenuItem("100%"));
+ auto item_50 = Gtk::manage(new Gtk::MenuItem( "50%"));
+ auto item_25 = Gtk::manage(new Gtk::MenuItem( "25%"));
+ auto item_10 = Gtk::manage(new Gtk::MenuItem( "10%"));
+
+ item_1000->signal_activate().connect(sigc::bind(sigc::mem_fun(this, &SPDesktopWidget::zoom_menu_handler), 10.00));
+ item_500->signal_activate().connect( sigc::bind(sigc::mem_fun(this, &SPDesktopWidget::zoom_menu_handler), 5.00));
+ item_200->signal_activate().connect( sigc::bind(sigc::mem_fun(this, &SPDesktopWidget::zoom_menu_handler), 2.00));
+ item_100->signal_activate().connect( sigc::bind(sigc::mem_fun(this, &SPDesktopWidget::zoom_menu_handler), 1.00));
+ item_50->signal_activate().connect( sigc::bind(sigc::mem_fun(this, &SPDesktopWidget::zoom_menu_handler), 0.50));
+ item_25->signal_activate().connect( sigc::bind(sigc::mem_fun(this, &SPDesktopWidget::zoom_menu_handler), 0.25));
+ item_10->signal_activate().connect( sigc::bind(sigc::mem_fun(this, &SPDesktopWidget::zoom_menu_handler), 0.10));
+
+ menu->append(*item_1000);
+ menu->append(*item_500);
+ menu->append(*item_200);
+ menu->append(*item_100);
+ menu->append(*item_50);
+ menu->append(*item_25);
+ menu->append(*item_10);
+
+ auto sep = Gtk::manage(new Gtk::SeparatorMenuItem());
+ menu->append(*sep);
+
+ auto item_page = Gtk::manage(new Gtk::MenuItem(_("Page")));
+ item_page->signal_activate().connect(sigc::mem_fun(desktop, &SPDesktop::zoom_page));
+ menu->append(*item_page);
+
+ auto item_drawing = Gtk::manage(new Gtk::MenuItem(_("Drawing")));
+ item_drawing->signal_activate().connect(sigc::mem_fun(desktop, &SPDesktop::zoom_drawing));
+ menu->append(*item_drawing);
+
+ auto item_selection = Gtk::manage(new Gtk::MenuItem(_("Selection")));
+ item_selection->signal_activate().connect(sigc::mem_fun(desktop, &SPDesktop::zoom_selection));
+ menu->append(*item_selection);
+
+ auto item_center_page = Gtk::manage(new Gtk::MenuItem(_("Centre Page")));
+ item_center_page->signal_activate().connect(sigc::mem_fun(desktop, &SPDesktop::zoom_center_page));
+ menu->append(*item_center_page);
+
+ menu->show_all();
+}
+
+
+void
+SPDesktopWidget::sticky_zoom_toggled()
+{
+ Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+ prefs->setBool("/options/stickyzoom/value", _sticky_zoom->get_active());
+}
+
+
+void
+SPDesktopWidget::update_zoom()
+{
+ _zoom_status_value_changed_connection.block();
+ _zoom_status->set_value(log(desktop->current_zoom()) / log(2));
+ _zoom_status->queue_draw();
+ _zoom_status_value_changed_connection.unblock();
+}
+
+
+// ---------------------- Rotation ------------------------
+int
+SPDesktopWidget::rotation_input(double *new_val)
+{
+ auto *b = g_strdup(_rotation_status->get_text().c_str());
+
+ gchar *comma = g_strstr_len (b, -1, ",");
+ if (comma) {
+ *comma = '.';
+ }
+
+ char *oldlocale = g_strdup (setlocale(LC_NUMERIC, nullptr));
+ setlocale (LC_NUMERIC, "C");
+ gdouble new_value = atof (b);
+ setlocale (LC_NUMERIC, oldlocale);
+ g_free (oldlocale);
+ g_free (b);
+
+ *new_val = new_value;
+ return true;
+}
+
+bool
+SPDesktopWidget::rotation_output()
+{
+ gchar b[64];
+ double val = _rotation_status->get_value();
+
+ if (val < -180) val += 360;
+ if (val > 180) val -= 360;
+
+ g_snprintf (b, 64, "%7.2f°", val);
+
+ _rotation_status->set_text(b);
+ return true;
+}
+
+void
+SPDesktopWidget::rotation_value_changed()
+{
+ double const rotate_factor = M_PI / 180.0 * _rotation_status->get_value();
+ // std::cout << "SPDesktopWidget::rotation_value_changed: "
+ // << _rotation_status->get_value()
+ // << " (" << rotate_factor << ")" <<std::endl;
+
+ // Rotate around center of window
+ Geom::Rect const d_canvas = desktop->getCanvas()->getViewbox();
+ _rotation_status_value_changed_connection.block();
+ Geom::Point midpoint = desktop->w2d(d_canvas.midpoint());
+ desktop->rotate_absolute_center_point (midpoint, rotate_factor);
+ _rotation_status_value_changed_connection.unblock();
+
+ spinbutton_defocus(GTK_WIDGET(_rotation_status->gobj()));
+}
+
+void
+SPDesktopWidget::rotation_populate_popup(Gtk::Menu *menu)
+{
+ for ( auto iter : menu->get_children()) {
+ menu->remove(*iter);
+ }
+
+ auto item_m135 = Gtk::manage(new Gtk::MenuItem("-135°"));
+ auto item_m90 = Gtk::manage(new Gtk::MenuItem( "-90°"));
+ auto item_m45 = Gtk::manage(new Gtk::MenuItem( "-45°"));
+ auto item_0 = Gtk::manage(new Gtk::MenuItem( "0°"));
+ auto item_p45 = Gtk::manage(new Gtk::MenuItem( "45°"));
+ auto item_p90 = Gtk::manage(new Gtk::MenuItem( "90°"));
+ auto item_p135 = Gtk::manage(new Gtk::MenuItem( "135°"));
+ auto item_p180 = Gtk::manage(new Gtk::MenuItem( "180°"));
+
+ item_m135->signal_activate().connect(sigc::bind(sigc::mem_fun(_rotation_status, &Gtk::SpinButton::set_value), -135));
+ item_m90->signal_activate().connect( sigc::bind(sigc::mem_fun(_rotation_status, &Gtk::SpinButton::set_value), -90));
+ item_m45->signal_activate().connect( sigc::bind(sigc::mem_fun(_rotation_status, &Gtk::SpinButton::set_value), -45));
+ item_0->signal_activate().connect( sigc::bind(sigc::mem_fun(_rotation_status, &Gtk::SpinButton::set_value), 0));
+ item_p45->signal_activate().connect( sigc::bind(sigc::mem_fun(_rotation_status, &Gtk::SpinButton::set_value), 45));
+ item_p90->signal_activate().connect( sigc::bind(sigc::mem_fun(_rotation_status, &Gtk::SpinButton::set_value), 90));
+ item_p135->signal_activate().connect(sigc::bind(sigc::mem_fun(_rotation_status, &Gtk::SpinButton::set_value), 135));
+ item_p180->signal_activate().connect(sigc::bind(sigc::mem_fun(_rotation_status, &Gtk::SpinButton::set_value), 180));
+
+ menu->append(*item_m135);
+ menu->append(*item_m90);
+ menu->append(*item_m45);
+ menu->append(*item_0);
+ menu->append(*item_p45);
+ menu->append(*item_p90);
+ menu->append(*item_p135);
+ menu->append(*item_p180);
+
+ menu->show_all();
+}
+
+
+void
+SPDesktopWidget::update_rotation()
+{
+ _rotation_status_value_changed_connection.block();
+ _rotation_status->set_value(desktop->current_rotation() / M_PI * 180.0);
+ _rotation_status->queue_draw();
+ _rotation_status_value_changed_connection.unblock();
+
+}
+
+
+// --------------- Rulers/Scrollbars/Etc. -----------------
+void
+SPDesktopWidget::toggle_rulers()
+{
+ Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+ if (_guides_lock->get_visible()) {
+ _guides_lock->hide();
+ _hruler->hide();
+ _vruler->hide();
+ prefs->setBool(desktop->is_fullscreen() ? "/fullscreen/rulers/state" : "/window/rulers/state", false);
+ } else {
+ _guides_lock->show_all();
+ _hruler->show_all();
+ _vruler->show_all();
+ prefs->setBool(desktop->is_fullscreen() ? "/fullscreen/rulers/state" : "/window/rulers/state", true);
+ }
+}
+
+void
+SPDesktopWidget::toggle_scrollbars()
+{
+ Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+ if (_hscrollbar->get_visible()) {
+ _hscrollbar->hide();
+ _vscrollbar_box->hide();
+ _cms_adjust->hide();
+ prefs->setBool(desktop->is_fullscreen() ? "/fullscreen/scrollbars/state" : "/window/scrollbars/state", false);
+ } else {
+ _hscrollbar->show_all();
+ _vscrollbar_box->show_all();
+ _cms_adjust->show_all();
+ prefs->setBool(desktop->is_fullscreen() ? "/fullscreen/scrollbars/state" : "/window/scrollbars/state", true);
+ }
+}
+
+bool
+SPDesktopWidget::get_color_prof_adj_enabled() const
+{
+ return _cms_adjust->get_sensitive() && _cms_adjust->get_active();
+}
+
+void
+SPDesktopWidget::toggle_color_prof_adj()
+{
+ if (_cms_adjust->get_sensitive()) {
+ if (_cms_adjust->get_active()) {
+ _cms_adjust->toggle_set_down(false);
+ } else {
+ _cms_adjust->toggle_set_down(true);
+ }
+ }
+}
+
+static void
+set_adjustment (Glib::RefPtr<Gtk::Adjustment> &adj, double l, double u, double ps, double si, double pi)
+{
+ if ((l != adj->get_lower()) ||
+ (u != adj->get_upper()) ||
+ (ps != adj->get_page_size()) ||
+ (si != adj->get_step_increment()) ||
+ (pi != adj->get_page_increment())) {
+ adj->set_lower(l);
+ adj->set_upper(u);
+ adj->set_page_size(ps);
+ adj->set_step_increment(si);
+ adj->set_page_increment(pi);
+ }
+}
+
+void
+SPDesktopWidget::update_scrollbars(double scale)
+{
+ if (update) return;
+ update = 1;
+
+ /* The desktop region we always show unconditionally */
+ SPDocument *doc = desktop->doc();
+ Geom::Rect darea ( Geom::Point(-doc->getWidth().value("px"), -doc->getHeight().value("px")),
+ Geom::Point(2 * doc->getWidth().value("px"), 2 * doc->getHeight().value("px")) );
+
+ Geom::OptRect deskarea;
+ if (Inkscape::Preferences::get()->getInt("/tools/bounding_box") == 0) {
+ deskarea = darea | doc->getRoot()->desktopVisualBounds();
+ } else {
+ deskarea = darea | doc->getRoot()->desktopGeometricBounds();
+ }
+
+ /* Canvas region we always show unconditionally */
+ double const y_dir = desktop->yaxisdir();
+ Geom::Rect carea( Geom::Point(deskarea->left() * scale - 64, (deskarea->top() * scale + 64) * y_dir),
+ Geom::Point(deskarea->right() * scale + 64, (deskarea->bottom() * scale - 64) * y_dir) );
+
+ Geom::Rect viewbox = _canvas->getViewbox();
+
+ /* Viewbox is always included into scrollable region */
+ carea = Geom::unify(carea, viewbox);
+
+ set_adjustment(_hadj, carea.min()[Geom::X], carea.max()[Geom::X],
+ viewbox.dimensions()[Geom::X],
+ 0.1 * viewbox.dimensions()[Geom::X],
+ viewbox.dimensions()[Geom::X]);
+ _hadj->set_value(viewbox.min()[Geom::X]);
+
+ set_adjustment(_vadj, carea.min()[Geom::Y], carea.max()[Geom::Y],
+ viewbox.dimensions()[Geom::Y],
+ 0.1 * viewbox.dimensions()[Geom::Y],
+ viewbox.dimensions()[Geom::Y]);
+ _vadj->set_value(viewbox.min()[Geom::Y]);
+
+ update = 0;
+}
+
+bool
+SPDesktopWidget::get_sticky_zoom_active() const
+{
+ return _sticky_zoom->get_active();
+}
+
+double
+SPDesktopWidget::get_hruler_thickness() const
+{
+ auto allocation = _hruler->get_allocation();
+ return allocation.get_height();
+}
+
+double
+SPDesktopWidget::get_vruler_thickness() const
+{
+ auto allocation = _vruler->get_allocation();
+ return allocation.get_width();
+}
+
+gint
+SPDesktopWidget::ruler_event(GtkWidget *widget, GdkEvent *event, SPDesktopWidget *dtw, bool horiz)
+{
+ switch (event->type) {
+ case GDK_BUTTON_PRESS:
+ dtw->on_ruler_box_button_press_event(&event->button, Glib::wrap(GTK_EVENT_BOX(widget)), horiz);
+ break;
+ case GDK_MOTION_NOTIFY:
+ dtw->on_ruler_box_motion_notify_event(&event->motion, Glib::wrap(GTK_EVENT_BOX(widget)), horiz);
+ break;
+ case GDK_BUTTON_RELEASE:
+ dtw->on_ruler_box_button_release_event(&event->button, Glib::wrap(GTK_EVENT_BOX(widget)), horiz);
+ break;
+ default:
+ break;
+ }
+
+ return FALSE;
+}
+
+bool
+SPDesktopWidget::on_ruler_box_motion_notify_event(GdkEventMotion *event, Gtk::EventBox *widget, bool horiz)
+{
+ if (horiz) {
+ sp_event_context_snap_delay_handler(desktop->event_context, (gpointer) widget->gobj(), (gpointer) this, event, Inkscape::UI::Tools::DelayedSnapEvent::GUIDE_HRULER);
+ }
+ else {
+ sp_event_context_snap_delay_handler(desktop->event_context, (gpointer) widget->gobj(), (gpointer) this, event, Inkscape::UI::Tools::DelayedSnapEvent::GUIDE_VRULER);
+ }
+
+ int wx, wy;
+
+ GdkWindow *window = gtk_widget_get_window(GTK_WIDGET(_canvas));
+
+ gint width, height;
+
+ gdk_window_get_device_position(window, event->device, &wx, &wy, nullptr);
+ gdk_window_get_geometry(window, nullptr /*x*/, nullptr /*y*/, &width, &height);
+
+ Geom::Point const event_win(wx, wy);
+
+ if (_ruler_clicked) {
+ Geom::Point const event_w(sp_canvas_window_to_world(_canvas, event_win));
+ Geom::Point event_dt(desktop->w2d(event_w));
+
+ Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+ gint tolerance = prefs->getIntLimited("/options/dragtolerance/value", 0, 0, 100);
+ if ( ( abs( (gint) event->x - _xp ) < tolerance )
+ && ( abs( (gint) event->y - _yp ) < tolerance ) ) {
+ return false;
+ }
+
+ _ruler_dragged = true;
+
+ // explicitly show guidelines; if I draw a guide, I want them on
+ if ((horiz ? wy : wx) >= 0) {
+ desktop->namedview->setGuides(true);
+ }
+
+ if (!(event->state & GDK_SHIFT_MASK)) {
+ ruler_snap_new_guide(desktop, _active_guide, event_dt, _normal);
+ }
+ sp_guideline_set_normal(SP_GUIDELINE(_active_guide), _normal);
+ sp_guideline_set_position(SP_GUIDELINE(_active_guide), event_dt);
+
+ desktop->set_coordinate_status(event_dt);
+ }
+
+ return false;
+}
+
+bool
+SPDesktopWidget::on_ruler_box_button_release_event(GdkEventButton *event, Gtk::EventBox *widget, bool horiz)
+{
+ int wx, wy;
+
+ GdkWindow *window = gtk_widget_get_window(GTK_WIDGET(_canvas));
+
+ gint width, height;
+
+ gdk_window_get_device_position(window, event->device, &wx, &wy, nullptr);
+ gdk_window_get_geometry(window, nullptr /*x*/, nullptr /*y*/, &width, &height);
+
+ Geom::Point const event_win(wx, wy);
+
+ if (_ruler_clicked && event->button == 1) {
+ sp_event_context_discard_delayed_snap_event(desktop->event_context);
+
+ auto seat = gdk_device_get_seat(event->device);
+ gdk_seat_ungrab(seat);
+
+ Geom::Point const event_w(sp_canvas_window_to_world(_canvas, event_win));
+ Geom::Point event_dt(desktop->w2d(event_w));
+
+ if (!(event->state & GDK_SHIFT_MASK)) {
+ ruler_snap_new_guide(desktop, _active_guide, event_dt, _normal);
+ }
+
+ sp_canvas_item_destroy(_active_guide);
+ _active_guide = nullptr;
+ if ((horiz ? wy : wx) >= 0) {
+ Inkscape::XML::Document *xml_doc = desktop->doc()->getReprDoc();
+ Inkscape::XML::Node *repr = xml_doc->createElement("sodipodi:guide");
+
+ // If root viewBox set, interpret guides in terms of viewBox (90/96)
+ double newx = event_dt.x();
+ double newy = event_dt.y();
+
+ // <sodipodi:guide> stores inverted y-axis coordinates
+ if (desktop->is_yaxisdown()) {
+ newy = desktop->doc()->getHeight().value("px") - newy;
+ _normal[Geom::Y] *= -1.0;
+ }
+
+ SPRoot *root = desktop->doc()->getRoot();
+ if( root->viewBox_set ) {
+ newx = newx * root->viewBox.width() / root->width.computed;
+ newy = newy * root->viewBox.height() / root->height.computed;
+ }
+ sp_repr_set_point(repr, "position", Geom::Point( newx, newy ));
+ sp_repr_set_point(repr, "orientation", _normal);
+ desktop->namedview->appendChild(repr);
+ Inkscape::GC::release(repr);
+ DocumentUndo::done(desktop->getDocument(), SP_VERB_NONE,
+ _("Create guide"));
+ }
+ desktop->set_coordinate_status(event_dt);
+
+ if (!_ruler_dragged) {
+ // Ruler click (without drag) toggle the guide visibility on and off
+ Inkscape::XML::Node *repr = desktop->namedview->getRepr();
+ sp_namedview_toggle_guides(desktop->getDocument(), desktop->namedview);
+ }
+
+ _ruler_clicked = false;
+ _ruler_dragged = false;
+ }
+
+ return false;
+}
+
+bool
+SPDesktopWidget::on_ruler_box_button_press_event(GdkEventButton *event, Gtk::EventBox *widget, bool horiz)
+{
+ if (_ruler_clicked) // event triggerred on a double click: do no process the click
+ return false;
+
+ int wx, wy;
+
+ GdkWindow *window = gtk_widget_get_window(GTK_WIDGET(_canvas));
+
+ gint width, height;
+
+ gdk_window_get_device_position(window, event->device, &wx, &wy, nullptr);
+ gdk_window_get_geometry(window, nullptr /*x*/, nullptr /*y*/, &width, &height);
+
+ Geom::Point const event_win(wx, wy);
+
+ if (event->button == 1) {
+ _ruler_clicked = true;
+ _ruler_dragged = false;
+ // save click origin
+ _xp = (gint) event->x;
+ _yp = (gint) event->y;
+
+ Geom::Point const event_w(sp_canvas_window_to_world(_canvas, event_win));
+ Geom::Point const event_dt(desktop->w2d(event_w));
+
+ // calculate the normal of the guidelines when dragged from the edges of rulers.
+ auto const y_dir = desktop->yaxisdir();
+ Geom::Point normal_bl_to_tr(1., y_dir); //bottomleft to topright
+ Geom::Point normal_tr_to_bl(-1., y_dir); //topright to bottomleft
+ normal_bl_to_tr.normalize();
+ normal_tr_to_bl.normalize();
+ Inkscape::CanvasGrid * grid = sp_namedview_get_first_enabled_grid(desktop->namedview);
+ if (grid){
+ if (grid->getGridType() == Inkscape::GRID_AXONOMETRIC ) {
+ Inkscape::CanvasAxonomGrid *axonomgrid = dynamic_cast<Inkscape::CanvasAxonomGrid *>(grid);
+ if (event->state & GDK_CONTROL_MASK) {
+ // guidelines normal to gridlines
+ normal_bl_to_tr = Geom::Point::polar(-axonomgrid->angle_rad[0], 1.0);
+ normal_tr_to_bl = Geom::Point::polar(axonomgrid->angle_rad[2], 1.0);
+ } else {
+ normal_bl_to_tr = rot90(Geom::Point::polar(axonomgrid->angle_rad[2], 1.0));
+ normal_tr_to_bl = rot90(Geom::Point::polar(-axonomgrid->angle_rad[0], 1.0));
+ }
+ }
+ }
+ if (horiz) {
+ if (wx < 50) {
+ _normal = normal_bl_to_tr;
+ } else if (wx > width - 50) {
+ _normal = normal_tr_to_bl;
+ } else {
+ _normal = Geom::Point(0.,1.);
+ }
+ } else {
+ if (wy < 50) {
+ _normal = normal_bl_to_tr;
+ } else if (wy > height - 50) {
+ _normal = normal_tr_to_bl;
+ } else {
+ _normal = Geom::Point(1.,0.);
+ }
+ }
+
+ _active_guide = sp_guideline_new(desktop->guides, nullptr, event_dt, _normal);
+ sp_guideline_set_color(SP_GUIDELINE(_active_guide), desktop->namedview->guidehicolor);
+
+ auto window = widget->get_window()->gobj();
+
+ auto seat = gdk_device_get_seat(event->device);
+ gdk_seat_grab(seat,
+ window,
+ GDK_SEAT_CAPABILITY_ALL_POINTING,
+ FALSE,
+ nullptr,
+ (GdkEvent*)event,
+ nullptr,
+ nullptr);
+ }
+
+ return false;
+}
+
+GtkAllocation
+SPDesktopWidget::get_canvas_allocation() const
+{
+ GtkAllocation allocation;
+ gtk_widget_get_allocation(GTK_WIDGET(_canvas), &allocation);
+ return allocation;
+}
+
+void
+SPDesktopWidget::ruler_snap_new_guide(SPDesktop *desktop, SPCanvasItem * /*guide*/, Geom::Point &event_dt, Geom::Point &normal)
+{
+ SnapManager &m = desktop->namedview->snap_manager;
+ m.setup(desktop);
+ // We're dragging a brand new guide, just pulled of the rulers seconds ago. When snapping to a
+ // path this guide will change it slope to become either tangential or perpendicular to that path. It's
+ // therefore not useful to try tangential or perpendicular snapping, so this will be disabled temporarily
+ bool pref_perp = m.snapprefs.getSnapPerp();
+ bool pref_tang = m.snapprefs.getSnapTang();
+ m.snapprefs.setSnapPerp(false);
+ m.snapprefs.setSnapTang(false);
+ // We only have a temporary guide which is not stored in our document yet.
+ // Because the guide snapper only looks in the document for guides to snap to,
+ // we don't have to worry about a guide snapping to itself here
+ Geom::Point normal_orig = normal;
+ m.guideFreeSnap(event_dt, normal, false, false);
+ // After snapping, both event_dt and normal have been modified accordingly; we'll take the normal (of the
+ // curve we snapped to) to set the normal the guide. And rotate it by 90 deg. if needed
+ if (pref_perp) { // Perpendicular snapping to paths is requested by the user, so let's do that
+ if (normal != normal_orig) {
+ normal = Geom::rot90(normal);
+ }
+ }
+ if (!(pref_tang || pref_perp)) { // if we don't want to snap either perpendicularly or tangentially, then
+ normal = normal_orig; // we must restore the normal to it's original state
+ }
+ // Restore the preferences
+ m.snapprefs.setSnapPerp(pref_perp);
+ m.snapprefs.setSnapTang(pref_tang);
+ m.unSetup();
+}
+
+/*
+ Local Variables:
+ mode:c++
+ c-file-style:"stroustrup"
+ c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
+ indent-tabs-mode:nil
+ fill-column:99
+ End:
+*/
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4 :
diff --git a/src/widgets/desktop-widget.h b/src/widgets/desktop-widget.h
new file mode 100644
index 0000000..e61cdd5
--- /dev/null
+++ b/src/widgets/desktop-widget.h
@@ -0,0 +1,354 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+#ifndef SEEN_SP_DESKTOP_WIDGET_H
+#define SEEN_SP_DESKTOP_WIDGET_H
+
+/** \file
+ * SPDesktopWidget: handling Gtk events on a desktop.
+ *
+ * Authors:
+ * Jon A. Cruz <jon@joncruz.org> (c) 2010
+ * John Bintz <jcoswell@coswellproductions.org> (c) 2006
+ * Ralf Stephan <ralf@ark.in-berlin.de> (c) 2005
+ * Abhishek Sharma
+ * ? -2004
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#ifdef HAVE_CONFIG_H
+# include "config.h" // only include where actually required!
+#endif
+
+#include <gtkmm.h>
+
+#include "message.h"
+#include "ui/view/view-widget.h"
+#include "ui/view/edit-widget-interface.h"
+
+#include <cstddef>
+#include <sigc++/connection.h>
+#include <2geom/point.h>
+
+// forward declaration
+typedef struct _EgeColorProfTracker EgeColorProfTracker;
+struct SPCanvas;
+struct SPCanvasItem;
+class SPDocument;
+class SPDesktop;
+struct SPDesktopWidget;
+class SPObject;
+
+namespace Inkscape {
+namespace UI {
+namespace Dialog {
+class SwatchesPanel;
+} // namespace Dialog
+
+namespace Widget {
+class Button;
+class LayerSelector;
+class SelectedStyle;
+class Ruler;
+} // namespace Widget
+} // namespace UI
+} // namespace Inkscape
+
+#define SP_TYPE_DESKTOP_WIDGET SPDesktopWidget::getType()
+#define SP_DESKTOP_WIDGET(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), SP_TYPE_DESKTOP_WIDGET, SPDesktopWidget))
+#define SP_DESKTOP_WIDGET_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), SP_TYPE_DESKTOP_WIDGET, SPDesktopWidgetClass))
+#define SP_IS_DESKTOP_WIDGET(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), SP_TYPE_DESKTOP_WIDGET))
+#define SP_IS_DESKTOP_WIDGET_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), SP_TYPE_DESKTOP_WIDGET))
+
+/**
+ * Create a new SPDesktopWidget
+ */
+SPDesktopWidget *sp_desktop_widget_new(SPDocument* document);
+
+void sp_desktop_widget_show_decorations(SPDesktopWidget *dtw, gboolean show);
+void sp_desktop_widget_update_hruler (SPDesktopWidget *dtw);
+void sp_desktop_widget_update_vruler (SPDesktopWidget *dtw);
+
+/* Show/hide rulers & scrollbars */
+void sp_desktop_widget_update_scrollbars (SPDesktopWidget *dtw, double scale);
+
+void sp_dtw_desktop_activate (SPDesktopWidget *dtw);
+void sp_dtw_desktop_deactivate (SPDesktopWidget *dtw);
+
+/// A GtkEventBox on an SPDesktop.
+struct SPDesktopWidget {
+ SPViewWidget viewwidget;
+
+ unsigned int update : 1;
+
+ sigc::connection modified_connection;
+
+ SPDesktop *desktop;
+
+ Gtk::Window *window;
+
+ static void dispose(GObject *object);
+
+private:
+ // Flags for ruler event handling
+ bool _ruler_clicked; ///< True if the ruler has been clicked
+ bool _ruler_dragged; ///< True if a drag on the ruler is occurring
+
+ SPCanvasItem *_active_guide; ///< The guide currently being handled during a ruler event
+ Geom::Point _normal; ///< Normal to the guide currently being handled during ruler event
+ int _xp; ///< x coordinate for start of drag
+ int _yp; ///< y coordinate for start of drag
+
+ // The root vbox of the window layout.
+ Gtk::Box *_vbox;
+
+ Gtk::Box *_hbox;
+
+ Gtk::MenuBar *_menubar; // TEMP
+ Gtk::Box *_statusbar;
+
+ Inkscape::UI::Dialog::SwatchesPanel *_panels;
+
+ Glib::RefPtr<Gtk::Adjustment> _hadj;
+ Glib::RefPtr<Gtk::Adjustment> _vadj;
+
+ Gtk::ToggleButton *_guides_lock;
+
+ Inkscape::UI::Widget::Button *_cms_adjust;
+ Gtk::ToggleButton *_sticky_zoom;
+ Gtk::Grid *_coord_status;
+
+ Gtk::Label *_coord_status_x;
+ Gtk::Label *_coord_status_y;
+ Gtk::SpinButton *_zoom_status;
+ sigc::connection _zoom_status_input_connection;
+ sigc::connection _zoom_status_output_connection;
+ sigc::connection _zoom_status_value_changed_connection;
+ sigc::connection _zoom_status_populate_popup_connection;
+ Gtk::Label *_select_status;
+ Gtk::SpinButton *_rotation_status;
+
+ sigc::connection _rotation_status_input_connection;
+ sigc::connection _rotation_status_output_connection;
+ sigc::connection _rotation_status_value_changed_connection;
+ sigc::connection _rotation_status_populate_popup_connection;
+
+ Inkscape::UI::Widget::Dock *_dock;
+
+ Gtk::Scrollbar *_hscrollbar;
+ Gtk::Scrollbar *_vscrollbar;
+ Gtk::Box *_vscrollbar_box;
+
+ Inkscape::UI::Widget::SelectedStyle *_selected_style;
+
+ /** A table for displaying the canvas, rulers etc */
+ Gtk::Grid *_canvas_tbl;
+ sigc::connection _canvas_tbl_size_allocate_connection;
+
+ Gtk::EventBox *_hruler_box;
+ Gtk::EventBox *_vruler_box; // eventboxes for setting tooltips
+
+ /* Rulers */
+ Inkscape::UI::Widget::Ruler *_hruler;
+ Inkscape::UI::Widget::Ruler *_vruler;
+ Gtk::Allocation _allocation;
+
+ unsigned int _interaction_disabled_counter;
+
+ Geom::Point _ruler_origin;
+ double _dt2r;
+
+ SPCanvas *_canvas;
+
+public:
+ Inkscape::UI::Widget::LayerSelector *layer_selector;
+
+ EgeColorProfTracker* _tracker;
+
+ struct WidgetStub : public Inkscape::UI::View::EditWidgetInterface {
+ SPDesktopWidget *_dtw;
+ WidgetStub (SPDesktopWidget* dtw) : _dtw(dtw) {}
+
+ void setTitle (gchar const *uri) override
+ { _dtw->updateTitle (uri); }
+ Gtk::Window* getWindow() override
+ { return _dtw->window; }
+
+ void layout() override {
+ _dtw->layoutWidgets();
+ }
+
+ void present() override
+ { _dtw->presentWindow(); }
+ void getGeometry (gint &x, gint &y, gint &w, gint &h) override
+ { _dtw->getWindowGeometry (x, y, w, h); }
+ void setSize (gint w, gint h) override
+ { _dtw->setWindowSize (w, h); }
+ void setPosition (Geom::Point p) override
+ { _dtw->setWindowPosition (p); }
+ void setTransient (void* p, int transient_policy) override
+ { _dtw->setWindowTransient (p, transient_policy); }
+ Geom::Point getPointer() override
+ { return _dtw->window_get_pointer(); }
+ void setIconified() override
+ { _dtw->iconify(); }
+ void setMaximized() override
+ { _dtw->maximize(); }
+ void setFullscreen() override
+ { _dtw->fullscreen(); }
+ bool shutdown() override
+ { return _dtw->shutdown(); }
+ void destroy() override
+ {
+ if(_dtw->window != nullptr)
+ delete _dtw->window;
+ _dtw->window = nullptr;
+ }
+
+ void storeDesktopPosition() override { _dtw->storeDesktopPosition(); }
+ void requestCanvasUpdate() override { _dtw->requestCanvasUpdate(); }
+ void requestCanvasUpdateAndWait() override { _dtw->requestCanvasUpdateAndWait(); }
+ void enableInteraction() override { _dtw->enableInteraction(); }
+ void disableInteraction() override { _dtw->disableInteraction(); }
+ void activateDesktop() override { sp_dtw_desktop_activate(_dtw); }
+ void deactivateDesktop() override { sp_dtw_desktop_deactivate(_dtw); }
+ void updateRulers() override { _dtw->update_rulers(); }
+ void updateScrollbars(double scale) override { _dtw->update_scrollbars(scale); }
+ void toggleRulers() override { _dtw->toggle_rulers(); }
+ void toggleScrollbars() override { _dtw->toggle_scrollbars(); }
+ void toggleColorProfAdjust() override { _dtw->toggle_color_prof_adj(); }
+ bool colorProfAdjustEnabled() override { return _dtw->get_color_prof_adj_enabled(); }
+ void updateZoom() override { _dtw->update_zoom(); }
+ void letZoomGrabFocus() override { _dtw->letZoomGrabFocus(); }
+ void updateRotation() override { _dtw->update_rotation(); }
+ Gtk::Toolbar* get_toolbar_by_name(const Glib::ustring& name) override {return _dtw->get_toolbar_by_name(name);}
+ void setToolboxFocusTo(const gchar *id) override { _dtw->setToolboxFocusTo(id); }
+ void setToolboxAdjustmentValue(const gchar *id, double val) override
+ { _dtw->setToolboxAdjustmentValue (id, val); }
+ bool isToolboxButtonActive (gchar const* id) override
+ { return _dtw->isToolboxButtonActive (id); }
+ void setCoordinateStatus (Geom::Point p) override
+ { _dtw->setCoordinateStatus (p); }
+ void setMessage (Inkscape::MessageType type, gchar const* msg) override
+ { _dtw->setMessage (type, msg); }
+
+ bool showInfoDialog( Glib::ustring const &message ) override {
+ return _dtw->showInfoDialog( message );
+ }
+
+ bool warnDialog (Glib::ustring const &text) override
+ { return _dtw->warnDialog (text); }
+
+ Inkscape::UI::Widget::Dock* getDock () override
+ { return _dtw->getDock(); }
+ };
+
+ WidgetStub *stub;
+
+ void setMessage(Inkscape::MessageType type, gchar const *message);
+ Geom::Point window_get_pointer();
+ bool shutdown();
+ void viewSetPosition (Geom::Point p);
+ void letZoomGrabFocus();
+ void getWindowGeometry (gint &x, gint &y, gint &w, gint &h);
+ void setWindowPosition (Geom::Point p);
+ void setWindowSize (gint w, gint h);
+ void setWindowTransient (void *p, int transient_policy);
+ void presentWindow();
+ bool showInfoDialog( Glib::ustring const &message );
+ bool warnDialog (Glib::ustring const &text);
+ Gtk::Toolbar* get_toolbar_by_name(const Glib::ustring& name);
+ void setToolboxFocusTo (gchar const *);
+ void setToolboxAdjustmentValue (gchar const * id, double value);
+ bool isToolboxButtonActive (gchar const *id);
+ void setToolboxPosition(Glib::ustring const& id, GtkPositionType pos);
+ void setCoordinateStatus(Geom::Point p);
+ void storeDesktopPosition();
+ void requestCanvasUpdate();
+ void requestCanvasUpdateAndWait();
+ void enableInteraction();
+ void disableInteraction();
+ void updateTitle(gchar const *uri);
+ bool onFocusInEvent(GdkEventFocus*);
+
+ Gtk::MenuBar *menubar() { return _menubar; }
+
+ Inkscape::UI::Widget::Dock* getDock();
+
+ static GType getType();
+ static SPDesktopWidget* createInstance(SPDocument *document);
+
+ void updateNamedview();
+ void update_guides_lock();
+
+ /// Get the CMS adjustment button widget
+ decltype(_cms_adjust) get_cms_adjust() const {return _cms_adjust;}
+
+ void cms_adjust_set_sensitive(bool enabled);
+ bool get_color_prof_adj_enabled() const;
+ void toggle_color_prof_adj();
+ bool get_sticky_zoom_active() const;
+ void update_zoom();
+ void update_rotation();
+ void update_rulers();
+ double get_hruler_thickness() const;
+ double get_vruler_thickness() const;
+ GtkAllocation get_canvas_allocation() const;
+ void iconify();
+ void maximize();
+ void fullscreen();
+ static gint ruler_event(GtkWidget *widget, GdkEvent *event, SPDesktopWidget *dtw, bool horiz);
+
+ private:
+ GtkWidget *tool_toolbox;
+ GtkWidget *aux_toolbox;
+ GtkWidget *commands_toolbox;
+ GtkWidget *snap_toolbox;
+
+ static void init(SPDesktopWidget *widget);
+ void layoutWidgets();
+
+ void namedviewModified(SPObject *obj, guint flags);
+ void on_adjustment_value_changed();
+ void toggle_scrollbars();
+ void update_scrollbars(double scale);
+ void toggle_rulers();
+ void sticky_zoom_toggled();
+ int zoom_input(double *new_val);
+ bool zoom_output();
+ void zoom_value_changed();
+ void zoom_menu_handler(double factor);
+ void zoom_populate_popup(Gtk::Menu *menu);
+ int rotation_input(double *new_val);
+ bool rotation_output();
+ void rotation_value_changed();
+ void rotation_populate_popup(Gtk::Menu *menu);
+ void canvas_tbl_size_allocate(Gtk::Allocation &allocation);
+
+#if defined(HAVE_LIBLCMS2)
+ static void cms_adjust_toggled( GtkWidget *button, gpointer data );
+ static void color_profile_event(EgeColorProfTracker *tracker, SPDesktopWidget *dtw);
+#endif
+ static void ruler_snap_new_guide(SPDesktop *desktop, SPCanvasItem *guide, Geom::Point &event_dt, Geom::Point &normal);
+ static gint event(GtkWidget *widget, GdkEvent *event, SPDesktopWidget *dtw);
+ bool on_ruler_box_button_press_event(GdkEventButton *event, Gtk::EventBox *widget, bool horiz);
+ bool on_ruler_box_button_release_event(GdkEventButton *event, Gtk::EventBox *widget, bool horiz);
+ bool on_ruler_box_motion_notify_event(GdkEventMotion *event, Gtk::EventBox *widget, bool horiz);
+};
+
+/// The SPDesktopWidget vtable
+struct SPDesktopWidgetClass {
+ SPViewWidgetClass parent_class;
+};
+
+#endif /* !SEEN_SP_DESKTOP_WIDGET_H */
+
+/*
+ Local Variables:
+mode:c++
+c-file-style:"stroustrup"
+c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
+indent-tabs-mode:nil
+fill-column:99
+End:
+*/
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4 :
diff --git a/src/widgets/ege-paint-def.cpp b/src/widgets/ege-paint-def.cpp
new file mode 100644
index 0000000..fa654cb
--- /dev/null
+++ b/src/widgets/ege-paint-def.cpp
@@ -0,0 +1,316 @@
+// SPDX-License-Identifier: GPL-2.0-or-later OR MPL-1.1 OR LGPL-2.1-or-later
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Eek Color Definition.
+ *
+ * The Initial Developer of the Original Code is
+ * Jon A. Cruz.
+ * Portions created by the Initial Developer are Copyright (C) 2006
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+#include <libintl.h>
+
+#include <cstdint>
+#include <string>
+#include <iostream>
+#include <sstream>
+#include <cstring>
+#include <cstdio>
+#include <utility>
+#include <glibmm/i18n.h>
+#include <glibmm/stringutils.h>
+
+#if !defined(_)
+#define _(s) gettext(s)
+#endif // !defined(_)
+
+#include "ege-paint-def.h"
+
+namespace ege
+{
+
+static std::string mimeTEXT("text/plain");
+static std::string mimeX_COLOR("application/x-color");
+static std::string mimeOSWB_COLOR("application/x-oswb-color");
+
+PaintDef::PaintDef() :
+ descr(_("none")),
+ type(NONE),
+ r(0),
+ g(0),
+ b(0),
+ editable(false),
+ _listeners()
+{
+}
+
+PaintDef::PaintDef( ColorType type ) :
+ descr(),
+ type(type),
+ r(0),
+ g(0),
+ b(0),
+ editable(false),
+ _listeners()
+{
+ switch (type) {
+ case CLEAR:
+ descr = _("remove");
+ break;
+ case NONE:
+ descr = _("none");
+ break;
+ case RGB:
+ descr = "";
+ break;
+ }
+}
+
+PaintDef::PaintDef( unsigned int r, unsigned int g, unsigned int b, std::string description ) :
+ descr(std::move(description)),
+ type(RGB),
+ r(r),
+ g(g),
+ b(b),
+ editable(false),
+ _listeners()
+{
+}
+
+PaintDef::~PaintDef()
+= default;
+
+PaintDef::PaintDef( PaintDef const &other )
+{
+ if ( this != &other ) {
+ *this = other;
+ }
+}
+
+PaintDef& PaintDef::operator=( PaintDef const &other )
+{
+ if ( this != & other )
+ {
+ type = other.type;
+ r = other.r;
+ g = other.g;
+ b = other.b;
+ descr = other.descr;
+ editable = other.editable;
+ //TODO: _listeners should be assigned a value
+ }
+ return *this;
+}
+
+class PaintDef::HookData {
+public:
+ HookData( ColorCallback cb, void* data ) {_cb = cb; _data = data;}
+ ColorCallback _cb;
+ void* _data;
+};
+
+
+std::vector<std::string> PaintDef::getMIMETypes()
+{
+ std::vector<std::string> listing;
+ listing.push_back(mimeOSWB_COLOR);
+ listing.push_back(mimeX_COLOR);
+ listing.push_back(mimeTEXT);
+ return listing;
+}
+
+void PaintDef::getMIMEData(std::string const & type, char*& dest, int& len, int& format)
+{
+ if ( type == mimeTEXT ) {
+ dest = new char[8];
+ snprintf( dest, 8, "#%02x%02x%02x", getR(), getG(), getB() );
+ dest[7] = 0;
+ len = 8;
+ format = 8;
+ } else if ( type == mimeX_COLOR ) {
+ uint16_t* tmp = new uint16_t[4];
+ tmp[0] = (getR() << 8) | getR();
+ tmp[1] = (getG() << 8) | getG();
+ tmp[2] = (getB() << 8) | getB();
+ tmp[3] = 0xffff;
+ dest = reinterpret_cast<char*>(tmp);
+ len = 8;
+ format = 16;
+ } else if ( type == mimeOSWB_COLOR ) {
+ std::string tmp("<paint>");
+ switch ( getType() ) {
+ case ege::PaintDef::NONE:
+ {
+ tmp += "<nocolor/>";
+ }
+ break;
+ case ege::PaintDef::CLEAR:
+ {
+ tmp += "<clear/>";
+ }
+ break;
+ default:
+ {
+ tmp += std::string("<color name=\"") + descr + "\">";
+ tmp += "<sRGB r=\"";
+ tmp += Glib::Ascii::dtostr(getR()/255.0);
+ tmp += "\" g=\"";
+ tmp += Glib::Ascii::dtostr(getG()/255.0);
+ tmp += "\" b=\"";
+ tmp += Glib::Ascii::dtostr(getB()/255.0);
+ tmp += "\"/>";
+ tmp += "</color>";
+ }
+ }
+ tmp += "</paint>";
+ len = tmp.size();
+ dest = new char[len];
+ // Note that this is not null-terminated:
+ memcpy(dest, tmp.c_str(), len);
+ format = 8;
+ } else {
+ // nothing
+ dest = nullptr;
+ len = 0;
+ }
+}
+
+bool PaintDef::fromMIMEData(std::string const & type, char const * data, int len, int /*format*/)
+{
+ bool worked = false;
+ bool changed = false;
+ if ( type == mimeTEXT ) {
+ } else if ( type == mimeX_COLOR ) {
+ } else if ( type == mimeOSWB_COLOR ) {
+ std::string xml(data, len);
+ if ( xml.find("<nocolor/>") != std::string::npos ) {
+ if ( (this->type != ege::PaintDef::NONE)
+ || (this->r != 0)
+ || (this->g != 0)
+ || (this->b != 0) ) {
+ this->type = ege::PaintDef::NONE;
+ this->r = 0;
+ this->g = 0;
+ this->b = 0;
+ changed = true;
+ }
+ worked = true;
+ } else {
+ size_t pos = xml.find("<sRGB");
+ if ( pos != std::string::npos ) {
+ size_t endPos = xml.find(">", pos);
+ std::string srgb = xml.substr(pos, endPos);
+ this->type = ege::PaintDef::RGB;
+ size_t numPos = srgb.find("r=");
+ if (numPos != std::string::npos) {
+ double dbl = Glib::Ascii::strtod(srgb.substr(numPos + 3));
+ this->r = static_cast<int>(255 * dbl);
+ }
+ numPos = srgb.find("g=");
+ if (numPos != std::string::npos) {
+ double dbl = Glib::Ascii::strtod(srgb.substr(numPos + 3));
+ this->g = static_cast<int>(255 * dbl);
+ }
+ numPos = srgb.find("b=");
+ if (numPos != std::string::npos) {
+ double dbl = Glib::Ascii::strtod(srgb.substr(numPos + 3));
+ this->b = static_cast<int>(255 * dbl);
+ }
+
+ size_t pos = xml.find("<color ");
+ if ( pos != std::string::npos ) {
+ size_t endPos = xml.find(">", pos);
+ std::string colorTag = xml.substr(pos, endPos);
+
+ size_t namePos = colorTag.find("name=");
+ if (namePos != std::string::npos) {
+ char quote = colorTag[namePos + 5];
+ endPos = colorTag.find(quote, namePos + 6);
+ descr = colorTag.substr(namePos + 6, endPos - (namePos + 6));
+ }
+ }
+ changed = true;
+ worked = true;
+ }
+ }
+ }
+ if ( changed ) {
+ // beware of callbacks changing things
+ for (auto & _listener : _listeners)
+ {
+ if ( _listener->_cb )
+ {
+ _listener->_cb( _listener->_data );
+ }
+ }
+ }
+ return worked;
+}
+
+void PaintDef::setRGB( unsigned int r, unsigned int g, unsigned int b )
+{
+ if ( r != this->r || g != this->g || b != this->b ) {
+ this->r = r;
+ this->g = g;
+ this->b = b;
+
+ // beware of callbacks changing things
+ for (auto & _listener : _listeners)
+ {
+ if ( _listener->_cb )
+ {
+ _listener->_cb( _listener->_data );
+ }
+ }
+ }
+}
+
+void PaintDef::addCallback( ColorCallback cb, void* data )
+{
+ _listeners.push_back( new HookData(cb, data) );
+}
+
+void PaintDef::removeCallback( ColorCallback /*cb*/, void* /*data*/ )
+{
+}
+
+
+} // namespace ege
+
+/*
+ Local Variables:
+ mode:c++
+ c-file-style:"stroustrup"
+ c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
+ indent-tabs-mode:nil
+ fill-column:99
+ End:
+*/
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :
diff --git a/src/widgets/ege-paint-def.h b/src/widgets/ege-paint-def.h
new file mode 100644
index 0000000..63643c5
--- /dev/null
+++ b/src/widgets/ege-paint-def.h
@@ -0,0 +1,112 @@
+// SPDX-License-Identifier: GPL-2.0-or-later OR MPL-1.1 OR LGPL-2.1-or-later
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Eek Color Definition.
+ *
+ * The Initial Developer of the Original Code is
+ * Jon A. Cruz.
+ * Portions created by the Initial Developer are Copyright (C) 2006
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+#ifndef SEEN_EGE_PAINT_DEF_H
+#define SEEN_EGE_PAINT_DEF_H
+
+#include <string>
+#include <vector>
+
+namespace ege
+{
+
+typedef void (*ColorCallback)( void* data );
+
+
+/**
+ * Pure data representation of a color definition.
+ */
+class PaintDef
+{
+public:
+ enum ColorType{CLEAR, NONE, RGB};
+
+ PaintDef();
+ PaintDef(ColorType type);
+ PaintDef( unsigned int r, unsigned int g, unsigned int b, std::string description );
+ virtual ~PaintDef();
+
+ PaintDef( PaintDef const &other );
+ virtual PaintDef& operator=( PaintDef const &other );
+
+ ColorType getType() const { return type; }
+
+ std::vector<std::string> getMIMETypes();
+ void getMIMEData(std::string const & type, char*& dest, int& len, int& format);
+ bool fromMIMEData(std::string const & type, char const * data, int len, int format);
+
+ void setRGB( unsigned int r, unsigned int g, unsigned int b );
+ unsigned int getR() const { return r; }
+ unsigned int getG() const { return g; }
+ unsigned int getB() const { return b; }
+
+ void addCallback( ColorCallback cb, void* data );
+ void removeCallback( ColorCallback cb, void* data );
+
+ bool isEditable() const { return editable; }
+ void setEditable( bool edit ) { editable = edit; }
+
+ std::string descr;
+
+protected:
+ ColorType type;
+ unsigned int r;
+ unsigned int g;
+ unsigned int b;
+ bool editable;
+
+private:
+ class HookData;
+
+ std::vector<HookData*> _listeners;
+};
+
+
+} // namespace ege
+
+#endif // SEEN_EGE_PAINT_DEF_H
+
+/*
+ Local Variables:
+ mode:c++
+ c-file-style:"stroustrup"
+ c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
+ indent-tabs-mode:nil
+ fill-column:99
+ End:
+*/
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :
diff --git a/src/widgets/fill-n-stroke-factory.h b/src/widgets/fill-n-stroke-factory.h
new file mode 100644
index 0000000..5ca9daa
--- /dev/null
+++ b/src/widgets/fill-n-stroke-factory.h
@@ -0,0 +1,38 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+#ifndef SEEN_FILL_N_STROKE_FACTORY_H
+#define SEEN_FILL_N_STROKE_FACTORY_H
+/* Authors:
+ * Jon A. Cruz <jon@joncruz.org>
+ *
+ * Copyright (C) 2010 Jon A. Cruz
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#include "fill-or-stroke.h"
+
+namespace Gtk {
+class Widget;
+}
+
+namespace Inkscape {
+namespace Widgets {
+
+Gtk::Widget *createStyleWidget( FillOrStroke kind );
+Gtk::Widget *createStrokeStyleWidget( );
+
+} // namespace Widgets
+} // namespace Inkscape
+
+#endif // !SEEN_FILL_N_STROKE_FACTORY_H
+
+/*
+ Local Variables:
+ mode:c++
+ c-file-style:"stroustrup"
+ c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
+ indent-tabs-mode:nil
+ fill-column:99
+ End:
+*/
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :
diff --git a/src/widgets/fill-style.cpp b/src/widgets/fill-style.cpp
new file mode 100644
index 0000000..f35a148
--- /dev/null
+++ b/src/widgets/fill-style.cpp
@@ -0,0 +1,832 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/**
+ * @file
+ * Fill style widget.
+ */
+/* Authors:
+ * Lauris Kaplinski <lauris@kaplinski.com>
+ * Frank Felfe <innerspace@iname.com>
+ * bulia byak <buliabyak@users.sf.net>
+ * Jon A. Cruz <jon@joncruz.org>
+ * Abhishek Sharma
+ *
+ * Copyright (C) 1999-2005 authors
+ * Copyright (C) 2001-2002 Ximian, Inc.
+ * Copyright (C) 2010 Jon A. Cruz
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#define noSP_FS_VERBOSE
+
+#include <gtkmm/box.h>
+#include <glibmm/i18n.h>
+
+#include "desktop-style.h"
+#include "desktop.h"
+#include "document-undo.h"
+#include "fill-n-stroke-factory.h"
+#include "fill-style.h"
+#include "gradient-chemistry.h"
+#include "inkscape.h"
+#include "selection.h"
+#include "verbs.h"
+
+#include "object/sp-defs.h"
+#include "object/sp-linear-gradient.h"
+#include "object/sp-mesh-gradient.h"
+#include "object/sp-pattern.h"
+#include "object/sp-radial-gradient.h"
+#include "object/sp-text.h"
+#include "style.h"
+
+#include "display/sp-canvas.h"
+
+#include "widgets/paint-selector.h"
+
+
+// These can be deleted once we sort out the libart dependence.
+
+#define ART_WIND_RULE_NONZERO 0
+
+/* Fill */
+
+
+Gtk::Widget *sp_fill_style_widget_new()
+{
+ return Inkscape::Widgets::createStyleWidget( FILL );
+}
+
+
+namespace Inkscape {
+
+class FillNStroke : public Gtk::VBox
+{
+public:
+ FillNStroke( FillOrStroke k );
+ ~FillNStroke() override;
+
+ void setFillrule( SPPaintSelector::FillRule mode );
+
+ void setDesktop(SPDesktop *desktop);
+
+private:
+ static void paintModeChangeCB(SPPaintSelector *psel, SPPaintSelector::Mode mode, FillNStroke *self);
+ static void paintChangedCB(SPPaintSelector *psel, FillNStroke *self);
+ static void paintDraggedCB(SPPaintSelector *psel, FillNStroke *self);
+ static gboolean dragDelayCB(gpointer data);
+
+ static void fillruleChangedCB( SPPaintSelector *psel, SPPaintSelector::FillRule mode, FillNStroke *self );
+
+ void selectionModifiedCB(guint flags);
+ void eventContextCB(SPDesktop *desktop, Inkscape::UI::Tools::ToolBase *eventcontext);
+
+ void dragFromPaint();
+ void updateFromPaint();
+
+ void performUpdate();
+
+ FillOrStroke kind;
+ SPDesktop *desktop;
+ SPPaintSelector *psel;
+ guint32 lastDrag;
+ guint dragId;
+ bool update;
+ sigc::connection selectChangedConn;
+ sigc::connection subselChangedConn;
+ sigc::connection selectModifiedConn;
+ sigc::connection eventContextConn;
+};
+
+} // namespace Inkscape
+
+void sp_fill_style_widget_set_desktop(Gtk::Widget *widget, SPDesktop *desktop)
+{
+ Inkscape::FillNStroke *fs = dynamic_cast<Inkscape::FillNStroke*>(widget);
+ if (fs) {
+ fs->setDesktop(desktop);
+ }
+}
+
+namespace Inkscape {
+
+/**
+ * Create the fill or stroke style widget, and hook up all the signals.
+ */
+Gtk::Widget *Inkscape::Widgets::createStyleWidget( FillOrStroke kind )
+{
+ FillNStroke *filler = new FillNStroke(kind);
+
+ return filler;
+}
+
+FillNStroke::FillNStroke( FillOrStroke k ) :
+ Gtk::VBox(),
+ kind(k),
+ desktop(nullptr),
+ psel(nullptr),
+ lastDrag(0),
+ dragId(0),
+ update(false),
+ selectChangedConn(),
+ subselChangedConn(),
+ selectModifiedConn(),
+ eventContextConn()
+{
+ // Add and connect up the paint selector widget:
+ psel = sp_paint_selector_new(kind);
+ gtk_widget_show(GTK_WIDGET(psel));
+ gtk_container_add(GTK_CONTAINER(gobj()), GTK_WIDGET(psel));
+ g_signal_connect( G_OBJECT(psel), "mode_changed",
+ G_CALLBACK(paintModeChangeCB),
+ this );
+
+ g_signal_connect( G_OBJECT(psel), "dragged",
+ G_CALLBACK(paintDraggedCB),
+ this );
+
+ g_signal_connect( G_OBJECT(psel), "changed",
+ G_CALLBACK(paintChangedCB),
+ this );
+ if (kind == FILL) {
+ g_signal_connect( G_OBJECT(psel), "fillrule_changed",
+ G_CALLBACK(fillruleChangedCB),
+ this );
+ }
+
+ performUpdate();
+}
+
+FillNStroke::~FillNStroke()
+{
+ if (dragId) {
+ g_source_remove(dragId);
+ dragId = 0;
+ }
+ psel = nullptr;
+ selectModifiedConn.disconnect();
+ subselChangedConn.disconnect();
+ selectChangedConn.disconnect();
+ eventContextConn.disconnect();
+}
+
+/**
+ * On signal modified, invokes an update of the fill or stroke style paint object.
+ */
+void FillNStroke::selectionModifiedCB( guint flags )
+{
+ if (flags & SP_OBJECT_STYLE_MODIFIED_FLAG) {
+#ifdef SP_FS_VERBOSE
+ g_message("selectionModifiedCB(%d) on %p", flags, this);
+#endif
+ performUpdate();
+ }
+}
+
+void FillNStroke::setDesktop(SPDesktop *desktop)
+{
+ if (this->desktop != desktop) {
+ if (dragId) {
+ g_source_remove(dragId);
+ dragId = 0;
+ }
+ if (this->desktop) {
+ selectModifiedConn.disconnect();
+ subselChangedConn.disconnect();
+ selectChangedConn.disconnect();
+ eventContextConn.disconnect();
+ }
+ this->desktop = desktop;
+ if (desktop && desktop->selection) {
+ selectChangedConn = desktop->selection->connectChanged(sigc::hide(sigc::mem_fun(*this, &FillNStroke::performUpdate)));
+ subselChangedConn = desktop->connectToolSubselectionChanged(sigc::hide(sigc::mem_fun(*this, &FillNStroke::performUpdate)));
+ eventContextConn = desktop->connectEventContextChanged(sigc::hide(sigc::bind(sigc::mem_fun(*this, &FillNStroke::eventContextCB), (Inkscape::UI::Tools::ToolBase *)nullptr)));
+
+ // Must check flags, so can't call performUpdate() directly.
+ selectModifiedConn = desktop->selection->connectModified(sigc::hide<0>(sigc::mem_fun(*this, &FillNStroke::selectionModifiedCB)));
+ }
+ performUpdate();
+ }
+}
+
+/**
+ * Listen to this "change in tool" event, in case a subselection tool (such as Gradient or Node) selection
+ * is changed back to a selection tool - especially needed for selected gradient stops.
+ */
+void FillNStroke::eventContextCB(SPDesktop * /*desktop*/, Inkscape::UI::Tools::ToolBase * /*eventcontext*/)
+{
+ performUpdate();
+}
+
+
+/**
+ * Gets the active fill or stroke style property, then sets the appropriate
+ * color, alpha, gradient, pattern, etc. for the paint-selector.
+ *
+ * @param sel Selection to use, or NULL.
+ */
+void FillNStroke::performUpdate()
+{
+ if ( update || !desktop ) {
+ return;
+ }
+
+ if ( dragId ) {
+ // local change; do nothing, but reset the flag
+ g_source_remove(dragId);
+ dragId = 0;
+ return;
+ }
+
+ update = true;
+
+ // create temporary style
+ SPStyle query(desktop->doc());
+
+ // query style from desktop into it. This returns a result flag and fills query with the style of subselection, if any, or selection
+ int result = sp_desktop_query_style(desktop, &query, (kind == FILL) ? QUERY_STYLE_PROPERTY_FILL : QUERY_STYLE_PROPERTY_STROKE);
+
+ SPIPaint &targPaint = *query.getFillOrStroke(kind == FILL);
+ SPIScale24 &targOpacity = *(kind == FILL ? query.fill_opacity.upcast() : query.stroke_opacity.upcast());
+
+ switch (result) {
+ case QUERY_STYLE_NOTHING:
+ {
+ /* No paint at all */
+ psel->setMode(SPPaintSelector::MODE_EMPTY);
+ break;
+ }
+
+ case QUERY_STYLE_SINGLE:
+ case QUERY_STYLE_MULTIPLE_AVERAGED: // TODO: treat this slightly differently, e.g. display "averaged" somewhere in paint selector
+ case QUERY_STYLE_MULTIPLE_SAME:
+ {
+ SPPaintSelector::Mode pselmode = SPPaintSelector::getModeForStyle(query, kind);
+ psel->setMode(pselmode);
+
+ if (kind == FILL) {
+ psel->setFillrule(query.fill_rule.computed == ART_WIND_RULE_NONZERO?
+ SPPaintSelector::FILLRULE_NONZERO : SPPaintSelector::FILLRULE_EVENODD);
+ }
+
+ if (targPaint.set && targPaint.isColor()) {
+ psel->setColorAlpha(targPaint.value.color, SP_SCALE24_TO_FLOAT(targOpacity.value));
+ } else if (targPaint.set && targPaint.isPaintserver()) {
+
+ SPPaintServer *server = (kind == FILL) ? query.getFillPaintServer() : query.getStrokePaintServer();
+
+ if (server) {
+ if (SP_IS_GRADIENT(server) && SP_GRADIENT(server)->getVector()->isSwatch()) {
+ SPGradient *vector = SP_GRADIENT(server)->getVector();
+ psel->setSwatch( vector );
+ } else if (SP_IS_LINEARGRADIENT(server)) {
+ SPGradient *vector = SP_GRADIENT(server)->getVector();
+ psel->setGradientLinear( vector );
+
+ SPLinearGradient *lg = SP_LINEARGRADIENT(server);
+ psel->setGradientProperties( lg->getUnits(),
+ lg->getSpread() );
+ } else if (SP_IS_RADIALGRADIENT(server)) {
+ SPGradient *vector = SP_GRADIENT(server)->getVector();
+ psel->setGradientRadial( vector );
+
+ SPRadialGradient *rg = SP_RADIALGRADIENT(server);
+ psel->setGradientProperties( rg->getUnits(),
+ rg->getSpread() );
+#ifdef WITH_MESH
+ } else if (SP_IS_MESHGRADIENT(server)) {
+ SPGradient *array = SP_GRADIENT(server)->getArray();
+ psel->setGradientMesh( SP_MESHGRADIENT(array) );
+ SPMeshGradient *mg = SP_MESHGRADIENT(server);
+ psel->updateMeshList( SP_MESHGRADIENT( array ));
+#endif
+ } else if (SP_IS_PATTERN(server)) {
+ SPPattern *pat = SP_PATTERN(server)->rootPattern();
+ psel->updatePatternList( pat );
+ }
+ }
+ }
+ break;
+ }
+
+ case QUERY_STYLE_MULTIPLE_DIFFERENT:
+ {
+ psel->setMode(SPPaintSelector::MODE_MULTIPLE);
+ break;
+ }
+ }
+
+ update = false;
+}
+
+/**
+ * When the mode is changed, invoke a regular changed handler.
+ */
+void FillNStroke::paintModeChangeCB( SPPaintSelector * /*psel*/,
+ SPPaintSelector::Mode /*mode*/,
+ FillNStroke *self )
+{
+#ifdef SP_FS_VERBOSE
+ g_message("paintModeChangeCB(psel, mode, self:%p)", self);
+#endif
+ if (self && !self->update) {
+ self->updateFromPaint();
+ }
+}
+
+void FillNStroke::fillruleChangedCB( SPPaintSelector * /*psel*/,
+ SPPaintSelector::FillRule mode,
+ FillNStroke *self )
+{
+ if (self) {
+ self->setFillrule(mode);
+ }
+}
+
+void FillNStroke::setFillrule( SPPaintSelector::FillRule mode )
+{
+ if (!update && desktop) {
+ SPCSSAttr *css = sp_repr_css_attr_new();
+ sp_repr_css_set_property(css, "fill-rule", (mode == SPPaintSelector::FILLRULE_EVENODD) ? "evenodd":"nonzero");
+
+ sp_desktop_set_style(desktop, css);
+
+ sp_repr_css_attr_unref(css);
+ css = nullptr;
+
+ DocumentUndo::done(desktop->doc(), SP_VERB_DIALOG_FILL_STROKE,
+ _("Change fill rule"));
+ }
+}
+
+static gchar const *undo_F_label_1 = "fill:flatcolor:1";
+static gchar const *undo_F_label_2 = "fill:flatcolor:2";
+
+static gchar const *undo_S_label_1 = "stroke:flatcolor:1";
+static gchar const *undo_S_label_2 = "stroke:flatcolor:2";
+
+static gchar const *undo_F_label = undo_F_label_1;
+static gchar const *undo_S_label = undo_S_label_1;
+
+
+void FillNStroke::paintDraggedCB(SPPaintSelector * /*psel*/, FillNStroke *self)
+{
+#ifdef SP_FS_VERBOSE
+ g_message("paintDraggedCB(psel, spw:%p)", self);
+#endif
+ if (self && !self->update) {
+ self->dragFromPaint();
+ }
+}
+
+
+gboolean FillNStroke::dragDelayCB(gpointer data)
+{
+ gboolean keepGoing = TRUE;
+ if (data) {
+ FillNStroke *self = reinterpret_cast<FillNStroke*>(data);
+ if (!self->update) {
+ if (self->dragId) {
+ g_source_remove(self->dragId);
+ self->dragId = 0;
+
+ self->dragFromPaint();
+ self->performUpdate();
+ }
+ keepGoing = FALSE;
+ }
+ } else {
+ keepGoing = FALSE;
+ }
+ return keepGoing;
+}
+
+/**
+ * This is called repeatedly while you are dragging a color slider, only for flat color
+ * modes. Previously it set the color in style but did not update the repr for efficiency, however
+ * this was flakey and didn't buy us almost anything. So now it does the same as _changed, except
+ * lumps all its changes for undo.
+ */
+void FillNStroke::dragFromPaint()
+{
+ if (!desktop || update) {
+ return;
+ }
+
+ guint32 when = gtk_get_current_event_time();
+
+ // Don't attempt too many updates per second.
+ // Assume a base 15.625ms resolution on the timer.
+ if (!dragId && lastDrag && when && ((when - lastDrag) < 32)) {
+ // local change, do not update from selection
+ dragId = g_timeout_add_full(G_PRIORITY_DEFAULT, 33, dragDelayCB, this, nullptr);
+ }
+
+ if (dragId) {
+ // previous local flag not cleared yet;
+ // this means dragged events come too fast, so we better skip this one to speed up display
+ // (it's safe to do this in any case)
+ return;
+ }
+ lastDrag = when;
+
+ update = true;
+
+ switch (psel->mode) {
+ case SPPaintSelector::MODE_SOLID_COLOR:
+ {
+ // local change, do not update from selection
+ dragId = g_timeout_add_full(G_PRIORITY_DEFAULT, 100, dragDelayCB, this, nullptr);
+ psel->setFlatColor( desktop, (kind == FILL) ? "fill" : "stroke", (kind == FILL) ? "fill-opacity" : "stroke-opacity" );
+ DocumentUndo::maybeDone(desktop->doc(), (kind == FILL) ? undo_F_label : undo_S_label, SP_VERB_DIALOG_FILL_STROKE,
+ (kind == FILL) ? _("Set fill color") : _("Set stroke color"));
+ break;
+ }
+
+ default:
+ g_warning( "file %s: line %d: Paint %d should not emit 'dragged'",
+ __FILE__, __LINE__, psel->mode );
+ break;
+ }
+ update = false;
+}
+
+/**
+This is called (at least) when:
+1 paint selector mode is switched (e.g. flat color -> gradient)
+2 you finished dragging a gradient node and released mouse
+3 you changed a gradient selector parameter (e.g. spread)
+Must update repr.
+ */
+void FillNStroke::paintChangedCB( SPPaintSelector * /*psel*/, FillNStroke *self )
+{
+#ifdef SP_FS_VERBOSE
+ g_message("paintChangedCB(psel, spw:%p)", self);
+#endif
+ if (self && !self->update) {
+ self->updateFromPaint();
+ }
+}
+
+void FillNStroke::updateFromPaint()
+{
+ if (!desktop) {
+ return;
+ }
+ update = true;
+
+ SPDocument *document = desktop->getDocument();
+ Inkscape::Selection *selection = desktop->getSelection();
+
+ std::vector<SPItem*> const items(selection->items().begin(), selection->items().end());
+
+ switch (psel->mode) {
+ case SPPaintSelector::MODE_EMPTY:
+ // This should not happen.
+ g_warning( "file %s: line %d: Paint %d should not emit 'changed'",
+ __FILE__, __LINE__, psel->mode);
+ break;
+ case SPPaintSelector::MODE_MULTIPLE:
+ // This happens when you switch multiple objects with different gradients to flat color;
+ // nothing to do here.
+ break;
+
+ case SPPaintSelector::MODE_NONE:
+ {
+ SPCSSAttr *css = sp_repr_css_attr_new();
+ sp_repr_css_set_property(css, (kind == FILL) ? "fill" : "stroke", "none");
+
+ sp_desktop_set_style(desktop, css);
+
+ sp_repr_css_attr_unref(css);
+ css = nullptr;
+
+ DocumentUndo::done(document, SP_VERB_DIALOG_FILL_STROKE,
+ (kind == FILL) ? _("Remove fill") : _("Remove stroke"));
+ break;
+ }
+
+ case SPPaintSelector::MODE_SOLID_COLOR:
+ {
+ if (kind == FILL) {
+ // FIXME: fix for GTK breakage, see comment in SelectedStyle::on_opacity_changed; here it results in losing release events
+ desktop->getCanvas()->forceFullRedrawAfterInterruptions(0);
+ }
+
+ psel->setFlatColor( desktop,
+ (kind == FILL) ? "fill" : "stroke",
+ (kind == FILL) ? "fill-opacity" : "stroke-opacity" );
+ DocumentUndo::maybeDone(desktop->getDocument(), (kind == FILL) ? undo_F_label : undo_S_label, SP_VERB_DIALOG_FILL_STROKE,
+ (kind == FILL) ? _("Set fill color") : _("Set stroke color"));
+
+ if (kind == FILL) {
+ // resume interruptibility
+ desktop->getCanvas()->endForcedFullRedraws();
+ }
+
+ // on release, toggle undo_label so that the next drag will not be lumped with this one
+ if (undo_F_label == undo_F_label_1) {
+ undo_F_label = undo_F_label_2;
+ undo_S_label = undo_S_label_2;
+ } else {
+ undo_F_label = undo_F_label_1;
+ undo_S_label = undo_S_label_1;
+ }
+
+ break;
+ }
+
+ case SPPaintSelector::MODE_GRADIENT_LINEAR:
+ case SPPaintSelector::MODE_GRADIENT_RADIAL:
+ case SPPaintSelector::MODE_SWATCH:
+ if (!items.empty()) {
+ SPGradientType const gradient_type = ( psel->mode != SPPaintSelector::MODE_GRADIENT_RADIAL
+ ? SP_GRADIENT_TYPE_LINEAR
+ : SP_GRADIENT_TYPE_RADIAL );
+ bool createSwatch = (psel->mode == SPPaintSelector::MODE_SWATCH);
+
+ SPCSSAttr *css = nullptr;
+ if (kind == FILL) {
+ // HACK: reset fill-opacity - that 0.75 is annoying; BUT remove this when we have an opacity slider for all tabs
+ css = sp_repr_css_attr_new();
+ sp_repr_css_set_property(css, "fill-opacity", "1.0");
+ }
+
+ SPGradient *vector = psel->getGradientVector();
+ if (!vector) {
+ /* No vector in paint selector should mean that we just changed mode */
+
+ SPStyle query(desktop->doc());
+ int result = objects_query_fillstroke(items, &query, kind == FILL);
+ if (result == QUERY_STYLE_MULTIPLE_SAME) {
+ SPIPaint &targPaint = *query.getFillOrStroke(kind == FILL);
+ SPColor common;
+ if (!targPaint.isColor()) {
+ common = sp_desktop_get_color(desktop, kind == FILL);
+ } else {
+ common = targPaint.value.color;
+ }
+ vector = sp_document_default_gradient_vector( document, common, createSwatch );
+ if ( vector && createSwatch ) {
+ vector->setSwatch();
+ }
+ }
+
+ for(auto item : items){
+ //FIXME: see above
+ if (kind == FILL) {
+ sp_repr_css_change_recursive(item->getRepr(), css, "style");
+ }
+
+ if (!vector) {
+ SPGradient *gr = sp_gradient_vector_for_object( document,
+ desktop,
+ reinterpret_cast<SPObject*>(item),
+ (kind == FILL) ? Inkscape::FOR_FILL : Inkscape::FOR_STROKE,
+ createSwatch );
+ if ( gr && createSwatch ) {
+ gr->setSwatch();
+ }
+ sp_item_set_gradient(item,
+ gr,
+ gradient_type, (kind == FILL) ? Inkscape::FOR_FILL : Inkscape::FOR_STROKE);
+ } else {
+ sp_item_set_gradient(item, vector, gradient_type, (kind == FILL) ? Inkscape::FOR_FILL : Inkscape::FOR_STROKE);
+ }
+ }
+ } else {
+ // We have changed from another gradient type, or modified spread/units within
+ // this gradient type.
+ vector = sp_gradient_ensure_vector_normalized(vector);
+ for(auto item : items){
+ //FIXME: see above
+ if (kind == FILL) {
+ sp_repr_css_change_recursive(item->getRepr(), css, "style");
+ }
+
+ SPGradient *gr = sp_item_set_gradient(item, vector, gradient_type, (kind == FILL) ? Inkscape::FOR_FILL : Inkscape::FOR_STROKE);
+ psel->pushAttrsToGradient( gr );
+ }
+ }
+
+ if (css) {
+ sp_repr_css_attr_unref(css);
+ css = nullptr;
+ }
+
+ DocumentUndo::done(document, SP_VERB_DIALOG_FILL_STROKE,
+ (kind == FILL) ? _("Set gradient on fill") : _("Set gradient on stroke"));
+ }
+ break;
+
+#ifdef WITH_MESH
+ case SPPaintSelector::MODE_GRADIENT_MESH:
+
+ if (!items.empty()) {
+ SPGradientType const gradient_type = SP_GRADIENT_TYPE_MESH;
+
+ SPCSSAttr *css = nullptr;
+ if (kind == FILL) {
+ // HACK: reset fill-opacity - that 0.75 is annoying; BUT remove this when we have an opacity slider for all tabs
+ css = sp_repr_css_attr_new();
+ sp_repr_css_set_property(css, "fill-opacity", "1.0");
+ }
+
+ Inkscape::XML::Document *xml_doc = document->getReprDoc();
+ SPDefs *defs = document->getDefs();
+
+ SPMeshGradient * mesh = psel->getMeshGradient();
+
+ for(auto item : items){
+
+ //FIXME: see above
+ if (kind == FILL) {
+ sp_repr_css_change_recursive(item->getRepr(), css, "style");
+ }
+
+ // Check if object already has mesh.
+ bool has_mesh = false;
+ SPStyle *style = item->style;
+ if (style) {
+ SPPaintServer *server =
+ (kind==FILL) ? style->getFillPaintServer():style->getStrokePaintServer();
+ if (server && SP_IS_MESHGRADIENT(server))
+ has_mesh = true;
+ }
+
+ if (!mesh || !has_mesh) {
+ // No mesh in document or object does not already have mesh ->
+ // Create new mesh.
+
+ // Create mesh element
+ Inkscape::XML::Node *repr = xml_doc->createElement("svg:meshgradient");
+
+ // privates are garbage-collectable
+ repr->setAttribute("inkscape:collect", "always");
+
+ // Attach to document
+ defs->getRepr()->appendChild(repr);
+ Inkscape::GC::release(repr);
+
+ // Get corresponding object
+ SPMeshGradient *mg = static_cast<SPMeshGradient *>(document->getObjectByRepr(repr));
+ mg->array.create(mg, item, (kind==FILL) ?
+ item->geometricBounds() : item->visualBounds());
+
+ bool isText = SP_IS_TEXT(item);
+ sp_style_set_property_url (item, ((kind == FILL) ? "fill":"stroke"),
+ mg, isText);
+
+ // (*i)->requestModified(SP_OBJECT_MODIFIED_FLAG|SP_OBJECT_STYLE_MODIFIED_FLAG);
+
+ } else {
+ // Using found mesh
+
+ // Duplicate
+ Inkscape::XML::Node *mesh_repr = mesh->getRepr();
+ Inkscape::XML::Node *copy_repr = mesh_repr->duplicate(xml_doc);
+
+ // privates are garbage-collectable
+ copy_repr->setAttribute("inkscape:collect", "always");
+
+ // Attach to document
+ defs->getRepr()->appendChild(copy_repr);
+ Inkscape::GC::release(copy_repr);
+
+ // Get corresponding object
+ SPMeshGradient *mg =
+ static_cast<SPMeshGradient *>(document->getObjectByRepr(copy_repr));
+ // std::cout << " " << (mg->getId()?mg->getId():"null") << std::endl;
+ mg->array.read(mg);
+
+ Geom::OptRect item_bbox = (kind==FILL) ?
+ item->geometricBounds() : item->visualBounds();
+ mg->array.fill_box( item_bbox );
+
+ bool isText = SP_IS_TEXT(item);
+ sp_style_set_property_url (item, ((kind == FILL) ? "fill":"stroke"),
+ mg, isText);
+ }
+ }
+
+ if (css) {
+ sp_repr_css_attr_unref(css);
+ css = nullptr;
+ }
+
+ DocumentUndo::done(document, SP_VERB_DIALOG_FILL_STROKE,
+ (kind == FILL) ? _("Set mesh on fill") : _("Set mesh on stroke"));
+ }
+ break;
+#endif
+
+ case SPPaintSelector::MODE_PATTERN:
+
+ if (!items.empty()) {
+
+ SPPattern *pattern = psel->getPattern();
+ if (!pattern) {
+
+ /* No Pattern in paint selector should mean that we just
+ * changed mode - don't do jack.
+ */
+
+ } else {
+ Inkscape::XML::Node *patrepr = pattern->getRepr();
+ SPCSSAttr *css = sp_repr_css_attr_new();
+ gchar *urltext = g_strdup_printf("url(#%s)", patrepr->attribute("id"));
+ sp_repr_css_set_property(css, (kind == FILL) ? "fill" : "stroke", urltext);
+
+ // HACK: reset fill-opacity - that 0.75 is annoying; BUT remove this when we have an opacity slider for all tabs
+ if (kind == FILL) {
+ sp_repr_css_set_property(css, "fill-opacity", "1.0");
+ }
+
+ // cannot just call sp_desktop_set_style, because we don't want to touch those
+ // objects who already have the same root pattern but through a different href
+ // chain. FIXME: move this to a sp_item_set_pattern
+ for(auto item : items){
+ Inkscape::XML::Node *selrepr = item->getRepr();
+ if ( (kind == STROKE) && !selrepr) {
+ continue;
+ }
+ SPObject *selobj = item;
+
+ SPStyle *style = selobj->style;
+ if (style && ((kind == FILL) ? style->fill.isPaintserver() : style->stroke.isPaintserver())) {
+ SPPaintServer *server = (kind == FILL) ?
+ selobj->style->getFillPaintServer() :
+ selobj->style->getStrokePaintServer();
+ if (SP_IS_PATTERN(server) && SP_PATTERN(server)->rootPattern() == pattern)
+ // only if this object's pattern is not rooted in our selected pattern, apply
+ continue;
+ }
+
+ if (kind == FILL) {
+ sp_desktop_apply_css_recursive(selobj, css, true);
+ } else {
+ sp_repr_css_change_recursive(selrepr, css, "style");
+ }
+ }
+
+ sp_repr_css_attr_unref(css);
+ css = nullptr;
+ g_free(urltext);
+
+ } // end if
+
+ DocumentUndo::done(document, SP_VERB_DIALOG_FILL_STROKE,
+ (kind == FILL) ? _("Set pattern on fill") :
+ _("Set pattern on stroke"));
+ } // end if
+
+ break;
+
+ case SPPaintSelector::MODE_UNSET:
+ if (!items.empty()) {
+ SPCSSAttr *css = sp_repr_css_attr_new();
+ if (kind == FILL) {
+ sp_repr_css_unset_property(css, "fill");
+ } else {
+ sp_repr_css_unset_property(css, "stroke");
+ sp_repr_css_unset_property(css, "stroke-opacity");
+ sp_repr_css_unset_property(css, "stroke-width");
+ sp_repr_css_unset_property(css, "stroke-miterlimit");
+ sp_repr_css_unset_property(css, "stroke-linejoin");
+ sp_repr_css_unset_property(css, "stroke-linecap");
+ sp_repr_css_unset_property(css, "stroke-dashoffset");
+ sp_repr_css_unset_property(css, "stroke-dasharray");
+ }
+
+ sp_desktop_set_style(desktop, css);
+ sp_repr_css_attr_unref(css);
+ css = nullptr;
+
+ DocumentUndo::done(document, SP_VERB_DIALOG_FILL_STROKE,
+ (kind == FILL) ? _("Unset fill") : _("Unset stroke"));
+ }
+ break;
+
+ default:
+ g_warning( "file %s: line %d: Paint selector should not be in "
+ "mode %d",
+ __FILE__, __LINE__,
+ psel->mode );
+ break;
+ }
+
+ update = false;
+}
+
+} // namespace Inkscape
+
+/*
+ Local Variables:
+ mode:c++
+ c-file-style:"stroustrup"
+ c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
+ indent-tabs-mode:nil
+ fill-column:99
+ End:
+*/
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :
diff --git a/src/widgets/fill-style.h b/src/widgets/fill-style.h
new file mode 100644
index 0000000..3a64f2c
--- /dev/null
+++ b/src/widgets/fill-style.h
@@ -0,0 +1,39 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/** @file
+ * @brief Fill style configuration
+ */
+/* Authors:
+ * Lauris Kaplinski <lauris@kaplinski.com>
+ * Jon A. Cruz <jon@joncruz.org>
+ *
+ * Copyright (C) 2010 Jon A. Cruz
+ * Copyright (C) 2002 Lauris Kaplinski
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#ifndef SEEN_DIALOGS_SP_FILL_STYLE_H
+#define SEEN_DIALOGS_SP_FILL_STYLE_H
+
+namespace Gtk {
+class Widget;
+}
+
+class SPDesktop;
+
+Gtk::Widget *sp_fill_style_widget_new();
+
+void sp_fill_style_widget_set_desktop(Gtk::Widget *widget, SPDesktop *desktop);
+
+#endif // SEEN_DIALOGS_SP_FILL_STYLE_H
+
+/*
+ Local Variables:
+ mode:c++
+ c-file-style:"stroustrup"
+ c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
+ indent-tabs-mode:nil
+ fill-column:99
+ End:
+*/
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :
diff --git a/src/widgets/gradient-image.cpp b/src/widgets/gradient-image.cpp
new file mode 100644
index 0000000..1a0e253
--- /dev/null
+++ b/src/widgets/gradient-image.cpp
@@ -0,0 +1,285 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/**
+ * A simple gradient preview
+ *
+ * Author:
+ * Lauris Kaplinski <lauris@kaplinski.com>
+ *
+ * Copyright (C) 2001-2002 Lauris Kaplinski
+ * Copyright (C) 2001 Ximian, Inc.
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#include <sigc++/sigc++.h>
+
+#include <glibmm/refptr.h>
+#include <gdkmm/pixbuf.h>
+
+#include <cairomm/surface.h>
+
+#include "gradient-image.h"
+
+#include "display/cairo-utils.h"
+
+#include "object/sp-gradient.h"
+#include "object/sp-stop.h"
+
+static void sp_gradient_image_size_request (GtkWidget *widget, GtkRequisition *requisition);
+
+static void sp_gradient_image_destroy(GtkWidget *object);
+static void sp_gradient_image_get_preferred_width(GtkWidget *widget,
+ gint *minimal_width,
+ gint *natural_width);
+
+static void sp_gradient_image_get_preferred_height(GtkWidget *widget,
+ gint *minimal_height,
+ gint *natural_height);
+static gboolean sp_gradient_image_draw(GtkWidget *widget, cairo_t *cr);
+static void sp_gradient_image_gradient_release (SPObject *, SPGradientImage *im);
+static void sp_gradient_image_gradient_modified (SPObject *, guint flags, SPGradientImage *im);
+static void sp_gradient_image_update (SPGradientImage *img);
+
+G_DEFINE_TYPE(SPGradientImage, sp_gradient_image, GTK_TYPE_WIDGET);
+
+static void sp_gradient_image_class_init(SPGradientImageClass *klass)
+{
+ GtkWidgetClass *widget_class = GTK_WIDGET_CLASS(klass);
+
+ widget_class->get_preferred_width = sp_gradient_image_get_preferred_width;
+ widget_class->get_preferred_height = sp_gradient_image_get_preferred_height;
+ widget_class->draw = sp_gradient_image_draw;
+ widget_class->destroy = sp_gradient_image_destroy;
+}
+
+static void
+sp_gradient_image_init (SPGradientImage *image)
+{
+ gtk_widget_set_has_window (GTK_WIDGET(image), FALSE);
+
+ image->gradient = nullptr;
+
+ new (&image->release_connection) sigc::connection();
+ new (&image->modified_connection) sigc::connection();
+}
+
+static void sp_gradient_image_destroy(GtkWidget *object)
+{
+ SPGradientImage *image = SP_GRADIENT_IMAGE (object);
+
+ if (image->gradient) {
+ image->release_connection.disconnect();
+ image->modified_connection.disconnect();
+ image->gradient = nullptr;
+ }
+
+ image->release_connection.~connection();
+ image->modified_connection.~connection();
+
+ if (GTK_WIDGET_CLASS(sp_gradient_image_parent_class)->destroy)
+ GTK_WIDGET_CLASS(sp_gradient_image_parent_class)->destroy(object);
+}
+
+static void sp_gradient_image_size_request(GtkWidget * /*widget*/, GtkRequisition *requisition)
+{
+ requisition->width = 54;
+ requisition->height = 12;
+}
+
+static void sp_gradient_image_get_preferred_width(GtkWidget *widget, gint *minimal_width, gint *natural_width)
+{
+ GtkRequisition requisition;
+ sp_gradient_image_size_request(widget, &requisition);
+ *minimal_width = *natural_width = requisition.width;
+}
+
+static void sp_gradient_image_get_preferred_height(GtkWidget *widget, gint *minimal_height, gint *natural_height)
+{
+ GtkRequisition requisition;
+ sp_gradient_image_size_request(widget, &requisition);
+ *minimal_height = *natural_height = requisition.height;
+}
+
+static gboolean sp_gradient_image_draw(GtkWidget *widget, cairo_t *ct)
+{
+ SPGradientImage *image = SP_GRADIENT_IMAGE(widget);
+ SPGradient *gr = image->gradient;
+ GtkAllocation allocation;
+ gtk_widget_get_allocation(widget, &allocation);
+
+ cairo_pattern_t *check = ink_cairo_pattern_create_checkerboard();
+ cairo_set_source(ct, check);
+ cairo_paint(ct);
+ cairo_pattern_destroy(check);
+
+ if (gr) {
+ cairo_pattern_t *p = gr->create_preview_pattern(allocation.width);
+ cairo_set_source(ct, p);
+ cairo_paint(ct);
+ cairo_pattern_destroy(p);
+ }
+
+ return TRUE;
+}
+
+GtkWidget *
+sp_gradient_image_new (SPGradient *gradient)
+{
+ SPGradientImage *image = SP_GRADIENT_IMAGE(g_object_new(SP_TYPE_GRADIENT_IMAGE, nullptr));
+
+ sp_gradient_image_set_gradient (image, gradient);
+
+ return GTK_WIDGET(image);
+}
+
+GdkPixbuf*
+sp_gradient_to_pixbuf (SPGradient *gr, int width, int height)
+{
+ cairo_surface_t *s = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, width, height);
+ cairo_t *ct = cairo_create(s);
+
+ cairo_pattern_t *check = ink_cairo_pattern_create_checkerboard();
+ cairo_set_source(ct, check);
+ cairo_paint(ct);
+ cairo_pattern_destroy(check);
+
+ if (gr) {
+ cairo_pattern_t *p = gr->create_preview_pattern(width);
+ cairo_set_source(ct, p);
+ cairo_paint(ct);
+ cairo_pattern_destroy(p);
+ }
+
+ cairo_destroy(ct);
+ cairo_surface_flush(s);
+
+ // no need to free s - the call below takes ownership
+ GdkPixbuf *pixbuf = ink_pixbuf_create_from_cairo_surface(s);
+ return pixbuf;
+}
+
+
+Glib::RefPtr<Gdk::Pixbuf>
+sp_gradient_to_pixbuf_ref (SPGradient *gr, int width, int height)
+{
+ cairo_surface_t *s = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, width, height);
+ cairo_t *ct = cairo_create(s);
+
+ cairo_pattern_t *check = ink_cairo_pattern_create_checkerboard();
+ cairo_set_source(ct, check);
+ cairo_paint(ct);
+ cairo_pattern_destroy(check);
+
+ if (gr) {
+ cairo_pattern_t *p = gr->create_preview_pattern(width);
+ cairo_set_source(ct, p);
+ cairo_paint(ct);
+ cairo_pattern_destroy(p);
+ }
+
+ cairo_destroy(ct);
+ cairo_surface_flush(s);
+
+ Cairo::RefPtr<Cairo::Surface> sref = Cairo::RefPtr<Cairo::Surface>(new Cairo::Surface(s));
+ Glib::RefPtr<Gdk::Pixbuf> pixbuf =
+ Gdk::Pixbuf::create(sref, 0, 0, width, height);
+
+ cairo_surface_destroy(s);
+
+ return pixbuf;
+}
+
+
+Glib::RefPtr<Gdk::Pixbuf>
+sp_gradstop_to_pixbuf_ref (SPStop *stop, int width, int height)
+{
+ cairo_surface_t *s = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, width, height);
+ cairo_t *ct = cairo_create(s);
+
+ /* Checkerboard background */
+ cairo_pattern_t *check = ink_cairo_pattern_create_checkerboard();
+ cairo_rectangle(ct, 0, 0, width, height);
+ cairo_set_source(ct, check);
+ cairo_fill_preserve(ct);
+ cairo_pattern_destroy(check);
+
+ if (stop) {
+ /* Alpha area */
+ cairo_rectangle(ct, 0, 0, width/2, height);
+ ink_cairo_set_source_rgba32(ct, stop->get_rgba32());
+ cairo_fill(ct);
+
+ /* Solid area */
+ cairo_rectangle(ct, width/2, 0, width, height);
+ ink_cairo_set_source_rgba32(ct, stop->get_rgba32() | 0xff);
+ cairo_fill(ct);
+ }
+
+ cairo_destroy(ct);
+ cairo_surface_flush(s);
+
+ Cairo::RefPtr<Cairo::Surface> sref = Cairo::RefPtr<Cairo::Surface>(new Cairo::Surface(s));
+ Glib::RefPtr<Gdk::Pixbuf> pixbuf =
+ Gdk::Pixbuf::create(sref, 0, 0, width, height);
+
+ cairo_surface_destroy(s);
+
+ return pixbuf;
+}
+
+
+void
+sp_gradient_image_set_gradient (SPGradientImage *image, SPGradient *gradient)
+{
+ if (image->gradient) {
+ image->release_connection.disconnect();
+ image->modified_connection.disconnect();
+ }
+
+ image->gradient = gradient;
+
+ if (gradient) {
+ image->release_connection = gradient->connectRelease(sigc::bind<1>(sigc::ptr_fun(&sp_gradient_image_gradient_release), image));
+ image->modified_connection = gradient->connectModified(sigc::bind<2>(sigc::ptr_fun(&sp_gradient_image_gradient_modified), image));
+ }
+
+ sp_gradient_image_update (image);
+}
+
+static void
+sp_gradient_image_gradient_release (SPObject *, SPGradientImage *image)
+{
+ if (image->gradient) {
+ image->release_connection.disconnect();
+ image->modified_connection.disconnect();
+ }
+
+ image->gradient = nullptr;
+
+ sp_gradient_image_update (image);
+}
+
+static void
+sp_gradient_image_gradient_modified (SPObject *, guint /*flags*/, SPGradientImage *image)
+{
+ sp_gradient_image_update (image);
+}
+
+static void
+sp_gradient_image_update (SPGradientImage *image)
+{
+ if (gtk_widget_is_drawable (GTK_WIDGET(image))) {
+ gtk_widget_queue_draw (GTK_WIDGET (image));
+ }
+}
+
+/*
+ Local Variables:
+ mode:c++
+ c-file-style:"stroustrup"
+ c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
+ indent-tabs-mode:nil
+ fill-column:99
+ End:
+*/
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8 :
diff --git a/src/widgets/gradient-image.h b/src/widgets/gradient-image.h
new file mode 100644
index 0000000..4fcc4ca
--- /dev/null
+++ b/src/widgets/gradient-image.h
@@ -0,0 +1,65 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+#ifndef SEEN_SP_GRADIENT_IMAGE_H
+#define SEEN_SP_GRADIENT_IMAGE_H
+
+/**
+ * A simple gradient preview
+ *
+ * Author:
+ * Lauris Kaplinski <lauris@kaplinski.com>
+ *
+ * Copyright (C) 2001-2002 Lauris Kaplinski
+ * Copyright (C) 2001 Ximian, Inc.
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#include <gtk/gtk.h>
+#include <glibmm/refptr.h>
+
+class SPGradient;
+class SPStop;
+namespace Gdk {
+ class Pixbuf;
+}
+
+#include <sigc++/connection.h>
+
+#define SP_TYPE_GRADIENT_IMAGE (sp_gradient_image_get_type ())
+#define SP_GRADIENT_IMAGE(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), SP_TYPE_GRADIENT_IMAGE, SPGradientImage))
+#define SP_GRADIENT_IMAGE_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), SP_TYPE_GRADIENT_IMAGE, SPGradientImageClass))
+#define SP_IS_GRADIENT_IMAGE(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), SP_TYPE_GRADIENT_IMAGE))
+#define SP_IS_GRADIENT_IMAGE_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), SP_TYPE_GRADIENT_IMAGE))
+
+struct SPGradientImage {
+ GtkWidget widget;
+ SPGradient *gradient;
+
+ sigc::connection release_connection;
+ sigc::connection modified_connection;
+};
+
+struct SPGradientImageClass {
+ GtkWidgetClass parent_class;
+};
+
+GType sp_gradient_image_get_type ();
+
+GtkWidget *sp_gradient_image_new (SPGradient *gradient);
+GdkPixbuf *sp_gradient_to_pixbuf (SPGradient *gr, int width, int height);
+Glib::RefPtr<Gdk::Pixbuf> sp_gradient_to_pixbuf_ref (SPGradient *gr, int width, int height);
+Glib::RefPtr<Gdk::Pixbuf> sp_gradstop_to_pixbuf_ref (SPStop *gr, int width, int height);
+void sp_gradient_image_set_gradient (SPGradientImage *gi, SPGradient *gr);
+
+#endif
+
+/*
+ Local Variables:
+ mode:c++
+ c-file-style:"stroustrup"
+ c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
+ indent-tabs-mode:nil
+ fill-column:99
+ End:
+*/
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8 :
diff --git a/src/widgets/gradient-selector.cpp b/src/widgets/gradient-selector.cpp
new file mode 100644
index 0000000..387f077
--- /dev/null
+++ b/src/widgets/gradient-selector.cpp
@@ -0,0 +1,660 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * Gradient vector widget
+ *
+ * Authors:
+ * Lauris Kaplinski <lauris@kaplinski.com>
+ * bulia byak <buliabyak@users.sf.net>
+ * Jon A. Cruz <jon@joncruz.org>
+ *
+ * Copyright (C) 2001-2002 Lauris Kaplinski
+ * Copyright (C) 2001 Ximian, Inc.
+ * Copyright (C) 2010 Jon A. Cruz
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#include <glibmm/i18n.h>
+#include <gtkmm/treeview.h>
+#include <vector>
+
+#include "document-undo.h"
+#include "document.h"
+#include "gradient-chemistry.h"
+#include "gradient-vector.h"
+#include "id-clash.h"
+#include "inkscape.h"
+#include "paint-selector.h"
+#include "preferences.h"
+#include "verbs.h"
+
+#include "object/sp-defs.h"
+#include "style.h"
+
+#include "helper/action.h"
+#include "ui/icon-loader.h"
+
+#include "ui/icon-names.h"
+
+enum {
+ GRABBED,
+ DRAGGED,
+ RELEASED,
+ CHANGED,
+ LAST_SIGNAL
+};
+
+
+static void sp_gradient_selector_dispose(GObject *object);
+
+/* Signal handlers */
+static void sp_gradient_selector_vector_set (SPGradientVectorSelector *gvs, SPGradient *gr, SPGradientSelector *sel);
+static void sp_gradient_selector_edit_vector_clicked (GtkWidget *w, SPGradientSelector *sel);
+static void sp_gradient_selector_add_vector_clicked (GtkWidget *w, SPGradientSelector *sel);
+static void sp_gradient_selector_delete_vector_clicked (GtkWidget *w, SPGradientSelector *sel);
+
+static guint signals[LAST_SIGNAL] = {0};
+
+G_DEFINE_TYPE(SPGradientSelector, sp_gradient_selector, GTK_TYPE_BOX);
+
+static void sp_gradient_selector_class_init(SPGradientSelectorClass *klass)
+{
+ GObjectClass *object_class = G_OBJECT_CLASS(klass);
+
+ signals[GRABBED] = g_signal_new ("grabbed",
+ G_TYPE_FROM_CLASS(object_class),
+ (GSignalFlags)(G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE),
+ G_STRUCT_OFFSET (SPGradientSelectorClass, grabbed),
+ nullptr, nullptr,
+ g_cclosure_marshal_VOID__VOID,
+ G_TYPE_NONE, 0);
+ signals[DRAGGED] = g_signal_new ("dragged",
+ G_TYPE_FROM_CLASS(object_class),
+ (GSignalFlags)(G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE),
+ G_STRUCT_OFFSET (SPGradientSelectorClass, dragged),
+ nullptr, nullptr,
+ g_cclosure_marshal_VOID__VOID,
+ G_TYPE_NONE, 0);
+ signals[RELEASED] = g_signal_new ("released",
+ G_TYPE_FROM_CLASS(object_class),
+ (GSignalFlags)(G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE),
+ G_STRUCT_OFFSET (SPGradientSelectorClass, released),
+ nullptr, nullptr,
+ g_cclosure_marshal_VOID__VOID,
+ G_TYPE_NONE, 0);
+ signals[CHANGED] = g_signal_new ("changed",
+ G_TYPE_FROM_CLASS(object_class),
+ (GSignalFlags)(G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE),
+ G_STRUCT_OFFSET (SPGradientSelectorClass, changed),
+ nullptr, nullptr,
+ g_cclosure_marshal_VOID__VOID,
+ G_TYPE_NONE, 0);
+
+ object_class->dispose = sp_gradient_selector_dispose;
+}
+
+static void gradsel_style_button(GtkWidget *gtkbtn, char const *iconName)
+{
+ Gtk::Button *btn = Glib::wrap(GTK_BUTTON(gtkbtn));
+ GtkWidget *child = sp_get_icon_image(iconName, GTK_ICON_SIZE_SMALL_TOOLBAR);
+ gtk_widget_show(child);
+ btn->add(*manage(Glib::wrap(child)));
+ btn->set_relief(Gtk::RELIEF_NONE);
+}
+
+static void sp_gradient_selector_init(SPGradientSelector *sel)
+{
+ sel->safelyInit = true;
+ sel->blocked = false;
+
+ gtk_orientable_set_orientation(GTK_ORIENTABLE(sel), GTK_ORIENTATION_VERTICAL);
+
+ new (&sel->nonsolid) std::vector<GtkWidget*>();
+ new (&sel->swatch_widgets) std::vector<GtkWidget*>();
+
+ sel->mode = SPGradientSelector::MODE_LINEAR;
+
+ sel->gradientUnits = SP_GRADIENT_UNITS_USERSPACEONUSE;
+ sel->gradientSpread = SP_GRADIENT_SPREAD_PAD;
+
+ /* Vectors */
+ sel->vectors = sp_gradient_vector_selector_new (nullptr, nullptr);
+ SPGradientVectorSelector *gvs = SP_GRADIENT_VECTOR_SELECTOR(sel->vectors);
+ sel->store = gvs->store;
+ sel->columns = gvs->columns;
+
+ sel->treeview = Gtk::manage(new Gtk::TreeView());
+ sel->treeview->set_model(gvs->store);
+ sel->treeview->set_headers_clickable (true);
+ sel->treeview->set_search_column(1);
+ sel->treeview->set_vexpand();
+ sel->icon_renderer = Gtk::manage(new Gtk::CellRendererPixbuf());
+ sel->text_renderer = Gtk::manage(new Gtk::CellRendererText());
+
+ sel->treeview->append_column(_("Gradient"), *sel->icon_renderer);
+ Gtk::TreeView::Column* icon_column = sel->treeview->get_column(0);
+ icon_column->add_attribute(sel->icon_renderer->property_pixbuf(), sel->columns->pixbuf);
+ icon_column->set_sort_column(sel->columns->color);
+ icon_column->set_clickable(true);
+
+ sel->treeview->append_column(_("Name"), *sel->text_renderer);
+ Gtk::TreeView::Column* name_column = sel->treeview->get_column(1);
+ sel->text_renderer->property_editable() = true;
+ name_column->add_attribute(sel->text_renderer->property_text(), sel->columns->name);
+ name_column->set_min_width(180);
+ name_column->set_clickable(true);
+ name_column->set_resizable(true);
+
+ sel->treeview->append_column("#", sel->columns->refcount);
+ Gtk::TreeView::Column* count_column = sel->treeview->get_column(2);
+ count_column->set_clickable(true);
+ count_column->set_resizable(true);
+
+ sel->treeview->signal_key_press_event().connect(sigc::mem_fun(*sel, &SPGradientSelector::onKeyPressEvent), false);
+
+ sel->treeview->show();
+
+ icon_column->signal_clicked().connect( sigc::mem_fun(*sel, &SPGradientSelector::onTreeColorColClick) );
+ name_column->signal_clicked().connect( sigc::mem_fun(*sel, &SPGradientSelector::onTreeNameColClick) );
+ count_column->signal_clicked().connect( sigc::mem_fun(*sel, &SPGradientSelector::onTreeCountColClick) );
+
+ gvs->tree_select_connection = sel->treeview->get_selection()->signal_changed().connect( sigc::mem_fun(*sel, &SPGradientSelector::onTreeSelection) );
+ sel->text_renderer->signal_edited().connect( sigc::mem_fun(*sel, &SPGradientSelector::onGradientRename) );
+
+ sel->scrolled_window = Gtk::manage(new Gtk::ScrolledWindow());
+ sel->scrolled_window->add(*sel->treeview);
+ sel->scrolled_window->set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
+ sel->scrolled_window->set_shadow_type(Gtk::SHADOW_IN);
+ sel->scrolled_window->set_size_request(0, 180);
+ sel->scrolled_window->set_hexpand();
+ sel->scrolled_window->show();
+
+ gtk_box_pack_start (GTK_BOX (sel), GTK_WIDGET(sel->scrolled_window->gobj()), TRUE, TRUE, 4);
+
+
+ /* Create box for buttons */
+ auto hb = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
+ gtk_box_set_homogeneous(GTK_BOX(hb), FALSE);
+ gtk_box_pack_start( GTK_BOX(sel), hb, FALSE, FALSE, 0 );
+
+ sel->add = gtk_button_new();
+ gradsel_style_button(sel->add, INKSCAPE_ICON("list-add"));
+
+ sel->nonsolid.push_back(sel->add);
+ gtk_box_pack_start (GTK_BOX (hb), sel->add, FALSE, FALSE, 0);
+
+ g_signal_connect (G_OBJECT (sel->add), "clicked", G_CALLBACK (sp_gradient_selector_add_vector_clicked), sel);
+ gtk_widget_set_sensitive (sel->add, FALSE);
+ gtk_button_set_relief(GTK_BUTTON(sel->add), GTK_RELIEF_NONE);
+ gtk_widget_set_tooltip_text( sel->add, _("Create a duplicate gradient"));
+
+ sel->edit = gtk_button_new();
+ gradsel_style_button(sel->edit, INKSCAPE_ICON("edit"));
+
+ sel->nonsolid.push_back(sel->edit);
+ gtk_box_pack_start (GTK_BOX (hb), sel->edit, FALSE, FALSE, 0);
+ g_signal_connect (G_OBJECT (sel->edit), "clicked", G_CALLBACK (sp_gradient_selector_edit_vector_clicked), sel);
+ gtk_widget_set_sensitive (sel->edit, FALSE);
+ gtk_button_set_relief(GTK_BUTTON(sel->edit), GTK_RELIEF_NONE);
+ gtk_widget_set_tooltip_text( sel->edit, _("Edit gradient"));
+
+ sel->del = gtk_button_new ();
+ gradsel_style_button(sel->del, INKSCAPE_ICON("list-remove"));
+
+ sel->swatch_widgets.push_back(sel->del);
+ gtk_box_pack_start (GTK_BOX (hb), sel->del, FALSE, FALSE, 0);
+ g_signal_connect (G_OBJECT (sel->del), "clicked", G_CALLBACK (sp_gradient_selector_delete_vector_clicked), sel);
+ gtk_widget_set_sensitive (sel->del, FALSE);
+ gtk_button_set_relief(GTK_BUTTON(sel->del), GTK_RELIEF_NONE);
+ gtk_widget_set_tooltip_text( sel->del, _("Delete swatch"));
+
+ gtk_widget_show_all(hb);
+}
+
+static void sp_gradient_selector_dispose(GObject *object)
+{
+ SPGradientSelector *sel = SP_GRADIENT_SELECTOR( object );
+
+ if ( sel->safelyInit ) {
+ sel->safelyInit = false;
+ sel->nonsolid.~vector<GtkWidget*>();
+ sel->swatch_widgets.~vector<GtkWidget*>();
+ }
+
+ if (sel->icon_renderer) {
+ delete sel->icon_renderer;
+ sel->icon_renderer = nullptr;
+ }
+ if (sel->text_renderer) {
+ delete sel->text_renderer;
+ sel->text_renderer = nullptr;
+ }
+
+ if ((G_OBJECT_CLASS(sp_gradient_selector_parent_class))->dispose) {
+ (G_OBJECT_CLASS(sp_gradient_selector_parent_class))->dispose(object);
+ }
+}
+
+void SPGradientSelector::setSpread(SPGradientSpread spread)
+{
+ gradientSpread = spread;
+ //gtk_combo_box_set_active (GTK_COMBO_BOX(this->spread), gradientSpread);
+}
+
+
+GtkWidget *sp_gradient_selector_new()
+{
+ SPGradientSelector *sel = SP_GRADIENT_SELECTOR(g_object_new (SP_TYPE_GRADIENT_SELECTOR, nullptr));
+
+ return GTK_WIDGET(sel);
+}
+
+void SPGradientSelector::setMode(SelectorMode mode)
+{
+ if (mode != this->mode) {
+ this->mode = mode;
+ if (mode == MODE_SWATCH) {
+ for (auto & it : nonsolid)
+ {
+ gtk_widget_hide(it);
+ }
+ for (auto & swatch_widget : swatch_widgets)
+ {
+ gtk_widget_show_all(swatch_widget);
+ }
+
+ Gtk::TreeView::Column* icon_column = treeview->get_column(0);
+ icon_column->set_title(_("Swatch"));
+
+ SPGradientVectorSelector* vs = SP_GRADIENT_VECTOR_SELECTOR(vectors);
+ vs->setSwatched();
+ } else {
+ for (auto & it : nonsolid)
+ {
+ gtk_widget_show_all(it);
+ }
+ for (auto & swatch_widget : swatch_widgets)
+ {
+ gtk_widget_hide(swatch_widget);
+ }
+ Gtk::TreeView::Column* icon_column = treeview->get_column(0);
+ icon_column->set_title(_("Gradient"));
+
+ }
+ }
+}
+
+void SPGradientSelector::setUnits(SPGradientUnits units)
+{
+ gradientUnits = units;
+}
+
+SPGradientUnits SPGradientSelector::getUnits()
+{
+ return gradientUnits;
+}
+
+SPGradientSpread SPGradientSelector::getSpread()
+{
+ return gradientSpread;
+}
+
+void SPGradientSelector::onGradientRename( const Glib::ustring& path_string, const Glib::ustring& new_text)
+{
+ Gtk::TreePath path(path_string);
+ Gtk::TreeModel::iterator iter = store->get_iter(path);
+
+ if( iter )
+ {
+ Gtk::TreeModel::Row row = *iter;
+ if ( row ) {
+ SPObject* obj = row[columns->data];
+ if ( obj ) {
+ row[columns->name] = gr_prepare_label(obj);
+ if (!new_text.empty() && new_text != row[columns->name]) {
+ rename_id(obj, new_text );
+ Inkscape::DocumentUndo::done(obj->document, SP_VERB_CONTEXT_GRADIENT,
+ _("Rename gradient"));
+ }
+ }
+ }
+ }
+}
+
+void SPGradientSelector::onTreeColorColClick() {
+ Gtk::TreeView::Column* column = treeview->get_column(0);
+ column->set_sort_column(columns->color);
+}
+
+void SPGradientSelector::onTreeNameColClick() {
+ Gtk::TreeView::Column* column = treeview->get_column(1);
+ column->set_sort_column(columns->name);
+}
+
+
+void SPGradientSelector::onTreeCountColClick() {
+ Gtk::TreeView::Column* column = treeview->get_column(2);
+ column->set_sort_column(columns->refcount);
+}
+
+void SPGradientSelector::moveSelection(int amount, bool down, bool toEnd)
+{
+ Glib::RefPtr<Gtk::TreeSelection> select = treeview->get_selection();
+ auto iter = select->get_selected();
+
+ if (amount < 0) {
+ down = !down;
+ amount = -amount;
+ }
+
+ auto canary = iter;
+ if (down) {
+ ++canary;
+ } else {
+ --canary;
+ }
+ while (canary && (toEnd || amount > 0)) {
+ --amount;
+ if (down) {
+ ++canary;
+ ++iter;
+ } else {
+ --canary;
+ --iter;
+ }
+ }
+
+ select->select(iter);
+ treeview->scroll_to_row(store->get_path(iter), 0.5);
+}
+
+bool SPGradientSelector::onKeyPressEvent(GdkEventKey *event)
+{
+ bool consume = false;
+ auto display = Gdk::Display::get_default();
+ auto keymap = display->get_keymap();
+ guint key = 0;
+ gdk_keymap_translate_keyboard_state(keymap, event->hardware_keycode,
+ static_cast<GdkModifierType>(event->state),
+ 0, &key, 0, 0, 0);
+
+ switch (key) {
+ case GDK_KEY_Up:
+ case GDK_KEY_KP_Up: {
+ moveSelection(-1);
+ consume = true;
+ break;
+ }
+ case GDK_KEY_Down:
+ case GDK_KEY_KP_Down: {
+ moveSelection(1);
+ consume = true;
+ break;
+ }
+ case GDK_KEY_Page_Up:
+ case GDK_KEY_KP_Page_Up: {
+ moveSelection(-5);
+ consume = true;
+ break;
+ }
+
+ case GDK_KEY_Page_Down:
+ case GDK_KEY_KP_Page_Down: {
+ moveSelection(5);
+ consume = true;
+ break;
+ }
+
+ case GDK_KEY_End:
+ case GDK_KEY_KP_End: {
+ moveSelection(0, true, true);
+ consume = true;
+ break;
+ }
+
+ case GDK_KEY_Home:
+ case GDK_KEY_KP_Home: {
+ moveSelection(0, false, true);
+ consume = true;
+ break;
+ }
+ }
+ return consume;
+}
+
+void SPGradientSelector::onTreeSelection()
+{
+ if (!treeview) {
+ return;
+ }
+
+ if (blocked) {
+ return;
+ }
+
+ if (!treeview->has_focus()) {
+ /* Workaround for GTK bug on Windows/OS X
+ * When the treeview initially doesn't have focus and is clicked
+ * sometimes get_selection()->signal_changed() has the wrong selection
+ */
+ treeview->grab_focus();
+ }
+
+ const Glib::RefPtr<Gtk::TreeSelection> sel = treeview->get_selection();
+ if (!sel) {
+ return;
+ }
+
+ SPGradient *obj = nullptr;
+ /* Single selection */
+ Gtk::TreeModel::iterator iter = sel->get_selected();
+ if ( iter ) {
+ Gtk::TreeModel::Row row = *iter;
+ obj = row[columns->data];
+ }
+
+ if (obj) {
+ sp_gradient_selector_vector_set (nullptr, SP_GRADIENT(obj), this);
+ }
+}
+
+bool SPGradientSelector::_checkForSelected(const Gtk::TreePath &path, const Gtk::TreeIter& iter, SPGradient *vector)
+{
+ bool found = false;
+
+ Gtk::TreeModel::Row row = *iter;
+ if ( vector == row[columns->data] )
+ {
+ treeview->scroll_to_row(path, 0.5);
+ Glib::RefPtr<Gtk::TreeSelection> select = treeview->get_selection();
+ bool wasBlocked = blocked;
+ blocked = true;
+ select->select(iter);
+ blocked = wasBlocked;
+ found = true;
+ }
+
+ return found;
+}
+
+void SPGradientSelector::selectGradientInTree(SPGradient *vector)
+{
+ store->foreach( sigc::bind<SPGradient*>(sigc::mem_fun(*this, &SPGradientSelector::_checkForSelected), vector) );
+}
+
+void SPGradientSelector::setVector(SPDocument *doc, SPGradient *vector)
+{
+ g_return_if_fail(!vector || SP_IS_GRADIENT(vector));
+ g_return_if_fail(!vector || (vector->document == doc));
+
+ if (vector && !vector->hasStops()) {
+ return;
+ }
+
+ sp_gradient_vector_selector_set_gradient(SP_GRADIENT_VECTOR_SELECTOR(vectors), doc, vector);
+
+ selectGradientInTree(vector);
+
+ if (vector) {
+ if ( (mode == MODE_SWATCH) && vector->isSwatch() ) {
+ if ( vector->isSolid() ) {
+ for (auto & it : nonsolid)
+ {
+ gtk_widget_hide(it);
+ }
+ } else {
+ for (auto & it : nonsolid)
+ {
+ gtk_widget_show_all(it);
+ }
+ }
+ } else if (mode != MODE_SWATCH) {
+
+ for (auto & swatch_widget : swatch_widgets)
+ {
+ gtk_widget_hide(swatch_widget);
+ }
+ for (auto & it : nonsolid)
+ {
+ gtk_widget_show_all(it);
+ }
+
+ }
+
+ if (edit) {
+ gtk_widget_set_sensitive(edit, TRUE);
+ }
+ if (add) {
+ gtk_widget_set_sensitive(add, TRUE);
+ }
+ if (del) {
+ gtk_widget_set_sensitive(del, TRUE);
+ }
+ } else {
+ if (edit) {
+ gtk_widget_set_sensitive(edit, FALSE);
+ }
+ if (add) {
+ gtk_widget_set_sensitive(add, (doc != nullptr));
+ }
+ if (del) {
+ gtk_widget_set_sensitive(del, FALSE);
+ }
+ }
+}
+
+SPGradient *SPGradientSelector::getVector()
+{
+ /* fixme: */
+ return SP_GRADIENT_VECTOR_SELECTOR(vectors)->gr;
+}
+
+
+static void sp_gradient_selector_vector_set(SPGradientVectorSelector * /*gvs*/, SPGradient *gr, SPGradientSelector *sel)
+{
+
+ if (!sel->blocked) {
+ sel->blocked = TRUE;
+ gr = sp_gradient_ensure_vector_normalized (gr);
+ sel->setVector((gr) ? gr->document : nullptr, gr);
+ g_signal_emit (G_OBJECT (sel), signals[CHANGED], 0, gr);
+ sel->blocked = FALSE;
+ }
+}
+
+
+static void
+sp_gradient_selector_delete_vector_clicked (GtkWidget */*w*/, SPGradientSelector *sel)
+{
+ const Glib::RefPtr<Gtk::TreeSelection> selection = sel->treeview->get_selection();
+ if (!selection) {
+ return;
+ }
+
+ SPGradient *obj = nullptr;
+ /* Single selection */
+ Gtk::TreeModel::iterator iter = selection->get_selected();
+ if ( iter ) {
+ Gtk::TreeModel::Row row = *iter;
+ obj = row[sel->columns->data];
+ }
+
+ if (obj) {
+ sp_gradient_unset_swatch(SP_ACTIVE_DESKTOP, obj->getId());
+ }
+
+}
+
+static void
+sp_gradient_selector_edit_vector_clicked (GtkWidget */*w*/, SPGradientSelector *sel)
+{
+ Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+ if (prefs->getBool("/dialogs/gradienteditor/showlegacy", false)) {
+ // Legacy gradient dialog
+ GtkWidget *dialog;
+ dialog = sp_gradient_vector_editor_new (SP_GRADIENT_VECTOR_SELECTOR (sel->vectors)->gr);
+ gtk_widget_show (dialog);
+ } else {
+ // Invoke the gradient tool
+ Inkscape::Verb *verb = Inkscape::Verb::get( SP_VERB_CONTEXT_GRADIENT );
+ if ( verb ) {
+ SPAction *action = verb->get_action( Inkscape::ActionContext( ( Inkscape::UI::View::View * ) SP_ACTIVE_DESKTOP ) );
+ if ( action ) {
+ sp_action_perform( action, nullptr );
+ }
+ }
+ }
+}
+
+static void
+sp_gradient_selector_add_vector_clicked (GtkWidget */*w*/, SPGradientSelector *sel)
+{
+ SPDocument *doc = sp_gradient_vector_selector_get_document (SP_GRADIENT_VECTOR_SELECTOR (sel->vectors));
+
+ if (!doc)
+ return;
+
+ SPGradient *gr = sp_gradient_vector_selector_get_gradient( SP_GRADIENT_VECTOR_SELECTOR (sel->vectors));
+ Inkscape::XML::Document *xml_doc = doc->getReprDoc();
+
+ Inkscape::XML::Node *repr = nullptr;
+
+ if (gr) {
+ repr = gr->getRepr()->duplicate(xml_doc);
+ // Rename the new gradients id to be similar to the cloned gradients
+ Glib::ustring old_id = gr->getId();
+ rename_id(gr, old_id);
+ doc->getDefs()->getRepr()->addChild(repr, nullptr);
+ } else {
+ repr = xml_doc->createElement("svg:linearGradient");
+ Inkscape::XML::Node *stop = xml_doc->createElement("svg:stop");
+ stop->setAttribute("offset", "0");
+ stop->setAttribute("style", "stop-color:#000;stop-opacity:1;");
+ repr->appendChild(stop);
+ Inkscape::GC::release(stop);
+ stop = xml_doc->createElement("svg:stop");
+ stop->setAttribute("offset", "1");
+ stop->setAttribute("style", "stop-color:#fff;stop-opacity:1;");
+ repr->appendChild(stop);
+ Inkscape::GC::release(stop);
+ doc->getDefs()->getRepr()->addChild(repr, nullptr);
+ gr = SP_GRADIENT(doc->getObjectByRepr(repr));
+ }
+
+ sp_gradient_vector_selector_set_gradient( SP_GRADIENT_VECTOR_SELECTOR (sel->vectors), doc, gr);
+
+ sel->selectGradientInTree(gr);
+
+ Inkscape::GC::release(repr);
+}
+
+/*
+ Local Variables:
+ mode:c++
+ c-file-style:"stroustrup"
+ c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
+ indent-tabs-mode:nil
+ fill-column:99
+ End:
+*/
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4 :
diff --git a/src/widgets/gradient-selector.h b/src/widgets/gradient-selector.h
new file mode 100644
index 0000000..c787552
--- /dev/null
+++ b/src/widgets/gradient-selector.h
@@ -0,0 +1,152 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+#ifndef SEEN_GRADIENT_SELECTOR_H
+#define SEEN_GRADIENT_SELECTOR_H
+
+/*
+ * Gradient vector and position widget
+ *
+ * Authors:
+ * Lauris Kaplinski <lauris@kaplinski.com>
+ * Jon A. Cruz <jon@joncruz.org>
+ *
+ * Copyright (C) 2001-2002 Lauris Kaplinski
+ * Copyright (C) 2001 Ximian, Inc.
+ * Copyright (C) 2010 Jon A. Cruz
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#include <gtkmm/liststore.h>
+#include <gtkmm/scrolledwindow.h>
+
+#include <vector>
+#include "object/sp-gradient-spread.h"
+#include "object/sp-gradient-units.h"
+
+class SPDocument;
+class SPGradient;
+
+namespace Gtk {
+class CellRendererPixbuf;
+class CellRendererText;
+class ScrolledWindow;
+class TreeView;
+}
+
+#define SP_TYPE_GRADIENT_SELECTOR (sp_gradient_selector_get_type ())
+#define SP_GRADIENT_SELECTOR(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), SP_TYPE_GRADIENT_SELECTOR, SPGradientSelector))
+#define SP_GRADIENT_SELECTOR_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), SP_TYPE_GRADIENT_SELECTOR, SPGradientSelectorClass))
+#define SP_IS_GRADIENT_SELECTOR(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), SP_TYPE_GRADIENT_SELECTOR))
+#define SP_IS_GRADIENT_SELECTOR_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), SP_TYPE_GRADIENT_SELECTOR))
+
+
+
+struct SPGradientSelector {
+ GtkBox vbox;
+
+ enum SelectorMode {
+ MODE_LINEAR,
+ MODE_RADIAL,
+ MODE_SWATCH
+ };
+
+ SelectorMode mode;
+
+ SPGradientUnits gradientUnits;
+ SPGradientSpread gradientSpread;
+
+ /* Vector selector */
+ GtkWidget *vectors;
+
+ /* Tree */
+ bool _checkForSelected(const Gtk::TreePath& path, const Gtk::TreeIter& iter, SPGradient *vector);
+ bool onKeyPressEvent(GdkEventKey *event);
+ void onTreeSelection();
+ void onGradientRename( const Glib::ustring& path_string, const Glib::ustring& new_text);
+ void onTreeNameColClick();
+ void onTreeColorColClick();
+ void onTreeCountColClick();
+
+ Gtk::TreeView *treeview;
+ Gtk::ScrolledWindow *scrolled_window;
+ class ModelColumns : public Gtk::TreeModel::ColumnRecord
+ {
+ public:
+ ModelColumns()
+ {
+ add(name);
+ add(refcount);
+ add(color);
+ add(data);
+ add(pixbuf);
+ }
+ ~ModelColumns() override = default;
+
+ Gtk::TreeModelColumn<Glib::ustring> name;
+ Gtk::TreeModelColumn<unsigned long> color;
+ Gtk::TreeModelColumn<gint> refcount;
+ Gtk::TreeModelColumn<SPGradient*> data;
+ Gtk::TreeModelColumn<Glib::RefPtr<Gdk::Pixbuf> > pixbuf;
+
+ };
+
+ ModelColumns *columns;
+ Glib::RefPtr<Gtk::ListStore> store;
+ Gtk::CellRendererPixbuf* icon_renderer;
+ Gtk::CellRendererText* text_renderer;
+
+ /* Editing buttons */
+ GtkWidget *edit;
+ GtkWidget *add;
+ GtkWidget *del;
+ GtkWidget *merge;
+
+ /* Position widget */
+ GtkWidget *position;
+
+ bool safelyInit;
+ bool blocked;
+
+ std::vector<GtkWidget*> nonsolid;
+ std::vector<GtkWidget*> swatch_widgets;
+
+ void setMode(SelectorMode mode);
+ void setUnits(SPGradientUnits units);
+ void setSpread(SPGradientSpread spread);
+ void setVector(SPDocument *doc, SPGradient *vector);
+ void selectGradientInTree(SPGradient *vector);
+ void moveSelection(int amount, bool down = true, bool toEnd = false);
+
+ SPGradientUnits getUnits();
+ SPGradientSpread getSpread();
+ SPGradient *getVector();
+};
+
+struct SPGradientSelectorClass {
+ GtkBoxClass parent_class;
+
+ void (* grabbed) (SPGradientSelector *sel);
+ void (* dragged) (SPGradientSelector *sel);
+ void (* released) (SPGradientSelector *sel);
+ void (* changed) (SPGradientSelector *sel);
+};
+
+GType sp_gradient_selector_get_type();
+
+GtkWidget *sp_gradient_selector_new ();
+
+void sp_gradient_selector_set_bbox (SPGradientSelector *sel, gdouble x0, gdouble y0, gdouble x1, gdouble y1);
+
+#endif // SEEN_GRADIENT_SELECTOR_H
+
+
+/*
+ Local Variables:
+ mode:c++
+ c-file-style:"stroustrup"
+ c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
+ indent-tabs-mode:nil
+ fill-column:99
+ End:
+*/
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4 :
diff --git a/src/widgets/gradient-vector.cpp b/src/widgets/gradient-vector.cpp
new file mode 100644
index 0000000..a2ca973
--- /dev/null
+++ b/src/widgets/gradient-vector.cpp
@@ -0,0 +1,1314 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * Gradient vector selection widget
+ *
+ * Authors:
+ * Lauris Kaplinski <lauris@kaplinski.com>
+ * bulia byak <buliabyak@users.sf.net>
+ * MenTaLguY <mental@rydia.net>
+ * Jon A. Cruz <jon@joncruz.org>
+ * Abhishek Sharma
+ *
+ * Copyright (C) 2001-2002 Lauris Kaplinski
+ * Copyright (C) 2001 Ximian, Inc.
+ * Copyright (C) 2004 Monash University
+ * Copyright (C) 2004 David Turner
+ * Copyright (C) 2006 MenTaLguY
+ * Copyright (C) 2010 Jon A. Cruz
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ *
+ */
+
+#include <set>
+
+#include <glibmm.h>
+#include <glibmm/i18n.h>
+
+
+
+
+#include "gradient-chemistry.h"
+#include "inkscape.h"
+#include "preferences.h"
+#include "desktop.h"
+#include "document-undo.h"
+#include "gradient-vector.h"
+#include "layer-manager.h"
+#include "include/macros.h"
+#include "selection-chemistry.h"
+#include "verbs.h"
+
+#include "io/resource.h"
+
+#include "object/sp-defs.h"
+#include "object/sp-linear-gradient.h"
+#include "object/sp-radial-gradient.h"
+#include "object/sp-root.h"
+#include "object/sp-stop.h"
+#include "style.h"
+
+#include "svg/css-ostringstream.h"
+
+#include "ui/dialog-events.h"
+#include "ui/selected-color.h"
+#include "ui/widget/color-notebook.h"
+#include "ui/widget/color-preview.h"
+
+#include "widgets/gradient-image.h"
+
+#include "xml/repr.h"
+
+using Inkscape::DocumentUndo;
+using Inkscape::UI::SelectedColor;
+
+enum {
+ VECTOR_SET,
+ LAST_SIGNAL
+};
+
+static void sp_gradient_vector_selector_destroy(GtkWidget *object);
+
+static void sp_gvs_gradient_release(SPObject *obj, SPGradientVectorSelector *gvs);
+static void sp_gvs_defs_release(SPObject *defs, SPGradientVectorSelector *gvs);
+static void sp_gvs_defs_modified(SPObject *defs, guint flags, SPGradientVectorSelector *gvs);
+
+static void sp_gvs_rebuild_gui_full(SPGradientVectorSelector *gvs);
+static SPStop *get_selected_stop( GtkWidget *vb);
+void gr_get_usage_counts(SPDocument *doc, std::map<SPGradient *, gint> *mapUsageCount );
+unsigned long sp_gradient_to_hhssll(SPGradient *gr);
+
+static guint signals[LAST_SIGNAL] = {0};
+
+// TODO FIXME kill these globals!!!
+static GtkWidget *dlg = nullptr;
+static win_data wd;
+static gint x = -1000, y = -1000, w = 0, h = 0; // impossible original values to make sure they are read from prefs
+static Glib::ustring const prefs_path = "/dialogs/gradienteditor/";
+
+G_DEFINE_TYPE(SPGradientVectorSelector, sp_gradient_vector_selector, GTK_TYPE_BOX);
+
+static void sp_gradient_vector_selector_class_init(SPGradientVectorSelectorClass *klass)
+{
+ GObjectClass *gobject_class = G_OBJECT_CLASS(klass);
+
+ signals[VECTOR_SET] = g_signal_new( "vector_set",
+ G_TYPE_FROM_CLASS(gobject_class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET(SPGradientVectorSelectorClass, vector_set),
+ nullptr, nullptr,
+ g_cclosure_marshal_VOID__POINTER,
+ G_TYPE_NONE, 1,
+ G_TYPE_POINTER);
+
+ GtkWidgetClass *widget_class = GTK_WIDGET_CLASS(klass);
+ widget_class->destroy = sp_gradient_vector_selector_destroy;
+}
+
+static void sp_gradient_vector_selector_init(SPGradientVectorSelector *gvs)
+{
+ gtk_orientable_set_orientation(GTK_ORIENTABLE(gvs), GTK_ORIENTATION_VERTICAL);
+
+ gvs->idlabel = TRUE;
+
+ gvs->swatched = false;
+
+ gvs->doc = nullptr;
+ gvs->gr = nullptr;
+
+ new (&gvs->gradient_release_connection) sigc::connection();
+ new (&gvs->defs_release_connection) sigc::connection();
+ new (&gvs->defs_modified_connection) sigc::connection();
+
+ gvs->columns = new SPGradientSelector::ModelColumns();
+ gvs->store = Gtk::ListStore::create(*gvs->columns);
+ new (&gvs->tree_select_connection) sigc::connection();
+
+}
+
+static void sp_gradient_vector_selector_destroy(GtkWidget *object)
+{
+ SPGradientVectorSelector *gvs = SP_GRADIENT_VECTOR_SELECTOR(object);
+
+ if (gvs->gr) {
+ gvs->gradient_release_connection.disconnect();
+ gvs->tree_select_connection.disconnect();
+ gvs->gr = nullptr;
+ }
+
+ if (gvs->doc) {
+ gvs->defs_release_connection.disconnect();
+ gvs->defs_modified_connection.disconnect();
+ gvs->doc = nullptr;
+ }
+
+ gvs->gradient_release_connection.~connection();
+ gvs->defs_release_connection.~connection();
+ gvs->defs_modified_connection.~connection();
+ gvs->tree_select_connection.~connection();
+
+ if ((GTK_WIDGET_CLASS(sp_gradient_vector_selector_parent_class))->destroy) {
+ (GTK_WIDGET_CLASS(sp_gradient_vector_selector_parent_class))->destroy(object);
+ }
+}
+
+GtkWidget *sp_gradient_vector_selector_new(SPDocument *doc, SPGradient *gr)
+{
+ GtkWidget *gvs;
+
+ g_return_val_if_fail(!gr || SP_IS_GRADIENT(gr), NULL);
+ g_return_val_if_fail(!gr || (gr->document == doc), NULL);
+
+ gvs = static_cast<GtkWidget*>(g_object_new(SP_TYPE_GRADIENT_VECTOR_SELECTOR, nullptr));
+
+ if (doc) {
+ sp_gradient_vector_selector_set_gradient(SP_GRADIENT_VECTOR_SELECTOR(gvs), doc, gr);
+ } else {
+ sp_gvs_rebuild_gui_full(SP_GRADIENT_VECTOR_SELECTOR(gvs));
+ }
+
+ return gvs;
+}
+
+void sp_gradient_vector_selector_set_gradient(SPGradientVectorSelector *gvs, SPDocument *doc, SPGradient *gr)
+{
+// g_message("sp_gradient_vector_selector_set_gradient(%p, %p, %p) [%s] %d %d", gvs, doc, gr,
+// (gr ? gr->getId():"N/A"),
+// (gr ? gr->isSwatch() : -1),
+// (gr ? gr->isSolid() : -1));
+ static gboolean suppress = FALSE;
+
+ g_return_if_fail(gvs != nullptr);
+ g_return_if_fail(SP_IS_GRADIENT_VECTOR_SELECTOR(gvs));
+ g_return_if_fail(!gr || (doc != nullptr));
+ g_return_if_fail(!gr || SP_IS_GRADIENT(gr));
+ g_return_if_fail(!gr || (gr->document == doc));
+ g_return_if_fail(!gr || gr->hasStops());
+
+ if (doc != gvs->doc) {
+ /* Disconnect signals */
+ if (gvs->gr) {
+ gvs->gradient_release_connection.disconnect();
+ gvs->gr = nullptr;
+ }
+ if (gvs->doc) {
+ gvs->defs_release_connection.disconnect();
+ gvs->defs_modified_connection.disconnect();
+ gvs->doc = nullptr;
+ }
+
+ // Connect signals
+ if (doc) {
+ gvs->defs_release_connection = doc->getDefs()->connectRelease(sigc::bind<1>(sigc::ptr_fun(&sp_gvs_defs_release), gvs));
+ gvs->defs_modified_connection = doc->getDefs()->connectModified(sigc::bind<2>(sigc::ptr_fun(&sp_gvs_defs_modified), gvs));
+ }
+ if (gr) {
+ gvs->gradient_release_connection = gr->connectRelease(sigc::bind<1>(sigc::ptr_fun(&sp_gvs_gradient_release), gvs));
+ }
+ gvs->doc = doc;
+ gvs->gr = gr;
+ sp_gvs_rebuild_gui_full(gvs);
+ if (!suppress) g_signal_emit(G_OBJECT(gvs), signals[VECTOR_SET], 0, gr);
+ } else if (gr != gvs->gr) {
+ // Harder case - keep document, rebuild list and stuff
+ // fixme: (Lauris)
+ suppress = TRUE;
+ sp_gradient_vector_selector_set_gradient(gvs, nullptr, nullptr);
+ sp_gradient_vector_selector_set_gradient(gvs, doc, gr);
+ suppress = FALSE;
+ g_signal_emit(G_OBJECT(gvs), signals[VECTOR_SET], 0, gr);
+ }
+ /* The case of setting NULL -> NULL is not very interesting */
+}
+
+SPDocument *sp_gradient_vector_selector_get_document(SPGradientVectorSelector *gvs)
+{
+ g_return_val_if_fail(gvs != nullptr, NULL);
+ g_return_val_if_fail(SP_IS_GRADIENT_VECTOR_SELECTOR(gvs), NULL);
+
+ return gvs->doc;
+}
+
+SPGradient *sp_gradient_vector_selector_get_gradient(SPGradientVectorSelector *gvs)
+{
+ g_return_val_if_fail(gvs != nullptr, NULL);
+ g_return_val_if_fail(SP_IS_GRADIENT_VECTOR_SELECTOR(gvs), NULL);
+
+ return gvs->gr;
+}
+
+Glib::ustring gr_prepare_label (SPObject *obj)
+{
+ const gchar *id = obj->label() ? obj->label() : obj->getId();
+ if (!id) {
+ id = obj->getRepr()->name();
+ }
+
+ if (strlen(id) > 14 && (!strncmp (id, "linearGradient", 14) || !strncmp (id, "radialGradient", 14)))
+ return gr_ellipsize_text (g_strdup_printf ("%s", id+14), 35);
+ return gr_ellipsize_text (id, 35);
+}
+
+/*
+ * Ellipse text if longer than maxlen, "50% start text + ... + ~50% end text"
+ * Text should be > length 8 or just return the original text
+ */
+Glib::ustring gr_ellipsize_text(Glib::ustring const &src, size_t maxlen)
+{
+ if (src.length() > maxlen && maxlen > 8) {
+ size_t p1 = (size_t) maxlen / 2;
+ size_t p2 = (size_t) src.length() - (maxlen - p1 - 1);
+ return src.substr(0, p1) + "…" + src.substr(p2);
+ }
+ return src;
+}
+
+static void sp_gvs_rebuild_gui_full(SPGradientVectorSelector *gvs)
+{
+
+ gvs->tree_select_connection.block();
+
+ /* Clear old list, if there is any */
+ gvs->store->clear();
+
+ /* Pick up all gradients with vectors */
+ std::vector<SPGradient *> gl;
+ if (gvs->gr) {
+ std::vector<SPObject *> gradients = gvs->gr->document->getResourceList("gradient");
+ for (auto gradient : gradients) {
+ SPGradient* grad = SP_GRADIENT(gradient);
+ if ( grad->hasStops() && (grad->isSwatch() == gvs->swatched) ) {
+ gl.push_back(SP_GRADIENT(gradient));
+ }
+ }
+ }
+
+ /* Get usage count of all the gradients */
+ std::map<SPGradient *, gint> usageCount;
+ gr_get_usage_counts(gvs->doc, &usageCount);
+
+ if (!gvs->doc) {
+ Gtk::TreeModel::Row row = *(gvs->store->append());
+ row[gvs->columns->name] = _("No document selected");
+
+ } else if (gl.empty()) {
+ Gtk::TreeModel::Row row = *(gvs->store->append());
+ row[gvs->columns->name] = _("No gradients in document");
+
+ } else if (!gvs->gr) {
+ Gtk::TreeModel::Row row = *(gvs->store->append());
+ row[gvs->columns->name] = _("No gradient selected");
+
+ } else {
+ for (auto gr:gl) {
+ unsigned long hhssll = sp_gradient_to_hhssll(gr);
+ GdkPixbuf *pixb = sp_gradient_to_pixbuf (gr, 64, 18);
+ Glib::ustring label = gr_prepare_label(gr);
+
+ Gtk::TreeModel::Row row = *(gvs->store->append());
+ row[gvs->columns->name] = label.c_str();
+ row[gvs->columns->color] = hhssll;
+ row[gvs->columns->refcount] = usageCount[gr];
+ row[gvs->columns->data] = gr;
+ row[gvs->columns->pixbuf] = Glib::wrap(pixb);
+ }
+ }
+
+ gvs->tree_select_connection.unblock();
+
+}
+
+/*
+ * Return a "HHSSLL" version of the first stop color so we can sort by it
+ */
+unsigned long sp_gradient_to_hhssll(SPGradient *gr)
+{
+ SPStop *stop = gr->getFirstStop();
+ unsigned long rgba = stop->get_rgba32();
+ float hsl[3];
+ SPColor::rgb_to_hsl_floatv (hsl, SP_RGBA32_R_F(rgba), SP_RGBA32_G_F(rgba), SP_RGBA32_B_F(rgba));
+
+ return ((int)(hsl[0]*100 * 10000)) + ((int)(hsl[1]*100 * 100)) + ((int)(hsl[2]*100 * 1));
+}
+
+static void get_all_doc_items(std::vector<SPItem*> &list, SPObject *from)
+{
+ for (auto& child: from->children) {
+ if (SP_IS_ITEM(&child)) {
+ list.push_back(SP_ITEM(&child));
+ }
+ get_all_doc_items(list, &child);
+ }
+}
+
+/*
+ * Return a SPItem's gradient
+ */
+static SPGradient * gr_item_get_gradient(SPItem *item, gboolean fillorstroke)
+{
+ SPIPaint *item_paint = item->style->getFillOrStroke(fillorstroke);
+ if (item_paint->isPaintserver()) {
+
+ SPPaintServer *item_server = (fillorstroke) ?
+ item->style->getFillPaintServer() : item->style->getStrokePaintServer();
+
+ if (SP_IS_LINEARGRADIENT(item_server) || SP_IS_RADIALGRADIENT(item_server) ||
+ (SP_IS_GRADIENT(item_server) && SP_GRADIENT(item_server)->getVector()->isSwatch())) {
+
+ return SP_GRADIENT(item_server)->getVector();
+ }
+ }
+
+ return nullptr;
+}
+
+/*
+ * Map each gradient to its usage count for both fill and stroke styles
+ */
+void gr_get_usage_counts(SPDocument *doc, std::map<SPGradient *, gint> *mapUsageCount )
+{
+ if (!doc)
+ return;
+
+ std::vector<SPItem *> all_list;
+ get_all_doc_items(all_list, doc->getRoot());
+
+ for (auto item:all_list) {
+ if (!item->getId())
+ continue;
+ SPGradient *gr = nullptr;
+ gr = gr_item_get_gradient(item, true); // fill
+ if (gr) {
+ mapUsageCount->count(gr) > 0 ? (*mapUsageCount)[gr] += 1 : (*mapUsageCount)[gr] = 1;
+ }
+ gr = gr_item_get_gradient(item, false); // stroke
+ if (gr) {
+ mapUsageCount->count(gr) > 0 ? (*mapUsageCount)[gr] += 1 : (*mapUsageCount)[gr] = 1;
+ }
+ }
+}
+
+static void sp_gvs_gradient_release(SPObject */*obj*/, SPGradientVectorSelector *gvs)
+{
+ /* Disconnect gradient */
+ if (gvs->gr) {
+ gvs->gradient_release_connection.disconnect();
+ gvs->gr = nullptr;
+ }
+
+ /* Rebuild GUI */
+ sp_gvs_rebuild_gui_full(gvs);
+}
+
+static void sp_gvs_defs_release(SPObject */*defs*/, SPGradientVectorSelector *gvs)
+{
+ gvs->doc = nullptr;
+
+ gvs->defs_release_connection.disconnect();
+ gvs->defs_modified_connection.disconnect();
+
+ /* Disconnect gradient as well */
+ if (gvs->gr) {
+ gvs->gradient_release_connection.disconnect();
+ gvs->gr = nullptr;
+ }
+
+ /* Rebuild GUI */
+ sp_gvs_rebuild_gui_full(gvs);
+}
+
+static void sp_gvs_defs_modified(SPObject */*defs*/, guint /*flags*/, SPGradientVectorSelector *gvs)
+{
+ /* fixme: We probably have to check some flags here (Lauris) */
+ sp_gvs_rebuild_gui_full(gvs);
+}
+
+void SPGradientVectorSelector::setSwatched()
+{
+ swatched = true;
+ sp_gvs_rebuild_gui_full(this);
+}
+
+/*##################################################################
+ ### Vector Editing Widget
+ ##################################################################*/
+
+#include "widgets/widget-sizes.h"
+#include "xml/node-event-vector.h"
+#include "svg/svg-color.h"
+
+#define PAD 4
+
+static GtkWidget *sp_gradient_vector_widget_new(SPGradient *gradient, SPStop *stop);
+
+static void sp_gradient_vector_widget_load_gradient(GtkWidget *widget, SPGradient *gradient);
+static gint sp_gradient_vector_dialog_delete(GtkWidget *widget, GdkEvent *event, GtkWidget *dialog);
+static void sp_gradient_vector_dialog_destroy(GtkWidget *object, gpointer data);
+static void sp_gradient_vector_widget_destroy(GtkWidget *object, gpointer data);
+static void sp_gradient_vector_gradient_release(SPObject *obj, GtkWidget *widget);
+static void sp_gradient_vector_gradient_modified(SPObject *obj, guint flags, GtkWidget *widget);
+static void sp_gradient_vector_color_dragged(Inkscape::UI::SelectedColor *selected_color, GObject *object);
+static void sp_gradient_vector_color_changed(Inkscape::UI::SelectedColor *selected_color, GObject *object);
+static void update_stop_list( GtkWidget *vb, SPGradient *gradient, SPStop *new_stop);
+
+static gboolean blocked = FALSE;
+
+static void grad_edit_dia_stop_added_or_removed(Inkscape::XML::Node */*repr*/, Inkscape::XML::Node */*child*/, Inkscape::XML::Node */*ref*/, gpointer data)
+{
+ GtkWidget *vb = GTK_WIDGET(data);
+ SPGradient *gradient = static_cast<SPGradient *>(g_object_get_data(G_OBJECT(vb), "gradient"));
+ update_stop_list(vb, gradient, nullptr);
+}
+
+//FIXME!!! We must also listen to attr changes on all children (i.e. stops) too,
+//otherwise the dialog does not reflect undoing color or offset change. This is a major
+//hassle, unless we have a "one of the descendants changed in some way" signal.
+static Inkscape::XML::NodeEventVector grad_edit_dia_repr_events =
+{
+ grad_edit_dia_stop_added_or_removed, /* child_added */
+ grad_edit_dia_stop_added_or_removed, /* child_removed */
+ nullptr, /* attr_changed*/
+ nullptr, /* content_changed */
+ nullptr /* order_changed */
+};
+
+static void verify_grad(SPGradient *gradient)
+{
+ int i = 0;
+ SPStop *stop = nullptr;
+ /* count stops */
+ for (auto& ochild: gradient->children) {
+ if (SP_IS_STOP(&ochild)) {
+ i++;
+ stop = SP_STOP(&ochild);
+ }
+ }
+
+ Inkscape::XML::Document *xml_doc;
+ xml_doc = gradient->getRepr()->document();
+
+ if (i < 1) {
+ Inkscape::CSSOStringStream os;
+ os << "stop-color: #000000;stop-opacity:" << 1.0 << ";";
+
+ Inkscape::XML::Node *child;
+
+ child = xml_doc->createElement("svg:stop");
+ sp_repr_set_css_double(child, "offset", 0.0);
+ child->setAttribute("style", os.str());
+ gradient->getRepr()->addChild(child, nullptr);
+ Inkscape::GC::release(child);
+
+ child = xml_doc->createElement("svg:stop");
+ sp_repr_set_css_double(child, "offset", 1.0);
+ child->setAttribute("style", os.str());
+ gradient->getRepr()->addChild(child, nullptr);
+ Inkscape::GC::release(child);
+ return;
+ }
+ if (i < 2) {
+ sp_repr_set_css_double(stop->getRepr(), "offset", 0.0);
+ Inkscape::XML::Node *child = stop->getRepr()->duplicate(gradient->getRepr()->document());
+ sp_repr_set_css_double(child, "offset", 1.0);
+ gradient->getRepr()->addChild(child, stop->getRepr());
+ Inkscape::GC::release(child);
+ }
+}
+
+static void select_stop_in_list( GtkWidget *vb, SPGradient *gradient, SPStop *new_stop)
+{
+ GtkWidget *combo_box = static_cast<GtkWidget *>(g_object_get_data(G_OBJECT(vb), "combo_box"));
+
+ int i = 0;
+ for (auto& ochild: gradient->children) {
+ if (SP_IS_STOP(&ochild)) {
+ if (&ochild == new_stop) {
+ gtk_combo_box_set_active (GTK_COMBO_BOX(combo_box) , i);
+ break;
+ }
+ i++;
+ }
+ }
+}
+
+static void update_stop_list( GtkWidget *vb, SPGradient *gradient, SPStop *new_stop)
+{
+
+ if (!SP_IS_GRADIENT(gradient)) {
+ return;
+ }
+
+ blocked = TRUE;
+
+ /* Clear old list, if there is any */
+ GtkWidget *combo_box = static_cast<GtkWidget *>(g_object_get_data(G_OBJECT(vb), "combo_box"));
+ if (!combo_box) {
+ return;
+ }
+ GtkListStore *store = GTK_LIST_STORE(gtk_combo_box_get_model(GTK_COMBO_BOX(combo_box)));
+ if (!store) {
+ return;
+ }
+ gtk_list_store_clear(store);
+ GtkTreeIter iter;
+
+ /* Populate the combobox store */
+ std::vector<SPStop *> sl;
+ if ( gradient->hasStops() ) {
+ for (auto& ochild: gradient->children) {
+ if (SP_IS_STOP(&ochild)) {
+ sl.push_back(SP_STOP(&ochild));
+ }
+ }
+ }
+ if (sl.empty()) {
+ gtk_list_store_append (store, &iter);
+ gtk_list_store_set (store, &iter, 0, NULL, 1, _("No stops in gradient"), 2, NULL, -1);
+ gtk_widget_set_sensitive (combo_box, FALSE);
+
+ } else {
+
+ for (auto stop:sl) {
+ Inkscape::XML::Node *repr = stop->getRepr();
+ Inkscape::UI::Widget::ColorPreview *cpv = Gtk::manage(new Inkscape::UI::Widget::ColorPreview(stop->get_rgba32()));
+ GdkPixbuf *pb = cpv->toPixbuf(64, 16);
+ gtk_list_store_append (store, &iter);
+ gtk_list_store_set (store, &iter, 0, pb, 1, repr->attribute("id"), 2, stop, -1);
+ gtk_widget_set_sensitive (combo_box, FALSE);
+ }
+ gtk_widget_set_sensitive(combo_box, TRUE);
+ }
+
+ /* Set history */
+ if (new_stop == nullptr) {
+ gtk_combo_box_set_active (GTK_COMBO_BOX(combo_box) , 0);
+ } else {
+ select_stop_in_list(vb, gradient, new_stop);
+ }
+
+ blocked = FALSE;
+}
+
+
+// user selected existing stop from list
+static void sp_grad_edit_combo_box_changed (GtkComboBox * /*widget*/, GtkWidget *tbl)
+{
+ SPStop *stop = get_selected_stop(tbl);
+ if (!stop) {
+ return;
+ }
+
+ blocked = TRUE;
+
+ SelectedColor *csel = static_cast<SelectedColor*>(g_object_get_data(G_OBJECT(tbl), "cselector"));
+ // set its color, from the stored array
+ g_object_set_data(G_OBJECT(tbl), "updating_color", reinterpret_cast<void*>(1));
+ csel->setColorAlpha(stop->getColor(), stop->getOpacity());
+ g_object_set_data(G_OBJECT(tbl), "updating_color", reinterpret_cast<void*>(0));
+ GtkWidget *offspin = GTK_WIDGET(g_object_get_data(G_OBJECT(tbl), "offspn"));
+ GtkWidget *offslide =GTK_WIDGET(g_object_get_data(G_OBJECT(tbl), "offslide"));
+
+ GtkAdjustment *adj = static_cast<GtkAdjustment*>(g_object_get_data(G_OBJECT(tbl), "offset"));
+
+ bool isEndStop = false;
+
+ SPStop *prev = nullptr;
+ prev = stop->getPrevStop();
+ if (prev != nullptr ) {
+ gtk_adjustment_set_lower (adj, prev->offset);
+ } else {
+ isEndStop = true;
+ gtk_adjustment_set_lower (adj, 0);
+ }
+
+ SPStop *next = nullptr;
+ next = stop->getNextStop();
+ if (next != nullptr ) {
+ gtk_adjustment_set_upper (adj, next->offset);
+ } else {
+ isEndStop = true;
+ gtk_adjustment_set_upper (adj, 1.0);
+ }
+
+ //fixme: does this work on all possible input gradients?
+ if (!isEndStop) {
+ gtk_widget_set_sensitive(offslide, TRUE);
+ gtk_widget_set_sensitive(GTK_WIDGET(offspin), TRUE);
+ } else {
+ gtk_widget_set_sensitive(offslide, FALSE);
+ gtk_widget_set_sensitive(GTK_WIDGET(offspin), FALSE);
+ }
+
+ gtk_adjustment_set_value(adj, stop->offset);
+
+ blocked = FALSE;
+}
+
+static SPStop *get_selected_stop( GtkWidget *vb)
+{
+ SPStop *stop = nullptr;
+ GtkWidget *combo_box = static_cast<GtkWidget *>(g_object_get_data(G_OBJECT(vb), "combo_box"));
+ if (combo_box) {
+ GtkTreeIter iter;
+ if (gtk_combo_box_get_active_iter (GTK_COMBO_BOX(combo_box), &iter)) {
+ GtkListStore *store = GTK_LIST_STORE(gtk_combo_box_get_model(GTK_COMBO_BOX(combo_box)));
+ gtk_tree_model_get (GTK_TREE_MODEL(store), &iter, 2, &stop, -1);
+ }
+ }
+ return stop;
+}
+
+static void offadjustmentChanged( GtkAdjustment *adjustment, GtkWidget *vb)
+{
+ if (!blocked) {
+ blocked = TRUE;
+
+ SPStop *stop = get_selected_stop(vb);
+ if (stop) {
+ stop->offset = gtk_adjustment_get_value (adjustment);
+ sp_repr_set_css_double(stop->getRepr(), "offset", stop->offset);
+
+ DocumentUndo::maybeDone(stop->document, "gradient:stop:offset", SP_VERB_CONTEXT_GRADIENT,
+ _("Change gradient stop offset"));
+
+ }
+
+ blocked = FALSE;
+ }
+}
+
+guint32 sp_average_color(guint32 c1, guint32 c2, gdouble p/* = 0.5*/)
+{
+ guint32 r = (guint32) (SP_RGBA32_R_U(c1) * p + SP_RGBA32_R_U(c2) * (1 - p));
+ guint32 g = (guint32) (SP_RGBA32_G_U(c1) * p + SP_RGBA32_G_U(c2) * (1 - p));
+ guint32 b = (guint32) (SP_RGBA32_B_U(c1) * p + SP_RGBA32_B_U(c2) * (1 - p));
+ guint32 a = (guint32) (SP_RGBA32_A_U(c1) * p + SP_RGBA32_A_U(c2) * (1 - p));
+
+ return SP_RGBA32_U_COMPOSE(r, g, b, a);
+}
+
+
+static void sp_grd_ed_add_stop(GtkWidget */*widget*/, GtkWidget *vb)
+{
+ SPGradient *gradient = static_cast<SPGradient *>(g_object_get_data(G_OBJECT(vb), "gradient"));
+ verify_grad(gradient);
+
+ SPStop *stop = get_selected_stop(vb);
+ if (!stop) {
+ return;
+ }
+
+ Inkscape::XML::Node *new_stop_repr = nullptr;
+
+ SPStop *next = stop->getNextStop();
+
+ if (next == nullptr) {
+ SPStop *prev = stop->getPrevStop();
+ if (prev != nullptr) {
+ next = stop;
+ stop = prev;
+ }
+ }
+
+ if (next != nullptr) {
+ new_stop_repr = stop->getRepr()->duplicate(gradient->getRepr()->document());
+ gradient->getRepr()->addChild(new_stop_repr, stop->getRepr());
+ } else {
+ next = stop;
+ new_stop_repr = stop->getPrevStop()->getRepr()->duplicate(gradient->getRepr()->document());
+ gradient->getRepr()->addChild(new_stop_repr, stop->getPrevStop()->getRepr());
+ }
+
+ SPStop *newstop = reinterpret_cast<SPStop *>(gradient->document->getObjectByRepr(new_stop_repr));
+
+ newstop->offset = (stop->offset + next->offset) * 0.5 ;
+
+ guint32 const c1 = stop->get_rgba32();
+ guint32 const c2 = next->get_rgba32();
+ guint32 cnew = sp_average_color(c1, c2);
+
+ Inkscape::CSSOStringStream os;
+ gchar c[64];
+ sp_svg_write_color(c, sizeof(c), cnew);
+ gdouble opacity = static_cast<gdouble>(SP_RGBA32_A_F(cnew));
+ os << "stop-color:" << c << ";stop-opacity:" << opacity <<";";
+ newstop->setAttribute("style", os.str());
+ sp_repr_set_css_double( newstop->getRepr(), "offset", (double)newstop->offset);
+
+ sp_gradient_vector_widget_load_gradient(vb, gradient);
+ Inkscape::GC::release(new_stop_repr);
+ update_stop_list(GTK_WIDGET(vb), gradient, newstop);
+ GtkWidget *offspin = GTK_WIDGET(g_object_get_data(G_OBJECT(vb), "offspn"));
+ GtkWidget *offslide =GTK_WIDGET(g_object_get_data(G_OBJECT(vb), "offslide"));
+ gtk_widget_set_sensitive(offslide, TRUE);
+ gtk_widget_set_sensitive(GTK_WIDGET(offspin), TRUE);
+ DocumentUndo::done(gradient->document, SP_VERB_CONTEXT_GRADIENT,
+ _("Add gradient stop"));
+}
+
+static void sp_grd_ed_del_stop(GtkWidget */*widget*/, GtkWidget *vb)
+{
+ SPGradient *gradient = static_cast<SPGradient *>(g_object_get_data(G_OBJECT(vb), "gradient"));
+
+ SPStop *stop = get_selected_stop(vb);
+ if (!stop) {
+ return;
+ }
+
+ if (gradient->vector.stops.size() > 2) { // 2 is the minimum
+
+ // if we delete first or last stop, move the next/previous to the edge
+ if (stop->offset == 0) {
+ SPStop *next = stop->getNextStop();
+ if (next) {
+ next->offset = 0;
+ sp_repr_set_css_double(next->getRepr(), "offset", 0);
+ }
+ } else if (stop->offset == 1) {
+ SPStop *prev = stop->getPrevStop();
+ if (prev) {
+ prev->offset = 1;
+ sp_repr_set_css_double(prev->getRepr(), "offset", 1);
+ }
+ }
+
+ gradient->getRepr()->removeChild(stop->getRepr());
+ sp_gradient_vector_widget_load_gradient(vb, gradient);
+ update_stop_list(GTK_WIDGET(vb), gradient, nullptr);
+ DocumentUndo::done(gradient->document, SP_VERB_CONTEXT_GRADIENT,
+ _("Delete gradient stop"));
+ }
+
+}
+
+static GtkWidget * sp_gradient_vector_widget_new(SPGradient *gradient, SPStop *select_stop)
+{
+ using Inkscape::UI::Widget::ColorNotebook;
+
+ GtkWidget *vb, *w, *f;
+
+ g_return_val_if_fail(gradient != nullptr, NULL);
+ g_return_val_if_fail(SP_IS_GRADIENT(gradient), NULL);
+
+ vb = gtk_box_new(GTK_ORIENTATION_VERTICAL, PAD);
+ gtk_box_set_homogeneous(GTK_BOX(vb), FALSE);
+ g_signal_connect(G_OBJECT(vb), "destroy", G_CALLBACK(sp_gradient_vector_widget_destroy), NULL);
+
+ w = sp_gradient_image_new(gradient);
+ g_object_set_data(G_OBJECT(vb), "preview", w);
+ gtk_widget_show(w);
+ gtk_box_pack_start(GTK_BOX(vb), w, TRUE, TRUE, PAD);
+
+ sp_repr_add_listener(gradient->getRepr(), &grad_edit_dia_repr_events, vb);
+
+ /* ComboBox of stops with 3 columns,
+ * The color preview, the label and a pointer to the SPStop
+ */
+ GtkListStore *store = gtk_list_store_new (3, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_POINTER);
+ GtkWidget *combo_box = gtk_combo_box_new_with_model (GTK_TREE_MODEL (store));
+
+ GtkCellRenderer *renderer = gtk_cell_renderer_pixbuf_new ();
+ gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo_box), renderer, FALSE);
+ gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combo_box), renderer, "pixbuf", 0, NULL);
+ gtk_cell_renderer_set_padding(renderer, 5, 0);
+
+ renderer = gtk_cell_renderer_text_new ();
+ gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo_box), renderer, TRUE);
+ gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combo_box), renderer, "text", 1, NULL);
+ gtk_widget_show(combo_box);
+ gtk_box_pack_start(GTK_BOX(vb), combo_box, FALSE, FALSE, 0);
+ g_object_set_data(G_OBJECT(vb), "combo_box", combo_box);
+
+ update_stop_list(GTK_WIDGET(vb), gradient, nullptr);
+
+ g_signal_connect(G_OBJECT(combo_box), "changed", G_CALLBACK(sp_grad_edit_combo_box_changed), vb);
+
+ /* Add and Remove buttons */
+ auto hb = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 1);
+ gtk_box_set_homogeneous(GTK_BOX(hb), FALSE);
+ // TRANSLATORS: "Stop" means: a "phase" of a gradient
+ GtkWidget *b = gtk_button_new_with_label(_("Add stop"));
+ gtk_widget_show(b);
+ gtk_container_add(GTK_CONTAINER(hb), b);
+ gtk_widget_set_tooltip_text(b, _("Add another control stop to gradient"));
+ g_signal_connect(G_OBJECT(b), "clicked", G_CALLBACK(sp_grd_ed_add_stop), vb);
+ b = gtk_button_new_with_label(_("Delete stop"));
+ gtk_widget_show(b);
+ gtk_container_add(GTK_CONTAINER(hb), b);
+ gtk_widget_set_tooltip_text(b, _("Delete current control stop from gradient"));
+ g_signal_connect(G_OBJECT(b), "clicked", G_CALLBACK(sp_grd_ed_del_stop), vb);
+
+ gtk_widget_show(hb);
+ gtk_box_pack_start(GTK_BOX(vb),hb, FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS);
+
+ /* Offset Slider and stuff */
+ hb = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
+ gtk_box_set_homogeneous(GTK_BOX(hb), FALSE);
+
+ /* Label */
+ GtkWidget *l = gtk_label_new(C_("Gradient","Offset:"));
+ gtk_widget_set_halign(l, GTK_ALIGN_END);
+
+ gtk_box_pack_start(GTK_BOX(hb),l, FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS);
+ gtk_widget_show(l);
+
+ /* Adjustment */
+ GtkAdjustment *Offset_adj = nullptr;
+ Offset_adj= GTK_ADJUSTMENT(gtk_adjustment_new(0.0, 0.0, 1.0, 0.01, 0.01, 0.0));
+ g_object_set_data(G_OBJECT(vb), "offset", Offset_adj);
+
+ SPStop *stop = get_selected_stop(vb);
+ if (!stop) {
+ return nullptr;
+ }
+
+ gtk_adjustment_set_value(Offset_adj, stop->offset);
+
+ /* Slider */
+ auto slider = gtk_scale_new(GTK_ORIENTATION_HORIZONTAL, Offset_adj);
+ gtk_scale_set_draw_value( GTK_SCALE(slider), FALSE );
+ gtk_widget_show(slider);
+ gtk_box_pack_start(GTK_BOX(hb),slider, TRUE, TRUE, AUX_BETWEEN_BUTTON_GROUPS);
+ g_object_set_data(G_OBJECT(vb), "offslide", slider);
+
+ /* Spinbutton */
+ GtkWidget *sbtn = gtk_spin_button_new(GTK_ADJUSTMENT(Offset_adj), 0.01, 2);
+ sp_dialog_defocus_on_enter(sbtn);
+ gtk_widget_show(sbtn);
+ gtk_box_pack_start(GTK_BOX(hb),sbtn, FALSE, TRUE, AUX_BETWEEN_BUTTON_GROUPS);
+ g_object_set_data(G_OBJECT(vb), "offspn", sbtn);
+
+ if (stop->offset>0 && stop->offset<1) {
+ gtk_widget_set_sensitive(slider, TRUE);
+ gtk_widget_set_sensitive(GTK_WIDGET(sbtn), TRUE);
+ } else {
+ gtk_widget_set_sensitive(slider, FALSE);
+ gtk_widget_set_sensitive(GTK_WIDGET(sbtn), FALSE);
+ }
+
+
+ /* Signals */
+ g_signal_connect(G_OBJECT(Offset_adj), "value_changed",
+ G_CALLBACK(offadjustmentChanged), vb);
+
+ // g_signal_connect(G_OBJECT(slider), "changed", G_CALLBACK(offsliderChanged), vb);
+ gtk_widget_show(hb);
+ gtk_box_pack_start(GTK_BOX(vb), hb, FALSE, FALSE, PAD);
+
+ // TRANSLATORS: "Stop" means: a "phase" of a gradient
+ f = gtk_frame_new(_("Stop Color"));
+ gtk_widget_show(f);
+ gtk_box_pack_start(GTK_BOX(vb), f, TRUE, TRUE, PAD);
+
+ Inkscape::UI::SelectedColor *selected_color = new Inkscape::UI::SelectedColor;
+ g_object_set_data(G_OBJECT(vb), "cselector", selected_color);
+ g_object_set_data(G_OBJECT(vb), "updating_color", reinterpret_cast<void*>(0));
+ selected_color->signal_changed.connect(sigc::bind(sigc::ptr_fun(&sp_gradient_vector_color_changed), selected_color, G_OBJECT(vb)));
+ selected_color->signal_dragged.connect(sigc::bind(sigc::ptr_fun(&sp_gradient_vector_color_changed), selected_color, G_OBJECT(vb)));
+
+ Gtk::Widget *color_selector = Gtk::manage(new ColorNotebook(*selected_color));
+ color_selector->show();
+ gtk_container_add(GTK_CONTAINER(f), color_selector->gobj());
+
+ /*
+ gtk_widget_show(csel);
+ gtk_container_add(GTK_CONTAINER(f), csel);
+ g_signal_connect(G_OBJECT(csel), "dragged", G_CALLBACK(sp_gradient_vector_color_dragged), vb);
+ g_signal_connect(G_OBJECT(csel), "changed", G_CALLBACK(sp_gradient_vector_color_changed), vb);
+ */
+
+ gtk_widget_show(vb);
+
+ sp_gradient_vector_widget_load_gradient(vb, gradient);
+
+ if (select_stop) {
+ select_stop_in_list(GTK_WIDGET(vb), gradient, select_stop);
+ }
+
+ return vb;
+}
+
+
+
+GtkWidget * sp_gradient_vector_editor_new(SPGradient *gradient, SPStop *stop)
+{
+ if (dlg == nullptr) {
+ Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+
+ dlg = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+ gtk_window_set_title ((GtkWindow *) dlg, _("Gradient editor"));
+ gtk_window_set_resizable ((GtkWindow *) dlg, true);
+
+ if (x == -1000 || y == -1000) {
+ x = prefs->getInt(prefs_path + "x", -1000);
+ y = prefs->getInt(prefs_path + "y", -1000);
+ }
+ if (w ==0 || h == 0) {
+ w = prefs->getInt(prefs_path + "w", 0);
+ h = prefs->getInt(prefs_path + "h", 0);
+ }
+
+ if (x<0) {
+ x=0;
+ }
+ if (y<0) {
+ y=0;
+ }
+
+ if (x != 0 || y != 0) {
+ gtk_window_move(reinterpret_cast<GtkWindow *>(dlg), x, y);
+ } else {
+ gtk_window_set_position(GTK_WINDOW(dlg), GTK_WIN_POS_CENTER);
+ }
+ if (w && h) {
+ gtk_window_resize(reinterpret_cast<GtkWindow *>(dlg), w, h);
+ }
+ sp_transientize(dlg);
+ wd.win = dlg;
+ wd.stop = 0;
+
+ GObject *obj = G_OBJECT(dlg);
+ sigc::connection *conn = nullptr;
+
+ conn = new sigc::connection(INKSCAPE.signal_activate_desktop.connect(sigc::bind(sigc::ptr_fun(&sp_transientize_callback), &wd)));
+ g_object_set_data(obj, "desktop-activate-connection", conn);
+
+ g_signal_connect(obj, "event", G_CALLBACK(sp_dialog_event_handler), dlg);
+ g_signal_connect(obj, "destroy", G_CALLBACK(sp_gradient_vector_dialog_destroy), dlg);
+ g_signal_connect(obj, "delete_event", G_CALLBACK(sp_gradient_vector_dialog_delete), dlg);
+
+ conn = new sigc::connection(INKSCAPE.signal_shut_down.connect(
+ sigc::hide_return(
+ sigc::bind(sigc::ptr_fun(&sp_gradient_vector_dialog_delete), (GtkWidget *) nullptr, (GdkEvent *) nullptr, (GtkWidget *) nullptr)
+ )));
+ g_object_set_data(obj, "shutdown-connection", conn);
+
+ conn = new sigc::connection(INKSCAPE.signal_dialogs_hide.connect(sigc::bind(sigc::ptr_fun(&gtk_widget_hide), dlg)));
+ g_object_set_data(obj, "dialog-hide-connection", conn);
+
+ conn = new sigc::connection(INKSCAPE.signal_dialogs_unhide.connect(sigc::bind(sigc::ptr_fun(&gtk_widget_show), dlg)));
+ g_object_set_data(obj, "dialog-unhide-connection", conn);
+
+ gtk_container_set_border_width(GTK_CONTAINER(dlg), PAD);
+
+ GtkWidget *wid = static_cast<GtkWidget*>(sp_gradient_vector_widget_new(gradient, stop));
+ g_object_set_data(G_OBJECT(dlg), "gradient-vector-widget", wid);
+ /* Connect signals */
+ gtk_widget_show(wid);
+ gtk_container_add(GTK_CONTAINER(dlg), wid);
+ } else {
+ // FIXME: temp fix for 0.38
+ // Simply load_gradient into the editor does not work for multi-stop gradients,
+ // as the stop list and other widgets are in a wrong state and crash readily.
+ // Instead we just delete the window (by sending the delete signal)
+ // and call sp_gradient_vector_editor_new again, so it creates the window anew.
+
+ GdkEventAny event;
+ GtkWidget *widget = static_cast<GtkWidget *>(dlg);
+ event.type = GDK_DELETE;
+ event.window = gtk_widget_get_window (widget);
+ event.send_event = TRUE;
+ g_object_ref(G_OBJECT(event.window));
+ gtk_main_do_event(reinterpret_cast<GdkEvent*>(&event));
+ g_object_unref(G_OBJECT(event.window));
+
+ g_assert(dlg == nullptr);
+ sp_gradient_vector_editor_new(gradient, stop);
+ }
+
+ return dlg;
+}
+
+static void sp_gradient_vector_widget_load_gradient(GtkWidget *widget, SPGradient *gradient)
+{
+ blocked = TRUE;
+
+ SPGradient *old;
+
+ old = static_cast<SPGradient*>(g_object_get_data(G_OBJECT(widget), "gradient"));
+
+ if (old != gradient) {
+ sigc::connection *release_connection;
+ sigc::connection *modified_connection;
+
+ release_connection = static_cast<sigc::connection *>(g_object_get_data(G_OBJECT(widget), "gradient_release_connection"));
+ modified_connection = static_cast<sigc::connection *>(g_object_get_data(G_OBJECT(widget), "gradient_modified_connection"));
+
+ if (old) {
+ g_assert( release_connection != nullptr );
+ g_assert( modified_connection != nullptr );
+ release_connection->disconnect();
+ modified_connection->disconnect();
+ sp_signal_disconnect_by_data(old, widget);
+ }
+
+ if (gradient) {
+ if (!release_connection) {
+ release_connection = new sigc::connection();
+ }
+ if (!modified_connection) {
+ modified_connection = new sigc::connection();
+ }
+ *release_connection = gradient->connectRelease(sigc::bind<1>(sigc::ptr_fun(&sp_gradient_vector_gradient_release), widget));
+ *modified_connection = gradient->connectModified(sigc::bind<2>(sigc::ptr_fun(&sp_gradient_vector_gradient_modified), widget));
+ } else {
+ if (release_connection) {
+ delete release_connection;
+ release_connection = nullptr;
+ }
+ if (modified_connection) {
+ delete modified_connection;
+ modified_connection = nullptr;
+ }
+ }
+
+ g_object_set_data(G_OBJECT(widget), "gradient_release_connection", release_connection);
+ g_object_set_data(G_OBJECT(widget), "gradient_modified_connection", modified_connection);
+ }
+
+ g_object_set_data(G_OBJECT(widget), "gradient", gradient);
+
+ if (gradient) {
+ gtk_widget_set_sensitive(widget, TRUE);
+
+ gradient->ensureVector();
+
+ SPStop *stop = get_selected_stop(widget);
+ if (!stop) {
+ return;
+ }
+
+ // get the color selector
+ SelectedColor *csel = static_cast<SelectedColor*>(g_object_get_data(G_OBJECT(widget), "cselector"));
+
+ g_object_set_data(G_OBJECT(widget), "updating_color", reinterpret_cast<void*>(1));
+ csel->setColorAlpha(stop->getColor(), stop->getOpacity());
+ g_object_set_data(G_OBJECT(widget), "updating_color", reinterpret_cast<void*>(0));
+
+ /* Fill preview */
+ GtkWidget *w = static_cast<GtkWidget *>(g_object_get_data(G_OBJECT(widget), "preview"));
+ sp_gradient_image_set_gradient(SP_GRADIENT_IMAGE(w), gradient);
+
+ update_stop_list(GTK_WIDGET(widget), gradient, nullptr);
+
+ // Once the user edits a gradient, it stops being auto-collectable
+ if (gradient->getRepr()->attribute("inkscape:collect")) {
+ SPDocument *document = gradient->document;
+ DocumentUndo::ScopedInsensitive _no_undo(document);
+ gradient->removeAttribute("inkscape:collect");
+ }
+ } else { // no gradient, disable everything
+ gtk_widget_set_sensitive(widget, FALSE);
+ }
+
+ blocked = FALSE;
+}
+
+static void sp_gradient_vector_dialog_destroy(GtkWidget * /*object*/, gpointer /*data*/)
+{
+ GObject *obj = G_OBJECT(dlg);
+ assert(obj != NULL);
+
+ sigc::connection *conn = static_cast<sigc::connection *>(g_object_get_data(obj, "desktop-activate-connection"));
+ assert(conn != NULL);
+ conn->disconnect();
+ delete conn;
+
+ conn = static_cast<sigc::connection *>(g_object_get_data(obj, "shutdown-connection"));
+ assert(conn != NULL);
+ conn->disconnect();
+ delete conn;
+
+ conn = static_cast<sigc::connection *>(g_object_get_data(obj, "dialog-hide-connection"));
+ assert(conn != NULL);
+ conn->disconnect();
+ delete conn;
+
+ conn = static_cast<sigc::connection *>(g_object_get_data(obj, "dialog-unhide-connection"));
+ assert(conn != NULL);
+ conn->disconnect();
+ delete conn;
+
+ wd.win = dlg = nullptr;
+ wd.stop = 0;
+}
+
+static gboolean sp_gradient_vector_dialog_delete(GtkWidget */*widget*/, GdkEvent */*event*/, GtkWidget */*dialog*/)
+{
+ gtk_window_get_position(GTK_WINDOW(dlg), &x, &y);
+ gtk_window_get_size(GTK_WINDOW(dlg), &w, &h);
+
+ if (x<0) {
+ x=0;
+ }
+ if (y<0) {
+ y=0;
+ }
+
+ Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+ prefs->setInt(prefs_path + "x", x);
+ prefs->setInt(prefs_path + "y", y);
+ prefs->setInt(prefs_path + "w", w);
+ prefs->setInt(prefs_path + "h", h);
+
+ return FALSE; // which means, go ahead and destroy it
+}
+
+/* Widget destroy handler */
+static void sp_gradient_vector_widget_destroy(GtkWidget *object, gpointer /*data*/)
+{
+ SPObject *gradient = SP_OBJECT(g_object_get_data(G_OBJECT(object), "gradient"));
+
+ sigc::connection *release_connection = static_cast<sigc::connection *>(g_object_get_data(G_OBJECT(object), "gradient_release_connection"));
+ sigc::connection *modified_connection = static_cast<sigc::connection *>(g_object_get_data(G_OBJECT(object), "gradient_modified_connection"));
+
+ if (gradient) {
+ g_assert( release_connection != nullptr );
+ g_assert( modified_connection != nullptr );
+ release_connection->disconnect();
+ modified_connection->disconnect();
+ sp_signal_disconnect_by_data(gradient, object);
+
+ if (gradient->getRepr()) {
+ sp_repr_remove_listener_by_data(gradient->getRepr(), object);
+ }
+ }
+
+ SelectedColor *selected_color = static_cast<SelectedColor *>(g_object_get_data(G_OBJECT(object), "cselector"));
+ if (selected_color) {
+ delete selected_color;
+ g_object_set_data(G_OBJECT(object), "cselector", nullptr);
+ }
+}
+
+static void sp_gradient_vector_gradient_release(SPObject */*object*/, GtkWidget *widget)
+{
+ sp_gradient_vector_widget_load_gradient(widget, nullptr);
+}
+
+static void sp_gradient_vector_gradient_modified(SPObject *object, guint /*flags*/, GtkWidget *widget)
+{
+ SPGradient *gradient=SP_GRADIENT(object);
+ if (!blocked) {
+ blocked = TRUE;
+ sp_gradient_vector_widget_load_gradient(widget, gradient);
+ blocked = FALSE;
+ }
+}
+
+static void sp_gradient_vector_color_dragged(Inkscape::UI::SelectedColor *selected_color, GObject *object)
+{
+ SPGradient *gradient, *ngr;
+
+ if (blocked) {
+ return;
+ }
+
+ gradient = static_cast<SPGradient*>(g_object_get_data(G_OBJECT(object), "gradient"));
+ if (!gradient) {
+ return;
+ }
+
+ blocked = TRUE;
+
+ ngr = sp_gradient_ensure_vector_normalized(gradient);
+ if (ngr != gradient) {
+ /* Our master gradient has changed */
+ sp_gradient_vector_widget_load_gradient(GTK_WIDGET(object), ngr);
+ }
+
+ ngr->ensureVector();
+
+ SPStop *stop = get_selected_stop(GTK_WIDGET(object));
+ if (!stop) {
+ return;
+ }
+
+ SPColor color = stop->getColor();
+ gfloat opacity = stop->getOpacity();
+ selected_color->colorAlpha(color, opacity);
+ stop->style->stop_color.currentcolor = false;
+
+ blocked = FALSE;
+}
+
+static void sp_gradient_vector_color_changed(Inkscape::UI::SelectedColor *selected_color, GObject *object)
+{
+ (void)selected_color;
+
+ void* updating_color = g_object_get_data(G_OBJECT(object), "updating_color");
+ if (updating_color) {
+ return;
+ }
+
+ if (blocked) {
+ return;
+ }
+
+ SPGradient *gradient = static_cast<SPGradient*>(g_object_get_data(G_OBJECT(object), "gradient"));
+ if (!gradient) {
+ return;
+ }
+
+ blocked = TRUE;
+
+ SPGradient *ngr = sp_gradient_ensure_vector_normalized(gradient);
+ if (ngr != gradient) {
+ /* Our master gradient has changed */
+ sp_gradient_vector_widget_load_gradient(GTK_WIDGET(object), ngr);
+ }
+
+ ngr->ensureVector();
+
+ /* Set start parameters */
+ /* We rely on normalized vector, i.e. stops HAVE to exist */
+ g_return_if_fail(ngr->getFirstStop() != nullptr);
+
+ SPStop *stop = get_selected_stop(GTK_WIDGET(object));
+ if (!stop) {
+ return;
+ }
+
+ SelectedColor *csel = static_cast<SelectedColor *>(g_object_get_data(G_OBJECT(object), "cselector"));
+ SPColor color;
+ float alpha = 0;
+ csel->colorAlpha(color, alpha);
+
+ sp_repr_set_css_double(stop->getRepr(), "offset", stop->offset);
+ Inkscape::CSSOStringStream os;
+ os << "stop-color:" << color.toString() << ";stop-opacity:" << static_cast<gdouble>(alpha) <<";";
+ stop->setAttribute("style", os.str());
+ // g_snprintf(c, 256, "stop-color:#%06x;stop-opacity:%g;", rgb >> 8, static_cast<gdouble>(alpha));
+ //stop->setAttribute("style", c);
+
+ DocumentUndo::done(ngr->document, SP_VERB_CONTEXT_GRADIENT,
+ _("Change gradient stop color"));
+
+ blocked = FALSE;
+
+ // Set the color in the selected stop after change
+ GtkWidget *combo_box = static_cast<GtkWidget *>(g_object_get_data(G_OBJECT(object), "combo_box"));
+ if (combo_box) {
+ GtkTreeIter iter;
+ if (gtk_combo_box_get_active_iter (GTK_COMBO_BOX(combo_box), &iter)) {
+ GtkListStore *store = GTK_LIST_STORE(gtk_combo_box_get_model(GTK_COMBO_BOX(combo_box)));
+
+ Inkscape::UI::Widget::ColorPreview *cp = Gtk::manage(new Inkscape::UI::Widget::ColorPreview(stop->get_rgba32()));
+ GdkPixbuf *pb = cp->toPixbuf(64, 16);
+
+ gtk_list_store_set (store, &iter, 0, pb, /*1, repr->attribute("id"),*/ 2, stop, -1);
+ }
+ }
+
+}
+
+/*
+ Local Variables:
+ mode:c++
+ c-file-style:"stroustrup"
+ c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
+ indent-tabs-mode:nil
+ fill-column:99
+ End:
+*/
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :
diff --git a/src/widgets/gradient-vector.h b/src/widgets/gradient-vector.h
new file mode 100644
index 0000000..c30cb32
--- /dev/null
+++ b/src/widgets/gradient-vector.h
@@ -0,0 +1,90 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+#ifndef SEEN_GRADIENT_VECTOR_H
+#define SEEN_GRADIENT_VECTOR_H
+
+/*
+ * Gradient vector selection widget
+ *
+ * Author:
+ * Lauris Kaplinski <lauris@kaplinski.com>
+ * Jon A. Cruz <jon@joncruz.org>
+ *
+ * Copyright (C) 2010 Jon A. Cruz
+ * Copyright (C) 2001-2002 Lauris Kaplinski
+ * Copyright (C) 2001 Ximian, Inc.
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#include <gtkmm/liststore.h>
+#include <sigc++/connection.h>
+#include "gradient-selector.h"
+
+#define SP_TYPE_GRADIENT_VECTOR_SELECTOR (sp_gradient_vector_selector_get_type ())
+#define SP_GRADIENT_VECTOR_SELECTOR(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), SP_TYPE_GRADIENT_VECTOR_SELECTOR, SPGradientVectorSelector))
+#define SP_GRADIENT_VECTOR_SELECTOR_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), SP_TYPE_GRADIENT_VECTOR_SELECTOR, SPGradientVectorSelectorClass))
+#define SP_IS_GRADIENT_VECTOR_SELECTOR(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), SP_TYPE_GRADIENT_VECTOR_SELECTOR))
+#define SP_IS_GRADIENT_VECTOR_SELECTOR_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), SP_TYPE_GRADIENT_VECTOR_SELECTOR))
+
+class SPDocument;
+class SPObject;
+class SPGradient;
+class SPStop;
+
+struct SPGradientVectorSelector {
+ GtkBox vbox;
+
+ guint idlabel : 1;
+
+ bool swatched;
+
+ SPDocument *doc;
+ SPGradient *gr;
+
+ /* Gradient vectors store */
+ Glib::RefPtr<Gtk::ListStore> store;
+ SPGradientSelector::ModelColumns *columns;
+
+ sigc::connection gradient_release_connection;
+ sigc::connection defs_release_connection;
+ sigc::connection defs_modified_connection;
+ sigc::connection tree_select_connection;
+
+ void setSwatched();
+};
+
+struct SPGradientVectorSelectorClass {
+ GtkBoxClass parent_class;
+
+ void (* vector_set) (SPGradientVectorSelector *gvs, SPGradient *gr);
+};
+
+GType sp_gradient_vector_selector_get_type();
+
+GtkWidget *sp_gradient_vector_selector_new (SPDocument *doc, SPGradient *gradient);
+
+void sp_gradient_vector_selector_set_gradient (SPGradientVectorSelector *gvs, SPDocument *doc, SPGradient *gr);
+
+SPDocument *sp_gradient_vector_selector_get_document (SPGradientVectorSelector *gvs);
+SPGradient *sp_gradient_vector_selector_get_gradient (SPGradientVectorSelector *gvs);
+
+/* fixme: rethink this (Lauris) */
+GtkWidget *sp_gradient_vector_editor_new (SPGradient *gradient, SPStop *stop = nullptr);
+
+guint32 sp_average_color(guint32 c1, guint32 c2, gdouble p = 0.5);
+
+Glib::ustring gr_prepare_label (SPObject *obj);
+Glib::ustring gr_ellipsize_text(Glib::ustring const &src, size_t maxlen);
+
+#endif // SEEN_GRADIENT_VECTOR_H
+
+/*
+ Local Variables:
+ mode:c++
+ c-file-style:"stroustrup"
+ c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
+ indent-tabs-mode:nil
+ fill-column:99
+ End:
+*/
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :
diff --git a/src/widgets/ink-action.cpp b/src/widgets/ink-action.cpp
new file mode 100644
index 0000000..0696228
--- /dev/null
+++ b/src/widgets/ink-action.cpp
@@ -0,0 +1,200 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/** @file
+ * TODO: insert short description here
+ *//*
+ * Authors: see git history
+ *
+ * Copyright (C) 2018 Authors
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+#include "ink-action.h"
+#include "ui/icon-loader.h"
+#include <gtk/gtk.h>
+
+static void ink_action_finalize( GObject* obj );
+static void ink_action_get_property( GObject* obj, guint propId, GValue* value, GParamSpec * pspec );
+static void ink_action_set_property( GObject* obj, guint propId, const GValue *value, GParamSpec* pspec );
+
+static GtkWidget* ink_action_create_menu_item( GtkAction* action );
+static GtkWidget* ink_action_create_tool_item( GtkAction* action );
+
+typedef struct
+{
+ gchar* iconId;
+ GtkIconSize iconSize;
+} InkActionPrivate;
+
+#define INK_ACTION_GET_PRIVATE( o ) \
+ reinterpret_cast<InkActionPrivate *>(ink_action_get_instance_private (o))
+
+G_DEFINE_TYPE_WITH_PRIVATE(InkAction, ink_action, GTK_TYPE_ACTION);
+
+enum {
+ PROP_INK_ID = 1,
+ PROP_INK_SIZE
+};
+
+static void ink_action_class_init( InkActionClass* klass )
+{
+ if ( klass ) {
+ GObjectClass * objClass = G_OBJECT_CLASS( klass );
+
+ objClass->finalize = ink_action_finalize;
+ objClass->get_property = ink_action_get_property;
+ objClass->set_property = ink_action_set_property;
+
+ klass->parent_class.create_menu_item = ink_action_create_menu_item;
+ klass->parent_class.create_tool_item = ink_action_create_tool_item;
+ /*klass->parent_class.connect_proxy = connect_proxy;*/
+ /*klass->parent_class.disconnect_proxy = disconnect_proxy;*/
+
+ g_object_class_install_property( objClass,
+ PROP_INK_ID,
+ g_param_spec_string( "iconId",
+ "Icon ID",
+ "The id for the icon",
+ "",
+ (GParamFlags)(G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT) ) );
+
+ g_object_class_install_property( objClass,
+ PROP_INK_SIZE,
+ g_param_spec_int( "iconSize",
+ "Icon Size",
+ "The size the icon",
+ (int)GTK_ICON_SIZE_MENU,
+ (int)GTK_ICON_SIZE_DIALOG,
+ (int)GTK_ICON_SIZE_SMALL_TOOLBAR,
+ (GParamFlags)(G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT) ) );
+ }
+}
+
+static void ink_action_init( InkAction* action )
+{
+ auto priv = INK_ACTION_GET_PRIVATE (action);
+ priv->iconId = nullptr;
+ priv->iconSize = GTK_ICON_SIZE_SMALL_TOOLBAR;
+}
+
+static void ink_action_finalize( GObject* obj )
+{
+ InkAction* action = INK_ACTION( obj );
+ auto priv = INK_ACTION_GET_PRIVATE (action);
+
+ g_free( priv->iconId );
+ g_free( priv );
+
+}
+
+//Any strings passed in should already be localised
+InkAction* ink_action_new( const gchar *name,
+ const gchar *label,
+ const gchar *tooltip,
+ const gchar *inkId,
+ GtkIconSize size )
+{
+ GObject* obj = (GObject*)g_object_new( INK_ACTION_TYPE,
+ "name", name,
+ "label", label,
+ "tooltip", tooltip,
+ "iconId", inkId,
+ "iconSize", size,
+ NULL );
+
+ InkAction* action = INK_ACTION( obj );
+
+ return action;
+}
+
+static void ink_action_get_property( GObject* obj, guint propId, GValue* value, GParamSpec * pspec )
+{
+ InkAction* action = INK_ACTION( obj );
+ auto priv = INK_ACTION_GET_PRIVATE (action);
+
+ switch ( propId ) {
+ case PROP_INK_ID:
+ {
+ g_value_set_string( value, priv->iconId );
+ }
+ break;
+
+ case PROP_INK_SIZE:
+ {
+ g_value_set_int( value, priv->iconSize );
+ }
+ break;
+
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID( obj, propId, pspec );
+ }
+}
+
+void ink_action_set_property( GObject* obj, guint propId, const GValue *value, GParamSpec* pspec )
+{
+ InkAction* action = INK_ACTION( obj );
+ auto priv = INK_ACTION_GET_PRIVATE (action);
+
+ switch ( propId ) {
+ case PROP_INK_ID:
+ {
+ gchar* tmp = priv->iconId;
+ priv->iconId = g_value_dup_string( value );
+ g_free( tmp );
+ }
+ break;
+
+ case PROP_INK_SIZE:
+ {
+ priv->iconSize = (GtkIconSize)g_value_get_int( value );
+ }
+ break;
+
+ default:
+ {
+ G_OBJECT_WARN_INVALID_PROPERTY_ID( obj, propId, pspec );
+ }
+ }
+}
+
+static GtkWidget* ink_action_create_menu_item( GtkAction* action )
+{
+ InkAction* act = INK_ACTION( action );
+ GtkWidget* item = GTK_ACTION_CLASS(ink_action_parent_class)->create_menu_item( action );
+
+ return item;
+}
+
+static GtkWidget* ink_action_create_tool_item( GtkAction* action )
+{
+ InkAction* act = INK_ACTION( action );
+ auto priv = INK_ACTION_GET_PRIVATE (act);
+ GtkWidget* item = GTK_ACTION_CLASS(ink_action_parent_class)->create_tool_item(action);
+
+ if ( priv->iconId ) {
+ if ( GTK_IS_TOOL_BUTTON(item) ) {
+ GtkToolButton* button = GTK_TOOL_BUTTON(item);
+
+ GtkWidget *child = sp_get_icon_image(priv->iconId, priv->iconSize);
+ gtk_tool_button_set_icon_widget( button, child );
+ } else {
+ // For now trigger a warning but don't do anything else
+ GtkToolButton* button = GTK_TOOL_BUTTON(item);
+ (void)button;
+ }
+ }
+
+ // TODO investigate if needed
+ gtk_widget_show_all( item );
+
+ return item;
+}
+
+/*
+ Local Variables:
+ mode:c++
+ c-file-style:"stroustrup"
+ c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
+ indent-tabs-mode:nil
+ fill-column:99
+ End:
+*/
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :
diff --git a/src/widgets/ink-action.h b/src/widgets/ink-action.h
new file mode 100644
index 0000000..d97afe1
--- /dev/null
+++ b/src/widgets/ink-action.h
@@ -0,0 +1,61 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/** @file
+ * TODO: insert short description here
+ *//*
+ * Authors: see git history
+ *
+ * Copyright (C) 2017 Authors
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+#ifndef SEEN_INK_ACTION
+#define SEEN_INK_ACTION
+
+#include <gtk/gtk.h>
+#include "attributes.h"
+
+/* Equivalent to GTK Actions of the same type, but can support Inkscape SVG icons */
+
+G_BEGIN_DECLS
+
+#define INK_ACTION_TYPE ( ink_action_get_type() )
+#define INK_ACTION( obj ) ( G_TYPE_CHECK_INSTANCE_CAST( (obj), INK_ACTION_TYPE, InkAction) )
+#define INK_ACTION_CLASS( klass ) ( G_TYPE_CHECK_CLASS_CAST( (klass), INK_ACTION_TYPE, InkActionClass) )
+#define IS_INK_ACTION( obj ) ( G_TYPE_CHECK_INSTANCE_TYPE( (obj), INK_ACTION_TYPE) )
+#define IS_INK_ACTION_CLASS( klass ) ( G_TYPE_CHECK_CLASS_TYPE( (klass), INK_ACTION_TYPE) )
+#define INK_ACTION_GET_CLASS( obj ) ( G_TYPE_INSTANCE_GET_CLASS( (obj), INK_ACTION_TYPE, InkActionClass) )
+
+typedef struct _InkAction InkAction;
+typedef struct _InkActionClass InkActionClass;
+
+struct _InkAction
+{
+ GtkAction action;
+};
+
+struct _InkActionClass
+{
+ GtkActionClass parent_class;
+};
+
+GType ink_action_get_type( void );
+
+InkAction* ink_action_new( const gchar *name,
+ const gchar *label,
+ const gchar *tooltip,
+ const gchar *inkId,
+ GtkIconSize size );
+
+
+G_END_DECLS
+
+#endif /* SEEN_INK_ACTION */
+/*
+ Local Variables:
+ mode:c++
+ c-file-style:"stroustrup"
+ c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
+ indent-tabs-mode:nil
+ fill-column:99
+ End:
+*/
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :
diff --git a/src/widgets/mappings.xml b/src/widgets/mappings.xml
new file mode 100644
index 0000000..3ea9cb3
--- /dev/null
+++ b/src/widgets/mappings.xml
@@ -0,0 +1,334 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<mappings>
+
+ <!-- file menu -->
+ <remap id='file_import' newid='document-import'/>
+ <remap id='file_export' newid='document-export'/>
+ <remap id='ocal_import' newid='document-import-ocal'/>
+ <remap id='ocal_export' newid='document-export-ocal'/>
+ <remap id='document_metadata' newid='document-metadata'/>
+ <remap id='input_devices' newid='dialog-input-devices'/>
+
+ <!-- edit menu -->
+ <remap id='edit_duplicate' newid='edit-duplicate'/>
+ <remap id='edit_clone' newid='edit-clone'/>
+ <remap id='edit_unlink_clone' newid='edit-clone-unlink'/>
+ <remap id='edit_select_original' newid='edit-select-original'/>
+ <remap id='edit_undo_history' newid='edit-undo-history'/>
+ <remap id='selection_paste_in_place' newid='edit-paste-in-place'/>
+ <remap id='selection_paste_style' newid='edit-paste-style'/>
+ <remap id='selection_bitmap' newid='selection-make-bitmap-copy'/>
+ <remap id='selection_select_all' newid='edit-select-all'/>
+ <remap id='selection_select_all_in_all_layers' newid='edit-select-all-layers'/>
+ <remap id='selection_invert' newid='edit-select-invert'/>
+ <remap id='selection_deselect' newid='edit-select-none'/>
+ <remap id='xml_editor' newid='dialog-xml-editor'/>
+
+ <!-- view menu -->
+ <!-- submenu: zoom -->
+ <remap id='zoom_1_to_1' newid='zoom-original'/>
+ <remap id='zoom_1_to_2' newid='zoom-half-size'/>
+ <remap id='zoom_2_to_1' newid='zoom-double-size'/>
+ <remap id='zoom_select' newid='zoom-fit-selection'/>
+ <remap id='zoom_draw' newid='zoom-fit-drawing'/>
+ <remap id='zoom_page' newid='zoom-fit-page'/>
+ <remap id='zoom_pagewidth' newid='zoom-fit-width'/>
+ <remap id='zoom_previous' newid='zoom-previous'/>
+ <remap id='zoom_next' newid='zoom-next'/>
+ <remap id='zoom_in' newid='zoom-in'/>
+ <remap id='zoom_out' newid='zoom-out'/>
+
+ <remap id='grid' newid='show-grid'/>
+ <remap id='guides' newid='show-guides'/>
+ <remap id='color_management' newid='color-management'/>
+ <remap id='dialog_toggle' newid='show-dialogs'/>
+ <remap id='messages' newid='dialog-messages'/>
+ <remap id='scripts' newid='dialog-scripts'/>
+ <remap id='window_previous' newid='window-previous'/>
+ <remap id='window_next' newid='window-next'/>
+ <remap id='view_icon_preview' newid='dialog-icon-preview'/>
+ <remap id='view_new' newid='window-new'/>
+ <remap id='fullscreen' newid='view-fullscreen'/>
+
+ <!-- layers menu -->
+ <remap id='new_layer' newid='layer-new'/>
+ <remap id='rename_layer' newid='layer-rename'/>
+ <remap id='switch_to_layer_above' newid='layer-previous'/>
+ <remap id='switch_to_layer_below' newid='layer-next'/>
+ <remap id='move_selection_above' newid='selection-move-to-layer-above'/>
+ <remap id='move_selection_below' newid='selection-move-to-layer-below'/>
+ <remap id='raise_layer' newid='layer-raise'/>
+ <remap id='lower_layer' newid='layer-lower'/>
+ <remap id='layer_to_top' newid='layer-top'/>
+ <remap id='layer_to_bottom' newid='layer-bottom'/>
+ <remap id='delete_layer' newid='layer-delete'/>
+ <remap id='layers' newid='dialog-layers'/>
+
+ <!-- object menu -->
+ <remap id='fill_and_stroke' newid='dialog-fill-and-stroke'/>
+ <remap id='dialog_item_properties' newid='dialog-object-properties'/>
+ <remap id='selection_group' newid='object-group'/>
+ <remap id='selection_ungroup' newid='object-ungroup'/>
+ <remap id='selection_up' newid='selection-raise'/>
+ <remap id='selection_down' newid='selection-lower'/>
+ <remap id='selection_top' newid='selection-top'/>
+ <remap id='selection_bot' newid='selection-bottom'/>
+ <remap id='object_rotate_90_CCW' newid='object-rotate-left'/>
+ <remap id='object_rotate_90_CW' newid='object-rotate-right'/>
+ <remap id='object_flip_hor' newid='object-flip-horizontal'/>
+ <remap id='object_flip_ver' newid='object-flip-vertical'/>
+ <remap id='object_trans' newid='dialog-transform'/>
+ <remap id='object_align' newid='dialog-align-and-distribute'/>
+ <remap id='grid_arrange' newid='dialog-rows-and-columns'/>
+
+ <!-- path menu -->
+ <remap id='object_tocurve' newid='object-to-path'/>
+ <remap id='stroke_tocurve' newid='stroke-to-path'/>
+ <remap id='selection_trace' newid='bitmap-trace'/>
+ <remap id='union' newid='path-union'/>
+ <remap id='difference' newid='path-difference'/>
+ <remap id='intersection' newid='path-intersection'/>
+ <remap id='exclusion' newid='path-exclusion'/>
+ <remap id='division' newid='path-division'/>
+ <remap id='cut_path' newid='path-cut'/>
+ <remap id='selection_combine' newid='path-combine'/>
+ <remap id='selection_break' newid='path-break-apart'/>
+ <remap id='outset_path' newid='path-outset'/>
+ <remap id='inset_path' newid='path-inset'/>
+ <remap id='dynamic_offset' newid='path-offset-dynamic'/>
+ <remap id='linked_offset' newid='path-offset-linked'/>
+ <remap id='simplify' newid='path-simplify'/>
+ <remap id='selection_reverse' newid='path-reverse'/>
+
+
+ <!-- text menu -->
+ <remap id='object_font' newid='dialog-text-and-font'/>
+ <remap id='put_on_path' newid='text-put-on-path'/>
+ <remap id='remove_from_path' newid='text-remove-from-path'/>
+ <remap id='flow_into_frame' newid='text-flow-into-frame'/>
+ <remap id='unflow' newid='text-unflow'/>
+ <remap id='convert_to_text' newid='text-convert-to-regular'/>
+ <remap id='remove_manual_kerns' newid='text-unkern'/>
+
+ <!-- help menu -->
+ <remap id='help_keys' newid='help-keyboard-shortcuts'/>
+ <remap id='help_tutorials' newid='help-contents'/>
+ <remap id='inkscape_options' newid='inkscape-logo'/>
+ <remap id='about_memory' newid='dialog-memory'/>
+
+ <!-- tools -->
+ <remap id='draw_select' newid='tool-pointer'/>
+ <remap id='draw_node' newid='tool-node-editor'/>
+ <remap id='draw_tweak' newid='tool-tweak'/>
+ <remap id='draw_zoom' newid='zoom'/>
+ <remap id='draw_rect' newid='draw-rectangle'/>
+ <remap id='draw_3dbox' newid='draw-cuboid'/>
+ <remap id='draw_arc' newid='draw-ellipse'/>
+ <remap id='draw_star' newid='draw-polygon-star'/>
+ <remap id='draw_spiral' newid='draw-spiral'/>
+ <remap id='draw_freehand' newid='draw-freehand'/>
+ <remap id='draw_pen' newid='draw-path'/>
+ <remap id='draw_calligraphic' newid='draw-calligraphic'/>
+ <remap id='draw_erase' newid='draw-eraser'/>
+ <remap id='draw_paintbucket' newid='color-fill'/>
+ <remap id='draw_text' newid='draw-text'/>
+ <remap id='draw_connector' newid='draw-connector'/>
+ <remap id='draw_gradient' newid='color-gradient'/>
+ <remap id='draw_dropper' newid='color-picker'/>
+
+ <!-- TOOLBARS -->
+ <!-- select toolbar -->
+ <remap id='transform_stroke' newid='transform-affect-stroke'/>
+ <remap id='transform_corners' newid='transform-affect-rounded-corners'/>
+ <remap id='transform_gradient' newid='transform-affect-gradient'/>
+ <remap id='transform_pattern' newid='transform-affect-pattern'/>
+
+ <!-- node editor toolbar -->
+ <remap id='node_insert' newid='node-add'/>
+ <remap id='node_delete' newid='node-delete'/>
+ <remap id='node_join' newid='node-join'/>
+ <remap id='node_break' newid='node-break'/>
+ <remap id='node_join_segment' newid='node-join-segment'/>
+ <remap id='node_delete_segment' newid='node-delete-segment'/>
+ <remap id='node_cusp' newid='node-type-cusp'/>
+ <remap id='node_smooth' newid='node-type-smooth'/>
+ <remap id='node_symmetric' newid='node-type-symmetric'/>
+ <remap id='node_auto' newid='node-type-auto-smooth'/>
+ <remap id='node_curve' newid='node-segment-curve'/>
+ <remap id='node_line' newid='node-segment-line'/>
+ <remap id='nodes_show_handles' newid='show-node-handles'/>
+ <remap id='edit_next_parameter' newid='path-effect-parameter-next'/>
+ <remap id='nodes_show_helperpath' newid='show-path-outline'/>
+ <remap id='nodeedit-clippath' newid='path-clip-edit'/>
+ <remap id='nodeedit-mask' newid='path-mask-edit'/>
+ <remap id='node_cusp' newid='node-type-cusp'/>
+
+ <!-- tweak toolbar -->
+ <remap id='tweak_move_mode' newid='object-tweak-push'/>
+ <remap id='tweak_move_mode_inout' newid='object-tweak-attract'/>
+ <remap id='tweak_move_mode_jitter' newid='object-tweak-randomize'/>
+ <remap id='tweak_scale_mode' newid='object-tweak-shrink'/>
+ <remap id='tweak_rotate_mode' newid='object-tweak-rotate'/>
+ <remap id='tweak_moreless_mode' newid='object-tweak-duplicate'/>
+ <remap id='tweak_move_mode' newid='object-tweak-push'/>
+ <remap id='tweak_push_mode' newid='path-tweak-push'/>
+ <remap id='tweak_shrink_mode' newid='path-tweak-shrink'/>
+ <remap id='tweak_attract_mode' newid='path-tweak-attract'/>
+ <remap id='tweak_roughen_mode' newid='path-tweak-roughen'/>
+ <remap id='tweak_colorpaint_mode' newid='object-tweak-paint'/>
+ <remap id='tweak_colorjitter_mode' newid='object-tweak-jitter-color'/>
+ <remap id='tweak_blur_mode' newid='object-tweak-blur'/>
+
+ <!-- rectangle toolbar -->
+ <remap id='squared_corner' newid='rectangle-make-corners-sharp'/>
+
+ <!-- cuboid toolbar -->
+ <remap id='toggle_vp_x' newid='perspective-parallel'/>
+
+ <!-- ellipse toolbar -->
+ <remap id='reset_circle' newid='draw-ellipse-whole'/>
+ <remap id='circle_closed_arc' newid='draw-ellipse-segment'/>
+ <remap id='circle_open_arc' newid='draw-ellipse-arc'/>
+
+ <!-- polygon toolbar -->
+ <remap id='star_flat' newid='draw-polygon'/>
+ <remap id='star_angled' newid='draw-star'/>
+
+ <!-- bezier toolbar -->
+ <remap id='bezier_mode' newid='path-mode-bezier'/>
+ <remap id='spiro_splines_mode' newid='path-mode-spiro'/>
+ <remap id='bspline_mode' newid='path-mode-bspline'/>
+ <remap id='polylines_mode' newid='path-mode-polyline'/>
+ <remap id='paraxial_lines_mode' newid='path-mode-polyline-paraxial'/>
+
+ <!-- calligraphic toolbar -->
+ <remap id='guse_tilt' newid='draw-use-tilt'/>
+ <remap id='guse_pressure' newid='draw-use-pressure'/>
+ <remap id='trace_background' newid='draw-trace-background'/>
+
+ <!-- eraser toolbar -->
+ <remap id='delete_object' newid='draw-eraser-delete-objects'/>
+
+ <!-- text toolbar -->
+ <remap id='writing_mode_tb' newid='format-text-direction-vertical'/>
+ <remap id='writing_mode_lr' newid='format-text-direction-horizontal'/>
+
+ <!-- connector toolbar -->
+ <remap id='connector_avoid' newid='connector-avoid'/>
+ <remap id='connector_ignore' newid='connector-ignore'/>
+
+ <!-- gradient toolbar -->
+ <remap id='controls_fill' newid='object-fill'/>
+ <remap id='controls_stroke' newid='object-stroke'/>
+
+ <!-- lpe toolbar -->
+ <remap id='lpetool_show_bbox' newid='show-bounding-box'/>
+ <remap id='all_inactive_old' newid='draw-geometry-inactive'/>
+ <remap id='angle_bisector' newid='draw-geometry-angle-bisector'/>
+ <remap id='circle_3pts' newid='draw-geometry-circle-from-three-points'/>
+ <remap id='line_segment' newid='draw-geometry-line-segment'/>
+ <remap id='mirror_symmetry' newid='draw-geometry-mirror'/>
+ <remap id='parralel' newid='draw-geometry-line-parallel'/>
+ <remap id='perp_bisector' newid='draw-geometry-line-perpendicular'/>
+
+ <!-- snapping toolbar -->
+ <remap id='toggle_snap_global' newid='snap'/>
+ <remap id='toggle_snap_bbox' newid='snap-bounding-box'/>
+ <remap id='toggle_snap_to_bbox_path' newid='snap-bounding-box-edges'/>
+ <remap id='toggle_snap_to_bbox_node' newid='snap-bounding-box-corners'/>
+ <remap id='toggle_snap_to_bbox_edge_midpoints' newid='snap-bounding-box-midpoints'/>
+ <remap id='toggle_snap_to_bbox_midpoints' newid='snap-bounding-box-center'/>
+ <remap id='toggle_snap_nodes' newid='snap-nodes'/>
+ <remap id='toggle_snap_to_paths' newid='snap-nodes-path'/>
+ <remap id='toggle_snap_to_nodes' newid='snap-nodes-cusp'/>
+ <remap id='toggle_snap_to_smooth_nodes' newid='snap-nodes-smooth'/>
+ <remap id='toggle_snap_to_midpoints' newid='snap-nodes-midpoint'/>
+ <remap id='toggle_snap_to_path_intersections' newid='snap-nodes-intersection'/>
+ <remap id='toggle_snap_to_bbox_midpoints-3' newid='snap-nodes-center'/>
+ <remap id='toggle_snap_center' newid='snap-nodes-rotation-center'/>
+ <remap id='toggle_snap_page_border' newid='snap-page'/>
+ <remap id='toggle_snap_grid_guide_intersections' newid='snap-grid-guide-intersections'/>
+
+ <!-- DIALOGS -->
+ <!-- align and distribute dialog -->
+ <remap id='al_left_out' newid='align-horizontal-right-to-anchor'/>
+ <remap id='al_left_in' newid='align-horizontal-left'/>
+ <remap id='al_center_hor' newid='align-horizontal-center'/>
+ <remap id='al_right_in' newid='align-horizontal-right'/>
+ <remap id='al_right_out' newid='align-horizontal-left-to-anchor'/>
+ <remap id='al_baselines_vert' newid='align-horizontal-baseline'/>
+
+ <remap id='al_top_out' newid='align-vertical-bottom-to-anchor'/>
+ <remap id='al_top_in' newid='align-vertical-top'/>
+ <remap id='al_center_ver' newid='align-vertical-center'/>
+ <remap id='al_bottom_in' newid='align-vertical-bottom'/>
+ <remap id='al_bottom_out' newid='align-vertical-top-to-anchor'/>
+ <remap id='al_baselines_hor' newid='align-vertical-baseline'/>
+
+ <remap id='distribute_left' newid='distribute-horizontal-left'/>
+ <remap id='distribute_hcentre' newid='distribute-horizontal-center'/>
+ <remap id='distribute_right' newid='distribute-horizontal-right'/>
+ <remap id='distrobute-hdist' newid='distribute-horizontal-gaps'/>
+ <remap id='distribute_baselines_hor' newid='distribute-horizontal-baseline'/>
+
+ <remap id='distribute_bottom' newid='distribute-vertical-bottom'/>
+ <remap id='distribute_vcentre' newid='distribute-vertical-center'/>
+ <remap id='distribute_top' newid='distribute-vertical-top'/>
+ <remap id='distrobute-vdist' newid='distribute-vertical-gaps'/>
+ <remap id='distribute_baselines_vert' newid='distribute-vertical-baseline'/>
+
+ <remap id='distribute_randomize' newid='distribute-randomize'/>
+ <remap id='unclump' newid='distribute-unclump'/>
+ <remap id='graph_layout' newid='distribute-graph'/>
+ <remap id='directed_graph' newid='distribute-graph-directed'/>
+ <remap id='remove_overlaps' newid='distribute-remove-overlaps'/>
+
+ <remap id='node_valign' newid='align-horizontal-node'/>
+ <remap id='node_halign' newid='align-vertical-node'/>
+ <remap id='node_vdistribute' newid='distribute-vertical-node'/>
+ <remap id='node_hdistribute' newid='distribute-horizontal-node'/>
+
+ <!-- XML editor -->
+ <remap id='add_xml_element_node' newid='xml-element-new'/>
+ <remap id='add_xml_text_node' newid='xml-text-new'/>
+ <remap id='delete_xml_node' newid='xml-node-delete'/>
+ <remap id='duplicate_xml_node' newid='xml-node-duplicate'/>
+ <remap id='delete_xml_attribute' newid='xml-attribute-delete'/>
+
+ <!-- transform dialog -->
+ <remap id='arrows_hor' newid='transform-move-horizontal'/>
+ <remap id='arrows_ver' newid='transform-move-vertical'/>
+ <remap id='transform_scale_hor' newid='transform-scale-horizontal'/>
+ <remap id='transform_scale_ver' newid='transform-scale-vertical'/>
+ <remap id='transform_scew_hor' newid='transform-skew-horizontal'/>
+ <remap id='transform_scew_ver' newid='transform-skew-vertical'/>
+
+ <!-- fill and stroke dialog -->
+ <remap id='properties_fill' newid='object-fill'/>
+ <remap id='properties_stroke_paint' newid='object-stroke'/>
+ <remap id='properties_stroke' newid='object-stroke-style'/>
+ <remap id='fill_none' newid='paint-none'/>
+ <remap id='fill_solid' newid='paint-solid'/>
+ <remap id='fill_gradient' newid='paint-gradient-linear'/>
+ <remap id='fill_radial' newid='paint-gradient-radial'/>
+ <remap id='fill_pattern' newid='paint-pattern'/>
+ <remap id='fill_unset' newid='paint-unknown'/>
+ <remap id='fillrule_evenodd' newid='fill-rule-even-odd'/>
+ <remap id='fillrule_nonzero' newid='fill-rule-nonzero'/>
+ <remap id='join_miter' newid='stroke-join-miter'/>
+ <remap id='join_bevel' newid='stroke-join-bevel'/>
+ <remap id='join_round' newid='stroke-join-round'/>
+ <remap id='cap_butt' newid='stroke-cap-butt'/>
+ <remap id='cap_square' newid='stroke-cap-square'/>
+ <remap id='cap_round' newid='stroke-cap-round'/>
+
+ <!-- MISCELLANEOUS -->
+ <remap id='guide' newid='guides'/>
+ <remap id='grid_xy' newid='grid-rectangular'/>
+ <remap id='grid_axonom' newid='grid-axonometric'/>
+ <remap id='visible' newid='object-visible'/>
+ <remap id='hidden' newid='object-hidden'/>
+ <remap id='lock_unlocked' newid='object-unlocked'/>
+ <remap id='width_height_lock' newid='object-locked'/>
+ <remap id='sticky_zoom' newid='zoom'/>
+</mappings>
diff --git a/src/widgets/paint-selector.cpp b/src/widgets/paint-selector.cpp
new file mode 100644
index 0000000..1e1f99e
--- /dev/null
+++ b/src/widgets/paint-selector.cpp
@@ -0,0 +1,1601 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/** @file
+ * SPPaintSelector: Generic paint selector widget.
+ *//*
+ * Authors:
+ * see git history
+ * Lauris Kaplinski
+ * bulia byak <buliabyak@users.sf.net>
+ * John Cliff <simarilius@yahoo.com>
+ * Jon A. Cruz <jon@joncruz.org>
+ * Abhishek Sharma
+ *
+ * Copyright (C) 2018 Authors
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#define noSP_PS_VERBOSE
+
+#include <cstring>
+#include <string>
+#include <vector>
+
+#include <glibmm/i18n.h>
+
+#include "desktop-style.h"
+#include "gradient-selector.h"
+#include "inkscape.h"
+#include "paint-selector.h"
+#include "path-prefix.h"
+
+#include "helper/stock-items.h"
+#include "ui/icon-loader.h"
+
+#include "style.h"
+
+#include "io/sys.h"
+
+#include "object/sp-hatch.h"
+#include "object/sp-linear-gradient.h"
+#include "object/sp-mesh-gradient.h"
+#include "object/sp-pattern.h"
+#include "object/sp-radial-gradient.h"
+#include "object/sp-stop.h"
+
+#include "svg/css-ostringstream.h"
+
+#include "ui/icon-names.h"
+#include "ui/widget/color-notebook.h"
+
+#include "widgets/swatch-selector.h"
+#include "widgets/widget-sizes.h"
+
+#include "xml/repr.h"
+
+#ifdef SP_PS_VERBOSE
+#include "svg/svg-icc-color.h"
+#endif // SP_PS_VERBOSE
+
+using Inkscape::Widgets::SwatchSelector;
+using Inkscape::UI::SelectedColor;
+
+enum {
+ MODE_CHANGED,
+ GRABBED,
+ DRAGGED,
+ RELEASED,
+ CHANGED,
+ FILLRULE_CHANGED,
+ LAST_SIGNAL
+};
+
+static void sp_paint_selector_dispose(GObject *object);
+
+static GtkWidget *sp_paint_selector_style_button_add(SPPaintSelector *psel, gchar const *px, SPPaintSelector::Mode mode, gchar const *tip);
+static void sp_paint_selector_style_button_toggled(GtkToggleButton *tb, SPPaintSelector *psel);
+static void sp_paint_selector_fillrule_toggled(GtkToggleButton *tb, SPPaintSelector *psel);
+
+static void sp_paint_selector_set_mode_empty(SPPaintSelector *psel);
+static void sp_paint_selector_set_mode_multiple(SPPaintSelector *psel);
+static void sp_paint_selector_set_mode_none(SPPaintSelector *psel);
+static void sp_paint_selector_set_mode_color(SPPaintSelector *psel, SPPaintSelector::Mode mode);
+static void sp_paint_selector_set_mode_gradient(SPPaintSelector *psel, SPPaintSelector::Mode mode);
+#ifdef WITH_MESH
+static void sp_paint_selector_set_mode_mesh(SPPaintSelector *psel, SPPaintSelector::Mode mode);
+#endif
+static void sp_paint_selector_set_mode_pattern(SPPaintSelector *psel, SPPaintSelector::Mode mode);
+static void sp_paint_selector_set_mode_hatch(SPPaintSelector *psel, SPPaintSelector::Mode mode);
+static void sp_paint_selector_set_mode_swatch(SPPaintSelector *psel, SPPaintSelector::Mode mode);
+static void sp_paint_selector_set_mode_unset(SPPaintSelector *psel);
+
+
+static void sp_paint_selector_set_style_buttons(SPPaintSelector *psel, GtkWidget *active);
+
+static guint psel_signals[LAST_SIGNAL] = {0};
+
+#ifdef SP_PS_VERBOSE
+static gchar const* modeStrings[] = {
+ "MODE_EMPTY",
+ "MODE_MULTIPLE",
+ "MODE_NONE",
+ "MODE_SOLID_COLOR",
+ "MODE_GRADIENT_LINEAR",
+ "MODE_GRADIENT_RADIAL",
+#ifdef WITH_MESH
+ "MODE_GRADIENT_MESH",
+#endif
+ "MODE_PATTERN",
+ "MODE_SWATCH",
+ "MODE_UNSET",
+ ".",
+ ".",
+};
+#endif
+
+
+static bool isPaintModeGradient(SPPaintSelector::Mode mode)
+{
+ bool isGrad = (mode == SPPaintSelector::MODE_GRADIENT_LINEAR) ||
+ (mode == SPPaintSelector::MODE_GRADIENT_RADIAL) ||
+ (mode == SPPaintSelector::MODE_SWATCH);
+
+ return isGrad;
+}
+
+static SPGradientSelector *getGradientFromData(SPPaintSelector const *psel)
+{
+ SPGradientSelector *grad = nullptr;
+ if (psel->mode == SPPaintSelector::MODE_SWATCH) {
+ SwatchSelector *swatchsel = static_cast<SwatchSelector*>(g_object_get_data(G_OBJECT(psel->selector), "swatch-selector"));
+ if (swatchsel) {
+ grad = swatchsel->getGradientSelector();
+ }
+ } else {
+ grad = reinterpret_cast<SPGradientSelector*>(g_object_get_data(G_OBJECT(psel->selector), "gradient-selector"));
+ }
+ return grad;
+}
+
+G_DEFINE_TYPE(SPPaintSelector, sp_paint_selector, GTK_TYPE_BOX);
+
+static void
+sp_paint_selector_class_init(SPPaintSelectorClass *klass)
+{
+ GObjectClass *object_class = G_OBJECT_CLASS(klass);
+
+ psel_signals[MODE_CHANGED] = g_signal_new("mode_changed",
+ G_TYPE_FROM_CLASS(object_class),
+ (GSignalFlags)(G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE),
+ G_STRUCT_OFFSET(SPPaintSelectorClass, mode_changed),
+ nullptr, nullptr,
+ g_cclosure_marshal_VOID__UINT,
+ G_TYPE_NONE, 1, G_TYPE_UINT);
+ psel_signals[GRABBED] = g_signal_new("grabbed",
+ G_TYPE_FROM_CLASS(object_class),
+ (GSignalFlags)(G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE),
+ G_STRUCT_OFFSET(SPPaintSelectorClass, grabbed),
+ nullptr, nullptr,
+ g_cclosure_marshal_VOID__VOID,
+ G_TYPE_NONE, 0);
+ psel_signals[DRAGGED] = g_signal_new("dragged",
+ G_TYPE_FROM_CLASS(object_class),
+ (GSignalFlags)(G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE),
+ G_STRUCT_OFFSET(SPPaintSelectorClass, dragged),
+ nullptr, nullptr,
+ g_cclosure_marshal_VOID__VOID,
+ G_TYPE_NONE, 0);
+ psel_signals[RELEASED] = g_signal_new("released",
+ G_TYPE_FROM_CLASS(object_class),
+ (GSignalFlags)(G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE),
+ G_STRUCT_OFFSET(SPPaintSelectorClass, released),
+ nullptr, nullptr,
+ g_cclosure_marshal_VOID__VOID,
+ G_TYPE_NONE, 0);
+ psel_signals[CHANGED] = g_signal_new("changed",
+ G_TYPE_FROM_CLASS(object_class),
+ (GSignalFlags)(G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE),
+ G_STRUCT_OFFSET(SPPaintSelectorClass, changed),
+ nullptr, nullptr,
+ g_cclosure_marshal_VOID__VOID,
+ G_TYPE_NONE, 0);
+ psel_signals[FILLRULE_CHANGED] = g_signal_new("fillrule_changed",
+ G_TYPE_FROM_CLASS(object_class),
+ (GSignalFlags)(G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE),
+ G_STRUCT_OFFSET(SPPaintSelectorClass, fillrule_changed),
+ nullptr, nullptr,
+ g_cclosure_marshal_VOID__UINT,
+ G_TYPE_NONE, 1, G_TYPE_UINT);
+
+ object_class->dispose = sp_paint_selector_dispose;
+}
+
+#define XPAD 4
+#define YPAD 1
+
+static void
+sp_paint_selector_init(SPPaintSelector *psel)
+{
+ gtk_orientable_set_orientation(GTK_ORIENTABLE(psel), GTK_ORIENTATION_VERTICAL);
+
+ psel->mode = static_cast<SPPaintSelector::Mode>(-1); // huh? do you mean 0xff? -- I think this means "not in the enum"
+
+ /* Paint style button box */
+ psel->style = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
+ gtk_box_set_homogeneous(GTK_BOX(psel->style), FALSE);
+ gtk_widget_set_name(psel->style,"PaintSelector");
+ gtk_widget_show(psel->style);
+ gtk_container_set_border_width(GTK_CONTAINER(psel->style), 4);
+ gtk_box_pack_start(GTK_BOX(psel), psel->style, FALSE, FALSE, 0);
+
+ /* Buttons */
+ psel->none = sp_paint_selector_style_button_add(psel, INKSCAPE_ICON("paint-none"),
+ SPPaintSelector::MODE_NONE, _("No paint"));
+ psel->solid = sp_paint_selector_style_button_add(psel, INKSCAPE_ICON("paint-solid"),
+ SPPaintSelector::MODE_SOLID_COLOR, _("Flat color"));
+ psel->gradient = sp_paint_selector_style_button_add(psel, INKSCAPE_ICON("paint-gradient-linear"),
+ SPPaintSelector::MODE_GRADIENT_LINEAR, _("Linear gradient"));
+ psel->radial = sp_paint_selector_style_button_add(psel, INKSCAPE_ICON("paint-gradient-radial"),
+ SPPaintSelector::MODE_GRADIENT_RADIAL, _("Radial gradient"));
+#ifdef WITH_MESH
+ psel->mesh = sp_paint_selector_style_button_add(psel, INKSCAPE_ICON("paint-gradient-mesh"),
+ SPPaintSelector::MODE_GRADIENT_MESH, _("Mesh gradient"));
+#endif
+ psel->pattern = sp_paint_selector_style_button_add(psel, INKSCAPE_ICON("paint-pattern"),
+ SPPaintSelector::MODE_PATTERN, _("Pattern"));
+ psel->swatch = sp_paint_selector_style_button_add(psel, INKSCAPE_ICON("paint-swatch"),
+ SPPaintSelector::MODE_SWATCH, _("Swatch"));
+ psel->unset = sp_paint_selector_style_button_add(psel, INKSCAPE_ICON("paint-unknown"),
+ SPPaintSelector::MODE_UNSET, _("Unset paint (make it undefined so it can be inherited)"));
+
+ /* Fillrule */
+ {
+ psel->fillrulebox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
+ gtk_box_set_homogeneous(GTK_BOX(psel->fillrulebox), FALSE);
+ gtk_box_pack_end(GTK_BOX(psel->style), psel->fillrulebox, FALSE, FALSE, 0);
+
+ GtkWidget *w;
+ psel->evenodd = gtk_radio_button_new(nullptr);
+ gtk_button_set_relief(GTK_BUTTON(psel->evenodd), GTK_RELIEF_NONE);
+ gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(psel->evenodd), FALSE);
+ // TRANSLATORS: for info, see http://www.w3.org/TR/2000/CR-SVG-20000802/painting.html#FillRuleProperty
+ gtk_widget_set_tooltip_text(psel->evenodd, _("Any path self-intersections or subpaths create holes in the fill (fill-rule: evenodd)"));
+ g_object_set_data(G_OBJECT(psel->evenodd), "mode", GUINT_TO_POINTER(SPPaintSelector::FILLRULE_EVENODD));
+ w = sp_get_icon_image("fill-rule-even-odd", GTK_ICON_SIZE_MENU);
+ gtk_container_add(GTK_CONTAINER(psel->evenodd), w);
+ gtk_box_pack_start(GTK_BOX(psel->fillrulebox), psel->evenodd, FALSE, FALSE, 0);
+ g_signal_connect(G_OBJECT(psel->evenodd), "toggled", G_CALLBACK(sp_paint_selector_fillrule_toggled), psel);
+
+ psel->nonzero = gtk_radio_button_new(gtk_radio_button_get_group(GTK_RADIO_BUTTON(psel->evenodd)));
+ gtk_button_set_relief(GTK_BUTTON(psel->nonzero), GTK_RELIEF_NONE);
+ gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(psel->nonzero), FALSE);
+ // TRANSLATORS: for info, see http://www.w3.org/TR/2000/CR-SVG-20000802/painting.html#FillRuleProperty
+ gtk_widget_set_tooltip_text(psel->nonzero, _("Fill is solid unless a subpath is counterdirectional (fill-rule: nonzero)"));
+ g_object_set_data(G_OBJECT(psel->nonzero), "mode", GUINT_TO_POINTER(SPPaintSelector::FILLRULE_NONZERO));
+ w = sp_get_icon_image("fill-rule-nonzero", GTK_ICON_SIZE_MENU);
+ gtk_container_add(GTK_CONTAINER(psel->nonzero), w);
+ gtk_box_pack_start(GTK_BOX(psel->fillrulebox), psel->nonzero, FALSE, FALSE, 0);
+ g_signal_connect(G_OBJECT(psel->nonzero), "toggled", G_CALLBACK(sp_paint_selector_fillrule_toggled), psel);
+ }
+
+ /* Frame */
+ psel->label = gtk_label_new("");
+ auto lbbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 4);
+ gtk_box_set_homogeneous(GTK_BOX(lbbox), FALSE);
+ gtk_widget_show(psel->label);
+ gtk_box_pack_start(GTK_BOX(lbbox), psel->label, false, false, 4);
+ gtk_box_pack_start(GTK_BOX(psel), lbbox, false, false, 4);
+
+ psel->frame = gtk_box_new(GTK_ORIENTATION_VERTICAL, 4);
+ gtk_box_set_homogeneous(GTK_BOX(psel->frame), FALSE);
+ gtk_widget_show(psel->frame);
+ //gtk_container_set_border_width(GTK_CONTAINER(psel->frame), 0);
+ gtk_box_pack_start(GTK_BOX(psel), psel->frame, TRUE, TRUE, 0);
+
+
+ /* Last used color */
+ psel->selected_color = new SelectedColor;
+ psel->updating_color = false;
+
+ psel->selected_color->signal_grabbed.connect(sigc::mem_fun(psel, &SPPaintSelector::onSelectedColorGrabbed));
+ psel->selected_color->signal_dragged.connect(sigc::mem_fun(psel, &SPPaintSelector::onSelectedColorDragged));
+ psel->selected_color->signal_released.connect(sigc::mem_fun(psel, &SPPaintSelector::onSelectedColorReleased));
+ psel->selected_color->signal_changed.connect(sigc::mem_fun(psel, &SPPaintSelector::onSelectedColorChanged));
+}
+
+static void sp_paint_selector_dispose(GObject *object)
+{
+ SPPaintSelector *psel = SP_PAINT_SELECTOR(object);
+
+ // clean up our long-living pattern menu
+ g_object_set_data(G_OBJECT(psel),"patternmenu",nullptr);
+
+#ifdef WITH_MESH
+ // clean up our long-living mesh menu
+ g_object_set_data(G_OBJECT(psel),"meshmenu",nullptr);
+#endif
+
+ if (psel->selected_color) {
+ delete psel->selected_color;
+ psel->selected_color = nullptr;
+ }
+
+ if ((G_OBJECT_CLASS(sp_paint_selector_parent_class))->dispose)
+ (G_OBJECT_CLASS(sp_paint_selector_parent_class))->dispose(object);
+}
+
+static GtkWidget *sp_paint_selector_style_button_add(SPPaintSelector *psel,
+ gchar const *pixmap, SPPaintSelector::Mode mode,
+ gchar const *tip)
+{
+ GtkWidget *b, *w;
+
+ b = gtk_toggle_button_new();
+ gtk_widget_set_tooltip_text(b, tip);
+ gtk_widget_show(b);
+
+ gtk_container_set_border_width(GTK_CONTAINER(b), 0);
+
+ gtk_button_set_relief(GTK_BUTTON(b), GTK_RELIEF_NONE);
+
+ gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(b), FALSE);
+ g_object_set_data(G_OBJECT(b), "mode", GUINT_TO_POINTER(mode));
+
+ w = sp_get_icon_image(pixmap, GTK_ICON_SIZE_BUTTON);
+ gtk_container_add(GTK_CONTAINER(b), w);
+
+ gtk_box_pack_start(GTK_BOX(psel->style), b, FALSE, FALSE, 0);
+ g_signal_connect(G_OBJECT(b), "toggled", G_CALLBACK(sp_paint_selector_style_button_toggled), psel);
+
+ return b;
+}
+
+static void
+sp_paint_selector_style_button_toggled(GtkToggleButton *tb, SPPaintSelector *psel)
+{
+ if (!psel->update && gtk_toggle_button_get_active(tb)) {
+ psel->setMode(static_cast<SPPaintSelector::Mode>(GPOINTER_TO_UINT(g_object_get_data(G_OBJECT(tb), "mode"))));
+ }
+}
+
+static void
+sp_paint_selector_fillrule_toggled(GtkToggleButton *tb, SPPaintSelector *psel)
+{
+ if (!psel->update && gtk_toggle_button_get_active(tb)) {
+ SPPaintSelector::FillRule fr = static_cast<SPPaintSelector::FillRule>(GPOINTER_TO_UINT(g_object_get_data(G_OBJECT(tb), "mode")));
+ g_signal_emit(G_OBJECT(psel), psel_signals[FILLRULE_CHANGED], 0, fr);
+ }
+}
+
+static void
+sp_paint_selector_show_fillrule(SPPaintSelector *psel, bool is_fill)
+{
+ if (psel->fillrulebox) {
+ if (is_fill) {
+ gtk_widget_show_all(psel->fillrulebox);
+ } else {
+ gtk_widget_destroy(psel->fillrulebox);
+ psel->fillrulebox = nullptr;
+ }
+ }
+}
+
+
+SPPaintSelector *sp_paint_selector_new(FillOrStroke kind)
+{
+ SPPaintSelector *psel = static_cast<SPPaintSelector*>(g_object_new(SP_TYPE_PAINT_SELECTOR, nullptr));
+
+ psel->setMode(SPPaintSelector::MODE_MULTIPLE);
+
+ // This silliness is here because I don't know how to pass a parameter to the
+ // GtkObject "constructor" (sp_paint_selector_init). Remove it when paint_selector
+ // becomes a normal class.
+ sp_paint_selector_show_fillrule(psel, kind == FILL);
+
+ return psel;
+}
+
+void SPPaintSelector::setMode(Mode mode)
+{
+ if (this->mode != mode) {
+ update = TRUE;
+#ifdef SP_PS_VERBOSE
+ g_print("Mode change %d -> %d %s -> %s\n", this->mode, mode, modeStrings[this->mode], modeStrings[mode]);
+#endif
+ switch (mode) {
+ case MODE_EMPTY:
+ sp_paint_selector_set_mode_empty(this);
+ break;
+ case MODE_MULTIPLE:
+ sp_paint_selector_set_mode_multiple(this);
+ break;
+ case MODE_NONE:
+ sp_paint_selector_set_mode_none(this);
+ break;
+ case MODE_SOLID_COLOR:
+ sp_paint_selector_set_mode_color(this, mode);
+ break;
+ case MODE_GRADIENT_LINEAR:
+ case MODE_GRADIENT_RADIAL:
+ sp_paint_selector_set_mode_gradient(this, mode);
+ break;
+#ifdef WITH_MESH
+ case MODE_GRADIENT_MESH:
+ sp_paint_selector_set_mode_mesh(this, mode);
+ break;
+#endif
+ case MODE_PATTERN:
+ sp_paint_selector_set_mode_pattern(this, mode);
+ break;
+ case MODE_HATCH:
+ sp_paint_selector_set_mode_hatch(this, mode);
+ break;
+ case MODE_SWATCH:
+ sp_paint_selector_set_mode_swatch(this, mode);
+ break;
+ case MODE_UNSET:
+ sp_paint_selector_set_mode_unset(this);
+ break;
+ default:
+ g_warning("file %s: line %d: Unknown paint mode %d", __FILE__, __LINE__, mode);
+ break;
+ }
+ this->mode = mode;
+ g_signal_emit(G_OBJECT(this), psel_signals[MODE_CHANGED], 0, this->mode);
+ update = FALSE;
+ }
+}
+
+void SPPaintSelector::setFillrule(FillRule fillrule)
+{
+ if (fillrulebox) {
+ // TODO this flips widgets but does not use a member to store state. Revisit
+ gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(evenodd), (fillrule == FILLRULE_EVENODD));
+ gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(nonzero), (fillrule == FILLRULE_NONZERO));
+ }
+}
+
+void SPPaintSelector::setColorAlpha(SPColor const &color, float alpha)
+{
+ g_return_if_fail( ( 0.0 <= alpha ) && ( alpha <= 1.0 ) );
+/*
+ guint32 rgba = 0;
+
+ if ( sp_color_get_colorspace_type(color) == SP_COLORSPACE_TYPE_CMYK )
+ {
+#ifdef SP_PS_VERBOSE
+ g_print("PaintSelector set CMYKA\n");
+#endif
+ sp_paint_selector_set_mode(psel, MODE_COLOR_CMYK);
+ }
+ else
+*/
+ {
+#ifdef SP_PS_VERBOSE
+ g_print("PaintSelector set RGBA\n");
+#endif
+ setMode(MODE_SOLID_COLOR);
+ }
+
+ updating_color = true;
+ selected_color->setColorAlpha(color, alpha);
+ updating_color = false;
+ //rgba = color.toRGBA32( alpha );
+}
+
+void SPPaintSelector::setSwatch(SPGradient *vector )
+{
+#ifdef SP_PS_VERBOSE
+ g_print("PaintSelector set SWATCH\n");
+#endif
+ setMode(MODE_SWATCH);
+
+ SwatchSelector *swatchsel = static_cast<SwatchSelector*>(g_object_get_data(G_OBJECT(selector), "swatch-selector"));
+ if (swatchsel) {
+ swatchsel->setVector( (vector) ? vector->document : nullptr, vector );
+ }
+}
+
+void SPPaintSelector::setGradientLinear(SPGradient *vector)
+{
+#ifdef SP_PS_VERBOSE
+ g_print("PaintSelector set GRADIENT LINEAR\n");
+#endif
+ setMode(MODE_GRADIENT_LINEAR);
+
+ SPGradientSelector *gsel = getGradientFromData(this);
+
+ gsel->setMode(SPGradientSelector::MODE_LINEAR);
+ gsel->setVector((vector) ? vector->document : nullptr, vector);
+}
+
+void SPPaintSelector::setGradientRadial(SPGradient *vector)
+{
+#ifdef SP_PS_VERBOSE
+ g_print("PaintSelector set GRADIENT RADIAL\n");
+#endif
+ setMode(MODE_GRADIENT_RADIAL);
+
+ SPGradientSelector *gsel = getGradientFromData(this);
+
+ gsel->setMode(SPGradientSelector::MODE_RADIAL);
+
+ gsel->setVector((vector) ? vector->document : nullptr, vector);
+}
+
+#ifdef WITH_MESH
+void SPPaintSelector::setGradientMesh(SPMeshGradient *array)
+{
+#ifdef SP_PS_VERBOSE
+ g_print("PaintSelector set GRADIENT MESH\n");
+#endif
+ setMode(MODE_GRADIENT_MESH);
+
+ // SPGradientSelector *gsel = getGradientFromData(this);
+
+ // gsel->setMode(SPGradientSelector::MODE_GRADIENT_MESH);
+ // gsel->setVector((mesh) ? mesh->document : 0, mesh);
+}
+#endif
+
+void SPPaintSelector::setGradientProperties( SPGradientUnits units, SPGradientSpread spread )
+{
+ g_return_if_fail(isPaintModeGradient(mode));
+
+ SPGradientSelector *gsel = getGradientFromData(this);
+ gsel->setUnits(units);
+ gsel->setSpread(spread);
+}
+
+void SPPaintSelector::getGradientProperties( SPGradientUnits &units, SPGradientSpread &spread) const
+{
+ g_return_if_fail(isPaintModeGradient(mode));
+
+ SPGradientSelector *gsel = getGradientFromData(this);
+ units = gsel->getUnits();
+ spread = gsel->getSpread();
+}
+
+
+/**
+ * \post (alpha == NULL) || (*alpha in [0.0, 1.0]).
+ */
+void SPPaintSelector::getColorAlpha(SPColor &color, gfloat &alpha) const
+{
+ selected_color->colorAlpha(color, alpha);
+
+ g_assert( ( 0.0 <= alpha )
+ && ( alpha <= 1.0 ) );
+}
+
+SPGradient *SPPaintSelector::getGradientVector()
+{
+ SPGradient* vect = nullptr;
+
+ if (isPaintModeGradient(mode)) {
+ SPGradientSelector *gsel = getGradientFromData(this);
+ vect = gsel->getVector();
+ }
+
+ return vect;
+}
+
+
+void SPPaintSelector::pushAttrsToGradient( SPGradient *gr ) const
+{
+ SPGradientUnits units = SP_GRADIENT_UNITS_OBJECTBOUNDINGBOX;
+ SPGradientSpread spread = SP_GRADIENT_SPREAD_PAD;
+ getGradientProperties( units, spread );
+ gr->setUnits(units);
+ gr->setSpread(spread);
+ gr->updateRepr();
+}
+
+static void
+sp_paint_selector_clear_frame(SPPaintSelector *psel)
+{
+ g_return_if_fail( psel != nullptr);
+
+ if (psel->selector) {
+
+ //This is a hack to work around GtkNotebook bug in ColorSelector. Is sends signal switch-page on destroy
+ //The widget is hidden first so it can recognize that it should not process signals from notebook child
+ gtk_widget_set_visible(psel->selector, false);
+ gtk_widget_destroy(psel->selector);
+ psel->selector = nullptr;
+ }
+}
+
+static void
+sp_paint_selector_set_mode_empty(SPPaintSelector *psel)
+{
+ sp_paint_selector_set_style_buttons(psel, nullptr);
+ gtk_widget_set_sensitive(psel->style, FALSE);
+
+ sp_paint_selector_clear_frame(psel);
+
+ gtk_label_set_markup(GTK_LABEL(psel->label), _("<b>No objects</b>"));
+}
+
+static void
+sp_paint_selector_set_mode_multiple(SPPaintSelector *psel)
+{
+ sp_paint_selector_set_style_buttons(psel, nullptr);
+ gtk_widget_set_sensitive(psel->style, TRUE);
+
+ sp_paint_selector_clear_frame(psel);
+
+ gtk_label_set_markup(GTK_LABEL(psel->label), _("<b>Multiple styles</b>"));
+}
+
+static void
+sp_paint_selector_set_mode_unset(SPPaintSelector *psel)
+{
+ sp_paint_selector_set_style_buttons(psel, psel->unset);
+ gtk_widget_set_sensitive(psel->style, TRUE);
+
+ sp_paint_selector_clear_frame(psel);
+
+ gtk_label_set_markup(GTK_LABEL(psel->label), _("<b>Paint is undefined</b>"));
+}
+
+static void
+sp_paint_selector_set_mode_none(SPPaintSelector *psel)
+{
+ sp_paint_selector_set_style_buttons(psel, psel->none);
+ gtk_widget_set_sensitive(psel->style, TRUE);
+
+ sp_paint_selector_clear_frame(psel);
+
+ gtk_label_set_markup(GTK_LABEL(psel->label), _("<b>No paint</b>"));
+
+}
+
+/* Color paint */
+
+void SPPaintSelector::onSelectedColorGrabbed() {
+ g_signal_emit(G_OBJECT(this), psel_signals[GRABBED], 0);
+}
+
+void SPPaintSelector::onSelectedColorDragged() {
+ if (updating_color) {
+ return;
+ }
+ g_signal_emit(G_OBJECT(this), psel_signals[DRAGGED], 0);
+}
+
+void SPPaintSelector::onSelectedColorReleased() {
+ g_signal_emit(G_OBJECT(this), psel_signals[RELEASED], 0);
+}
+
+void SPPaintSelector::onSelectedColorChanged() {
+ if (updating_color) {
+ return;
+ }
+
+ if (mode == MODE_SOLID_COLOR) {
+ g_signal_emit(G_OBJECT(this), psel_signals[CHANGED], 0);
+ } else {
+ g_warning("SPPaintSelector::onSelectedColorChanged(): selected color changed while not in color selection mode");
+ }
+}
+
+static void sp_paint_selector_set_mode_color(SPPaintSelector *psel, SPPaintSelector::Mode /*mode*/)
+{
+ using Inkscape::UI::Widget::ColorNotebook;
+
+ if ((psel->mode == SPPaintSelector::MODE_SWATCH)
+ || (psel->mode == SPPaintSelector::MODE_GRADIENT_LINEAR)
+ || (psel->mode == SPPaintSelector::MODE_GRADIENT_RADIAL) ) {
+ SPGradientSelector *gsel = getGradientFromData(psel);
+ if (gsel) {
+ SPGradient *gradient = gsel->getVector();
+
+ // Gradient can be null if object paint is changed externally (ie. with a color picker tool)
+ if (gradient)
+ {
+ SPColor color = gradient->getFirstStop()->getColor();
+ float alpha = gradient->getFirstStop()->getOpacity();
+ psel->selected_color->setColorAlpha(color, alpha, false);
+ }
+ }
+ }
+
+ sp_paint_selector_set_style_buttons(psel, psel->solid);
+ gtk_widget_set_sensitive(psel->style, TRUE);
+
+ if (psel->mode == SPPaintSelector::MODE_SOLID_COLOR) {
+ /* Already have color selector */
+ // Do nothing
+ } else {
+
+ sp_paint_selector_clear_frame(psel);
+ /* Create new color selector */
+ /* Create vbox */
+ auto vb = gtk_box_new(GTK_ORIENTATION_VERTICAL, 4);
+ gtk_box_set_homogeneous(GTK_BOX(vb), FALSE);
+ gtk_widget_show(vb);
+
+ /* Color selector */
+ Gtk::Widget *color_selector = Gtk::manage(new ColorNotebook(*(psel->selected_color)));
+ color_selector->show();
+ gtk_box_pack_start(GTK_BOX(vb), color_selector->gobj(), TRUE, TRUE, 0);
+
+ /* Pack everything to frame */
+ gtk_container_add(GTK_CONTAINER(psel->frame), vb);
+
+ psel->selector = vb;
+ }
+
+ gtk_label_set_markup(GTK_LABEL(psel->label), _("<b>Flat color</b>"));
+
+#ifdef SP_PS_VERBOSE
+ g_print("Color req\n");
+#endif
+}
+
+/* Gradient */
+
+static void sp_paint_selector_gradient_grabbed(SPGradientSelector * /*csel*/, SPPaintSelector *psel)
+{
+ g_signal_emit(G_OBJECT(psel), psel_signals[GRABBED], 0);
+}
+
+static void sp_paint_selector_gradient_dragged(SPGradientSelector * /*csel*/, SPPaintSelector *psel)
+{
+ g_signal_emit(G_OBJECT(psel), psel_signals[DRAGGED], 0);
+}
+
+static void sp_paint_selector_gradient_released(SPGradientSelector * /*csel*/, SPPaintSelector *psel)
+{
+ g_signal_emit(G_OBJECT(psel), psel_signals[RELEASED], 0);
+}
+
+static void sp_paint_selector_gradient_changed(SPGradientSelector * /*csel*/, SPPaintSelector *psel)
+{
+ g_signal_emit(G_OBJECT(psel), psel_signals[CHANGED], 0);
+}
+
+static void sp_paint_selector_set_mode_gradient(SPPaintSelector *psel, SPPaintSelector::Mode mode)
+{
+ GtkWidget *gsel;
+
+ /* fixme: We do not need function-wide gsel at all */
+
+ if (mode == SPPaintSelector::MODE_GRADIENT_LINEAR) {
+ sp_paint_selector_set_style_buttons(psel, psel->gradient);
+ } else if (mode == SPPaintSelector::MODE_GRADIENT_RADIAL) {
+ sp_paint_selector_set_style_buttons(psel, psel->radial);
+ }
+ gtk_widget_set_sensitive(psel->style, TRUE);
+
+ if ((psel->mode == SPPaintSelector::MODE_GRADIENT_LINEAR) || (psel->mode == SPPaintSelector::MODE_GRADIENT_RADIAL)) {
+ /* Already have gradient selector */
+ gsel = GTK_WIDGET(g_object_get_data(G_OBJECT(psel->selector), "gradient-selector"));
+ } else {
+ sp_paint_selector_clear_frame(psel);
+ /* Create new gradient selector */
+ gsel = sp_gradient_selector_new();
+ gtk_widget_show(gsel);
+ g_signal_connect(G_OBJECT(gsel), "grabbed", G_CALLBACK(sp_paint_selector_gradient_grabbed), psel);
+ g_signal_connect(G_OBJECT(gsel), "dragged", G_CALLBACK(sp_paint_selector_gradient_dragged), psel);
+ g_signal_connect(G_OBJECT(gsel), "released", G_CALLBACK(sp_paint_selector_gradient_released), psel);
+ g_signal_connect(G_OBJECT(gsel), "changed", G_CALLBACK(sp_paint_selector_gradient_changed), psel);
+ /* Pack everything to frame */
+ gtk_container_add(GTK_CONTAINER(psel->frame), gsel);
+ psel->selector = gsel;
+ g_object_set_data(G_OBJECT(psel->selector), "gradient-selector", gsel);
+ }
+
+ /* Actually we have to set option menu history here */
+ if (mode == SPPaintSelector::MODE_GRADIENT_LINEAR) {
+ SP_GRADIENT_SELECTOR(gsel)->setMode(SPGradientSelector::MODE_LINEAR);
+ //sp_gradient_selector_set_mode(SP_GRADIENT_SELECTOR(gsel), SP_GRADIENT_SELECTOR_MODE_LINEAR);
+ gtk_label_set_markup(GTK_LABEL(psel->label), _("<b>Linear gradient</b>"));
+ } else if (mode == SPPaintSelector::MODE_GRADIENT_RADIAL) {
+ SP_GRADIENT_SELECTOR(gsel)->setMode(SPGradientSelector::MODE_RADIAL);
+ gtk_label_set_markup(GTK_LABEL(psel->label), _("<b>Radial gradient</b>"));
+ }
+
+#ifdef SP_PS_VERBOSE
+ g_print("Gradient req\n");
+#endif
+}
+
+// ************************* MESH ************************
+#ifdef WITH_MESH
+static void sp_psel_mesh_destroy(GtkWidget *widget, SPPaintSelector * /*psel*/)
+{
+ // drop our reference to the mesh menu widget
+ g_object_unref( G_OBJECT(widget) );
+}
+
+static void sp_psel_mesh_change(GtkWidget * /*widget*/, SPPaintSelector *psel)
+{
+ g_signal_emit(G_OBJECT(psel), psel_signals[CHANGED], 0);
+}
+
+
+/**
+ * Returns a list of meshes in the defs of the given source document as a vector
+ */
+static std::vector<SPMeshGradient *>
+ink_mesh_list_get (SPDocument *source)
+{
+ std::vector<SPMeshGradient *> pl;
+ if (source == nullptr)
+ return pl;
+
+
+ std::vector<SPObject *> meshes = source->getResourceList("gradient");
+ for (auto meshe : meshes) {
+ if (SP_IS_MESHGRADIENT(meshe) &&
+ SP_GRADIENT(meshe) == SP_GRADIENT(meshe)->getArray()) { // only if this is a root mesh
+ pl.push_back(SP_MESHGRADIENT(meshe));
+ }
+ }
+ return pl;
+}
+
+/**
+ * Adds menu items for mesh list.
+ */
+static void
+sp_mesh_menu_build (GtkWidget *combo, std::vector<SPMeshGradient *> &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;
+ 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);
+
+ }
+}
+
+/**
+ * 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*/)
+{
+ std::vector<SPMeshGradient *> pl = ink_mesh_list_get(source);
+ sp_mesh_menu_build (combo, pl, source);
+}
+
+
+static void
+ink_mesh_menu_populate_menu(GtkWidget *combo, SPDocument *doc)
+{
+ static SPDocument *meshes_doc = nullptr;
+
+ // If we ever add a list of canned mesh gradients, uncomment following:
+
+ // find and load meshes.svg
+ // if (meshes_doc == NULL) {
+ // char *meshes_source = g_build_filename(INKSCAPE_MESHESDIR, "meshes.svg", NULL);
+ // if (Inkscape::IO::file_test(meshes_source, G_FILE_TEST_IS_REGULAR)) {
+ // meshes_doc = SPDocument::createNewDoc(meshes_source, FALSE);
+ // }
+ // g_free(meshes_source);
+ // }
+
+ // suck in from current doc
+ sp_mesh_list_from_doc ( combo, nullptr, 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);
+ // }
+
+ // suck in from meshes.svg
+ // if (meshes_doc) {
+ // doc->ensureUpToDate();
+ // sp_mesh_list_from_doc ( combo, doc, meshes_doc, NULL );
+ // }
+
+}
+
+
+static GtkWidget*
+ink_mesh_menu(GtkWidget *combo)
+{
+ 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);
+
+ } else {
+
+ ink_mesh_menu_populate_menu(combo, doc);
+ gtk_widget_set_sensitive(combo, 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 (sep) {
+ gtk_tree_model_iter_next(GTK_TREE_MODEL(store), &iter);
+ }
+ gtk_combo_box_set_active_iter(GTK_COMBO_BOX(combo), &iter);
+ }
+
+ return combo;
+}
+
+
+/*update mesh list*/
+void SPPaintSelector::updateMeshList( SPMeshGradient *mesh )
+{
+ if (update) {
+ return;
+ }
+
+ GtkWidget *combo = GTK_WIDGET(g_object_get_data(G_OBJECT(this), "meshmenu"));
+ g_assert( combo != nullptr );
+
+ /* Clear existing menu if any */
+ GtkTreeModel *store = gtk_combo_box_get_model(GTK_COMBO_BOX(combo));
+ gtk_list_store_clear(GTK_LIST_STORE(store));
+
+ ink_mesh_menu(combo);
+
+ /* Set history */
+
+ if (mesh && !g_object_get_data(G_OBJECT(combo), "update")) {
+
+ g_object_set_data(G_OBJECT(combo), "update", GINT_TO_POINTER(TRUE));
+ 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) {
+ 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);
+ }
+
+ if (valid) {
+ gtk_combo_box_set_active_iter(GTK_COMBO_BOX(combo), &iter);
+ }
+
+ g_object_set_data(G_OBJECT(combo), "update", GINT_TO_POINTER(FALSE));
+ g_free(meshid);
+ }
+}
+
+static void sp_paint_selector_set_mode_mesh(SPPaintSelector *psel, SPPaintSelector::Mode mode)
+{
+ if (mode == SPPaintSelector::MODE_GRADIENT_MESH) {
+ sp_paint_selector_set_style_buttons(psel, psel->mesh);
+ }
+ gtk_widget_set_sensitive(psel->style, TRUE);
+
+ GtkWidget *tbl = nullptr;
+
+ if (psel->mode == SPPaintSelector::MODE_GRADIENT_MESH) {
+ /* Already have mesh menu */
+ tbl = GTK_WIDGET(g_object_get_data(G_OBJECT(psel->selector), "mesh-selector"));
+ } else {
+ sp_paint_selector_clear_frame(psel);
+
+ /* Create vbox */
+ tbl = gtk_box_new(GTK_ORIENTATION_VERTICAL, 4);
+ gtk_box_set_homogeneous(GTK_BOX(tbl), FALSE);
+ gtk_widget_show(tbl);
+
+ {
+ auto hb = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 1);
+ gtk_box_set_homogeneous(GTK_BOX(hb), 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), SPPaintSelector::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(sp_psel_mesh_change), psel);
+ g_signal_connect(G_OBJECT(combo), "destroy", G_CALLBACK(sp_psel_mesh_destroy), psel);
+ g_object_set_data(G_OBJECT(psel), "meshmenu", combo);
+ g_object_ref( G_OBJECT(combo));
+
+ gtk_container_add(GTK_CONTAINER(hb), combo);
+ gtk_box_pack_start(GTK_BOX(tbl), hb, FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS);
+
+ g_object_unref( G_OBJECT(store));
+ }
+
+ {
+ auto hb = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
+ gtk_box_set_homogeneous(GTK_BOX(hb), FALSE);
+ auto l = gtk_label_new(nullptr);
+ gtk_label_set_markup(GTK_LABEL(l), _("Use the <b>Mesh tool</b> to modify the mesh."));
+ gtk_label_set_line_wrap(GTK_LABEL(l), true);
+ gtk_widget_set_size_request(l, 180, -1);
+ gtk_box_pack_start(GTK_BOX(hb), l, TRUE, TRUE, AUX_BETWEEN_BUTTON_GROUPS);
+ gtk_box_pack_start(GTK_BOX(tbl), hb, FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS);
+ }
+
+ gtk_widget_show_all(tbl);
+
+ gtk_container_add(GTK_CONTAINER(psel->frame), tbl);
+ psel->selector = tbl;
+ g_object_set_data(G_OBJECT(psel->selector), "mesh-selector", tbl);
+
+ gtk_label_set_markup(GTK_LABEL(psel->label), _("<b>Mesh fill</b>"));
+ }
+#ifdef SP_PS_VERBOSE
+ g_print("Mesh req\n");
+#endif
+}
+
+SPMeshGradient *SPPaintSelector::getMeshGradient()
+{
+ g_return_val_if_fail((mode == MODE_GRADIENT_MESH) , NULL);
+
+ GtkWidget *combo = GTK_WIDGET(g_object_get_data(G_OBJECT(this), "meshmenu"));
+
+ /* no mesh menu if we were just selected */
+ if ( combo == nullptr ) {
+ return nullptr;
+ }
+ GtkTreeModel *store = gtk_combo_box_get_model(GTK_COMBO_BOX(combo));
+
+ /* Get the selected mesh */
+ GtkTreeIter iter;
+ if (!gtk_combo_box_get_active_iter (GTK_COMBO_BOX(combo), &iter) ||
+ !gtk_list_store_iter_is_valid(GTK_LIST_STORE(store), &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);
+ if (meshid == nullptr) {
+ return nullptr;
+ }
+
+ SPMeshGradient *mesh = nullptr;
+ if (strcmp(meshid, "none")){
+
+ gchar *mesh_name;
+ if (stockid) {
+ mesh_name = g_strconcat("urn:inkscape:mesh:", meshid, NULL);
+ } else {
+ mesh_name = g_strdup(meshid);
+ }
+
+ SPObject *mesh_obj = get_stock_item(mesh_name);
+ if (mesh_obj && SP_IS_MESHGRADIENT(mesh_obj)) {
+ mesh = SP_MESHGRADIENT(mesh_obj);
+ }
+ g_free(mesh_name);
+ } else {
+ std::cerr << "SPPaintSelector::getMeshGradient: Unexpected meshid value." << std::endl;
+ }
+
+ g_free(meshid);
+
+ return mesh;
+}
+
+#endif
+// ************************ End Mesh ************************
+
+static void
+sp_paint_selector_set_style_buttons(SPPaintSelector *psel, GtkWidget *active)
+{
+ gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(psel->none), (active == psel->none));
+ gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(psel->solid), (active == psel->solid));
+ gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(psel->gradient), (active == psel->gradient));
+ gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(psel->radial), (active == psel->radial));
+#ifdef WITH_MESH
+ gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(psel->mesh), (active == psel->mesh));
+#endif
+ gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(psel->pattern), (active == psel->pattern));
+ gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(psel->swatch), (active == psel->swatch));
+ gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(psel->unset), (active == psel->unset));
+}
+
+static void sp_psel_pattern_destroy(GtkWidget *widget, SPPaintSelector * /*psel*/)
+{
+ // drop our reference to the pattern menu widget
+ g_object_unref( G_OBJECT(widget) );
+}
+
+static void sp_psel_pattern_change(GtkWidget * /*widget*/, SPPaintSelector *psel)
+{
+ g_signal_emit(G_OBJECT(psel), psel_signals[CHANGED], 0);
+}
+
+
+
+/**
+ * Returns a list of patterns in the defs of the given source document as a vector
+ */
+static std::vector<SPPattern*>
+ink_pattern_list_get (SPDocument *source)
+{
+ std::vector<SPPattern *> pl;
+ if (source == nullptr)
+ return pl;
+
+ std::vector<SPObject *> patterns = source->getResourceList("pattern");
+ for (auto pattern : patterns) {
+ if (SP_PATTERN(pattern) == SP_PATTERN(pattern)->rootPattern()) { // only if this is a root pattern
+ pl.push_back(SP_PATTERN(pattern));
+ }
+ }
+
+ return pl;
+}
+
+/**
+ * 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<SPPattern *> &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();
+
+ // label for combobox
+ gchar const *label;
+ if (repr->attribute("inkscape:stockid")) {
+ label = _(repr->attribute("inkscape:stockid"));
+ } else {
+ label = _(repr->attribute("id"));
+ }
+
+ gchar const *patid = repr->attribute("id");
+
+ gboolean stockid = false;
+ if (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_PATTERN, patid, COMBO_COL_SEP, FALSE, -1);
+
+ }
+}
+
+/**
+ * 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*/)
+{
+ std::vector<SPPattern *> pl = ink_pattern_list_get(source);
+ sp_pattern_menu_build (combo, pl, source);
+}
+
+
+static void
+ink_pattern_menu_populate_menu(GtkWidget *combo, SPDocument *doc)
+{
+ static SPDocument *patterns_doc = nullptr;
+
+ // find and load patterns.svg
+ if (patterns_doc == nullptr) {
+ char *patterns_source = g_build_filename(INKSCAPE_PAINTDIR, "patterns.svg", NULL);
+ if (Inkscape::IO::file_test(patterns_source, G_FILE_TEST_IS_REGULAR)) {
+ patterns_doc = SPDocument::createNewDoc(patterns_source, FALSE);
+ }
+ g_free(patterns_source);
+ }
+
+ // suck in from current doc
+ sp_pattern_list_from_doc ( combo, 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);
+ }
+
+ // suck in from patterns.svg
+ if (patterns_doc) {
+ doc->ensureUpToDate();
+ sp_pattern_list_from_doc ( combo, doc, patterns_doc, nullptr );
+ }
+
+}
+
+
+static GtkWidget*
+ink_pattern_menu(GtkWidget *combo)
+{
+ 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);
+
+ } else {
+
+ ink_pattern_menu_populate_menu(combo, doc);
+ gtk_widget_set_sensitive(combo, 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 (sep) {
+ gtk_tree_model_iter_next(GTK_TREE_MODEL(store), &iter);
+ }
+ gtk_combo_box_set_active_iter(GTK_COMBO_BOX(combo), &iter);
+ }
+
+ return combo;
+}
+
+
+/*update pattern list*/
+void SPPaintSelector::updatePatternList( SPPattern *pattern )
+{
+ if (update) {
+ return;
+ }
+ GtkWidget *combo = GTK_WIDGET(g_object_get_data(G_OBJECT(this), "patternmenu"));
+ g_assert( combo != nullptr );
+
+ /* Clear existing menu if any */
+ GtkTreeModel *store = gtk_combo_box_get_model(GTK_COMBO_BOX(combo));
+ gtk_list_store_clear(GTK_LIST_STORE(store));
+
+ ink_pattern_menu(combo);
+
+ /* Set history */
+
+ if (pattern && !g_object_get_data(G_OBJECT(combo), "update")) {
+
+ g_object_set_data(G_OBJECT(combo), "update", GINT_TO_POINTER(TRUE));
+ 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) {
+ 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);
+ }
+ g_free(patid);
+
+ if (valid) {
+ gtk_combo_box_set_active_iter(GTK_COMBO_BOX(combo), &iter);
+ }
+
+ g_object_set_data(G_OBJECT(combo), "update", GINT_TO_POINTER(FALSE));
+ }
+}
+
+static void sp_paint_selector_set_mode_pattern(SPPaintSelector *psel, SPPaintSelector::Mode mode)
+{
+ if (mode == SPPaintSelector::MODE_PATTERN) {
+ sp_paint_selector_set_style_buttons(psel, psel->pattern);
+ }
+
+ gtk_widget_set_sensitive(psel->style, TRUE);
+
+ GtkWidget *tbl = nullptr;
+
+ if (psel->mode == SPPaintSelector::MODE_PATTERN) {
+ /* Already have pattern menu */
+ tbl = GTK_WIDGET(g_object_get_data(G_OBJECT(psel->selector), "pattern-selector"));
+ } else {
+ sp_paint_selector_clear_frame(psel);
+
+ /* Create vbox */
+ tbl = gtk_box_new(GTK_ORIENTATION_VERTICAL, 4);
+ gtk_box_set_homogeneous(GTK_BOX(tbl), FALSE);
+ gtk_widget_show(tbl);
+
+ {
+ auto hb = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 1);
+ gtk_box_set_homogeneous(GTK_BOX(hb), 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);
+ GtkWidget *combo = gtk_combo_box_new_with_model (GTK_TREE_MODEL (store));
+ gtk_combo_box_set_row_separator_func(GTK_COMBO_BOX(combo), SPPaintSelector::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_pattern_menu(combo);
+ g_signal_connect(G_OBJECT(combo), "changed", G_CALLBACK(sp_psel_pattern_change), psel);
+ g_signal_connect(G_OBJECT(combo), "destroy", G_CALLBACK(sp_psel_pattern_destroy), psel);
+ g_object_set_data(G_OBJECT(psel), "patternmenu", combo);
+ g_object_ref( G_OBJECT(combo));
+
+ gtk_container_add(GTK_CONTAINER(hb), combo);
+ gtk_box_pack_start(GTK_BOX(tbl), hb, FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS);
+
+ g_object_unref( G_OBJECT(store));
+ }
+
+ {
+ auto hb = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
+ gtk_box_set_homogeneous(GTK_BOX(hb), FALSE);
+ auto l = gtk_label_new(nullptr);
+ gtk_label_set_markup(GTK_LABEL(l), _("Use the <b>Node tool</b> to adjust position, scale, and rotation of the pattern on canvas. Use <b>Object &gt; Pattern &gt; Objects to Pattern</b> to create a new pattern from selection."));
+ gtk_label_set_line_wrap(GTK_LABEL(l), true);
+ gtk_widget_set_size_request(l, 180, -1);
+ gtk_box_pack_start(GTK_BOX(hb), l, TRUE, TRUE, AUX_BETWEEN_BUTTON_GROUPS);
+ gtk_box_pack_start(GTK_BOX(tbl), hb, FALSE, FALSE, AUX_BETWEEN_BUTTON_GROUPS);
+ }
+
+ gtk_widget_show_all(tbl);
+
+ gtk_container_add(GTK_CONTAINER(psel->frame), tbl);
+ psel->selector = tbl;
+ g_object_set_data(G_OBJECT(psel->selector), "pattern-selector", tbl);
+
+ gtk_label_set_markup(GTK_LABEL(psel->label), _("<b>Pattern fill</b>"));
+ }
+#ifdef SP_PS_VERBOSE
+ g_print("Pattern req\n");
+#endif
+}
+
+static void sp_paint_selector_set_mode_hatch(SPPaintSelector *psel, SPPaintSelector::Mode mode)
+{
+ if (mode == SPPaintSelector::MODE_HATCH) {
+ sp_paint_selector_set_style_buttons(psel, psel->unset);
+ }
+
+ gtk_widget_set_sensitive(psel->style, TRUE);
+
+ if (psel->mode == SPPaintSelector::MODE_HATCH) {
+ /* Already have hatch menu, for the moment unset */
+ } else {
+ sp_paint_selector_clear_frame(psel);
+
+ gtk_label_set_markup(GTK_LABEL(psel->label), _("<b>Hatch fill</b>"));
+ }
+#ifdef SP_PS_VERBOSE
+ g_print("Hatch req\n");
+#endif
+}
+
+gboolean SPPaintSelector::isSeparator (GtkTreeModel *model, GtkTreeIter *iter, gpointer /*data*/) {
+
+ gboolean sep = FALSE;
+ gtk_tree_model_get(model, iter, COMBO_COL_SEP, &sep, -1);
+ return sep;
+}
+
+SPPattern *SPPaintSelector::getPattern()
+{
+ SPPattern *pat = nullptr;
+ g_return_val_if_fail(mode == MODE_PATTERN, NULL);
+
+ GtkWidget *combo = GTK_WIDGET(g_object_get_data(G_OBJECT(this), "patternmenu"));
+
+ /* no pattern menu if we were just selected */
+ if (combo == nullptr) {
+ return nullptr;
+ }
+
+ GtkTreeModel *store = gtk_combo_box_get_model(GTK_COMBO_BOX(combo));
+
+ /* Get the selected pattern */
+ GtkTreeIter iter;
+ if (!gtk_combo_box_get_active_iter(GTK_COMBO_BOX(combo), &iter) ||
+ !gtk_list_store_iter_is_valid(GTK_LIST_STORE(store), &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) {
+ return nullptr;
+ }
+
+ if (strcmp(patid, "none") != 0) {
+ gchar *paturn;
+
+ if (stockid) {
+ paturn = g_strconcat("urn:inkscape:pattern:", patid, NULL);
+ } else {
+ paturn = g_strdup(patid);
+ }
+ SPObject *pat_obj = get_stock_item(paturn);
+ if (pat_obj) {
+ pat = SP_PATTERN(pat_obj);
+ }
+ g_free(paturn);
+ } else {
+ SPDocument *doc = SP_ACTIVE_DOCUMENT;
+ SPObject *pat_obj = doc->getObjectById(patid);
+
+ if (pat_obj && SP_IS_PATTERN(pat_obj)) {
+ pat = SP_PATTERN(pat_obj)->rootPattern();
+ }
+ }
+
+ g_free(patid);
+
+ return pat;
+}
+
+static void sp_paint_selector_set_mode_swatch(SPPaintSelector *psel, SPPaintSelector::Mode mode)
+{
+ if (mode == SPPaintSelector::MODE_SWATCH) {
+ sp_paint_selector_set_style_buttons(psel, psel->swatch);
+ }
+
+ gtk_widget_set_sensitive(psel->style, TRUE);
+
+ if (psel->mode == SPPaintSelector::MODE_SWATCH){
+ // swatchsel = static_cast<SwatchSelector*>(g_object_get_data(G_OBJECT(psel->selector), "swatch-selector"));
+ } else {
+ sp_paint_selector_clear_frame(psel);
+ // Create new gradient selector
+ SwatchSelector *swatchsel = new SwatchSelector();
+ swatchsel->show();
+
+ swatchsel->connectGrabbedHandler( G_CALLBACK(sp_paint_selector_gradient_grabbed), psel );
+ swatchsel->connectDraggedHandler( G_CALLBACK(sp_paint_selector_gradient_dragged), psel );
+ swatchsel->connectReleasedHandler( G_CALLBACK(sp_paint_selector_gradient_released), psel );
+ swatchsel->connectchangedHandler( G_CALLBACK(sp_paint_selector_gradient_changed), psel );
+
+ // Pack everything to frame
+ gtk_container_add(GTK_CONTAINER(psel->frame), GTK_WIDGET(swatchsel->gobj()));
+ psel->selector = GTK_WIDGET(swatchsel->gobj());
+ g_object_set_data(G_OBJECT(psel->selector), "swatch-selector", swatchsel);
+
+ gtk_label_set_markup(GTK_LABEL(psel->label), _("<b>Swatch fill</b>"));
+ }
+
+#ifdef SP_PS_VERBOSE
+ g_print("Swatch req\n");
+#endif
+}
+
+// TODO this seems very bad to be taking in a desktop pointer to muck with. Logic probably belongs elsewhere
+void SPPaintSelector::setFlatColor( SPDesktop *desktop, gchar const *color_property, gchar const *opacity_property )
+{
+ SPCSSAttr *css = sp_repr_css_attr_new();
+
+ SPColor color;
+ gfloat alpha = 0;
+ getColorAlpha( color, alpha );
+
+ std::string colorStr = color.toString();
+
+#ifdef SP_PS_VERBOSE
+ guint32 rgba = color.toRGBA32( alpha );
+ g_message("sp_paint_selector_set_flat_color() to '%s' from 0x%08x::%s",
+ colorStr.c_str(),
+ rgba,
+ (color.icc ? color.icc->colorProfile.c_str():"<null>") );
+#endif // SP_PS_VERBOSE
+
+ sp_repr_css_set_property(css, color_property, colorStr.c_str());
+ Inkscape::CSSOStringStream osalpha;
+ osalpha << alpha;
+ sp_repr_css_set_property(css, opacity_property, osalpha.str().c_str());
+
+ sp_desktop_set_style(desktop, css);
+
+ sp_repr_css_attr_unref(css);
+}
+
+SPPaintSelector::Mode SPPaintSelector::getModeForStyle(SPStyle const & style, FillOrStroke kind)
+{
+ Mode mode = MODE_UNSET;
+ SPIPaint const &target = *style.getFillOrStroke(kind == FILL);
+
+ if ( !target.set ) {
+ mode = MODE_UNSET;
+ } else if ( target.isPaintserver() ) {
+ SPPaintServer const *server = (kind == FILL) ? style.getFillPaintServer() : style.getStrokePaintServer();
+
+#ifdef SP_PS_VERBOSE
+ g_message("SPPaintSelector::getModeForStyle(%p, %d)", &style, kind);
+ g_message("==== server:%p %s grad:%s swatch:%s", server, server->getId(), (SP_IS_GRADIENT(server)?"Y":"n"), (SP_IS_GRADIENT(server) && SP_GRADIENT(server)->getVector()->isSwatch()?"Y":"n"));
+#endif // SP_PS_VERBOSE
+
+
+ if (server && SP_IS_GRADIENT(server) && SP_GRADIENT(server)->getVector()->isSwatch()) {
+ mode = MODE_SWATCH;
+ } else if (SP_IS_LINEARGRADIENT(server)) {
+ mode = MODE_GRADIENT_LINEAR;
+ } else if (SP_IS_RADIALGRADIENT(server)) {
+ mode = MODE_GRADIENT_RADIAL;
+#ifdef WITH_MESH
+ } else if (SP_IS_MESHGRADIENT(server)) {
+ mode = MODE_GRADIENT_MESH;
+#endif
+ } else if (SP_IS_PATTERN(server)) {
+ mode = MODE_PATTERN;
+ } else if (SP_IS_HATCH(server)) {
+ mode = MODE_HATCH;
+ } else {
+ g_warning( "file %s: line %d: Unknown paintserver", __FILE__, __LINE__ );
+ mode = MODE_NONE;
+ }
+ } else if ( target.isColor() ) {
+ // TODO this is no longer a valid assertion:
+ mode = MODE_SOLID_COLOR; // so far only rgb can be read from svg
+ } else if ( target.isNone() ) {
+ mode = MODE_NONE;
+ } else {
+ g_warning( "file %s: line %d: Unknown paint type", __FILE__, __LINE__ );
+ mode = MODE_NONE;
+ }
+
+ return mode;
+}
+
+/*
+ Local Variables:
+ mode:c++
+ c-file-style:"stroustrup"
+ c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
+ indent-tabs-mode:nil
+ fill-column:99
+ End:
+*/
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :
diff --git a/src/widgets/paint-selector.h b/src/widgets/paint-selector.h
new file mode 100644
index 0000000..7d142f3
--- /dev/null
+++ b/src/widgets/paint-selector.h
@@ -0,0 +1,171 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/** @file
+ * Generic paint selector widget
+ *//*
+ * Authors:
+ * Lauris
+ * Jon A. Cruz <jon@joncruz.org>
+ *
+ * Copyright (C) 2018 Authors
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+#ifndef SEEN_SP_PAINT_SELECTOR_H
+#define SEEN_SP_PAINT_SELECTOR_H
+
+#include <glib.h>
+#include <gtk/gtk.h>
+
+#include "color.h"
+#include "fill-or-stroke.h"
+
+#include "object/sp-gradient-spread.h"
+#include "object/sp-gradient-units.h"
+
+#include "ui/selected-color.h"
+
+class SPGradient;
+#ifdef WITH_MESH
+class SPMeshGradient;
+#endif
+class SPDesktop;
+class SPPattern;
+class SPStyle;
+
+#define SP_TYPE_PAINT_SELECTOR (sp_paint_selector_get_type ())
+#define SP_PAINT_SELECTOR(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), SP_TYPE_PAINT_SELECTOR, SPPaintSelector))
+#define SP_PAINT_SELECTOR_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), SP_TYPE_PAINT_SELECTOR, SPPaintSelectorClass))
+#define SP_IS_PAINT_SELECTOR(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), SP_TYPE_PAINT_SELECTOR))
+#define SP_IS_PAINT_SELECTOR_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), SP_TYPE_PAINT_SELECTOR))
+
+/**
+ * Generic paint selector widget.
+ */
+struct SPPaintSelector {
+ GtkBox vbox;
+
+ enum Mode {
+ MODE_EMPTY,
+ MODE_MULTIPLE,
+ MODE_NONE,
+ MODE_SOLID_COLOR,
+ MODE_GRADIENT_LINEAR,
+ MODE_GRADIENT_RADIAL,
+#ifdef WITH_MESH
+ MODE_GRADIENT_MESH,
+#endif
+ MODE_PATTERN,
+ MODE_HATCH,
+ MODE_SWATCH,
+ MODE_UNSET
+ } ;
+
+ enum FillRule {
+ FILLRULE_NONZERO,
+ FILLRULE_EVENODD
+ } ;
+
+ guint update : 1;
+
+ Mode mode;
+
+ GtkWidget *style;
+ GtkWidget *none;
+ GtkWidget *solid;
+ GtkWidget *gradient;
+ GtkWidget *radial;
+#ifdef WITH_MESH
+ GtkWidget *mesh;
+#endif
+ GtkWidget *pattern;
+ GtkWidget *swatch;
+ GtkWidget *unset;
+
+ GtkWidget *fillrulebox;
+ GtkWidget *evenodd, *nonzero;
+
+ GtkWidget *frame, *selector;
+ GtkWidget *label;
+
+ Inkscape::UI::SelectedColor *selected_color;
+ bool updating_color;
+
+ static Mode getModeForStyle(SPStyle const & style, FillOrStroke kind);
+
+ void setMode( Mode mode );
+ void setFillrule( FillRule fillrule );
+
+ void setColorAlpha( SPColor const &color, float alpha );
+ void getColorAlpha( SPColor &color, gfloat &alpha ) const;
+
+ void setGradientLinear( SPGradient *vector );
+ void setGradientRadial( SPGradient *vector );
+#ifdef WITH_MESH
+ void setGradientMesh(SPMeshGradient *array);
+#endif
+ void setSwatch( SPGradient *vector );
+
+ void setGradientProperties( SPGradientUnits units, SPGradientSpread spread );
+ void getGradientProperties( SPGradientUnits &units, SPGradientSpread &spread ) const;
+
+ void pushAttrsToGradient( SPGradient *gr ) const;
+ SPGradient *getGradientVector();
+
+#ifdef WITH_MESH
+ SPMeshGradient * getMeshGradient();
+ void updateMeshList( SPMeshGradient *pat );
+#endif
+
+ SPPattern * getPattern();
+ void updatePatternList( SPPattern *pat );
+
+ static gboolean isSeparator (GtkTreeModel *model, GtkTreeIter *iter, gpointer data);
+
+ // TODO move this elsewhere:
+ void setFlatColor( SPDesktop *desktop, const gchar *color_property, const gchar *opacity_property );
+
+ void onSelectedColorGrabbed();
+ void onSelectedColorDragged();
+ void onSelectedColorReleased();
+ void onSelectedColorChanged();
+};
+
+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
+};
+
+/// The SPPaintSelector vtable
+struct SPPaintSelectorClass {
+ GtkBoxClass parent_class;
+
+ void (* mode_changed) (SPPaintSelector *psel, SPPaintSelector::Mode mode);
+
+ void (* grabbed) (SPPaintSelector *psel);
+ void (* dragged) (SPPaintSelector *psel);
+ void (* released) (SPPaintSelector *psel);
+ void (* changed) (SPPaintSelector *psel);
+ void (* fillrule_changed) (SPPaintSelector *psel, SPPaintSelector::FillRule fillrule);
+};
+
+GType sp_paint_selector_get_type ();
+
+SPPaintSelector *sp_paint_selector_new(FillOrStroke kind);
+
+
+
+#endif // SEEN_SP_PAINT_SELECTOR_H
+
+/*
+ Local Variables:
+ mode:c++
+ c-file-style:"stroustrup"
+ c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
+ indent-tabs-mode:nil
+ fill-column:99
+ End:
+*/
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :
diff --git a/src/widgets/sp-attribute-widget.cpp b/src/widgets/sp-attribute-widget.cpp
new file mode 100644
index 0000000..a82d06d
--- /dev/null
+++ b/src/widgets/sp-attribute-widget.cpp
@@ -0,0 +1,303 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/**
+ * @file
+ * Base widget for user input of object properties.
+ */
+/* Authors:
+ * Lauris Kaplinski <lauris@ximian.com>
+ * Abhishek Sharma
+ * Kris De Gussem <Kris.DeGussem@gmail.com>
+ *
+ * Copyright (C) 2001 Ximian, Inc.
+ * Copyright (C) 2012, authors
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#include <glibmm/i18n.h>
+#include <gtkmm/entry.h>
+#include <gtkmm/grid.h>
+
+#include "sp-attribute-widget.h"
+
+#include "include/macros.h"
+#include "document.h"
+#include "document-undo.h"
+#include "verbs.h"
+
+#include "include/gtkmm_version.h"
+
+#include "object/sp-object.h"
+
+#include "xml/repr.h"
+
+using Inkscape::DocumentUndo;
+
+/**
+ * Callback for user input in one of the entries.
+ *
+ * sp_attribute_table_entry_changed set the object property
+ * to the new value and updates history. It is a callback from
+ * the entries created by SPAttributeTable.
+ *
+ * @param editable pointer to the entry box.
+ * @param spat pointer to the SPAttributeTable instance.
+ */
+static void sp_attribute_table_entry_changed (Gtk::Entry *editable, SPAttributeTable *spat);
+/**
+ * Callback for a modification of the selected object (size, color, properties, etc.).
+ *
+ * sp_attribute_table_object_modified rereads the object properties
+ * and shows the values in the entry boxes. It is a callback from a
+ * connection of the SPObject.
+ *
+ * @param object the SPObject to which this instance is referring to.
+ * @param flags gives the applied modifications
+ * @param spat pointer to the SPAttributeTable instance.
+ */
+static void sp_attribute_table_object_modified (SPObject *object, guint flags, SPAttributeTable *spaw);
+/**
+ * Callback for the deletion of the selected object.
+ *
+ * sp_attribute_table_object_release invalidates all data of
+ * SPAttributeTable and disables the widget.
+ */
+static void sp_attribute_table_object_release (SPObject */*object*/, SPAttributeTable *spat);
+
+#define XPAD 4
+#define YPAD 0
+
+
+SPAttributeTable::SPAttributeTable () :
+ _object(nullptr),
+ blocked(false),
+ table(nullptr),
+ _attributes(),
+ _entries(),
+ modified_connection(),
+ release_connection()
+{
+}
+
+SPAttributeTable::SPAttributeTable (SPObject *object, std::vector<Glib::ustring> &labels, std::vector<Glib::ustring> &attributes, GtkWidget* parent) :
+ _object(nullptr),
+ blocked(false),
+ table(nullptr),
+ _attributes(),
+ _entries(),
+ modified_connection(),
+ release_connection()
+{
+ set_object(object, labels, attributes, parent);
+}
+
+SPAttributeTable::~SPAttributeTable ()
+{
+ clear();
+}
+
+void SPAttributeTable::clear()
+{
+ if (table)
+ {
+ std::vector<Gtk::Widget*> ch = table->get_children();
+ for (int i = (ch.size())-1; i >=0 ; i--)
+ {
+ Gtk::Widget *w = ch[i];
+ ch.pop_back();
+ if (w != nullptr)
+ {
+ try
+ {
+ sp_signal_disconnect_by_data (w->gobj(), this);
+ delete w;
+ }
+ catch(...)
+ {
+ }
+ }
+ }
+ ch.clear();
+ _attributes.clear();
+ _entries.clear();
+
+ delete table;
+ table = nullptr;
+ }
+
+ if (_object)
+ {
+ modified_connection.disconnect();
+ release_connection.disconnect();
+ _object = nullptr;
+ }
+}
+
+void SPAttributeTable::set_object(SPObject *object,
+ std::vector<Glib::ustring> &labels,
+ std::vector<Glib::ustring> &attributes,
+ GtkWidget* parent)
+{
+ g_return_if_fail (!object || SP_IS_OBJECT (object));
+ g_return_if_fail (!object || !labels.empty() || !attributes.empty());
+ g_return_if_fail (labels.size() == attributes.size());
+
+ clear();
+ _object = object;
+
+ if (object) {
+ blocked = true;
+
+ // Set up object
+ modified_connection = object->connectModified(sigc::bind<2>(sigc::ptr_fun(&sp_attribute_table_object_modified), this));
+ release_connection = object->connectRelease (sigc::bind<1>(sigc::ptr_fun(&sp_attribute_table_object_release), this));
+
+ // Create table
+ table = new Gtk::Grid();
+
+ if (!(parent == nullptr))
+ gtk_container_add(GTK_CONTAINER(parent), (GtkWidget*)table->gobj());
+
+ // Fill rows
+ _attributes = attributes;
+ for (guint i = 0; i < (attributes.size()); i++) {
+ Gtk::Label *ll = new Gtk::Label (_(labels[i].c_str()));
+ ll->show();
+ ll->set_halign(Gtk::ALIGN_START);
+ ll->set_valign(Gtk::ALIGN_CENTER);
+ ll->set_vexpand();
+ ll->set_margin_start(XPAD);
+ ll->set_margin_end(XPAD);
+ ll->set_margin_top(XPAD);
+ ll->set_margin_bottom(XPAD);
+ table->attach(*ll, 0, i, 1, 1);
+
+ Gtk::Entry *ee = new Gtk::Entry();
+ ee->show();
+ const gchar *val = object->getRepr()->attribute(attributes[i].c_str());
+ ee->set_text (val ? val : (const gchar *) "");
+ ee->set_hexpand();
+ ee->set_vexpand();
+ ee->set_margin_start(XPAD);
+ ee->set_margin_end(XPAD);
+ ee->set_margin_top(XPAD);
+ ee->set_margin_bottom(XPAD);
+ table->attach(*ee, 1, i, 1, 1);
+
+ _entries.push_back(ee);
+ g_signal_connect ( ee->gobj(), "changed",
+ G_CALLBACK (sp_attribute_table_entry_changed),
+ this );
+ }
+ /* Show table */
+ table->show ();
+ blocked = false;
+ }
+}
+
+void SPAttributeTable::change_object(SPObject *object)
+{
+ g_return_if_fail (!object || SP_IS_OBJECT (object));
+ if (_object)
+ {
+ modified_connection.disconnect();
+ release_connection.disconnect();
+ _object = nullptr;
+ }
+
+ _object = object;
+ if (_object) {
+ blocked = true;
+
+ // Set up object
+ modified_connection = _object->connectModified(sigc::bind<2>(sigc::ptr_fun(&sp_attribute_table_object_modified), this));
+ release_connection = _object->connectRelease (sigc::bind<1>(sigc::ptr_fun(&sp_attribute_table_object_release), this));
+ for (guint i = 0; i < (_attributes.size()); i++) {
+ const gchar *val = _object->getRepr()->attribute(_attributes[i].c_str());
+ _entries[i]->set_text(val ? val : "");
+ }
+
+ blocked = false;
+ }
+
+}
+
+void SPAttributeTable::reread_properties()
+{
+ blocked = true;
+ for (guint i = 0; i < (_attributes.size()); i++)
+ {
+ const gchar *val = _object->getRepr()->attribute(_attributes[i].c_str());
+ _entries[i]->set_text(val ? val : "");
+ }
+ blocked = false;
+}
+
+static void sp_attribute_table_object_modified ( SPObject */*object*/,
+ guint flags,
+ SPAttributeTable *spat )
+{
+ if (flags & SP_OBJECT_MODIFIED_FLAG)
+ {
+ std::vector<Glib::ustring> attributes = spat->get_attributes();
+ std::vector<Gtk::Entry *> entries = spat->get_entries();
+ Glib::ustring text="";
+ for (guint i = 0; i < (attributes.size()); i++) {
+ Gtk::Entry* e = entries[i];
+ const gchar *val = spat->_object->getRepr()->attribute(attributes[i].c_str());
+ text = e->get_text ();
+ if (val || !text.empty()) {
+ if (text != val) {
+ // We are different
+ spat->blocked = true;
+ e->set_text (val ? val : (const gchar *) "");
+ spat->blocked = false;
+ }
+ }
+ }
+ }
+
+} // end of sp_attribute_table_object_modified()
+
+static void sp_attribute_table_entry_changed ( Gtk::Entry *editable,
+ SPAttributeTable *spat )
+{
+ if (!spat->blocked)
+ {
+ std::vector<Glib::ustring> attributes = spat->get_attributes();
+ std::vector<Gtk::Entry *> entries = spat->get_entries();
+ for (guint i = 0; i < (attributes.size()); i++) {
+ Gtk::Entry *e = entries[i];
+ if ((GtkWidget*)editable == (GtkWidget*)e->gobj()) {
+ spat->blocked = true;
+ Glib::ustring text = e->get_text ();
+ if (spat->_object) {
+ spat->_object->getRepr()->setAttribute(attributes[i], text);
+ DocumentUndo::done(spat->_object->document, SP_VERB_NONE,
+ _("Set attribute"));
+ }
+ spat->blocked = false;
+ return;
+ }
+ }
+ g_warning ("file %s: line %d: Entry signalled change, but there is no such entry", __FILE__, __LINE__);
+ }
+
+} // end of sp_attribute_table_entry_changed()
+
+static void sp_attribute_table_object_release (SPObject */*object*/, SPAttributeTable *spat)
+{
+ std::vector<Glib::ustring> labels;
+ std::vector<Glib::ustring> attributes;
+ spat->set_object (nullptr, labels, attributes, nullptr);
+}
+
+/*
+ Local Variables:
+ mode:c++
+ c-file-style:"stroustrup"
+ c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
+ indent-tabs-mode:nil
+ fill-column:99
+ End:
+*/
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :
diff --git a/src/widgets/sp-attribute-widget.h b/src/widgets/sp-attribute-widget.h
new file mode 100644
index 0000000..f43fe84
--- /dev/null
+++ b/src/widgets/sp-attribute-widget.h
@@ -0,0 +1,172 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/**
+ * @file
+ * Widget that listens and modifies repr attributes.
+ */
+/* Authors:
+ * Lauris Kaplinski <lauris@kaplinski.com>
+ * Kris De Gussem <Kris.DeGussem@gmail.com>
+ *
+ * Copyright (C) 2001 Ximian, Inc.
+ * Copyright (C) 2002,2011-2012 authors
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#ifndef SEEN_DIALOGS_SP_ATTRIBUTE_WIDGET_H
+#define SEEN_DIALOGS_SP_ATTRIBUTE_WIDGET_H
+
+#include <gtkmm/widget.h>
+#include <cstddef>
+#include <sigc++/connection.h>
+
+namespace Gtk {
+class Entry;
+class Grid;
+}
+
+namespace Inkscape {
+namespace XML {
+class Node;
+}
+}
+
+class SPObject;
+
+/**
+ * A base class for dialogs to enter the value of several properties.
+ *
+ * SPAttributeTable is used if you want to alter several properties of
+ * an object. For each property, it creates an entry next to a label and
+ * positiones these labels and entries one by one below each other.
+ */
+class SPAttributeTable : public Gtk::Widget {
+public:
+ /**
+ * Constructor defaulting to no content.
+ */
+ SPAttributeTable ();
+
+ /**
+ * Constructor referring to a specific object.
+ *
+ * This constructor initializes all data fields and creates the necessary widgets.
+ * set_object is called for this purpose.
+ *
+ * @param object the SPObject to which this instance is referring to. It should be the object that is currently selected and whose properties are being shown by this SPAttributeTable instance.
+ * @param labels list of labels to be shown for the different attributes.
+ * @param attributes list of attributes whose value can be edited.
+ * @param parent the parent object owning the SPAttributeTable instance.
+ *
+ * @see set_object
+ */
+ SPAttributeTable (SPObject *object, std::vector<Glib::ustring> &labels, std::vector<Glib::ustring> &attributes, GtkWidget* parent);
+
+ ~SPAttributeTable () override;
+
+ /**
+ * Sets class properties and creates child widgets
+ *
+ * set_object initializes all data fields, creates links to the
+ * SPOject item and creates the necessary widgets. For n properties
+ * n labels and n entries are created and shown in tabular format.
+ *
+ * @param object the SPObject to which this instance is referring to. It should be the object that is currently selected and whose properties are being shown by this SPAttribuTable instance.
+ * @param labels list of labels to be shown for the different attributes.
+ * @param attributes list of attributes whose value can be edited.
+ * @param parent the parent object owning the SPAttributeTable instance.
+ */
+ void set_object(SPObject *object, std::vector<Glib::ustring> &labels, std::vector<Glib::ustring> &attributes, GtkWidget* parent);
+
+ /**
+ * Update values in entry boxes on change of object.
+ *
+ * change_object updates the values of the entry boxes in case the user
+ * of Inkscape selects an other object.
+ * change_object is a subset of set_object and should only be called by
+ * the parent class (holding the SPAttributeTable instance). This function
+ * should only be called when the number of properties/entries nor
+ * the labels do not change.
+ *
+ * @param object the SPObject to which this instance is referring to. It should be the object that is currently selected and whose properties are being shown by this SPAttribuTable instance.
+ */
+ void change_object(SPObject *object);
+
+ /**
+ * Clears data of SPAttributeTable instance, destroys all child widgets and closes connections.
+ */
+ void clear();
+
+ /**
+ * Reads the object attributes.
+ *
+ * Reads the object attributes and shows the new object attributes in the
+ * entry boxes. Caution: function should only be used when which there is
+ * no change in which objects are selected.
+ */
+ void reread_properties();
+
+ /**
+ * Gives access to the attributes list.
+ */
+ std::vector<Glib::ustring> get_attributes() {return _attributes;};
+
+ /**
+ * Gives access to the Gtk::Entry list.
+ */
+ std::vector<Gtk::Entry *> get_entries() {return _entries;};
+
+ /**
+ * Stores pointer to the selected object.
+ */
+ SPObject *_object;
+
+ /**
+ * Indicates whether SPAttributeTable is processing callbacks and whether it should accept any updating.
+ */
+ bool blocked;
+
+private:
+ /**
+ * Container widget for the dynamically created child widgets (labels and entry boxes).
+ */
+ Gtk::Grid *table;
+
+ /**
+ * List of attributes.
+ *
+ * _attributes stores the attribute names of the selected object that
+ * are valid and can be modified through this widget.
+ */
+ std::vector<Glib::ustring> _attributes;
+ /**
+ * List of pointers to the respective entry boxes.
+ *
+ * _entries stores pointers to the dynamically created entry boxes in which
+ * the user can midify the attributes of the selected object.
+ */
+ std::vector<Gtk::Entry *> _entries;
+
+ /**
+ * Sets the callback for a modification of the selection.
+ */
+ sigc::connection modified_connection;
+
+ /**
+ * Sets the callback for the deletion of the selected object.
+ */
+ sigc::connection release_connection;
+};
+
+#endif
+
+/*
+ Local Variables:
+ mode:c++
+ c-file-style:"stroustrup"
+ c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
+ indent-tabs-mode:nil
+ fill-column:99
+ End:
+*/
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :
diff --git a/src/widgets/sp-color-selector.cpp b/src/widgets/sp-color-selector.cpp
new file mode 100644
index 0000000..c1c6975
--- /dev/null
+++ b/src/widgets/sp-color-selector.cpp
@@ -0,0 +1,334 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/** @file
+ * TODO: insert short description here
+ *//*
+ * Authors:
+ * see git history
+ * bulia byak <buliabyak@users.sf.net>
+ * Jon A. Cruz <jon@joncruz.org>
+ *
+ * Copyright (C) 2018 Authors
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#include <cmath>
+#include <gtk/gtk.h>
+#include <glibmm/i18n.h>
+#include "sp-color-selector.h"
+
+enum {
+ GRABBED,
+ DRAGGED,
+ RELEASED,
+ CHANGED,
+ LAST_SIGNAL
+};
+
+#define noDUMP_CHANGE_INFO
+#define FOO_NAME(x) g_type_name( G_TYPE_FROM_INSTANCE(x) )
+
+static void sp_color_selector_dispose(GObject *object);
+
+static void sp_color_selector_show_all( GtkWidget *widget );
+static void sp_color_selector_hide( GtkWidget *widget );
+
+static guint csel_signals[LAST_SIGNAL] = {0};
+
+double ColorSelector::_epsilon = 1e-4;
+
+G_DEFINE_TYPE(SPColorSelector, sp_color_selector, GTK_TYPE_BOX);
+
+void sp_color_selector_class_init( SPColorSelectorClass *klass )
+{
+ static const gchar* nameset[] = {N_("Unnamed"), nullptr};
+ GObjectClass *object_class = G_OBJECT_CLASS(klass);
+ GtkWidgetClass *widget_class;
+ widget_class = GTK_WIDGET_CLASS(klass);
+
+ csel_signals[GRABBED] = g_signal_new( "grabbed",
+ G_TYPE_FROM_CLASS(object_class),
+ (GSignalFlags)(G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE),
+ G_STRUCT_OFFSET(SPColorSelectorClass, grabbed),
+ nullptr, nullptr,
+ g_cclosure_marshal_VOID__VOID,
+ G_TYPE_NONE, 0 );
+ csel_signals[DRAGGED] = g_signal_new( "dragged",
+ G_TYPE_FROM_CLASS(object_class),
+ (GSignalFlags)(G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE),
+ G_STRUCT_OFFSET(SPColorSelectorClass, dragged),
+ nullptr, nullptr,
+ g_cclosure_marshal_VOID__VOID,
+ G_TYPE_NONE, 0 );
+ csel_signals[RELEASED] = g_signal_new( "released",
+ G_TYPE_FROM_CLASS(object_class),
+ (GSignalFlags)(G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE),
+ G_STRUCT_OFFSET(SPColorSelectorClass, released),
+ nullptr, nullptr,
+ g_cclosure_marshal_VOID__VOID,
+ G_TYPE_NONE, 0 );
+ csel_signals[CHANGED] = g_signal_new( "changed",
+ G_TYPE_FROM_CLASS(object_class),
+ (GSignalFlags)(G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE),
+ G_STRUCT_OFFSET(SPColorSelectorClass, changed),
+ nullptr, nullptr,
+ g_cclosure_marshal_VOID__VOID,
+ G_TYPE_NONE, 0 );
+
+ klass->name = nameset;
+ klass->submode_count = 1;
+
+ object_class->dispose = sp_color_selector_dispose;
+
+ widget_class->show_all = sp_color_selector_show_all;
+ widget_class->hide = sp_color_selector_hide;
+
+}
+
+void sp_color_selector_init( SPColorSelector *csel )
+{
+ gtk_orientable_set_orientation(GTK_ORIENTABLE(csel), GTK_ORIENTATION_VERTICAL);
+
+ if ( csel->base )
+ {
+ csel->base->init();
+ }
+/* g_signal_connect(G_OBJECT(csel->rgbae), "changed", G_CALLBACK(sp_color_selector_rgba_entry_changed), csel); */
+}
+
+void sp_color_selector_dispose(GObject *object)
+{
+ SPColorSelector *csel = SP_COLOR_SELECTOR( object );
+ if ( csel->base )
+ {
+ delete csel->base;
+ csel->base = nullptr;
+ }
+
+ if ((G_OBJECT_CLASS(sp_color_selector_parent_class))->dispose ) {
+ (G_OBJECT_CLASS(sp_color_selector_parent_class))->dispose(object);
+ }
+}
+
+void sp_color_selector_show_all( GtkWidget *widget )
+{
+ gtk_widget_show( widget );
+}
+
+void sp_color_selector_hide(GtkWidget *widget)
+{
+ gtk_widget_hide( widget );
+}
+
+GtkWidget *sp_color_selector_new( GType selector_type )
+{
+ g_return_val_if_fail( g_type_is_a( selector_type, SP_TYPE_COLOR_SELECTOR ), NULL );
+
+ SPColorSelector *csel = SP_COLOR_SELECTOR( g_object_new( selector_type, nullptr ) );
+
+ return GTK_WIDGET( csel );
+}
+
+void ColorSelector::setSubmode( guint /*submode*/ )
+{
+}
+
+guint ColorSelector::getSubmode() const
+{
+ guint mode = 0;
+ return mode;
+}
+
+ColorSelector::ColorSelector( SPColorSelector* csel )
+ : _csel(csel),
+ _color( 0 ),
+ _alpha(1.0),
+ _held(FALSE),
+ virgin(true)
+{
+ g_return_if_fail( SP_IS_COLOR_SELECTOR(_csel) );
+}
+
+ColorSelector::~ColorSelector()
+= default;
+
+void ColorSelector::init()
+{
+ _csel->base = new ColorSelector( _csel );
+}
+
+void ColorSelector::setColor( const SPColor& color )
+{
+ setColorAlpha( color, _alpha );
+}
+
+SPColor ColorSelector::getColor() const
+{
+ return _color;
+}
+
+void ColorSelector::setAlpha( gfloat alpha )
+{
+ g_return_if_fail( ( 0.0 <= alpha ) && ( alpha <= 1.0 ) );
+ setColorAlpha( _color, alpha );
+}
+
+gfloat ColorSelector::getAlpha() const
+{
+ return _alpha;
+}
+
+/**
+Called from the outside to set the color; optionally emits signal (only when called from
+downstream, e.g. the RGBA value field, but not from the rest of the program)
+*/
+void ColorSelector::setColorAlpha( const SPColor& color, gfloat alpha, bool emit )
+{
+#ifdef DUMP_CHANGE_INFO
+ g_message("ColorSelector::setColorAlpha( this=%p, %f, %f, %f, %s, %f, %s) in %s", this, color.v.c[0], color.v.c[1], color.v.c[2], (color.icc?color.icc->colorProfile.c_str():"<null>"), alpha, (emit?"YES":"no"), FOO_NAME(_csel));
+#endif
+ g_return_if_fail( _csel != nullptr );
+ g_return_if_fail( ( 0.0 <= alpha ) && ( alpha <= 1.0 ) );
+
+#ifdef DUMP_CHANGE_INFO
+ g_message("---- ColorSelector::setColorAlpha virgin:%s !close:%s alpha is:%s in %s",
+ (virgin?"YES":"no"),
+ (!color.isClose( _color, _epsilon )?"YES":"no"),
+ ((fabs((_alpha) - (alpha)) >= _epsilon )?"YES":"no"),
+ FOO_NAME(_csel)
+ );
+#endif
+
+ if ( virgin || !color.isClose( _color, _epsilon ) ||
+ (fabs((_alpha) - (alpha)) >= _epsilon )) {
+
+ virgin = false;
+
+ _color = color;
+ _alpha = alpha;
+ _colorChanged();
+
+ if (emit) {
+ g_signal_emit(G_OBJECT(_csel), csel_signals[CHANGED], 0);
+ }
+#ifdef DUMP_CHANGE_INFO
+ } else {
+ g_message("++++ ColorSelector::setColorAlpha color:%08x ==> _color:%08X isClose:%s in %s", color.toRGBA32(alpha), _color.toRGBA32(_alpha),
+ (color.isClose( _color, _epsilon )?"YES":"no"), FOO_NAME(_csel));
+#endif
+ }
+}
+
+void ColorSelector::_grabbed()
+{
+ _held = TRUE;
+#ifdef DUMP_CHANGE_INFO
+ g_message("%s:%d: About to signal %s in %s", __FILE__, __LINE__,
+ "GRABBED",
+ FOO_NAME(_csel));
+#endif
+ g_signal_emit(G_OBJECT(_csel), csel_signals[GRABBED], 0);
+}
+
+void ColorSelector::_released()
+{
+ _held = false;
+#ifdef DUMP_CHANGE_INFO
+ g_message("%s:%d: About to signal %s in %s", __FILE__, __LINE__,
+ "RELEASED",
+ FOO_NAME(_csel));
+#endif
+ g_signal_emit(G_OBJECT(_csel), csel_signals[RELEASED], 0);
+ g_signal_emit(G_OBJECT(_csel), csel_signals[CHANGED], 0);
+}
+
+// Called from subclasses to update color and broadcast if needed
+void ColorSelector::_updateInternals( const SPColor& color, gfloat alpha, gboolean held )
+{
+ g_return_if_fail( ( 0.0 <= alpha ) && ( alpha <= 1.0 ) );
+ gboolean colorDifferent = ( !color.isClose( _color, _epsilon )
+ || ( fabs((_alpha) - (alpha)) >= _epsilon ) );
+
+ gboolean grabbed = held && !_held;
+ gboolean released = !held && _held;
+
+ // Store these before emitting any signals
+ _held = held;
+ if ( colorDifferent )
+ {
+ _color = color;
+ _alpha = alpha;
+ }
+
+ if ( grabbed )
+ {
+#ifdef DUMP_CHANGE_INFO
+ g_message("%s:%d: About to signal %s to color %08x::%s in %s", __FILE__, __LINE__,
+ "GRABBED",
+ color.toRGBA32( alpha ), (color.icc?color.icc->colorProfile.c_str():"<null>"), FOO_NAME(_csel));
+#endif
+ g_signal_emit(G_OBJECT(_csel), csel_signals[GRABBED], 0);
+ }
+ else if ( released )
+ {
+#ifdef DUMP_CHANGE_INFO
+ g_message("%s:%d: About to signal %s to color %08x::%s in %s", __FILE__, __LINE__,
+ "RELEASED",
+ color.toRGBA32( alpha ), (color.icc?color.icc->colorProfile.c_str():"<null>"), FOO_NAME(_csel));
+#endif
+ g_signal_emit(G_OBJECT(_csel), csel_signals[RELEASED], 0);
+ }
+
+ if ( colorDifferent || released )
+ {
+#ifdef DUMP_CHANGE_INFO
+ g_message("%s:%d: About to signal %s to color %08x::%s in %s", __FILE__, __LINE__,
+ (_held ? "CHANGED" : "DRAGGED" ),
+ color.toRGBA32( alpha ), (color.icc?color.icc->colorProfile.c_str():"<null>"), FOO_NAME(_csel));
+#endif
+ g_signal_emit(G_OBJECT(_csel), csel_signals[_held ? DRAGGED : CHANGED], 0);
+ }
+}
+
+/**
+ * Called once the color actually changes. Allows subclasses to react to changes.
+ */
+void ColorSelector::_colorChanged()
+{
+}
+
+void ColorSelector::getColorAlpha( SPColor &color, gfloat &alpha ) const
+{
+ gint i = 0;
+
+ color = _color;
+ alpha = _alpha;
+
+ // Try to catch uninitialized value usage
+ if ( color.v.c[0] )
+ {
+ i++;
+ }
+ if ( color.v.c[1] )
+ {
+ i++;
+ }
+ if ( color.v.c[2] )
+ {
+ i++;
+ }
+ if ( alpha )
+ {
+ i++;
+ }
+}
+
+/*
+ Local Variables:
+ mode:c++
+ c-file-style:"stroustrup"
+ c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
+ indent-tabs-mode:nil
+ fill-column:99
+ End:
+*/
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :
diff --git a/src/widgets/sp-color-selector.h b/src/widgets/sp-color-selector.h
new file mode 100644
index 0000000..eb77250
--- /dev/null
+++ b/src/widgets/sp-color-selector.h
@@ -0,0 +1,105 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/** @file
+ * TODO: insert short description here
+ *//*
+ * Authors: see git history
+ *
+ * Copyright (C) 2018 Authors
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+#ifndef SEEN_SP_COLOR_SELECTOR_H
+#define SEEN_SP_COLOR_SELECTOR_H
+
+#include <gtk/gtk.h>
+#include "color.h"
+
+struct SPColorSelector;
+
+class ColorSelector
+{
+public:
+ ColorSelector( SPColorSelector* csel );
+ virtual ~ColorSelector();
+
+ virtual void init();
+
+ void setColor( const SPColor& color );
+ SPColor getColor() const;
+
+ void setAlpha( gfloat alpha );
+ gfloat getAlpha() const;
+
+ void setColorAlpha( const SPColor& color, gfloat alpha, bool emit = false );
+ void getColorAlpha( SPColor &color, gfloat &alpha ) const;
+
+ virtual void setSubmode( guint submode );
+ virtual guint getSubmode() const;
+
+protected:
+ void _grabbed();
+ void _released();
+ void _updateInternals( const SPColor& color, gfloat alpha, gboolean held );
+ gboolean _isHeld() const { return _held; }
+
+ virtual void _colorChanged();
+
+ static double _epsilon;
+
+ SPColorSelector* _csel;
+ SPColor _color;
+ gfloat _alpha; // guaranteed to be in [0, 1].
+
+private:
+ // By default, disallow copy constructor and assignment operator
+ ColorSelector( const ColorSelector& obj ) = delete;
+ ColorSelector& operator=( const ColorSelector& obj ) = delete;
+
+ gboolean _held;
+
+ bool virgin; // if true, no color is set yet
+};
+
+
+
+#define SP_TYPE_COLOR_SELECTOR (sp_color_selector_get_type ())
+#define SP_COLOR_SELECTOR(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), SP_TYPE_COLOR_SELECTOR, SPColorSelector))
+#define SP_COLOR_SELECTOR_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), SP_TYPE_COLOR_SELECTOR, SPColorSelectorClass))
+#define SP_IS_COLOR_SELECTOR(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), SP_TYPE_COLOR_SELECTOR))
+#define SP_IS_COLOR_SELECTOR_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), SP_TYPE_COLOR_SELECTOR))
+#define SP_COLOR_SELECTOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), SP_TYPE_COLOR_SELECTOR, SPColorSelectorClass))
+
+struct SPColorSelector {
+ GtkBox vbox;
+ ColorSelector* base;
+};
+
+struct SPColorSelectorClass {
+ GtkBoxClass parent_class;
+
+ const gchar **name;
+ guint submode_count;
+
+ void (* grabbed) (SPColorSelector *rgbsel);
+ void (* dragged) (SPColorSelector *rgbsel);
+ void (* released) (SPColorSelector *rgbsel);
+ void (* changed) (SPColorSelector *rgbsel);
+};
+
+GType sp_color_selector_get_type();
+
+GtkWidget *sp_color_selector_new( GType selector_type );
+
+
+
+#endif // SEEN_SP_COLOR_SELECTOR_H
+
+/*
+ Local Variables:
+ mode:c++
+ c-file-style:"stroustrup"
+ c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
+ indent-tabs-mode:nil
+ fill-column:99
+ End:
+*/
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :
diff --git a/src/widgets/sp-xmlview-tree.cpp b/src/widgets/sp-xmlview-tree.cpp
new file mode 100644
index 0000000..6f45e64
--- /dev/null
+++ b/src/widgets/sp-xmlview-tree.cpp
@@ -0,0 +1,866 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/**
+ * Specialization of GtkTreeView for the XML tree view
+ *
+ * Authors:
+ * MenTaLguY <mental@rydia.net>
+ *
+ * Copyright (C) 2002 MenTaLguY
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#include <cstring>
+
+#include "xml/node-event-vector.h"
+#include "sp-xmlview-tree.h"
+
+namespace {
+struct NodeData {
+ SPXMLViewTree * tree;
+ GtkTreeRowReference *rowref;
+ Inkscape::XML::Node * repr;
+ bool expanded = false; //< true if tree view has been expanded to this node
+ bool dragging = false;
+
+ NodeData(SPXMLViewTree *tree, GtkTreeIter *node, Inkscape::XML::Node *repr);
+ ~NodeData();
+};
+
+// currently dragged node
+Inkscape::XML::Node *dragging_repr = nullptr;
+} // namespace
+
+enum { STORE_TEXT_COL = 0, STORE_DATA_COL, STORE_N_COLS };
+
+static void sp_xmlview_tree_destroy(GtkWidget * object);
+
+static NodeData *sp_xmlview_tree_node_get_data(GtkTreeModel *model, GtkTreeIter *iter);
+
+static void add_node(SPXMLViewTree *tree, GtkTreeIter *parent, GtkTreeIter *before, Inkscape::XML::Node *repr);
+
+static void element_child_added (Inkscape::XML::Node * repr, Inkscape::XML::Node * child, Inkscape::XML::Node * ref, gpointer data);
+static void element_attr_changed (Inkscape::XML::Node * repr, const gchar * key, const gchar * old_value, const gchar * new_value, bool is_interactive, gpointer data);
+static void element_child_removed (Inkscape::XML::Node * repr, Inkscape::XML::Node * child, Inkscape::XML::Node * ref, gpointer data);
+static void element_order_changed (Inkscape::XML::Node * repr, Inkscape::XML::Node * child, Inkscape::XML::Node * oldref, Inkscape::XML::Node * newref, gpointer data);
+static void element_name_changed (Inkscape::XML::Node* repr, gchar const* oldname, gchar const* newname, gpointer data);
+static void element_attr_or_name_change_update(Inkscape::XML::Node* repr, NodeData* data);
+
+static void text_content_changed (Inkscape::XML::Node * repr, const gchar * old_content, const gchar * new_content, gpointer data);
+static void comment_content_changed (Inkscape::XML::Node * repr, const gchar * old_content, const gchar * new_content, gpointer data);
+static void pi_content_changed (Inkscape::XML::Node * repr, const gchar * old_content, const gchar * new_content, gpointer data);
+
+static gboolean ref_to_sibling (NodeData *node, Inkscape::XML::Node * ref, GtkTreeIter *);
+static gboolean repr_to_child (NodeData *node, Inkscape::XML::Node * repr, GtkTreeIter *);
+static GtkTreeRowReference *tree_iter_to_ref(SPXMLViewTree *, GtkTreeIter *);
+static gboolean tree_ref_to_iter (SPXMLViewTree * tree, GtkTreeIter* iter, GtkTreeRowReference *ref);
+
+static gboolean search_equal_func(GtkTreeModel *, gint column, const gchar *key, GtkTreeIter *, gpointer search_data);
+static gboolean foreach_func(GtkTreeModel *, GtkTreePath *, GtkTreeIter *, gpointer user_data);
+
+static void on_row_changed(GtkTreeModel *, GtkTreePath *, GtkTreeIter *, gpointer user_data);
+static void on_drag_begin(GtkWidget *, GdkDragContext *, gpointer userdata);
+static void on_drag_end(GtkWidget *, GdkDragContext *, gpointer userdata);
+static gboolean do_drag_motion(GtkWidget *, GdkDragContext *, gint x, gint y, guint time, gpointer user_data);
+
+static const Inkscape::XML::NodeEventVector element_repr_events = {
+ element_child_added,
+ element_child_removed,
+ element_attr_changed,
+ nullptr, /* content_changed */
+ element_order_changed,
+ element_name_changed
+};
+
+static const Inkscape::XML::NodeEventVector text_repr_events = {
+ nullptr, /* child_added */
+ nullptr, /* child_removed */
+ nullptr, /* attr_changed */
+ text_content_changed,
+ nullptr /* order_changed */,
+ nullptr /* element_name_changed */
+};
+
+static const Inkscape::XML::NodeEventVector comment_repr_events = {
+ nullptr, /* child_added */
+ nullptr, /* child_removed */
+ nullptr, /* attr_changed */
+ comment_content_changed,
+ nullptr /* order_changed */,
+ nullptr /* element_name_changed */
+};
+
+static const Inkscape::XML::NodeEventVector pi_repr_events = {
+ nullptr, /* child_added */
+ nullptr, /* child_removed */
+ nullptr, /* attr_changed */
+ pi_content_changed,
+ nullptr /* order_changed */,
+ nullptr /* element_name_changed */
+};
+
+/**
+ * Get an iterator to the first child of `data`
+ * @param data handle which references a row
+ * @param[out] child_iter On success: valid iterator to first child
+ * @return False if the node has no children
+ */
+static bool get_first_child(NodeData *data, GtkTreeIter *child_iter)
+{
+ GtkTreeIter iter;
+ return tree_ref_to_iter(data->tree, &iter, data->rowref) &&
+ gtk_tree_model_iter_children(GTK_TREE_MODEL(data->tree->store), child_iter, &iter);
+}
+
+/**
+ * @param iter First dummy row on that level
+ * @pre all rows on the same level are dummies
+ * @pre iter is valid
+ * @post iter is invalid
+ * @post level is empty
+ */
+static void remove_dummy_rows(GtkTreeStore *store, GtkTreeIter *iter)
+{
+ do {
+ g_assert(nullptr == sp_xmlview_tree_node_get_data(GTK_TREE_MODEL(store), iter));
+ gtk_tree_store_remove(store, iter);
+ } while (gtk_tree_store_iter_is_valid(store, iter));
+}
+
+static gboolean on_test_expand_row( //
+ GtkTreeView *tree_view, //
+ GtkTreeIter *iter, //
+ GtkTreePath *path, //
+ gpointer)
+{
+ auto tree = SP_XMLVIEW_TREE(tree_view);
+ auto model = GTK_TREE_MODEL(tree->store);
+
+ GtkTreeIter childiter;
+ bool has_children = gtk_tree_model_iter_children(model, &childiter, iter);
+ g_assert(has_children);
+
+ if (sp_xmlview_tree_node_get_repr(model, &childiter) == nullptr) {
+ NodeData *data = sp_xmlview_tree_node_get_data(model, iter);
+
+ remove_dummy_rows(tree->store, &childiter);
+
+ // insert real rows
+ data->expanded = true;
+ sp_repr_synthesize_events(data->repr, &element_repr_events, data);
+ }
+
+ return false;
+}
+
+GtkWidget *sp_xmlview_tree_new(Inkscape::XML::Node * repr, void * /*factory*/, void * /*data*/)
+{
+ SPXMLViewTree *tree = SP_XMLVIEW_TREE(g_object_new (SP_TYPE_XMLVIEW_TREE, nullptr));
+
+ gtk_tree_view_set_headers_visible (GTK_TREE_VIEW(tree), FALSE);
+ gtk_tree_view_set_reorderable (GTK_TREE_VIEW(tree), TRUE);
+ gtk_tree_view_set_enable_search (GTK_TREE_VIEW(tree), TRUE);
+ gtk_tree_view_set_search_equal_func (GTK_TREE_VIEW(tree), search_equal_func, nullptr, nullptr);
+
+ GtkCellRenderer *renderer = gtk_cell_renderer_text_new ();
+ GtkTreeViewColumn *column = gtk_tree_view_column_new_with_attributes ("", renderer, "text", STORE_TEXT_COL, NULL);
+ gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
+ gtk_cell_renderer_set_padding (renderer, 2, 0);
+ gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
+
+ sp_xmlview_tree_set_repr (tree, repr);
+
+ g_signal_connect(GTK_TREE_VIEW(tree), "drag-begin", G_CALLBACK(on_drag_begin), tree);
+ g_signal_connect(GTK_TREE_VIEW(tree), "drag-end", G_CALLBACK(on_drag_end), tree);
+ g_signal_connect(GTK_TREE_VIEW(tree), "drag-motion", G_CALLBACK(do_drag_motion), tree);
+ g_signal_connect(GTK_TREE_VIEW(tree), "test-expand-row", G_CALLBACK(on_test_expand_row), nullptr);
+
+ return GTK_WIDGET(tree);
+}
+
+G_DEFINE_TYPE(SPXMLViewTree, sp_xmlview_tree, GTK_TYPE_TREE_VIEW);
+
+void sp_xmlview_tree_class_init(SPXMLViewTreeClass * klass)
+{
+ auto widget_class = GTK_WIDGET_CLASS(klass);
+ widget_class->destroy = sp_xmlview_tree_destroy;
+
+ // Signal for when a tree drag and drop has completed
+ g_signal_new ( "tree_move",
+ G_TYPE_FROM_CLASS(klass),
+ G_SIGNAL_RUN_FIRST,
+ 0,
+ nullptr, nullptr,
+ g_cclosure_marshal_VOID__UINT,
+ G_TYPE_NONE, 1,
+ G_TYPE_UINT);
+}
+
+void
+sp_xmlview_tree_init (SPXMLViewTree * tree)
+{
+ tree->repr = nullptr;
+ tree->blocked = 0;
+}
+
+void sp_xmlview_tree_destroy(GtkWidget * object)
+{
+ SPXMLViewTree * tree = SP_XMLVIEW_TREE (object);
+
+ sp_xmlview_tree_set_repr (tree, nullptr);
+
+ GTK_WIDGET_CLASS(sp_xmlview_tree_parent_class)->destroy (object);
+}
+
+/*
+ * Add a new row to the tree
+ */
+void
+add_node (SPXMLViewTree * tree, GtkTreeIter *parent, GtkTreeIter *before, Inkscape::XML::Node * repr)
+{
+ const Inkscape::XML::NodeEventVector * vec;
+
+ g_assert (tree != nullptr);
+
+ if (before && !gtk_tree_store_iter_is_valid(tree->store, before)) {
+ before = nullptr;
+ }
+
+ GtkTreeIter iter;
+ gtk_tree_store_insert_before (tree->store, &iter, parent, before);
+
+ if (!gtk_tree_store_iter_is_valid(tree->store, &iter)) {
+ return;
+ }
+
+ if (!repr) {
+ // no need to store any data
+ return;
+ }
+
+ auto data = new NodeData(tree, &iter, repr);
+
+ g_assert (data != nullptr);
+
+ gtk_tree_store_set(tree->store, &iter, STORE_DATA_COL, data, -1);
+
+ if ( repr->type() == Inkscape::XML::TEXT_NODE ) {
+ vec = &text_repr_events;
+ } else if ( repr->type() == Inkscape::XML::COMMENT_NODE ) {
+ vec = &comment_repr_events;
+ } else if ( repr->type() == Inkscape::XML::PI_NODE ) {
+ vec = &pi_repr_events;
+ } else if ( repr->type() == Inkscape::XML::ELEMENT_NODE ) {
+ vec = &element_repr_events;
+ } else {
+ vec = nullptr;
+ }
+
+ if (vec) {
+ /* cheat a little to get the text updated on nodes without id */
+ if (repr->type() == Inkscape::XML::ELEMENT_NODE && repr->attribute("id") == nullptr) {
+ element_attr_changed (repr, "id", nullptr, nullptr, false, data);
+ }
+ sp_repr_add_listener (repr, vec, data);
+ sp_repr_synthesize_events (repr, vec, data);
+ }
+}
+
+static gboolean remove_all_listeners(GtkTreeModel *model, GtkTreePath *, GtkTreeIter *iter, gpointer)
+{
+ NodeData *data = sp_xmlview_tree_node_get_data(model, iter);
+ delete data;
+ return false;
+}
+
+NodeData::NodeData(SPXMLViewTree *tree, GtkTreeIter *iter, Inkscape::XML::Node *repr)
+ : tree(tree)
+ , rowref(tree_iter_to_ref(tree, iter))
+ , repr(repr)
+{
+ if (repr) {
+ Inkscape::GC::anchor(repr);
+ }
+}
+
+NodeData::~NodeData()
+{
+ if (repr) {
+ sp_repr_remove_listener_by_data(repr, this);
+ Inkscape::GC::release(repr);
+ }
+ gtk_tree_row_reference_free(rowref);
+}
+
+void element_child_added (Inkscape::XML::Node * /*repr*/, Inkscape::XML::Node * child, Inkscape::XML::Node * ref, gpointer ptr)
+{
+ NodeData *data = static_cast<NodeData *>(ptr);
+ GtkTreeIter before;
+
+ if (data->tree->blocked) return;
+
+ if (!ref_to_sibling (data, ref, &before)) {
+ return;
+ }
+
+ GtkTreeIter data_iter;
+ tree_ref_to_iter(data->tree, &data_iter, data->rowref);
+
+ if (!data->expanded) {
+ auto model = GTK_TREE_MODEL(data->tree->store);
+ GtkTreeIter childiter;
+ if (!gtk_tree_model_iter_children(model, &childiter, &data_iter)) {
+ // no children yet, add a dummy
+ child = nullptr;
+ } else if (sp_xmlview_tree_node_get_repr(model, &childiter) == nullptr) {
+ // already has a dummy child
+ return;
+ }
+ }
+
+ add_node (data->tree, &data_iter, &before, child);
+}
+
+void element_attr_changed(
+ Inkscape::XML::Node* repr, gchar const* key,
+ gchar const* /*old_value*/, gchar const* /*new_value*/, bool /*is_interactive*/,
+ gpointer ptr)
+{
+ if (0 != strcmp (key, "id") && 0 != strcmp (key, "inkscape:label"))
+ return;
+ element_attr_or_name_change_update(repr, static_cast<NodeData*>(ptr));
+}
+
+void element_name_changed(
+ Inkscape::XML::Node* repr,
+ gchar const* /*oldname*/, gchar const* /*newname*/, gpointer ptr)
+{
+ element_attr_or_name_change_update(repr, static_cast<NodeData*>(ptr));
+}
+
+void element_attr_or_name_change_update(Inkscape::XML::Node* repr, NodeData* data)
+{
+ if (data->tree->blocked) {
+ return;
+ }
+
+ gchar const* node_name = repr->name();
+ gchar const* id_value = repr->attribute("id");
+ gchar const* label_value = repr->attribute("inkscape:label");
+ gchar* display_text;
+
+ if (id_value && label_value) {
+ display_text = g_strdup_printf ("<%s id=\"%s\" inkscape:label=\"%s\">", node_name, id_value, label_value);
+ } else if (id_value) {
+ display_text = g_strdup_printf ("<%s id=\"%s\">", node_name, id_value);
+ } else if (label_value) {
+ display_text = g_strdup_printf ("<%s inkscape:label=\"%s\">", node_name, label_value);
+ } else {
+ display_text = g_strdup_printf ("<%s>", node_name);
+ }
+
+ GtkTreeIter iter;
+ if (tree_ref_to_iter(data->tree, &iter, data->rowref)) {
+ gtk_tree_store_set (GTK_TREE_STORE(data->tree->store), &iter, STORE_TEXT_COL, display_text, -1);
+ }
+
+ g_free(display_text);
+}
+
+void element_child_removed(Inkscape::XML::Node *repr, Inkscape::XML::Node *child, Inkscape::XML::Node * /*ref*/,
+ gpointer ptr)
+{
+ NodeData *data = static_cast<NodeData *>(ptr);
+
+ if (data->tree->blocked) return;
+
+ GtkTreeIter iter;
+ if (repr_to_child(data, child, &iter)) {
+ delete sp_xmlview_tree_node_get_data(GTK_TREE_MODEL(data->tree->store), &iter);
+ gtk_tree_store_remove(data->tree->store, &iter);
+ } else if (!repr->firstChild() && get_first_child(data, &iter)) {
+ // remove dummy when all children gone
+ remove_dummy_rows(data->tree->store, &iter);
+ } else {
+ return;
+ }
+
+#ifndef GTK_ISSUE_2510_IS_FIXED
+ // https://gitlab.gnome.org/GNOME/gtk/issues/2510
+ gtk_tree_selection_unselect_all(gtk_tree_view_get_selection(GTK_TREE_VIEW(data->tree)));
+#endif
+}
+
+void element_order_changed(Inkscape::XML::Node * /*repr*/, Inkscape::XML::Node * child, Inkscape::XML::Node * /*oldref*/, Inkscape::XML::Node * newref, gpointer ptr)
+{
+ NodeData *data = static_cast<NodeData *>(ptr);
+ GtkTreeIter before, node;
+
+ if (data->tree->blocked) return;
+
+ ref_to_sibling (data, newref, &before);
+ repr_to_child (data, child, &node);
+
+ if (gtk_tree_store_iter_is_valid(data->tree->store, &before)) {
+ gtk_tree_store_move_before (data->tree->store, &node, &before);
+ } else {
+ repr_to_child (data, newref, &before);
+ gtk_tree_store_move_after (data->tree->store, &node, &before);
+ }
+}
+
+Glib::ustring sp_remove_newlines_and_tabs(Glib::ustring val)
+{
+ int pos;
+ Glib::ustring newlinesign = "␤";
+ Glib::ustring tabsign = "⇥";
+ while ((pos = val.find("\r\n")) != std::string::npos) {
+ val.erase(pos, 2);
+ val.insert(pos, newlinesign);
+ }
+ while ((pos = val.find('\n')) != std::string::npos) {
+ val.erase(pos, 1);
+ val.insert(pos, newlinesign);
+ }
+ while ((pos = val.find('\t')) != std::string::npos) {
+ val.erase(pos, 1);
+ val.insert(pos, tabsign);
+ }
+ return val;
+}
+
+void text_content_changed(Inkscape::XML::Node * /*repr*/, const gchar * /*old_content*/, const gchar * new_content, gpointer ptr)
+{
+ NodeData *data = static_cast<NodeData *>(ptr);
+
+ if (data->tree->blocked) return;
+
+ gchar *label = g_strdup_printf ("\"%s\"", new_content);
+ Glib::ustring nolinecontent = label;
+ nolinecontent = sp_remove_newlines_and_tabs(nolinecontent);
+
+ GtkTreeIter iter;
+ if (tree_ref_to_iter(data->tree, &iter, data->rowref)) {
+ gtk_tree_store_set(GTK_TREE_STORE(data->tree->store), &iter, STORE_TEXT_COL, nolinecontent.c_str(), -1);
+ }
+
+ g_free (label);
+}
+
+void comment_content_changed(Inkscape::XML::Node * /*repr*/, const gchar * /*old_content*/, const gchar *new_content, gpointer ptr)
+{
+ NodeData *data = static_cast<NodeData*>(ptr);
+
+ if (data->tree->blocked) return;
+
+ gchar *label = g_strdup_printf ("<!--%s-->", new_content);
+ Glib::ustring nolinecontent = label;
+ nolinecontent = sp_remove_newlines_and_tabs(nolinecontent);
+
+ GtkTreeIter iter;
+ if (tree_ref_to_iter(data->tree, &iter, data->rowref)) {
+ gtk_tree_store_set(GTK_TREE_STORE(data->tree->store), &iter, STORE_TEXT_COL, nolinecontent.c_str(), -1);
+ }
+ g_free (label);
+}
+
+void pi_content_changed(Inkscape::XML::Node *repr, const gchar * /*old_content*/, const gchar *new_content, gpointer ptr)
+{
+ NodeData *data = static_cast<NodeData *>(ptr);
+
+ if (data->tree->blocked) return;
+
+ gchar *label = g_strdup_printf ("<?%s %s?>", repr->name(), new_content);
+ Glib::ustring nolinecontent = label;
+ nolinecontent = sp_remove_newlines_and_tabs(nolinecontent);
+
+ GtkTreeIter iter;
+ if (tree_ref_to_iter(data->tree, &iter, data->rowref)) {
+ gtk_tree_store_set(GTK_TREE_STORE(data->tree->store), &iter, STORE_TEXT_COL, nolinecontent.c_str(), -1);
+ }
+ g_free (label);
+}
+
+/*
+ * Save the source path on drag start, will need it in on_row_changed() when moving a row
+ */
+void on_drag_begin(GtkWidget *, GdkDragContext *, gpointer userdata)
+{
+ SPXMLViewTree *tree = static_cast<SPXMLViewTree *>(userdata);
+ if (!tree) {
+ return;
+ }
+
+ GtkTreeModel *model = nullptr;
+ GtkTreeIter iter;
+ GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree));
+ if (gtk_tree_selection_get_selected(selection, &model, &iter)) {
+ NodeData *data = sp_xmlview_tree_node_get_data(model, &iter);
+ if (data) {
+ data->dragging = true;
+ dragging_repr = data->repr;
+ }
+ }
+}
+
+/**
+ * Finalize what happended in `on_row_changed` and clean up what was set up in `on_drag_begin`
+ */
+void on_drag_end(GtkWidget *, GdkDragContext *, gpointer userdata)
+{
+ if (!dragging_repr)
+ return;
+
+ auto tree = static_cast<SPXMLViewTree *>(userdata);
+ auto selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree));
+ bool failed = false;
+
+ GtkTreeIter iter;
+ if (sp_xmlview_tree_get_repr_node(tree, dragging_repr, &iter)) {
+ NodeData *data = sp_xmlview_tree_node_get_data(GTK_TREE_MODEL(tree->store), &iter);
+
+ if (data && data->dragging) {
+ // dragging flag was not cleared in `on_row_changed`, this indicates a failed drag
+ data->dragging = false;
+ failed = true;
+ } else {
+ // Reselect the dragged row
+ gtk_tree_selection_select_iter(selection, &iter);
+ }
+ } else {
+#ifndef GTK_ISSUE_2510_IS_FIXED
+ // https://gitlab.gnome.org/GNOME/gtk/issues/2510
+ gtk_tree_selection_unselect_all(selection);
+#endif
+ }
+
+ dragging_repr = nullptr;
+
+ if (!failed) {
+ // Signal that a drag and drop has completed successfully
+ g_signal_emit_by_name(G_OBJECT(tree), "tree_move", GUINT_TO_POINTER(1));
+ }
+}
+
+/*
+ * Main drag & drop function
+ * Get the old and new paths, and change the Inkscape::XML::Node repr's
+ */
+void on_row_changed(GtkTreeModel *tree_model, GtkTreePath *path, GtkTreeIter *iter, gpointer user_data)
+{
+ NodeData *data = sp_xmlview_tree_node_get_data(tree_model, iter);
+
+ if (!data || !data->dragging) {
+ return;
+ }
+ data->dragging = false;
+
+ SPXMLViewTree *tree = SP_XMLVIEW_TREE(user_data);
+
+ gtk_tree_row_reference_free(data->rowref);
+ data->rowref = tree_iter_to_ref(tree, iter);
+
+ GtkTreeIter new_parent;
+ if (!gtk_tree_model_iter_parent(tree_model, &new_parent, iter)) {
+ //No parent of drop location
+ return;
+ }
+
+ Inkscape::XML::Node *repr = sp_xmlview_tree_node_get_repr(tree_model, iter);
+ Inkscape::XML::Node *before_repr = nullptr;
+
+ // Find the sibling node before iter
+ GtkTreeIter before_iter = *iter;
+ if (gtk_tree_model_iter_previous(tree_model, &before_iter)) {
+ before_repr = sp_xmlview_tree_node_get_repr(tree_model, &before_iter);
+ }
+
+ // Drop onto oneself causes assert in changeOrder() below, ignore
+ if (repr == before_repr)
+ return;
+
+ auto repr_old_parent = repr->parent();
+ auto repr_new_parent = sp_xmlview_tree_node_get_repr(tree_model, &new_parent);
+
+ tree->blocked++;
+
+ if (repr_old_parent == repr_new_parent) {
+ repr_old_parent->changeOrder(repr, before_repr);
+ } else {
+ repr_old_parent->removeChild(repr);
+ repr_new_parent->addChild(repr, before_repr);
+ }
+
+ NodeData *data_new_parent = sp_xmlview_tree_node_get_data(tree_model, &new_parent);
+ if (data_new_parent && data_new_parent->expanded) {
+ // Reselect the dragged row in `on_drag_end` instead of here, because of
+ // https://gitlab.gnome.org/GNOME/gtk/-/issues/2510
+ } else {
+ // convert to dummy node
+ delete data;
+ gtk_tree_store_set(tree->store, iter, STORE_DATA_COL, nullptr, -1);
+ }
+
+ tree->blocked--;
+}
+
+/*
+ * Set iter to ref or node data's child with the same repr or first child
+ */
+gboolean ref_to_sibling (NodeData *data, Inkscape::XML::Node *repr, GtkTreeIter *iter)
+{
+ if (repr) {
+ if (!repr_to_child (data, repr, iter)) {
+ return false;
+ }
+ gtk_tree_model_iter_next (GTK_TREE_MODEL(data->tree->store), iter);
+ } else {
+ GtkTreeIter data_iter;
+ if (!tree_ref_to_iter(data->tree, &data_iter, data->rowref)) {
+ return false;
+ }
+ gtk_tree_model_iter_children(GTK_TREE_MODEL(data->tree->store), iter, &data_iter);
+ }
+ return true;
+}
+
+/*
+ * Set iter to the node data's child with the same repr
+ */
+gboolean repr_to_child (NodeData *data, Inkscape::XML::Node * repr, GtkTreeIter *iter)
+{
+ GtkTreeIter data_iter;
+ GtkTreeModel *model = GTK_TREE_MODEL(data->tree->store);
+ gboolean valid = false;
+
+ if (!tree_ref_to_iter(data->tree, &data_iter, data->rowref)) {
+ return false;
+ }
+
+ /*
+ * The node we are looking for is likely to be the last one, so check it first.
+ */
+ gint n_children = gtk_tree_model_iter_n_children (model, &data_iter);
+ if (n_children > 1) {
+ valid = gtk_tree_model_iter_nth_child (model, iter, &data_iter, n_children-1);
+ if (valid && sp_xmlview_tree_node_get_repr (model, iter) == repr) {
+ //g_message("repr_to_child hit %d", n_children);
+ return valid;
+ }
+ }
+
+ valid = gtk_tree_model_iter_children(model, iter, &data_iter);
+ while (valid && sp_xmlview_tree_node_get_repr (model, iter) != repr) {
+ valid = gtk_tree_model_iter_next(model, iter);
+ }
+
+ return valid;
+}
+
+/*
+ * Get a matching GtkTreeRowReference for a GtkTreeIter
+ */
+GtkTreeRowReference *tree_iter_to_ref (SPXMLViewTree * tree, GtkTreeIter* iter)
+{
+ GtkTreePath* path = gtk_tree_model_get_path(GTK_TREE_MODEL(tree->store), iter);
+ GtkTreeRowReference *ref = gtk_tree_row_reference_new(GTK_TREE_MODEL(tree->store), path);
+ gtk_tree_path_free(path);
+
+ return ref;
+}
+
+/*
+ * Get a matching GtkTreeIter for a GtkTreeRowReference
+ */
+gboolean tree_ref_to_iter (SPXMLViewTree * tree, GtkTreeIter* iter, GtkTreeRowReference *ref)
+{
+ GtkTreePath* path = gtk_tree_row_reference_get_path(ref);
+ if (!path) {
+ return false;
+ }
+ gboolean const valid = //
+ gtk_tree_model_get_iter(GTK_TREE_MODEL(tree->store), iter, path);
+ gtk_tree_path_free(path);
+
+ return valid;
+}
+
+/*
+ * Disable drag and drop target on : root node and non-element nodes
+ */
+gboolean do_drag_motion(GtkWidget *widget, GdkDragContext *context, gint x, gint y, guint time, gpointer user_data)
+{
+ GtkTreePath *path = nullptr;
+ GtkTreeViewDropPosition pos;
+ gtk_tree_view_get_dest_row_at_pos (GTK_TREE_VIEW(widget), x, y, &path, &pos);
+
+ int action = 0;
+
+ if (!dragging_repr) {
+ goto finally;
+ }
+
+ if (path) {
+ SPXMLViewTree *tree = SP_XMLVIEW_TREE(user_data);
+ GtkTreeIter iter;
+ gtk_tree_model_get_iter(GTK_TREE_MODEL(tree->store), &iter, path);
+ auto repr = sp_xmlview_tree_node_get_repr(GTK_TREE_MODEL(tree->store), &iter);
+
+ bool const drop_into = pos != GTK_TREE_VIEW_DROP_BEFORE && //
+ pos != GTK_TREE_VIEW_DROP_AFTER;
+
+ // 0. don't drop on self (also handled by on_row_changed but nice to not have drop highlight for it)
+ if (repr == dragging_repr) {
+ goto finally;
+ }
+
+ // 1. only xml elements can have children
+ if (drop_into && repr->type() != Inkscape::XML::ELEMENT_NODE) {
+ goto finally;
+ }
+
+ // 3. elements must be at least children of the root <svg:svg> element
+ if (gtk_tree_path_get_depth(path) < 2) {
+ goto finally;
+ }
+
+ // 4. drag node specific limitations
+ {
+ // nodes which can't be re-parented (because the document holds pointers to them which must stay valid)
+ static GQuark const CODE_sodipodi_namedview = g_quark_from_static_string("sodipodi:namedview");
+ static GQuark const CODE_svg_defs = g_quark_from_static_string("svg:defs");
+
+ bool const no_reparenting = dragging_repr->code() == CODE_sodipodi_namedview || //
+ dragging_repr->code() == CODE_svg_defs;
+
+ if (no_reparenting && (drop_into || dragging_repr->parent() != repr->parent())) {
+ goto finally;
+ }
+ }
+
+ action = GDK_ACTION_MOVE;
+ }
+
+finally:
+ if (action == 0) {
+ // remove drop highlight
+ gtk_tree_view_set_drag_dest_row(GTK_TREE_VIEW(widget), nullptr, pos /* ignored */);
+ }
+
+ gtk_tree_path_free(path);
+ gdk_drag_status (context, (GdkDragAction)action, time);
+
+ return (action == 0);
+}
+
+/*
+ * Set the tree selection and scroll to the row with the given repr
+ */
+void
+sp_xmlview_tree_set_repr (SPXMLViewTree * tree, Inkscape::XML::Node * repr)
+{
+ if ( tree->repr == repr ) return;
+
+ if (tree->store) {
+ gtk_tree_view_set_model(GTK_TREE_VIEW(tree), nullptr);
+ gtk_tree_model_foreach(GTK_TREE_MODEL(tree->store), remove_all_listeners, nullptr);
+ g_object_unref(tree->store);
+ tree->store = nullptr;
+ }
+
+ if (tree->repr) {
+ Inkscape::GC::release(tree->repr);
+ }
+ tree->repr = repr;
+ if (repr) {
+ tree->store = gtk_tree_store_new(STORE_N_COLS, G_TYPE_STRING, G_TYPE_POINTER);
+
+ Inkscape::GC::anchor(repr);
+ add_node(tree, nullptr, nullptr, repr);
+
+ // Set the tree model here, after all data is inserted
+ gtk_tree_view_set_model (GTK_TREE_VIEW(tree), GTK_TREE_MODEL(tree->store));
+ g_signal_connect(G_OBJECT(tree->store), "row-changed", G_CALLBACK(on_row_changed), tree);
+
+ GtkTreePath *path = gtk_tree_path_new_from_indices(0, -1);
+ gtk_tree_view_expand_to_path (GTK_TREE_VIEW(tree), path);
+ gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW(tree), path, nullptr, true, 0.5, 0.0);
+ gtk_tree_path_free(path);
+ }
+}
+
+/*
+ * Return the node data at a given GtkTreeIter position
+ */
+NodeData *sp_xmlview_tree_node_get_data(GtkTreeModel *model, GtkTreeIter *iter)
+{
+ NodeData *data = nullptr;
+ gtk_tree_model_get(model, iter, STORE_DATA_COL, &data, -1);
+ return data;
+}
+
+/*
+ * Return the repr at a given GtkTreeIter position
+ */
+Inkscape::XML::Node *
+sp_xmlview_tree_node_get_repr (GtkTreeModel *model, GtkTreeIter * iter)
+{
+ NodeData *data = sp_xmlview_tree_node_get_data(model, iter);
+ return data ? data->repr : nullptr;
+}
+
+struct IterByReprData {
+ const Inkscape::XML::Node *repr; //< in
+ GtkTreeIter *iter; //< out
+};
+
+/*
+ * Find a GtkTreeIter position in the tree by repr
+ * @return True if the node was found
+ */
+gboolean
+sp_xmlview_tree_get_repr_node (SPXMLViewTree * tree, Inkscape::XML::Node * repr, GtkTreeIter *iter)
+{
+ iter->stamp = 0; // invalidate iterator
+ IterByReprData funcdata = { repr, iter };
+ gtk_tree_model_foreach(GTK_TREE_MODEL(tree->store), foreach_func, &funcdata);
+ return iter->stamp != 0;
+}
+
+gboolean foreach_func(GtkTreeModel *model, GtkTreePath * /*path*/, GtkTreeIter *iter, gpointer user_data)
+{
+ auto funcdata = static_cast<IterByReprData *>(user_data);
+ if (sp_xmlview_tree_node_get_repr(model, iter) == funcdata->repr) {
+ *funcdata->iter = *iter;
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+/*
+ * Callback function for string searches in the tree
+ * Return a match on any substring
+ */
+gboolean search_equal_func(GtkTreeModel *model, gint /*column*/, const gchar *key, GtkTreeIter *iter, gpointer /*search_data*/)
+{
+ gchar *text = nullptr;
+ gtk_tree_model_get(model, iter, STORE_TEXT_COL, &text, -1);
+
+ gboolean match = (strstr(text, key) != nullptr);
+
+ g_free(text);
+
+ return !match;
+}
+
+/*
+ Local Variables:
+ mode:c++
+ c-file-style:"stroustrup"
+ c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
+ indent-tabs-mode:nil
+ fill-column:99
+ End:
+*/
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=4:softtabstop=4:fileencoding=utf-8 :
diff --git a/src/widgets/sp-xmlview-tree.h b/src/widgets/sp-xmlview-tree.h
new file mode 100644
index 0000000..8839ee9
--- /dev/null
+++ b/src/widgets/sp-xmlview-tree.h
@@ -0,0 +1,64 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/**
+ * Authors:
+ * MenTaLguY <mental@rydia.net>
+ *
+ * Copyright (C) 2002 MenTaLguY
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#ifndef SEEN_SP_XMLVIEW_TREE_H
+#define SEEN_SP_XMLVIEW_TREE_H
+
+#include <gtk/gtk.h>
+#include <glib.h>
+
+/**
+ * Specialization of GtkTreeView for the XML editor
+ */
+
+#define SP_TYPE_XMLVIEW_TREE (sp_xmlview_tree_get_type ())
+#define SP_XMLVIEW_TREE(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), SP_TYPE_XMLVIEW_TREE, SPXMLViewTree))
+#define SP_IS_XMLVIEW_TREE(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), SP_TYPE_XMLVIEW_TREE))
+#define SP_XMLVIEW_TREE_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), SP_TYPE_XMLVIEW_TREE))
+
+struct SPXMLViewTree;
+struct SPXMLViewTreeClass;
+
+struct SPXMLViewTree
+{
+ GtkTreeView tree;
+ GtkTreeStore *store;
+ Inkscape::XML::Node * repr;
+ gint blocked;
+};
+
+struct SPXMLViewTreeClass
+{
+ GtkTreeViewClass parent_class;
+};
+
+GType sp_xmlview_tree_get_type ();
+GtkWidget * sp_xmlview_tree_new (Inkscape::XML::Node * repr, void * factory, void * data);
+
+#define SP_XMLVIEW_TREE_REPR(tree) (SP_XMLVIEW_TREE (tree)->repr)
+
+void sp_xmlview_tree_set_repr (SPXMLViewTree * tree, Inkscape::XML::Node * repr);
+
+Inkscape::XML::Node * sp_xmlview_tree_node_get_repr (GtkTreeModel *model, GtkTreeIter * node);
+gboolean sp_xmlview_tree_get_repr_node (SPXMLViewTree * tree, Inkscape::XML::Node * repr, GtkTreeIter *node);
+
+
+#endif // !SEEN_SP_XMLVIEW_TREE_H
+
+/*
+ Local Variables:
+ mode:c++
+ c-file-style:"stroustrup"
+ c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
+ indent-tabs-mode:nil
+ fill-column:99
+ End:
+*/
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8 :
diff --git a/src/widgets/spinbutton-events.cpp b/src/widgets/spinbutton-events.cpp
new file mode 100644
index 0000000..9800cf5
--- /dev/null
+++ b/src/widgets/spinbutton-events.cpp
@@ -0,0 +1,163 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * Common callbacks for spinbuttons
+ *
+ * Authors:
+ * bulia byak <bulia@users.sourceforge.net>
+ * Jon A. Cruz <jon@joncruz.org>
+ *
+ * Copyright (C) 2013 authors
+ * Copyright (C) 2003 authors
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#include <gtk/gtk.h>
+#include <gdk/gdkkeysyms.h>
+
+#include "ui/tools/tool-base.h"
+
+#include "spinbutton-events.h"
+
+gboolean spinbutton_focus_in(GtkWidget *w, GdkEventKey * /*event*/, gpointer /*data*/)
+{
+ gdouble *ini = static_cast<gdouble *>(g_object_get_data(G_OBJECT(w), "ini"));
+ if (ini) {
+ g_free(ini); // free the old value if any
+ }
+
+ // retrieve the value
+ ini = g_new(gdouble, 1);
+ *ini = gtk_spin_button_get_value(GTK_SPIN_BUTTON(w));
+
+ // remember it
+ g_object_set_data(G_OBJECT(w), "ini", ini);
+
+ return FALSE; // I didn't consume the event
+}
+
+void spinbutton_undo(GtkWidget *w)
+{
+ gdouble *ini = static_cast<gdouble *>(g_object_get_data(G_OBJECT(w), "ini"));
+ if (ini) {
+ gtk_spin_button_set_value(GTK_SPIN_BUTTON(w), *ini);
+ }
+}
+
+void spinbutton_defocus(GtkWidget *container)
+{
+ // defocus spinbuttons by moving focus to the canvas, unless "stay" is on
+ gboolean stay = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(container), "stay"));
+ if (stay) {
+ g_object_set_data(G_OBJECT(container), "stay", GINT_TO_POINTER(FALSE));
+ } else {
+ GtkWidget *canvas = GTK_WIDGET(g_object_get_data(G_OBJECT(container), "dtw"));
+ if (canvas) {
+ gtk_widget_grab_focus(GTK_WIDGET(canvas));
+ }
+ }
+}
+
+gboolean spinbutton_keypress(GtkWidget *w, GdkEventKey *event, gpointer /*data*/)
+{
+ gboolean result = FALSE; // I didn't consume the event
+
+ switch (Inkscape::UI::Tools::get_latin_keyval(event)) {
+ case GDK_KEY_Escape: // defocus
+ spinbutton_undo(w);
+ spinbutton_defocus(w);
+ result = TRUE; // I consumed the event
+ break;
+ case GDK_KEY_Return: // defocus
+ case GDK_KEY_KP_Enter:
+ spinbutton_defocus(w);
+ result = TRUE; // I consumed the event
+ break;
+ case GDK_KEY_Tab:
+ case GDK_KEY_ISO_Left_Tab:
+ // set the flag meaning "do not leave toolbar when changing value"
+ g_object_set_data(G_OBJECT(w), "stay", GINT_TO_POINTER(TRUE));
+ result = FALSE; // I didn't consume the event
+ break;
+
+ // The following keys are processed manually because GTK implements them in strange ways
+ // (increments start with double step value and seem to grow as you press the key continuously)
+
+ case GDK_KEY_Up:
+ case GDK_KEY_KP_Up:
+ {
+ g_object_set_data(G_OBJECT(w), "stay", GINT_TO_POINTER(TRUE));
+ gdouble v = gtk_spin_button_get_value(GTK_SPIN_BUTTON(w));
+ gdouble step = 0;
+ gdouble page = 0;
+ gtk_spin_button_get_increments(GTK_SPIN_BUTTON(w), &step, &page);
+ v += step;
+ gtk_spin_button_set_value(GTK_SPIN_BUTTON(w), v);
+ result = TRUE; // I consumed the event
+ break;
+ }
+ case GDK_KEY_Down:
+ case GDK_KEY_KP_Down:
+ {
+ g_object_set_data(G_OBJECT(w), "stay", GINT_TO_POINTER(TRUE));
+ gdouble v = gtk_spin_button_get_value(GTK_SPIN_BUTTON(w));
+ gdouble step = 0;
+ gdouble page = 0;
+ gtk_spin_button_get_increments(GTK_SPIN_BUTTON(w), &step, &page);
+ v -= step;
+ gtk_spin_button_set_value(GTK_SPIN_BUTTON(w), v);
+ result = TRUE; // I consumed the event
+ break;
+ }
+ case GDK_KEY_Page_Up:
+ case GDK_KEY_KP_Page_Up:
+ {
+ g_object_set_data(G_OBJECT(w), "stay", GINT_TO_POINTER(TRUE));
+ gdouble v = gtk_spin_button_get_value(GTK_SPIN_BUTTON(w));
+ gdouble step = 0;
+ gdouble page = 0;
+ gtk_spin_button_get_increments(GTK_SPIN_BUTTON(w), &step, &page);
+ v += page;
+ gtk_spin_button_set_value(GTK_SPIN_BUTTON(w), v);
+ result = TRUE; // I consumed the event
+ break;
+ }
+ case GDK_KEY_Page_Down:
+ case GDK_KEY_KP_Page_Down:
+ {
+ g_object_set_data(G_OBJECT(w), "stay", GINT_TO_POINTER(TRUE));
+ gdouble v = gtk_spin_button_get_value(GTK_SPIN_BUTTON(w));
+ gdouble step = 0;
+ gdouble page = 0;
+ gtk_spin_button_get_increments(GTK_SPIN_BUTTON(w), &step, &page);
+ v -= page;
+ gtk_spin_button_set_value(GTK_SPIN_BUTTON(w), v);
+ result = TRUE; // I consumed the event
+ break;
+ }
+ case GDK_KEY_z:
+ case GDK_KEY_Z:
+ g_object_set_data(G_OBJECT(w), "stay", GINT_TO_POINTER(TRUE));
+ if (event->state & GDK_CONTROL_MASK) {
+ spinbutton_undo(w);
+ result = TRUE; // I consumed the event
+ }
+ break;
+ default:
+ result = FALSE;
+ break;
+ }
+
+ return result;
+}
+
+/*
+ Local Variables:
+ mode:c++
+ c-file-style:"stroustrup"
+ c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
+ indent-tabs-mode:nil
+ fill-column:99
+ End:
+*/
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :
diff --git a/src/widgets/spinbutton-events.h b/src/widgets/spinbutton-events.h
new file mode 100644
index 0000000..e32ef18
--- /dev/null
+++ b/src/widgets/spinbutton-events.h
@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * Common callbacks for spinbuttons
+ *
+ * Authors:
+ * bulia byak <bulia@users.sourceforge.net>
+ *
+ * Copyright (C) 2003 authors
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#include <glib.h>
+
+typedef struct _GdkEventKey GdkEventKey;
+typedef struct _GtkWidget GtkWidget;
+
+gboolean spinbutton_focus_in (GtkWidget *w, GdkEventKey *event, gpointer data);
+void spinbutton_undo (GtkWidget *w);
+gboolean spinbutton_keypress (GtkWidget *w, GdkEventKey *event, gpointer data);
+void spinbutton_defocus (GtkWidget *container);
+
+/*
+ Local Variables:
+ mode:c++
+ c-file-style:"stroustrup"
+ c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
+ indent-tabs-mode:nil
+ fill-column:99
+ End:
+*/
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :
diff --git a/src/widgets/spw-utilities.cpp b/src/widgets/spw-utilities.cpp
new file mode 100644
index 0000000..38759ef
--- /dev/null
+++ b/src/widgets/spw-utilities.cpp
@@ -0,0 +1,160 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * Inkscape Widget Utilities
+ *
+ * Authors:
+ * Bryce W. Harrington <brycehar@bryceharrington.org>
+ * bulia byak <buliabyak@users.sf.net>
+ *
+ * Copyright (C) 2003 Bryce W. Harrington
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#include <cstring>
+#include <string>
+
+#include <gtkmm/box.h>
+#include <gtkmm/label.h>
+#include <gtkmm/grid.h>
+
+#include "selection.h"
+
+#include "spw-utilities.h"
+
+/**
+ * Creates a label widget with the given text, at the given col, row
+ * position in the table.
+ */
+Gtk::Label * spw_label(Gtk::Grid *table, const gchar *label_text, int col, int row, Gtk::Widget* target)
+{
+ Gtk::Label *label_widget = new Gtk::Label();
+ g_assert(label_widget != nullptr);
+ if (target != nullptr) {
+ label_widget->set_text_with_mnemonic(label_text);
+ label_widget->set_mnemonic_widget(*target);
+ } else {
+ label_widget->set_text(label_text);
+ }
+ label_widget->show();
+
+ label_widget->set_halign(Gtk::ALIGN_START);
+ label_widget->set_valign(Gtk::ALIGN_CENTER);
+ label_widget->set_margin_start(4);
+ label_widget->set_margin_end(4);
+
+ table->attach(*label_widget, col, row, 1, 1);
+
+ return label_widget;
+}
+
+/**
+ * Creates a horizontal layout manager with 4-pixel spacing between children
+ * and space for 'width' columns.
+ */
+Gtk::HBox * spw_hbox(Gtk::Grid * table, int width, int col, int row)
+{
+ /* Create a new hbox with a 4-pixel spacing between children */
+ Gtk::HBox *hb = new Gtk::HBox(false, 4);
+ g_assert(hb != nullptr);
+ hb->show();
+ hb->set_hexpand();
+ hb->set_halign(Gtk::ALIGN_FILL);
+ hb->set_valign(Gtk::ALIGN_CENTER);
+ table->attach(*hb, col, row, width, 1);
+
+ return hb;
+}
+
+/**
+ * Finds the descendant of w which has the data with the given key and returns the data, or NULL if there's none.
+ */
+gpointer sp_search_by_data_recursive(GtkWidget *w, gpointer key)
+{
+ gpointer r = nullptr;
+
+ if (w && G_IS_OBJECT(w)) {
+ r = g_object_get_data(G_OBJECT(w), (gchar *) key);
+ }
+ if (r) return r;
+
+ if (GTK_IS_CONTAINER(w)) {
+ std::vector<Gtk::Widget*> children = Glib::wrap(GTK_CONTAINER(w))->get_children();
+ for (auto i:children) {
+ r = sp_search_by_data_recursive(GTK_WIDGET(i->gobj()), key);
+ if (r) return r;
+ }
+ }
+
+ return nullptr;
+}
+
+/**
+ * Returns a named descendent of parent, which has the given name, or nullptr if there's none.
+ *
+ * \param[in] parent The widget to search
+ * \param[in] name The name of the desired child widget
+ *
+ * \return The specified child widget, or nullptr if it cannot be found
+ */
+Gtk::Widget *
+sp_search_by_name_recursive(Gtk::Widget *parent, const Glib::ustring& name)
+{
+ auto parent_bin = dynamic_cast<Gtk::Bin *>(parent);
+ auto parent_container = dynamic_cast<Gtk::Container *>(parent);
+
+ if (parent && parent->get_name() == name) {
+ return parent;
+ }
+ else if (parent_bin) {
+ auto child = parent_bin->get_child();
+ return sp_search_by_name_recursive(child, name);
+ }
+ else if (parent_container) {
+ auto children = parent_container->get_children();
+
+ for (auto child : children) {
+ auto tmp = sp_search_by_name_recursive(child, name);
+
+ if (tmp) {
+ return tmp;
+ }
+ }
+ }
+
+ 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<Gtk::Widget*> 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++
+ c-file-style:"stroustrup"
+ c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
+ indent-tabs-mode:nil
+ fill-column:99
+ End:
+*/
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :
diff --git a/src/widgets/spw-utilities.h b/src/widgets/spw-utilities.h
new file mode 100644
index 0000000..4751e81
--- /dev/null
+++ b/src/widgets/spw-utilities.h
@@ -0,0 +1,48 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+#ifndef __SPW_UTILITIES_H__
+#define __SPW_UTILITIES_H__
+
+/*
+ * Inkscape Widget Utilities
+ *
+ * Author:
+ * Bryce W. Harrington <brycehar@bryceharrington.org>
+ *
+ * Copyright (C) 2003 Bryce Harrington
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+/* The following are helper routines for making Inkscape dialog widgets.
+ All are prefixed with spw_, short for inkscape_widget. This is not to
+ be confused with SPWidget, an existing datatype associated with Inkscape::XML::Node/
+ SPObject, that reacts to modification.
+*/
+
+namespace Gtk {
+ class Label;
+ class Grid;
+ class HBox;
+ class Widget;
+}
+
+Gtk::Label * spw_label(Gtk::Grid *table, gchar const *label_text, int col, int row, Gtk::Widget *target);
+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);
+#endif
+
+/*
+ Local Variables:
+ mode:c++
+ c-file-style:"stroustrup"
+ c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
+ indent-tabs-mode:nil
+ fill-column:99
+ End:
+*/
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :
diff --git a/src/widgets/stroke-marker-selector.cpp b/src/widgets/stroke-marker-selector.cpp
new file mode 100644
index 0000000..337ba16
--- /dev/null
+++ b/src/widgets/stroke-marker-selector.cpp
@@ -0,0 +1,567 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/**
+ * @file
+ * Combobox for selecting dash patterns - implementation.
+ */
+/* Author:
+ * Lauris Kaplinski <lauris@kaplinski.com>
+ * bulia byak <buliabyak@users.sf.net>
+ * Maximilian Albert <maximilian.albert@gmail.com>
+ *
+ * Copyright (C) 2002 Lauris Kaplinski
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#include "stroke-marker-selector.h"
+
+#include <glibmm/i18n.h>
+#include <gtkmm/icontheme.h>
+
+#include "desktop-style.h"
+#include "path-prefix.h"
+#include "stroke-style.h"
+
+#include "helper/stock-items.h"
+#include "ui/icon-loader.h"
+
+#include "io/sys.h"
+
+#include "object/sp-defs.h"
+#include "object/sp-marker.h"
+#include "object/sp-root.h"
+#include "style.h"
+
+#include "ui/cache/svg_preview_cache.h"
+#include "ui/dialog-events.h"
+#include "ui/util.h"
+#include "ui/widget/spinbutton.h"
+
+static Inkscape::UI::Cache::SvgPreview svg_preview_cache;
+
+MarkerComboBox::MarkerComboBox(gchar const *id, int l) :
+ Gtk::ComboBox(),
+ combo_id(id),
+ loc(l),
+ updating(false),
+ markerCount(0)
+{
+
+ marker_store = Gtk::ListStore::create(marker_columns);
+ set_model(marker_store);
+ pack_start(image_renderer, false);
+ set_cell_data_func(image_renderer, sigc::mem_fun(*this, &MarkerComboBox::prepareImageRenderer));
+ gtk_combo_box_set_row_separator_func(GTK_COMBO_BOX(gobj()), MarkerComboBox::separator_cb, nullptr, nullptr);
+ empty_image = sp_get_icon_image("no-marker", Gtk::ICON_SIZE_SMALL_TOOLBAR);
+
+ sandbox = ink_markers_preview_doc ();
+
+ init_combo();
+ this->get_style_context()->add_class("combobright");
+
+ show();
+}
+
+MarkerComboBox::~MarkerComboBox() {
+ delete combo_id;
+ delete sandbox;
+ delete empty_image;
+
+ if (doc) {
+ modified_connection.disconnect();
+ }
+}
+
+void MarkerComboBox::setDocument(SPDocument *document)
+{
+ if (doc != document) {
+
+ if (doc) {
+ modified_connection.disconnect();
+ }
+
+ doc = document;
+
+ if (doc) {
+ modified_connection = doc->getDefs()->connectModified( sigc::hide(sigc::hide(sigc::bind(sigc::ptr_fun(&MarkerComboBox::handleDefsModified), this))) );
+ }
+
+ refreshHistory();
+ }
+}
+
+void
+MarkerComboBox::handleDefsModified(MarkerComboBox *self)
+{
+ self->refreshHistory();
+}
+
+void
+MarkerComboBox::refreshHistory()
+{
+ if (updating)
+ return;
+
+ updating = true;
+
+ std::vector<SPMarker *> ml = get_marker_list(doc);
+
+ /*
+ * Seems to be no way to get notified of changes just to markers,
+ * so listen to changes in all defs and check if the number of markers has changed here
+ * to avoid unnecessary refreshes when things like gradients change
+ */
+ if (markerCount != ml.size()) {
+ const char *active = get_active()->get_value(marker_columns.marker);
+ sp_marker_list_from_doc(doc, true);
+ set_selected(active);
+ markerCount = ml.size();
+ }
+
+ updating = false;
+}
+
+/**
+ * Init the combobox widget to display markers from markers.svg
+ */
+void
+MarkerComboBox::init_combo()
+{
+ if (updating)
+ return;
+
+ static SPDocument *markers_doc = nullptr;
+
+ // add separator
+ Gtk::TreeModel::Row row_sep = *(marker_store->append());
+ row_sep[marker_columns.label] = "Separator";
+ row_sep[marker_columns.marker] = g_strdup("None");
+ row_sep[marker_columns.image] = NULL;
+ row_sep[marker_columns.stock] = false;
+ row_sep[marker_columns.history] = false;
+ row_sep[marker_columns.separator] = true;
+
+ // find and load markers.svg
+ if (markers_doc == nullptr) {
+ char *markers_source = g_build_filename(INKSCAPE_MARKERSDIR, "markers.svg", NULL);
+ if (Inkscape::IO::file_test(markers_source, G_FILE_TEST_IS_REGULAR)) {
+ markers_doc = SPDocument::createNewDoc(markers_source, FALSE);
+ }
+ g_free(markers_source);
+ }
+
+ // load markers from markers.svg
+ if (markers_doc) {
+ sp_marker_list_from_doc(markers_doc, false);
+ }
+
+ set_sensitive(true);
+}
+
+/**
+ * Sets the current marker in the marker combobox.
+ */
+void MarkerComboBox::set_current(SPObject *marker)
+{
+ updating = true;
+
+ if (marker != nullptr) {
+ gchar *markname = g_strdup(marker->getRepr()->attribute("id"));
+ set_selected(markname);
+ g_free (markname);
+ }
+ else {
+ set_selected(nullptr);
+ }
+
+ updating = false;
+
+}
+/**
+ * Return a uri string representing the current selected marker used for setting the marker style in the document
+ */
+const gchar * MarkerComboBox::get_active_marker_uri()
+{
+ /* Get Marker */
+ const gchar *markid = get_active()->get_value(marker_columns.marker);
+ if (!markid)
+ {
+ return nullptr;
+ }
+
+ gchar const *marker = "";
+ if (strcmp(markid, "none")) {
+ bool stockid = get_active()->get_value(marker_columns.stock);
+
+ gchar *markurn;
+ if (stockid)
+ {
+ markurn = g_strconcat("urn:inkscape:marker:",markid,NULL);
+ }
+ else
+ {
+ markurn = g_strdup(markid);
+ }
+ SPObject *mark = get_stock_item(markurn, stockid);
+ g_free(markurn);
+ if (mark) {
+ Inkscape::XML::Node *repr = mark->getRepr();
+ marker = g_strconcat("url(#", repr->attribute("id"), ")", NULL);
+ }
+ } else {
+ marker = g_strdup(markid);
+ }
+
+ return marker;
+}
+
+void MarkerComboBox::set_active_history() {
+
+ const gchar *markid = get_active()->get_value(marker_columns.marker);
+
+ // If forked from a stockid, add the stockid
+ SPObject const *marker = doc->getObjectById(markid);
+ if (marker && marker->getRepr()->attribute("inkscape:stockid")) {
+ markid = marker->getRepr()->attribute("inkscape:stockid");
+ }
+
+ set_selected(markid);
+}
+
+
+void MarkerComboBox::set_selected(const gchar *name, gboolean retry/*=true*/) {
+
+ if (!name) {
+ set_active(0);
+ return;
+ }
+
+ for(Gtk::TreeIter iter = marker_store->children().begin();
+ iter != marker_store->children().end(); ++iter) {
+ Gtk::TreeModel::Row row = (*iter);
+ if (row[marker_columns.marker] &&
+ !strcmp(row[marker_columns.marker], name)) {
+ set_active(iter);
+ return;
+ }
+ }
+
+ // Didn't find it in the list, try refreshing from the doc
+ if (retry) {
+ sp_marker_list_from_doc(doc, true);
+ set_selected(name, false);
+ }
+}
+
+
+/**
+ * Pick up all markers from source, except those that are in
+ * current_doc (if non-NULL), and add items to the combo.
+ */
+void MarkerComboBox::sp_marker_list_from_doc(SPDocument *source, gboolean history)
+{
+ std::vector<SPMarker *> ml = get_marker_list(source);
+
+ remove_markers(history); // Seem to need to remove 2x
+ remove_markers(history);
+ add_markers(ml, source, history);
+}
+
+/**
+ * Returns a list of markers in the defs of the given source document as a vector
+ * Returns NULL if there are no markers in the document.
+ */
+std::vector<SPMarker *> MarkerComboBox::get_marker_list (SPDocument *source)
+{
+ std::vector<SPMarker *> ml;
+ if (source == nullptr)
+ return ml;
+
+ SPDefs *defs = source->getDefs();
+ if (!defs) {
+ return ml;
+ }
+
+ for (auto& child: defs->children)
+ {
+ if (SP_IS_MARKER(&child)) {
+ ml.push_back(SP_MARKER(&child));
+ }
+ }
+ return ml;
+}
+
+/**
+ * Remove history or non-history markers from the combo
+ */
+void MarkerComboBox::remove_markers (gboolean history)
+{
+ // Having the model set causes assertions when erasing rows, temporarily disconnect
+ unset_model();
+ for(Gtk::TreeIter iter = marker_store->children().begin();
+ iter != marker_store->children().end(); ++iter) {
+ Gtk::TreeModel::Row row = (*iter);
+ if (row[marker_columns.history] == history && row[marker_columns.separator] == false) {
+ marker_store->erase(iter);
+ iter = marker_store->children().begin();
+ }
+ }
+
+ set_model(marker_store);
+}
+
+/**
+ * Adds markers in marker_list to the combo
+ */
+void MarkerComboBox::add_markers (std::vector<SPMarker *> const& marker_list, SPDocument *source, gboolean history)
+{
+ // Do this here, outside of loop, to speed up preview generation:
+ Inkscape::Drawing drawing;
+ unsigned const visionkey = SPItem::display_key_new(1);
+ drawing.setRoot(sandbox->getRoot()->invoke_show(drawing, visionkey, SP_ITEM_SHOW_DISPLAY));
+ // Find the separator,
+ Gtk::TreeIter sep_iter;
+ for(Gtk::TreeIter iter = marker_store->children().begin();
+ iter != marker_store->children().end(); ++iter) {
+ Gtk::TreeModel::Row row = (*iter);
+ if (row[marker_columns.separator]) {
+ sep_iter = iter;
+ }
+ }
+
+ if (history) {
+ // add "None"
+ Gtk::TreeModel::Row row = *(marker_store->prepend());
+ row[marker_columns.label] = C_("Marker", "None");
+ row[marker_columns.stock] = false;
+ row[marker_columns.marker] = g_strdup("None");
+ row[marker_columns.image] = NULL;
+ row[marker_columns.history] = true;
+ row[marker_columns.separator] = false;
+ }
+
+ for (auto i:marker_list) {
+
+ Inkscape::XML::Node *repr = i->getRepr();
+ gchar const *markid = repr->attribute("inkscape:stockid") ? repr->attribute("inkscape:stockid") : repr->attribute("id");
+
+ // generate preview
+ Gtk::Image *prv = create_marker_image (24, repr->attribute("id"), source, drawing, visionkey);
+ prv->show();
+
+ // Add history before separator, others after
+ Gtk::TreeModel::Row row;
+ if (history)
+ row = *(marker_store->insert(sep_iter));
+ else
+ row = *(marker_store->append());
+
+ row[marker_columns.label] = ink_ellipsize_text(markid, 20);
+ // Non "stock" markers can also have "inkscape:stockid" (when using extension ColorMarkers),
+ // So use !is_history instead to determine is it is "stock" (ie in the markers.svg file)
+ row[marker_columns.stock] = !history;
+ row[marker_columns.marker] = repr->attribute("id");
+ row[marker_columns.image] = prv;
+ row[marker_columns.history] = history;
+ row[marker_columns.separator] = false;
+
+ }
+
+ sandbox->getRoot()->invoke_hide(visionkey);
+}
+
+/*
+ * Remove from the cache and recreate a marker image
+ */
+void
+MarkerComboBox::update_marker_image(gchar const *mname)
+{
+ gchar *cache_name = g_strconcat(combo_id, mname, NULL);
+ Glib::ustring key = svg_preview_cache.cache_key(doc->getDocumentURI(), cache_name, 24);
+ g_free (cache_name);
+ svg_preview_cache.remove_preview_from_cache(key);
+
+ Inkscape::Drawing drawing;
+ unsigned const visionkey = SPItem::display_key_new(1);
+ drawing.setRoot(sandbox->getRoot()->invoke_show(drawing, visionkey, SP_ITEM_SHOW_DISPLAY));
+ Gtk::Image *prv = create_marker_image(24, mname, doc, drawing, visionkey);
+ if (prv) {
+ prv->show();
+ }
+ sandbox->getRoot()->invoke_hide(visionkey);
+
+ for(const auto & iter : marker_store->children()) {
+ Gtk::TreeModel::Row row = iter;
+ if (row[marker_columns.marker] && row[marker_columns.history] &&
+ !strcmp(row[marker_columns.marker], mname)) {
+ row[marker_columns.image] = prv;
+ return;
+ }
+ }
+
+}
+/**
+ * Creates a copy of the marker named mname, determines its visible and renderable
+ * area in the bounding box, and then renders it. This allows us to fill in
+ * preview images of each marker in the marker combobox.
+ */
+Gtk::Image *
+MarkerComboBox::create_marker_image(unsigned psize, gchar const *mname,
+ SPDocument *source, Inkscape::Drawing &drawing, unsigned /*visionkey*/)
+{
+ // Retrieve the marker named 'mname' from the source SVG document
+ SPObject const *marker = source->getObjectById(mname);
+ if (marker == nullptr) {
+ return nullptr;
+ }
+
+ // Create a copy repr of the marker with id="sample"
+ Inkscape::XML::Document *xml_doc = sandbox->getReprDoc();
+ Inkscape::XML::Node *mrepr = marker->getRepr()->duplicate(xml_doc);
+ mrepr->setAttribute("id", "sample");
+
+ // Replace the old sample in the sandbox by the new one
+ Inkscape::XML::Node *defsrepr = sandbox->getObjectById("defs")->getRepr();
+ SPObject *oldmarker = sandbox->getObjectById("sample");
+ if (oldmarker) {
+ oldmarker->deleteObject(false);
+ }
+
+ // TODO - This causes a SIGTRAP on windows
+ defsrepr->appendChild(mrepr);
+
+ Inkscape::GC::release(mrepr);
+
+ // If the marker color is a url link to a pattern or gradient copy that too
+ SPObject *mk = source->getObjectById(mname);
+ SPCSSAttr *css_marker = sp_css_attr_from_object(mk->firstChild(), SP_STYLE_FLAG_ALWAYS);
+ //const char *mfill = sp_repr_css_property(css_marker, "fill", "none");
+ const char *mstroke = sp_repr_css_property(css_marker, "fill", "none");
+
+ if (!strncmp (mstroke, "url(", 4)) {
+ SPObject *linkObj = getMarkerObj(mstroke, source);
+ if (linkObj) {
+ Inkscape::XML::Node *grepr = linkObj->getRepr()->duplicate(xml_doc);
+ SPObject *oldmarker = sandbox->getObjectById(linkObj->getId());
+ if (oldmarker) {
+ oldmarker->deleteObject(false);
+ }
+ defsrepr->appendChild(grepr);
+ Inkscape::GC::release(grepr);
+
+ if (SP_IS_GRADIENT(linkObj)) {
+ SPGradient *vector = sp_gradient_get_forked_vector_if_necessary (SP_GRADIENT(linkObj), false);
+ if (vector) {
+ Inkscape::XML::Node *grepr = vector->getRepr()->duplicate(xml_doc);
+ SPObject *oldmarker = sandbox->getObjectById(vector->getId());
+ if (oldmarker) {
+ oldmarker->deleteObject(false);
+ }
+ defsrepr->appendChild(grepr);
+ Inkscape::GC::release(grepr);
+ }
+ }
+ }
+ }
+
+// Uncomment this to get the sandbox documents saved (useful for debugging)
+ //FILE *fp = fopen (g_strconcat(combo_id, mname, ".svg", NULL), "w");
+ //sp_repr_save_stream(sandbox->getReprDoc(), fp);
+ //fclose (fp);
+
+ // object to render; note that the id is the same as that of the combo we're building
+ SPObject *object = sandbox->getObjectById(combo_id);
+ sandbox->getRoot()->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
+ sandbox->ensureUpToDate();
+
+ if (object == nullptr || !SP_IS_ITEM(object)) {
+ return nullptr; // sandbox broken?
+ }
+
+ SPItem *item = SP_ITEM(object);
+ // Find object's bbox in document
+ Geom::OptRect dbox = item->documentVisualBounds();
+
+ if (!dbox) {
+ return nullptr;
+ }
+
+ /* Update to renderable state */
+ gchar *cache_name = g_strconcat(combo_id, mname, NULL);
+ Glib::ustring key = svg_preview_cache.cache_key(source->getDocumentURI(), cache_name, psize);
+ g_free (cache_name);
+ GdkPixbuf *pixbuf = svg_preview_cache.get_preview_from_cache(key); // no ref created
+
+ if (!pixbuf) {
+ pixbuf = render_pixbuf(drawing, 0.8, *dbox, psize);
+ svg_preview_cache.set_preview_in_cache(key, pixbuf);
+ g_object_unref(pixbuf); // reference is held by svg_preview_cache
+ }
+
+ // Create widget
+ Gtk::Image *pb = Glib::wrap(GTK_IMAGE(gtk_image_new_from_pixbuf(pixbuf)));
+ return pb;
+}
+
+void MarkerComboBox::prepareImageRenderer( Gtk::TreeModel::const_iterator const &row ) {
+
+ Gtk::Image *image = (*row)[marker_columns.image];
+ if (image)
+ image_renderer.property_pixbuf() = image->get_pixbuf();
+ else
+ image_renderer.property_pixbuf() = empty_image->get_pixbuf();
+}
+
+gboolean MarkerComboBox::separator_cb (GtkTreeModel *model, GtkTreeIter *iter, gpointer /*data*/) {
+
+ gboolean sep = FALSE;
+ gtk_tree_model_get(model, iter, 4, &sep, -1);
+ return sep;
+}
+
+/**
+ * Returns a new document containing default start, mid, and end markers.
+ */
+SPDocument *MarkerComboBox::ink_markers_preview_doc ()
+{
+gchar const *buffer = R"A(
+ <svg xmlns="http://www.w3.org/2000/svg"
+ xmlns:xlink="http://www.w3.org/1999/xlink"
+ id="MarkerSample">
+
+ <defs id="defs"/>
+
+ <g id="marker-start">
+ <path style="fill:gray;stroke:darkgray;stroke-width:1.7;marker-start:url(#sample)"
+ d="M 12.5,13 L 25,13"/>
+ <rect x="0" y="0" width="25" height="25" style="fill:none;stroke:none"/>
+ </g>
+
+ <g id="marker-mid">
+ <path style="fill:gray;stroke:darkgray;stroke-width:1.7;marker-mid:url(#sample)"
+ d="M 0,113 L 12.5,113 L 25,113"/>
+ <rect x="0" y="100" width="25" height="25" style="fill:none;stroke:none"/>
+ </g>
+
+ <g id="marker-end">
+ <path style="fill:gray;stroke:darkgray;stroke-width:1.7;marker-end:url(#sample)"
+ d="M 0,213 L 12.5,213"/>
+ <rect x="0" y="200" width="25" height="25" style="fill:none;stroke:none"/>
+ </g>
+
+ </svg>
+)A";
+
+ return SPDocument::createNewDocFromMem (buffer, strlen(buffer), FALSE);
+}
+
+/*
+ Local Variables:
+ mode:c++
+ c-file-style:"stroustrup"
+ c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
+ indent-tabs-mode:nil
+ fill-column:99
+ End:
+*/
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :
diff --git a/src/widgets/stroke-marker-selector.h b/src/widgets/stroke-marker-selector.h
new file mode 100644
index 0000000..c9bd2e8
--- /dev/null
+++ b/src/widgets/stroke-marker-selector.h
@@ -0,0 +1,118 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+#ifndef SEEN_SP_MARKER_SELECTOR_NEW_H
+#define SEEN_SP_MARKER_SELECTOR_NEW_H
+
+/* Authors:
+ * Lauris Kaplinski <lauris@kaplinski.com>
+ * Maximilian Albert <maximilian.albert> (gtkmm-ification)
+ *
+ * Copyright (C) 2002 Lauris Kaplinski
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+#include <vector>
+
+#include <gtkmm/box.h>
+#include <gtkmm/combobox.h>
+#include <gtkmm/liststore.h>
+
+#include <sigc++/signal.h>
+
+#include "document.h"
+#include "inkscape.h"
+
+#include "display/drawing.h"
+
+class SPMarker;
+
+namespace Gtk {
+
+class Container;
+class Adjustment;
+}
+
+/**
+ * ComboBox derived class for selecting stroke markers.
+ */
+
+class MarkerComboBox : public Gtk::ComboBox {
+public:
+ MarkerComboBox(gchar const *id, int loc);
+ ~MarkerComboBox() override;
+
+ void setDocument(SPDocument *);
+
+ sigc::signal<void> changed_signal;
+
+ void set_current(SPObject *marker);
+ void set_active_history();
+ void set_selected(const gchar *name, gboolean retry=true);
+ const gchar *get_active_marker_uri();
+ bool update() { return updating; };
+ gchar const *get_id() { return combo_id; };
+ void update_marker_image(gchar const *mname);
+ int get_loc() { return loc; };
+
+private:
+
+
+ Glib::RefPtr<Gtk::ListStore> marker_store;
+ gchar const *combo_id;
+ int loc;
+ bool updating;
+ guint markerCount;
+ SPDocument *doc = nullptr;
+ SPDocument *sandbox;
+ Gtk::Image *empty_image;
+ Gtk::CellRendererPixbuf image_renderer;
+
+ class MarkerColumns : public Gtk::TreeModel::ColumnRecord {
+ public:
+ Gtk::TreeModelColumn<Glib::ustring> label;
+ Gtk::TreeModelColumn<const gchar *> marker; // ustring doesn't work here on windows due to unicode
+ Gtk::TreeModelColumn<gboolean> stock;
+ Gtk::TreeModelColumn<Gtk::Image *> image;
+ Gtk::TreeModelColumn<gboolean> history;
+ Gtk::TreeModelColumn<gboolean> separator;
+
+ MarkerColumns() {
+ add(label); add(stock); add(marker); add(history); add(separator); add(image);
+ }
+ };
+ MarkerColumns marker_columns;
+
+ void init_combo();
+ void set_history(Gtk::TreeModel::Row match_row);
+ void sp_marker_list_from_doc(SPDocument *source, gboolean history);
+ std::vector <SPMarker*> get_marker_list (SPDocument *source);
+ void add_markers (std::vector<SPMarker *> const& marker_list, SPDocument *source, gboolean history);
+ void remove_markers (gboolean history);
+ SPDocument *ink_markers_preview_doc ();
+ Gtk::Image * create_marker_image(unsigned psize, gchar const *mname,
+ SPDocument *source, Inkscape::Drawing &drawing, unsigned /*visionkey*/);
+
+ /*
+ * Callbacks for drawing the combo box
+ */
+ void prepareImageRenderer( Gtk::TreeModel::const_iterator const &row );
+ static gboolean separator_cb (GtkTreeModel *model, GtkTreeIter *iter, gpointer data);
+
+ static void handleDefsModified(MarkerComboBox *self);
+
+ void refreshHistory();
+
+ sigc::connection modified_connection;
+};
+
+#endif // SEEN_SP_MARKER_SELECTOR_NEW_H
+
+/*
+ Local Variables:
+ mode:c++
+ c-file-style:"stroustrup"
+ c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
+ indent-tabs-mode:nil
+ fill-column:99
+ End:
+*/
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :
diff --git a/src/widgets/stroke-style.cpp b/src/widgets/stroke-style.cpp
new file mode 100644
index 0000000..f2fe0e1
--- /dev/null
+++ b/src/widgets/stroke-style.cpp
@@ -0,0 +1,1346 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/* Authors:
+ * Lauris Kaplinski <lauris@kaplinski.com>
+ * Bryce Harrington <brycehar@bryceharrington.org>
+ * bulia byak <buliabyak@users.sf.net>
+ * Maximilian Albert <maximilian.albert@gmail.com>
+ * Josh Andler <scislac@users.sf.net>
+ * Jon A. Cruz <jon@joncruz.org>
+ * Abhishek Sharma
+ *
+ * Copyright (C) 2001-2005 authors
+ * Copyright (C) 2001 Ximian, Inc.
+ * Copyright (C) 2004 John Cliff
+ * Copyright (C) 2008 Maximilian Albert (gtkmm-ification)
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#define noSP_SS_VERBOSE
+
+#include "desktop-widget.h"
+#include "stroke-style.h"
+
+#include "object/sp-marker.h"
+#include "object/sp-namedview.h"
+#include "object/sp-rect.h"
+#include "object/sp-stop.h"
+#include "object/sp-text.h"
+
+#include "svg/svg-color.h"
+
+#include "ui/icon-loader.h"
+#include "ui/widget/dash-selector.h"
+#include "ui/widget/unit-menu.h"
+
+#include "widgets/style-utils.h"
+
+using Inkscape::DocumentUndo;
+using Inkscape::Util::unit_table;
+
+/**
+ * Creates a new widget for the line stroke paint.
+ */
+Gtk::Widget *sp_stroke_style_paint_widget_new()
+{
+ return Inkscape::Widgets::createStyleWidget( STROKE );
+}
+
+/**
+ * Creates a new widget for the line stroke style.
+ */
+Gtk::Widget *sp_stroke_style_line_widget_new()
+{
+ return Inkscape::Widgets::createStrokeStyleWidget();
+}
+
+void sp_stroke_style_widget_set_desktop(Gtk::Widget *widget, SPDesktop *desktop)
+{
+ Inkscape::StrokeStyle *ss = dynamic_cast<Inkscape::StrokeStyle*>(widget);
+ if (ss) {
+ ss->setDesktop(desktop);
+ }
+}
+
+
+/**
+ * Extract the actual name of the link
+ * e.g. get mTriangle from url(#mTriangle).
+ * \return Buffer containing the actual name, allocated from GLib;
+ * the caller should free the buffer when they no longer need it.
+ */
+SPObject* getMarkerObj(gchar const *n, SPDocument *doc)
+{
+ gchar const *p = n;
+ while (*p != '\0' && *p != '#') {
+ p++;
+ }
+
+ if (*p == '\0' || p[1] == '\0') {
+ return nullptr;
+ }
+
+ p++;
+ int c = 0;
+ while (p[c] != '\0' && p[c] != ')') {
+ c++;
+ }
+
+ if (p[c] == '\0') {
+ return nullptr;
+ }
+
+ gchar* b = g_strdup(p);
+ b[c] = '\0';
+
+ // FIXME: get the document from the object and let the caller pass it in
+ SPObject *marker = doc->getObjectById(b);
+
+ g_free(b);
+ return marker;
+}
+
+namespace Inkscape {
+
+
+/**
+ * Construct a stroke-style radio button with a given icon
+ *
+ * \param[in] grp The Gtk::RadioButtonGroup to which to add the new button
+ * \param[in] icon The icon to use for the button
+ * \param[in] button_type The type of stroke-style radio button (join/cap)
+ * \param[in] stroke_style The style attribute to associate with the button
+ */
+StrokeStyle::StrokeStyleButton::StrokeStyleButton(Gtk::RadioButtonGroup &grp,
+ char const *icon,
+ StrokeStyleButtonType button_type,
+ gchar const *stroke_style)
+ :
+ Gtk::RadioButton(grp),
+ button_type(button_type),
+ stroke_style(stroke_style)
+{
+ show();
+ set_mode(false);
+
+ auto px = Gtk::manage(sp_get_icon_image(icon, Gtk::ICON_SIZE_LARGE_TOOLBAR));
+ g_assert(px != nullptr);
+ px->show();
+ add(*px);
+}
+
+/**
+ * Create the fill or stroke style widget, and hook up all the signals.
+ */
+Gtk::Widget *Inkscape::Widgets::createStrokeStyleWidget( )
+{
+ StrokeStyle *strokeStyle = new StrokeStyle();
+
+ return strokeStyle;
+}
+
+StrokeStyle::StrokeStyle() :
+ Gtk::Box(),
+ miterLimitSpin(),
+ widthSpin(),
+ unitSelector(),
+ joinMiter(),
+ joinRound(),
+ joinBevel(),
+ capButt(),
+ capRound(),
+ capSquare(),
+ dashSelector(),
+ update(false),
+ desktop(nullptr),
+ selectChangedConn(),
+ selectModifiedConn(),
+ startMarkerConn(),
+ midMarkerConn(),
+ endMarkerConn(),
+ _old_unit(nullptr)
+{
+ table = new Gtk::Grid();
+ table->set_border_width(4);
+ table->set_row_spacing(4);
+ table->set_hexpand(false);
+ table->set_halign(Gtk::ALIGN_CENTER);
+ table->show();
+ add(*table);
+
+ Gtk::HBox *hb;
+ gint i = 0;
+
+ //spw_label(t, C_("Stroke width", "_Width:"), 0, i);
+
+ hb = spw_hbox(table, 3, 1, i);
+
+// TODO: when this is gtkmmified, use an Inkscape::UI::Widget::ScalarUnit instead of the separate
+// spinbutton and unit selector for stroke width. In sp_stroke_style_line_update, use
+// setHundredPercent to remember the averaged width corresponding to 100%. Then the
+// stroke_width_set_unit will be removed (because ScalarUnit takes care of conversions itself), and
+// with it, the two remaining calls of stroke_average_width, allowing us to get rid of that
+// function in desktop-style.
+ widthAdj = new Glib::RefPtr<Gtk::Adjustment>(Gtk::Adjustment::create(1.0, 0.0, 1000.0, 0.1, 10.0, 0.0));
+ widthSpin = new Inkscape::UI::Widget::SpinButton(*widthAdj, 0.1, 3);
+ widthSpin->set_tooltip_text(_("Stroke width"));
+ widthSpin->show();
+ spw_label(table, C_("Stroke width", "_Width:"), 0, i, widthSpin);
+
+ sp_dialog_defocus_on_enter_cpp(widthSpin);
+
+ hb->pack_start(*widthSpin, false, false, 0);
+ unitSelector = new Inkscape::UI::Widget::UnitMenu();
+ unitSelector->setUnitType(Inkscape::Util::UNIT_TYPE_LINEAR);
+ Gtk::Widget *us = Gtk::manage(unitSelector);
+ SPDesktop *desktop = SP_ACTIVE_DESKTOP;
+
+ unitSelector->addUnit(*unit_table.getUnit("%"));
+ _old_unit = unitSelector->getUnit();
+ if (desktop) {
+ unitSelector->setUnit(desktop->getNamedView()->display_units->abbr);
+ _old_unit = desktop->getNamedView()->display_units;
+ }
+ widthSpin->setUnitMenu(unitSelector);
+ unitChangedConn = unitSelector->signal_changed().connect(sigc::mem_fun(*this, &StrokeStyle::unitChangedCB));
+
+ us->show();
+
+ hb->pack_start(*us, FALSE, FALSE, 0);
+ (*widthAdj)->signal_value_changed().connect(sigc::mem_fun(*this, &StrokeStyle::widthChangedCB));
+ i++;
+
+ /* Dash */
+ spw_label(table, _("Dashes:"), 0, i, nullptr); //no mnemonic for now
+ //decide what to do:
+ // implement a set_mnemonic_source function in the
+ // Inkscape::UI::Widget::DashSelector class, so that we do not have to
+ // expose any of the underlying widgets?
+ dashSelector = Gtk::manage(new Inkscape::UI::Widget::DashSelector);
+
+ dashSelector->show();
+ dashSelector->set_hexpand();
+ dashSelector->set_halign(Gtk::ALIGN_FILL);
+ dashSelector->set_valign(Gtk::ALIGN_CENTER);
+ table->attach(*dashSelector, 1, i, 3, 1);
+ dashSelector->changed_signal.connect(sigc::mem_fun(*this, &StrokeStyle::lineDashChangedCB));
+
+ i++;
+
+ /* Drop down marker selectors*/
+ // TRANSLATORS: Path markers are an SVG feature that allows you to attach arbitrary shapes
+ // (arrowheads, bullets, faces, whatever) to the start, end, or middle nodes of a path.
+
+ spw_label(table, _("Markers:"), 0, i, nullptr);
+
+ hb = spw_hbox(table, 1, 1, i);
+ i++;
+
+ startMarkerCombo = Gtk::manage(new MarkerComboBox("marker-start", SP_MARKER_LOC_START));
+ startMarkerCombo->set_tooltip_text(_("Start Markers are drawn on the first node of a path or shape"));
+ startMarkerConn = startMarkerCombo->signal_changed().connect(
+ sigc::bind<MarkerComboBox *, StrokeStyle *, SPMarkerLoc>(
+ sigc::ptr_fun(&StrokeStyle::markerSelectCB), startMarkerCombo, this, SP_MARKER_LOC_START));
+ startMarkerCombo->show();
+
+ hb->pack_start(*startMarkerCombo, true, true, 0);
+
+ midMarkerCombo = Gtk::manage(new MarkerComboBox("marker-mid", SP_MARKER_LOC_MID));
+ midMarkerCombo->set_tooltip_text(_("Mid Markers are drawn on every node of a path or shape except the first and last nodes"));
+ midMarkerConn = midMarkerCombo->signal_changed().connect(
+ sigc::bind<MarkerComboBox *, StrokeStyle *, SPMarkerLoc>(
+ sigc::ptr_fun(&StrokeStyle::markerSelectCB), midMarkerCombo, this, SP_MARKER_LOC_MID));
+ midMarkerCombo->show();
+
+ hb->pack_start(*midMarkerCombo, true, true, 0);
+
+ endMarkerCombo = Gtk::manage(new MarkerComboBox("marker-end", SP_MARKER_LOC_END));
+ endMarkerCombo->set_tooltip_text(_("End Markers are drawn on the last node of a path or shape"));
+ endMarkerConn = endMarkerCombo->signal_changed().connect(
+ sigc::bind<MarkerComboBox *, StrokeStyle *, SPMarkerLoc>(
+ sigc::ptr_fun(&StrokeStyle::markerSelectCB), endMarkerCombo, this, SP_MARKER_LOC_END));
+ endMarkerCombo->show();
+
+ hb->pack_start(*endMarkerCombo, true, true, 0);
+
+ i++;
+
+ /* Join type */
+ // TRANSLATORS: The line join style specifies the shape to be used at the
+ // corners of paths. It can be "miter", "round" or "bevel".
+ spw_label(table, _("Join:"), 0, i, nullptr);
+
+ hb = spw_hbox(table, 3, 1, i);
+
+ Gtk::RadioButtonGroup joinGrp;
+
+ joinRound = makeRadioButton(joinGrp, INKSCAPE_ICON("stroke-join-round"),
+ hb, STROKE_STYLE_BUTTON_JOIN, "round");
+
+ // TRANSLATORS: Round join: joining lines with a rounded corner.
+ // For an example, draw a triangle with a large stroke width and modify the
+ // "Join" option (in the Fill and Stroke dialog).
+ joinRound->set_tooltip_text(_("Round join"));
+
+ joinBevel = makeRadioButton(joinGrp, INKSCAPE_ICON("stroke-join-bevel"),
+ hb, STROKE_STYLE_BUTTON_JOIN, "bevel");
+
+ // TRANSLATORS: Bevel join: joining lines with a blunted (flattened) corner.
+ // For an example, draw a triangle with a large stroke width and modify the
+ // "Join" option (in the Fill and Stroke dialog).
+ joinBevel->set_tooltip_text(_("Bevel join"));
+
+ joinMiter = makeRadioButton(joinGrp, INKSCAPE_ICON("stroke-join-miter"),
+ hb, STROKE_STYLE_BUTTON_JOIN, "miter");
+
+ // TRANSLATORS: Miter join: joining lines with a sharp (pointed) corner.
+ // For an example, draw a triangle with a large stroke width and modify the
+ // "Join" option (in the Fill and Stroke dialog).
+ joinMiter->set_tooltip_text(_("Miter join"));
+
+ /* Miterlimit */
+ // TRANSLATORS: Miter limit: only for "miter join", this limits the length
+ // of the sharp "spike" when the lines connect at too sharp an angle.
+ // When two line segments meet at a sharp angle, a miter join results in a
+ // spike that extends well beyond the connection point. The purpose of the
+ // miter limit is to cut off such spikes (i.e. convert them into bevels)
+ // when they become too long.
+ //spw_label(t, _("Miter _limit:"), 0, i);
+ miterLimitAdj = new Glib::RefPtr<Gtk::Adjustment>(Gtk::Adjustment::create(4.0, 0.0, 100.0, 0.1, 10.0, 0.0));
+ miterLimitSpin = new Inkscape::UI::Widget::SpinButton(*miterLimitAdj, 0.1, 2);
+ miterLimitSpin->set_tooltip_text(_("Maximum length of the miter (in units of stroke width)"));
+ miterLimitSpin->show();
+ sp_dialog_defocus_on_enter_cpp(miterLimitSpin);
+
+ hb->pack_start(*miterLimitSpin, false, false, 0);
+ (*miterLimitAdj)->signal_value_changed().connect(sigc::mem_fun(*this, &StrokeStyle::miterLimitChangedCB));
+ i++;
+
+ /* Cap type */
+ // TRANSLATORS: cap type specifies the shape for the ends of lines
+ //spw_label(t, _("_Cap:"), 0, i);
+ spw_label(table, _("Cap:"), 0, i, nullptr);
+
+ hb = spw_hbox(table, 3, 1, i);
+
+ Gtk::RadioButtonGroup capGrp;
+
+ capButt = makeRadioButton(capGrp, INKSCAPE_ICON("stroke-cap-butt"),
+ hb, STROKE_STYLE_BUTTON_CAP, "butt");
+
+ // TRANSLATORS: Butt cap: the line shape does not extend beyond the end point
+ // of the line; the ends of the line are square
+ capButt->set_tooltip_text(_("Butt cap"));
+
+ capRound = makeRadioButton(capGrp, INKSCAPE_ICON("stroke-cap-round"),
+ hb, STROKE_STYLE_BUTTON_CAP, "round");
+
+ // TRANSLATORS: Round cap: the line shape extends beyond the end point of the
+ // line; the ends of the line are rounded
+ capRound->set_tooltip_text(_("Round cap"));
+
+ capSquare = makeRadioButton(capGrp, INKSCAPE_ICON("stroke-cap-square"),
+ hb, STROKE_STYLE_BUTTON_CAP, "square");
+
+ // TRANSLATORS: Square cap: the line shape extends beyond the end point of the
+ // line; the ends of the line are square
+ capSquare->set_tooltip_text(_("Square cap"));
+
+ i++;
+
+ /* Paint order */
+ // TRANSLATORS: Paint order determines the order the 'fill', 'stroke', and 'markers are painted.
+ spw_label(table, _("Order:"), 0, i, nullptr);
+
+ hb = spw_hbox(table, 4, 1, i);
+
+ Gtk::RadioButtonGroup paintOrderGrp;
+
+ paintOrderFSM = makeRadioButton(paintOrderGrp, INKSCAPE_ICON("paint-order-fsm"),
+ hb, STROKE_STYLE_BUTTON_ORDER, "normal");
+ paintOrderFSM->set_tooltip_text(_("Fill, Stroke, Markers"));
+
+ paintOrderSFM = makeRadioButton(paintOrderGrp, INKSCAPE_ICON("paint-order-sfm"),
+ hb, STROKE_STYLE_BUTTON_ORDER, "stroke fill markers");
+ paintOrderSFM->set_tooltip_text(_("Stroke, Fill, Markers"));
+
+ paintOrderFMS = makeRadioButton(paintOrderGrp, INKSCAPE_ICON("paint-order-fms"),
+ hb, STROKE_STYLE_BUTTON_ORDER, "fill markers stroke");
+ paintOrderFMS->set_tooltip_text(_("Fill, Markers, Stroke"));
+
+ i++;
+
+ hb = spw_hbox(table, 4, 1, i);
+
+ paintOrderMFS = makeRadioButton(paintOrderGrp, INKSCAPE_ICON("paint-order-mfs"),
+ hb, STROKE_STYLE_BUTTON_ORDER, "markers fill stroke");
+ paintOrderMFS->set_tooltip_text(_("Markers, Fill, Stroke"));
+
+ paintOrderSMF = makeRadioButton(paintOrderGrp, INKSCAPE_ICON("paint-order-smf"),
+ hb, STROKE_STYLE_BUTTON_ORDER, "stroke markers fill");
+ paintOrderSMF->set_tooltip_text(_("Stroke, Markers, Fill"));
+
+ paintOrderMSF = makeRadioButton(paintOrderGrp, INKSCAPE_ICON("paint-order-msf"),
+ hb, STROKE_STYLE_BUTTON_ORDER, "markers stroke fill");
+ paintOrderMSF->set_tooltip_text(_("Markers, Stroke, Fill"));
+
+ i++;
+}
+
+StrokeStyle::~StrokeStyle()
+{
+ selectModifiedConn.disconnect();
+ selectChangedConn.disconnect();
+}
+
+void StrokeStyle::setDesktop(SPDesktop *desktop)
+{
+ if (this->desktop != desktop) {
+
+ if (this->desktop) {
+ selectModifiedConn.disconnect();
+ selectChangedConn.disconnect();
+ _document_replaced_connection.disconnect();
+ }
+ this->desktop = desktop;
+
+ if (!desktop) {
+ return;
+ }
+
+ if (desktop->selection) {
+ selectChangedConn = desktop->selection->connectChanged(sigc::hide(sigc::mem_fun(*this, &StrokeStyle::selectionChangedCB)));
+ selectModifiedConn = desktop->selection->connectModified(sigc::hide<0>(sigc::mem_fun(*this, &StrokeStyle::selectionModifiedCB)));
+ }
+
+ _document_replaced_connection =
+ desktop->connectDocumentReplaced(sigc::mem_fun(this, &StrokeStyle::_handleDocumentReplaced));
+
+ _handleDocumentReplaced(nullptr, desktop->getDocument());
+
+ updateLine();
+ }
+}
+
+void StrokeStyle::_handleDocumentReplaced(SPDesktop *, SPDocument *document)
+{
+ for (MarkerComboBox *combo : { startMarkerCombo, midMarkerCombo, endMarkerCombo }) {
+ combo->setDocument(document);
+ }
+}
+
+
+/**
+ * Helper function for creating stroke-style radio buttons.
+ *
+ * \param[in] grp The Gtk::RadioButtonGroup in which to add the button
+ * \param[in] icon The icon for the button
+ * \param[in] hb The Gtk::Box container in which to add the button
+ * \param[in] button_type The type (join/cap) for the button
+ * \param[in] stroke_style The style attribute to associate with the button
+ *
+ * \details After instantiating the button, it is added to a container box and
+ * a handler for the toggle event is connected.
+ */
+StrokeStyle::StrokeStyleButton *
+StrokeStyle::makeRadioButton(Gtk::RadioButtonGroup &grp,
+ char const *icon,
+ Gtk::HBox *hb,
+ StrokeStyleButtonType button_type,
+ gchar const *stroke_style)
+{
+ g_assert(icon != nullptr);
+ g_assert(hb != nullptr);
+
+ StrokeStyleButton *tb = new StrokeStyleButton(grp, icon, button_type, stroke_style);
+
+ hb->pack_start(*tb, false, false, 0);
+ set_data(icon, tb);
+
+ tb->signal_toggled().connect(sigc::bind<StrokeStyleButton *, StrokeStyle *>(
+ sigc::ptr_fun(&StrokeStyle::buttonToggledCB), tb, this));
+
+ return tb;
+}
+
+bool StrokeStyle::shouldMarkersBeUpdated()
+{
+ return startMarkerCombo->update() || midMarkerCombo->update() ||
+ endMarkerCombo->update();
+}
+
+/**
+ * Handles when user selects one of the markers from the marker combobox.
+ * Gets the marker uri string and applies it to all selected
+ * items in the current desktop.
+ */
+void StrokeStyle::markerSelectCB(MarkerComboBox *marker_combo, StrokeStyle *spw, SPMarkerLoc const /*which*/)
+{
+ if (spw->update || spw->shouldMarkersBeUpdated()) {
+ return;
+ }
+
+ spw->update = true;
+
+ SPDocument *document = spw->desktop->getDocument();
+ if (!document) {
+ return;
+ }
+
+ /* Get Marker */
+ gchar const *marker = marker_combo->get_active_marker_uri();
+
+
+ SPCSSAttr *css = sp_repr_css_attr_new();
+ gchar const *combo_id = marker_combo->get_id();
+ sp_repr_css_set_property(css, combo_id, marker);
+
+ // Also update the marker combobox, so the document's markers
+ // show up at the top of the combobox
+// sp_stroke_style_line_update( SP_WIDGET(spw), desktop ? desktop->getSelection() : NULL);
+ //spw->updateMarkerHist(which);
+
+ Inkscape::Selection *selection = spw->desktop->getSelection();
+ auto itemlist= selection->items();
+ for(auto i=itemlist.begin();i!=itemlist.end();++i){
+ SPItem *item = *i;
+ if (!SP_IS_SHAPE(item) || SP_IS_RECT(item)) { // can't set marker to rect, until it's converted to using <path>
+ continue;
+ }
+ Inkscape::XML::Node *selrepr = item->getRepr();
+ if (selrepr) {
+ sp_repr_css_change_recursive(selrepr, css, "style");
+ SPObject *markerObj = getMarkerObj(marker, document);
+ spw->setMarkerColor(markerObj, marker_combo->get_loc(), item);
+ }
+
+ item->requestModified(SP_OBJECT_MODIFIED_FLAG);
+ item->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_STYLE_MODIFIED_FLAG);
+
+ DocumentUndo::done(document, SP_VERB_DIALOG_FILL_STROKE, _("Set markers"));
+ }
+
+ sp_repr_css_attr_unref(css);
+ css = nullptr;
+
+ spw->update = false;
+};
+
+void StrokeStyle::updateMarkerHist(SPMarkerLoc const which)
+{
+ switch (which) {
+ case SP_MARKER_LOC_START:
+ startMarkerConn.block();
+ startMarkerCombo->set_active_history();
+ startMarkerConn.unblock();
+ break;
+
+ case SP_MARKER_LOC_MID:
+ midMarkerConn.block();
+ midMarkerCombo->set_active_history();
+ midMarkerConn.unblock();
+ break;
+
+ case SP_MARKER_LOC_END:
+ endMarkerConn.block();
+ endMarkerCombo->set_active_history();
+ endMarkerConn.unblock();
+ break;
+ default:
+ g_assert_not_reached();
+ }
+}
+
+/**
+ * Callback for when UnitMenu widget is modified.
+ * Triggers update action.
+ */
+void StrokeStyle::unitChangedCB()
+{
+ Inkscape::Util::Unit const *new_unit = unitSelector->getUnit();
+ if (new_unit->type == Inkscape::Util::UNIT_TYPE_DIMENSIONLESS) {
+ widthSpin->set_value(100);
+ }
+ widthSpin->set_value(Inkscape::Util::Quantity::convert(widthSpin->get_value(), _old_unit, new_unit));
+ _old_unit = new_unit;
+}
+
+/**
+ * Callback for when stroke style widget is modified.
+ * Triggers update action.
+ */
+void
+StrokeStyle::selectionModifiedCB(guint flags)
+{
+ // We care deeply about only updating when the style is updated
+ // if we update on other flags, we slow inkscape down when dragging
+ if (flags & (SP_OBJECT_STYLE_MODIFIED_FLAG)) {
+ updateLine();
+ }
+}
+
+/**
+ * Callback for when stroke style widget is changed.
+ * Triggers update action.
+ */
+void
+StrokeStyle::selectionChangedCB()
+{
+ updateLine();
+}
+
+/*
+ * Fork marker if necessary and set the referencing items url to the new marker
+ * Return the new marker
+ */
+SPObject *
+StrokeStyle::forkMarker(SPObject *marker, int loc, SPItem *item)
+{
+ if (!item || !marker) {
+ return nullptr;
+ }
+
+ gchar const *marker_id = SPMarkerNames[loc].key;
+
+ /*
+ * Optimization when all the references to this marker are from this item
+ * then we can reuse it and don't need to fork
+ */
+ Glib::ustring urlId = Glib::ustring::format("url(#", marker->getRepr()->attribute("id"), ")");
+ unsigned int refs = 0;
+ for (int i = SP_MARKER_LOC_START; i < SP_MARKER_LOC_QTY; i++) {
+ if (item->style->marker_ptrs[i]->set &&
+ !strcmp(urlId.c_str(), item->style->marker_ptrs[i]->value())) {
+ refs++;
+ }
+ }
+ if (marker->hrefcount <= refs) {
+ return marker;
+ }
+
+ marker = sp_marker_fork_if_necessary(marker);
+
+ // Update the items url to new marker
+ Inkscape::XML::Node *mark_repr = marker->getRepr();
+ SPCSSAttr *css_item = sp_repr_css_attr_new();
+ sp_repr_css_set_property(css_item, marker_id, g_strconcat("url(#", mark_repr->attribute("id"), ")", NULL));
+ sp_repr_css_change_recursive(item->getRepr(), css_item, "style");
+
+ sp_repr_css_attr_unref(css_item);
+ css_item = nullptr;
+
+ return marker;
+}
+
+/**
+ * Change the color of the marker to match the color of the item.
+ * Marker stroke color is set to item stroke color.
+ * Fill color :
+ * 1. If the item has fill, use that for the marker fill,
+ * 2. If the marker has same fill and stroke assume its solid, use item stroke for both fill and stroke the line stroke
+ * 3. If the marker has fill color, use the marker fill color
+ *
+ */
+void
+StrokeStyle::setMarkerColor(SPObject *marker, int loc, SPItem *item)
+{
+
+ if (!item || !marker) {
+ return;
+ }
+
+ Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+ gboolean colorStock = prefs->getBool("/options/markers/colorStockMarkers", true);
+ gboolean colorCustom = prefs->getBool("/options/markers/colorCustomMarkers", false);
+ const gchar *stock = marker->getRepr()->attribute("inkscape:isstock");
+ gboolean isStock = (stock && !strcmp(stock,"true"));
+
+ if (isStock ? !colorStock : !colorCustom) {
+ return;
+ }
+
+ // Check if we need to fork this marker
+ marker = forkMarker(marker, loc, item);
+
+ Inkscape::XML::Node *repr = marker->getRepr()->firstChild();
+ if (!repr) {
+ return;
+ };
+
+ // Current line style
+ SPCSSAttr *css_item = sp_css_attr_from_object(item, SP_STYLE_FLAG_ALWAYS);
+ const char *lstroke = getItemColorForMarker(item, FOR_STROKE, loc);
+ const char *lstroke_opacity = sp_repr_css_property(css_item, "stroke-opacity", "1");
+ const char *lfill = getItemColorForMarker(item, FOR_FILL, loc);
+ const char *lfill_opacity = sp_repr_css_property(css_item, "fill-opacity", "1");
+
+ // Current marker style
+ SPCSSAttr *css_marker = sp_css_attr_from_object(marker->firstChild(), SP_STYLE_FLAG_ALWAYS);
+ const char *mfill = sp_repr_css_property(css_marker, "fill", "none");
+ const char *mstroke = sp_repr_css_property(css_marker, "fill", "none");
+
+ // Create new marker style with the lines stroke
+ SPCSSAttr *css = sp_repr_css_attr_new();
+
+ sp_repr_css_set_property(css, "stroke", lstroke);
+ sp_repr_css_set_property(css, "stroke-opacity", lstroke_opacity);
+
+ if (strcmp(lfill, "none") ) {
+ // 1. If the line has fill, use that for the marker fill
+ sp_repr_css_set_property(css, "fill", lfill);
+ sp_repr_css_set_property(css, "fill-opacity", lfill_opacity);
+ }
+ else if (mfill && mstroke && !strcmp(mfill, mstroke) && mfill[0] == '#' && strcmp(mfill, "#ffffff")) {
+ // 2. If the marker has same fill and stroke assume its solid. use line stroke for both fill and stroke the line stroke
+ sp_repr_css_set_property(css, "fill", lstroke);
+ sp_repr_css_set_property(css, "fill-opacity", lstroke_opacity);
+ }
+ else if (mfill && mfill[0] == '#' && strcmp(mfill, "#000000")) {
+ // 3. If the marker has fill color, use the marker fill color
+ sp_repr_css_set_property(css, "fill", mfill);
+ //sp_repr_css_set_property(css, "fill-opacity", mfill_opacity);
+ }
+
+ sp_repr_css_change_recursive(marker->firstChild()->getRepr(), css, "style");
+
+ // Tell the combos to update its image cache of this marker
+ gchar const *mid = marker->getRepr()->attribute("id");
+ startMarkerCombo->update_marker_image(mid);
+ midMarkerCombo->update_marker_image(mid);
+ endMarkerCombo->update_marker_image(mid);
+
+ sp_repr_css_attr_unref(css);
+ css = nullptr;
+
+
+}
+
+/*
+ * Get the fill or stroke color of the item
+ * If its a gradient, then return first or last stop color
+ */
+const char *
+StrokeStyle::getItemColorForMarker(SPItem *item, Inkscape::PaintTarget fill_or_stroke, int loc)
+{
+ SPCSSAttr *css_item = sp_css_attr_from_object(item, SP_STYLE_FLAG_ALWAYS);
+ const char *color;
+ if (fill_or_stroke == FOR_FILL)
+ color = sp_repr_css_property(css_item, "fill", "none");
+ else
+ color = sp_repr_css_property(css_item, "stroke", "none");
+
+ if (!strncmp (color, "url(", 4)) {
+ // If the item has a gradient use the first stop color for the marker
+
+ SPGradient *grad = getGradient(item, fill_or_stroke);
+ if (grad) {
+ SPGradient *vector = grad->getVector(FALSE);
+ SPStop *stop = vector->getFirstStop();
+ if (loc == SP_MARKER_LOC_END) {
+ stop = sp_last_stop(vector);
+ }
+ if (stop) {
+ guint32 const c1 = stop->get_rgba32();
+ gchar c[64];
+ sp_svg_write_color(c, sizeof(c), c1);
+ color = g_strdup(c);
+ //lstroke_opacity = Glib::ustring::format(stop->opacity).c_str();
+ }
+ }
+ }
+ return color;
+}
+/**
+ * Sets selector widgets' dash style from an SPStyle object.
+ */
+void
+StrokeStyle::setDashSelectorFromStyle(Inkscape::UI::Widget::DashSelector *dsel, SPStyle *style)
+{
+ if (!style->stroke_dasharray.values.empty()) {
+ double d[64];
+ size_t len = MIN(style->stroke_dasharray.values.size(), 64);
+ /* Set dash */
+ Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+ gboolean scale = prefs->getBool("/options/dash/scale", true);
+ double scaledash = 1.0;
+ if (scale) {
+ scaledash = style->stroke_width.computed;
+ }
+ for (unsigned i = 0; i < len; i++) {
+ if (style->stroke_width.computed != 0)
+ d[i] = style->stroke_dasharray.values[i].value / scaledash;
+ else
+ d[i] = style->stroke_dasharray.values[i].value; // is there a better thing to do for stroke_width==0?
+ }
+ dsel->set_dash(len, d,
+ style->stroke_width.computed != 0 ? style->stroke_dashoffset.value / scaledash
+ : style->stroke_dashoffset.value);
+ } else {
+ dsel->set_dash(0, nullptr, 0.0);
+ }
+}
+
+/**
+ * Sets the join type for a line, and updates the stroke style widget's buttons
+ */
+void
+StrokeStyle::setJoinType (unsigned const jointype)
+{
+ Gtk::RadioButton *tb = nullptr;
+ switch (jointype) {
+ case SP_STROKE_LINEJOIN_MITER:
+ tb = joinMiter;
+ break;
+ case SP_STROKE_LINEJOIN_ROUND:
+ tb = joinRound;
+ break;
+ case SP_STROKE_LINEJOIN_BEVEL:
+ tb = joinBevel;
+ break;
+ default:
+ // Should not happen
+ std::cerr << "StrokeStyle::setJoinType(): Invalid value: " << jointype << std::endl;
+ tb = joinMiter;
+ break;
+ }
+ setJoinButtons(tb);
+}
+
+/**
+ * Sets the cap type for a line, and updates the stroke style widget's buttons
+ */
+void
+StrokeStyle::setCapType (unsigned const captype)
+{
+ Gtk::RadioButton *tb = nullptr;
+ switch (captype) {
+ case SP_STROKE_LINECAP_BUTT:
+ tb = capButt;
+ break;
+ case SP_STROKE_LINECAP_ROUND:
+ tb = capRound;
+ break;
+ case SP_STROKE_LINECAP_SQUARE:
+ tb = capSquare;
+ break;
+ default:
+ // Should not happen
+ std::cerr << "StrokeStyle::setCapType(): Invalid value: " << captype << std::endl;
+ tb = capButt;
+ break;
+ }
+ setCapButtons(tb);
+}
+
+/**
+ * Sets the cap type for a line, and updates the stroke style widget's buttons
+ */
+void
+StrokeStyle::setPaintOrder (gchar const *paint_order)
+{
+ Gtk::RadioButton *tb = paintOrderFSM;
+
+ SPIPaintOrder temp;
+ temp.read( paint_order );
+
+ if (temp.layer[0] != SP_CSS_PAINT_ORDER_NORMAL) {
+
+ if (temp.layer[0] == SP_CSS_PAINT_ORDER_FILL) {
+ if (temp.layer[1] == SP_CSS_PAINT_ORDER_STROKE) {
+ tb = paintOrderFSM;
+ } else {
+ tb = paintOrderFMS;
+ }
+ } else if (temp.layer[0] == SP_CSS_PAINT_ORDER_STROKE) {
+ if (temp.layer[1] == SP_CSS_PAINT_ORDER_FILL) {
+ tb = paintOrderSFM;
+ } else {
+ tb = paintOrderSMF;
+ }
+ } else {
+ if (temp.layer[1] == SP_CSS_PAINT_ORDER_STROKE) {
+ tb = paintOrderMSF;
+ } else {
+ tb = paintOrderMFS;
+ }
+ }
+
+ }
+ setPaintOrderButtons(tb);
+}
+
+/**
+ * Callback for when stroke style widget is updated, including markers, cap type,
+ * join type, etc.
+ */
+void
+StrokeStyle::updateLine()
+{
+ if (update) {
+ return;
+ }
+
+ update = true;
+
+ Inkscape::Selection *sel = desktop ? desktop->getSelection() : nullptr;
+
+ FillOrStroke kind = GPOINTER_TO_INT(get_data("kind")) ? FILL : STROKE;
+
+ // create temporary style
+ SPStyle query(SP_ACTIVE_DOCUMENT);
+ // query into it
+ int result_sw = sp_desktop_query_style (SP_ACTIVE_DESKTOP, &query, QUERY_STYLE_PROPERTY_STROKEWIDTH);
+ int result_ml = sp_desktop_query_style (SP_ACTIVE_DESKTOP, &query, QUERY_STYLE_PROPERTY_STROKEMITERLIMIT);
+ int result_cap = sp_desktop_query_style (SP_ACTIVE_DESKTOP, &query, QUERY_STYLE_PROPERTY_STROKECAP);
+ int result_join = sp_desktop_query_style (SP_ACTIVE_DESKTOP, &query, QUERY_STYLE_PROPERTY_STROKEJOIN);
+
+ int result_order = sp_desktop_query_style (SP_ACTIVE_DESKTOP, &query, QUERY_STYLE_PROPERTY_PAINTORDER);
+
+ SPIPaint &targPaint = *query.getFillOrStroke(kind == FILL);
+
+ if (!sel || sel->isEmpty()) {
+ // Nothing selected, grey-out all controls in the stroke-style dialog
+ table->set_sensitive(false);
+
+ update = false;
+
+ return;
+ } else {
+ table->set_sensitive(true);
+
+ if (result_sw == QUERY_STYLE_MULTIPLE_AVERAGED) {
+ unitSelector->setUnit("%");
+ } else {
+ // same width, or only one object; no sense to keep percent, switch to absolute
+ Inkscape::Util::Unit const *tempunit = unitSelector->getUnit();
+ if (tempunit->type != Inkscape::Util::UNIT_TYPE_LINEAR) {
+ unitSelector->setUnit(SP_ACTIVE_DESKTOP->getNamedView()->display_units->abbr);
+ }
+ }
+
+ Inkscape::Util::Unit const *unit = unitSelector->getUnit();
+
+ if (unit->type == Inkscape::Util::UNIT_TYPE_LINEAR) {
+ double avgwidth = Inkscape::Util::Quantity::convert(query.stroke_width.computed, "px", unit);
+ (*widthAdj)->set_value(avgwidth);
+ } else {
+ (*widthAdj)->set_value(100);
+ }
+
+ // if none of the selected objects has a stroke, than quite some controls should be disabled
+ // The markers might still be shown though, so these will not be disabled
+ bool enabled = (result_sw != QUERY_STYLE_NOTHING) && !targPaint.isNoneSet();
+ /* No objects stroked, set insensitive */
+ joinMiter->set_sensitive(enabled);
+ joinRound->set_sensitive(enabled);
+ joinBevel->set_sensitive(enabled);
+
+ miterLimitSpin->set_sensitive(enabled);
+
+ capButt->set_sensitive(enabled);
+ capRound->set_sensitive(enabled);
+ capSquare->set_sensitive(enabled);
+
+ dashSelector->set_sensitive(enabled);
+ }
+
+ if (result_ml != QUERY_STYLE_NOTHING)
+ (*miterLimitAdj)->set_value(query.stroke_miterlimit.value); // TODO: reflect averagedness?
+
+ using Inkscape::is_query_style_updateable;
+ if (! is_query_style_updateable(result_join)) {
+ setJoinType(query.stroke_linejoin.value);
+ } else {
+ setJoinButtons(nullptr);
+ }
+
+ if (! is_query_style_updateable(result_cap)) {
+ setCapType (query.stroke_linecap.value);
+ } else {
+ setCapButtons(nullptr);
+ }
+
+ if (! is_query_style_updateable(result_order)) {
+ setPaintOrder (query.paint_order.value);
+ } else {
+ setPaintOrder (nullptr);
+ }
+
+ std::vector<SPItem*> const objects(sel->items().begin(), sel->items().end());
+ if (objects.size()) {
+ SPObject *const object = objects[0];
+ SPStyle *const style = object->style;
+ /* Markers */
+ updateAllMarkers(objects, true); // FIXME: make this desktop query too
+
+ /* Dash */
+ setDashSelectorFromStyle(dashSelector, style); // FIXME: make this desktop query too
+ }
+ table->set_sensitive(true);
+
+ update = false;
+}
+
+/**
+ * Sets a line's dash properties in a CSS style object.
+ */
+void
+StrokeStyle::setScaledDash(SPCSSAttr *css,
+ int ndash, double *dash, double offset,
+ double scale)
+{
+ if (ndash > 0) {
+ Inkscape::CSSOStringStream osarray;
+ for (int i = 0; i < ndash; i++) {
+ osarray << dash[i] * scale;
+ if (i < (ndash - 1)) {
+ osarray << ",";
+ }
+ }
+ sp_repr_css_set_property(css, "stroke-dasharray", osarray.str().c_str());
+
+ Inkscape::CSSOStringStream osoffset;
+ osoffset << offset * scale;
+ sp_repr_css_set_property(css, "stroke-dashoffset", osoffset.str().c_str());
+ } else {
+ sp_repr_css_set_property(css, "stroke-dasharray", "none");
+ sp_repr_css_set_property(css, "stroke-dashoffset", nullptr);
+ }
+}
+
+static inline double calcScaleLineWidth(const double width_typed, SPItem *const item, Inkscape::Util::Unit const *const unit)
+{
+ if (unit->type == Inkscape::Util::UNIT_TYPE_LINEAR) {
+ return Inkscape::Util::Quantity::convert(width_typed, unit, "px");
+ } else { // percentage
+ const gdouble old_w = item->style->stroke_width.computed;
+ return old_w * width_typed / 100;
+ }
+}
+
+/**
+ * Sets line properties like width, dashes, markers, etc. on all currently selected items.
+ */
+void
+StrokeStyle::scaleLine()
+{
+ if (!desktop) {
+ return;
+ }
+
+ if (update) {
+ return;
+ }
+
+ update = true;
+
+ SPDocument *document = desktop->getDocument();
+ Inkscape::Selection *selection = desktop->getSelection();
+ auto items= selection->items();
+
+ /* TODO: Create some standardized method */
+ SPCSSAttr *css = sp_repr_css_attr_new();
+
+ if (!items.empty()) {
+ double width_typed = (*widthAdj)->get_value();
+ double const miterlimit = (*miterLimitAdj)->get_value();
+
+ Inkscape::Util::Unit const *const unit = unitSelector->getUnit();
+
+ double *dash, offset;
+ int ndash;
+ dashSelector->get_dash(&ndash, &dash, &offset);
+
+ for(auto i=items.begin();i!=items.end();++i){
+ /* Set stroke width */
+ const double width = calcScaleLineWidth(width_typed, (*i), unit);
+
+ {
+ Inkscape::CSSOStringStream os_width;
+ os_width << width;
+ sp_repr_css_set_property(css, "stroke-width", os_width.str().c_str());
+ }
+
+ {
+ Inkscape::CSSOStringStream os_ml;
+ os_ml << miterlimit;
+ sp_repr_css_set_property(css, "stroke-miterlimit", os_ml.str().c_str());
+ }
+
+ /* Set dash */
+ Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+ gboolean scale = prefs->getBool("/options/dash/scale", true);
+ if (scale) {
+ setScaledDash(css, ndash, dash, offset, width);
+ }
+ else {
+ setScaledDash(css, ndash, dash, offset, document->getDocumentScale()[0]);
+ }
+ sp_desktop_apply_css_recursive ((*i), css, true);
+ }
+
+ g_free(dash);
+
+ if (unit->type != Inkscape::Util::UNIT_TYPE_LINEAR) {
+ // reset to 100 percent
+ (*widthAdj)->set_value(100.0);
+ }
+
+ }
+
+ // we have already changed the items, so set style without changing selection
+ // FIXME: move the above stroke-setting stuff, including percentages, to desktop-style
+ sp_desktop_set_style (desktop, css, false);
+
+ sp_repr_css_attr_unref(css);
+ css = nullptr;
+
+ DocumentUndo::done(document, SP_VERB_DIALOG_FILL_STROKE,
+ _("Set stroke style"));
+
+ update = false;
+}
+
+/**
+ * Callback for when the stroke style's width changes.
+ * Causes all line styles to be applied to all selected items.
+ */
+void
+StrokeStyle::widthChangedCB()
+{
+ if (update) {
+ return;
+ }
+
+ scaleLine();
+}
+
+/**
+ * Callback for when the stroke style's miterlimit changes.
+ * Causes all line styles to be applied to all selected items.
+ */
+void
+StrokeStyle::miterLimitChangedCB()
+{
+ if (update) {
+ return;
+ }
+
+ scaleLine();
+}
+
+/**
+ * Callback for when the stroke style's dash changes.
+ * Causes all line styles to be applied to all selected items.
+ */
+
+void
+StrokeStyle::lineDashChangedCB()
+{
+ if (update) {
+ return;
+ }
+
+ scaleLine();
+}
+
+/**
+ * This routine handles toggle events for buttons in the stroke style dialog.
+ *
+ * When activated, this routine gets the data for the various widgets, and then
+ * calls the respective routines to update css properties, etc.
+ *
+ */
+void StrokeStyle::buttonToggledCB(StrokeStyleButton *tb, StrokeStyle *spw)
+{
+ if (spw->update) {
+ return;
+ }
+
+ if (tb->get_active()) {
+ if (tb->get_button_type() == STROKE_STYLE_BUTTON_JOIN) {
+ spw->miterLimitSpin->set_sensitive(!strcmp(tb->get_stroke_style(), "miter"));
+ }
+
+ /* TODO: Create some standardized method */
+ SPCSSAttr *css = sp_repr_css_attr_new();
+
+ switch (tb->get_button_type()) {
+ case STROKE_STYLE_BUTTON_JOIN:
+ sp_repr_css_set_property(css, "stroke-linejoin", tb->get_stroke_style());
+ sp_desktop_set_style (spw->desktop, css);
+ spw->setJoinButtons(tb);
+ break;
+ case STROKE_STYLE_BUTTON_CAP:
+ sp_repr_css_set_property(css, "stroke-linecap", tb->get_stroke_style());
+ sp_desktop_set_style (spw->desktop, css);
+ spw->setCapButtons(tb);
+ break;
+ case STROKE_STYLE_BUTTON_ORDER:
+ sp_repr_css_set_property(css, "paint-order", tb->get_stroke_style());
+ sp_desktop_set_style (spw->desktop, css);
+ //spw->setPaintButtons(tb);
+ }
+
+ sp_repr_css_attr_unref(css);
+ css = nullptr;
+
+ DocumentUndo::done(spw->desktop->getDocument(), SP_VERB_DIALOG_FILL_STROKE, _("Set stroke style"));
+ }
+}
+
+/**
+ * Updates the join style toggle buttons
+ */
+void
+StrokeStyle::setJoinButtons(Gtk::ToggleButton *active)
+{
+ joinMiter->set_active(active == joinMiter);
+ miterLimitSpin->set_sensitive(active == joinMiter);
+ joinRound->set_active(active == joinRound);
+ joinBevel->set_active(active == joinBevel);
+}
+
+/**
+ * Updates the cap style toggle buttons
+ */
+void
+StrokeStyle::setCapButtons(Gtk::ToggleButton *active)
+{
+ capButt->set_active(active == capButt);
+ capRound->set_active(active == capRound);
+ capSquare->set_active(active == capSquare);
+}
+
+
+/**
+ * Updates the paint order style toggle buttons
+ */
+void
+StrokeStyle::setPaintOrderButtons(Gtk::ToggleButton *active)
+{
+ paintOrderFSM->set_active(active == paintOrderFSM);
+ paintOrderSFM->set_active(active == paintOrderSFM);
+ paintOrderFMS->set_active(active == paintOrderFMS);
+ paintOrderMFS->set_active(active == paintOrderMFS);
+ paintOrderSMF->set_active(active == paintOrderSMF);
+ paintOrderMSF->set_active(active == paintOrderMSF);
+}
+
+
+/**
+ * Recursively builds a simple list from an arbitrarily complex selection
+ * of items and grouped items
+ */
+static void buildGroupedItemList(SPObject *element, std::vector<SPObject*> &simple_list)
+{
+ if (SP_IS_GROUP(element)) {
+ for (SPObject *i = element->firstChild(); i; i = i->getNext()) {
+ buildGroupedItemList(i, simple_list);
+ }
+ } else {
+ simple_list.push_back(element);
+ }
+}
+
+
+/**
+ * Updates the marker combobox to highlight the appropriate marker and scroll to
+ * that marker.
+ */
+void
+StrokeStyle::updateAllMarkers(std::vector<SPItem*> const &objects, bool skip_undo)
+{
+ struct { MarkerComboBox *key; int loc; } const keyloc[] = {
+ { startMarkerCombo, SP_MARKER_LOC_START },
+ { midMarkerCombo, SP_MARKER_LOC_MID },
+ { endMarkerCombo, SP_MARKER_LOC_END }
+ };
+
+ bool all_texts = true;
+
+ auto simplified_list = std::vector<SPObject *>();
+ for (SPItem *item : objects) {
+ buildGroupedItemList(item, simplified_list);
+ }
+
+ for (SPObject *object : simplified_list) {
+ if (!SP_IS_TEXT(object)) {
+ all_texts = false;
+ break;
+ }
+ }
+
+ // We show markers of the last object in the list only
+ // FIXME: use the first in the list that has the marker of each type, if any
+
+ // -1 means prefs haven't been queried yet
+ int update = -1;
+
+ for (auto const &markertype : keyloc) {
+ // For all three marker types,
+
+ // find the corresponding combobox item
+ MarkerComboBox *combo = markertype.key;
+
+ // Quit if we're in update state
+ if (combo->update()) {
+ return;
+ }
+
+ // Per SVG spec, text objects cannot have markers; disable combobox if only texts are selected
+ combo->set_sensitive(!all_texts);
+
+ SPObject *marker = nullptr;
+
+ if (!all_texts) {
+ for (SPObject *object : simplified_list) {
+ char const *value = object->style->marker_ptrs[markertype.loc]->value();
+
+ // If the object has this type of markers,
+ if (value == nullptr)
+ continue;
+
+ // Extract the name of the marker that the object uses
+ marker = getMarkerObj(value, object->document);
+
+ // Set the marker color
+ if (update < 0) {
+ // query prefs (only once)
+ Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+ update = prefs->getBool("/options/markers/colorUpdateMarkers", true) ? 1 : 0;
+ }
+
+ if (update > 0) {
+ setMarkerColor(marker, markertype.loc, SP_ITEM(object));
+
+ if (!skip_undo) {
+ SPDocument *document = desktop->getDocument();
+ DocumentUndo::maybeDone(document, "UaM", SP_VERB_DIALOG_FILL_STROKE,
+ _("Set marker color"));
+ }
+ }
+ }
+ }
+
+ // Scroll the combobox to that marker
+ combo->set_current(marker);
+ }
+
+}
+
+
+
+} // namespace Inkscape
+
+
+/*
+ Local Variables:
+ mode:c++
+ c-file-style:"stroustrup"
+ c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
+ indent-tabs-mode:nil
+ fill-column:99
+ End:
+*/
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :
diff --git a/src/widgets/stroke-style.h b/src/widgets/stroke-style.h
new file mode 100644
index 0000000..d11c1ae
--- /dev/null
+++ b/src/widgets/stroke-style.h
@@ -0,0 +1,227 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/**
+ * @file
+ * Widgets used in the stroke style dialog.
+ */
+/* Author:
+ * Lauris Kaplinski <lauris@ximian.com>
+ * Jon A. Cruz <jon@joncruz.org>
+ *
+ * Copyright (C) 2010 Jon A. Cruz
+ * Copyright (C) 2001 Ximian, Inc.
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+// WHOA! talk about header bloat!
+
+#ifndef SEEN_DIALOGS_STROKE_STYLE_H
+#define SEEN_DIALOGS_STROKE_STYLE_H
+
+#include <glibmm/i18n.h>
+#include <gtkmm/grid.h>
+#include <gtkmm/radiobutton.h>
+
+#include "desktop-style.h"
+#include "desktop.h"
+#include "document-undo.h"
+#include "fill-n-stroke-factory.h"
+#include "fill-style.h" // to get sp_fill_style_widget_set_desktop
+#include "gradient-chemistry.h"
+
+#include "inkscape.h"
+#include "io/sys.h"
+#include "path-prefix.h"
+#include "preferences.h"
+#include "selection.h"
+#include "verbs.h"
+
+#include "display/canvas-bpath.h" // for SP_STROKE_LINEJOIN_*
+#include "display/drawing.h"
+
+#include "helper/stock-items.h"
+
+#include "style.h"
+
+#include "svg/css-ostringstream.h"
+
+#include "ui/cache/svg_preview_cache.h"
+#include "ui/dialog-events.h"
+#include "ui/icon-names.h"
+#include "ui/widget/spinbutton.h"
+
+#include "widgets/paint-selector.h"
+#include "widgets/spw-utilities.h"
+#include "widgets/stroke-marker-selector.h"
+
+#include "xml/repr.h"
+
+namespace Gtk {
+class Widget;
+class Container;
+}
+
+namespace Inkscape {
+ namespace Util {
+ class Unit;
+ }
+ namespace UI {
+ namespace Widget {
+ class DashSelector;
+ class UnitMenu;
+ }
+ }
+}
+
+struct { gchar const *key; gint value; } const SPMarkerNames[] = {
+ {"marker-all", SP_MARKER_LOC},
+ {"marker-start", SP_MARKER_LOC_START},
+ {"marker-mid", SP_MARKER_LOC_MID},
+ {"marker-end", SP_MARKER_LOC_END},
+ {"", SP_MARKER_LOC_QTY},
+ {nullptr, -1}
+};
+
+/**
+ * Creates an instance of a paint style widget.
+ */
+Gtk::Widget *sp_stroke_style_paint_widget_new();
+
+/**
+ * Creates an instance of a line style widget.
+ */
+Gtk::Widget *sp_stroke_style_line_widget_new();
+
+/**
+ * Switches a line or paint style widget to track the given desktop.
+ */
+void sp_stroke_style_widget_set_desktop(Gtk::Widget *widget, SPDesktop *desktop);
+
+SPObject *getMarkerObj(gchar const *n, SPDocument *doc);
+
+namespace Inkscape {
+class StrokeStyleButton;
+
+class StrokeStyle : public Gtk::Box
+{
+public:
+ StrokeStyle();
+ ~StrokeStyle() override;
+ void setDesktop(SPDesktop *desktop);
+
+private:
+ /** List of valid types for the stroke-style radio-button widget */
+ enum StrokeStyleButtonType {
+ STROKE_STYLE_BUTTON_JOIN, ///< A button to set the line-join style
+ STROKE_STYLE_BUTTON_CAP, ///< A button to set the line-cap style
+ STROKE_STYLE_BUTTON_ORDER ///< A button to set the paint-order style
+ };
+
+ /**
+ * A custom radio-button for setting the stroke style. It can be configured
+ * to set either the join or cap style by setting the button_type field.
+ */
+ class StrokeStyleButton : public Gtk::RadioButton {
+ public:
+ StrokeStyleButton(Gtk::RadioButtonGroup &grp,
+ char const *icon,
+ StrokeStyleButtonType button_type,
+ gchar const *stroke_style);
+
+ /** Get the type (line/cap) of the stroke-style button */
+ inline StrokeStyleButtonType get_button_type() {return button_type;}
+
+ /** Get the stroke style attribute associated with the button */
+ inline gchar const * get_stroke_style() {return stroke_style;}
+
+ private:
+ StrokeStyleButtonType button_type; ///< The type (line/cap) of the button
+ gchar const *stroke_style; ///< The stroke style associated with the button
+ };
+
+ void updateLine();
+ void updateAllMarkers(std::vector<SPItem*> const &objects, bool skip_undo = false);
+ void updateMarkerHist(SPMarkerLoc const which);
+ void setDashSelectorFromStyle(Inkscape::UI::Widget::DashSelector *dsel, SPStyle *style);
+ void setJoinType (unsigned const jointype);
+ void setCapType (unsigned const captype);
+ void setPaintOrder (gchar const *paint_order);
+ void setJoinButtons(Gtk::ToggleButton *active);
+ void setCapButtons(Gtk::ToggleButton *active);
+ void setPaintOrderButtons(Gtk::ToggleButton *active);
+ void scaleLine();
+ void setScaledDash(SPCSSAttr *css, int ndash, double *dash, double offset, double scale);
+ void setMarkerColor(SPObject *marker, int loc, SPItem *item);
+ SPObject *forkMarker(SPObject *marker, int loc, SPItem *item);
+ const char *getItemColorForMarker(SPItem *item, Inkscape::PaintTarget fill_or_stroke, int loc);
+
+ StrokeStyleButton * makeRadioButton(Gtk::RadioButtonGroup &grp,
+ char const *icon,
+ Gtk::HBox *hb,
+ StrokeStyleButtonType button_type,
+ gchar const *stroke_style);
+
+ // Callback functions
+ void selectionModifiedCB(guint flags);
+ void selectionChangedCB();
+ void widthChangedCB();
+ void miterLimitChangedCB();
+ void lineDashChangedCB();
+ void unitChangedCB();
+ bool shouldMarkersBeUpdated();
+ static void markerSelectCB(MarkerComboBox *marker_combo, StrokeStyle *spw, SPMarkerLoc const which);
+ static void buttonToggledCB(StrokeStyleButton *tb, StrokeStyle *spw);
+
+
+ MarkerComboBox *startMarkerCombo;
+ MarkerComboBox *midMarkerCombo;
+ MarkerComboBox *endMarkerCombo;
+ Gtk::Grid *table;
+ Glib::RefPtr<Gtk::Adjustment> *widthAdj;
+ Glib::RefPtr<Gtk::Adjustment> *miterLimitAdj;
+ Inkscape::UI::Widget::SpinButton *miterLimitSpin;
+ Inkscape::UI::Widget::SpinButton *widthSpin;
+ Inkscape::UI::Widget::UnitMenu *unitSelector;
+ StrokeStyleButton *joinMiter;
+ StrokeStyleButton *joinRound;
+ StrokeStyleButton *joinBevel;
+ StrokeStyleButton *capButt;
+ StrokeStyleButton *capRound;
+ StrokeStyleButton *capSquare;
+ StrokeStyleButton *paintOrderFSM;
+ StrokeStyleButton *paintOrderSFM;
+ StrokeStyleButton *paintOrderFMS;
+ StrokeStyleButton *paintOrderMFS;
+ StrokeStyleButton *paintOrderSMF;
+ StrokeStyleButton *paintOrderMSF;
+ Inkscape::UI::Widget::DashSelector *dashSelector;
+
+ gboolean update;
+ SPDesktop *desktop;
+ sigc::connection selectChangedConn;
+ sigc::connection selectModifiedConn;
+ sigc::connection startMarkerConn;
+ sigc::connection midMarkerConn;
+ sigc::connection endMarkerConn;
+ sigc::connection unitChangedConn;
+
+ Inkscape::Util::Unit const *_old_unit;
+
+ void _handleDocumentReplaced(SPDesktop *, SPDocument *);
+ sigc::connection _document_replaced_connection;
+};
+
+} // namespace Inkscape
+
+#endif // SEEN_DIALOGS_STROKE_STYLE_H
+
+/*
+ Local Variables:
+ mode:c++
+ c-file-style:"stroustrup"
+ c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
+ indent-tabs-mode:nil
+ fill-column:99
+ End:
+*/
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :
diff --git a/src/widgets/style-utils.h b/src/widgets/style-utils.h
new file mode 100644
index 0000000..1557218
--- /dev/null
+++ b/src/widgets/style-utils.h
@@ -0,0 +1,35 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/** @file
+ * Common utility functions for manipulating style.
+ *//*
+ * Authors:
+ * see git history
+ * Shlomi Fish <shlomif@cpan.org>
+ *
+ * Copyright (C) 2016 Authors
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#ifndef SEEN_DIALOGS_STYLE_UTILS_H
+#define SEEN_DIALOGS_STYLE_UTILS_H
+
+#include "desktop-style.h"
+
+namespace Inkscape {
+ inline bool is_query_style_updateable(const int style) {
+ return (style == QUERY_STYLE_MULTIPLE_DIFFERENT || style == QUERY_STYLE_NOTHING);
+ }
+} // namespace Inkscape
+
+#endif // SEEN_DIALOGS_STYLE_UTILS_H
+
+/*
+ Local Variables:
+ mode:c++
+ c-file-style:"stroustrup"
+ c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
+ indent-tabs-mode:nil
+ fill-column:99
+ End:
+*/
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :
diff --git a/src/widgets/swatch-selector.cpp b/src/widgets/swatch-selector.cpp
new file mode 100644
index 0000000..aeead1c
--- /dev/null
+++ b/src/widgets/swatch-selector.cpp
@@ -0,0 +1,168 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/** @file
+ * TODO: insert short description here
+ *//*
+ * Authors: see git history
+ *
+ * Copyright (C) 2018 Authors
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#include "swatch-selector.h"
+
+#include <glibmm/i18n.h>
+
+#include "document-undo.h"
+#include "document.h"
+#include "gradient-chemistry.h"
+#include "gradient-selector.h"
+#include "verbs.h"
+
+#include "object/sp-stop.h"
+
+#include "svg/css-ostringstream.h"
+#include "svg/svg-color.h"
+
+#include "ui/widget/color-notebook.h"
+
+#include "xml/node.h"
+
+namespace Inkscape
+{
+namespace Widgets
+{
+
+SwatchSelector::SwatchSelector() :
+ Gtk::VBox(),
+ _gsel(nullptr),
+ _updating_color(false)
+{
+ using Inkscape::UI::Widget::ColorNotebook;
+
+ GtkWidget *gsel = sp_gradient_selector_new();
+ _gsel = SP_GRADIENT_SELECTOR(gsel);
+ g_object_set_data( G_OBJECT(gobj()), "base", this );
+ _gsel->setMode(SPGradientSelector::MODE_SWATCH);
+
+ gtk_widget_show(gsel);
+
+ pack_start(*Gtk::manage(Glib::wrap(gsel)));
+
+ Gtk::Widget *color_selector = Gtk::manage(new ColorNotebook(_selected_color));
+ color_selector->show();
+ pack_start(*color_selector);
+
+ //_selected_color.signal_grabbed.connect(sigc::mem_fun(this, &SwatchSelector::_grabbedCb));
+ _selected_color.signal_dragged.connect(sigc::mem_fun(this, &SwatchSelector::_changedCb));
+ _selected_color.signal_released.connect(sigc::mem_fun(this, &SwatchSelector::_changedCb));
+ // signal_changed doesn't get called if updating shape with colour.
+ //_selected_color.signal_changed.connect(sigc::mem_fun(this, &SwatchSelector::_changedCb));
+}
+
+SwatchSelector::~SwatchSelector()
+{
+ _gsel = nullptr;
+}
+
+SPGradientSelector *SwatchSelector::getGradientSelector()
+{
+ return _gsel;
+}
+
+void SwatchSelector::_changedCb()
+{
+ if (_updating_color) {
+ return;
+ }
+ // TODO might have to block cycles
+
+ if (_gsel && _gsel->getVector()) {
+ SPGradient *gradient = _gsel->getVector();
+ SPGradient *ngr = sp_gradient_ensure_vector_normalized(gradient);
+ if (ngr != gradient) {
+ /* Our master gradient has changed */
+ // TODO replace with proper - sp_gradient_vector_widget_load_gradient(GTK_WIDGET(swsel->_gsel), ngr);
+ }
+
+ ngr->ensureVector();
+
+
+ SPStop* stop = ngr->getFirstStop();
+ if (stop) {
+ SPColor color = _selected_color.color();
+ gfloat alpha = _selected_color.alpha();
+ guint32 rgb = color.toRGBA32( 0x00 );
+
+ // TODO replace with generic shared code that also handles icc-color
+ Inkscape::CSSOStringStream os;
+ gchar c[64];
+ sp_svg_write_color(c, sizeof(c), rgb);
+ os << "stop-color:" << c << ";stop-opacity:" << static_cast<gdouble>(alpha) <<";";
+ stop->setAttribute("style", os.str());
+
+ DocumentUndo::done(ngr->document, SP_VERB_CONTEXT_GRADIENT,
+ _("Change swatch color"));
+ }
+ }
+}
+
+void SwatchSelector::connectGrabbedHandler( GCallback handler, void *data )
+{
+ GObject* obj = G_OBJECT(_gsel);
+ g_signal_connect( obj, "grabbed", handler, data );
+}
+
+void SwatchSelector::connectDraggedHandler( GCallback handler, void *data )
+{
+ GObject* obj = G_OBJECT(_gsel);
+ g_signal_connect( obj, "dragged", handler, data );
+}
+
+void SwatchSelector::connectReleasedHandler( GCallback handler, void *data )
+{
+ GObject* obj = G_OBJECT(_gsel);
+ g_signal_connect( obj, "released", handler, data );
+}
+
+void SwatchSelector::connectchangedHandler( GCallback handler, void *data )
+{
+ GObject* obj = G_OBJECT(_gsel);
+ g_signal_connect( obj, "changed", handler, data );
+}
+
+void SwatchSelector::setVector(SPDocument */*doc*/, SPGradient *vector)
+{
+ //GtkVBox * box = gobj();
+ _gsel->setVector((vector) ? vector->document : nullptr, vector);
+
+ if ( vector && vector->isSolid() ) {
+ SPStop* stop = vector->getFirstStop();
+
+ guint32 const colorVal = stop->get_rgba32();
+ _updating_color = true;
+ _selected_color.setValue(colorVal);
+ _updating_color = false;
+ // gtk_widget_show_all( GTK_WIDGET(_csel) );
+ } else {
+ //gtk_widget_hide( GTK_WIDGET(_csel) );
+ }
+
+/*
+*/
+}
+
+} // namespace Widgets
+} // namespace Inkscape
+
+
+
+/*
+ Local Variables:
+ mode:c++
+ c-file-style:"stroustrup"
+ c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
+ indent-tabs-mode:nil
+ fill-column:99
+ End:
+*/
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :
diff --git a/src/widgets/swatch-selector.h b/src/widgets/swatch-selector.h
new file mode 100644
index 0000000..88e7ad6
--- /dev/null
+++ b/src/widgets/swatch-selector.h
@@ -0,0 +1,68 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/** @file
+ * TODO: insert short description here
+ *//*
+ * Authors: see git history
+ *
+ * Copyright (C) 2018 Authors
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+#ifndef SEEN_SP_SWATCH_SELECTOR_H
+#define SEEN_SP_SWATCH_SELECTOR_H
+
+#include <gtkmm/box.h>
+#include "ui/selected-color.h"
+
+class SPDocument;
+class SPGradient;
+struct SPColorSelector;
+struct SPGradientSelector;
+
+namespace Inkscape
+{
+namespace Widgets
+{
+
+class SwatchSelector : public Gtk::VBox
+{
+public:
+ SwatchSelector();
+ ~SwatchSelector() override;
+
+ void connectGrabbedHandler( GCallback handler, void *data );
+ void connectDraggedHandler( GCallback handler, void *data );
+ void connectReleasedHandler( GCallback handler, void *data );
+ void connectchangedHandler( GCallback handler, void *data );
+
+ void setVector(SPDocument *doc, SPGradient *vector);
+
+ SPGradientSelector *getGradientSelector();
+
+private:
+ void _grabbedCb();
+ void _draggedCb();
+ void _releasedCb();
+ void _changedCb();
+
+ SPGradientSelector *_gsel;
+ Inkscape::UI::SelectedColor _selected_color;
+ bool _updating_color;
+};
+
+
+} // namespace Widgets
+} // namespace Inkscape
+
+#endif // SEEN_SP_SWATCH_SELECTOR_H
+
+/*
+ Local Variables:
+ mode:c++
+ c-file-style:"stroustrup"
+ c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
+ indent-tabs-mode:nil
+ fill-column:99
+ End:
+*/
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :
+
diff --git a/src/widgets/toolbox.cpp b/src/widgets/toolbox.cpp
new file mode 100644
index 0000000..6248dec
--- /dev/null
+++ b/src/widgets/toolbox.cpp
@@ -0,0 +1,842 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+/**
+ * @file
+ * Inkscape toolbar definitions and general utility functions.
+ * Each tool should have its own xxx-toolbar implementation file
+ */
+/* Authors:
+ * MenTaLguY <mental@rydia.net>
+ * Lauris Kaplinski <lauris@kaplinski.com>
+ * bulia byak <buliabyak@users.sf.net>
+ * Frank Felfe <innerspace@iname.com>
+ * John Cliff <simarilius@yahoo.com>
+ * David Turner <novalis@gnu.org>
+ * Josh Andler <scislac@scislac.com>
+ * Jon A. Cruz <jon@joncruz.org>
+ * Maximilian Albert <maximilian.albert@gmail.com>
+ * Tavmjong Bah <tavmjong@free.fr>
+ * Abhishek Sharma
+ * Kris De Gussem <Kris.DeGussem@gmail.com>
+ * Jabiertxo Arraiza <jabier.arraiza@marker.es>
+ *
+ * Copyright (C) 2004 David Turner
+ * Copyright (C) 2003 MenTaLguY
+ * Copyright (C) 1999-2015 authors
+ * Copyright (C) 2001-2002 Ximian, Inc.
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#include <gtkmm/box.h>
+#include <gtkmm/action.h>
+#include <gtkmm/actiongroup.h>
+#include <gtkmm/toolitem.h>
+#include <glibmm/i18n.h>
+
+#include "desktop-style.h"
+#include "desktop.h"
+#include "document-undo.h"
+#include "inkscape.h"
+#include "verbs.h"
+
+#include "ink-action.h"
+
+#include "helper/action.h"
+#include "helper/verb-action.h"
+
+#include "include/gtkmm_version.h"
+
+#include "io/resource.h"
+
+#include "object/sp-namedview.h"
+
+#include "ui/icon-names.h"
+#include "ui/tools-switch.h"
+#include "ui/uxmanager.h"
+#include "ui/widget/button.h"
+#include "ui/widget/spinbutton.h"
+#include "ui/widget/style-swatch.h"
+#include "ui/widget/unit-tracker.h"
+
+#include "widgets/spinbutton-events.h"
+#include "widgets/spw-utilities.h"
+#include "widgets/widget-sizes.h"
+
+#include "xml/attribute-record.h"
+#include "xml/node-event-vector.h"
+
+#include "ui/toolbar/arc-toolbar.h"
+#include "ui/toolbar/box3d-toolbar.h"
+#include "ui/toolbar/calligraphy-toolbar.h"
+#include "ui/toolbar/connector-toolbar.h"
+#include "ui/toolbar/dropper-toolbar.h"
+#include "ui/toolbar/eraser-toolbar.h"
+#include "ui/toolbar/gradient-toolbar.h"
+#include "ui/toolbar/lpe-toolbar.h"
+#include "ui/toolbar/mesh-toolbar.h"
+#include "ui/toolbar/measure-toolbar.h"
+#include "ui/toolbar/node-toolbar.h"
+#include "ui/toolbar/rect-toolbar.h"
+#include "ui/toolbar/paintbucket-toolbar.h"
+#include "ui/toolbar/pencil-toolbar.h"
+#include "ui/toolbar/select-toolbar.h"
+#include "ui/toolbar/snap-toolbar.h"
+#include "ui/toolbar/spray-toolbar.h"
+#include "ui/toolbar/spiral-toolbar.h"
+#include "ui/toolbar/star-toolbar.h"
+#include "ui/toolbar/tweak-toolbar.h"
+#include "ui/toolbar/text-toolbar.h"
+#include "ui/toolbar/zoom-toolbar.h"
+
+#include "toolbox.h"
+
+#include "ui/tools/tool-base.h"
+
+//#define DEBUG_TEXT
+
+using Inkscape::UI::UXManager;
+using Inkscape::DocumentUndo;
+using Inkscape::UI::ToolboxFactory;
+using Inkscape::UI::Tools::ToolBase;
+
+using Inkscape::IO::Resource::get_filename;
+using Inkscape::IO::Resource::UIS;
+
+typedef void (*SetupFunction)(GtkWidget *toolbox, SPDesktop *desktop);
+typedef void (*UpdateFunction)(SPDesktop *desktop, ToolBase *eventcontext, GtkWidget *toolbox);
+
+enum BarId {
+ BAR_TOOL = 0,
+ BAR_AUX,
+ BAR_COMMANDS,
+ BAR_SNAP,
+};
+
+#define BAR_ID_KEY "BarIdValue"
+#define HANDLE_POS_MARK "x-inkscape-pos"
+
+GtkIconSize ToolboxFactory::prefToSize( Glib::ustring const &path, int base ) {
+ static GtkIconSize sizeChoices[] = {
+ GTK_ICON_SIZE_LARGE_TOOLBAR,
+ GTK_ICON_SIZE_SMALL_TOOLBAR,
+ GTK_ICON_SIZE_DND,
+ GTK_ICON_SIZE_DIALOG
+ };
+ Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+ int index = prefs->getIntLimited( path, base, 0, G_N_ELEMENTS(sizeChoices) );
+ return sizeChoices[index];
+}
+
+Gtk::IconSize ToolboxFactory::prefToSize_mm(Glib::ustring const &path, int base)
+{
+ static Gtk::IconSize sizeChoices[] = { Gtk::ICON_SIZE_LARGE_TOOLBAR, Gtk::ICON_SIZE_SMALL_TOOLBAR,
+ Gtk::ICON_SIZE_DND, Gtk::ICON_SIZE_DIALOG };
+ Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+ int index = prefs->getIntLimited(path, base, 0, G_N_ELEMENTS(sizeChoices));
+ return sizeChoices[index];
+}
+
+static struct {
+ gchar const *type_name;
+ gchar const *data_name;
+ sp_verb_t verb;
+ sp_verb_t doubleclick_verb;
+} const tools[] = {
+ { "/tools/select", "select_tool", SP_VERB_CONTEXT_SELECT, SP_VERB_CONTEXT_SELECT_PREFS},
+ { "/tools/nodes", "node_tool", SP_VERB_CONTEXT_NODE, SP_VERB_CONTEXT_NODE_PREFS },
+ { "/tools/tweak", "tweak_tool", SP_VERB_CONTEXT_TWEAK, SP_VERB_CONTEXT_TWEAK_PREFS },
+ { "/tools/spray", "spray_tool", SP_VERB_CONTEXT_SPRAY, SP_VERB_CONTEXT_SPRAY_PREFS },
+ { "/tools/zoom", "zoom_tool", SP_VERB_CONTEXT_ZOOM, SP_VERB_CONTEXT_ZOOM_PREFS },
+ { "/tools/measure", "measure_tool", SP_VERB_CONTEXT_MEASURE, SP_VERB_CONTEXT_MEASURE_PREFS },
+ { "/tools/shapes/rect", "rect_tool", SP_VERB_CONTEXT_RECT, SP_VERB_CONTEXT_RECT_PREFS },
+ { "/tools/shapes/3dbox", "3dbox_tool", SP_VERB_CONTEXT_3DBOX, SP_VERB_CONTEXT_3DBOX_PREFS },
+ { "/tools/shapes/arc", "arc_tool", SP_VERB_CONTEXT_ARC, SP_VERB_CONTEXT_ARC_PREFS },
+ { "/tools/shapes/star", "star_tool", SP_VERB_CONTEXT_STAR, SP_VERB_CONTEXT_STAR_PREFS },
+ { "/tools/shapes/spiral", "spiral_tool", SP_VERB_CONTEXT_SPIRAL, SP_VERB_CONTEXT_SPIRAL_PREFS },
+ { "/tools/freehand/pencil", "pencil_tool", SP_VERB_CONTEXT_PENCIL, SP_VERB_CONTEXT_PENCIL_PREFS },
+ { "/tools/freehand/pen", "pen_tool", SP_VERB_CONTEXT_PEN, SP_VERB_CONTEXT_PEN_PREFS },
+ { "/tools/calligraphic", "dyna_draw_tool", SP_VERB_CONTEXT_CALLIGRAPHIC, SP_VERB_CONTEXT_CALLIGRAPHIC_PREFS },
+ { "/tools/lpetool", "lpetool_tool", SP_VERB_CONTEXT_LPETOOL, SP_VERB_CONTEXT_LPETOOL_PREFS },
+ { "/tools/eraser", "eraser_tool", SP_VERB_CONTEXT_ERASER, SP_VERB_CONTEXT_ERASER_PREFS },
+ { "/tools/paintbucket", "paintbucket_tool", SP_VERB_CONTEXT_PAINTBUCKET, SP_VERB_CONTEXT_PAINTBUCKET_PREFS },
+ { "/tools/text", "text_tool", SP_VERB_CONTEXT_TEXT, SP_VERB_CONTEXT_TEXT_PREFS },
+ { "/tools/connector","connector_tool", SP_VERB_CONTEXT_CONNECTOR, SP_VERB_CONTEXT_CONNECTOR_PREFS },
+ { "/tools/gradient", "gradient_tool", SP_VERB_CONTEXT_GRADIENT, SP_VERB_CONTEXT_GRADIENT_PREFS },
+ { "/tools/mesh", "mesh_tool", SP_VERB_CONTEXT_MESH, SP_VERB_CONTEXT_MESH_PREFS },
+ { "/tools/dropper", "dropper_tool", SP_VERB_CONTEXT_DROPPER, SP_VERB_CONTEXT_DROPPER_PREFS },
+ { nullptr, nullptr, 0, 0 }
+};
+
+static struct {
+ gchar const *type_name;
+ gchar const *data_name;
+ GtkWidget *(*create_func)(SPDesktop *desktop);
+ gchar const *ui_name;
+ gint swatch_verb_id;
+ gchar const *swatch_tool;
+ gchar const *swatch_tip;
+} const aux_toolboxes[] = {
+ { "/tools/select", "select_toolbox", Inkscape::UI::Toolbar::SelectToolbar::create, "SelectToolbar",
+ SP_VERB_INVALID, nullptr, nullptr},
+ { "/tools/nodes", "node_toolbox", Inkscape::UI::Toolbar::NodeToolbar::create, "NodeToolbar",
+ SP_VERB_INVALID, nullptr, nullptr},
+ { "/tools/tweak", "tweak_toolbox", Inkscape::UI::Toolbar::TweakToolbar::create, "TweakToolbar",
+ SP_VERB_CONTEXT_TWEAK_PREFS, "/tools/tweak", N_("Color/opacity used for color tweaking")},
+ { "/tools/spray", "spray_toolbox", Inkscape::UI::Toolbar::SprayToolbar::create, "SprayToolbar",
+ SP_VERB_INVALID, nullptr, nullptr},
+ { "/tools/zoom", "zoom_toolbox", Inkscape::UI::Toolbar::ZoomToolbar::create, "ZoomToolbar",
+ SP_VERB_INVALID, nullptr, nullptr},
+ // If you change MeasureToolbar here, change it also in desktop-widget.cpp
+ { "/tools/measure", "measure_toolbox", Inkscape::UI::Toolbar::MeasureToolbar::create, "MeasureToolbar",
+ SP_VERB_INVALID, nullptr, nullptr},
+ { "/tools/shapes/star", "star_toolbox", Inkscape::UI::Toolbar::StarToolbar::create, "StarToolbar",
+ SP_VERB_CONTEXT_STAR_PREFS, "/tools/shapes/star", N_("Style of new stars")},
+ { "/tools/shapes/rect", "rect_toolbox", Inkscape::UI::Toolbar::RectToolbar::create, "RectToolbar",
+ SP_VERB_CONTEXT_RECT_PREFS, "/tools/shapes/rect", N_("Style of new rectangles")},
+ { "/tools/shapes/3dbox", "3dbox_toolbox", Inkscape::UI::Toolbar::Box3DToolbar::create, "3DBoxToolbar",
+ SP_VERB_CONTEXT_3DBOX_PREFS, "/tools/shapes/3dbox", N_("Style of new 3D boxes")},
+ { "/tools/shapes/arc", "arc_toolbox", Inkscape::UI::Toolbar::ArcToolbar::create, "ArcToolbar",
+ SP_VERB_CONTEXT_ARC_PREFS, "/tools/shapes/arc", N_("Style of new ellipses")},
+ { "/tools/shapes/spiral", "spiral_toolbox", Inkscape::UI::Toolbar::SpiralToolbar::create, "SpiralToolbar",
+ SP_VERB_CONTEXT_SPIRAL_PREFS, "/tools/shapes/spiral", N_("Style of new spirals")},
+ { "/tools/freehand/pencil", "pencil_toolbox", Inkscape::UI::Toolbar::PencilToolbar::create_pencil, "PencilToolbar",
+ SP_VERB_CONTEXT_PENCIL_PREFS, "/tools/freehand/pencil", N_("Style of new paths created by Pencil")},
+ { "/tools/freehand/pen", "pen_toolbox", Inkscape::UI::Toolbar::PencilToolbar::create_pen, "PenToolbar",
+ SP_VERB_CONTEXT_PEN_PREFS, "/tools/freehand/pen", N_("Style of new paths created by Pen")},
+ { "/tools/calligraphic", "calligraphy_toolbox", Inkscape::UI::Toolbar::CalligraphyToolbar::create, "CalligraphyToolbar",
+ SP_VERB_CONTEXT_CALLIGRAPHIC_PREFS, "/tools/calligraphic", N_("Style of new calligraphic strokes")},
+ { "/tools/eraser", "eraser_toolbox", Inkscape::UI::Toolbar::EraserToolbar::create, "EraserToolbar",
+ SP_VERB_CONTEXT_ERASER_PREFS, "/tools/eraser", _("TBD")},
+ { "/tools/lpetool", "lpetool_toolbox", Inkscape::UI::Toolbar::LPEToolbar::create, "LPEToolToolbar",
+ SP_VERB_CONTEXT_LPETOOL_PREFS, "/tools/lpetool", _("TBD")},
+ // If you change TextToolbar here, change it also in desktop-widget.cpp
+ { "/tools/text", "text_toolbox", Inkscape::UI::Toolbar::TextToolbar::create, "TextToolbar",
+ SP_VERB_INVALID, nullptr, nullptr},
+ { "/tools/dropper", "dropper_toolbox", Inkscape::UI::Toolbar::DropperToolbar::create, "DropperToolbar",
+ SP_VERB_INVALID, nullptr, nullptr},
+ { "/tools/connector", "connector_toolbox", Inkscape::UI::Toolbar::ConnectorToolbar::create, "ConnectorToolbar",
+ SP_VERB_INVALID, nullptr, nullptr},
+ { "/tools/gradient", "gradient_toolbox", Inkscape::UI::Toolbar::GradientToolbar::create, "GradientToolbar",
+ SP_VERB_INVALID, nullptr, nullptr},
+ { "/tools/mesh", "mesh_toolbox", Inkscape::UI::Toolbar::MeshToolbar::create, "MeshToolbar",
+ SP_VERB_INVALID, nullptr, nullptr},
+ { "/tools/paintbucket", "paintbucket_toolbox", Inkscape::UI::Toolbar::PaintbucketToolbar::create, "PaintbucketToolbar",
+ SP_VERB_CONTEXT_PAINTBUCKET_PREFS, "/tools/paintbucket", N_("Style of Paint Bucket fill objects")},
+ { nullptr, nullptr, nullptr, nullptr,
+ SP_VERB_INVALID, nullptr, nullptr }
+};
+
+
+static Glib::RefPtr<Gtk::ActionGroup> create_or_fetch_actions( SPDesktop* desktop );
+
+static void setup_snap_toolbox(GtkWidget *toolbox, SPDesktop *desktop);
+
+static void setup_tool_toolbox(GtkWidget *toolbox, SPDesktop *desktop);
+static void update_tool_toolbox(SPDesktop *desktop, ToolBase *eventcontext, GtkWidget *toolbox);
+
+static void setup_aux_toolbox(GtkWidget *toolbox, SPDesktop *desktop);
+static void update_aux_toolbox(SPDesktop *desktop, ToolBase *eventcontext, GtkWidget *toolbox);
+
+static void setup_commands_toolbox(GtkWidget *toolbox, SPDesktop *desktop);
+static void update_commands_toolbox(SPDesktop *desktop, ToolBase *eventcontext, GtkWidget *toolbox);
+
+static void trigger_sp_action( GtkAction* /*act*/, gpointer user_data )
+{
+ SPAction* targetAction = SP_ACTION(user_data);
+ if ( targetAction ) {
+ sp_action_perform( targetAction, nullptr );
+ }
+}
+
+static GtkAction* create_action_for_verb( Inkscape::Verb* verb, Inkscape::UI::View::View* view, GtkIconSize size )
+{
+ GtkAction* act = nullptr;
+
+ SPAction* targetAction = verb->get_action(Inkscape::ActionContext(view));
+ InkAction* inky = ink_action_new( verb->get_id(), _(verb->get_name()), verb->get_tip(), verb->get_image(), size );
+ act = GTK_ACTION(inky);
+ gtk_action_set_sensitive( act, targetAction->sensitive );
+
+ g_signal_connect( G_OBJECT(inky), "activate", G_CALLBACK(trigger_sp_action), targetAction );
+
+ // FIXME: memory leak: this is not unrefed anywhere
+ g_object_ref(G_OBJECT(targetAction));
+ g_object_set_data_full(G_OBJECT(inky), "SPAction", (void*) targetAction, (GDestroyNotify) &g_object_unref);
+ targetAction->signal_set_sensitive.connect(
+ sigc::bind<0>(
+ sigc::ptr_fun(&gtk_action_set_sensitive),
+ GTK_ACTION(inky)));
+
+ return act;
+}
+
+static std::map<SPDesktop*, Glib::RefPtr<Gtk::ActionGroup> > groups;
+
+static void desktopDestructHandler(SPDesktop *desktop)
+{
+ std::map<SPDesktop*, Glib::RefPtr<Gtk::ActionGroup> >::iterator it = groups.find(desktop);
+ if (it != groups.end())
+ {
+ groups.erase(it);
+ }
+}
+
+static Glib::RefPtr<Gtk::ActionGroup> create_or_fetch_actions( SPDesktop* desktop )
+{
+ Inkscape::UI::View::View *view = desktop;
+ gint verbsToUse[] = {
+ // disabled until we have icons for them:
+ //find
+ //SP_VERB_EDIT_TILE,
+ //SP_VERB_EDIT_UNTILE,
+ SP_VERB_DIALOG_ALIGN_DISTRIBUTE,
+ SP_VERB_DIALOG_DISPLAY,
+ SP_VERB_DIALOG_FILL_STROKE,
+ SP_VERB_DIALOG_NAMEDVIEW,
+ SP_VERB_DIALOG_TEXT,
+ SP_VERB_DIALOG_XML_EDITOR,
+ SP_VERB_DIALOG_SELECTORS,
+ SP_VERB_DIALOG_LAYERS,
+ SP_VERB_EDIT_CLONE,
+ SP_VERB_EDIT_COPY,
+ SP_VERB_EDIT_CUT,
+ SP_VERB_EDIT_DUPLICATE,
+ SP_VERB_EDIT_PASTE,
+ SP_VERB_EDIT_REDO,
+ SP_VERB_EDIT_UNDO,
+ SP_VERB_EDIT_UNLINK_CLONE,
+ //SP_VERB_FILE_EXPORT,
+ SP_VERB_DIALOG_EXPORT,
+ SP_VERB_FILE_IMPORT,
+ SP_VERB_FILE_NEW,
+ SP_VERB_FILE_OPEN,
+ SP_VERB_FILE_PRINT,
+ SP_VERB_FILE_SAVE,
+ SP_VERB_OBJECT_TO_CURVE,
+ SP_VERB_SELECTION_GROUP,
+ SP_VERB_SELECTION_OUTLINE,
+ SP_VERB_SELECTION_UNGROUP,
+ SP_VERB_ZOOM_1_1,
+ SP_VERB_ZOOM_1_2,
+ SP_VERB_ZOOM_2_1,
+ SP_VERB_ZOOM_DRAWING,
+ SP_VERB_ZOOM_IN,
+ SP_VERB_ZOOM_NEXT,
+ SP_VERB_ZOOM_OUT,
+ SP_VERB_ZOOM_PAGE,
+ SP_VERB_ZOOM_PAGE_WIDTH,
+ SP_VERB_ZOOM_PREV,
+ SP_VERB_ZOOM_SELECTION,
+ SP_VERB_ZOOM_CENTER_PAGE
+ };
+
+ GtkIconSize toolboxSize = ToolboxFactory::prefToSize("/toolbox/small");
+ Glib::RefPtr<Gtk::ActionGroup> mainActions;
+ if (desktop == nullptr)
+ {
+ return mainActions;
+ }
+
+ if ( groups.find(desktop) != groups.end() ) {
+ mainActions = groups[desktop];
+ }
+
+ if ( !mainActions ) {
+ mainActions = Gtk::ActionGroup::create("main");
+ groups[desktop] = mainActions;
+ desktop->connectDestroy(&desktopDestructHandler);
+ }
+
+ for (int i : verbsToUse) {
+ Inkscape::Verb* verb = Inkscape::Verb::get(i);
+ if ( verb ) {
+ if (!mainActions->get_action(verb->get_id())) {
+ GtkAction* act = create_action_for_verb( verb, view, toolboxSize );
+ mainActions->add(Glib::wrap(act));
+ }
+ }
+ }
+
+ if ( !mainActions->get_action("ToolZoom") ) {
+ for ( guint i = 0; i < G_N_ELEMENTS(tools) && tools[i].type_name; i++ ) {
+ Glib::RefPtr<VerbAction> va = VerbAction::create(Inkscape::Verb::get(tools[i].verb), Inkscape::Verb::get(tools[i].doubleclick_verb), view);
+ if ( va ) {
+ mainActions->add(va);
+ if ( i == 0 ) {
+ va->set_active(true);
+ }
+ } else {
+ // This creates a blank action using the data_name, this can replace
+ // tools that have been disabled by compile time options.
+ Glib::RefPtr<Gtk::Action> act = Gtk::Action::create(Glib::ustring(tools[i].data_name));
+ act->set_sensitive(false);
+ mainActions->add(act);
+ }
+ }
+ }
+
+ return mainActions;
+}
+
+
+static GtkWidget* toolboxNewCommon( GtkWidget* tb, BarId id, GtkPositionType /*handlePos*/ )
+{
+ g_object_set_data(G_OBJECT(tb), "desktop", nullptr);
+
+ gtk_widget_set_sensitive(tb, FALSE);
+
+ GtkWidget *hb = gtk_event_box_new(); // A simple, neutral container.
+ gtk_widget_set_name(hb, "ToolboxCommon");
+
+ gtk_container_add(GTK_CONTAINER(hb), tb);
+ gtk_widget_show(GTK_WIDGET(tb));
+
+ sigc::connection* conn = new sigc::connection;
+ g_object_set_data(G_OBJECT(hb), "event_context_connection", conn);
+
+ gpointer val = GINT_TO_POINTER(id);
+ g_object_set_data(G_OBJECT(hb), BAR_ID_KEY, val);
+
+ return hb;
+}
+
+GtkWidget *ToolboxFactory::createToolToolbox()
+{
+ auto tb = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
+ gtk_widget_set_name(tb, "ToolToolbox");
+ gtk_box_set_homogeneous(GTK_BOX(tb), FALSE);
+
+ return toolboxNewCommon( tb, BAR_TOOL, GTK_POS_TOP );
+}
+
+GtkWidget *ToolboxFactory::createAuxToolbox()
+{
+ auto tb = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
+ gtk_widget_set_name(tb, "AuxToolbox");
+ gtk_box_set_homogeneous(GTK_BOX(tb), FALSE);
+
+ return toolboxNewCommon( tb, BAR_AUX, GTK_POS_LEFT );
+}
+
+//####################################
+//# Commands Bar
+//####################################
+
+GtkWidget *ToolboxFactory::createCommandsToolbox()
+{
+ auto tb = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
+ gtk_widget_set_name(tb, "CommandsToolbox");
+ gtk_box_set_homogeneous(GTK_BOX(tb), FALSE);
+
+ return toolboxNewCommon( tb, BAR_COMMANDS, GTK_POS_LEFT );
+}
+
+GtkWidget *ToolboxFactory::createSnapToolbox()
+{
+ auto tb = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
+ gtk_widget_set_name(tb, "SnapToolbox");
+ gtk_box_set_homogeneous(GTK_BOX(tb), FALSE);
+
+ return toolboxNewCommon( tb, BAR_SNAP, GTK_POS_LEFT );
+}
+
+static GtkWidget* createCustomSlider( GtkAdjustment *adjustment, gdouble climbRate, guint digits, Inkscape::UI::Widget::UnitTracker *unit_tracker)
+{
+ auto adj = Glib::wrap(adjustment, true);
+ auto inkSpinner = new Inkscape::UI::Widget::SpinButton(adj, climbRate, digits);
+ inkSpinner->addUnitTracker(unit_tracker);
+ inkSpinner = Gtk::manage( inkSpinner );
+ GtkWidget *widget = GTK_WIDGET( inkSpinner->gobj() );
+ return widget;
+}
+
+void ToolboxFactory::setToolboxDesktop(GtkWidget *toolbox, SPDesktop *desktop)
+{
+ sigc::connection *conn = static_cast<sigc::connection*>(g_object_get_data(G_OBJECT(toolbox),
+ "event_context_connection"));
+
+ BarId id = static_cast<BarId>( GPOINTER_TO_INT(g_object_get_data(G_OBJECT(toolbox), BAR_ID_KEY)) );
+
+ SetupFunction setup_func = nullptr;
+ UpdateFunction update_func = nullptr;
+
+ switch (id) {
+ case BAR_TOOL:
+ setup_func = setup_tool_toolbox;
+ update_func = update_tool_toolbox;
+ break;
+
+ case BAR_AUX:
+ toolbox = gtk_bin_get_child(GTK_BIN(toolbox));
+ setup_func = setup_aux_toolbox;
+ update_func = update_aux_toolbox;
+ break;
+
+ case BAR_COMMANDS:
+ setup_func = setup_commands_toolbox;
+ update_func = update_commands_toolbox;
+ break;
+
+ case BAR_SNAP:
+ setup_func = setup_snap_toolbox;
+ update_func = updateSnapToolbox;
+ break;
+ default:
+ g_warning("Unexpected toolbox id encountered.");
+ }
+
+ gpointer ptr = g_object_get_data(G_OBJECT(toolbox), "desktop");
+ SPDesktop *old_desktop = static_cast<SPDesktop*>(ptr);
+
+ if (old_desktop) {
+ std::vector<Gtk::Widget*> children = Glib::wrap(GTK_CONTAINER(toolbox))->get_children();
+ for ( auto i:children ) {
+ gtk_container_remove( GTK_CONTAINER(toolbox), i->gobj() );
+ }
+ }
+
+ g_object_set_data(G_OBJECT(toolbox), "desktop", (gpointer)desktop);
+
+ if (desktop && setup_func && update_func) {
+ gtk_widget_set_sensitive(toolbox, TRUE);
+ setup_func(toolbox, desktop);
+ update_func(desktop, desktop->event_context, toolbox);
+ *conn = desktop->connectEventContextChanged(sigc::bind (sigc::ptr_fun(update_func), toolbox));
+ } else {
+ gtk_widget_set_sensitive(toolbox, FALSE);
+ }
+
+} // end of sp_toolbox_set_desktop()
+
+
+static void setupToolboxCommon( GtkWidget *toolbox,
+ SPDesktop *desktop,
+ gchar const *ui_file,
+ gchar const* toolbarName,
+ gchar const* sizePref )
+{
+ Glib::RefPtr<Gtk::ActionGroup> mainActions = create_or_fetch_actions( desktop );
+ Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+
+ GtkUIManager* mgr = gtk_ui_manager_new();
+ GError* err = nullptr;
+
+ GtkOrientation orientation = GTK_ORIENTATION_HORIZONTAL;
+
+ gtk_ui_manager_insert_action_group( mgr, mainActions->gobj(), 0 );
+
+ Glib::ustring filename = get_filename(UIS, ui_file);
+ gtk_ui_manager_add_ui_from_file( mgr, filename.c_str(), &err );
+ if(err) {
+ g_warning("Failed to load %s: %s", filename.c_str(), err->message);
+ g_error_free(err);
+ return;
+ }
+
+ GtkWidget* toolBar = gtk_ui_manager_get_widget( mgr, toolbarName );
+ if ( prefs->getBool("/toolbox/icononly", true) ) {
+ gtk_toolbar_set_style( GTK_TOOLBAR(toolBar), GTK_TOOLBAR_ICONS );
+ }
+
+ GtkIconSize toolboxSize = ToolboxFactory::prefToSize(sizePref);
+ gtk_toolbar_set_icon_size( GTK_TOOLBAR(toolBar), static_cast<GtkIconSize>(toolboxSize) );
+
+ GtkPositionType pos = static_cast<GtkPositionType>(GPOINTER_TO_INT(g_object_get_data( G_OBJECT(toolbox), HANDLE_POS_MARK )));
+ orientation = ((pos == GTK_POS_LEFT) || (pos == GTK_POS_RIGHT)) ? GTK_ORIENTATION_HORIZONTAL : GTK_ORIENTATION_VERTICAL;
+ gtk_orientable_set_orientation (GTK_ORIENTABLE(toolBar), orientation);
+ gtk_toolbar_set_show_arrow(GTK_TOOLBAR(toolBar), TRUE);
+
+ g_object_set_data(G_OBJECT(toolBar), "desktop", nullptr);
+
+ GtkWidget* child = gtk_bin_get_child(GTK_BIN(toolbox));
+ if ( child ) {
+ gtk_container_remove( GTK_CONTAINER(toolbox), child );
+ }
+
+ gtk_container_add( GTK_CONTAINER(toolbox), toolBar );
+}
+
+#define noDUMP_DETAILS 1
+
+void ToolboxFactory::setOrientation(GtkWidget* toolbox, GtkOrientation orientation)
+{
+#if DUMP_DETAILS
+ g_message("Set orientation for %p to be %d", toolbox, orientation);
+ GType type = G_OBJECT_TYPE(toolbox);
+ g_message(" [%s]", g_type_name(type));
+ g_message(" %p", g_object_get_data(G_OBJECT(toolbox), BAR_ID_KEY));
+#endif
+
+ GtkPositionType pos = (orientation == GTK_ORIENTATION_HORIZONTAL) ? GTK_POS_LEFT : GTK_POS_TOP;
+
+ if (GTK_IS_BIN(toolbox)) {
+#if DUMP_DETAILS
+ g_message(" is a BIN");
+#endif // DUMP_DETAILS
+ GtkWidget* child = gtk_bin_get_child(GTK_BIN(toolbox));
+ if (child) {
+#if DUMP_DETAILS
+ GType type2 = G_OBJECT_TYPE(child);
+ g_message(" child [%s]", g_type_name(type2));
+#endif // DUMP_DETAILS
+
+ if (GTK_IS_BOX(child)) {
+#if DUMP_DETAILS
+ g_message(" is a BOX");
+#endif // DUMP_DETAILS
+
+ std::vector<Gtk::Widget*> children = Glib::wrap(GTK_CONTAINER(child))->get_children();
+ if (!children.empty()) {
+ for (auto curr:children) {
+ GtkWidget* child2 = curr->gobj();
+#if DUMP_DETAILS
+ GType type3 = G_OBJECT_TYPE(child2);
+ g_message(" child2 [%s]", g_type_name(type3));
+#endif // DUMP_DETAILS
+
+ if (GTK_IS_CONTAINER(child2)) {
+ std::vector<Gtk::Widget*> children2 = Glib::wrap(GTK_CONTAINER(child2))->get_children();
+ if (!children2.empty()) {
+ for (auto curr2:children2) {
+ GtkWidget* child3 = curr2->gobj();
+#if DUMP_DETAILS
+ GType type4 = G_OBJECT_TYPE(child3);
+ g_message(" child3 [%s]", g_type_name(type4));
+#endif // DUMP_DETAILS
+ if (GTK_IS_TOOLBAR(child3)) {
+ GtkToolbar* childBar = GTK_TOOLBAR(child3);
+ gtk_orientable_set_orientation(GTK_ORIENTABLE(childBar), orientation);
+ }
+ }
+ }
+ }
+
+
+ if (GTK_IS_TOOLBAR(child2)) {
+ GtkToolbar* childBar = GTK_TOOLBAR(child2);
+ gtk_orientable_set_orientation(GTK_ORIENTABLE(childBar), orientation);
+ } else {
+ g_message("need to add dynamic switch");
+ }
+ }
+ } else {
+ // The call is being made before the toolbox proper has been setup.
+ g_object_set_data(G_OBJECT(toolbox), HANDLE_POS_MARK, GINT_TO_POINTER(pos));
+ }
+ } else if (GTK_IS_TOOLBAR(child)) {
+ GtkToolbar* toolbar = GTK_TOOLBAR(child);
+ gtk_orientable_set_orientation( GTK_ORIENTABLE(toolbar), orientation );
+ }
+ }
+ }
+}
+
+void setup_tool_toolbox(GtkWidget *toolbox, SPDesktop *desktop)
+{
+ setupToolboxCommon(toolbox, desktop, "toolbar-tool.ui", "/ui/ToolToolbar", "/toolbox/tools/small");
+}
+
+void update_tool_toolbox( SPDesktop *desktop, ToolBase *eventcontext, GtkWidget * /*toolbox*/ )
+{
+ gchar const *const tname = ( eventcontext
+ ? eventcontext->getPrefsPath().c_str() //g_type_name(G_OBJECT_TYPE(eventcontext))
+ : nullptr );
+ Glib::RefPtr<Gtk::ActionGroup> mainActions = create_or_fetch_actions( desktop );
+
+ for (int i = 0 ; tools[i].type_name ; i++ ) {
+ Glib::RefPtr<Gtk::Action> act = mainActions->get_action( Inkscape::Verb::get(tools[i].verb)->get_id() );
+ if ( act ) {
+ bool setActive = tname && !strcmp(tname, tools[i].type_name);
+ Glib::RefPtr<VerbAction> verbAct = Glib::RefPtr<VerbAction>::cast_dynamic(act);
+ if ( verbAct ) {
+ verbAct->set_active(setActive);
+ }
+ }
+ }
+}
+
+/**
+ * \brief Generate the auxiliary toolbox
+ *
+ * \details This is the one that appears below the main menu, and contains
+ * tool-specific toolbars. Each toolbar is created here, using
+ * its "create" method.
+ *
+ * The actual method used for each toolbar is specified in the
+ * "aux_toolboxes" array, defined above.
+ */
+void setup_aux_toolbox(GtkWidget *toolbox, SPDesktop *desktop)
+{
+ Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+
+ // Loop through all the toolboxes and create them using either
+ // their "create" methods.
+ for (int i = 0 ; aux_toolboxes[i].type_name ; i++ ) {
+ if (aux_toolboxes[i].create_func) {
+ GtkWidget *sub_toolbox = aux_toolboxes[i].create_func(desktop);
+ gtk_widget_set_name( sub_toolbox, "SubToolBox" );
+
+ auto holder = gtk_grid_new();
+ gtk_grid_attach(GTK_GRID(holder), sub_toolbox, 0, 0, 1, 1);
+
+ // This part is just for styling
+ if ( prefs->getBool( "/toolbox/icononly", true) ) {
+ gtk_toolbar_set_style( GTK_TOOLBAR(sub_toolbox), GTK_TOOLBAR_ICONS );
+ }
+
+ GtkIconSize toolboxSize = ToolboxFactory::prefToSize("/toolbox/small");
+ gtk_toolbar_set_icon_size( GTK_TOOLBAR(sub_toolbox), static_cast<GtkIconSize>(toolboxSize) );
+ gtk_widget_set_hexpand(sub_toolbox, TRUE);
+
+ // Add a swatch widget if one was specified
+ if ( aux_toolboxes[i].swatch_verb_id != SP_VERB_INVALID ) {
+ auto swatch = new Inkscape::UI::Widget::StyleSwatch( nullptr, _(aux_toolboxes[i].swatch_tip) );
+ swatch->setDesktop( desktop );
+ swatch->setClickVerb( aux_toolboxes[i].swatch_verb_id );
+ swatch->setWatchedTool( aux_toolboxes[i].swatch_tool, true );
+ swatch->set_margin_start(AUX_BETWEEN_BUTTON_GROUPS);
+ swatch->set_margin_end(AUX_BETWEEN_BUTTON_GROUPS);
+ swatch->set_margin_top(AUX_SPACING);
+ swatch->set_margin_bottom(AUX_SPACING);
+
+ auto swatch_ = GTK_WIDGET( swatch->gobj() );
+ gtk_grid_attach( GTK_GRID(holder), swatch_, 1, 0, 1, 1);
+ }
+
+ // Add the new toolbar into the toolbox (i.e., make it the visible toolbar)
+ // and also store a pointer to it inside the toolbox. This allows the
+ // active toolbar to be changed.
+ gtk_container_add(GTK_CONTAINER(toolbox), holder);
+ gtk_widget_set_name( holder, aux_toolboxes[i].ui_name );
+
+ // TODO: We could make the toolbox a custom subclass of GtkEventBox
+ // so that we can store a list of toolbars, rather than using
+ // GObject data
+ g_object_set_data(G_OBJECT(toolbox), aux_toolboxes[i].data_name, holder);
+ gtk_widget_show(sub_toolbox);
+ gtk_widget_show(holder);
+ } else if (aux_toolboxes[i].swatch_verb_id != SP_VERB_NONE) {
+ g_warning("Could not create toolbox %s", aux_toolboxes[i].ui_name);
+ }
+ }
+}
+
+void update_aux_toolbox(SPDesktop * /*desktop*/, ToolBase *eventcontext, GtkWidget *toolbox)
+{
+ gchar const *tname = ( eventcontext
+ ? eventcontext->getPrefsPath().c_str() //g_type_name(G_OBJECT_TYPE(eventcontext))
+ : nullptr );
+ for (int i = 0 ; aux_toolboxes[i].type_name ; i++ ) {
+ GtkWidget *sub_toolbox = GTK_WIDGET(g_object_get_data(G_OBJECT(toolbox), aux_toolboxes[i].data_name));
+ if (tname && !strcmp(tname, aux_toolboxes[i].type_name)) {
+ gtk_widget_show_now(sub_toolbox);
+ g_object_set_data(G_OBJECT(toolbox), "shows", sub_toolbox);
+ } else {
+ gtk_widget_hide(sub_toolbox);
+ }
+ //FIX issue #Inkscape686
+ GtkAllocation allocation;
+ gtk_widget_get_allocation(sub_toolbox, &allocation);
+ gtk_widget_size_allocate(sub_toolbox, &allocation);
+ }
+ //FIX issue #Inkscape125
+ GtkAllocation allocation;
+ gtk_widget_get_allocation(toolbox, &allocation);
+ gtk_widget_size_allocate(toolbox, &allocation);
+}
+
+void setup_commands_toolbox(GtkWidget *toolbox, SPDesktop *desktop)
+{
+ setupToolboxCommon(toolbox, desktop, "toolbar-commands.ui", "/ui/CommandsToolbar", "/toolbox/small");
+}
+
+void update_commands_toolbox(SPDesktop * /*desktop*/, ToolBase * /*eventcontext*/, GtkWidget * /*toolbox*/)
+{
+}
+
+void setup_snap_toolbox(GtkWidget *toolbox, SPDesktop *desktop)
+{
+ Glib::ustring sizePref("/toolbox/secondary");
+ auto toolBar = Inkscape::UI::Toolbar::SnapToolbar::create(desktop);
+ auto prefs = Inkscape::Preferences::get();
+
+ if ( prefs->getBool("/toolbox/icononly", true) ) {
+ gtk_toolbar_set_style( GTK_TOOLBAR(toolBar), GTK_TOOLBAR_ICONS );
+ }
+
+ GtkIconSize toolboxSize = ToolboxFactory::prefToSize(sizePref.c_str());
+ gtk_toolbar_set_icon_size( GTK_TOOLBAR(toolBar), static_cast<GtkIconSize>(toolboxSize) );
+
+ GtkPositionType pos = static_cast<GtkPositionType>(GPOINTER_TO_INT(g_object_get_data( G_OBJECT(toolbox), HANDLE_POS_MARK )));
+ auto orientation = ((pos == GTK_POS_LEFT) || (pos == GTK_POS_RIGHT)) ? GTK_ORIENTATION_HORIZONTAL : GTK_ORIENTATION_VERTICAL;
+ gtk_orientable_set_orientation (GTK_ORIENTABLE(toolBar), orientation);
+ gtk_toolbar_set_show_arrow(GTK_TOOLBAR(toolBar), TRUE);
+
+ GtkWidget* child = gtk_bin_get_child(GTK_BIN(toolbox));
+ if ( child ) {
+ gtk_container_remove( GTK_CONTAINER(toolbox), child );
+ }
+
+ gtk_container_add( GTK_CONTAINER(toolbox), toolBar );
+}
+
+Glib::ustring ToolboxFactory::getToolboxName(GtkWidget* toolbox)
+{
+ Glib::ustring name;
+ BarId id = static_cast<BarId>( GPOINTER_TO_INT(g_object_get_data(G_OBJECT(toolbox), BAR_ID_KEY)) );
+ switch(id) {
+ case BAR_TOOL:
+ name = "ToolToolbar";
+ break;
+ case BAR_AUX:
+ name = "AuxToolbar";
+ break;
+ case BAR_COMMANDS:
+ name = "CommandsToolbar";
+ break;
+ case BAR_SNAP:
+ name = "SnapToolbar";
+ break;
+ }
+
+ return name;
+}
+
+void ToolboxFactory::updateSnapToolbox(SPDesktop *desktop, ToolBase * /*eventcontext*/, GtkWidget *toolbox)
+{
+ auto tb = dynamic_cast<Inkscape::UI::Toolbar::SnapToolbar*>(Glib::wrap(GTK_TOOLBAR(gtk_bin_get_child(GTK_BIN(toolbox)))));
+
+ if (!tb) {
+ std::cerr << "Can't get snap toolbar" << std::endl;
+ return;
+ }
+
+ Inkscape::UI::Toolbar::SnapToolbar::update(tb);
+}
+
+void ToolboxFactory::showAuxToolbox(GtkWidget *toolbox_toplevel)
+{
+ gtk_widget_show(toolbox_toplevel);
+ GtkWidget *toolbox = gtk_bin_get_child(GTK_BIN(toolbox_toplevel));
+
+ GtkWidget *shown_toolbox = GTK_WIDGET(g_object_get_data(G_OBJECT(toolbox), "shows"));
+ if (!shown_toolbox) {
+ return;
+ }
+ gtk_widget_show(toolbox);
+}
+
+#define MODE_LABEL_WIDTH 70
+
+
+/*
+ Local Variables:
+ mode:c++
+ c-file-style:"stroustrup"
+ c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
+ indent-tabs-mode:nil
+ fill-column:99
+ End:
+*/
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :
diff --git a/src/widgets/toolbox.h b/src/widgets/toolbox.h
new file mode 100644
index 0000000..3a1bb4c
--- /dev/null
+++ b/src/widgets/toolbox.h
@@ -0,0 +1,84 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+#ifndef SEEN_TOOLBOX_H
+#define SEEN_TOOLBOX_H
+
+/*
+ * Authors:
+ * Lauris Kaplinski <lauris@kaplinski.com>
+ * Frank Felfe <innerspace@iname.com>
+ * Jon A. Cruz <jon@joncruz.org>
+ *
+ * Copyright (C) 1999-2002 Authors
+ * Copyright (C) 2001-2002 Ximian, Inc.
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#include <glibmm/ustring.h>
+
+#include "preferences.h"
+
+#define TOOLBAR_SLIDER_HINT "compact"
+
+class SPDesktop;
+
+namespace Inkscape {
+namespace UI {
+namespace Tools {
+
+class ToolBase;
+
+}
+}
+}
+
+namespace Inkscape {
+namespace UI {
+
+namespace Widget {
+ class UnitTracker;
+}
+
+/**
+ * Main toolbox source.
+ */
+class ToolboxFactory
+{
+public:
+ static void setToolboxDesktop(GtkWidget *toolbox, SPDesktop *desktop);
+ static void setOrientation(GtkWidget* toolbox, GtkOrientation orientation);
+ static void showAuxToolbox(GtkWidget* toolbox);
+
+ static GtkWidget *createToolToolbox();
+ static GtkWidget *createAuxToolbox();
+ static GtkWidget *createCommandsToolbox();
+ static GtkWidget *createSnapToolbox();
+
+
+ static Glib::ustring getToolboxName(GtkWidget* toolbox);
+
+ static void updateSnapToolbox(SPDesktop *desktop, Inkscape::UI::Tools::ToolBase *eventcontext, GtkWidget *toolbox);
+
+ static GtkIconSize prefToSize(Glib::ustring const &path, int base = 0 );
+ static Gtk::IconSize prefToSize_mm(Glib::ustring const &path, int base = 0);
+
+ ToolboxFactory() = delete;
+};
+
+
+
+} // namespace UI
+} // namespace Inkscape
+
+#endif /* !SEEN_TOOLBOX_H */
+
+/*
+ Local Variables:
+ mode:c++
+ c-file-style:"stroustrup"
+ c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
+ indent-tabs-mode:nil
+ fill-column:99
+ End:
+*/
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :
diff --git a/src/widgets/widget-sizes.h b/src/widgets/widget-sizes.h
new file mode 100644
index 0000000..8dd8c6c
--- /dev/null
+++ b/src/widgets/widget-sizes.h
@@ -0,0 +1,57 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/** @file
+ * TODO: insert short description here
+ *//*
+ * Authors: see git history
+ *
+ * Copyright (C) 2016 Authors
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+// #define TOOL_BUTTON_SIZE 28
+
+// GTK uses 24 for icon sizes by default. Spacing adjust to keep the
+// toolbar the same as other GTK applications. If we want that, use
+// these defines instead:
+//#define AUX_BUTTON_SIZE 24
+//#define AUX_SPACING 2
+
+// #define AUX_BUTTON_SIZE 20
+#define AUX_SPACING 3
+
+#define AUX_BETWEEN_BUTTON_GROUPS 7
+#define AUX_BETWEEN_SPINBUTTONS 0
+#define AUX_SPINBUTTON_WIDTH 62
+#define AUX_SPINBUTTON_WIDTH_SMALL 56
+#define AUX_SPINBUTTON_HEIGHT 20
+#define AUX_OPTION_MENU_WIDTH 55
+#define AUX_OPTION_MENU_HEIGHT 20
+#define AUX_MENU_ITEM_WIDTH 32
+#define AUX_MENU_ITEM_HEIGHT 18
+
+#define SPIN_STEP 0.1
+#define SPIN_PAGE_STEP 5.0
+
+#define BOTTOM_BAR_HEIGHT 20
+#define BOTTOM_BUTTON_SIZE 14
+
+#define STATUS_BAR_FONT_SIZE 10000
+
+#define STATUS_ZOOM_WIDTH 57
+#define STATUS_ROTATION_WIDTH 57
+
+#define SELECTED_STYLE_SB_WIDTH 48
+#define SELECTED_STYLE_WIDTH 190
+#define STYLE_SWATCH_WIDTH 135
+
+#define STATUS_LAYER_FONT_SIZE 7700
+
+/*
+ Local Variables:
+ mode:c++
+ c-file-style:"stroustrup"
+ c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
+ indent-tabs-mode:nil
+ fill-column:99
+ End:
+*/
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :