diff options
Diffstat (limited to 'src/ui/dialog/command-palette.cpp')
| -rw-r--r-- | src/ui/dialog/command-palette.cpp | 1636 |
1 files changed, 1636 insertions, 0 deletions
diff --git a/src/ui/dialog/command-palette.cpp b/src/ui/dialog/command-palette.cpp new file mode 100644 index 0000000..32d2ca9 --- /dev/null +++ b/src/ui/dialog/command-palette.cpp @@ -0,0 +1,1636 @@ +// SPDX-License-Identifier: GPL-2.0-or-later +/** + * @file + * Dialog for adding a live path effect. + * + * Author: + * Abhay Raj Singh <abhayonlyone@gmail.com> + * + * Copyright (C) 2020 Authors + * Released under GNU GPL v2+, read the file 'COPYING' for more information. + */ + +#include "command-palette.h" + +#include <cstddef> +#include <cstring> +#include <ctime> +#include <gdk/gdkkeysyms.h> +#include <giomm/action.h> +#include <giomm/application.h> +#include <giomm/file.h> +#include <giomm/fileinfo.h> +#include <glib/gi18n.h> +#include <glibconfig.h> +#include <glibmm/convert.h> +#include <glibmm/date.h> +#include <glibmm/error.h> +#include <glibmm/i18n.h> +#include <glibmm/markup.h> +#include <glibmm/ustring.h> +#include <gtkmm/application.h> +#include <gtkmm/box.h> +#include <gtkmm/enums.h> +#include <gtkmm/eventbox.h> +#include <gtkmm/label.h> +#include <gtkmm/messagedialog.h> +#include <gtkmm/recentinfo.h> +#include <iostream> +#include <iterator> +#include <memory> +#include <optional> +#include <ostream> +#include <sigc++/adaptors/bind.h> +#include <sigc++/functors/mem_fun.h> +#include <string> + +#include "actions/actions-extra-data.h" +#include "file.h" +#include "gc-anchored.h" +#include "include/glibmm_version.h" +#include "inkscape-application.h" +#include "inkscape-window.h" +#include "inkscape.h" +#include "io/resource.h" +#include "message-context.h" +#include "message-stack.h" +#include "object/uri.h" +#include "preferences.h" +#include "ui/interface.h" +#include "xml/repr.h" + +namespace Inkscape { +class MessageStack; +namespace UI { +namespace Dialog { + +namespace { +template <typename T> +void debug_print(T variable) +{ + std::cerr << variable << std::endl; +} +} // namespace + +// constructor +CommandPalette::CommandPalette() +{ + // setup _builder + { + auto gladefile = get_filename_string(Inkscape::IO::Resource::UIS, "command-palette-main.glade"); + try { + _builder = Gtk::Builder::create_from_file(gladefile); + } catch (const Glib::Error &ex) { + g_warning("Glade file loading failed for command palette dialog"); + return; + } + } + + // Setup Base UI Components + _builder->get_widget("CPBase", _CPBase); + _builder->get_widget("CPHeader", _CPHeader); + _builder->get_widget("CPListBase", _CPListBase); + + _builder->get_widget("CPSearchBar", _CPSearchBar); + _builder->get_widget("CPFilter", _CPFilter); + + _builder->get_widget("CPSuggestions", _CPSuggestions); + _builder->get_widget("CPHistory", _CPHistory); + + _builder->get_widget("CPSuggestionsScroll", _CPSuggestionsScroll); + _builder->get_widget("CPHistoryScroll", _CPHistoryScroll); + + _CPBase->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); + + // TODO: Customise on user language RTL, LTR or better user preference + _CPBase->set_halign(Gtk::ALIGN_CENTER); + _CPBase->set_valign(Gtk::ALIGN_START); + + _CPFilter->signal_key_press_event().connect(sigc::mem_fun(*this, &CommandPalette::on_key_press_cpfilter_escape), + false); + _CPSuggestions->signal_key_press_event().connect(sigc::mem_fun(*this, &CommandPalette::on_key_press_cpfilter_escape), false); + _CPHistory->signal_key_press_event().connect(sigc::mem_fun(*this, &CommandPalette::on_key_press_cpfilter_escape), false); + set_mode(CPMode::SEARCH); + + _CPSuggestions->set_activate_on_single_click(); + _CPSuggestions->set_selection_mode(Gtk::SELECTION_SINGLE); + + // Setup operations [actions, extensions] + { + // setup recent files + { + //TODO: refactor this ============================== + // this code is repeated in menubar.cpp + auto recent_manager = Gtk::RecentManager::get_default(); + auto recent_files = recent_manager->get_items(); // all recent files not necessarily inkscape only + + int max_files = Inkscape::Preferences::get()->getInt("/options/maxrecentdocuments/value"); + + for (auto const &recent_file : recent_files) { + // check if given was generated by inkscape + bool valid_file = recent_file->has_application(g_get_prgname()) or + recent_file->has_application("org.inkscape.Inkscape") or + recent_file->has_application("inkscape") or + recent_file->has_application("inkscape.exe"); + + valid_file = valid_file and recent_file->exists(); + + if (not valid_file) { + continue; + } + + if (max_files-- <= 0) { + break; + } + + append_recent_file_operation(recent_file->get_uri_display(), true, + false); // open - second param true to append in _CPSuggestions + append_recent_file_operation(recent_file->get_uri_display(), true, + true); // import - last param true for import operation + } + // ================================================== + } + } + + // History management + { + const auto history = _history_xml.get_operation_history(); + + for (const auto &page : history) { + // second params false to append in history + switch (page.history_type) { + case HistoryType::ACTION: + generate_action_operation(get_action_ptr_name(page.data), false); + break; + case HistoryType::IMPORT_FILE: + append_recent_file_operation(page.data, false, true); + break; + case HistoryType::OPEN_FILE: + append_recent_file_operation(page.data, false, false); + break; + default: + continue; + } + } + } + // for `enter to execute` feature + _CPSuggestions->signal_row_activated().connect(sigc::mem_fun(*this, &CommandPalette::on_row_activated)); +} + +void CommandPalette::open() +{ + if (not _win_doc_actions_loaded) { + // loading actions can be very slow + load_app_actions(); + // win doc don't exist at construction so loading at first time opening Command Palette + load_win_doc_actions(); + _win_doc_actions_loaded = true; + } + _CPBase->show_all(); + _CPFilter->grab_focus(); + _is_open = true; +} + +void CommandPalette::close() +{ + _CPBase->hide(); + + // Reset filtering - show all suggestions + _CPFilter->set_text(""); + _CPSuggestions->invalidate_filter(); + + set_mode(CPMode::SEARCH); + + _is_open = false; +} + +void CommandPalette::toggle() +{ + if (not _is_open) { + open(); + return; + } + close(); +} + +void CommandPalette::append_recent_file_operation(const Glib::ustring &path, bool is_suggestion, bool is_import) +{ + static const auto gladefile = get_filename_string(Inkscape::IO::Resource::UIS, "command-palette-operation.glade"); + Glib::RefPtr<Gtk::Builder> operation_builder; + try { + operation_builder = Gtk::Builder::create_from_file(gladefile); + } catch (const Glib::Error &ex) { + g_warning("Glade file loading failed for Command Palette operation dialog"); + } + + // declaring required widgets pointers + Gtk::EventBox *CPOperation; + Gtk::Box *CPSynapseBox; + + Gtk::Label *CPGroup; + Gtk::Label *CPName; + Gtk::Label *CPShortcut; + Gtk::Button *CPActionFullName; + Gtk::Label *CPDescription; + + // Reading widgets + operation_builder->get_widget("CPOperation", CPOperation); + operation_builder->get_widget("CPSynapseBox", CPSynapseBox); + + operation_builder->get_widget("CPGroup", CPGroup); + operation_builder->get_widget("CPName", CPName); + operation_builder->get_widget("CPShortcut", CPShortcut); + operation_builder->get_widget("CPActionFullName", CPActionFullName); + operation_builder->get_widget("CPDescription", CPDescription); + + const auto file = Gio::File::create_for_path(path); + if (file->query_exists()) { + const Glib::ustring file_name = file->get_basename(); + + if (is_import) { + // Used for Activate row signal of listbox and not + CPGroup->set_text("import"); + CPActionFullName->set_label("import"); // For filtering only + + } else { + CPGroup->set_text("open"); + CPActionFullName->set_label("open"); // For filtering only + } + + // Hide for recent_file, not required + CPActionFullName->set_no_show_all(); + CPActionFullName->hide(); + + CPName->set_text((is_import ? _("Import") : _("Open")) + (": " + file_name)); + CPName->set_tooltip_text((is_import ? ("Import") : ("Open")) + (": " + file_name)); // Tooltip_text are not translatable + CPDescription->set_text(path); + CPDescription->set_tooltip_text(path); + + { + Glib::DateTime mod_time; +#if GLIBMM_CHECK_VERSION(2, 62, 0) + mod_time = file->query_info()->get_modification_date_time(); + // Using this to reduce instead of ActionFullName widget because fullname is searched +#else + mod_time.create_now_local(file->query_info()->modification_time()); +#endif + CPShortcut->set_text(mod_time.format("%d %b %R")); + } + // Add to suggestions + if (is_suggestion) { + _CPSuggestions->append(*CPOperation); + } else { + _CPHistory->append(*CPOperation); + } + } +} + +bool CommandPalette::generate_action_operation(const ActionPtrName &action_ptr_name, bool is_suggestion) +{ + static const auto app = InkscapeApplication::instance(); + static const auto gapp = app->gtk_app(); + static InkActionExtraData &action_data = app->get_action_extra_data(); + static const bool show_full_action_name = + Inkscape::Preferences::get()->getBool("/options/commandpalette/showfullactionname/value"); + static const auto gladefile = get_filename_string(Inkscape::IO::Resource::UIS, "command-palette-operation.glade"); + + Glib::RefPtr<Gtk::Builder> operation_builder; + try { + operation_builder = Gtk::Builder::create_from_file(gladefile); + } catch (const Glib::Error &ex) { + g_warning("Glade file loading failed for Command Palette operation dialog"); + return false; + } + + // declaring required widgets pointers + Gtk::EventBox *CPOperation; + Gtk::Box *CPSynapseBox; + + Gtk::Label *CPGroup; + Gtk::Label *CPName; + Gtk::Label *CPShortcut; + Gtk::Label *CPDescription; + Gtk::Button *CPActionFullName; + + // Reading widgets + operation_builder->get_widget("CPOperation", CPOperation); + operation_builder->get_widget("CPSynapseBox", CPSynapseBox); + + operation_builder->get_widget("CPGroup", CPGroup); + operation_builder->get_widget("CPName", CPName); + operation_builder->get_widget("CPShortcut", CPShortcut); + operation_builder->get_widget("CPActionFullName", CPActionFullName); + operation_builder->get_widget("CPDescription", CPDescription); + + CPGroup->set_text(action_data.get_section_for_action(Glib::ustring(action_ptr_name.second))); + + // Setting CPName + { + auto name = action_data.get_label_for_action(action_ptr_name.second); + auto untranslated_name = action_data.get_label_for_action(action_ptr_name.second, false); + if (name.empty()) { + // If action doesn't have a label, set the name = full action name + name = action_ptr_name.second; + untranslated_name = action_ptr_name.second; + } + + CPName->set_text(name); + CPName->set_tooltip_text(untranslated_name); + } + + { + CPActionFullName->set_label(action_ptr_name.second); + + if (not show_full_action_name) { + CPActionFullName->set_no_show_all(); + CPActionFullName->hide(); + } else { + CPActionFullName->signal_clicked().connect( + sigc::bind<Glib::ustring>(sigc::mem_fun(*this, &CommandPalette::on_action_fullname_clicked), + action_ptr_name.second), + false); + } + } + + { + std::vector<Glib::ustring> accels = gapp->get_accels_for_action(action_ptr_name.second); + std::stringstream ss; + for (const auto &accel : accels) { + ss << accel << ','; + } + std::string accel_label = ss.str(); + + if (not accel_label.empty()) { + accel_label.pop_back(); + CPShortcut->set_text(accel_label); + } else { + CPShortcut->set_no_show_all(); + CPShortcut->hide(); + } + } + + CPDescription->set_text(action_data.get_tooltip_for_action(action_ptr_name.second)); + CPDescription->set_tooltip_text(action_data.get_tooltip_for_action(action_ptr_name.second, false)); + + // Add to suggestions + if (is_suggestion) { + _CPSuggestions->append(*CPOperation); + } else { + _CPHistory->append(*CPOperation); + } + + return true; +} + +void CommandPalette::on_search() +{ + _CPSuggestions->unset_sort_func(); + _CPSuggestions->set_sort_func(sigc::mem_fun(*this, &CommandPalette::on_sort)); + _search_text = _CPFilter->get_text(); + _CPSuggestions->invalidate_filter(); // Remove old filter constraint and apply new one + if (auto top_row = _CPSuggestions->get_row_at_y(0); top_row) { + _CPSuggestions->select_row(*top_row); // select top row + } +} + +bool CommandPalette::on_filter_full_action_name(Gtk::ListBoxRow *child) +{ + if (auto CPActionFullName = get_full_action_name(child); + CPActionFullName and _search_text == CPActionFullName->get_label()) { + return true; + } + return false; +} + +bool CommandPalette::on_filter_recent_file(Gtk::ListBoxRow *child, bool const is_import) +{ + auto CPActionFullName = get_full_action_name(child); + if (is_import) { + if (CPActionFullName and CPActionFullName->get_label() == "import") { + auto [CPName, CPDescription] = get_name_desc(child); + if (CPDescription && CPDescription->get_text() == _search_text) { + return true; + } + } + return false; + } + if (CPActionFullName and CPActionFullName->get_label() == "open") { + auto [CPName, CPDescription] = get_name_desc(child); + if (CPDescription && CPDescription->get_text() == _search_text) { + return true; + } + } + return false; +} + +bool CommandPalette::on_key_press_cpfilter_escape(GdkEventKey *evt) +{ + if (evt->keyval == GDK_KEY_Escape || evt->keyval == GDK_KEY_question) { + close(); + return true; // stop propagation of key press, not needed anymore + } + return false; // Pass the key event which are not used +} + +bool CommandPalette::on_key_press_cpfilter_search_mode(GdkEventKey *evt) +{ + auto key = evt->keyval; + if (key == GDK_KEY_Return or key == GDK_KEY_Linefeed) { + if (auto selected_row = _CPSuggestions->get_selected_row(); selected_row) { + selected_row->activate(); + } + return true; + } else if (key == GDK_KEY_Up) { + if (not _CPHistory->get_children().empty()) { + set_mode(CPMode::HISTORY); + return true; + } + } + return false; +} + +bool CommandPalette::on_key_press_cpfilter_history_mode(GdkEventKey *evt) +{ + if (evt->keyval == GDK_KEY_BackSpace) { + return true; + } + return false; +} + +/** + * Executes action when enter pressed + */ +bool CommandPalette::on_key_press_cpfilter_input_mode(GdkEventKey *evt, const ActionPtrName &action_ptr_name) +{ + switch (evt->keyval) { + case GDK_KEY_Return: + [[fallthrough]]; + case GDK_KEY_Linefeed: + execute_action(action_ptr_name, _CPFilter->get_text()); + close(); + return true; + } + return false; +} + +void CommandPalette::hide_suggestions() +{ + _CPBase->set_size_request(-1, 10); + _CPListBase->hide(); +} +void CommandPalette::show_suggestions() +{ + _CPBase->set_size_request(-1, _max_height_requestable); + _CPListBase->show_all(); +} + +void CommandPalette::on_action_fullname_clicked(const Glib::ustring &action_fullname) +{ + static auto clipboard = Gtk::Clipboard::get(); + clipboard->set_text(action_fullname); + clipboard->store(); +} + +void CommandPalette::on_row_activated(Gtk::ListBoxRow *activated_row) +{ + // this is set to import/export or full action name + const auto full_action_name = get_full_action_name(activated_row)->get_label(); + if (full_action_name == "import" or full_action_name == "open") { + const auto [name, description] = get_name_desc(activated_row); + operate_recent_file(description->get_text(), full_action_name == "import"); + } else { + ask_action_parameter(get_action_ptr_name(full_action_name)); + // this is an action + } +} + +void CommandPalette::on_history_selection_changed(Gtk::ListBoxRow *lb) +{ + // set the search box text to current selection + if (const auto name_label = get_name_desc(lb).first; name_label) { + _CPFilter->set_text(name_label->get_text()); + } +} + +bool CommandPalette::operate_recent_file(Glib::ustring const &uri, bool const import) +{ + static auto prefs = Inkscape::Preferences::get(); + + bool write_to_history = true; + + // if the last element in CPHistory is already this, don't update history file + if (not _CPHistory->get_children().empty()) { + if (const auto last_operation = _history_xml.get_last_operation(); last_operation.has_value()) { + if (uri == last_operation->data) { + bool last_operation_was_import = last_operation->history_type == HistoryType::IMPORT_FILE; + // As previous uri is verfied to be the same as current uri we can write to history if current and + // previous operation are not the same. + // For example: if we want to import and previous operation was import (with same uri) we should not + // write ot history, similarly if current is open and previous was open to then dont WTH. + // But in case previous operation was open and current is import and vice-versa we should write to + // history. + if (not(import xor last_operation_was_import)) { + write_to_history = false; + } + } + } + } + + if (import) { + prefs->setBool("/options/onimport", true); + file_import(SP_ACTIVE_DOCUMENT, uri, nullptr); + prefs->setBool("/options/onimport", true); + + if (write_to_history) { + _history_xml.add_import(uri); + } + + close(); + return true; + } + + // open + { + get_action_ptr_name("app.file-open").first->activate(uri); + if (write_to_history) { + _history_xml.add_open(uri); + } + } + + close(); + return true; +} // namespace Dialog + +/** + * Maybe replaced by: Temporary arrangement may be replaced by snippets + * This can help us provide parameters for multiple argument function + * whose actions take a string as param + */ +bool CommandPalette::ask_action_parameter(const ActionPtrName &action_ptr_name) +{ + // Avoid writing same last action again + // TODO: Merge the if else parts + if (const auto last_of_history = _history_xml.get_last_operation(); last_of_history.has_value()) { + // operation history is not empty + const auto last_full_action_name = last_of_history->data; + if (last_full_action_name != action_ptr_name.second) { + // last action is not the same so write this one + _history_xml.add_action(action_ptr_name.second); // to history file + generate_action_operation(action_ptr_name, false); // to _CPHistory + } + } else { + // History is empty so no need to check + _history_xml.add_action(action_ptr_name.second); // to history file + generate_action_operation(action_ptr_name, false); // to _CPHistory + } + + // Checking if action has handleable parameter type + TypeOfVariant action_param_type = get_action_variant_type(action_ptr_name.first); + if (action_param_type == TypeOfVariant::UNKNOWN) { + std::cerr << "CommandPalette::ask_action_parameter: unhandled action value type (Unknown Type) " + << action_ptr_name.second << std::endl; + return false; + } + + if (action_param_type != TypeOfVariant::NONE) { + set_mode(CPMode::INPUT); + + _cpfilter_key_press_connection = _CPFilter->signal_key_press_event().connect( + sigc::bind<ActionPtrName>(sigc::mem_fun(*this, &CommandPalette::on_key_press_cpfilter_input_mode), + action_ptr_name), + false); + + // get type string NOTE: Temporary should be replaced by adding some data to InkActionExtraDataj + Glib::ustring type_string; + switch (action_param_type) { + case TypeOfVariant::BOOL: + type_string = "bool"; + break; + case TypeOfVariant::INT: + type_string = "integer"; + break; + case TypeOfVariant::DOUBLE: + type_string = "double"; + break; + case TypeOfVariant::STRING: + type_string = "string"; + break; + case TypeOfVariant::TUPLE_DD: + type_string = "pair of doubles"; + break; + default: + break; + } + + const auto app = InkscapeApplication::instance(); + InkActionHintData &action_hint_data = app->get_action_hint_data(); + auto action_hint = action_hint_data.get_tooltip_hint_for_action(action_ptr_name.second, false); + + + // Indicate user about what to enter FIXME Dialog generation + if (action_hint.length()) { + _CPFilter->set_placeholder_text(action_hint); + _CPFilter->set_tooltip_text(action_hint); + } else { + _CPFilter->set_placeholder_text("Enter a " + type_string + "..."); + _CPFilter->set_tooltip_text("Enter a " + type_string + "..."); + } + + + return true; + } + + execute_action(action_ptr_name, ""); + close(); + + return true; +} + +/** + * Color removal + */ +void CommandPalette::remove_color(Gtk::Label *label, const Glib::ustring &subject, bool tooltip) +{ + if (tooltip) { + label->set_tooltip_text(subject); + } else if (label->get_use_markup()) { + label->set_text(subject); + } +} + +/** + * Color addition + */ +Glib::ustring make_bold(const Glib::ustring &search) +{ + // TODO: Add a CSS class that changes the color of the search + return "<span weight=\"bold\">" + search + "</span>"; +} + +void CommandPalette::add_color(Gtk::Label *label, const Glib::ustring &search, const Glib::ustring &subject, bool tooltip) +{ + Glib::ustring text = ""; + Glib::ustring subject_string = subject.lowercase(); + Glib::ustring search_string = search.lowercase(); + int j = 0; + + if (search_string.length() > 7) { + for (gunichar i : search_string) { + if (i == ' ') { + continue; + } + while (j < subject_string.length()) { + if (i == subject_string[j]) { + text += make_bold(Glib::Markup::escape_text(subject.substr(j, 1))); + j++; + break; + } else { + text += subject[j]; + } + j++; + } + } + if (j < subject.length()) { + text += Glib::Markup::escape_text(subject.substr(j)); + } + } else { + std::map<gunichar, int> search_string_character; + + for (const auto &character : search_string) { + search_string_character[character]++; + } + + int subject_length = subject_string.length(); + + for (int i = 0; i < subject_length; i++) { + if (search_string_character[subject_string[i]]--) { + text += make_bold(Glib::Markup::escape_text(subject.substr(i, 1))); + } else { + text += subject[i]; + } + } + } + + if (tooltip) { + label->set_tooltip_markup(text); + } else { + label->set_markup(text); + } +} + +/** + * Color addition for description text + * Coloring complete consecutive search text in the description text + */ +void CommandPalette::add_color_description(Gtk::Label *label, const Glib::ustring &search) +{ + Glib::ustring subject = label->get_text(); + + Glib::ustring const subject_normalize = subject.lowercase().normalize(); + Glib::ustring const search_normalize = search.lowercase().normalize(); + + auto const position = subject_normalize.find(search_normalize); + auto const search_length = search_normalize.size(); + + subject = Glib::Markup::escape_text(subject.substr(0, position)) + + make_bold(Glib::Markup::escape_text(subject.substr(position, search_length))) + + Glib::Markup::escape_text(subject.substr(position + search_length)); + + label->set_markup(subject); +} + +/** + * The Searching algorithm consists of fuzzy search and fuzzy points. + * + * Ever search of the label can contain up to three subjects to search + * CPName text,CPName tooltip text,CPDescription text + * + * Fuzzy search searches the search text in these subjects and returns a boolean + * Searching of a search text as a subsequence of the subject + * + * Fuzzy points give an integer of a particular search text concerning a particular subject. + * Less the fuzzy point more is the precedence. + * + * Special case for CPDescription text search by searching text as a substring of the subject + * + * TODO: Adding more conditions in fuzzy points and fuzzy search for creating better user experience + */ + +bool CommandPalette::fuzzy_tolerance_search(const Glib::ustring &subject, const Glib::ustring &search) +{ + Glib::ustring subject_string = subject.lowercase(); + Glib::ustring search_string = search.lowercase(); + std::map<gunichar, int> subject_string_character, search_string_character; + for (const auto &character : subject_string) { + subject_string_character[character]++; + } + for (const auto &character : search_string) { + search_string_character[character]++; + } + for (const auto &character : search_string_character) { + auto [alphabet, occurrence] = character; + if (subject_string_character[alphabet] < occurrence) { + return false; + } + } + return true; +} + +bool CommandPalette::fuzzy_search(const Glib::ustring &subject, const Glib::ustring &search) +{ + Glib::ustring subject_string = subject.lowercase(); + Glib::ustring search_string = search.lowercase(); + + for (int j = 0, i = 0; i < search_string.length(); i++) { + bool alphabet_present = false; + + while (j < subject_string.length()) { + if (search_string[i] == subject_string[j]) { + alphabet_present = true; + j++; + break; + } + j++; + } + + if (!alphabet_present) { + return false; // If not present + } + } + + return true; +} + +/** + * Searching the full search_text in the subject string + * used for CPDescription text + */ +bool CommandPalette::normal_search(const Glib::ustring &subject, const Glib::ustring &search) +{ + if (subject.lowercase().find(search.lowercase()) != -1) { + return true; + } + return false; +} + +/** + * Calculates the fuzzy_point + */ +int CommandPalette::fuzzy_points(const Glib::ustring &subject, const Glib::ustring &search) +{ + int fuzzy_cost = 100; // Taking initial fuzzy_cost as 100 + + constexpr int SEQUENTIAL_BONUS = -15; // bonus for adjacent matches + constexpr int SEPARATOR_BONUS = -30; // bonus if search occurs after a separator + constexpr int CAMEL_BONUS = -30; // bonus if search is uppercase and subject is lower + constexpr int FIRST_LETTET_BONUS = -15; // bonus if the first letter is matched + constexpr int LEADING_LETTER_PENALTY = +5; // penalty applied for every letter in subject before the first match + constexpr int MAX_LEADING_LETTER_PENALTY = +15; // maximum penalty for leading letters + constexpr int UNMATCHED_LETTER_PENALTY = +1; // penalty for every letter that doesn't matter + + Glib::ustring subject_string = subject.lowercase(); + Glib::ustring search_string = search.lowercase(); + + bool sequential_compare = false; + bool leading_letter = true; + int total_leading_letter_penalty = 0; + int j = 0, i = 0; + + while (i < search_string.length() && j < subject_string.length()) { + if (search_string[i] != subject_string[j]) { + j++; + sequential_compare = false; + fuzzy_cost += UNMATCHED_LETTER_PENALTY; + + if (leading_letter) { + if (total_leading_letter_penalty < MAX_LEADING_LETTER_PENALTY) { + fuzzy_cost += LEADING_LETTER_PENALTY; + total_leading_letter_penalty += LEADING_LETTER_PENALTY; + } + } + + continue; + } + + if (search_string[i] == subject_string[j]) { + leading_letter = false; + + if (j > 0 && subject_string[j - 1] == ' ') { + fuzzy_cost += SEPARATOR_BONUS; + } + + if (i == 0 && j == 0) { + fuzzy_cost += FIRST_LETTET_BONUS; + } + + if (search[i] == subject_string[j]) { + fuzzy_cost += CAMEL_BONUS; + } + + if (sequential_compare) { + fuzzy_cost += SEQUENTIAL_BONUS; + } + + sequential_compare = true; + i++; + } + } + + return fuzzy_cost; +} + +int CommandPalette::fuzzy_tolerance_points(const Glib::ustring &subject, const Glib::ustring &search) +{ + int fuzzy_cost = 200; // Taking initial fuzzy_cost as 200 + constexpr int FIRST_LETTET_BONUS = -15; // bonus if the first letter is matched + + Glib::ustring subject_string = subject.lowercase(); + Glib::ustring search_string = search.lowercase(); + + std::map<gunichar, int> search_string_character; + + for (const auto &character : search_string) { + search_string_character[character]++; + } + + for (const auto &character : search_string_character) { + auto [alphabet, occurrence] = character; + for (int i = 0; i < subject_string.length() && occurrence; i++) { + if (subject_string[i] == alphabet) { + if (i == 0) + fuzzy_cost += FIRST_LETTET_BONUS; + fuzzy_cost += i; + occurrence--; + } + } + } + + return fuzzy_cost; +} + +int CommandPalette::on_filter_general(Gtk::ListBoxRow *child) +{ + auto [CPName, CPDescription] = get_name_desc(child); + if (CPName) { + remove_color(CPName, CPName->get_text()); + remove_color(CPName, CPName->get_tooltip_text(), true); + } + if (CPDescription) { + remove_color(CPDescription, CPDescription->get_text()); + } + + if (_search_text.empty()) { + return 1; + } // Every operation is visible if search text is empty + + if (CPName) { + if (fuzzy_search(CPName->get_text(), _search_text)) { + add_color(CPName, _search_text, CPName->get_text()); + return fuzzy_points(CPName->get_text(), _search_text); + } + + if (fuzzy_search(CPName->get_tooltip_text(), _search_text)) { + add_color(CPName, _search_text, CPName->get_tooltip_text(), true); + return fuzzy_points(CPName->get_tooltip_text(), _search_text); + } + + if (fuzzy_tolerance_search(CPName->get_text(), _search_text)) { + add_color(CPName, _search_text, CPName->get_text()); + return fuzzy_tolerance_points(CPName->get_text(), _search_text); + } + + if (fuzzy_tolerance_search(CPName->get_tooltip_text(), _search_text)) { + add_color(CPName, _search_text, CPName->get_tooltip_text(), true); + return fuzzy_tolerance_points(CPName->get_tooltip_text(), _search_text); + } + } + if (CPDescription && normal_search(CPDescription->get_text(), _search_text)) { + add_color_description(CPDescription, _search_text); + return fuzzy_points(CPDescription->get_text(), _search_text); + } + + return 0; +} + +int CommandPalette::fuzzy_points_compare(int fuzzy_points_count_1, int fuzzy_points_count_2, int text_len_1, + int text_len_2) +{ + if (fuzzy_points_count_1 && fuzzy_points_count_2) { + if (fuzzy_points_count_1 < fuzzy_points_count_2) { + return -1; + } else if (fuzzy_points_count_1 == fuzzy_points_count_2) { + if (text_len_1 > text_len_2) { + return 1; + } else { + return -1; + } + } else { + return 1; + } + } + + if (fuzzy_points_count_1 == 0 && fuzzy_points_count_2) { + return 1; + } + if (fuzzy_points_count_2 == 0 && fuzzy_points_count_1) { + return -1; + } + + return 0; +} + +/** + * compare different rows for order of display + * priority of comparison + * 1) CPName->get_text() + * 2) CPName->get_tooltip_text() + * 3) CPDescription->get_text() + */ +int CommandPalette::on_sort(Gtk::ListBoxRow *row1, Gtk::ListBoxRow *row2) +{ + // tests for fuzzy_search + assert(fuzzy_search("Export background", "ebo") == true); + assert(fuzzy_search("Query y", "qyy") == true); + assert(fuzzy_search("window close", "qt") == false); + + // tests for fuzzy_points + assert(fuzzy_points("Export background", "ebo") == -22); + assert(fuzzy_points("Query y", "qyy") == -16); + assert(fuzzy_points("window close", "wc") == 2); + + // tests for fuzzy_tolerance_search + assert(fuzzy_tolerance_search("object to path", "ebo") == true); + assert(fuzzy_tolerance_search("execute verb", "qyy") == false); + assert(fuzzy_tolerance_search("color mode", "moco") == true); + + // tests for fuzzy_tolerance_points + assert(fuzzy_tolerance_points("object to path", "ebo") == 189); + assert(fuzzy_tolerance_points("execute verb", "vec") == 196); + assert(fuzzy_tolerance_points("color mode", "moco") == 195); + + if (_search_text.empty()) { + return -1; + } // No change in the order + + auto [cp_name_1, cp_description_1] = get_name_desc(row1); + auto [cp_name_2, cp_description_2] = get_name_desc(row2); + + int fuzzy_points_count_1 = 0, fuzzy_points_count_2 = 0; + int text_len_1 = 0, text_len_2 = 0; + int points_compare = 0; + + constexpr int TOOLTIP_PENALTY = 100; + constexpr int DESCRIPTION_PENALTY = 500; + + if (cp_name_1 && cp_name_2) { + if (fuzzy_search(cp_name_1->get_text(), _search_text)) { + text_len_1 = cp_name_1->get_text().length(); + fuzzy_points_count_1 = fuzzy_points(cp_name_1->get_text(), _search_text); + } + if (fuzzy_search(cp_name_2->get_text(), _search_text)) { + text_len_2 = cp_name_2->get_text().length(); + fuzzy_points_count_2 = fuzzy_points(cp_name_2->get_text(), _search_text); + } + + points_compare = fuzzy_points_compare(fuzzy_points_count_1, fuzzy_points_count_2, text_len_1, text_len_2); + if (points_compare != 0) { + return points_compare; + } + + if (fuzzy_tolerance_search(cp_name_1->get_text(), _search_text)) { + text_len_1 = cp_name_1->get_text().length(); + fuzzy_points_count_1 = fuzzy_tolerance_points(cp_name_1->get_text(), _search_text); + } + if (fuzzy_tolerance_search(cp_name_2->get_text(), _search_text)) { + text_len_2 = cp_name_2->get_text().length(); + fuzzy_points_count_2 = fuzzy_tolerance_points(cp_name_2->get_text(), _search_text); + } + + points_compare = fuzzy_points_compare(fuzzy_points_count_1, fuzzy_points_count_2, text_len_1, text_len_2); + if (points_compare != 0) { + return points_compare; + } + + if (fuzzy_search(cp_name_1->get_tooltip_text(), _search_text)) { + text_len_1 = cp_name_1->get_tooltip_text().length(); + fuzzy_points_count_1 = fuzzy_points(cp_name_1->get_tooltip_text(), _search_text) + TOOLTIP_PENALTY; + } + if (fuzzy_search(cp_name_2->get_tooltip_text(), _search_text)) { + text_len_2 = cp_name_2->get_tooltip_text().length(); + fuzzy_points_count_2 = fuzzy_points(cp_name_2->get_tooltip_text(), _search_text) + TOOLTIP_PENALTY; + } + + points_compare = fuzzy_points_compare(fuzzy_points_count_1, fuzzy_points_count_2, text_len_1, text_len_2); + if (points_compare != 0) { + return points_compare; + } + + if (fuzzy_tolerance_search(cp_name_1->get_tooltip_text(), _search_text)) { + text_len_1 = cp_name_1->get_tooltip_text().length(); + fuzzy_points_count_1 = fuzzy_tolerance_points(cp_name_1->get_tooltip_text(), _search_text) + + TOOLTIP_PENALTY; // Adding a constant integer to decrease the prefrence + } + if (fuzzy_tolerance_search(cp_name_2->get_tooltip_text(), _search_text)) { + text_len_2 = cp_name_2->get_tooltip_text().length(); + fuzzy_points_count_2 = fuzzy_tolerance_points(cp_name_2->get_tooltip_text(), _search_text) + + TOOLTIP_PENALTY; // Adding a constant integer to decrease the prefrence + } + points_compare = fuzzy_points_compare(fuzzy_points_count_1, fuzzy_points_count_2, text_len_1, text_len_2); + if (points_compare != 0) { + return points_compare; + } + } + + if (cp_description_1 && normal_search(cp_description_1->get_text(), _search_text)) { + text_len_1 = cp_description_1->get_text().length(); + fuzzy_points_count_1 = fuzzy_points(cp_description_1->get_text(), _search_text) + + DESCRIPTION_PENALTY; // Adding a constant integer to decrease the prefrence + } + if (cp_description_2 && normal_search(cp_description_2->get_text(), _search_text)) { + text_len_2 = cp_description_2->get_text().length(); + fuzzy_points_count_2 = fuzzy_points(cp_description_2->get_text(), _search_text) + + DESCRIPTION_PENALTY; // Adding a constant integer to decrease the prefrence + } + + points_compare = fuzzy_points_compare(fuzzy_points_count_1, fuzzy_points_count_2, text_len_1, text_len_2); + if (points_compare != 0) { + return points_compare; + } + return 0; +} + +void CommandPalette::set_mode(CPMode mode) +{ + switch (mode) { + case CPMode::SEARCH: + if (_mode == CPMode::SEARCH) { + return; + } + + _CPFilter->set_text(""); + _CPFilter->set_icon_from_icon_name("edit-find-symbolic"); + _CPFilter->set_placeholder_text("Search operation..."); + _CPFilter->set_tooltip_text("Search operation..."); + show_suggestions(); + + // Show Suggestions instead of history + _CPHistoryScroll->set_no_show_all(); + _CPHistoryScroll->hide(); + + _CPSuggestionsScroll->set_no_show_all(false); + _CPSuggestionsScroll->show_all(); + + _CPSuggestions->unset_filter_func(); + _CPSuggestions->set_filter_func(sigc::mem_fun(*this, &CommandPalette::on_filter_general)); + + _cpfilter_search_connection.disconnect(); // to be sure + _cpfilter_key_press_connection.disconnect(); + + _cpfilter_search_connection = + _CPFilter->signal_search_changed().connect(sigc::mem_fun(*this, &CommandPalette::on_search)); + _cpfilter_key_press_connection = _CPFilter->signal_key_press_event().connect( + sigc::mem_fun(*this, &CommandPalette::on_key_press_cpfilter_search_mode), false); + + _search_text = ""; + _CPSuggestions->invalidate_filter(); + break; + + case CPMode::INPUT: + if (_mode == CPMode::INPUT) { + return; + } + _cpfilter_search_connection.disconnect(); + _cpfilter_key_press_connection.disconnect(); + + hide_suggestions(); + _CPFilter->set_text(""); + _CPFilter->grab_focus(); + + _CPFilter->set_icon_from_icon_name("input-keyboard"); + _CPFilter->set_placeholder_text("Enter action argument"); + _CPFilter->set_tooltip_text("Enter action argument"); + + break; + + case CPMode::SHELL: + if (_mode == CPMode::SHELL) { + return; + } + + hide_suggestions(); + _CPFilter->set_icon_from_icon_name("gtk-search"); + _cpfilter_search_connection.disconnect(); + _cpfilter_key_press_connection.disconnect(); + + break; + + case CPMode::HISTORY: + if (_mode == CPMode::HISTORY) { + return; + } + + if (_CPHistory->get_children().empty()) { + return; + } + + // Show history instead of suggestions + _CPSuggestionsScroll->set_no_show_all(); + _CPHistoryScroll->set_no_show_all(false); + + _CPSuggestionsScroll->hide(); + _CPHistoryScroll->show_all(); + + _CPFilter->set_icon_from_icon_name("format-justify-fill"); + _CPFilter->set_icon_tooltip_text(N_("History mode")); + _cpfilter_search_connection.disconnect(); + _cpfilter_key_press_connection.disconnect(); + + _cpfilter_key_press_connection = _CPFilter->signal_key_press_event().connect( + sigc::mem_fun(*this, &CommandPalette::on_key_press_cpfilter_history_mode), false); + + _CPHistory->signal_row_selected().connect( + sigc::mem_fun(*this, &CommandPalette::on_history_selection_changed)); + _CPHistory->signal_row_activated().connect(sigc::mem_fun(*this, &CommandPalette::on_row_activated)); + + { + // select last row + const auto last_row = _CPHistory->get_row_at_index(_CPHistory->get_children().size() - 1); + _CPHistory->select_row(*last_row); + last_row->grab_focus(); + } + + { + // FIXME: scroll to bottom + const auto adjustment = _CPHistoryScroll->get_vadjustment(); + adjustment->set_value(adjustment->get_upper()); + } + + break; + } + _mode = mode; +} + +/** + * Calls actions with parameters + */ +CommandPalette::ActionPtrName CommandPalette::get_action_ptr_name(const Glib::ustring &full_action_name) +{ + static auto gapp = InkscapeApplication::instance()->gtk_app(); + // TODO: Optimisation: only try to assign if null, make static + const auto win = InkscapeApplication::instance()->get_active_window(); + const auto doc = InkscapeApplication::instance()->get_active_document(); + auto action_domain_string = full_action_name.substr(0, full_action_name.find('.')); // app, win, doc + auto action_name = full_action_name.substr(full_action_name.find('.') + 1); + + ActionPtr action_ptr; + if (action_domain_string == "app") { + action_ptr = gapp->lookup_action(action_name); + } else if (action_domain_string == "win" and win) { + action_ptr = win->lookup_action(action_name); + } else if (action_domain_string == "doc" and doc) { + if (const auto map = doc->getActionGroup(); map) { + action_ptr = map->lookup_action(action_name); + } + } + + return {action_ptr, full_action_name}; +} + +bool CommandPalette::execute_action(const ActionPtrName &action_ptr_name, const Glib::ustring &value) +{ + if (not value.empty()) { + _history_xml.add_action_parameter(action_ptr_name.second, value); + } + auto [action_ptr, action_name] = action_ptr_name; + + switch (get_action_variant_type(action_ptr)) { + case TypeOfVariant::BOOL: + if (value == "1" || value == "t" || value == "true" || value.empty()) { + action_ptr->activate(Glib::Variant<bool>::create(true)); + } else if (value == "0" || value == "f" || value == "false") { + action_ptr->activate(Glib::Variant<bool>::create(false)); + } else { + std::cerr << "CommandPalette::execute_action: Invalid boolean value: " << action_name << ":" << value + << std::endl; + } + break; + case TypeOfVariant::INT: + try { + action_ptr->activate(Glib::Variant<int>::create(std::stoi(value))); + } catch (...) { + if (SPDesktop *dt = SP_ACTIVE_DESKTOP; dt) { + dt->messageStack()->flash(ERROR_MESSAGE, _("Invalid input! Enter an integer number.")); + } + } + break; + case TypeOfVariant::DOUBLE: + try { + action_ptr->activate(Glib::Variant<double>::create(std::stod(value))); + } catch (...) { + if (SPDesktop *dt = SP_ACTIVE_DESKTOP; dt) { + dt->messageStack()->flash(ERROR_MESSAGE, _("Invalid input! Enter a decimal number.")); + } + } + break; + case TypeOfVariant::STRING: + action_ptr->activate(Glib::Variant<Glib::ustring>::create(value)); + break; + case TypeOfVariant::TUPLE_DD: + try { + double d0 = 0; + double d1 = 0; + std::vector<Glib::ustring> tokens = Glib::Regex::split_simple("\\s*,\\s*", value); + + try { + if (tokens.size() != 2) { + throw std::invalid_argument("requires two numbers"); + } + } catch (...) { + throw; + } + + try { + d0 = std::stod(tokens[0]); + d1 = std::stod(tokens[1]); + } catch (...) { + throw; + } + + auto variant = Glib::Variant<std::tuple<double, double>>::create(std::tuple<double, double>(d0, d1)); + action_ptr->activate(variant); + } catch (...) { + if (SPDesktop *dt = SP_ACTIVE_DESKTOP; dt) { + dt->messageStack()->flash(ERROR_MESSAGE, _("Invalid input! Enter two comma separated numbers.")); + } + } + break; + case TypeOfVariant::UNKNOWN: + std::cerr << "CommandPalette::execute_action: unhandled action value type (Unknown Type) " << action_name + << std::endl; + break; + case TypeOfVariant::NONE: + default: + action_ptr->activate(); + break; + } + return false; +} + +TypeOfVariant CommandPalette::get_action_variant_type(const ActionPtr &action_ptr) +{ + const GVariantType *gtype = g_action_get_parameter_type(action_ptr->gobj()); + if (gtype) { + Glib::VariantType type = action_ptr->get_parameter_type(); + if (type.get_string() == "b") { + return TypeOfVariant::BOOL; + } else if (type.get_string() == "i") { + return TypeOfVariant::INT; + } else if (type.get_string() == "d") { + return TypeOfVariant::DOUBLE; + } else if (type.get_string() == "s") { + return TypeOfVariant::STRING; + } else if (type.get_string() == "(dd)") { + return TypeOfVariant::TUPLE_DD; + } else { + std::cerr << "CommandPalette::get_action_variant_type: unknown variant type: " << type.get_string() << std::endl; + return TypeOfVariant::UNKNOWN; + } + } + // With value. + return TypeOfVariant::NONE; +} + +std::pair<Gtk::Label *, Gtk::Label *> CommandPalette::get_name_desc(Gtk::ListBoxRow *child) +{ + auto event_box = dynamic_cast<Gtk::EventBox *>(child->get_child()); + if (event_box) { + // NOTE: These variables have same name as in the glade file command-palette-operation.glade + // FIXME: When structure of Gladefile of CPOperation changes, refactor this + auto CPSynapseBox = dynamic_cast<Gtk::Box *>(event_box->get_child()); + if (CPSynapseBox) { + auto synapse_children = CPSynapseBox->get_children(); + auto CPName = dynamic_cast<Gtk::Label *>(synapse_children[0]); + auto CPDescription = dynamic_cast<Gtk::Label *>(synapse_children[1]); + + return std::pair(CPName, CPDescription); + } + } + + return std::pair(nullptr, nullptr); +} + +Gtk::Button *CommandPalette::get_full_action_name(Gtk::ListBoxRow *child) +{ + auto event_box = dynamic_cast<Gtk::EventBox *>(child->get_child()); + if (event_box) { + auto CPSynapseBox = dynamic_cast<Gtk::Box *>(event_box->get_child()); + if (CPSynapseBox) { + auto synapse_children = CPSynapseBox->get_children(); + auto CPActionFullName = dynamic_cast<Gtk::Button *>(synapse_children[2]); + + return CPActionFullName; + } + } + + return nullptr; +} + +void CommandPalette::load_app_actions() +{ + auto gapp = InkscapeApplication::instance()->gtk_app(); + std::vector<ActionPtrName> all_actions_info; + + std::vector<Glib::ustring> actions = gapp->list_actions(); + for (const auto &action : actions) { + generate_action_operation(get_action_ptr_name("app." + action), true); + } +} +void CommandPalette::load_win_doc_actions() +{ + if (auto window = InkscapeApplication::instance()->get_active_window(); window) { + std::vector<Glib::ustring> actions = window->list_actions(); + for (auto action : actions) { + generate_action_operation(get_action_ptr_name("win." + action), true); + } + + if (auto document = window->get_document(); document) { + auto map = document->getActionGroup(); + if (map) { + std::vector<Glib::ustring> actions = map->list_actions(); + for (auto action : actions) { + generate_action_operation(get_action_ptr_name("doc." + action), true); + } + } else { + std::cerr << "CommandPalette::load_win_doc_actions: No document map!" << std::endl; + } + } + } +} + +Gtk::Box *CommandPalette::get_base_widget() +{ + return _CPBase; +} + +// CPHistoryXML --------------------------------------------------------------- +CPHistoryXML::CPHistoryXML() + : _file_path(IO::Resource::profile_path("cphistory.xml")) +{ + _xml_doc = sp_repr_read_file(_file_path.c_str(), nullptr); + if (not _xml_doc) { + _xml_doc = sp_repr_document_new("cphistory"); + + /* STRUCTURE EXAMPLE ------------------ Illustration 1 + <cphistory> + <operations> + <action> full.action_name </action> + <import> uri </import> + <export> uri </export> + </operations> + <params> + <action name="app.transfor-rotate"> + <param> 30 </param> + <param> 23.5 </param> + </action> + </params> + </cphistory> + */ + + // Just a pointer, we don't own it, don't free/release/delete + auto root = _xml_doc->root(); + + // add operation history in this element + auto operations = _xml_doc->createElement("operations"); + root->appendChild(operations); + + // add param history in this element + auto params = _xml_doc->createElement("params"); + root->appendChild(params); + + // This was created by allocated + Inkscape::GC::release(operations); + Inkscape::GC::release(params); + + // only save if created new + save(); + } + + // Only two children :) check and ensure Illustration 1 + _operations = _xml_doc->root()->firstChild(); + _params = _xml_doc->root()->lastChild(); +} + +CPHistoryXML::~CPHistoryXML() +{ + Inkscape::GC::release(_xml_doc); +} +void CPHistoryXML::add_action(const std::string &full_action_name) +{ + add_operation(HistoryType::ACTION, full_action_name); +} + +void CPHistoryXML::add_import(const std::string &uri) +{ + add_operation(HistoryType::IMPORT_FILE, uri); +} +void CPHistoryXML::add_open(const std::string &uri) +{ + add_operation(HistoryType::OPEN_FILE, uri); +} + +void CPHistoryXML::add_action_parameter(const std::string &full_action_name, const std::string ¶m) +{ + /* Creates + * <params> + * +1 <action name="full.action-name"> + * + <param>30</param> + * + <param>60</param> + * + <param>90</param> + * +1 <action name="full.action-name"> + * <params> + * + * + : generally creates + * +1: creates once + */ + const auto parameter_node = _xml_doc->createElement("param"); + const auto parameter_text = _xml_doc->createTextNode(param.c_str()); + + parameter_node->appendChild(parameter_text); + Inkscape::GC::release(parameter_text); + + for (auto action_iter = _params->firstChild(); action_iter; action_iter = action_iter->next()) { + // If this action's node already exists + if (full_action_name == action_iter->attribute("name")) { + // If the last parameter was the same don't do anything, inner text is also a node hence 2 times last + // child + if (action_iter->lastChild()->lastChild() && action_iter->lastChild()->lastChild()->content() == param) { + Inkscape::GC::release(parameter_node); + return; + } + + // If last current than parameter is different, add current + action_iter->appendChild(parameter_node); + Inkscape::GC::release(parameter_node); + + save(); + return; + } + } + + // only encountered when the actions element doesn't already exists,so we create that action's element + const auto action_node = _xml_doc->createElement("action"); + action_node->setAttribute("name", full_action_name.c_str()); + action_node->appendChild(parameter_node); + + _params->appendChild(action_node); + save(); + + Inkscape::GC::release(action_node); + Inkscape::GC::release(parameter_node); +} + +std::optional<History> CPHistoryXML::get_last_operation() +{ + auto last_child = _operations->lastChild(); + if (last_child) { + if (const auto operation_type = _get_operation_type(last_child); operation_type.has_value()) { + // inner text is a text Node thus last child + return History{*operation_type, last_child->lastChild()->content()}; + } + } + return std::nullopt; +} +std::vector<History> CPHistoryXML::get_operation_history() const +{ + // TODO: add max items in history + std::vector<History> history; + for (auto operation_iter = _operations->firstChild(); operation_iter; operation_iter = operation_iter->next()) { + if (const auto operation_type = _get_operation_type(operation_iter); operation_type.has_value()) { + history.emplace_back(*operation_type, operation_iter->firstChild()->content()); + } + } + return history; +} + +std::vector<std::string> CPHistoryXML::get_action_parameter_history(const std::string &full_action_name) const +{ + std::vector<std::string> params; + for (auto action_iter = _params->firstChild(); action_iter; action_iter = action_iter->prev()) { + // If this action's node already exists + if (full_action_name == action_iter->attribute("name")) { + // lastChild and prev for LIFO order + for (auto param_iter = _params->lastChild(); param_iter; param_iter = param_iter->prev()) { + params.emplace_back(param_iter->content()); + } + return params; + } + } + // action not used previously so no params; + return {}; +} + +void CPHistoryXML::save() const +{ + sp_repr_save_file(_xml_doc, _file_path.c_str()); +} + +void CPHistoryXML::add_operation(const HistoryType history_type, const std::string &data) +{ + std::string operation_type_name; + switch (history_type) { + // see Illustration 1 + case HistoryType::ACTION: + operation_type_name = "action"; + break; + case HistoryType::IMPORT_FILE: + operation_type_name = "import"; + break; + case HistoryType::OPEN_FILE: + operation_type_name = "open"; + break; + default: + return; + } + auto operation_to_add = _xml_doc->createElement(operation_type_name.c_str()); // action, import, open + auto operation_data = _xml_doc->createTextNode(data.c_str()); + operation_data->setContent(data.c_str()); + + operation_to_add->appendChild(operation_data); + _operations->appendChild(operation_to_add); + + Inkscape::GC::release(operation_data); + Inkscape::GC::release(operation_to_add); + + save(); +} +std::optional<HistoryType> CPHistoryXML::_get_operation_type(Inkscape::XML::Node *operation) +{ + const std::string operation_type_name = operation->name(); + + if (operation_type_name == "action") { + return HistoryType::ACTION; + } else if (operation_type_name == "import") { + return HistoryType::IMPORT_FILE; + } else if (operation_type_name == "open") { + return HistoryType::OPEN_FILE; + } else { + return std::nullopt; + // unknown HistoryType + } +} + +} // 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 : |