diff options
Diffstat (limited to 'src/inkscape-application.cpp')
| -rw-r--r-- | src/inkscape-application.cpp | 1736 |
1 files changed, 1736 insertions, 0 deletions
diff --git a/src/inkscape-application.cpp b/src/inkscape-application.cpp new file mode 100644 index 0000000..1eebde9 --- /dev/null +++ b/src/inkscape-application.cpp @@ -0,0 +1,1736 @@ +// SPDX-License-Identifier: GPL-2.0-or-later +/* + * The main Inkscape application. + * + * Copyright (C) 2018 Tavmjong Bah + * + * The contents of this file may be used under the GNU General Public License Version 2 or later. + * + */ + +/* Application flow: + * main() -> InkscapeApplication::singleton().gio_app()->run(argc, argv); + * + * InkscapeApplication::InkscapeApplication + * Initialized: GC, Debug, Gettext, Autosave, Actions, Commandline + * InkscapeApplication::on_handle_local_options + * InkscapeAppllication::parse_actions + * + * -- Switch to main instance if new Inkscape instance is merged with existing instance. -- + * New instances are merged with existing instance unless app_id is changed, see below. + * + * InkscapeApplication::on_startup | Only called for main instance + * + * InkscapeApplication::on_activate (no file specified) OR InkscapeApplication::on_open (file specified) + * InkscapeApplication::process_document | Will use command-line actions from main instance! + * + * InkscapeApplication::create_window (document) + * Inkscape::Shortcuts + * + * InkscapeApplication::create_window (file) | + * InkscapeApplication::create_window (document) | Open/Close document + * InkscapeApplication::destroy_window | + * + * InkscapeApplication::on_quit + * InkscapeApplication::destroy_all + * InkscapeApplication::destroy_window + */ + +#include <iostream> +#include <iomanip> +#include <cerrno> // History file +#include <regex> +#include <numeric> + +// checking if dithering is supported +#ifdef WITH_PATCHED_CAIRO +#include "3rdparty/cairo/src/cairo.h" +#else +#include <cairo.h> +#endif + +#include <glibmm/i18n.h> // Internationalization + +#ifdef HAVE_CONFIG_H +# include "config.h" // Defines ENABLE_NLS +#endif + +#include "inkscape-application.h" +#include "inkscape-version-info.h" +#include "inkscape-window.h" + +#include "auto-save.h" // Auto-save +#include "desktop.h" // Access to window +#include "file.h" // sp_file_convert_dpi +#include "inkscape.h" // Inkscape::Application +#include "path-prefix.h" // Data directory +#include "event-log.h" + +#include "include/glibmm_version.h" + +#include "inkgc/gc-core.h" // Garbage Collecting init +#include "debug/logger.h" // INKSCAPE_DEBUG_LOG support + +#include "extension/init.h" + +#include "io/file.h" // File open (command line). +#include "io/resource.h" // TEMPLATE +#include "io/fix-broken-links.h" // Fix up references. + +#include "object/sp-root.h" // Inkscape version. + +#include "ui/interface.h" // sp_ui_error_dialog +#include "ui/desktop/document-check.h" // Check for data loss on closing document window. +#include "ui/desktop/menubar.h" +#include "ui/dialog/dialog-manager.h" // Save state +#include "ui/dialog/font-substitution.h" // Warn user about font substitution. +#include "ui/dialog/startup.h" +#include "ui/shortcuts.h" // Shortcuts... init + +#include "util/units.h" // Redimension window + +#include "actions/actions-base.h" // Actions +#include "actions/actions-file.h" // Actions +#include "actions/actions-edit.h" // Actions +#include "actions/actions-effect.h" // Actions +#include "actions/actions-element-a.h" // Actions +#include "actions/actions-element-image.h" // Actions +#include "actions/actions-hide-lock.h" // Actions +#include "actions/actions-object.h" // Actions +#include "actions/actions-object-align.h" // Actions +#include "actions/actions-output.h" // Actions +#include "actions/actions-paths.h" // Actions +#include "actions/actions-selection-object.h" // Actions +#include "actions/actions-selection.h" // Actions +#include "actions/actions-transform.h" // Actions +#include "actions/actions-text.h" // Actions +#include "actions/actions-window.h" // Actions +#include "actions/actions-undo-document.h" + +// With GUI +#include "actions/actions-tutorial.h" // Actions + +#include "widgets/desktop-widget.h" // Access dialog container. + +#ifdef ENABLE_NLS +// Native Language Support - shouldn't this always be used? +#include "helper/gettext.h" // gettext init +#endif // ENABLE_NLS + +#ifdef WITH_GNU_READLINE +#include <readline/readline.h> +#include <readline/history.h> +#endif + +#include "io/resource.h" +using Inkscape::IO::Resource::UIS; + +// This is a bit confusing as there are two ways to handle command line arguments and files +// depending on if the Gio::APPLICATION_HANDLES_OPEN and/or Gio::APPLICATION_HANDLES_COMMAND_LINE +// flags are set. If the open flag is set and the command line not, the all the remainng arguments +// after calling on_handle_local_options() are assumed to be filenames. + +// Add document to app. +void +InkscapeApplication::document_add(SPDocument* document) +{ + if (document) { + auto it = _documents.find(document); + if (it == _documents.end()) { + _documents[document] = std::vector<InkscapeWindow*>(); + } else { + // Should never happen. + std::cerr << "InkscapeApplication::add_document: Document already opened!" << std::endl; + } + } else { + // Should never happen! + std::cerr << "InkscapeApplication::add_document: No document!" << std::endl; + } +} + +// New document, add it to app. TODO: This should really be open_document with option to strip template data. +SPDocument* +InkscapeApplication::document_new(const std::string &Template) +{ + auto my_template = Template; + if (my_template.empty()) { + my_template = Inkscape::IO::Resource::get_filename(Inkscape::IO::Resource::TEMPLATES, "default.svg", true); + } + + // Open file + SPDocument *document = ink_file_new(my_template); + if (document) { + document_add(document); + + // Set viewBox if it doesn't exist. + if (!document->getRoot()->viewBox_set) { + document->setViewBox(); + } + + } else { + std::cerr << "InkscapeApplication::new_document: failed to open new document!" << std::endl; + } + + return document; +} + + +// Open a document, add it to app. +SPDocument* +InkscapeApplication::document_open(const Glib::RefPtr<Gio::File>& file, bool *cancelled) +{ + // Open file + SPDocument *document = ink_file_open(file, cancelled); + + if (document) { + document->setVirgin(false); // Prevents replacing document in same window during file open. + + // Add/promote recent file; when we call add_item and file is on a recent list already, + // then apparently only "modified" time changes. + if (auto recentmanager = Gtk::RecentManager::get_default()) { + recentmanager->add_item(file->get_uri()); + } + + document_add (document); + } else if (cancelled == nullptr || !(*cancelled)) { + std::cerr << "InkscapeApplication::document_open: Failed to open: " << file->get_parse_name() << std::endl; + } + + return document; +} + + +// Open a document, add it to app. +SPDocument* +InkscapeApplication::document_open(const std::string& data) +{ + // Open file + SPDocument *document = ink_file_open(data); + + if (document) { + document->setVirgin(false); // Prevents replacing document in same window during file open. + + document_add (document); + } else { + std::cerr << "InkscapeApplication::document_open: Failed to open memory document." << std::endl; + } + + return document; +} + + +/** Swap out one document for another in a window... maybe this should disappear. + * Does not delete old document! + */ +bool +InkscapeApplication::document_swap(InkscapeWindow* window, SPDocument* document) +{ + if (!document || !window) { + std::cerr << "InkscapeAppliation::swap_document: Missing window or document!" << std::endl; + return false; + } + + SPDesktop* desktop = window->get_desktop(); + SPDocument* old_document = window->get_document(); + desktop->change_document(document); + + // We need to move window from the old document to the new document. + + // Find old document + auto it = _documents.find(old_document); + if (it != _documents.end()) { + + // Remove window from document map. + auto it2 = std::find(it->second.begin(), it->second.end(), window); + if (it2 != it->second.end()) { + it->second.erase(it2); + } else { + std::cerr << "InkscapeApplication::swap_document: Window not found!" << std::endl; + } + + } else { + std::cerr << "InkscapeApplication::swap_document: Document not in map!" << std::endl; + } + + // Find new document + it = _documents.find(document); + if (it != _documents.end()) { + it->second.push_back(window); + } else { + std::cerr << "InkscapeApplication::swap_document: Document not in map!" << std::endl; + } + + // To be removed (add/delete once per window)! + INKSCAPE.add_document(document); + INKSCAPE.remove_document(old_document); + + _active_document = document; + _active_selection = desktop->getSelection(); + _active_view = desktop; + _active_window = window; + return true; +} + +/** Revert document: open saved document and swap it for each window. + */ +bool +InkscapeApplication::document_revert(SPDocument* document) +{ + // Find saved document. + gchar const *path = document->getDocumentFilename(); + if (!path) { + std::cerr << "InkscapeApplication::revert_document: Document never saved, cannot revert." << std::endl; + return false; + } + + // Open saved document. + Glib::RefPtr<Gio::File> file = Gio::File::create_for_path(document->getDocumentFilename()); + SPDocument* new_document = document_open (file); + if (!new_document) { + std::cerr << "InkscapeApplication::revert_document: Cannot open saved document!" << std::endl; + return false; + } + + // Allow overwriting current document. + document->setVirgin(true); + + auto it = _documents.find(document); + if (it != _documents.end()) { + + // Swap reverted document in all windows. + for (auto it2 : it->second) { + + SPDesktop* desktop = it2->get_desktop(); + + // Remember current zoom and view. + double zoom = desktop->current_zoom(); + Geom::Point c = desktop->current_center(); + + bool reverted = document_swap (it2, new_document); + + if (reverted) { + desktop->zoom_absolute(c, zoom, false); + /** Update LPE and Fix legacy LPE system **/ + sp_file_fix_lpe(desktop->getDocument()); + } else { + std::cerr << "InkscapeApplication::revert_document: Revert failed!" << std::endl; + } + } + + document_close (document); + } else { + std::cerr << "InkscapeApplication::revert_document: Document not found!" << std::endl; + return false; + } + return true; +} + + + +/** Close a document, remove from app. No checking is done on modified status, etc. + */ +void +InkscapeApplication::document_close(SPDocument* document) +{ + if (document) { + + auto it = _documents.find(document); + if (it != _documents.end()) { + if (it->second.size() != 0) { + std::cerr << "InkscapeApplication::close_document: Window vector not empty!" << std::endl; + } + _documents.erase(it); + } else { + std::cerr << "InkscapeApplication::close_document: Document not registered with application." << std::endl; + } + + delete document; + + } else { + std::cerr << "InkscapeApplication::close_document: No document!" << std::endl; + } +} + + +/** Return number of windows with document. + */ +unsigned +InkscapeApplication::document_window_count(SPDocument* document) +{ + unsigned count = 0; + + auto it = _documents.find(document); + if (it != _documents.end()) { + count = it->second.size(); + } else { + std::cerr << "InkscapeApplication::document_window_count: Document not in map!" << std::endl; + } + + return count; +} + +/** Fix up a document if necessary (Only fixes that require GUI). MOVE TO ANOTHER FILE! + */ +void +InkscapeApplication::document_fix(InkscapeWindow* window) +{ + // Most fixes are handled when document is opened in SPDocument::createDoc(). + // But some require the GUI to be present. These are handled here. + + if (_with_gui) { + + SPDocument* document = window->get_document(); + + // Perform a fixup pass for hrefs. + if ( Inkscape::fixBrokenLinks(document) ) { + Glib::ustring msg = _("Broken links have been changed to point to existing files."); + SPDesktop* desktop = window->get_desktop(); + if (desktop != nullptr) { + desktop->showInfoDialog(msg); + } + } + + // Fix dpi (pre-92 files). + if ( sp_version_inside_range( document->getRoot()->version.inkscape, 0, 1, 0, 92 ) ) { + sp_file_convert_dpi(document); + } + /** Update LPE and Fix legacy LPE system **/ + sp_file_fix_lpe(document); + + // Check for font substitutions, requires text to have been rendered. + Inkscape::UI::Dialog::FontSubstitution::getInstance().checkFontSubstitutions(document); + } +} + +/** Get a list of open documents (from document map). + */ +std::vector<SPDocument*> +InkscapeApplication::get_documents() +{ + std::vector<SPDocument*> documents; + for (auto &i : _documents) { + documents.push_back(i.first); + } + return documents; +} + + + +// Take an already open document and create a new window, adding window to document map. +InkscapeWindow* +InkscapeApplication::window_open(SPDocument* document) +{ + // Once we've removed Inkscape::Application (separating GUI from non-GUI stuff) + // it will be more easy to start up the GUI after-the-fact. Until then, prevent + // opening a window if GUI not selected at start-up time. + if (!_with_gui) { + std::cerr << "InkscapeApplication::window_open: Not in gui mode!" << std::endl; + return nullptr; + } + + InkscapeWindow* window = new InkscapeWindow(document); + // TODO Add window to application. (Instead of in InkscapeWindow constructor.) + + // To be removed (add once per window)! + INKSCAPE.add_document(document); + + _active_window = window; + _active_view = window->get_desktop(); + _active_selection = window->get_desktop()->getSelection(); + _active_document = document; + + auto it = _documents.find(document); + if (it != _documents.end()) { + it->second.push_back(window); + } else { + std::cerr << "InkscapeApplication::window_open: Document not in map!" << std::endl; + } + + document_fix(window); // May need flag to prevent this from being called more than once. + + return window; +} + + +// Close a window. Does not delete document. +void +InkscapeApplication::window_close(InkscapeWindow* window) +{ + // std::cout << "InkscapeApplication::close_window" << std::endl; + // dump(); + + if (window) { + + SPDocument* document = window->get_document(); + if (document) { + + // To be removed (remove once per window)! + /* bool last = */ INKSCAPE.remove_document(document); + + // Leave active document alone (maybe should find new active window and reset variables). + _active_selection = nullptr; + _active_view = nullptr; + _active_window = nullptr; + + // Remove window from document map. + auto it = _documents.find(document); + if (it != _documents.end()) { + auto it2 = std::find(it->second.begin(), it->second.end(), window); + if (it2 != it->second.end()) { + if (get_number_of_windows() == 1) { + // persist layout of docked and floating dialogs before deleting the last window + Inkscape::UI::Dialog::DialogManager::singleton().save_dialogs_state( + window->get_desktop_widget()->getDialogContainer()); + } + it->second.erase(it2); + delete window; // Results in call to SPDesktop::destroy() + } else { + std::cerr << "InkscapeApplication::close_window: window not found!" << std::endl; + } + } else { + std::cerr << "InkscapeApplication::close_window: document not in map!" << std::endl; + } + } else { + std::cerr << "InkscapeApplication::close_window: No document!" << std::endl; + } + + } else { + std::cerr << "InkscapeApplication::close_window: No window!" << std::endl; + } + + // dump(); +} + + +// Closes active window (useful for scripting). +void +InkscapeApplication::window_close_active() +{ + if (_active_window) { + window_close (_active_window); + } else { + std::cerr << "InkscapeApplication::window_close_active: no active window!" << std::endl; + } +} + + +/** Update windows in response to: + * - New active window + * - Document change + * - Selection change + */ +void +InkscapeApplication::windows_update(SPDocument* document) +{ + // Find windows: + auto it = _documents.find( document ); + if (it != _documents.end()) { + std::vector<InkscapeWindow*> windows = it->second; + // std::cout << "InkscapeApplication::update_windows: windows size: " << windows.size() << std::endl; + // Loop over InkscapeWindows. + // Loop over DialogWindows. TBD + } else { + // std::cout << "InkscapeApplication::update_windows: no windows found" << std::endl; + } +} + +/** Debug function + */ +void +InkscapeApplication::dump() +{ + std::cout << "InkscapeApplication::dump()" << std::endl; + std::cout << " Documents: " << _documents.size() << std::endl; + for (auto i : _documents) { + std::cout << " Document: " << (i.first->getDocumentName()?i.first->getDocumentName():"unnamed") << std::endl; + for (auto j : i.second) { + std::cout << " Window: " << j->get_title() << std::endl; + } + } +} + +static InkscapeApplication *_instance = nullptr; + +InkscapeApplication &InkscapeApplication::singleton() +{ + if (!_instance) { + _instance = new InkscapeApplication(); + } + return *_instance; +} + +InkscapeApplication *InkscapeApplication::instance() +{ + return _instance; +} + +void +InkscapeApplication::_start_main_option_section(const Glib::ustring& section_name) +{ +#ifndef _WIN32 + // Avoid outputting control characters to non-tty destinations. + // + // However, isatty() is not useful on Windows + // - it doesn't recognize mintty and similar terminals + // - it doesn't work in cmd.exe either, where we have to use the inkscape.com wrapper, connecting stdout to a pipe + if (!isatty(fileno(stdout))) { + return; + } +#endif + + auto *gapp = gio_app(); + + if (section_name.empty()) { + gapp->add_main_option_entry(Gio::Application::OPTION_TYPE_BOOL, Glib::ustring("\b\b ")); + } else { + gapp->add_main_option_entry(Gio::Application::OPTION_TYPE_BOOL, Glib::ustring("\b\b \n") + section_name + ":"); + } +} + +InkscapeApplication::InkscapeApplication() +{ + using T = Gio::Application; + + auto app_id = Glib::ustring("org.inkscape.Inkscape"); + auto flags = Gio::APPLICATION_HANDLES_OPEN | // Use default file opening. + Gio::APPLICATION_CAN_OVERRIDE_APP_ID; + auto non_unique = false; + + // Allow an independent instance of Inkscape to run. Will have matching DBus name and paths + // (e.g org.inkscape.Inkscape.tag, /org/inkscape/Inkscape/tag/window/1). + // If this flag isn't set, any new instance of Inkscape will be merged with the already running + // instance of Inkscape before on_open() or on_activate() is called. + if (Glib::getenv("INKSCAPE_APP_ID_TAG") != "") { + flags |= Gio::APPLICATION_CAN_OVERRIDE_APP_ID; + app_id += "." + Glib::getenv("INKSCAPE_APP_ID_TAG"); + if (!Gio::Application::id_is_valid(app_id)) { + std::cerr << "InkscapeApplication: invalid application id: " << app_id << std::endl; + std::cerr << " tag must be ASCII and not start with a number." << std::endl; + } + non_unique = true; + } + + if (gtk_init_check(nullptr, nullptr)) { + g_set_prgname(app_id.c_str()); + _gio_application = Gtk::Application::create(app_id, flags); + } else { + _gio_application = Gio::Application::create(app_id, flags); + _with_gui = false; + } + + auto *gapp = gio_app(); + + gapp->signal_startup().connect([this]() { this->on_startup(); }); + gapp->signal_activate().connect([this]() { this->on_activate(); }); + gapp->signal_open().connect(sigc::mem_fun(*this, &InkscapeApplication::on_open)); + + // ==================== Initializations ===================== + // Garbage Collector + Inkscape::GC::init(); + +#ifndef NDEBUG + // Use environment variable INKSCAPE_DEBUG_LOG=log.txt for event logging + Inkscape::Debug::Logger::init(); +#endif + +#ifdef ENABLE_NLS + // Native Language Support (shouldn't this always be used?). + Inkscape::initialize_gettext(); +#endif + + // Autosave + Inkscape::AutoSave::getInstance().init(this); + + // Don't set application name for now. We don't use it anywhere but + // it overrides the name used for adding recently opened files and breaks the Gtk::RecentFilter + // Glib::set_application_name(N_("Inkscape - A Vector Drawing Program")); // After gettext() init. + + // ======================== Actions ========================= + add_actions_base(this); // actions that are GUI independent + add_actions_edit(this); // actions for editing + add_actions_effect(this); // actions for Filters and Extensions + add_actions_element_a(this); // actions for the SVG a (anchor) element + add_actions_element_image(this); // actions for the SVG image element + add_actions_file(this); // actions for file handling + add_actions_hide_lock(this); // actions for hiding/locking items. + add_actions_object(this); // actions for object manipulation + add_actions_object_align(this); // actions for object alignment + add_actions_output(this); // actions for file export + add_actions_selection(this); // actions for object selection + add_actions_path(this); // actions for Paths + add_actions_selection_object(this); // actions for selected objects + add_actions_text(this); // actions for Text + add_actions_tutorial(this); // actions for opening tutorials (with GUI only) + add_actions_transform(this); // actions for transforming selected objects + add_actions_window(this); // actions for windows + add_actions_undo_app(this); // Actions to undo/redo from the application level + + // ====================== Command Line ====================== + + // Will automatically handle character conversions. + // Note: OPTION_TYPE_FILENAME => std::string, OPTION_TYPE_STRING => Glib::ustring. + +#if GLIBMM_CHECK_VERSION(2,56,0) + // Additional informational strings for --help output + // TODO: Claims to be translated automatically, but seems broken, so pass already translated strings + gapp->set_option_context_parameter_string(_("file1 [file2 [fileN]]")); + gapp->set_option_context_summary(_("Process (or open) one or more files.")); + gapp->set_option_context_description(Glib::ustring("\n") + _("Examples:") + '\n' + + " " + Glib::ustring::compose(_("Export input SVG (%1) to PDF (%2) format:"), "in.svg", "out.pdf") + '\n' + + '\t' + "inkscape --export-filename=out.pdf in.svg\n" + + " " + Glib::ustring::compose(_("Export input files (%1) to PNG format keeping original name (%2):"), "in1.svg, in2.svg", "in1.png, in2.png") + '\n' + + '\t' + "inkscape --export-type=png in1.svg in2.svg\n" + + " " + Glib::ustring::compose(_("See %1 and %2 for more details."), "'man inkscape'", "http://wiki.inkscape.org/wiki/index.php/Using_the_Command_Line")); +#endif + + // clang-format off + // General + gapp->add_main_option_entry(T::OPTION_TYPE_BOOL, "version", 'V', N_("Print Inkscape version"), ""); + gapp->add_main_option_entry(T::OPTION_TYPE_BOOL, "debug-info", '\0', N_("Print debugging information"), ""); + gapp->add_main_option_entry(T::OPTION_TYPE_BOOL, "system-data-directory", '\0', N_("Print system data directory"), ""); + gapp->add_main_option_entry(T::OPTION_TYPE_BOOL, "user-data-directory", '\0', N_("Print user data directory"), ""); + gapp->add_main_option_entry(T::OPTION_TYPE_STRING, "app-id-tag", '\0', N_("Create a unique instance of Inkscape with the application ID 'org.inkscape.Inkscape.TAG'"), ""); + + // Open/Import + _start_main_option_section(_("File import")); + gapp->add_main_option_entry(T::OPTION_TYPE_BOOL, "pipe", 'p', N_("Read input file from standard input (stdin)"), ""); + gapp->add_main_option_entry(T::OPTION_TYPE_INT, "pdf-page", '\0', N_("PDF page number to import"), N_("PAGE")); + gapp->add_main_option_entry(T::OPTION_TYPE_BOOL, "pdf-poppler", '\0', N_("Use poppler when importing via commandline"), ""); + gapp->add_main_option_entry(T::OPTION_TYPE_STRING, "convert-dpi-method", '\0', N_("Method used to convert pre-0.92 document dpi, if needed: [none|scale-viewbox|scale-document]"), N_("METHOD")); + gapp->add_main_option_entry(T::OPTION_TYPE_BOOL, "no-convert-text-baseline-spacing", '\0', N_("Do not fix pre-0.92 document's text baseline spacing on opening"), ""); + + // Export - File and File Type + _start_main_option_section(_("File export")); + gapp->add_main_option_entry(T::OPTION_TYPE_FILENAME, "export-filename", 'o', N_("Output file name (defaults to input filename; file type is guessed from extension if present; use '-' to write to stdout)"), N_("FILENAME")); + gapp->add_main_option_entry(T::OPTION_TYPE_BOOL, "export-overwrite", '\0', N_("Overwrite input file (otherwise add '_out' suffix if type doesn't change)"), ""); + gapp->add_main_option_entry(T::OPTION_TYPE_STRING, "export-type", '\0', N_("File type(s) to export: [svg,png,ps,eps,pdf,emf,wmf,xaml]"), N_("TYPE[,TYPE]*")); + gapp->add_main_option_entry(T::OPTION_TYPE_STRING, "export-extension", '\0', N_("Extension ID to use for exporting"), N_("EXTENSION-ID")); + + // Export - Geometry + _start_main_option_section(_("Export geometry")); // B = PNG, S = SVG, P = PS/EPS/PDF + gapp->add_main_option_entry(T::OPTION_TYPE_BOOL, "export-area-page", 'C', N_("Area to export is page"), ""); // BSP + gapp->add_main_option_entry(T::OPTION_TYPE_BOOL, "export-area-drawing", 'D', N_("Area to export is whole drawing (ignoring page size)"), ""); // BSP + gapp->add_main_option_entry(T::OPTION_TYPE_STRING, "export-area", 'a', N_("Area to export in SVG user units"), N_("x0:y0:x1:y1")); // BSP + gapp->add_main_option_entry(T::OPTION_TYPE_BOOL, "export-area-snap", '\0', N_("Snap the bitmap export area outwards to the nearest integer values"), ""); // Bxx + gapp->add_main_option_entry(T::OPTION_TYPE_DOUBLE, "export-dpi", 'd', N_("Resolution for bitmaps and rasterized filters; default is 96"), N_("DPI")); // BxP + gapp->add_main_option_entry(T::OPTION_TYPE_INT, "export-width", 'w', N_("Bitmap width in pixels (overrides --export-dpi)"), N_("WIDTH")); // Bxx + gapp->add_main_option_entry(T::OPTION_TYPE_INT, "export-height", 'h', N_("Bitmap height in pixels (overrides --export-dpi)"), N_("HEIGHT")); // Bxx + gapp->add_main_option_entry(T::OPTION_TYPE_INT, "export-margin", '\0', N_("Margin around export area: units of page size for SVG, mm for PS/PDF"), N_("MARGIN")); // xSP + + // Export - Options + _start_main_option_section(_("Export options")); + gapp->add_main_option_entry(T::OPTION_TYPE_STRING, "export-id", 'i', N_("ID(s) of object(s) to export"), N_("OBJECT-ID[;OBJECT-ID]*")); // BSP + gapp->add_main_option_entry(T::OPTION_TYPE_BOOL, "export-id-only", 'j', N_("Hide all objects except object with ID selected by export-id"), ""); // BSx + gapp->add_main_option_entry(T::OPTION_TYPE_BOOL, "export-plain-svg", 'l', N_("Remove Inkscape-specific SVG attributes/properties"), ""); // xSx + gapp->add_main_option_entry(T::OPTION_TYPE_INT, "export-ps-level", '\0', N_("Postscript level (2 or 3); default is 3"), N_("LEVEL")); // xxP + gapp->add_main_option_entry(T::OPTION_TYPE_STRING, "export-pdf-version", '\0', N_("PDF version (1.4 or 1.5); default is 1.5"), N_("VERSION")); // xxP + gapp->add_main_option_entry(T::OPTION_TYPE_BOOL, "export-text-to-path", 'T', N_("Convert text to paths (PS/EPS/PDF/SVG)"), ""); // xxP + gapp->add_main_option_entry(T::OPTION_TYPE_BOOL, "export-latex", '\0', N_("Export text separately to LaTeX file (PS/EPS/PDF)"), ""); // xxP + gapp->add_main_option_entry(T::OPTION_TYPE_BOOL, "export-ignore-filters", '\0', N_("Render objects without filters instead of rasterizing (PS/EPS/PDF)"), ""); // xxP + gapp->add_main_option_entry(T::OPTION_TYPE_BOOL, "export-use-hints", 't', N_("Use stored filename and DPI hints when exporting object selected by --export-id"), ""); // Bxx + gapp->add_main_option_entry(T::OPTION_TYPE_STRING, "export-background", 'b', N_("Background color for exported bitmaps (any SVG color string)"), N_("COLOR")); // Bxx + // FIXME: Opacity should really be a DOUBLE, but an upstream bug means 0.0 is detected as NULL + gapp->add_main_option_entry(T::OPTION_TYPE_STRING, "export-background-opacity", 'y', N_("Background opacity for exported bitmaps (0.0 to 1.0, or 1 to 255)"), N_("VALUE")); // Bxx + gapp->add_main_option_entry(T::OPTION_TYPE_STRING, "export-png-color-mode", '\0', N_("Color mode (bit depth and color type) for exported bitmaps (Gray_1/Gray_2/Gray_4/Gray_8/Gray_16/RGB_8/RGB_16/GrayAlpha_8/GrayAlpha_16/RGBA_8/RGBA_16)"), N_("COLOR-MODE")); // Bxx + gapp->add_main_option_entry(T::OPTION_TYPE_STRING, "export-png-use-dithering", '\0', N_("Force dithering or disables it"), "false|true"); // Bxx + + // Query - Geometry + _start_main_option_section(_("Query object/document geometry")); + gapp->add_main_option_entry(T::OPTION_TYPE_STRING, "query-id", 'I', N_("ID(s) of object(s) to be queried"), N_("OBJECT-ID[,OBJECT-ID]*")); + gapp->add_main_option_entry(T::OPTION_TYPE_BOOL, "query-all", 'S', N_("Print bounding boxes of all objects"), ""); + gapp->add_main_option_entry(T::OPTION_TYPE_BOOL, "query-x", 'X', N_("X coordinate of drawing or object (if specified by --query-id)"), ""); + gapp->add_main_option_entry(T::OPTION_TYPE_BOOL, "query-y", 'Y', N_("Y coordinate of drawing or object (if specified by --query-id)"), ""); + gapp->add_main_option_entry(T::OPTION_TYPE_BOOL, "query-width", 'W', N_("Width of drawing or object (if specified by --query-id)"), ""); + gapp->add_main_option_entry(T::OPTION_TYPE_BOOL, "query-height", 'H', N_("Height of drawing or object (if specified by --query-id)"), ""); + + // Processing + _start_main_option_section(_("Advanced file processing")); + gapp->add_main_option_entry(T::OPTION_TYPE_BOOL, "vacuum-defs", '\0', N_("Remove unused definitions from the <defs> section(s) of document"), ""); + gapp->add_main_option_entry(T::OPTION_TYPE_STRING, "select", '\0', N_("Select objects: comma-separated list of IDs"), N_("OBJECT-ID[,OBJECT-ID]*")); + + // Actions + _start_main_option_section(); + gapp->add_main_option_entry(T::OPTION_TYPE_STRING, "actions", 'a', N_("List of actions (with optional arguments) to execute"), N_("ACTION(:ARG)[;ACTION(:ARG)]*")); + gapp->add_main_option_entry(T::OPTION_TYPE_BOOL, "action-list", '\0', N_("List all available actions"), ""); + + // Interface + _start_main_option_section(_("Interface")); + gapp->add_main_option_entry(T::OPTION_TYPE_BOOL, "with-gui", 'g', N_("With graphical user interface (required by some actions)"), ""); + gapp->add_main_option_entry(T::OPTION_TYPE_BOOL, "batch-process", '\0', N_("Close GUI after executing all actions"), ""); + _start_main_option_section(); + gapp->add_main_option_entry(T::OPTION_TYPE_BOOL, "shell", '\0', N_("Start Inkscape in interactive shell mode"), ""); + + // clang-format on + + gapp->signal_handle_local_options().connect(sigc::mem_fun(*this, &InkscapeApplication::on_handle_local_options)); + + if (_with_gui && !non_unique) { // Will fail to register if not unique. + // On macOS, this enables: + // - DnD via dock icon + // - system menu "Quit" + gtk_app()->property_register_session() = true; + } +} + +/** Create a window given a document. This is used internally in InkscapeApplication. + */ +InkscapeWindow* +InkscapeApplication::create_window(SPDocument *document, bool replace) +{ + if (!gtk_app()) { + g_assert_not_reached(); + return nullptr; + } + + SPDocument *old_document = _active_document; + InkscapeWindow* window = InkscapeApplication::get_active_window(); + + if (replace && old_document && window) { + document_swap (window, document); + + // Delete old document if no longer attached to any window. + auto it = _documents.find (old_document); + if (it != _documents.end()) { + if (it->second.size() == 0) { + document_close (old_document); + } + } + } else { + window = window_open (document); + } + window->show(); + + return window; +} + + +/** Create a window given a Gio::File. This is what most external functions should call. + * + * @param file - The filename to open as a Gio::File object +*/ +void +InkscapeApplication::create_window(const Glib::RefPtr<Gio::File>& file) +{ + if (!gtk_app()) { + g_assert_not_reached(); + return; + } + + SPDocument* document = nullptr; + InkscapeWindow* window = nullptr; + bool cancelled = false; + + if (file) { + startup_close(); + document = document_open(file, &cancelled); + if (document) { + // Remember document so much that we'll add it to recent documents + auto recentmanager = Gtk::RecentManager::get_default(); + recentmanager->add_item (file->get_uri()); + + SPDocument* old_document = _active_document; + bool replace = old_document && old_document->getVirgin(); + + window = create_window (document, replace); + document_fix(window); + } else if (!cancelled) { + std::cerr << "ConcreteInkscapeApplication<T>::create_window: Failed to load: " + << file->get_parse_name() << std::endl; + + gchar *text = g_strdup_printf(_("Failed to load the requested file %s"), file->get_parse_name().c_str()); + sp_ui_error_dialog(text); + g_free(text); + } + + } else { + document = document_new (); + if (document) { + window = window_open (document); + } else { + std::cerr << "ConcreteInkscapeApplication<T>::create_window: Failed to open default document!" << std::endl; + } + } + + _active_document = document; + _active_window = window; +} + +/** Destroy a window and close the document it contains. Aborts if document needs saving. + * Replaces document and keeps window open if last window and keep_alive is true. + * Returns true if window destroyed. + */ +bool +InkscapeApplication::destroy_window(InkscapeWindow* window, bool keep_alive) +{ + if (!gtk_app()) { + g_assert_not_reached(); + return false; + } + + SPDocument* document = window->get_document(); + + if (!document) { + std::cerr << "InkscapeApplication::destroy_window: window has no document!" << std::endl; + return false; + } + + // Remove document if no window with document is left. + auto it = _documents.find(document); + if (it != _documents.end()) { + + // If only one window for document: + if (it->second.size() == 1) { + // Check if document needs saving. + bool abort = document_check_for_data_loss(window); + if (abort) { + return false; + } + } + + if (get_number_of_windows() == 1 && keep_alive) { + // Last window, replace with new document. + auto new_document = document_new(); + document_swap(window, new_document); + } else { + window_close(window); + if (get_number_of_windows() == 0) { + // No Inkscape windows left, remove dialog windows. + for (auto const &window : gtk_app()->get_windows()) { + window->close(); + } + } + } + + if (it->second.size() == 0) { + // No window contains document so let's close it. + document_close (document); + } + + } else { + std::cerr << "ConcreteInkscapeApplication<Gtk::Application>::destroy_window: Could not find document!" << std::endl; + } + + // Debug + // auto windows = get_windows(); + // std::cout << "destroy_windows: app windows size: " << windows.size() << std::endl; + + return true; +} + +bool +InkscapeApplication::destroy_all() +{ + if (!gtk_app()) { + g_assert_not_reached(); + return false; + } + + while (_documents.size() != 0) { + auto it = _documents.begin(); + if (!it->second.empty()) { + auto it2 = it->second.begin(); + if (!destroy_window (*it2)) { + return false; // If destroy aborted, we need to stop exit. + } + } + } + return true; +} + +/** Common processing for documents + */ +void +InkscapeApplication::process_document(SPDocument* document, std::string output_path) +{ + // Add to Inkscape::Application... + INKSCAPE.add_document(document); + + // Are we doing one file at a time? In that case, we don't recreate new windows for each file. + bool replace = _use_pipe || _batch_process; + + // Open window if needed (reuse window if we are doing one file at a time inorder to save overhead). + _active_document = document; + if (_with_gui) { + _active_window = create_window(document, replace); + _active_view = _active_window->get_desktop(); + } else { + _active_window = nullptr; + _active_view = nullptr; + _active_selection = document->getSelection(); + } + + document->ensureUpToDate(); // Or queries don't work! + + // process_file + for (auto action: _command_line_actions) { + if (!_gio_application->has_action(action.first)) { + std::cerr << "ConcreteInkscapeApplication<T>::process_document: Unknown action name: " << action.first << std::endl; + } + _gio_application->activate_action( action.first, action.second ); + } + + if (_use_shell) { + shell(); + } + if (_with_gui && _active_window) { + document_fix(_active_window); + } + // Only if --export-filename, --export-type --export-overwrite, or --export-use-hints are used. + if (_auto_export) { + // Save... can't use action yet. + _file_export.do_export(document, output_path); + } +} + +/* + * Called on first Inkscape instance creation. Not called if a new Inkscape instance is merged + * with an existing instance. + */ +void +InkscapeApplication::on_startup() +{ + // Deprecated... + Inkscape::Application::create(_with_gui); + + // Extensions + Inkscape::Extension::init(); + + // Command line execution. Must be after Extensions are initialized. + parse_actions(_command_line_actions_input, _command_line_actions); + + if (!_with_gui) { + return; + } + + auto *gapp = gio_app(); + + // ======================= Actions (GUI) ====================== + gapp->add_action("new", sigc::mem_fun(*this, &InkscapeApplication::on_new )); + gapp->add_action("quit", sigc::mem_fun(*this, &InkscapeApplication::on_quit )); + + // ========================= GUI Init ========================= + Gtk::Window::set_default_icon_name("org.inkscape.Inkscape"); + + // build_menu(); // Builds and adds menu to app. Used by all Inkscape windows. This can be done + // before all actions defined. * For the moment done by each window so we can add + // window action info to menu_label_to_tooltip map. +} + +// Open document window with default document or pipe. Either this or on_open() is called. +void +InkscapeApplication::on_activate() +{ + std::string output; + + // Create new document, either from pipe or from template. + SPDocument *document = nullptr; + auto prefs = Inkscape::Preferences::get(); + + if (_use_pipe) { + + // Create document from pipe in. + std::istreambuf_iterator<char> begin(std::cin), end; + std::string s(begin, end); + document = document_open (s); + output = "-"; + + } else if(prefs->getBool("/options/boot/enabled", true) + && !_use_command_line_argument + && (gtk_app() && gtk_app()->get_windows().empty())) { + + Inkscape::UI::Dialog::StartScreen start_screen; + + // add start window to gtk_app to ensure proper closing on quit + gtk_app()->add_window(start_screen); + + start_screen.run(); + document = start_screen.get_document(); + } else { + + // Create a blank document from template + document = document_new(); + } + startup_close(); + + if (!document) { + std::cerr << "ConcreteInkscapeApplication::on_activate: failed to create document!" << std::endl; + return; + } + + // Process document (command line actions, shell, create window) + process_document (document, output); + + if (_batch_process) { + // If with_gui, we've reused a window for each file. We must quit to destroy it. + gio_app()->quit(); + } +} + +void +InkscapeApplication::startup_close() +{ + if (auto app = gtk_app()) { + // Close any open start screens preventing double opens + for (auto win : app->get_windows()) { + if (auto start = dynamic_cast<Inkscape::UI::Dialog::StartScreen *>(win)) { + start->close(); + } + } + } +} + +// Open document window for each file. Either this or on_activate() is called. +// type_vec_files == std::vector<Glib::RefPtr<Gio::File> > +void +InkscapeApplication::on_open(const Gio::Application::type_vec_files& files, const Glib::ustring& hint) +{ + if(_pdf_poppler) + INKSCAPE.set_pdf_poppler(_pdf_poppler); + if(_pdf_page) + INKSCAPE.set_pdf_page(_pdf_page); + + if (files.size() > 1 && !_file_export.export_filename.empty()) { + std::cerr << "ConcreteInkscapeApplication<Gtk::Application>::on_open: " + "Can't use '--export-filename' with multiple input files " + "(output file would be overwritten for each input file). " + "Please use '--export-type' instead and rename manually." + << std::endl; + return; + } + + startup_close(); + for (auto file : files) { + + // Open file + SPDocument *document = document_open (file); + if (!document) { + std::cerr << "ConcreteInkscapeApplication::on_open: failed to create document!" << std::endl; + continue; + } + + // Process document (command line actions, shell, create window) + process_document (document, file->get_path()); + } + + if (_batch_process) { + // If with_gui, we've reused a window for each file. We must quit to destroy it. + gio_app()->quit(); + } +} + +void +InkscapeApplication::parse_actions(const Glib::ustring& input, action_vector_t& action_vector) +{ + const auto re_colon = Glib::Regex::create("\\s*:\\s*"); + + // Split action list + std::vector<Glib::ustring> tokens = Glib::Regex::split_simple("\\s*;\\s*", input); + for (auto token : tokens) { + // Note: split into 2 tokens max ("param:value"); allows value to contain colon (e.g. abs. paths on Windows) + std::vector<Glib::ustring> tokens2 = re_colon->split(token, 0, static_cast<Glib::RegexMatchFlags>(0), 2); + std::string action; + std::string value; + if (tokens2.size() > 0) { + action = tokens2[0]; + } + if (action.find_first_not_of(" \f\n\r\t\v") == std::string::npos) { + continue; + } + if (tokens2.size() > 1) { + value = tokens2[1]; + } + + Glib::RefPtr<Gio::Action> action_ptr = _gio_application->lookup_action(action); + if (action_ptr) { + // Doesn't seem to be a way to test this using the C++ binding without Glib-CRITICAL errors. + const GVariantType* gtype = g_action_get_parameter_type(action_ptr->gobj()); + if (gtype) { + // With value. + Glib::VariantType type = action_ptr->get_parameter_type(); + if (type.get_string() == "b") { + bool b = false; + if (value == "1" || value == "true" || value.empty()) { + b = true; + } else if (value == "0" || value == "false") { + b = false; + } else { + std::cerr << "InkscapeApplication::parse_actions: Invalid boolean value: " << action << ":" << value << std::endl; + } + action_vector.push_back( + std::make_pair( action, Glib::Variant<bool>::create(b))); + } else if (type.get_string() == "i") { + action_vector.push_back( + std::make_pair( action, Glib::Variant<int>::create(std::stoi(value)))); + } else if (type.get_string() == "d") { + action_vector.push_back( + std::make_pair( action, Glib::Variant<double>::create(std::stod(value)))); + } else if (type.get_string() == "s") { + action_vector.push_back( + std::make_pair( action, Glib::Variant<Glib::ustring>::create(value) )); + } else if (type.get_string() == "(dd)") { + std::vector<Glib::ustring> tokens3 = Glib::Regex::split_simple(",", value); + if (tokens3.size() != 2) { + std::cerr << "InkscapeApplication::parse_actions: " << action << " requires two comma separated numbers" << std::endl; + continue; + } + + double d0 = 0; + double d1 = 0; + try { + d0 = std::stod(tokens3[0]); + d1 = std::stod(tokens3[1]); + } catch (...) { + std::cerr << "InkscapeApplication::parse_actions: " << action << " requires two comma separated numbers" << std::endl; + continue; + } + + action_vector.push_back( + std::make_pair( action, Glib::Variant<std::tuple<double, double>>::create(std::tuple<double, double>(d0, d1)))); + } else { + std::cerr << "InkscapeApplication::parse_actions: unhandled action value: " + << action << ": " << type.get_string() << std::endl; + } + } else { + // Stateless (i.e. no value). + action_vector.push_back( std::make_pair( action, Glib::VariantBase() ) ); + } + } else { + std::cerr << "InkscapeApplication::parse_actions: could not find action for: " << action << std::endl; + } + } +} + +#ifdef WITH_GNU_READLINE + +// For use in shell mode. Command completion of action names. +char* readline_generator (const char* text, int state) +{ + static std::vector<Glib::ustring> actions; + + // Fill the vector of action names. + if (actions.size() == 0) { + auto *app = InkscapeApplication::instance(); + actions = app->gio_app()->list_actions(); + std::sort(actions.begin(), actions.end()); + } + + static int list_index = 0; + static int len = 0; + + if (!state) { + list_index = 0; + len = strlen(text); + } + + const char* name = nullptr; + while (list_index < actions.size()) { + name = actions[list_index].c_str(); + list_index++; + if (strncmp (name, text, len) == 0) { + return (strdup(name)); + } + } + + return ((char*)nullptr); +} + +char** readline_completion(const char* text, int start, int end) +{ + char **matches = (char**)nullptr; + + // Match actions names, but only at start of line. + // It would be nice to also match action names after a ';' but it's not possible as text won't include ';'. + if (start == 0) { + matches = rl_completion_matches (text, readline_generator); + } + + return (matches); +} + +void readline_init() +{ + rl_readline_name = "inkscape"; + rl_attempted_completion_function = readline_completion; +} +#endif // WITH_GNU_READLINE + + +// Once we don't need to create a window just to process verbs! +void +InkscapeApplication::shell() +{ + std::cout << "Inkscape interactive shell mode. Type 'action-list' to list all actions. " + << "Type 'quit' to quit." << std::endl; + std::cout << " Input of the form:" << std::endl; + std::cout << " action1:arg1; action2:arg2; ..." << std::endl; + if (!_with_gui) { + std::cout << "Only actions that don't require a desktop may be used." << std::endl; + } + +#ifdef WITH_GNU_READLINE + auto history_file = Glib::build_filename(Inkscape::IO::Resource::profile_path(), "shell.history"); + +#ifdef _WIN32 + gchar *locale_filename = g_win32_locale_filename_from_utf8(history_file.c_str()); + if (locale_filename) { + history_file = locale_filename; + g_free(locale_filename); + } +#endif + + static bool init = false; + if (!init) { + readline_init(); + using_history(); + init = true; + + int error = read_history(history_file.c_str()); + if (error && error != ENOENT) { + std::cerr << "read_history error: " << std::strerror(error) << " " << history_file << std::endl; + } + } +#endif + + while (std::cin.good()) { + bool eof = false; + std::string input; + +#ifdef WITH_GNU_READLINE + char *readline_input = readline("> "); + if (readline_input) { + input = readline_input; + if (input != "quit" && input != "q") { + add_history(readline_input); + } + } else { + eof = true; + } + free(readline_input); +#else + std::cout << "> "; + std::getline(std::cin, input); +#endif + + // Remove trailing space + input = std::regex_replace(input, std::regex(" +$"), ""); + + if (eof || input == "quit" || input == "q") { + break; + } + + action_vector_t action_vector; + parse_actions(input, action_vector); + for (auto action: action_vector) { + _gio_application->activate_action( action.first, action.second ); + } + + // This would allow displaying the results of actions on the fly... but it needs to be well + // vetted first. + Glib::RefPtr<Glib::MainContext> context = Glib::MainContext::get_default(); + while (context->iteration(false)) {}; + } + +#ifdef WITH_GNU_READLINE + stifle_history(200); // ToDo: Make number a preference. + int error = write_history(history_file.c_str()); + if (error) { + std::cerr << "write_history error: " << std::strerror(error) << " " << history_file << std::endl; + } +#endif + + if (_with_gui) { + _gio_application->quit(); // Force closing windows. + } +} + + +// ========================= Callbacks ========================== + +/* + * Handle command line options. + * + * Options are processed in the order they appear in this function. + * We process in order: Print -> GUI -> Open -> Query -> Process -> Export. + * For each file without GUI: Open -> Query -> Process -> Export + * More flexible processing can be done via actions. + */ +int +InkscapeApplication::on_handle_local_options(const Glib::RefPtr<Glib::VariantDict>& options) +{ + auto prefs = Inkscape::Preferences::get(); + if (!options) { + std::cerr << "InkscapeApplication::on_handle_local_options: options is null!" << std::endl; + return -1; // Keep going + } + + // ===================== APP ID ==================== + if (options->contains("app-id-tag")) { + Glib::ustring id_tag; + options->lookup_value("app-id-tag", id_tag); + Glib::ustring app_id = "org.inkscape.Inkscape." + id_tag; + if (Gio::Application::id_is_valid(app_id)) { + _gio_application->set_id(app_id); + } else { + std::cerr << "InkscapeApplication: invalid application id: " << app_id << std::endl; + std::cerr << " tag must be ASCII and not start with a number." << std::endl; + } + } + + // ===================== QUERY ===================== + // These are processed first as they result in immediate program termination. + // Note: we cannot use actions here as the app has not been registered yet (registering earlier + // causes problems with changing the app id). + if (options->contains("version")) { + std::cout << Inkscape::inkscape_version() << std::endl; + return EXIT_SUCCESS; + } + + if (options->contains("debug-info")) { + std::cout << Inkscape::debug_info() << std::endl; + return EXIT_SUCCESS; + } + + if (options->contains("system-data-directory")) { + std::cout << Glib::build_filename(get_inkscape_datadir(), "inkscape") << std::endl; + return EXIT_SUCCESS; + } + + if (options->contains("user-data-directory")) { + std::cout << Inkscape::IO::Resource::profile_path("") << std::endl; + return EXIT_SUCCESS; + } + + // Can't do this until after app is registered! + // if (options->contains("action-list")) { + // print_action_list(); + // return EXIT_SUCCESS; + // } + + // For options without arguments. + auto base = Glib::VariantBase(); + + // ================== GUI and Shell ================ + + // Use of most command line options turns off use of gui unless explicitly requested! + // Listed in order that they appear in constructor. + if (options->contains("pipe") || + + options->contains("export-filename") || + options->contains("export-overwrite") || + options->contains("export-type") || + + options->contains("export-area-page") || + options->contains("export-area-drawing") || + options->contains("export-area") || + options->contains("export-area-snap") || + options->contains("export-dpi") || + options->contains("export-width") || + options->contains("export-height") || + options->contains("export-margin") || + options->contains("export-height") || + + options->contains("export-id") || + options->contains("export-id-only") || + options->contains("export-plain-svg") || + options->contains("export-ps-level") || + options->contains("export-pdf-version") || + options->contains("export-text-to_path") || + options->contains("export-latex") || + options->contains("export-ignore-filters") || + options->contains("export-use-hints") || + options->contains("export-background") || + options->contains("export-background-opacity") || + options->contains("export-text-to_path") || + + options->contains("query-id") || + options->contains("query-x") || + options->contains("query-all") || + options->contains("query-y") || + options->contains("query-width") || + options->contains("query-height") || + + options->contains("vacuum-defs") || + options->contains("select") || + options->contains("action-list") || + options->contains("actions") || + options->contains("shell") + ) { + _with_gui = false; + } + + if (options->contains("with-gui") || + options->contains("batch-process") + ) { + _with_gui = bool(gtk_app()); // Override turning GUI off + if (!_with_gui) + std::cerr << "No GUI available, some actions may fail" << std::endl; + } + + if (options->contains("batch-process")) _batch_process = true; + if (options->contains("shell")) _use_shell = true; + if (options->contains("pipe")) _use_pipe = true; + + + // Enable auto-export + if (options->contains("export-filename") || + options->contains("export-type") || + options->contains("export-overwrite") || + options->contains("export-use-hints") + ) { + _auto_export = true; + } + + // If we are running in command-line mode (without gui) and we haven't explicitly changed the app_id, + // change it here so that this instance of Inkscape is not merged with an existing instance (otherwise + // unwanted windows will pop up and the command-line arguments will be ignored). + if (_with_gui == false && + !options->contains("app-id-tag")) { + Glib::ustring app_id = "org.inkscape.Inkscape.p" + std::to_string(getpid()); + _gio_application->set_id(app_id); + } + + // ==================== ACTIONS ==================== + // Actions as an argument string: e.g.: --actions="query-id:rect1;query-x". + // Actions will be processed in order that they are given in argument. + Glib::ustring actions; + if (options->contains("actions")) { + options->lookup_value("actions", _command_line_actions_input); + // Parsing done after extensions initialized. + } + + // This must be done after the app has been registered! + if (options->contains("action-list")) { + _command_line_actions.push_back(std::make_pair("action-list", base)); + } + + // ================= OPEN/IMPORT =================== + + if (options->contains("pdf-poppler")) { + _pdf_poppler = true; + } + if (options->contains("pdf-page")) { // Maybe useful for other file types? + int page = 0; + options->lookup_value("pdf-page", page); + _pdf_page = page; + } + + if (options->contains("convert-dpi-method")) { + Glib::ustring method; + options->lookup_value("convert-dpi-method", method); + if (!method.empty()) { + _command_line_actions.push_back( + std::make_pair("convert-dpi-method", Glib::Variant<Glib::ustring>::create(method))); + } + } + + if (options->contains("no-convert-text-baseline-spacing")) _command_line_actions.push_back(std::make_pair("no-convert-baseline", base)); + + + // ===================== QUERY ===================== + + // 'query-id' should be processed first! Can be a comma-separated list. + if (options->contains("query-id")) { + Glib::ustring query_id; + options->lookup_value("query-id", query_id); + if (!query_id.empty()) { + _command_line_actions.push_back( + std::make_pair("select-by-id", Glib::Variant<Glib::ustring>::create(query_id))); + } + } + + if (options->contains("query-all")) _command_line_actions.push_back(std::make_pair("query-all", base)); + if (options->contains("query-x")) _command_line_actions.push_back(std::make_pair("query-x", base)); + if (options->contains("query-y")) _command_line_actions.push_back(std::make_pair("query-y", base)); + if (options->contains("query-width")) _command_line_actions.push_back(std::make_pair("query-width", base)); + if (options->contains("query-height")) _command_line_actions.push_back(std::make_pair("query-height",base)); + + + // =================== PROCESS ===================== + + if (options->contains("vacuum-defs")) _command_line_actions.push_back(std::make_pair("vacuum-defs", base)); + + if (options->contains("select")) { + Glib::ustring select; + options->lookup_value("select", select); + if (!select.empty()) { + _command_line_actions.push_back( + std::make_pair("select", Glib::Variant<Glib::ustring>::create(select))); + } + } + + // ==================== EXPORT ===================== + if (options->contains("export-filename")) { + options->lookup_value("export-filename", _file_export.export_filename); + } + + if (options->contains("export-type")) { + options->lookup_value("export-type", _file_export.export_type); + } + if (options->contains("export-extension")) { + options->lookup_value("export-extension", _file_export.export_extension); + _file_export.export_extension = _file_export.export_extension.lowercase(); + } + + if (options->contains("export-overwrite")) _file_export.export_overwrite = true; + + // Export - Geometry + if (options->contains("export-area")) { + options->lookup_value("export-area", _file_export.export_area); + } + + if (options->contains("export-area-drawing")) _file_export.export_area_drawing = true; + if (options->contains("export-area-page")) _file_export.export_area_page = true; + + if (options->contains("export-margin")) { + options->lookup_value("export-margin", _file_export.export_margin); + } + + if (options->contains("export-area-snap")) _file_export.export_area_snap = true; + + if (options->contains("export-width")) { + options->lookup_value("export-width", _file_export.export_width); + } + + if (options->contains("export-height")) { + options->lookup_value("export-height", _file_export.export_height); + } + + // Export - Options + if (options->contains("export-id")) { + options->lookup_value("export-id", _file_export.export_id); + } + + if (options->contains("export-id-only")) _file_export.export_id_only = true; + if (options->contains("export-plain-svg")) _file_export.export_plain_svg = true; + + if (options->contains("export-dpi")) { + options->lookup_value("export-dpi", _file_export.export_dpi); + } + + if (options->contains("export-ignore-filters")) _file_export.export_ignore_filters = true; + if (options->contains("export-text-to-path")) _file_export.export_text_to_path = true; + + if (options->contains("export-ps-level")) { + options->lookup_value("export-ps-level", _file_export.export_ps_level); + } + + if (options->contains("export-pdf-version")) { + options->lookup_value("export-pdf-version", _file_export.export_pdf_level); + } + + if (options->contains("export-latex")) _file_export.export_latex = true; + if (options->contains("export-use-hints")) _file_export.export_use_hints = true; + + if (options->contains("export-background")) { + options->lookup_value("export-background",_file_export.export_background); + } + + // FIXME: Upstream bug means DOUBLE is ignored if set to 0.0 so doesn't exist in options + if (options->contains("export-background-opacity")) { + Glib::ustring opacity; + options->lookup_value("export-background-opacity", opacity); + _file_export.export_background_opacity = Glib::Ascii::strtod(opacity); + } + + if (options->contains("export-png-color-mode")) { + options->lookup_value("export-png-color-mode", _file_export.export_png_color_mode); + } + + if (options->contains("export-png-use-dithering")) { +#ifndef CAIRO_HAS_DITHER + std::cerr << "Your cairo version does not support dithering! Option will be ignored." << std::endl; +#endif + Glib::ustring val; + options->lookup_value("export-png-use-dithering", val); + if (val == "true") _file_export.export_png_use_dithering = true; + else if (val == "false") _file_export.export_png_use_dithering = false; + else std::cerr << "invalid value for export-png-use-dithering. Ignoring." << std::endl; + } else _file_export.export_png_use_dithering = prefs->getBool("/options/dithering/render", false); + + + GVariantDict *options_copy = options->gobj_copy(); + GVariant *options_var = g_variant_dict_end(options_copy); + if (g_variant_get_size(options_var) != 0) { + _use_command_line_argument = true; + } + g_variant_dict_unref(options_copy); + g_variant_unref(options_var); + + return -1; // Keep going +} + +// ======================== Actions ========================= + +void +InkscapeApplication::on_new() +{ + create_window(); +} + +void +InkscapeApplication::on_quit() +{ + if (gtk_app()) { + if (!destroy_all()) return; // Quit aborted. + // For mac, ensure closing the gtk_app windows + for (auto window : gtk_app()->get_windows()) { + window->close(); + } + } + + gio_app()->quit(); +} + +/* + * Quit without checking for data loss. + */ +void +InkscapeApplication::on_quit_immediate() +{ + gio_app()->quit(); +} + +void +InkscapeApplication::print_action_list() +{ + auto const *gapp = gio_app(); + + auto actions = gapp->list_actions(); + std::sort(actions.begin(), actions.end()); + for (auto const &action : actions) { + Glib::ustring fullname("app." + action); + std::cout << std::left << std::setw(20) << action + << ": " << _action_extra_data.get_tooltip_for_action(fullname) << std::endl; + } +} + +/** + * Return number of open Inkscape Windows (irrespective of number of documents) +.*/ +int InkscapeApplication::get_number_of_windows() const { + if (_with_gui) { + return std::accumulate(_documents.begin(), _documents.end(), 0, + [&](int sum, auto& v){ return sum + static_cast<int>(v.second.size()); }); + } + return 0; +} + +void InkscapeApplication::set_active_document(SPDocument* document) +{ + _active_document = document; + if (document) { + // Keep macOS undo menu items upto date. + document->get_event_log()->updateUndoVerbs(); + } +} + +/* + 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 : |