X-Git-Url: https://git.tokkee.org/?a=blobdiff_plain;f=src%2Ffile.cpp;h=03fb7bd5937f1bcd1ef7202a7e4165b2dce460ed;hb=48ca4bc36d8d8fa0536dc5f3eb619ae0c369c9d7;hp=4d96899da117579869922e3d0ff55e1db3d2d1d7;hpb=6129af7cc5b723223e9617614c931936e5190421;p=inkscape.git diff --git a/src/file.cpp b/src/file.cpp index 4d96899da..03fb7bd59 100644 --- a/src/file.cpp +++ b/src/file.cpp @@ -1,22 +1,23 @@ -#define __SP_FILE_C__ - -/* - * File/Print operations - * - * Authors: +/** @file + * @brief File/Print operations + */ +/* Authors: * Lauris Kaplinski * Chema Celorio * bulia byak + * Bruno Dilly + * Stephen Silver * - * Copyright (C) 1999-2005 Authors - * Copyright (C) 2001-2002 Ximian, Inc. + * Copyright (C) 2006 Johan Engelen + * Copyright (C) 1999-2008 Authors * Copyright (C) 2004 David Turner + * Copyright (C) 2001-2002 Ximian, Inc. * * Released under GNU GPL, read the file 'COPYING' for more information */ -/** - * Note: This file needs to be cleaned up extensively. +/** @file + * @note This file needs to be cleaned up extensively. * What it probably needs is to have one .h file for * the API, and two or more .cpp files for the implementations. */ @@ -25,53 +26,55 @@ # include "config.h" #endif +#include +#include +#include #include -#include "document-private.h" -#include "selection-chemistry.h" -#include "ui/view/view-widget.h" -#include "dir-util.h" -#include "helper/png-write.h" -#include "dialogs/export.h" -#include -#include "inkscape.h" +#include "application/application.h" +#include "application/editor.h" #include "desktop.h" -#include "selection.h" -#include "interface.h" -#include "style.h" -#include "print.h" -#include "file.h" -#include "message-stack.h" -#include "dialogs/filedialog.h" -#include "prefs-utils.h" -#include "path-prefix.h" - -#include "sp-namedview.h" #include "desktop-handles.h" - +#include "dialogs/export.h" +#include "dir-util.h" +#include "document-private.h" #include "extension/db.h" #include "extension/input.h" #include "extension/output.h" -/* #include "extension/menu.h" */ #include "extension/system.h" - -#include "io/sys.h" -#include "application/application.h" -#include "application/editor.h" +#include "file.h" +#include "helper/png-write.h" +#include "id-clash.h" #include "inkscape.h" +#include "inkscape.h" +#include "interface.h" +#include "io/sys.h" +#include "message.h" +#include "message-stack.h" +#include "path-prefix.h" +#include "preferences.h" +#include "print.h" +#include "rdf.h" +#include "selection-chemistry.h" +#include "selection.h" +#include "sp-namedview.h" +#include "style.h" +#include "ui/dialog/ocaldialogs.h" +#include "ui/view/view-widget.h" #include "uri.h" +#include "xml/rebase-hrefs.h" + +#ifdef WITH_GNOME_VFS +# include +#endif #ifdef WITH_INKBOARD #include "jabber_whiteboard/session-manager.h" #endif -/** - * 'Current' paths. Used to remember which directory - * had the last file accessed. - * Static globals are evil. This will be gone soon - * as C++ification continues - */ -static gchar *import_path = NULL; +#ifdef WIN32 +#include +#endif //#define INK_DUMP_FILENAME_CONV 1 #undef INK_DUMP_FILENAME_CONV @@ -82,6 +85,25 @@ static gchar *import_path = NULL; void dump_str(gchar const *str, gchar const *prefix); void dump_ustr(Glib::ustring const &ustr); +// what gets passed here is not actually an URI... it is an UTF-8 encoded filename (!) +static void sp_file_add_recent(gchar const *uri) +{ + if(uri == NULL) { + g_warning("sp_file_add_recent: uri == NULL"); + return; + } + GtkRecentManager *recent = gtk_recent_manager_get_default(); + gchar *fn = g_filename_from_utf8(uri, -1, NULL, NULL, NULL); + if (fn) { + gchar *uri_to_add = g_filename_to_uri(fn, NULL, NULL); + if (uri_to_add) { + gtk_recent_manager_add_item(recent, uri_to_add); + g_free(uri_to_add); + } + g_free(fn); + } +} + /*###################### ## N E W @@ -91,9 +113,12 @@ void dump_ustr(Glib::ustring const &ustr); * Create a blank document and add it to the desktop */ SPDesktop* -sp_file_new(gchar const *templ) +sp_file_new(const Glib::ustring &templ) { - SPDocument *doc = sp_document_new(templ, TRUE, true); + char *templName = NULL; + if (templ.size()>0) + templName = (char *)templ.c_str(); + SPDocument *doc = sp_document_new(templName, TRUE, true); g_return_val_if_fail(doc != NULL, NULL); SPDesktop *dt; @@ -108,6 +133,7 @@ sp_file_new(gchar const *templ) sp_create_window(dtw, TRUE); dt = static_cast(dtw->view); sp_namedview_window_from_document(dt); + sp_namedview_update_layers_from_document(dt); } return dt; } @@ -136,7 +162,7 @@ sp_file_new_default() sources.pop_front(); } - return sp_file_new(NULL); + return sp_file_new(""); } @@ -166,19 +192,27 @@ sp_file_exit() * will replace the empty one. */ bool -sp_file_open(gchar const *uri, Inkscape::Extension::Extension *key, bool add_to_recent, bool replace_empty) +sp_file_open(const Glib::ustring &uri, + Inkscape::Extension::Extension *key, + bool add_to_recent, bool replace_empty) { - SPDocument *doc; + SPDesktop *desktop = SP_ACTIVE_DESKTOP; + if (desktop) + desktop->setWaitingCursor(); + + SPDocument *doc = NULL; try { - doc = Inkscape::Extension::open(key, uri); + doc = Inkscape::Extension::open(key, uri.c_str()); } catch (Inkscape::Extension::Input::no_extension_found &e) { doc = NULL; } catch (Inkscape::Extension::Input::open_failed &e) { doc = NULL; } + if (desktop) + desktop->clearWaitingCursor(); + if (doc) { - SPDesktop *desktop = SP_ACTIVE_DESKTOP; SPDocument *existing = desktop ? sp_desktop_document(desktop) : NULL; if (existing && existing->virgin && replace_empty) { @@ -201,20 +235,16 @@ sp_file_open(gchar const *uri, Inkscape::Extension::Extension *key, bool add_to_ // everyone who cares now has a reference, get rid of ours sp_document_unref(doc); // resize the window to match the document properties - // (this may be redundant for new windows... if so, move to the "virgin" - // section above) -#ifdef WITH_INKBOARD - desktop->whiteboard_session_manager()->setDesktop(desktop); -#endif sp_namedview_window_from_document(desktop); + sp_namedview_update_layers_from_document(desktop); if (add_to_recent) { - prefs_set_recent_file(SP_DOCUMENT_URI(doc), SP_DOCUMENT_NAME(doc)); + sp_file_add_recent(SP_DOCUMENT_URI(doc)); } return TRUE; } else { - gchar *safeUri = Inkscape::IO::sanitizeString(uri); + gchar *safeUri = Inkscape::IO::sanitizeString(uri.c_str()); gchar *text = g_strdup_printf(_("Failed to load the requested file %s"), safeUri); sp_ui_error_dialog(text); g_free(text); @@ -245,7 +275,7 @@ sp_file_revert_dialog() } bool do_revert = true; - if (repr->attribute("sodipodi:modified") != NULL) { + if (doc->isModifiedSinceSave()) { gchar *text = g_strdup_printf(_("Changes will be lost! Are you sure you want to reload document %s?"), uri); bool response = desktop->warnDialog (text); @@ -260,7 +290,16 @@ sp_file_revert_dialog() if (do_revert) { // Allow overwriting of current document. doc->virgin = TRUE; + + // remember current zoom and view + double zoom = desktop->current_zoom(); + Geom::Point c = desktop->get_display_area().midpoint(); + reverted = sp_file_open(uri,NULL); + if (reverted) { + // restore zoom and view + desktop->zoom_absolute(c[Geom::X], c[Geom::Y], zoom); + } } else { reverted = false; } @@ -285,7 +324,7 @@ void dump_str(gchar const *str, gchar const *prefix) } tmp += "]"; - g_message(tmp.c_str()); + g_message("%s", tmp.c_str()); } void dump_ustr(Glib::ustring const &ustr) @@ -346,7 +385,7 @@ void dump_ustr(Glib::ustring const &ustr) tmp += " "; } - g_message( tmp.c_str() ); + g_message( "%s", tmp.c_str() ); } } catch (...) { g_message("XXXXXXXXXXXXXXXXXX Exception" ); @@ -354,143 +393,134 @@ void dump_ustr(Glib::ustring const &ustr) g_message("---------------"); } -static Inkscape::UI::Dialogs::FileOpenDialog *openDialogInstance = NULL; - /** * Display an file Open selector. Open a document if OK is pressed. * Can select single or multiple files for opening. */ void -sp_file_open_dialog(gpointer object, gpointer data) +sp_file_open_dialog(Gtk::Window &parentWindow, gpointer /*object*/, gpointer /*data*/) { - gchar *open_path2 = NULL; + //# Get the current directory for finding files + static Glib::ustring open_path; + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - gchar *open_path = g_strdup(prefs_get_string_attribute("dialogs.open", "path")); - if (open_path != NULL && open_path[0] == '\0') { - g_free(open_path); - open_path = NULL; + if(open_path.empty()) + { + Glib::ustring attr = prefs->getString("/dialogs/open/path"); + if (!attr.empty()) open_path = attr; } - if (open_path && !Inkscape::IO::file_test(open_path, (GFileTest)(G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR))) { - g_free(open_path); - open_path = NULL; + + //# Test if the open_path directory exists + if (!Inkscape::IO::file_test(open_path.c_str(), + (GFileTest)(G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR))) + open_path = ""; + +#ifdef WIN32 + //# If no open path, default to our win32 documents folder + if (open_path.empty()) + { + // The path to the My Documents folder is read from the + // value "HKEY_CURRENT_USER\Software\Windows\CurrentVersion\Explorer\Shell Folders\Personal" + HKEY key = NULL; + if(RegOpenKeyExA(HKEY_CURRENT_USER, + "Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Shell Folders", + 0, KEY_QUERY_VALUE, &key) == ERROR_SUCCESS) + { + WCHAR utf16path[_MAX_PATH]; + DWORD value_type; + DWORD data_size = sizeof(utf16path); + if(RegQueryValueExW(key, L"Personal", NULL, &value_type, + (BYTE*)utf16path, &data_size) == ERROR_SUCCESS) + { + g_assert(value_type == REG_SZ); + gchar *utf8path = g_utf16_to_utf8( + (const gunichar2*)utf16path, -1, NULL, NULL, NULL); + if(utf8path) + { + open_path = Glib::ustring(utf8path); + g_free(utf8path); + } + } + } } - if (open_path == NULL) - open_path = g_strconcat(g_get_home_dir(), G_DIR_SEPARATOR_S, NULL); - - if (!openDialogInstance) { - openDialogInstance = - Inkscape::UI::Dialogs::FileOpenDialog::create( - (char const *)open_path, - Inkscape::UI::Dialogs::SVG_TYPES, - (char const *)_("Select file to open")); +#endif + + //# If no open path, default to our home directory + if (open_path.empty()) + { + open_path = g_get_home_dir(); + open_path.append(G_DIR_SEPARATOR_S); } - bool const success = openDialogInstance->show(); - gchar *fileName = ( success - ? g_strdup(openDialogInstance->getFilename()) - : NULL ); - Inkscape::Extension::Extension *selection = - openDialogInstance->getSelectionType(); - g_free(open_path); - if (!success) return; + //# Create a dialog + Inkscape::UI::Dialog::FileOpenDialog *openDialogInstance = + Inkscape::UI::Dialog::FileOpenDialog::create( + parentWindow, open_path, + Inkscape::UI::Dialog::SVG_TYPES, + _("Select file to open")); - // Code to check & open iff multiple files. - Glib::SListHandle flist=openDialogInstance->getFilenames(); - GSList *list=flist.data(); + //# Show the dialog + bool const success = openDialogInstance->show(); - if(g_slist_length(list)>1) + //# Save the folder the user selected for later + open_path = openDialogInstance->getCurrentDirectory(); + + if (!success) { - gchar *fileName=NULL; + delete openDialogInstance; + return; + } - while(list!=NULL) - { + //# User selected something. Get name and type + Glib::ustring fileName = openDialogInstance->getFilename(); -#ifdef INK_DUMP_FILENAME_CONV - g_message(" FileName: %s",(const char *)list->data); -#endif + Inkscape::Extension::Extension *selection = + openDialogInstance->getSelectionType(); - fileName=(gchar *)g_strdup((gchar *)list->data); + //# Code to check & open if multiple files. + std::vector flist = openDialogInstance->getFilenames(); - if (fileName && !g_file_test(fileName,G_FILE_TEST_IS_DIR)) { - gsize bytesRead = 0; - gsize bytesWritten = 0; - GError *error = NULL; -#ifdef INK_DUMP_FILENAME_CONV - dump_str( fileName, "A file pre is " ); -#endif - gchar *newFileName = g_filename_to_utf8(fileName, - -1, - &bytesRead, - &bytesWritten, - &error); - if ( newFileName != NULL ) { - g_free(fileName); - fileName = newFileName; -#ifdef INK_DUMP_FILENAME_CONV - dump_str( fileName, "A file post is " ); -#endif - } else { - // TODO: bulia, please look over - g_warning( "ERROR CONVERTING OPEN FILENAME TO UTF-8" ); - } + //# We no longer need the file dialog object - delete it + delete openDialogInstance; + openDialogInstance = NULL; -#ifdef INK_DUMP_FILENAME_CONV - g_message("Opening File %s\n",fileName); -#endif + //# Iterate through filenames if more than 1 + if (flist.size() > 1) + { + for (unsigned int i = 0; i < flist.size(); i++) + { + fileName = flist[i]; - sp_file_open(fileName, selection); - g_free(fileName); - } + Glib::ustring newFileName = Glib::filename_to_utf8(fileName); + if ( newFileName.size() > 0 ) + fileName = newFileName; else - { - g_message("Cannot Open Directory %s\n",fileName); - } + g_warning( "ERROR CONVERTING OPEN FILENAME TO UTF-8" ); - list=list->next; +#ifdef INK_DUMP_FILENAME_CONV + g_message("Opening File %s\n", fileName.c_str()); +#endif + sp_file_open(fileName, selection); } return; } - if (fileName) { - gsize bytesRead = 0; - gsize bytesWritten = 0; - GError *error = NULL; -#ifdef INK_DUMP_FILENAME_CONV - dump_str( fileName, "A file pre is " ); -#endif - gchar *newFileName = g_filename_to_utf8(fileName, - -1, - &bytesRead, - &bytesWritten, - &error); - if ( newFileName != NULL ) { - g_free(fileName); + if (!fileName.empty()) + { + Glib::ustring newFileName = Glib::filename_to_utf8(fileName); + + if ( newFileName.size() > 0) fileName = newFileName; -#ifdef INK_DUMP_FILENAME_CONV - dump_str( fileName, "A file post is " ); -#endif - } else { - // TODO: bulia, please look over + else g_warning( "ERROR CONVERTING OPEN FILENAME TO UTF-8" ); - } - - - if ( !g_utf8_validate(fileName, -1, NULL) ) { - // TODO: bulia, please look over - g_warning( "INPUT FILENAME IS NOT UTF-8" ); - } - - open_path = g_dirname(fileName); - open_path2 = g_strconcat(open_path, G_DIR_SEPARATOR_S, NULL); - prefs_set_string_attribute("dialogs.open", "path", open_path2); - g_free(open_path); - g_free(open_path2); + open_path = Glib::path_get_dirname (fileName); + open_path.append(G_DIR_SEPARATOR_S); + prefs->setString("/dialogs/open/path", open_path); sp_file_open(fileName, selection); - g_free(fileName); } return; @@ -513,7 +543,8 @@ sp_file_vacuum() unsigned int diff = vacuum_document (doc); - sp_document_done(doc); + sp_document_done(doc, SP_VERB_FILE_VACUUM, + _("Vacuum <defs>")); SPDesktop *dt = SP_ACTIVE_DESKTOP; if (diff > 0) { @@ -535,19 +566,25 @@ sp_file_vacuum() /** * This 'save' function called by the others below + * + * \param official whether to set :output_module and :modified in the + * document; is true for normal save, false for temporary saves */ static bool -file_save(SPDocument *doc, gchar const *uri, Inkscape::Extension::Extension *key, bool saveas) +file_save(Gtk::Window &parentWindow, SPDocument *doc, const Glib::ustring &uri, + Inkscape::Extension::Extension *key, bool checkoverwrite, bool official, + Inkscape::Extension::FileSaveMethod save_method) { - if (!doc || !uri) //Safety check - return FALSE; + if (!doc || uri.size()<1) //Safety check + return false; try { - Inkscape::Extension::save(key, doc, uri, - saveas && prefs_get_int_attribute("dialogs.save_as", "append_extension", 1), - saveas, TRUE); // save officially, with inkscape: attributes set + Inkscape::Extension::save(key, doc, uri.c_str(), + false, + checkoverwrite, official, + save_method); } catch (Inkscape::Extension::Output::no_extension_found &e) { - gchar *safeUri = Inkscape::IO::sanitizeString(uri); + gchar *safeUri = Inkscape::IO::sanitizeString(uri.c_str()); gchar *text = g_strdup_printf(_("No Inkscape extension found to save document (%s). This may have been caused by an unknown filename extension."), safeUri); SP_ACTIVE_DESKTOP->messageStack()->flash(Inkscape::ERROR_MESSAGE, _("Document not saved.")); sp_ui_error_dialog(text); @@ -555,188 +592,269 @@ file_save(SPDocument *doc, gchar const *uri, Inkscape::Extension::Extension *key g_free(safeUri); return FALSE; } catch (Inkscape::Extension::Output::save_failed &e) { - gchar *safeUri = Inkscape::IO::sanitizeString(uri); + gchar *safeUri = Inkscape::IO::sanitizeString(uri.c_str()); gchar *text = g_strdup_printf(_("File %s could not be saved."), safeUri); SP_ACTIVE_DESKTOP->messageStack()->flash(Inkscape::ERROR_MESSAGE, _("Document not saved.")); sp_ui_error_dialog(text); g_free(text); g_free(safeUri); return FALSE; + } catch (Inkscape::Extension::Output::save_cancelled &e) { + SP_ACTIVE_DESKTOP->messageStack()->flash(Inkscape::ERROR_MESSAGE, _("Document not saved.")); + return FALSE; } catch (Inkscape::Extension::Output::no_overwrite &e) { - return sp_file_save_dialog(doc); + return sp_file_save_dialog(parentWindow, doc, Inkscape::Extension::FILE_SAVE_METHOD_SAVE_AS); } + SP_ACTIVE_DESKTOP->event_log->rememberFileSave(); SP_ACTIVE_DESKTOP->messageStack()->flash(Inkscape::NORMAL_MESSAGE, _("Document saved.")); - return TRUE; + return true; } -static Inkscape::UI::Dialogs::FileSaveDialog *saveDialogInstance = NULL; - -/** - * Display a SaveAs dialog. Save the document if OK pressed. +/* + * Used only for remote saving using VFS and a specific uri. Gets the file at the /tmp. */ -gboolean -sp_file_save_dialog(SPDocument *doc) +bool +file_save_remote(SPDocument */*doc*/, + #ifdef WITH_GNOME_VFS + const Glib::ustring &uri, + #else + const Glib::ustring &/*uri*/, + #endif + Inkscape::Extension::Extension */*key*/, bool /*saveas*/, bool /*official*/) { - Inkscape::XML::Node *repr = sp_document_repr_root(doc); - gchar const *default_extension = NULL; - gchar *save_loc; - Inkscape::Extension::Output *extension; - gchar *save_path = NULL; +#ifdef WITH_GNOME_VFS + +#define BUF_SIZE 8192 + gnome_vfs_init(); - default_extension = repr->attribute("inkscape:output_extension"); - if (default_extension == NULL) { - default_extension = prefs_get_string_attribute("dialogs.save_as", "default"); + GnomeVFSHandle *from_handle = NULL; + GnomeVFSHandle *to_handle = NULL; + GnomeVFSFileSize bytes_read; + GnomeVFSFileSize bytes_written; + GnomeVFSResult result; + guint8 buffer[8192]; + + gchar* uri_local = g_filename_from_utf8( uri.c_str(), -1, NULL, NULL, NULL); + + if ( uri_local == NULL ) { + g_warning( "Error converting filename to locale encoding."); } - //g_warning("%s: extension name: '%s'", __FUNCTION__, default_extension); - if (doc->uri == NULL) { - int i = 1; - char const *filename_extension; - char *temp_filename; + // Gets the temp file name. + Glib::ustring fileName = Glib::get_tmp_dir (); + fileName.append(G_DIR_SEPARATOR_S); + fileName.append((gnome_vfs_uri_extract_short_name(gnome_vfs_uri_new(uri_local)))); - extension = dynamic_cast(Inkscape::Extension::db.get(default_extension)); - //g_warning("%s: extension ptr: 0x%x", __FUNCTION__, (unsigned int)extension); - if (extension == NULL) { - filename_extension = ".svg"; - } else { - filename_extension = extension->get_extension(); + // Open the temp file to send. + result = gnome_vfs_open (&from_handle, fileName.c_str(), GNOME_VFS_OPEN_READ); + + if (result != GNOME_VFS_OK) { + g_warning("Could not find the temp saving."); + return false; + } + + result = gnome_vfs_create (&to_handle, uri_local, GNOME_VFS_OPEN_WRITE, FALSE, GNOME_VFS_PERM_USER_ALL); + result = gnome_vfs_open (&to_handle, uri_local, GNOME_VFS_OPEN_WRITE); + + if (result != GNOME_VFS_OK) { + g_warning("file creating: %s", gnome_vfs_result_to_string(result)); + return false; + } + + while (1) { + + result = gnome_vfs_read (from_handle, buffer, 8192, &bytes_read); + + if ((result == GNOME_VFS_ERROR_EOF) &&(!bytes_read)){ + result = gnome_vfs_close (from_handle); + result = gnome_vfs_close (to_handle); + return true; } - save_path = g_strdup(prefs_get_string_attribute("dialogs.save_as", "path")); - if (save_path != NULL && save_path[0] == '\0') { - g_free(save_path); - save_path = NULL; + if (result != GNOME_VFS_OK) { + g_warning("%s", gnome_vfs_result_to_string(result)); + return false; } - if (save_path && !Inkscape::IO::file_test(save_path, (GFileTest)(G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR))) { - g_free(save_path); - save_path = NULL; + result = gnome_vfs_write (to_handle, buffer, bytes_read, &bytes_written); + if (result != GNOME_VFS_OK) { + g_warning("%s", gnome_vfs_result_to_string(result)); + return false; } - if (save_path == NULL) - save_path = g_strdup(g_get_home_dir()); - temp_filename = g_strdup_printf(_("drawing%s"), filename_extension); - save_loc = g_build_filename(save_path, temp_filename, NULL); - g_free(temp_filename); - - while (Inkscape::IO::file_test(save_loc, G_FILE_TEST_EXISTS)) { - g_free(save_loc); - temp_filename = g_strdup_printf(_("drawing-%d%s"), i++, filename_extension); - save_loc = g_build_filename(save_path, temp_filename, NULL); - g_free(temp_filename); + + + if (bytes_read != bytes_written){ + return false; } - } else { - save_loc = g_path_get_dirname(doc->uri); /* \todo should use a getter */ - } - { // convert save_loc from utf-8 to locale - // is this needed any more, now that everything is handled in - // Inkscape::IO? - gsize bytesRead = 0; - gsize bytesWritten = 0; - GError* error = NULL; -#ifdef INK_DUMP_FILENAME_CONV - dump_str( save_loc, "B file pre is " ); + } + return true; +#else + // in case we do not have GNOME_VFS + return false; #endif - gchar* save_loc_local = g_filename_from_utf8( save_loc, -1, &bytesRead, &bytesWritten, &error); - if ( save_loc_local != NULL ) { - g_free(save_loc); - save_loc = save_loc_local; -#ifdef INK_DUMP_FILENAME_CONV - dump_str( save_loc, "B file post is " ); -#endif - } else { - //g_warning( "Error converting save filename stored in the file to locale encoding."); +} + + +/** + * Display a SaveAs dialog. Save the document if OK pressed. + */ +bool +sp_file_save_dialog(Gtk::Window &parentWindow, SPDocument *doc, Inkscape::Extension::FileSaveMethod save_method) +{ + Inkscape::Extension::Output *extension = 0; + bool is_copy = (save_method == Inkscape::Extension::FILE_SAVE_METHOD_SAVE_COPY); + + // Note: default_extension has the format "org.inkscape.output.svg.inkscape", whereas + // filename_extension only uses ".svg" + Glib::ustring default_extension; + Glib::ustring filename_extension = ".svg"; + + default_extension= Inkscape::Extension::get_file_save_extension(save_method); + //g_message("%s: extension name: '%s'", __FUNCTION__, default_extension); + + extension = dynamic_cast + (Inkscape::Extension::db.get(default_extension.c_str())); + + if (extension) + filename_extension = extension->get_extension(); + + Glib::ustring save_path; + Glib::ustring save_loc; + + save_path = Inkscape::Extension::get_file_save_path(doc, save_method); + + if (!Inkscape::IO::file_test(save_path.c_str(), + (GFileTest)(G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR))) + save_path = ""; + + if (save_path.size()<1) + save_path = g_get_home_dir(); + + save_loc = save_path; + save_loc.append(G_DIR_SEPARATOR_S); + + char formatBuf[256]; + int i = 1; + if (!doc->uri) { + // We are saving for the first time; create a unique default filename + snprintf(formatBuf, 255, _("drawing%s"), filename_extension.c_str()); + save_loc.append(formatBuf); + + while (Inkscape::IO::file_test(save_loc.c_str(), G_FILE_TEST_EXISTS)) { + save_loc = save_path; + save_loc.append(G_DIR_SEPARATOR_S); + snprintf(formatBuf, 255, _("drawing-%d%s"), i++, filename_extension.c_str()); + save_loc.append(formatBuf); } + } else { + snprintf(formatBuf, 255, _("%s"), Glib::path_get_basename(doc->uri).c_str()); + save_loc.append(formatBuf); } - if (!saveDialogInstance) { - saveDialogInstance = - Inkscape::UI::Dialogs::FileSaveDialog::create( - (char const *) save_loc, - Inkscape::UI::Dialogs::SVG_TYPES, - (char const *) _("Select file to save to"), - default_extension + // convert save_loc from utf-8 to locale + // is this needed any more, now that everything is handled in + // Inkscape::IO? + Glib::ustring save_loc_local = Glib::filename_from_utf8(save_loc); + + if ( save_loc_local.size() > 0) + save_loc = save_loc_local; + + //# Show the SaveAs dialog + char const * dialog_title; + if (is_copy) { + dialog_title = (char const *) _("Select file to save a copy to"); + } else { + dialog_title = (char const *) _("Select file to save to"); + } + gchar* doc_title = doc->root->title(); + Inkscape::UI::Dialog::FileSaveDialog *saveDialog = + Inkscape::UI::Dialog::FileSaveDialog::create( + parentWindow, + save_loc, + Inkscape::UI::Dialog::SVG_TYPES, + dialog_title, + default_extension, + doc_title ? doc_title : "", + save_method ); - } // FIXME: else (i.e. if reshowing an already shown dialog) save_loc is not used, it thus always displays the previously opened dir - bool success = saveDialogInstance->show(); - char *fileName = ( success - ? g_strdup(saveDialogInstance->getFilename()) - : NULL ); - Inkscape::Extension::Extension *selectionType = - saveDialogInstance->getSelectionType(); - g_free(save_loc); - g_free(save_path); + + saveDialog->setSelectionType(extension); + + bool success = saveDialog->show(); if (!success) { + delete saveDialog; return success; } - if (fileName && *fileName) { - gsize bytesRead = 0; - gsize bytesWritten = 0; - GError *error = NULL; -#ifdef INK_DUMP_FILENAME_CONV - dump_str( fileName, "C file pre is " ); -#endif - gchar *newFileName = g_filename_to_utf8(fileName, - -1, - &bytesRead, - &bytesWritten, - &error); - if ( newFileName != NULL ) { - g_free(fileName); + // set new title here (call RDF to ensure metadata and title element are updated) + rdf_set_work_entity(doc, rdf_find_entity("title"), saveDialog->getDocTitle().c_str()); + // free up old string + if(doc_title) g_free(doc_title); + + Glib::ustring fileName = saveDialog->getFilename(); + Inkscape::Extension::Extension *selectionType = saveDialog->getSelectionType(); + + delete saveDialog; + + saveDialog = 0; + + if (fileName.size() > 0) { + Glib::ustring newFileName = Glib::filename_to_utf8(fileName); + + if ( newFileName.size()>0 ) fileName = newFileName; -#ifdef INK_DUMP_FILENAME_CONV - dump_str( fileName, "C file post is " ); -#endif - } else { + else g_warning( "Error converting save filename to UTF-8." ); - } - if (!g_utf8_validate(fileName, -1, NULL)) { - // TODO: bulia, please look over - g_warning( "The filename is not UTF-8." ); - } - - success = file_save(doc, fileName, selectionType, TRUE); + // FIXME: does the argument !is_copy really convey the correct meaning here? + success = file_save(parentWindow, doc, fileName, selectionType, TRUE, !is_copy, save_method); - if (success) { - prefs_set_recent_file(SP_DOCUMENT_URI(doc), SP_DOCUMENT_NAME(doc)); + if (success && SP_DOCUMENT_URI(doc)) { + sp_file_add_recent(SP_DOCUMENT_URI(doc)); } - save_path = g_dirname(fileName); - prefs_set_string_attribute("dialogs.save_as", "path", save_path); - g_free(save_path); + save_path = Glib::path_get_dirname(fileName); + Inkscape::Extension::store_save_path_in_prefs(save_path, save_method); - g_free(fileName); return success; - } else { - return FALSE; } + + + return false; } /** * Save a document, displaying a SaveAs dialog if necessary. */ -gboolean -sp_file_save_document(SPDocument *doc) +bool +sp_file_save_document(Gtk::Window &parentWindow, SPDocument *doc) { - gboolean success = TRUE; - - Inkscape::XML::Node *repr = sp_document_repr_root(doc); + bool success = true; - gchar const *fn = repr->attribute("sodipodi:modified"); - if (fn != NULL) { - if (doc->uri == NULL - || repr->attribute("inkscape:output_extension") == NULL) + if (doc->isModifiedSinceSave()) { + if ( doc->uri == NULL ) { - return sp_file_save_dialog(doc); + // Hier sollte in Argument mitgegeben werden, das anzeigt, daß das Dokument das erste + // Mal gespeichert wird, so daß als default .svg ausgewählt wird und nicht die zuletzt + // benutzte "Save as ..."-Endung + return sp_file_save_dialog(parentWindow, doc, Inkscape::Extension::FILE_SAVE_METHOD_INKSCAPE_SVG); } else { - fn = g_strdup(doc->uri); - gchar const *ext = repr->attribute("inkscape:output_extension"); - success = file_save(doc, fn, Inkscape::Extension::db.get(ext), FALSE); - g_free((void *) fn); + Glib::ustring extension = Inkscape::Extension::get_file_save_extension(Inkscape::Extension::FILE_SAVE_METHOD_SAVE_AS); + Glib::ustring fn = g_strdup(doc->uri); + // Try to determine the extension from the uri; this may not lead to a valid extension, + // but this case is caught in the file_save method below (or rather in Extension::save() + // further down the line). + Glib::ustring ext = ""; + Glib::ustring::size_type pos = fn.rfind('.'); + if (pos != Glib::ustring::npos) { + // FIXME: this could/should be more sophisticated (see FileSaveDialog::appendExtension()), + // but hopefully it's a reasonable workaround for now + ext = fn.substr( pos ); + } + success = file_save(parentWindow, doc, fn, Inkscape::Extension::db.get(ext.c_str()), FALSE, TRUE, Inkscape::Extension::FILE_SAVE_METHOD_SAVE_AS); } } else { SP_ACTIVE_DESKTOP->messageStack()->flash(Inkscape::WARNING_MESSAGE, _("No changes need to be saved.")); @@ -751,12 +869,15 @@ sp_file_save_document(SPDocument *doc) * Save a document. */ bool -sp_file_save(gpointer object, gpointer data) +sp_file_save(Gtk::Window &parentWindow, gpointer /*object*/, gpointer /*data*/) { if (!SP_ACTIVE_DOCUMENT) return false; + + SP_ACTIVE_DESKTOP->messageStack()->flash(Inkscape::IMMEDIATE_MESSAGE, _("Saving document...")); + sp_namedview_document_from_window(SP_ACTIVE_DESKTOP); - return sp_file_save_document(SP_ACTIVE_DOCUMENT); + return sp_file_save_document(parentWindow, SP_ACTIVE_DOCUMENT); } @@ -764,16 +885,28 @@ sp_file_save(gpointer object, gpointer data) * Save a document, always displaying the SaveAs dialog. */ bool -sp_file_save_as(gpointer object, gpointer data) +sp_file_save_as(Gtk::Window &parentWindow, gpointer /*object*/, gpointer /*data*/) { if (!SP_ACTIVE_DOCUMENT) return false; sp_namedview_document_from_window(SP_ACTIVE_DESKTOP); - return sp_file_save_dialog(SP_ACTIVE_DOCUMENT); + return sp_file_save_dialog(parentWindow, SP_ACTIVE_DOCUMENT, Inkscape::Extension::FILE_SAVE_METHOD_SAVE_AS); } +/** + * Save a copy of a document, always displaying a sort of SaveAs dialog. + */ +bool +sp_file_save_a_copy(Gtk::Window &parentWindow, gpointer /*object*/, gpointer /*data*/) +{ + if (!SP_ACTIVE_DOCUMENT) + return false; + sp_namedview_document_from_window(SP_ACTIVE_DESKTOP); + return sp_file_save_dialog(parentWindow, SP_ACTIVE_DOCUMENT, Inkscape::Extension::FILE_SAVE_METHOD_SAVE_COPY); +} + /*###################### ## I M P O R T @@ -783,14 +916,15 @@ sp_file_save_as(gpointer object, gpointer data) * Import a resource. Called by sp_file_import() */ void -file_import(SPDocument *in_doc, gchar const *uri, Inkscape::Extension::Extension *key) +file_import(SPDocument *in_doc, const Glib::ustring &uri, + Inkscape::Extension::Extension *key) { SPDesktop *desktop = SP_ACTIVE_DESKTOP; //DEBUG_MESSAGE( fileImport, "file_import( in_doc:%p uri:[%s], key:%p", in_doc, uri, key ); SPDocument *doc; try { - doc = Inkscape::Extension::open(key, uri); + doc = Inkscape::Extension::open(key, uri.c_str()); } catch (Inkscape::Extension::Input::no_extension_found &e) { doc = NULL; } catch (Inkscape::Extension::Input::open_failed &e) { @@ -798,109 +932,111 @@ file_import(SPDocument *in_doc, gchar const *uri, Inkscape::Extension::Extension } if (doc != NULL) { - // the import extension has passed us a document, now we need to embed it into our document - if ( 0 ) { -// const gchar *docbase = (sp_repr_document_root( sp_repr_document( repr ))->attribute("sodipodi:docbase" ); - g_message(" settings uri [%s]", doc->uri ); - g_message(" base [%s]", doc->base ); - g_message(" name [%s]", doc->name ); - Inkscape::IO::fixupHrefs( doc, doc->base, TRUE ); - g_message(" mid-fixup"); - Inkscape::IO::fixupHrefs( doc, in_doc->base, TRUE ); - } + Inkscape::XML::rebase_hrefs(doc, in_doc->base, true); + Inkscape::XML::Document *xml_in_doc = sp_document_repr_doc(in_doc); + + prevent_id_clashes(doc, in_doc); - // move imported defs to our document's defs SPObject *in_defs = SP_DOCUMENT_DEFS(in_doc); - SPObject *defs = SP_DOCUMENT_DEFS(doc); Inkscape::XML::Node *last_def = SP_OBJECT_REPR(in_defs)->lastChild(); - for (SPObject *child = sp_object_first_child(defs); - child != NULL; child = SP_OBJECT_NEXT(child)) - { - // FIXME: in case of id conflict, newly added thing will be re-ided and thus likely break a reference to it from imported stuff - SP_OBJECT_REPR(in_defs)->addChild(SP_OBJECT_REPR(child)->duplicate(), last_def); - } + SPCSSAttr *style = sp_css_attr_from_object(SP_DOCUMENT_ROOT(doc)); + + // Count the number of top-level items in the imported document. guint items_count = 0; for (SPObject *child = sp_object_first_child(SP_DOCUMENT_ROOT(doc)); - child != NULL; child = SP_OBJECT_NEXT(child)) { - if (SP_IS_ITEM(child)) - items_count ++; + child != NULL; child = SP_OBJECT_NEXT(child)) + { + if (SP_IS_ITEM(child)) items_count++; } - SPCSSAttr *style = sp_css_attr_from_object (SP_DOCUMENT_ROOT (doc)); - - SPObject *new_obj = NULL; + // Create a new group if necessary. + Inkscape::XML::Node *newgroup = NULL; if ((style && style->firstChild()) || items_count > 1) { - // create group - Inkscape::XML::Node *newgroup = sp_repr_new("svg:g"); - sp_repr_css_set (newgroup, style, "style"); + newgroup = xml_in_doc->createElement("svg:g"); + sp_repr_css_set(newgroup, style, "style"); + } - for (SPObject *child = sp_object_first_child(SP_DOCUMENT_ROOT(doc)); child != NULL; child = SP_OBJECT_NEXT(child) ) { - if (SP_IS_ITEM(child)) { - Inkscape::XML::Node *newchild = SP_OBJECT_REPR(child)->duplicate(); + // Determine the place to insert the new object. + // This will be the current layer, if possible. + // FIXME: If there's no desktop (command line run?) we need + // a document:: method to return the current layer. + // For now, we just use the root in this case. + SPObject *place_to_insert; + if (desktop) { + place_to_insert = desktop->currentLayer(); + } else { + place_to_insert = SP_DOCUMENT_ROOT(in_doc); + } - // convert layers to groups; FIXME: add "preserve layers" mode where each layer - // from impot is copied to the same-named layer in host - newchild->setAttribute("inkscape:groupmode", NULL); + // Construct a new object representing the imported image, + // and insert it into the current document. + SPObject *new_obj = NULL; + for (SPObject *child = sp_object_first_child(SP_DOCUMENT_ROOT(doc)); + child != NULL; child = SP_OBJECT_NEXT(child) ) + { + if (SP_IS_ITEM(child)) { + Inkscape::XML::Node *newitem = SP_OBJECT_REPR(child)->duplicate(xml_in_doc); - newgroup->appendChild(newchild); - } - } + // convert layers to groups, and make sure they are unlocked + // FIXME: add "preserve layers" mode where each layer from + // import is copied to the same-named layer in host + newitem->setAttribute("inkscape:groupmode", NULL); + newitem->setAttribute("sodipodi:insensitive", NULL); - if (desktop) { - // Add it to the current layer - new_obj = desktop->currentLayer()->appendChildRepr(newgroup); - } else { - // There's no desktop (command line run?) - // FIXME: For such cases we need a document:: method to return the current layer - new_obj = SP_DOCUMENT_ROOT(in_doc)->appendChildRepr(newgroup); + if (newgroup) newgroup->appendChild(newitem); + else new_obj = place_to_insert->appendChildRepr(newitem); } - Inkscape::GC::release(newgroup); - } else { - // just add one item - for (SPObject *child = sp_object_first_child(SP_DOCUMENT_ROOT(doc)); child != NULL; child = SP_OBJECT_NEXT(child) ) { - if (SP_IS_ITEM(child)) { - Inkscape::XML::Node *newitem = SP_OBJECT_REPR(child)->duplicate(); - newitem->setAttribute("inkscape:groupmode", NULL); - - if (desktop) { - // Add it to the current layer - new_obj = desktop->currentLayer()->appendChildRepr(newitem); - } else { - // There's no desktop (command line run?) - // FIXME: For such cases we need a document:: method to return the current layer - new_obj = SP_DOCUMENT_ROOT(in_doc)->appendChildRepr(newitem); + // don't lose top-level defs or style elements + else if (SP_OBJECT_REPR(child)->type() == Inkscape::XML::ELEMENT_NODE) { + const gchar *tag = SP_OBJECT_REPR(child)->name(); + if (!strcmp(tag, "svg:defs")) { + for (SPObject *x = sp_object_first_child(child); + x != NULL; x = SP_OBJECT_NEXT(x)) + { + SP_OBJECT_REPR(in_defs)->addChild(SP_OBJECT_REPR(x)->duplicate(xml_in_doc), last_def); } - + } + else if (!strcmp(tag, "svg:style")) { + SP_DOCUMENT_ROOT(in_doc)->appendChildRepr(SP_OBJECT_REPR(child)->duplicate(xml_in_doc)); } } } + if (newgroup) new_obj = place_to_insert->appendChildRepr(newgroup); - if (style) sp_repr_css_attr_unref (style); + // release some stuff + if (newgroup) Inkscape::GC::release(newgroup); + if (style) sp_repr_css_attr_unref(style); // select and move the imported item if (new_obj && SP_IS_ITEM(new_obj)) { Inkscape::Selection *selection = sp_desktop_selection(desktop); selection->set(SP_ITEM(new_obj)); - // To move the imported object, we must temporarily set the "transform pattern with - // object" option. + // preserve parent and viewBox transformations + // c2p is identity matrix at this point unless sp_document_ensure_up_to_date is called + sp_document_ensure_up_to_date(doc); + Geom::Matrix affine = SP_ROOT(SP_DOCUMENT_ROOT(doc))->c2p * sp_item_i2doc_affine(SP_ITEM(place_to_insert)).inverse(); + sp_selection_apply_affine(selection, desktop->dt2doc() * affine * desktop->doc2dt(), true, false); + + // move to mouse pointer { - int const saved_pref = prefs_get_int_attribute("options.transform", "pattern", 1); - prefs_set_int_attribute("options.transform", "pattern", 1); sp_document_ensure_up_to_date(sp_desktop_document(desktop)); - NR::Point m( desktop->point() - selection->bounds().midpoint() ); - sp_selection_move_relative(selection, m); - prefs_set_int_attribute("options.transform", "pattern", saved_pref); + Geom::OptRect sel_bbox = selection->bounds(); + if (sel_bbox) { + Geom::Point m( desktop->point() - sel_bbox->midpoint() ); + sp_selection_move_relative(selection, m, false); + } } } sp_document_unref(doc); - sp_document_done(in_doc); + sp_document_done(in_doc, SP_VERB_FILE_IMPORT, + _("Import")); } else { - gchar *text = g_strdup_printf(_("Failed to load the requested file %s"), uri); + gchar *text = g_strdup_printf(_("Failed to load the requested file %s"), uri.c_str()); sp_ui_error_dialog(text); g_free(text); } @@ -909,68 +1045,73 @@ file_import(SPDocument *in_doc, gchar const *uri, Inkscape::Extension::Extension } -static Inkscape::UI::Dialogs::FileOpenDialog *importDialogInstance = NULL; - /** * Display an Open dialog, import a resource if OK pressed. */ void -sp_file_import(GtkWidget *widget) +sp_file_import(Gtk::Window &parentWindow) { + static Glib::ustring import_path; + SPDocument *doc = SP_ACTIVE_DOCUMENT; if (!doc) return; - if (!importDialogInstance) { - importDialogInstance = - Inkscape::UI::Dialogs::FileOpenDialog::create( - (char const *)import_path, - Inkscape::UI::Dialogs::IMPORT_TYPES, - (char const *)_("Select file to import")); + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + + if(import_path.empty()) + { + Glib::ustring attr = prefs->getString("/dialogs/import/path"); + if (!attr.empty()) import_path = attr; } + + //# Test if the import_path directory exists + if (!Inkscape::IO::file_test(import_path.c_str(), + (GFileTest)(G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR))) + import_path = ""; + + //# If no open path, default to our home directory + if (import_path.empty()) + { + import_path = g_get_home_dir(); + import_path.append(G_DIR_SEPARATOR_S); + } + + // Create new dialog (don't use an old one, because parentWindow has probably changed) + Inkscape::UI::Dialog::FileOpenDialog *importDialogInstance = + Inkscape::UI::Dialog::FileOpenDialog::create( + parentWindow, + import_path, + Inkscape::UI::Dialog::IMPORT_TYPES, + (char const *)_("Select file to import")); + bool success = importDialogInstance->show(); - char *fileName = ( success - ? g_strdup(importDialogInstance->getFilename()) - : NULL ); - Inkscape::Extension::Extension *selection = - importDialogInstance->getSelectionType(); + if (!success) { + delete importDialogInstance; + return; + } - if (!success) return; - if (fileName) { - gsize bytesRead = 0; - gsize bytesWritten = 0; - GError *error = NULL; -#ifdef INK_DUMP_FILENAME_CONV - dump_str( fileName, "D file pre is " ); -#endif - gchar *newFileName = g_filename_to_utf8( fileName, - -1, - &bytesRead, - &bytesWritten, - &error); - if ( newFileName != NULL ) { - g_free(fileName); - fileName = newFileName; -#ifdef INK_DUMP_FILENAME_CONV - dump_str( fileName, "D file post is " ); -#endif - } else { - // TODO: bulia, please look over - g_warning( "ERROR CONVERTING OPEN FILENAME TO UTF-8" ); - } + //# Get file name and extension type + Glib::ustring fileName = importDialogInstance->getFilename(); + Inkscape::Extension::Extension *selection = importDialogInstance->getSelectionType(); + delete importDialogInstance; + importDialogInstance = NULL; - if (!g_utf8_validate(fileName, -1, NULL)) { - // TODO: bulia, please look over - g_warning( "INPUT FILENAME IS NOT UTF-8" ); - } + if (fileName.size() > 0) { - g_free(import_path); - import_path = g_dirname(fileName); - if (import_path) import_path = g_strconcat(import_path, G_DIR_SEPARATOR_S, NULL); + Glib::ustring newFileName = Glib::filename_to_utf8(fileName); + + if ( newFileName.size() > 0) + fileName = newFileName; + else + g_warning( "ERROR CONVERTING OPEN FILENAME TO UTF-8" ); + + import_path = Glib::path_get_dirname (fileName); + import_path.append(G_DIR_SEPARATOR_S); + prefs->setString("/dialogs/import/path", import_path); file_import(doc, fileName, selection); - g_free(fileName); } return; @@ -982,246 +1123,379 @@ sp_file_import(GtkWidget *widget) ## E X P O R T ######################*/ -/** - * - */ -void -sp_file_export_dialog(void *widget) -{ - sp_export_dialog(); -} +//#define NEW_EXPORT_DIALOG -#include -#include -struct SPEBP { - int width, height, sheight; - guchar r, g, b, a; - NRArenaItem *root; // the root arena item to show; it is assumed that all unneeded items are hidden - guchar *px; - unsigned (*status)(float, void *); - void *data; -}; +#ifdef NEW_EXPORT_DIALOG /** - * + * Display an Export dialog, export as the selected type if OK pressed */ -static int -sp_export_get_rows(guchar const **rows, int row, int num_rows, void *data) +bool +sp_file_export_dialog(void *widget) { - struct SPEBP *ebp = (struct SPEBP *) data; + //# temp hack for 'doc' until we can switch to this dialog + SPDocument *doc = SP_ACTIVE_DOCUMENT; + + Glib::ustring export_path; + Glib::ustring export_loc; + + Inkscape::XML::Node *repr = sp_document_repr_root(doc); + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + Inkscape::Extension::Output *extension; - if (ebp->status) { - if (!ebp->status((float) row / ebp->height, ebp->data)) return 0; + //# Get the default extension name + Glib::ustring default_extension = prefs->getString("/dialogs/save_export/default"); + if(default_extension.empty()) { + // FIXME: Is this a good default? Should there be a macro for the string? + default_extension = "org.inkscape.output.png.cairo"; } + //g_message("%s: extension name: '%s'", __FUNCTION__, default_extension); - num_rows = MIN(num_rows, ebp->sheight); - num_rows = MIN(num_rows, ebp->height - row); - - /* Set area of interest */ - NRRectL bbox; - bbox.x0 = 0; - bbox.y0 = row; - bbox.x1 = ebp->width; - bbox.y1 = row + num_rows; - /* Update to renderable state */ - NRGC gc(NULL); - nr_matrix_set_identity(&gc.transform); - - nr_arena_item_invoke_update(ebp->root, &bbox, &gc, NR_ARENA_ITEM_STATE_ALL, NR_ARENA_ITEM_STATE_NONE); - - NRPixBlock pb; - nr_pixblock_setup_extern(&pb, NR_PIXBLOCK_MODE_R8G8B8A8N, - bbox.x0, bbox.y0, bbox.x1, bbox.y1, - ebp->px, 4 * ebp->width, FALSE, FALSE); - - for (int r = 0; r < num_rows; r++) { - guchar *p = NR_PIXBLOCK_PX(&pb) + r * pb.rs; - for (int c = 0; c < ebp->width; c++) { - *p++ = ebp->r; - *p++ = ebp->g; - *p++ = ebp->b; - *p++ = ebp->a; + if (doc->uri == NULL) + { + char formatBuf[256]; + + Glib::ustring filename_extension = ".svg"; + extension = dynamic_cast + (Inkscape::Extension::db.get(default_extension.c_str())); + //g_warning("%s: extension ptr: 0x%x", __FUNCTION__, (unsigned int)extension); + if (extension) + filename_extension = extension->get_extension(); + + Glib::ustring attr3 = prefs->getString("/dialogs/save_export/path"); + if (!attr3.empty()) + export_path = attr3; + + if (!Inkscape::IO::file_test(export_path.c_str(), + (GFileTest)(G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR))) + export_path = ""; + + if (export_path.size()<1) + export_path = g_get_home_dir(); + + export_loc = export_path; + export_loc.append(G_DIR_SEPARATOR_S); + snprintf(formatBuf, 255, _("drawing%s"), filename_extension.c_str()); + export_loc.append(formatBuf); + + } + else + { + export_path = Glib::path_get_dirname(doc->uri); } + + // convert save_loc from utf-8 to locale + // is this needed any more, now that everything is handled in + // Inkscape::IO? + Glib::ustring export_path_local = Glib::filename_from_utf8(export_path); + if ( export_path_local.size() > 0) + export_path = export_path_local; + + //# Show the SaveAs dialog + Inkscape::UI::Dialog::FileExportDialog *exportDialogInstance = + Inkscape::UI::Dialog::FileExportDialog::create( + export_path, + Inkscape::UI::Dialog::EXPORT_TYPES, + (char const *) _("Select file to export to"), + default_extension + ); + + bool success = exportDialogInstance->show(); + if (!success) { + delete exportDialogInstance; + return success; } - /* Render */ - nr_arena_item_invoke_render(ebp->root, &bbox, &pb, 0); + Glib::ustring fileName = exportDialogInstance->getFilename(); - for (int r = 0; r < num_rows; r++) { - rows[r] = NR_PIXBLOCK_PX(&pb) + r * pb.rs; + Inkscape::Extension::Extension *selectionType = + exportDialogInstance->getSelectionType(); + + delete exportDialogInstance; + exportDialogInstance = NULL; + + if (fileName.size() > 0) { + Glib::ustring newFileName = Glib::filename_to_utf8(fileName); + + if ( newFileName.size()>0 ) + fileName = newFileName; + else + g_warning( "Error converting save filename to UTF-8." ); + + success = file_save(doc, fileName, selectionType, TRUE, FALSE); + + if (success) { + Glib::RefPtr recent = Gtk::RecentManager::get_default(); + recent->add_item(SP_DOCUMENT_URI(doc)); + } + + export_path = fileName; + prefs->setString("/dialogs/save_export/path", export_path); + + return success; } - nr_pixblock_release(&pb); - return num_rows; + return false; } +#else + /** -Hide all items which are not listed in list, recursively, skipping groups and defs -*/ -void -hide_other_items_recursively(SPObject *o, GSList *list, unsigned dkey) + * + */ +bool +sp_file_export_dialog(void */*widget*/) { - if (SP_IS_ITEM(o) - && !SP_IS_DEFS(o) - && !SP_IS_ROOT(o) - && !SP_IS_GROUP(o) - && !g_slist_find(list, o)) - { - sp_item_invoke_hide(SP_ITEM(o), dkey); - } - - // recurse - if (!g_slist_find(list, o)) { - for (SPObject *child = sp_object_first_child(o) ; child != NULL; child = SP_OBJECT_NEXT(child) ) { - hide_other_items_recursively(child, list, dkey); - } - } + sp_export_dialog(); + return true; } +#endif + +/*###################### +## E X P O R T T O O C A L +######################*/ /** - * Render the SVG drawing onto a PNG raster image, then save to - * a file. Returns TRUE if succeeded in writing the file, - * FALSE otherwise. + * Display an Export dialog, export as the selected type if OK pressed */ -int -sp_export_png_file(SPDocument *doc, gchar const *filename, - double x0, double y0, double x1, double y1, - unsigned width, unsigned height, - unsigned long bgcolor, - unsigned (*status)(float, void *), - void *data, bool force_overwrite, - GSList *items_only) +bool +sp_file_export_to_ocal_dialog(Gtk::Window &parentWindow) { - int write_status = TRUE; - g_return_val_if_fail(doc != NULL, FALSE); - g_return_val_if_fail(filename != NULL, FALSE); - g_return_val_if_fail(width >= 1, FALSE); - g_return_val_if_fail(height >= 1, FALSE); - if (!force_overwrite && !sp_ui_overwrite_file(filename)) { - return FALSE; + if (!SP_ACTIVE_DOCUMENT) + return false; + + SPDocument *doc = SP_ACTIVE_DOCUMENT; + + Glib::ustring export_path; + Glib::ustring export_loc; + Glib::ustring fileName; + Inkscape::Extension::Extension *selectionType; + + bool success = false; + + static bool gotSuccess = false; + + Inkscape::XML::Node *repr = sp_document_repr_root(doc); + (void)repr; + + if (!doc->uri && !doc->isModifiedSinceSave()) + return false; + + // Get the default extension name + Glib::ustring default_extension = "org.inkscape.output.svg.inkscape"; + char formatBuf[256]; + + Glib::ustring filename_extension = ".svg"; + selectionType = Inkscape::Extension::db.get(default_extension.c_str()); + + export_path = Glib::get_tmp_dir (); + + export_loc = export_path; + export_loc.append(G_DIR_SEPARATOR_S); + snprintf(formatBuf, 255, _("drawing%s"), filename_extension.c_str()); + export_loc.append(formatBuf); + + // convert save_loc from utf-8 to locale + // is this needed any more, now that everything is handled in + // Inkscape::IO? + Glib::ustring export_path_local = Glib::filename_from_utf8(export_path); + if ( export_path_local.size() > 0) + export_path = export_path_local; + + // Show the Export To OCAL dialog + Inkscape::UI::Dialog::FileExportToOCALDialog *exportDialogInstance = + new Inkscape::UI::Dialog::FileExportToOCALDialog( + parentWindow, + Inkscape::UI::Dialog::EXPORT_TYPES, + (char const *) _("Select file to export to") + ); + + success = exportDialogInstance->show(); + if (!success) { + delete exportDialogInstance; + return success; } - sp_document_ensure_up_to_date(doc); - - /* Go to document coordinates */ - gdouble t = y0; - y0 = sp_document_height(doc) - y1; - y1 = sp_document_height(doc) - t; - - /* - * 1) a[0] * x0 + a[2] * y1 + a[4] = 0.0 - * 2) a[1] * x0 + a[3] * y1 + a[5] = 0.0 - * 3) a[0] * x1 + a[2] * y1 + a[4] = width - * 4) a[1] * x0 + a[3] * y0 + a[5] = height - * 5) a[1] = 0.0; - * 6) a[2] = 0.0; - * - * (1,3) a[0] * x1 - a[0] * x0 = width - * a[0] = width / (x1 - x0) - * (2,4) a[3] * y0 - a[3] * y1 = height - * a[3] = height / (y0 - y1) - * (1) a[4] = -a[0] * x0 - * (2) a[5] = -a[3] * y1 - */ - - NRMatrix affine; - affine.c[0] = width / (x1 - x0); - affine.c[1] = 0.0; - affine.c[2] = 0.0; - affine.c[3] = height / (y1 - y0); - affine.c[4] = -affine.c[0] * x0; - affine.c[5] = -affine.c[3] * y0; - - //SP_PRINT_MATRIX("SVG2PNG", &affine); - - struct SPEBP ebp; - ebp.width = width; - ebp.height = height; - ebp.r = NR_RGBA32_R(bgcolor); - ebp.g = NR_RGBA32_G(bgcolor); - ebp.b = NR_RGBA32_B(bgcolor); - ebp.a = NR_RGBA32_A(bgcolor); - - /* Create new arena */ - NRArena *arena = NRArena::create(); - unsigned dkey = sp_item_display_key_new(1); - - /* Create ArenaItems and set transform */ - ebp.root = sp_item_invoke_show(SP_ITEM(sp_document_root(doc)), arena, dkey, SP_ITEM_SHOW_DISPLAY); - nr_arena_item_set_transform(NR_ARENA_ITEM(ebp.root), NR::Matrix(&affine)); - - // We show all and then hide all items we don't want, instead of showing only requested items, - // because that would not work if the shown item references something in defs - if (items_only) { - hide_other_items_recursively(sp_document_root(doc), items_only, dkey); + fileName = exportDialogInstance->getFilename(); + + delete exportDialogInstance; + exportDialogInstance = NULL;; + + fileName.append(filename_extension.c_str()); + if (fileName.size() > 0) { + Glib::ustring newFileName = Glib::filename_to_utf8(fileName); + + if ( newFileName.size()>0 ) + fileName = newFileName; + else + g_warning( "Error converting save filename to UTF-8." ); } + Glib::ustring filePath = export_path; + filePath.append(G_DIR_SEPARATOR_S); + filePath.append(Glib::path_get_basename(fileName)); - ebp.status = status; - ebp.data = data; + fileName = filePath; - if ((width < 256) || ((width * height) < 32768)) { - ebp.px = nr_pixelstore_64K_new(FALSE, 0); - ebp.sheight = 65536 / (4 * width); - write_status = sp_png_write_rgba_striped(filename, width, height, sp_export_get_rows, &ebp); - nr_pixelstore_64K_free(ebp.px); - } else { - ebp.px = nr_new(guchar, 4 * 64 * width); - ebp.sheight = 64; - write_status = sp_png_write_rgba_striped(filename, width, height, sp_export_get_rows, &ebp); - nr_free(ebp.px); + success = file_save(parentWindow, doc, filePath, selectionType, FALSE, FALSE, Inkscape::Extension::FILE_SAVE_METHOD_EXPORT); + + if (!success){ + gchar *text = g_strdup_printf(_("Error saving a temporary copy")); + sp_ui_error_dialog(text); + + return success; } - // Hide items - sp_item_invoke_hide(SP_ITEM(sp_document_root(doc)), dkey); + // Start now the submition + + // Create the uri + Inkscape::Preferences *prefs = Inkscape::Preferences::get(); + Glib::ustring uri = "dav://"; + Glib::ustring username = prefs->getString("/options/ocalusername/str"); + Glib::ustring password = prefs->getString("/options/ocalpassword/str"); + if (username.empty() || password.empty()) + { + Inkscape::UI::Dialog::FileExportToOCALPasswordDialog *exportPasswordDialogInstance = NULL; + if(!gotSuccess) + { + exportPasswordDialogInstance = new Inkscape::UI::Dialog::FileExportToOCALPasswordDialog( + parentWindow, + (char const *) _("Open Clip Art Login")); + success = exportPasswordDialogInstance->show(); + if (!success) { + delete exportPasswordDialogInstance; + return success; + } + } + username = exportPasswordDialogInstance->getUsername(); + password = exportPasswordDialogInstance->getPassword(); - /* Free Arena and ArenaItem */ - nr_arena_item_unref(ebp.root); - nr_object_unref((NRObject *) arena); - return write_status; + delete exportPasswordDialogInstance; + exportPasswordDialogInstance = NULL; + } + uri.append(username); + uri.append(":"); + uri.append(password); + uri.append("@"); + uri.append(prefs->getString("/options/ocalurl/str")); + uri.append("/dav.php/"); + uri.append(Glib::path_get_basename(fileName)); + + // Save as a remote file using the dav protocol. + success = file_save_remote(doc, uri, selectionType, FALSE, FALSE); + remove(fileName.c_str()); + if (!success) + { + gchar *text = g_strdup_printf(_("Error exporting the document. Verify if the server name, username and password are correct, if the server has support for webdav and verify if you didn't forget to choose a license.")); + sp_ui_error_dialog(text); + } + else + gotSuccess = true; + + return success; +} + +/** + * Export the current document to OCAL + */ +void +sp_file_export_to_ocal(Gtk::Window &parentWindow) +{ + + // Try to execute the new code and return; + if (!SP_ACTIVE_DOCUMENT) + return; + bool success = sp_file_export_to_ocal_dialog(parentWindow); + if (success) + SP_ACTIVE_DESKTOP->messageStack()->flash(Inkscape::IMMEDIATE_MESSAGE, _("Document exported...")); } /*###################### -## P R I N T +## I M P O R T F R O M O C A L ######################*/ - /** - * Print the current document, if any. + * Display an ImportToOcal Dialog, and the selected document from OCAL */ void -sp_file_print() +sp_file_import_from_ocal(Gtk::Window &parentWindow) { + static Glib::ustring import_path; + SPDocument *doc = SP_ACTIVE_DOCUMENT; - if (doc) - sp_print_document(doc, FALSE); + if (!doc) + return; + + Inkscape::UI::Dialog::FileImportFromOCALDialog *importDialogInstance = NULL; + + if (!importDialogInstance) { + importDialogInstance = new + Inkscape::UI::Dialog::FileImportFromOCALDialog( + parentWindow, + import_path, + Inkscape::UI::Dialog::IMPORT_TYPES, + (char const *)_("Import From Open Clip Art Library")); + } + + bool success = importDialogInstance->show(); + if (!success) { + delete importDialogInstance; + return; + } + + // Get file name and extension type + Glib::ustring fileName = importDialogInstance->getFilename(); + Inkscape::Extension::Extension *selection = importDialogInstance->getSelectionType(); + + delete importDialogInstance; + importDialogInstance = NULL; + + if (fileName.size() > 0) { + + Glib::ustring newFileName = Glib::filename_to_utf8(fileName); + + if ( newFileName.size() > 0) + fileName = newFileName; + else + g_warning( "ERROR CONVERTING OPEN FILENAME TO UTF-8" ); + + import_path = fileName; + if (import_path.size()>0) + import_path.append(G_DIR_SEPARATOR_S); + + file_import(doc, fileName, selection); + } + + return; } +/*###################### +## P R I N T +######################*/ + /** - * Print the current document, if any. Do not use - * the machine's print drivers. + * Print the current document, if any. */ void -sp_file_print_direct() +sp_file_print(Gtk::Window& parentWindow) { SPDocument *doc = SP_ACTIVE_DOCUMENT; if (doc) - sp_print_document(doc, TRUE); + sp_print_document(parentWindow, doc); } - /** * Display what the drawing would look like, if * printed. */ void -sp_file_print_preview(gpointer object, gpointer data) +sp_file_print_preview(gpointer /*object*/, gpointer /*data*/) { SPDocument *doc = SP_ACTIVE_DOCUMENT; @@ -1230,102 +1504,6 @@ sp_file_print_preview(gpointer object, gpointer data) } -void Inkscape::IO::fixupHrefs( SPDocument *doc, const gchar *base, gboolean spns ) -{ - //g_message("Inkscape::IO::fixupHrefs( , [%s], )", base ); - - if ( 0 ) { - gchar const* things[] = { - "data:foo,bar", - "http://www.google.com/image.png", - "ftp://ssd.com/doo", - "/foo/dee/bar.svg", - "foo.svg", - "file:/foo/dee/bar.svg", - "file:///foo/dee/bar.svg", - "file:foo.svg", - "/foo/bar\xe1\x84\x92.svg", - "file:///foo/bar\xe1\x84\x92.svg", - "file:///foo/bar%e1%84%92.svg", - "/foo/bar%e1%84%92.svg", - "bar\xe1\x84\x92.svg", - "bar%e1%84%92.svg", - NULL - }; - g_message("+------"); - for ( int i = 0; things[i]; i++ ) - { - try - { - URI uri(things[i]); - gboolean isAbs = g_path_is_absolute( things[i] ); - gchar *str = uri.toString(); - g_message( "abs:%d isRel:%d scheme:[%s] path:[%s][%s] uri[%s] / [%s]", (int)isAbs, - (int)uri.isRelative(), - uri.getScheme(), - uri.getPath(), - uri.getOpaque(), - things[i], - str ); - g_free(str); - } - catch ( MalformedURIException err ) - { - dump_str( things[i], "MalformedURIException" ); - xmlChar *redo = xmlURIEscape((xmlChar const *)things[i]); - g_message(" gone from [%s] to [%s]", things[i], redo ); - if ( redo == NULL ) - { - URI again = URI::fromUtf8( things[i] ); - gboolean isAbs = g_path_is_absolute( things[i] ); - gchar *str = again.toString(); - g_message( "abs:%d isRel:%d scheme:[%s] path:[%s][%s] uri[%s] / [%s]", (int)isAbs, - (int)again.isRelative(), - again.getScheme(), - again.getPath(), - again.getOpaque(), - things[i], - str ); - g_free(str); - g_message(" ----"); - } - } - } - g_message("+------"); - } - - GSList const *images = sp_document_get_resource_list(doc, "image"); - for (GSList const *l = images; l != NULL; l = l->next) { - Inkscape::XML::Node *ir = SP_OBJECT_REPR(l->data); - - const gchar *href = ir->attribute("xlink:href"); - - // First try to figure out an absolute path to the asset - //g_message("image href [%s]", href ); - if (spns && !g_path_is_absolute(href)) { - const gchar *absref = ir->attribute("sodipodi:absref"); - const gchar *base_href = g_build_filename(base, href, NULL); - //g_message(" absr [%s]", absref ); - - if ( absref && Inkscape::IO::file_test(absref, G_FILE_TEST_EXISTS) && !Inkscape::IO::file_test(base_href, G_FILE_TEST_EXISTS)) - { - // only switch over if the absref is valid while href is not - href = absref; - //g_message(" copied absref to href"); - } - } - - // Once we have an absolute path, convert it relative to the new location - if (href && g_path_is_absolute(href)) { - const gchar *relname = sp_relative_path_from_path(href, base); - //g_message(" setting to [%s]", relname ); - ir->setAttribute("xlink:href", relname); - } -// TODO next refinement is to make the first choice keeping the relative path as-is if -// based on the new location it gives us a valid file. - } -} - /* Local Variables: