summaryrefslogtreecommitdiffstats
path: root/src/ui/dialog/livepatheffect-add.cpp
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 18:24:48 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 18:24:48 +0000
commitcca66b9ec4e494c1d919bff0f71a820d8afab1fa (patch)
tree146f39ded1c938019e1ed42d30923c2ac9e86789 /src/ui/dialog/livepatheffect-add.cpp
parentInitial commit. (diff)
downloadinkscape-upstream.tar.xz
inkscape-upstream.zip
Adding upstream version 1.2.2.upstream/1.2.2upstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to '')
-rw-r--r--src/ui/dialog/livepatheffect-add.cpp981
1 files changed, 981 insertions, 0 deletions
diff --git a/src/ui/dialog/livepatheffect-add.cpp b/src/ui/dialog/livepatheffect-add.cpp
new file mode 100644
index 0000000..b7a48e7
--- /dev/null
+++ b/src/ui/dialog/livepatheffect-add.cpp
@@ -0,0 +1,981 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/**
+ * @file
+ * Dialog for adding a live path effect.
+ *
+ * Author:
+ *
+ * Copyright (C) 2012 Authors
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#include "livepatheffect-add.h"
+
+#include <cmath>
+#include <glibmm/i18n.h>
+
+#include "desktop.h"
+#include "io/resource.h"
+#include "live_effects/effect.h"
+#include "object/sp-clippath.h"
+#include "object/sp-item-group.h"
+#include "object/sp-mask.h"
+#include "object/sp-path.h"
+#include "object/sp-shape.h"
+#include "preferences.h"
+#include "ui/widget/canvas.h"
+#include "ui/themes.h"
+#include "ui/util.h"
+
+namespace Inkscape {
+namespace UI {
+namespace Dialog {
+
+bool sp_has_fav(Glib::ustring effect)
+{
+ Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+ Glib::ustring favlist = prefs->getString("/dialogs/livepatheffect/favs");
+ size_t pos = favlist.find(effect);
+ if (pos != std::string::npos) {
+ return true;
+ }
+ return false;
+}
+
+void sp_add_fav(Glib::ustring effect)
+{
+ Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+ Glib::ustring favlist = prefs->getString("/dialogs/livepatheffect/favs");
+ if (!sp_has_fav(effect)) {
+ prefs->setString("/dialogs/livepatheffect/favs", favlist + effect + ";");
+ }
+}
+
+void sp_remove_fav(Glib::ustring effect)
+{
+ if (sp_has_fav(effect)) {
+ Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+ Glib::ustring favlist = prefs->getString("/dialogs/livepatheffect/favs");
+ effect += ";";
+ size_t pos = favlist.find(effect);
+ if (pos != std::string::npos) {
+ favlist.erase(pos, effect.length());
+ prefs->setString("/dialogs/livepatheffect/favs", favlist);
+ }
+ }
+}
+
+void sp_add_top_window_classes_callback(Gtk::Widget *widg)
+{
+ SPDesktop *desktop = SP_ACTIVE_DESKTOP;
+ if (desktop) {
+ Gtk::Widget *canvas = desktop->canvas;
+ Gtk::Window *toplevel_window = dynamic_cast<Gtk::Window *>(canvas->get_toplevel());
+ if (toplevel_window) {
+ Gtk::Window *current_window = dynamic_cast<Gtk::Window *>(widg);
+ if (!current_window) {
+ current_window = dynamic_cast<Gtk::Window *>(widg->get_toplevel());
+ }
+ if (current_window) {
+ if (toplevel_window->get_style_context()->has_class("dark")) {
+ current_window->get_style_context()->add_class("dark");
+ current_window->get_style_context()->remove_class("bright");
+ } else {
+ current_window->get_style_context()->add_class("bright");
+ current_window->get_style_context()->remove_class("dark");
+ }
+ if (toplevel_window->get_style_context()->has_class("symbolic")) {
+ current_window->get_style_context()->add_class("symbolic");
+ current_window->get_style_context()->remove_class("regular");
+ } else {
+ current_window->get_style_context()->remove_class("symbolic");
+ current_window->get_style_context()->add_class("regular");
+ }
+ }
+ }
+ }
+}
+
+void sp_add_top_window_classes(Gtk::Widget *widg)
+{
+ if (!widg) {
+ return;
+ }
+ if (!widg->get_realized()) {
+ widg->signal_realize().connect(sigc::bind(sigc::ptr_fun(&sp_add_top_window_classes_callback), widg));
+ } else {
+ sp_add_top_window_classes_callback(widg);
+ }
+}
+
+bool LivePathEffectAdd::mouseover(GdkEventCrossing *evt, GtkWidget *wdg)
+{
+ GdkDisplay *display = gdk_display_get_default();
+ GdkCursor *cursor = gdk_cursor_new_for_display(display, GDK_HAND2);
+ GdkWindow *window = gtk_widget_get_window(wdg);
+ gdk_window_set_cursor(window, cursor);
+ g_object_unref(cursor);
+ return true;
+}
+
+bool LivePathEffectAdd::mouseout(GdkEventCrossing *evt, GtkWidget *wdg)
+{
+ GdkWindow *window = gtk_widget_get_window(wdg);
+ gdk_window_set_cursor(window, nullptr);
+ hide_pop_description(evt);
+ return true;
+}
+
+LivePathEffectAdd::LivePathEffectAdd()
+ : converter(Inkscape::LivePathEffect::LPETypeConverter)
+ , _applied(false)
+ , _showfavs(false)
+{
+ auto gladefile = get_filename_string(Inkscape::IO::Resource::UIS, "dialog-livepatheffect-add.glade");
+ try {
+ _builder = Gtk::Builder::create_from_file(gladefile);
+ } catch (const Glib::Error &ex) {
+ g_warning("Glade file loading failed for path effect dialog");
+ return;
+ }
+ _builder->get_widget("LPEDialogSelector", _LPEDialogSelector);
+ _builder->get_widget("LPESelectorFlowBox", _LPESelectorFlowBox);
+ _builder->get_widget("LPESelectorEffectInfoPop", _LPESelectorEffectInfoPop);
+ _builder->get_widget("LPEFilter", _LPEFilter);
+ _builder->get_widget("LPEInfo", _LPEInfo);
+ _builder->get_widget("LPEExperimental", _LPEExperimental);
+ _builder->get_widget("LPEScrolled", _LPEScrolled);
+ _builder->get_widget("LPESelectorEffectEventFavShow", _LPESelectorEffectEventFavShow);
+ _builder->get_widget("LPESelectorEffectInfoEventBox", _LPESelectorEffectInfoEventBox);
+ _builder->get_widget("LPESelectorEffectRadioPackLess", _LPESelectorEffectRadioPackLess);
+ _builder->get_widget("LPESelectorEffectRadioPackMore", _LPESelectorEffectRadioPackMore);
+ _builder->get_widget("LPESelectorEffectRadioList", _LPESelectorEffectRadioList);
+
+ _LPEFilter->signal_search_changed().connect(sigc::mem_fun(*this, &LivePathEffectAdd::on_search));
+ _LPEDialogSelector->add_events(Gdk::POINTER_MOTION_MASK | Gdk::BUTTON_PRESS_MASK | Gdk::BUTTON_RELEASE_MASK |
+ Gdk::ENTER_NOTIFY_MASK | Gdk::LEAVE_NOTIFY_MASK | Gdk::KEY_PRESS_MASK);
+ _LPESelectorFlowBox->signal_set_focus_child().connect(sigc::mem_fun(*this, &LivePathEffectAdd::on_focus));
+
+ gladefile = get_filename_string(Inkscape::IO::Resource::UIS, "dialog-livepatheffect-effect.glade");
+ for (int i = 0; i < static_cast<int>(converter._length); ++i) {
+ Glib::RefPtr<Gtk::Builder> builder_effect;
+ try {
+ builder_effect = Gtk::Builder::create_from_file(gladefile);
+ } catch (const Glib::Error &ex) {
+ g_warning("Glade file loading failed for filter effect dialog");
+ return;
+ }
+ const LivePathEffect::EnumEffectData<LivePathEffect::EffectType> *data = &converter.data(i);
+ Gtk::EventBox *LPESelectorEffect;
+ builder_effect->get_widget("LPESelectorEffect", LPESelectorEffect);
+ LPESelectorEffect->signal_button_press_event().connect(
+ sigc::bind<Glib::RefPtr<Gtk::Builder>, const LivePathEffect::EnumEffectData<LivePathEffect::EffectType> *>(
+ sigc::mem_fun(*this, &LivePathEffectAdd::apply), builder_effect, &converter.data(i)));
+ Gtk::EventBox *LPESelectorEffectEventExpander;
+ builder_effect->get_widget("LPESelectorEffectEventExpander", LPESelectorEffectEventExpander);
+ LPESelectorEffectEventExpander->signal_button_press_event().connect(
+ sigc::bind<Glib::RefPtr<Gtk::Builder>>(sigc::mem_fun(*this, &LivePathEffectAdd::expand), builder_effect));
+ LPESelectorEffectEventExpander->signal_enter_notify_event().connect(sigc::bind<GtkWidget *>(
+ sigc::mem_fun(*this, &LivePathEffectAdd::mouseover), GTK_WIDGET(LPESelectorEffect->gobj())));
+ LPESelectorEffectEventExpander->signal_leave_notify_event().connect(sigc::bind<GtkWidget *>(
+ sigc::mem_fun(*this, &LivePathEffectAdd::mouseout), GTK_WIDGET(LPESelectorEffect->gobj())));
+ Gtk::Label *LPEName;
+ builder_effect->get_widget("LPEName", LPEName);
+ const Glib::ustring label = g_dpgettext2(nullptr, "path effect", converter.get_label(data->id).c_str());
+ const Glib::ustring untranslated_label = converter.get_label(data->id);
+ if (untranslated_label == label) {
+ LPEName->set_text(label);
+ } else {
+ LPEName->set_markup((label + "\n<span size='x-small'>" + untranslated_label + "</span>").c_str());
+ }
+ Gtk::Label *LPEDescription;
+ builder_effect->get_widget("LPEDescription", LPEDescription);
+ const Glib::ustring description = _(converter.get_description(data->id).c_str());
+ LPEDescription->set_text(description);
+ Gtk::ToggleButton *LPEExperimentalToggle;
+ builder_effect->get_widget("LPEExperimentalToggle", LPEExperimentalToggle);
+ bool active = converter.get_experimental(data->id) ? true : false;
+ LPEExperimentalToggle->set_active(active);
+ Gtk::Image *LPEIcon;
+ builder_effect->get_widget("LPEIcon", LPEIcon);
+ LPEIcon->set_from_icon_name(converter.get_icon(data->id), Gtk::IconSize(Gtk::ICON_SIZE_DIALOG));
+ Gtk::EventBox *LPESelectorEffectEventInfo;
+ builder_effect->get_widget("LPESelectorEffectEventInfo", LPESelectorEffectEventInfo);
+ LPESelectorEffectEventInfo->signal_enter_notify_event().connect(sigc::bind<Glib::RefPtr<Gtk::Builder>>(
+ sigc::mem_fun(*this, &LivePathEffectAdd::pop_description), builder_effect));
+ Gtk::EventBox *LPESelectorEffectEventFav;
+ builder_effect->get_widget("LPESelectorEffectEventFav", LPESelectorEffectEventFav);
+ Gtk::Image *fav = dynamic_cast<Gtk::Image *>(LPESelectorEffectEventFav->get_child());
+ if (sp_has_fav(LPEName->get_text())) {
+ fav->set_from_icon_name("draw-star", Gtk::IconSize(Gtk::ICON_SIZE_SMALL_TOOLBAR));
+ } else {
+ fav->set_from_icon_name("draw-star-outline", Gtk::IconSize(Gtk::ICON_SIZE_SMALL_TOOLBAR));
+ }
+ Gtk::EventBox *LPESelectorEffectEventFavTop;
+ builder_effect->get_widget("LPESelectorEffectEventFavTop", LPESelectorEffectEventFavTop);
+ LPESelectorEffectEventFav->signal_button_press_event().connect(sigc::bind<Glib::RefPtr<Gtk::Builder>>(
+ sigc::mem_fun(*this, &LivePathEffectAdd::fav_toggler), builder_effect));
+ LPESelectorEffectEventFavTop->signal_button_press_event().connect(sigc::bind<Glib::RefPtr<Gtk::Builder>>(
+ sigc::mem_fun(*this, &LivePathEffectAdd::fav_toggler), builder_effect));
+ Gtk::Image *favtop = dynamic_cast<Gtk::Image *>(LPESelectorEffectEventFavTop->get_child());
+ if (sp_has_fav(LPEName->get_text())) {
+ favtop->set_from_icon_name("draw-star", Gtk::IconSize(Gtk::ICON_SIZE_SMALL_TOOLBAR));
+ } else {
+ favtop->set_from_icon_name("draw-star-outline", Gtk::IconSize(Gtk::ICON_SIZE_SMALL_TOOLBAR));
+ }
+ Gtk::EventBox *LPESelectorEffectEventApply;
+ builder_effect->get_widget("LPESelectorEffectEventApply", LPESelectorEffectEventApply);
+ LPESelectorEffectEventApply->signal_button_press_event().connect(
+ sigc::bind<Glib::RefPtr<Gtk::Builder>, const LivePathEffect::EnumEffectData<LivePathEffect::EffectType> *>(
+ sigc::mem_fun(*this, &LivePathEffectAdd::apply), builder_effect, &converter.data(i)));
+ LPESelectorEffectEventApply->signal_enter_notify_event().connect(sigc::bind<GtkWidget *>(
+ sigc::mem_fun(*this, &LivePathEffectAdd::mouseover), GTK_WIDGET(LPESelectorEffectEventApply->gobj())));
+ LPESelectorEffectEventApply->signal_leave_notify_event().connect(sigc::bind<GtkWidget *>(
+ sigc::mem_fun(*this, &LivePathEffectAdd::mouseout), GTK_WIDGET(LPESelectorEffectEventApply->gobj())));
+ Gtk::ButtonBox *LPESelectorButtonBox;
+ builder_effect->get_widget("LPESelectorButtonBox", LPESelectorButtonBox);
+ LPESelectorButtonBox->signal_enter_notify_event().connect(sigc::bind<GtkWidget *>(
+ sigc::mem_fun(*this, &LivePathEffectAdd::mouseover), GTK_WIDGET(LPESelectorEffect->gobj())));
+ LPESelectorButtonBox->signal_leave_notify_event().connect(sigc::bind<GtkWidget *>(
+ sigc::mem_fun(*this, &LivePathEffectAdd::mouseout), GTK_WIDGET(LPESelectorEffect->gobj())));
+ LPESelectorEffect->signal_enter_notify_event().connect(sigc::bind<GtkWidget *>(
+ sigc::mem_fun(*this, &LivePathEffectAdd::mouseover), GTK_WIDGET(LPESelectorEffect->gobj())));
+ LPESelectorEffect->signal_leave_notify_event().connect(sigc::bind<GtkWidget *>(
+ sigc::mem_fun(*this, &LivePathEffectAdd::mouseout), GTK_WIDGET(LPESelectorEffect->gobj())));
+ _LPESelectorFlowBox->insert(*LPESelectorEffect, i);
+ LPESelectorEffect->get_parent()->signal_key_press_event().connect(
+ sigc::bind<Glib::RefPtr<Gtk::Builder>, const LivePathEffect::EnumEffectData<LivePathEffect::EffectType> *>(
+ sigc::mem_fun(*this, &LivePathEffectAdd::on_press_enter), builder_effect, &converter.data(i)));
+ LPESelectorEffect->get_parent()->get_style_context()->add_class(
+ ("LPEIndex" + Glib::ustring::format(i)).c_str());
+ }
+ _LPESelectorFlowBox->set_activate_on_single_click(false);
+ _visiblelpe = _LPESelectorFlowBox->get_children().size();
+ _LPEInfo->set_visible(false);
+ _LPESelectorEffectRadioPackLess->signal_clicked().connect(
+ sigc::bind(sigc::mem_fun(*this, &LivePathEffectAdd::viewChanged), 0));
+ _LPESelectorEffectRadioPackMore->signal_clicked().connect(
+ sigc::bind(sigc::mem_fun(*this, &LivePathEffectAdd::viewChanged), 1));
+ _LPESelectorEffectRadioList->signal_clicked().connect(
+ sigc::bind(sigc::mem_fun(*this, &LivePathEffectAdd::viewChanged), 2));
+ _LPESelectorEffectEventFavShow->signal_enter_notify_event().connect(sigc::bind<GtkWidget *>(
+ sigc::mem_fun(*this, &LivePathEffectAdd::mouseover), GTK_WIDGET(_LPESelectorEffectEventFavShow->gobj())));
+ _LPESelectorEffectEventFavShow->signal_leave_notify_event().connect(sigc::bind<GtkWidget *>(
+ sigc::mem_fun(*this, &LivePathEffectAdd::mouseout), GTK_WIDGET(_LPESelectorEffectEventFavShow->gobj())));
+ _LPESelectorEffectEventFavShow->signal_button_press_event().connect(
+ sigc::mem_fun(*this, &LivePathEffectAdd::show_fav_toggler));
+ _LPESelectorEffectInfoEventBox->signal_leave_notify_event().connect(
+ sigc::mem_fun(*this, &LivePathEffectAdd::hide_pop_description));
+ _LPESelectorEffectInfoEventBox->signal_enter_notify_event().connect(sigc::bind<GtkWidget *>(
+ sigc::mem_fun(*this, &LivePathEffectAdd::mouseover), GTK_WIDGET(_LPESelectorEffectInfoEventBox->gobj())));
+ _LPESelectorEffectInfoEventBox->signal_leave_notify_event().connect(sigc::bind<GtkWidget *>(
+ sigc::mem_fun(*this, &LivePathEffectAdd::mouseout), GTK_WIDGET(_LPESelectorEffectInfoEventBox->gobj())));
+ _LPEExperimental->property_active().signal_changed().connect(
+ sigc::mem_fun(*this, &LivePathEffectAdd::reload_effect_list));
+ Gtk::Window *window = SP_ACTIVE_DESKTOP->getToplevel();
+ int width;
+ int height;
+ window->get_size(width, height);
+ _LPEDialogSelector->resize(std::min(width - 300, 1440), std::min(height - 300, 900));
+ _LPESelectorFlowBox->set_focus_vadjustment(_LPEScrolled->get_vadjustment());
+ _LPEDialogSelector->show_all_children();
+ _lasteffect = nullptr;
+ Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+ gint mode = prefs->getInt("/dialogs/livepatheffect/dialogmode", 0);
+ switch (mode) {
+ case 0:
+ _LPESelectorEffectRadioPackLess->set_active();
+ viewChanged(0);
+ break;
+ case 1:
+ _LPESelectorEffectRadioPackMore->set_active();
+ viewChanged(1);
+ break;
+ default:
+ _LPESelectorEffectRadioList->set_active();
+ viewChanged(2);
+ }
+ Gtk::Widget *widg = dynamic_cast<Gtk::Widget *>(_LPEDialogSelector);
+ INKSCAPE.themecontext->getChangeThemeSignal().connect(sigc::bind(sigc::ptr_fun(sp_add_top_window_classes), widg));
+ sp_add_top_window_classes(widg);
+}
+const LivePathEffect::EnumEffectData<LivePathEffect::EffectType> *LivePathEffectAdd::getActiveData()
+{
+ return instance()._to_add;
+}
+
+void LivePathEffectAdd::viewChanged(gint mode)
+{
+ Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+ bool changed = false;
+ if (mode == 2 && !_LPEDialogSelector->get_style_context()->has_class("LPEList")) {
+ _LPEDialogSelector->get_style_context()->add_class("LPEList");
+ _LPEDialogSelector->get_style_context()->remove_class("LPEPackLess");
+ _LPEDialogSelector->get_style_context()->remove_class("LPEPackMore");
+ _LPESelectorFlowBox->set_max_children_per_line(1);
+ changed = true;
+ } else if (mode == 1 && !_LPEDialogSelector->get_style_context()->has_class("LPEPackMore")) {
+ _LPEDialogSelector->get_style_context()->remove_class("LPEList");
+ _LPEDialogSelector->get_style_context()->remove_class("LPEPackLess");
+ _LPEDialogSelector->get_style_context()->add_class("LPEPackMore");
+ _LPESelectorFlowBox->set_max_children_per_line(30);
+ changed = true;
+ } else if (mode == 0 && !_LPEDialogSelector->get_style_context()->has_class("LPEPackLess")) {
+ _LPEDialogSelector->get_style_context()->remove_class("LPEList");
+ _LPEDialogSelector->get_style_context()->add_class("LPEPackLess");
+ _LPEDialogSelector->get_style_context()->remove_class("LPEPackMore");
+ _LPESelectorFlowBox->set_max_children_per_line(30);
+ changed = true;
+ }
+ prefs->setInt("/dialogs/livepatheffect/dialogmode", mode);
+ if (changed) {
+ _LPESelectorFlowBox->unset_sort_func();
+ _LPESelectorFlowBox->set_sort_func(sigc::mem_fun(this, &LivePathEffectAdd::on_sort));
+ std::vector<Gtk::FlowBoxChild *> selected = _LPESelectorFlowBox->get_selected_children();
+ if (selected.size() == 1) {
+ _LPESelectorFlowBox->get_selected_children()[0]->grab_focus();
+ }
+ }
+}
+
+void LivePathEffectAdd::on_focus(Gtk::Widget *widget)
+{
+ Gtk::FlowBoxChild *child = dynamic_cast<Gtk::FlowBoxChild *>(widget);
+ Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+ gint mode = prefs->getInt("/dialogs/livepatheffect/dialogmode", 0);
+ if (child && mode != 2) {
+ for (auto i : _LPESelectorFlowBox->get_children()) {
+ Gtk::FlowBoxChild *leitem = dynamic_cast<Gtk::FlowBoxChild *>(i);
+ Gtk::EventBox *eventbox = dynamic_cast<Gtk::EventBox *>(leitem->get_child());
+ if (eventbox) {
+ Gtk::Box *box = dynamic_cast<Gtk::Box *>(eventbox->get_child());
+ if (box) {
+ std::vector<Gtk::Widget *> contents = box->get_children();
+ Gtk::Box *actions = dynamic_cast<Gtk::Box *>(contents[5]);
+ if (actions) {
+ actions->set_visible(false);
+ }
+ Gtk::EventBox *expander = dynamic_cast<Gtk::EventBox *>(contents[4]);
+ if (expander) {
+ expander->set_visible(true);
+ }
+ }
+ }
+ }
+ Gtk::EventBox *eventbox = dynamic_cast<Gtk::EventBox *>(child->get_child());
+ if (eventbox) {
+ Gtk::Box *box = dynamic_cast<Gtk::Box *>(eventbox->get_child());
+ if (box) {
+ std::vector<Gtk::Widget *> contents = box->get_children();
+ Gtk::EventBox *expander = dynamic_cast<Gtk::EventBox *>(contents[4]);
+ if (expander) {
+ expander->set_visible(false);
+ }
+ }
+ }
+
+ child->show_all_children();
+ _LPESelectorFlowBox->select_child(*child);
+ }
+}
+
+bool LivePathEffectAdd::pop_description(GdkEventCrossing *evt, Glib::RefPtr<Gtk::Builder> builder_effect)
+{
+ Gtk::Image *LPESelectorEffectInfo;
+ builder_effect->get_widget("LPESelectorEffectInfo", LPESelectorEffectInfo);
+ _LPESelectorEffectInfoPop->set_relative_to(*LPESelectorEffectInfo);
+
+ Gtk::Label *LPEName;
+ builder_effect->get_widget("LPEName", LPEName);
+ Gtk::Label *LPEDescription;
+ builder_effect->get_widget("LPEDescription", LPEDescription);
+ Gtk::Image *LPEIcon;
+ builder_effect->get_widget("LPEIcon", LPEIcon);
+
+ Gtk::Image *LPESelectorEffectInfoIcon;
+ _builder->get_widget("LPESelectorEffectInfoIcon", LPESelectorEffectInfoIcon);
+ LPESelectorEffectInfoIcon->set_from_icon_name(LPEIcon->get_icon_name(), Gtk::IconSize(Gtk::ICON_SIZE_DIALOG));
+
+ Gtk::Label *LPESelectorEffectInfoName;
+ _builder->get_widget("LPESelectorEffectInfoName", LPESelectorEffectInfoName);
+ LPESelectorEffectInfoName->set_text(LPEName->get_text());
+
+ Gtk::Label *LPESelectorEffectInfoDescription;
+ _builder->get_widget("LPESelectorEffectInfoDescription", LPESelectorEffectInfoDescription);
+ LPESelectorEffectInfoDescription->set_text(LPEDescription->get_text());
+
+ _LPESelectorEffectInfoPop->show();
+
+ return true;
+}
+
+bool LivePathEffectAdd::hide_pop_description(GdkEventCrossing *evt)
+{
+ _LPESelectorEffectInfoPop->hide();
+ return true;
+}
+
+bool LivePathEffectAdd::fav_toggler(GdkEventButton *evt, Glib::RefPtr<Gtk::Builder> builder_effect)
+{
+ Gtk::EventBox *LPESelectorEffect;
+ builder_effect->get_widget("LPESelectorEffect", LPESelectorEffect);
+ Gtk::Label *LPEName;
+ builder_effect->get_widget("LPEName", LPEName);
+ Gtk::Image *LPESelectorEffectFav;
+ builder_effect->get_widget("LPESelectorEffectFav", LPESelectorEffectFav);
+ Gtk::Image *LPESelectorEffectFavTop;
+ builder_effect->get_widget("LPESelectorEffectFavTop", LPESelectorEffectFavTop);
+ Gtk::EventBox *LPESelectorEffectEventFavTop;
+ builder_effect->get_widget("LPESelectorEffectEventFavTop", LPESelectorEffectEventFavTop);
+ if (LPESelectorEffectFav && LPESelectorEffectEventFavTop) {
+ if (sp_has_fav(LPEName->get_text())) {
+ Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+ gint mode = prefs->getInt("/dialogs/livepatheffect/dialogmode", 0);
+ if (mode == 2) {
+ LPESelectorEffectEventFavTop->set_visible(true);
+ LPESelectorEffectEventFavTop->show();
+ } else {
+ LPESelectorEffectEventFavTop->set_visible(false);
+ LPESelectorEffectEventFavTop->hide();
+ }
+ LPESelectorEffectFavTop->set_from_icon_name("draw-star-outline",
+ Gtk::IconSize(Gtk::ICON_SIZE_SMALL_TOOLBAR));
+ LPESelectorEffectFav->set_from_icon_name("draw-star-outline", Gtk::IconSize(Gtk::ICON_SIZE_SMALL_TOOLBAR));
+ sp_remove_fav(LPEName->get_text());
+ LPESelectorEffect->get_parent()->get_style_context()->remove_class("lpefav");
+ LPESelectorEffect->get_parent()->get_style_context()->add_class("lpenormal");
+ LPESelectorEffect->get_parent()->get_style_context()->add_class("lpe");
+ if (_showfavs) {
+ reload_effect_list();
+ }
+ } else {
+ LPESelectorEffectEventFavTop->set_visible(true);
+ LPESelectorEffectEventFavTop->show();
+ LPESelectorEffectFavTop->set_from_icon_name("draw-star", Gtk::IconSize(Gtk::ICON_SIZE_SMALL_TOOLBAR));
+ LPESelectorEffectFav->set_from_icon_name("draw-star", Gtk::IconSize(Gtk::ICON_SIZE_SMALL_TOOLBAR));
+ sp_add_fav(LPEName->get_text());
+ LPESelectorEffect->get_parent()->get_style_context()->add_class("lpefav");
+ LPESelectorEffect->get_parent()->get_style_context()->remove_class("lpenormal");
+ LPESelectorEffect->get_parent()->get_style_context()->add_class("lpe");
+ }
+ }
+ return true;
+}
+
+bool LivePathEffectAdd::show_fav_toggler(GdkEventButton *evt)
+{
+ _showfavs = !_showfavs;
+ Gtk::Image *favimage = dynamic_cast<Gtk::Image *>(_LPESelectorEffectEventFavShow->get_child());
+ if (favimage) {
+ if (_showfavs) {
+ favimage->set_from_icon_name("draw-star", Gtk::IconSize(Gtk::ICON_SIZE_SMALL_TOOLBAR));
+ } else {
+ favimage->set_from_icon_name("draw-star-outline", Gtk::IconSize(Gtk::ICON_SIZE_SMALL_TOOLBAR));
+ }
+ }
+ reload_effect_list();
+ return true;
+}
+
+bool LivePathEffectAdd::apply(GdkEventButton *evt, Glib::RefPtr<Gtk::Builder> builder_effect,
+ const LivePathEffect::EnumEffectData<LivePathEffect::EffectType> *to_add)
+{
+ _to_add = to_add;
+ Gtk::EventBox *LPESelectorEffect;
+ builder_effect->get_widget("LPESelectorEffect", LPESelectorEffect);
+ Gtk::FlowBoxChild *flowboxchild = dynamic_cast<Gtk::FlowBoxChild *>(LPESelectorEffect->get_parent());
+ _LPESelectorFlowBox->select_child(*flowboxchild);
+ if (flowboxchild && flowboxchild->get_style_context()->has_class("lpedisabled")) {
+ return true;
+ }
+ _applied = true;
+ _lasteffect = flowboxchild;
+ _LPEDialogSelector->response(Gtk::RESPONSE_APPLY);
+ _LPEDialogSelector->hide();
+ return true;
+}
+
+bool LivePathEffectAdd::on_press_enter(GdkEventKey *key, Glib::RefPtr<Gtk::Builder> builder_effect,
+ const LivePathEffect::EnumEffectData<LivePathEffect::EffectType> *to_add)
+{
+ if (key->keyval == 65293 || key->keyval == 65421) {
+ _to_add = to_add;
+ Gtk::EventBox *LPESelectorEffect;
+ builder_effect->get_widget("LPESelectorEffect", LPESelectorEffect);
+ Gtk::FlowBoxChild *flowboxchild = dynamic_cast<Gtk::FlowBoxChild *>(LPESelectorEffect->get_parent());
+ if (flowboxchild && flowboxchild->get_style_context()->has_class("lpedisabled")) {
+ return true;
+ }
+ _applied = true;
+ _lasteffect = flowboxchild;
+ _LPEDialogSelector->response(Gtk::RESPONSE_APPLY);
+ _LPEDialogSelector->hide();
+ return true;
+ }
+ return false;
+}
+
+bool LivePathEffectAdd::expand(GdkEventButton *evt, Glib::RefPtr<Gtk::Builder> builder_effect)
+{
+ Gtk::EventBox *LPESelectorEffect;
+ builder_effect->get_widget("LPESelectorEffect", LPESelectorEffect);
+ Gtk::FlowBoxChild *child = dynamic_cast<Gtk::FlowBoxChild *>(LPESelectorEffect->get_parent());
+ if (child) {
+ child->grab_focus();
+ }
+ return true;
+}
+
+
+
+bool LivePathEffectAdd::on_filter(Gtk::FlowBoxChild *child)
+{
+ std::vector<Glib::ustring> classes = child->get_style_context()->list_classes();
+ int pos = 0;
+ for (auto childclass : classes) {
+ size_t s = childclass.find("LPEIndex", 0);
+ if (s != -1) {
+ childclass = childclass.erase(0, 8);
+ pos = std::stoi(childclass.raw());
+ }
+ }
+ const LivePathEffect::EnumEffectData<LivePathEffect::EffectType> *data = &converter.data(pos);
+ bool disable = false;
+ if (_item_type == "group" && !converter.get_on_group(data->id)) {
+ disable = true;
+ } else if (_item_type == "shape" && !converter.get_on_shape(data->id)) {
+ disable = true;
+ } else if (_item_type == "path" && !converter.get_on_path(data->id)) {
+ disable = true;
+ }
+
+ if (!_has_clip && data->id == Inkscape::LivePathEffect::POWERCLIP) {
+ disable = true;
+ }
+ if (!_has_mask && data->id == Inkscape::LivePathEffect::POWERMASK) {
+ disable = true;
+ }
+
+ if (disable) {
+ child->get_style_context()->add_class("lpedisabled");
+ } else {
+ child->get_style_context()->remove_class("lpedisabled");
+ }
+ child->set_valign(Gtk::ALIGN_START);
+ Gtk::EventBox *eventbox = dynamic_cast<Gtk::EventBox *>(child->get_child());
+ if (eventbox) {
+ Gtk::Box *box = dynamic_cast<Gtk::Box *>(eventbox->get_child());
+ if (box) {
+ std::vector<Gtk::Widget *> contents = box->get_children();
+ Gtk::Overlay *overlay = dynamic_cast<Gtk::Overlay *>(contents[0]);
+ std::vector<Gtk::Widget *> content_overlay = overlay->get_children();
+
+ Gtk::Label *lpename = dynamic_cast<Gtk::Label *>(contents[1]);
+ if (!sp_has_fav(lpename->get_text()) && _showfavs) {
+ return false;
+ }
+ Gtk::ToggleButton *experimental = dynamic_cast<Gtk::ToggleButton *>(contents[3]);
+ if (experimental) {
+ if (experimental->get_active() && !_LPEExperimental->get_active()) {
+ return false;
+ }
+ }
+ Gtk::Label *lpedesc = dynamic_cast<Gtk::Label *>(contents[2]);
+ if (lpedesc) {
+ size_t s = lpedesc->get_text().uppercase().find(_LPEFilter->get_text().uppercase(), 0);
+ if (s != -1) {
+ _visiblelpe++;
+ return true;
+ }
+ }
+ if (_LPEFilter->get_text().length() < 1) {
+ _visiblelpe++;
+ return true;
+ }
+ if (lpename) {
+ size_t s = lpename->get_text().uppercase().find(_LPEFilter->get_text().uppercase(), 0);
+ if (s != -1) {
+ _visiblelpe++;
+ return true;
+ }
+ }
+ }
+ }
+ return false;
+}
+
+void LivePathEffectAdd::reload_effect_list()
+{
+ /* if(_LPEExperimental->get_active()) {
+ _LPEExperimental->get_style_context()->add_class("active");
+ } else {
+ _LPEExperimental->get_style_context()->remove_class("active");
+ } */
+ _visiblelpe = 0;
+ _LPESelectorFlowBox->invalidate_filter();
+ if (_showfavs) {
+ if (_visiblelpe == 0) {
+ _LPEInfo->set_text(_("You don't have any favorites yet. Click on the favorites star again to see all LPEs."));
+ _LPEInfo->set_visible(true);
+ _LPEInfo->get_style_context()->add_class("lpeinfowarn");
+ } else {
+ _LPEInfo->set_text(_("These are your favorite effects"));
+ _LPEInfo->set_visible(true);
+ _LPEInfo->get_style_context()->add_class("lpeinfowarn");
+ }
+ } else {
+ _LPEInfo->set_text(_("Nothing found! Please try again with different search terms."));
+ _LPEInfo->set_visible(false);
+ _LPEInfo->get_style_context()->remove_class("lpeinfowarn");
+ }
+}
+
+void LivePathEffectAdd::on_search()
+{
+ _visiblelpe = 0;
+ _LPESelectorFlowBox->invalidate_filter();
+ if (_showfavs) {
+ if (_visiblelpe == 0) {
+ _LPEInfo->set_text(_("Nothing found! Please try again with different search terms."));
+ _LPEInfo->set_visible(true);
+ _LPEInfo->get_style_context()->add_class("lpeinfowarn");
+ } else {
+ _LPEInfo->set_visible(true);
+ _LPEInfo->get_style_context()->add_class("lpeinfowarn");
+ }
+ } else {
+ if (_visiblelpe == 0) {
+ _LPEInfo->set_text(_("Nothing found! Please try again with different search terms."));
+ _LPEInfo->set_visible(true);
+ _LPEInfo->get_style_context()->add_class("lpeinfowarn");
+ } else {
+ _LPEInfo->set_visible(false);
+ _LPEInfo->get_style_context()->remove_class("lpeinfowarn");
+ }
+ }
+}
+
+int LivePathEffectAdd::on_sort(Gtk::FlowBoxChild *child1, Gtk::FlowBoxChild *child2)
+{
+ Glib::ustring name1 = "";
+ Glib::ustring name2 = "";
+ Gtk::EventBox *eventbox = dynamic_cast<Gtk::EventBox *>(child1->get_child());
+ Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+ gint mode = prefs->getInt("/dialogs/livepatheffect/dialogmode", 0);
+ if (mode == 2) {
+ eventbox->set_halign(Gtk::ALIGN_START);
+ } else {
+ eventbox->set_halign(Gtk::ALIGN_CENTER);
+ }
+ if (eventbox) {
+ Gtk::Box *box = dynamic_cast<Gtk::Box *>(eventbox->get_child());
+ if (mode == 2) {
+ box->set_orientation(Gtk::ORIENTATION_HORIZONTAL);
+ } else {
+ box->set_orientation(Gtk::ORIENTATION_VERTICAL);
+ }
+ if (box) {
+ std::vector<Gtk::Widget *> contents = box->get_children();
+ Gtk::Label *lpename = dynamic_cast<Gtk::Label *>(contents[1]);
+ name1 = lpename->get_text();
+ if (lpename) {
+ if (mode == 2) {
+ lpename->set_justify(Gtk::JUSTIFY_LEFT);
+ lpename->set_halign(Gtk::ALIGN_START);
+ lpename->set_valign(Gtk::ALIGN_CENTER);
+ lpename->set_width_chars(-1);
+ lpename->set_max_width_chars(-1);
+ } else {
+ lpename->set_justify(Gtk::JUSTIFY_CENTER);
+ lpename->set_halign(Gtk::ALIGN_CENTER);
+ lpename->set_valign(Gtk::ALIGN_CENTER);
+ lpename->set_width_chars(14);
+ lpename->set_max_width_chars(23);
+ }
+ }
+ Gtk::EventBox *lpemore = dynamic_cast<Gtk::EventBox *>(contents[4]);
+ if (lpemore) {
+ if (mode == 2) {
+ lpemore->hide();
+ } else {
+ if (child1->is_selected()) {
+ lpemore->hide();
+ } else {
+ lpemore->show();
+ }
+ }
+ }
+ Gtk::ButtonBox *lpebuttonbox = dynamic_cast<Gtk::ButtonBox *>(contents[5]);
+ if (lpebuttonbox) {
+ if (mode == 2) {
+ lpebuttonbox->hide();
+ } else {
+ if (child1->is_selected()) {
+ lpebuttonbox->show();
+ } else {
+ lpebuttonbox->hide();
+ }
+ }
+ }
+ Gtk::Label *lpedesc = dynamic_cast<Gtk::Label *>(contents[2]);
+ if (lpedesc) {
+ if (mode == 2) {
+ lpedesc->show();
+ lpedesc->set_justify(Gtk::JUSTIFY_LEFT);
+ lpedesc->set_halign(Gtk::ALIGN_START);
+ lpedesc->set_valign(Gtk::ALIGN_CENTER);
+ lpedesc->set_ellipsize(Pango::ELLIPSIZE_END);
+ } else {
+ lpedesc->hide();
+ lpedesc->set_justify(Gtk::JUSTIFY_CENTER);
+ lpedesc->set_halign(Gtk::ALIGN_CENTER);
+ lpedesc->set_valign(Gtk::ALIGN_CENTER);
+ lpedesc->set_ellipsize(Pango::ELLIPSIZE_NONE);
+ }
+ }
+ Gtk::Overlay *overlay = dynamic_cast<Gtk::Overlay *>(contents[0]);
+ if (overlay) {
+ std::vector<Gtk::Widget *> contents_overlay = overlay->get_children();
+ Gtk::Image *icon = dynamic_cast<Gtk::Image *>(contents_overlay[0]);
+ if (icon) {
+ if (mode == 2) {
+ icon->set_pixel_size(40);
+ icon->set_margin_end(25);
+ overlay->set_margin_end(5);
+ } else {
+ icon->set_pixel_size(60);
+ icon->set_margin_end(0);
+ overlay->set_margin_end(0);
+ }
+ }
+ Gtk::EventBox *LPESelectorEffectEventFavTop = dynamic_cast<Gtk::EventBox *>(contents_overlay[1]);
+ if (LPESelectorEffectEventFavTop) {
+ Gtk::Image *fav = dynamic_cast<Gtk::Image *>(LPESelectorEffectEventFavTop->get_child());
+ if (sp_has_fav(name1)) {
+ fav->set_from_icon_name("draw-star", Gtk::IconSize(Gtk::ICON_SIZE_SMALL_TOOLBAR));
+ LPESelectorEffectEventFavTop->set_visible(true);
+ LPESelectorEffectEventFavTop->show();
+ child1->get_style_context()->add_class("lpefav");
+ child1->get_style_context()->remove_class("lpenormal");
+ } else if (!sp_has_fav(name1)) {
+ fav->set_from_icon_name("draw-star-outline", Gtk::IconSize(Gtk::ICON_SIZE_SMALL_TOOLBAR));
+ LPESelectorEffectEventFavTop->set_visible(false);
+ LPESelectorEffectEventFavTop->hide();
+ child1->get_style_context()->remove_class("lpefav");
+ child1->get_style_context()->add_class("lpenormal");
+ }
+ if (mode == 2) {
+ LPESelectorEffectEventFavTop->set_visible(true);
+ LPESelectorEffectEventFavTop->show();
+ LPESelectorEffectEventFavTop->set_halign(Gtk::ALIGN_END);
+ LPESelectorEffectEventFavTop->set_valign(Gtk::ALIGN_CENTER);
+ } else {
+ LPESelectorEffectEventFavTop->set_halign(Gtk::ALIGN_END);
+ LPESelectorEffectEventFavTop->set_valign(Gtk::ALIGN_START);
+ }
+ child1->get_style_context()->add_class("lpe");
+ }
+ }
+ }
+ }
+ eventbox = dynamic_cast<Gtk::EventBox *>(child2->get_child());
+ if (mode == 2) {
+ eventbox->set_halign(Gtk::ALIGN_START);
+ } else {
+ eventbox->set_halign(Gtk::ALIGN_CENTER);
+ }
+ if (eventbox) {
+ Gtk::Box *box = dynamic_cast<Gtk::Box *>(eventbox->get_child());
+ if (mode == 2) {
+ box->set_orientation(Gtk::ORIENTATION_HORIZONTAL);
+ } else {
+ box->set_orientation(Gtk::ORIENTATION_VERTICAL);
+ }
+ if (box) {
+ std::vector<Gtk::Widget *> contents = box->get_children();
+ Gtk::Label *lpename = dynamic_cast<Gtk::Label *>(contents[1]);
+ name2 = lpename->get_text();
+ if (lpename) {
+ if (mode == 2) {
+ lpename->set_justify(Gtk::JUSTIFY_LEFT);
+ lpename->set_halign(Gtk::ALIGN_START);
+ lpename->set_valign(Gtk::ALIGN_CENTER);
+ lpename->set_width_chars(-1);
+ lpename->set_max_width_chars(-1);
+ } else {
+ lpename->set_justify(Gtk::JUSTIFY_CENTER);
+ lpename->set_halign(Gtk::ALIGN_CENTER);
+ lpename->set_valign(Gtk::ALIGN_CENTER);
+ lpename->set_width_chars(14);
+ lpename->set_max_width_chars(23);
+ }
+ }
+ Gtk::EventBox *lpemore = dynamic_cast<Gtk::EventBox *>(contents[4]);
+ if (lpemore) {
+ if (mode == 2) {
+ lpemore->hide();
+ } else {
+ if (child2->is_selected()) {
+ lpemore->hide();
+ } else {
+ lpemore->show();
+ }
+ }
+ }
+ Gtk::ButtonBox *lpebuttonbox = dynamic_cast<Gtk::ButtonBox *>(contents[5]);
+ if (lpebuttonbox) {
+ if (mode == 2) {
+ lpebuttonbox->hide();
+ } else {
+ if (child2->is_selected()) {
+ lpebuttonbox->show();
+ } else {
+ lpebuttonbox->hide();
+ }
+ }
+ }
+ Gtk::Label *lpedesc = dynamic_cast<Gtk::Label *>(contents[2]);
+ if (lpedesc) {
+ if (mode == 2) {
+ lpedesc->show();
+ lpedesc->set_justify(Gtk::JUSTIFY_LEFT);
+ lpedesc->set_halign(Gtk::ALIGN_START);
+ lpedesc->set_valign(Gtk::ALIGN_CENTER);
+ lpedesc->set_ellipsize(Pango::ELLIPSIZE_END);
+ } else {
+ lpedesc->hide();
+ lpedesc->set_justify(Gtk::JUSTIFY_CENTER);
+ lpedesc->set_halign(Gtk::ALIGN_CENTER);
+ lpedesc->set_valign(Gtk::ALIGN_CENTER);
+ lpedesc->set_ellipsize(Pango::ELLIPSIZE_NONE);
+ }
+ }
+ Gtk::Overlay *overlay = dynamic_cast<Gtk::Overlay *>(contents[0]);
+ if (overlay) {
+ std::vector<Gtk::Widget *> contents_overlay = overlay->get_children();
+ Gtk::Image *icon = dynamic_cast<Gtk::Image *>(contents_overlay[0]);
+ if (icon) {
+ if (mode == 2) {
+ icon->set_pixel_size(33);
+ icon->set_margin_end(40);
+ } else {
+ icon->set_pixel_size(60);
+ icon->set_margin_end(0);
+ }
+ }
+ Gtk::EventBox *LPESelectorEffectEventFavTop = dynamic_cast<Gtk::EventBox *>(contents_overlay[1]);
+ Gtk::Image *fav = dynamic_cast<Gtk::Image *>(LPESelectorEffectEventFavTop->get_child());
+ if (LPESelectorEffectEventFavTop) {
+ if (sp_has_fav(name2)) {
+ fav->set_from_icon_name("draw-star", Gtk::IconSize(Gtk::ICON_SIZE_SMALL_TOOLBAR));
+ LPESelectorEffectEventFavTop->set_visible(true);
+ LPESelectorEffectEventFavTop->show();
+ child2->get_style_context()->add_class("lpefav");
+ child2->get_style_context()->remove_class("lpenormal");
+ } else if (!sp_has_fav(name2)) {
+ fav->set_from_icon_name("draw-star-outline", Gtk::IconSize(Gtk::ICON_SIZE_SMALL_TOOLBAR));
+ LPESelectorEffectEventFavTop->set_visible(false);
+ LPESelectorEffectEventFavTop->hide();
+ child2->get_style_context()->remove_class("lpefav");
+ child2->get_style_context()->add_class("lpenormal");
+ }
+ if (mode == 2) {
+ LPESelectorEffectEventFavTop->set_visible(true);
+ LPESelectorEffectEventFavTop->show();
+ LPESelectorEffectEventFavTop->set_halign(Gtk::ALIGN_END);
+ LPESelectorEffectEventFavTop->set_valign(Gtk::ALIGN_CENTER);
+ } else {
+ LPESelectorEffectEventFavTop->set_halign(Gtk::ALIGN_END);
+ LPESelectorEffectEventFavTop->set_valign(Gtk::ALIGN_START);
+ }
+ child2->get_style_context()->add_class("lpe");
+ }
+ }
+ }
+ }
+ std::vector<Glib::ustring> effect;
+ effect.push_back(name1);
+ effect.push_back(name2);
+ sort(effect.begin(), effect.end());
+ /* if (sp_has_fav(name1) && sp_has_fav(name2)) {
+ return effect[0] == name1?-1:1;
+ }
+ if (sp_has_fav(name1)) {
+ return -1;
+ } */
+ if (effect[0] == name1) { //&& !sp_has_fav(name2)) {
+ return -1;
+ }
+ return 1;
+}
+
+
+void LivePathEffectAdd::onClose() { _LPEDialogSelector->hide(); }
+
+void LivePathEffectAdd::onKeyEvent(GdkEventKey *evt)
+{
+ if (evt->keyval == GDK_KEY_Escape) {
+ onClose();
+ }
+}
+
+void LivePathEffectAdd::show(SPDesktop *desktop)
+{
+ LivePathEffectAdd &dial = instance();
+ Inkscape::Selection *sel = desktop->getSelection();
+ if (sel && !sel->isEmpty()) {
+ SPItem *item = sel->singleItem();
+ if (item) {
+ SPShape *shape = dynamic_cast<SPShape *>(item);
+ SPPath *path = dynamic_cast<SPPath *>(item);
+ SPGroup *group = dynamic_cast<SPGroup *>(item);
+ dial._has_clip = (item->getClipObject() != nullptr);
+ dial._has_mask = (item->getMaskObject() != nullptr);
+ dial._item_type = "";
+ if (group) {
+ dial._item_type = "group";
+ } else if (path) {
+ dial._item_type = "path";
+ } else if (shape) {
+ dial._item_type = "shape";
+ } else {
+ dial._LPEDialogSelector->hide();
+ return;
+ }
+ }
+ }
+ dial._applied = false;
+ dial._LPESelectorFlowBox->unset_sort_func();
+ dial._LPESelectorFlowBox->unset_filter_func();
+ dial._LPESelectorFlowBox->set_filter_func(sigc::mem_fun(dial, &LivePathEffectAdd::on_filter));
+ dial._LPESelectorFlowBox->set_sort_func(sigc::mem_fun(dial, &LivePathEffectAdd::on_sort));
+ Glib::RefPtr<Gtk::Adjustment> vadjust = dial._LPEScrolled->get_vadjustment();
+ vadjust->set_value(vadjust->get_lower());
+ Gtk::Window *window = desktop->getToplevel();
+ dial._LPEDialogSelector->set_transient_for(*window);
+ dial._LPEDialogSelector->show();
+ int searchlen = dial._LPEFilter->get_text().length();
+ if (searchlen > 0) {
+ dial._LPEFilter->select_region (0, searchlen);
+ dial._LPESelectorFlowBox->unselect_all();
+ } else if (dial._lasteffect) {
+ dial._lasteffect->grab_focus();
+ }
+ dial._LPEDialogSelector->run();
+ dial._LPEDialogSelector->hide();
+}
+
+} // namespace Dialog
+} // namespace UI
+} // 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 :