Adding upstream version 1.2.2.upstream/1.2.2upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 710 insertions, 0 deletions

diff --git a/src/extension/system.cpp b/src/extension/system.cpp
new file mode 100644
index 0000000..f4ba2dc
--- /dev/null
+++ b/src/extension/system.cpp
@@ -0,0 +1,710 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * This is file is kind of the junk file.  Basically everything that
+ * didn't fit in one of the other well defined areas, well, it's now
+ * here.  Which is good in someways, but this file really needs some
+ * definition.  Hopefully that will come ASAP.
+ *
+ * Authors:
+ *   Ted Gould <ted@gould.cx>
+ *   Johan Engelen <johan@shouraizou.nl>
+ *   Jon A. Cruz <jon@joncruz.org>
+ *   Abhishek Sharma
+ *
+ * Copyright (C) 2006-2007 Johan Engelen
+ * Copyright (C) 2002-2004 Ted Gould
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#include "ui/interface.h"
+
+#include "system.h"
+#include "preferences.h"
+#include "extension.h"
+#include "db.h"
+#include "input.h"
+#include "output.h"
+#include "effect.h"
+#include "patheffect.h"
+#include "print.h"
+#include "implementation/script.h"
+#include "implementation/xslt.h"
+#include "xml/rebase-hrefs.h"
+#include "io/sys.h"
+#include "inkscape.h"
+#include "document-undo.h"
+#include "loader.h"
+
+#include <glibmm/miscutils.h>
+
+namespace Inkscape {
+namespace Extension {
+
+static void open_internal(Inkscape::Extension::Extension *in_plug, gpointer in_data);
+static void save_internal(Inkscape::Extension::Extension *in_plug, gpointer in_data);
+
+/**
+ * \return   A new document created from the filename passed in
+ * \brief    This is a generic function to use the open function of
+ *           a module (including Autodetect)
+ * \param    key       Identifier of which module to use
+ * \param    filename  The file that should be opened
+ *
+ * First things first, are we looking at an autodetection?  Well if that's the case then the module
+ * needs to be found, and that is done with a database lookup through the module DB.  The foreach
+ * function is called, with the parameter being a gpointer array.  It contains both the filename
+ * (to find its extension) and where to write the module when it is found.
+ *
+ * If there is no autodetection, then the module database is queried with the key given.
+ *
+ * If everything is cool at this point, the module is loaded, and there is possibility for
+ * preferences.  If there is a function, then it is executed to get the dialog to be displayed.
+ * After it is finished the function continues.
+ *
+ * Lastly, the open function is called in the module itself.
+ */
+SPDocument *open(Extension *key, gchar const *filename)
+{
+    Input *imod = nullptr;
+
+    if (key == nullptr) {
+        gpointer parray[2];
+        parray[0] = (gpointer)filename;
+        parray[1] = (gpointer)&imod;
+        db.foreach(open_internal, (gpointer)&parray);
+    } else {
+        imod = dynamic_cast<Input *>(key);
+    }
+
+    bool last_chance_svg = false;
+    if (key == nullptr && imod == nullptr) {
+        last_chance_svg = true;
+        imod = dynamic_cast<Input *>(db.get(SP_MODULE_KEY_INPUT_SVG));
+    }
+
+    if (imod == nullptr) {
+        throw Input::no_extension_found();
+    }
+
+    // Hide pixbuf extensions depending on user preferences.
+    //g_warning("Extension: %s", imod->get_id());
+
+    bool show = true;
+    if (strlen(imod->get_id()) > 21) {
+        Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+        bool ask = prefs->getBool("/dialogs/import/ask");
+        bool ask_svg = prefs->getBool("/dialogs/import/ask_svg");
+        Glib::ustring id = Glib::ustring(imod->get_id(), 22);
+        if (id.compare("org.inkscape.input.svg") == 0) {
+            if (ask_svg && prefs->getBool("/options/onimport", false)) {
+                show = true;
+                imod->set_gui(true);
+            } else {
+                show = false;
+                imod->set_gui(false);
+            }
+        } else if(strlen(imod->get_id()) > 27) {
+            id = Glib::ustring(imod->get_id(), 28);
+            if (!ask && id.compare( "org.inkscape.input.gdkpixbuf") == 0) {
+                show = false;
+                imod->set_gui(false);
+            }
+        }
+    }
+    imod->set_state(Extension::STATE_LOADED);
+
+    if (!imod->loaded()) {
+        throw Input::open_failed();
+    }
+
+    if (!imod->prefs(filename)) {
+        throw Input::open_cancelled();
+    }
+
+    SPDocument *doc = imod->open(filename);
+
+    if (!doc) {
+        if (last_chance_svg) {
+            if ( INKSCAPE.use_gui() ) {
+                sp_ui_error_dialog(_("Could not detect file format. Tried to open it as an SVG anyway but this also failed."));
+            } else {
+                g_warning("%s", _("Could not detect file format. Tried to open it as an SVG anyway but this also failed."));
+            }
+        }
+        throw Input::open_failed();
+    }
+    // If last_chance_svg is true here, it means we successfully opened a file as an svg
+    // and there's no need to warn the user about it, just do it.
+
+    doc->setDocumentFilename(filename);
+    if (!show) {
+        imod->set_gui(true);
+    }
+
+    return doc;
+}
+
+/**
+ * \return   none
+ * \brief    This is the function that searches each module to see
+ *           if it matches the filename for autodetection.
+ * \param    in_plug  The module to be tested
+ * \param    in_data  An array of pointers containing the filename, and
+ *                    the place to put a successfully found module.
+ *
+ * Basically this function only looks at input modules as it is part of the open function.  If the
+ * module is an input module, it then starts to take it apart, and the data that is passed in.
+ * Because the data being passed in is in such a weird format, there are a few casts to make it
+ * easier to use.  While it looks like a lot of local variables, they'll all get removed by the
+ * compiler.
+ *
+ * First thing that is checked is if the filename is shorter than the extension itself.  There is
+ * no way for a match in that case.  If it's long enough then there is a string compare of the end
+ * of the filename (for the length of the extension), and the extension itself.  If this passes
+ * then the pointer passed in is set to the current module.
+ */
+static void
+open_internal(Extension *in_plug, gpointer in_data)
+{
+    auto imod = dynamic_cast<Input *>(in_plug);
+    if (imod && !imod->deactivated()) {
+        gpointer *parray = (gpointer *)in_data;
+        gchar const *filename = (gchar const *)parray[0];
+        Input **pimod = (Input **)parray[1];
+
+        // skip all the rest if we already found a function to open it
+        // since they're ordered by preference now.
+        if (!*pimod) {
+            gchar const *ext = imod->get_extension();
+
+            gchar *filenamelower = g_utf8_strdown(filename, -1);
+            gchar *extensionlower = g_utf8_strdown(ext, -1);
+
+            if (g_str_has_suffix(filenamelower, extensionlower)) {
+                *pimod = imod;
+            }
+
+            g_free(filenamelower);
+            g_free(extensionlower);
+        }
+    }
+
+    return;
+}
+
+/**
+ * \return   None
+ * \brief    This is a generic function to use the save function of
+ *           a module (including Autodetect)
+ * \param    key       Identifier of which module to use
+ * \param    doc       The document to be saved
+ * \param    filename  The file that the document should be saved to
+ * \param    official  (optional) whether to set :output_module and :modified in the
+ *                     document; is true for normal save, false for temporary saves
+ *
+ * First things first, are we looking at an autodetection?  Well if that's the case then the module
+ * needs to be found, and that is done with a database lookup through the module DB.  The foreach
+ * function is called, with the parameter being a gpointer array.  It contains both the filename
+ * (to find its extension) and where to write the module when it is found.
+ *
+ * If there is no autodetection the module database is queried with the key given.
+ *
+ * If everything is cool at this point, the module is loaded, and there is possibility for
+ * preferences.  If there is a function, then it is executed to get the dialog to be displayed.
+ * After it is finished the function continues.
+ *
+ * Lastly, the save function is called in the module itself.
+ */
+void
+save(Extension *key, SPDocument *doc, gchar const *filename, bool check_overwrite, bool official,
+    Inkscape::Extension::FileSaveMethod save_method)
+{
+    Output *omod;
+    if (key == nullptr) {
+        gpointer parray[2];
+        parray[0] = (gpointer)filename;
+        parray[1] = (gpointer)&omod;
+        omod = nullptr;
+        db.foreach(save_internal, (gpointer)&parray);
+
+        /* This is a nasty hack, but it is required to ensure that
+           autodetect will always save with the Inkscape extensions
+           if they are available. */
+        if (omod != nullptr && !strcmp(omod->get_id(), SP_MODULE_KEY_OUTPUT_SVG)) {
+            omod = dynamic_cast<Output *>(db.get(SP_MODULE_KEY_OUTPUT_SVG_INKSCAPE));
+        }
+        /* If autodetect fails, save as Inkscape SVG */
+        if (omod == nullptr) {
+            // omod = dynamic_cast<Output *>(db.get(SP_MODULE_KEY_OUTPUT_SVG_INKSCAPE)); use exception and let user choose
+        }
+    } else {
+        omod = dynamic_cast<Output *>(key);
+    }
+
+    if (!dynamic_cast<Output *>(omod)) {
+        g_warning("Unable to find output module to handle file: %s\n", filename);
+        throw Output::no_extension_found();
+    }
+
+    omod->set_state(Extension::STATE_LOADED);
+    if (!omod->loaded()) {
+        throw Output::save_failed();
+    }
+
+    if (!omod->prefs()) {
+        throw Output::save_cancelled();
+    }
+
+    gchar *fileName = g_strdup(filename);
+
+    if (check_overwrite && !sp_ui_overwrite_file(fileName)) {
+        g_free(fileName);
+        throw Output::no_overwrite();
+    }
+
+    // test if the file exists and is writable
+    // the test only checks the file attributes and might pass where ACL does not allow writes
+    if (Inkscape::IO::file_test(filename, G_FILE_TEST_EXISTS) && !Inkscape::IO::file_is_writable(filename)) {
+        g_free(fileName);
+        throw Output::file_read_only();
+    }
+
+    Inkscape::XML::Node *repr = doc->getReprRoot();
+
+
+    // remember attributes in case this is an unofficial save and/or overwrite fails
+    gchar *saved_filename = g_strdup(doc->getDocumentFilename());
+    gchar *saved_output_extension = nullptr;
+    gchar *saved_dataloss = nullptr;
+    bool saved_modified = doc->isModifiedSinceSave();
+    saved_output_extension = g_strdup(get_file_save_extension(save_method).c_str());
+    saved_dataloss = g_strdup(repr->attribute("inkscape:dataloss"));
+    if (official) {
+        // The document is changing name/uri.
+        doc->changeFilenameAndHrefs(fileName);
+    }
+
+    // Update attributes:
+    {
+        {
+            DocumentUndo::ScopedInsensitive _no_undo(doc);
+            // also save the extension for next use
+            store_file_extension_in_prefs (omod->get_id(), save_method);
+            // set the "dataloss" attribute if the chosen extension is lossy
+            repr->removeAttribute("inkscape:dataloss");
+            if (omod->causes_dataloss()) {
+                repr->setAttribute("inkscape:dataloss", "true");
+            }
+        }
+        doc->setModifiedSinceSave(false);
+    }
+
+    try {
+        omod->save(doc, fileName);
+    }
+    catch(...) {
+        // revert attributes in case of official and overwrite
+        if(check_overwrite && official) {
+            {
+                DocumentUndo::ScopedInsensitive _no_undo(doc);
+                store_file_extension_in_prefs (saved_output_extension, save_method);
+                repr->setAttribute("inkscape:dataloss", saved_dataloss);
+            }
+            doc->changeFilenameAndHrefs(saved_filename);
+        }
+        doc->setModifiedSinceSave(saved_modified);
+        // free used resources
+        g_free(saved_output_extension);
+        g_free(saved_dataloss);
+        g_free(saved_filename);
+
+        g_free(fileName);
+
+        throw;
+    }
+
+    // If it is an unofficial save, set the modified attributes back to what they were.
+    if ( !official) {
+        {
+            DocumentUndo::ScopedInsensitive _no_undo(doc);
+            store_file_extension_in_prefs (saved_output_extension, save_method);
+            repr->setAttribute("inkscape:dataloss", saved_dataloss);
+        }
+        doc->setModifiedSinceSave(saved_modified);
+
+        g_free(saved_output_extension);
+        g_free(saved_dataloss);
+    }
+
+    g_free(fileName);
+    return;
+}
+
+/**
+ * \return   none
+ * \brief    This is the function that searches each module to see
+ *           if it matches the filename for autodetection.
+ * \param    in_plug  The module to be tested
+ * \param    in_data  An array of pointers containing the filename, and
+ *                    the place to put a successfully found module.
+ *
+ * Basically this function only looks at output modules as it is part of the open function.  If the
+ * module is an output module, it then starts to take it apart, and the data that is passed in.
+ * Because the data being passed in is in such a weird format, there are a few casts to make it
+ * easier to use.  While it looks like a lot of local variables, they'll all get removed by the
+ * compiler.
+ *
+ * First thing that is checked is if the filename is shorter than the extension itself.  There is
+ * no way for a match in that case.  If it's long enough then there is a string compare of the end
+ * of the filename (for the length of the extension), and the extension itself.  If this passes
+ * then the pointer passed in is set to the current module.
+ */
+static void
+save_internal(Extension *in_plug, gpointer in_data)
+{
+    auto omod = dynamic_cast<Output *>(in_plug);
+    if (omod && !omod->deactivated()) {
+        gpointer *parray = (gpointer *)in_data;
+        gchar const *filename = (gchar const *)parray[0];
+        Output **pomod = (Output **)parray[1];
+
+        // skip all the rest if we already found someone to save it
+        // since they're ordered by preference now.
+        if (!*pomod) {
+            gchar const *ext = omod->get_extension();
+
+            gchar *filenamelower = g_utf8_strdown(filename, -1);
+            gchar *extensionlower = g_utf8_strdown(ext, -1);
+
+            if (g_str_has_suffix(filenamelower, extensionlower)) {
+                *pomod = omod;
+            }
+
+            g_free(filenamelower);
+            g_free(extensionlower);
+        }
+    }
+
+    return;
+}
+
+Print *
+get_print(gchar const *key)
+{
+    return dynamic_cast<Print *>(db.get(key));
+}
+
+/**
+ * \return   true if extension successfully parsed, false otherwise
+ *           A true return value does not guarantee an extension was actually registered,
+ *           but indicates no errors occurred while parsing the extension.
+ * \brief    Creates a module from a Inkscape::XML::Document describing the module
+ * \param    doc  The XML description of the module
+ *
+ * This function basically has two segments.  The first is that it goes through the Repr tree
+ * provided, and determines what kind of module this is, and what kind of implementation to use.
+ * All of these are then stored in two enums that are defined in this function.  This makes it
+ * easier to add additional types (which will happen in the future, I'm sure).
+ *
+ * Second, there is case statements for these enums.  The first one is the type of module.  This is
+ * the one where the module is actually created.  After that, then the implementation is applied to
+ * get the load and unload functions.  If there is no implementation then these are not set.  This
+ * case could apply to modules that are built in (like the SVG load/save functions).
+ */
+bool
+build_from_reprdoc(Inkscape::XML::Document *doc, Implementation::Implementation *in_imp, std::string* baseDir)
+{
+    ModuleImpType module_implementation_type = MODULE_UNKNOWN_IMP;
+    ModuleFuncType module_functional_type = MODULE_UNKNOWN_FUNC;
+
+    g_return_val_if_fail(doc != nullptr, false);
+
+    Inkscape::XML::Node *repr = doc->root();
+
+    if (strcmp(repr->name(), INKSCAPE_EXTENSION_NS "inkscape-extension")) {
+        g_warning("Extension definition started with <%s> instead of <" INKSCAPE_EXTENSION_NS "inkscape-extension>.  Extension will not be created. See http://wiki.inkscape.org/wiki/index.php/Extensions for reference.\n", repr->name());
+        return false;
+    }
+
+    Inkscape::XML::Node *child_repr = repr->firstChild();
+    while (child_repr != nullptr) {
+        char const *element_name = child_repr->name();
+        /* printf("Child: %s\n", child_repr->name()); */
+        if (!strcmp(element_name, INKSCAPE_EXTENSION_NS "input")) {
+            module_functional_type = MODULE_INPUT;
+        } else if (!strcmp(element_name, INKSCAPE_EXTENSION_NS "output")) {
+            module_functional_type = MODULE_OUTPUT;
+        } else if (!strcmp(element_name, INKSCAPE_EXTENSION_NS "effect")) {
+            module_functional_type = MODULE_FILTER;
+        } else if (!strcmp(element_name, INKSCAPE_EXTENSION_NS "print")) {
+            module_functional_type = MODULE_PRINT;
+        } else if (!strcmp(element_name, INKSCAPE_EXTENSION_NS "path-effect")) {
+            module_functional_type = MODULE_PATH_EFFECT;
+        } else if (!strcmp(element_name, INKSCAPE_EXTENSION_NS "script")) {
+            module_implementation_type = MODULE_EXTENSION;
+        } else if (!strcmp(element_name, INKSCAPE_EXTENSION_NS "xslt")) {
+            module_implementation_type = MODULE_XSLT;
+        } else if (!strcmp(element_name,  INKSCAPE_EXTENSION_NS "plugin")) {
+            module_implementation_type = MODULE_PLUGIN;
+        }
+
+        //Inkscape::XML::Node *old_repr = child_repr;
+        child_repr = child_repr->next();
+        //Inkscape::GC::release(old_repr);
+    }
+
+    Implementation::Implementation *imp;
+    if (in_imp == nullptr) {
+        switch (module_implementation_type) {
+            case MODULE_EXTENSION: {
+                Implementation::Script *script = new Implementation::Script();
+                imp = static_cast<Implementation::Implementation *>(script);
+                break;
+            }
+            case MODULE_XSLT: {
+                Implementation::XSLT *xslt = new Implementation::XSLT();
+                imp = static_cast<Implementation::Implementation *>(xslt);
+                break;
+            }
+            case MODULE_PLUGIN: {
+                Inkscape::Extension::Loader loader = Inkscape::Extension::Loader();
+                if( baseDir != nullptr){
+                    loader.set_base_directory ( *baseDir );
+                }
+                imp = loader.load_implementation(doc);
+                break;
+            }
+            default: {
+                imp = nullptr;
+                break;
+            }
+        }
+    } else {
+        imp = in_imp;
+    }
+
+    Extension *module = nullptr;
+    try {
+        switch (module_functional_type) {
+            case MODULE_INPUT: {
+                module = new Input(repr, imp, baseDir);
+                break;
+            }
+            case MODULE_OUTPUT: {
+                module = new Output(repr, imp, baseDir);
+                break;
+            }
+            case MODULE_FILTER: {
+                module = new Effect(repr, imp, baseDir);
+                break;
+            }
+            case MODULE_PRINT: {
+                module = new Print(repr, imp, baseDir);
+                break;
+            }
+            case MODULE_PATH_EFFECT: {
+                module = new PathEffect(repr, imp, baseDir);
+                break;
+            }
+            default: {
+                g_warning("Extension of unknown type!"); // TODO: Should not happen! Is this even useful?
+                module = new Extension(repr, imp, baseDir);
+                break;
+            }
+        }
+    } catch (const Extension::extension_no_id& e) {
+        g_warning("Building extension failed. Extension does not have a valid ID");
+    } catch (const Extension::extension_no_name& e) {
+        g_warning("Building extension failed. Extension does not have a valid name");
+    } catch (const Extension::extension_not_compatible& e) {
+        return true; // This is not an actual error; just silently ignore the extension
+    }
+
+    if (module) {
+        return true;
+    }
+
+    return false;
+}
+
+/**
+ * \brief    This function creates a module from a filename of an
+ *           XML description.
+ * \param    filename  The file holding the XML description of the module.
+ *
+ * This function calls build_from_reprdoc with using sp_repr_read_file to create the reprdoc.
+ */
+void
+build_from_file(gchar const *filename)
+{
+    std::string dir = Glib::path_get_dirname(filename);
+
+    Inkscape::XML::Document *doc = sp_repr_read_file(filename, INKSCAPE_EXTENSION_URI);
+    if (!doc) {
+        g_critical("Inkscape::Extension::build_from_file() - XML description loaded from '%s' not valid.", filename);
+        return;
+    }
+
+    if (!build_from_reprdoc(doc, nullptr, &dir)) {
+        g_warning("Inkscape::Extension::build_from_file() - Could not parse extension from '%s'.", filename);
+    }
+
+    Inkscape::GC::release(doc);
+}
+
+/**
+ * \brief    This function creates a module from a buffer holding an
+ *           XML description.
+ * \param    buffer  The buffer holding the XML description of the module.
+ *
+ * This function calls build_from_reprdoc with using sp_repr_read_mem to create the reprdoc.  It
+ * finds the length of the buffer using strlen.
+ */
+void
+build_from_mem(gchar const *buffer, Implementation::Implementation *in_imp)
+{
+    Inkscape::XML::Document *doc = sp_repr_read_mem(buffer, strlen(buffer), INKSCAPE_EXTENSION_URI);
+    if (!doc) {
+        g_critical("Inkscape::Extension::build_from_mem() - XML description loaded from memory buffer not valid.");
+        return;
+    }
+
+    if (!build_from_reprdoc(doc, in_imp, nullptr)) {
+        g_critical("Inkscape::Extension::build_from_mem() - Could not parse extension from memory buffer.");
+    }
+
+    Inkscape::GC::release(doc);
+}
+
+/*
+ * TODO: Is it guaranteed that the returned extension is valid? If so, we can remove the check for
+ * filename_extension in sp_file_save_dialog().
+ */
+Glib::ustring
+get_file_save_extension (Inkscape::Extension::FileSaveMethod method) {
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    Glib::ustring extension;
+    switch (method) {
+        case FILE_SAVE_METHOD_SAVE_AS:
+        case FILE_SAVE_METHOD_TEMPORARY:
+            extension = prefs->getString("/dialogs/save_as/default");
+            break;
+        case FILE_SAVE_METHOD_SAVE_COPY:
+            extension = prefs->getString("/dialogs/save_copy/default");
+            break;
+        case FILE_SAVE_METHOD_INKSCAPE_SVG:
+            extension = SP_MODULE_KEY_OUTPUT_SVG_INKSCAPE;
+            break;
+        case FILE_SAVE_METHOD_EXPORT:
+            /// \todo no default extension set for Export? defaults to SP_MODULE_KEY_OUTPUT_SVG_INKSCAPE is ok?
+            break;
+    }
+
+    if(extension.empty()) {
+        extension = SP_MODULE_KEY_OUTPUT_SVG_INKSCAPE;
+    }
+
+    return extension;
+}
+
+Glib::ustring
+get_file_save_path (SPDocument *doc, FileSaveMethod method) {
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    Glib::ustring path;
+    bool use_current_dir = true;
+    switch (method) {
+        case FILE_SAVE_METHOD_SAVE_AS:
+        {
+            use_current_dir = prefs->getBool("/dialogs/save_as/use_current_dir", true);
+            if (doc->getDocumentFilename() && use_current_dir) {
+                path = Glib::path_get_dirname(doc->getDocumentFilename());
+            } else {
+                path = prefs->getString("/dialogs/save_as/path");
+            }
+            break;
+        }
+        case FILE_SAVE_METHOD_TEMPORARY:
+            path = prefs->getString("/dialogs/save_as/path");
+            break;
+        case FILE_SAVE_METHOD_SAVE_COPY:
+            use_current_dir = prefs->getBool("/dialogs/save_copy/use_current_dir", prefs->getBool("/dialogs/save_as/use_current_dir", true));
+            if (doc->getDocumentFilename() && use_current_dir) {
+                path = Glib::path_get_dirname(doc->getDocumentFilename());
+            } else {
+                path = prefs->getString("/dialogs/save_copy/path");
+            }
+            break;
+        case FILE_SAVE_METHOD_INKSCAPE_SVG:
+            if (doc->getDocumentFilename()) {
+                path = Glib::path_get_dirname(doc->getDocumentFilename());
+            } else {
+                // FIXME: should we use the save_as path here or something else? Maybe we should
+                // leave this as a choice to the user.
+                path = prefs->getString("/dialogs/save_as/path");
+            }
+            break;
+        case FILE_SAVE_METHOD_EXPORT:
+            /// \todo no default path set for Export?
+            // defaults to g_get_home_dir()
+            break;
+    }
+
+    if(path.empty()) {
+        path = g_get_home_dir(); // Is this the most sensible solution? Note that we should avoid
+                                 // g_get_current_dir because this leads to problems on OS X where
+                                 // Inkscape opens the dialog inside application bundle when it is
+                                 // invoked for the first teim.
+    }
+
+    return path;
+}
+
+void
+store_file_extension_in_prefs (Glib::ustring extension, FileSaveMethod method) {
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    switch (method) {
+        case FILE_SAVE_METHOD_SAVE_AS:
+        case FILE_SAVE_METHOD_TEMPORARY:
+            prefs->setString("/dialogs/save_as/default", extension);
+            break;
+        case FILE_SAVE_METHOD_SAVE_COPY:
+            prefs->setString("/dialogs/save_copy/default", extension);
+            break;
+        case FILE_SAVE_METHOD_INKSCAPE_SVG:
+        case FILE_SAVE_METHOD_EXPORT:
+            // do nothing
+            break;
+    }
+}
+
+void
+store_save_path_in_prefs (Glib::ustring path, FileSaveMethod method) {
+    Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+    switch (method) {
+        case FILE_SAVE_METHOD_SAVE_AS:
+        case FILE_SAVE_METHOD_TEMPORARY:
+            prefs->setString("/dialogs/save_as/path", path);
+            break;
+        case FILE_SAVE_METHOD_SAVE_COPY:
+            prefs->setString("/dialogs/save_copy/path", path);
+            break;
+        case FILE_SAVE_METHOD_INKSCAPE_SVG:
+        case FILE_SAVE_METHOD_EXPORT:
+            // do nothing
+            break;
+    }
+}
+
+} } /* namespace Inkscape::Extension */
+
+/*
+  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 :