/* * Implementation of the file dialog interfaces defined in filedialog.h * * Authors: * Bob Jamison * Other dudes from The Inkscape Organization * * Copyright (C) 2004 The Inkscape Organization * * Released under GNU GPL, read the file 'COPYING' for more information */ #ifdef HAVE_CONFIG_H # include #endif //Temporary ugly hack //Remove these after the get_filter() calls in //show() on both classes are fixed #include //Another hack #include #include #include #include #include #include #include #include #include #include #include #include #include #include "prefs-utils.h" #include #include #include #include #include "inkscape.h" #include "svg-view-widget.h" #include "filedialog.h" #undef INK_DUMP_FILENAME_CONV #ifdef INK_DUMP_FILENAME_CONV void dump_str( const gchar* str, const gchar* prefix ); void dump_ustr( const Glib::ustring& ustr ); #endif namespace Inkscape { namespace UI { namespace Dialogs { void FileDialogExtensionToPattern (Glib::ustring &pattern, gchar * in_file_extension); /*######################################################################### ### SVG Preview Widget #########################################################################*/ /** * Simple class for displaying an SVG file in the "preview widget." * Currently, this is just a wrapper of the sp_svg_view Gtk widget. * Hopefully we will eventually replace with a pure Gtkmm widget. */ class SVGPreview : public Gtk::VBox { public: SVGPreview(); ~SVGPreview(); bool setDocument(SPDocument *doc); bool setFileName(Glib::ustring &fileName); bool setFromMem(char const *xmlBuffer); bool set(Glib::ustring &fileName, int dialogType); bool setURI(URI &uri); /** * Show image embedded in SVG */ void showImage(Glib::ustring &fileName); /** * Show the "No preview" image */ void showNoPreview(); /** * Show the "Too large" image */ void showTooLarge(long fileLength); private: /** * The svg document we are currently showing */ SPDocument *document; /** * The sp_svg_view widget */ GtkWidget *viewerGtk; /** * are we currently showing the "no preview" image? */ bool showingNoPreview; }; bool SVGPreview::setDocument(SPDocument *doc) { if (document) sp_document_unref(document); sp_document_ref(doc); document = doc; //This should remove it from the box, and free resources if (viewerGtk) { gtk_widget_destroy(viewerGtk); } viewerGtk = sp_svg_view_widget_new(doc); GtkWidget *vbox = (GtkWidget *)gobj(); gtk_box_pack_start(GTK_BOX(vbox), viewerGtk, TRUE, TRUE, 0); gtk_widget_show(viewerGtk); return true; } bool SVGPreview::setFileName(Glib::ustring &theFileName) { Glib::ustring fileName = theFileName; fileName = Glib::filename_to_utf8(fileName); SPDocument *doc = sp_document_new (fileName.c_str(), 0); if (!doc) { g_warning("SVGView: error loading document '%s'\n", fileName.c_str()); return false; } setDocument(doc); sp_document_unref(doc); return true; } bool SVGPreview::setFromMem(char const *xmlBuffer) { if (!xmlBuffer) return false; gint len = (gint)strlen(xmlBuffer); SPDocument *doc = sp_document_new_from_mem(xmlBuffer, len, 0); if (!doc) { g_warning("SVGView: error loading buffer '%s'\n",xmlBuffer); return false; } setDocument(doc); sp_document_unref(doc); return true; } void SVGPreview::showImage(Glib::ustring &theFileName) { Glib::ustring fileName = theFileName; /*##################################### # LET'S HAVE SOME FUN WITH SVG! # Instead of just loading an image, why # don't we make a lovely little svg and # display it nicely? #####################################*/ //Arbitrary size of svg doc -- rather 'portrait' shaped gint previewWidth = 400; gint previewHeight = 600; //Get some image info. Smart pointer does not need to be deleted Glib::RefPtr img = Gdk::Pixbuf::create_from_file(fileName); gint imgWidth = img->get_width(); gint imgHeight = img->get_height(); //Find the minimum scale to fit the image inside the preview area double scaleFactorX = (0.9 *(double)previewWidth) / ((double)imgWidth); double scaleFactorY = (0.9 *(double)previewHeight) / ((double)imgHeight); double scaleFactor = scaleFactorX; if (scaleFactorX > scaleFactorY) scaleFactor = scaleFactorY; //Now get the resized values gint scaledImgWidth = (int) (scaleFactor * (double)imgWidth); gint scaledImgHeight = (int) (scaleFactor * (double)imgHeight); //center the image on the area gint imgX = (previewWidth - scaledImgWidth) / 2; gint imgY = (previewHeight - scaledImgHeight) / 2; //wrap a rectangle around the image gint rectX = imgX-1; gint rectY = imgY-1; gint rectWidth = scaledImgWidth +2; gint rectHeight = scaledImgHeight+2; //Our template. Modify to taste gchar const *xformat = "\n" "\n" "\n" "\n" "\n" "%d x %d\n" "\n\n"; //if (!Glib::get_charset()) //If we are not utf8 fileName = Glib::filename_to_utf8(fileName); //Fill in the template /* FIXME: Do proper XML quoting for fileName. */ gchar *xmlBuffer = g_strdup_printf(xformat, previewWidth, previewHeight, imgX, imgY, scaledImgWidth, scaledImgHeight, fileName.c_str(), rectX, rectY, rectWidth, rectHeight, imgWidth, imgHeight); //g_message("%s\n", xmlBuffer); //now show it! setFromMem(xmlBuffer); g_free(xmlBuffer); } void SVGPreview::showNoPreview() { //Are we already showing it? if (showingNoPreview) return; //Arbitrary size of svg doc -- rather 'portrait' shaped gint previewWidth = 300; gint previewHeight = 600; //Our template. Modify to taste gchar const *xformat = "\n" "\n" "\n" "\n" "\n" "\n" "\n" "\n" " \n" "%s\n" "\n\n"; //Fill in the template gchar *xmlBuffer = g_strdup_printf(xformat, previewWidth, previewHeight, _("No preview")); //g_message("%s\n", xmlBuffer); //now show it! setFromMem(xmlBuffer); g_free(xmlBuffer); showingNoPreview = true; } void SVGPreview::showTooLarge(long fileLength) { //Arbitrary size of svg doc -- rather 'portrait' shaped gint previewWidth = 300; gint previewHeight = 600; //Our template. Modify to taste gchar const *xformat = "\n" "\n" "\n" "\n" "\n" "\n" "\n" "\n" "\n" "%5.1f MB\n" "%s\n" "\n\n"; //Fill in the template double floatFileLength = ((double)fileLength) / 1048576.0; //printf("%ld %f\n", fileLength, floatFileLength); gchar *xmlBuffer = g_strdup_printf(xformat, previewWidth, previewHeight, floatFileLength, _("too large for preview")); //g_message("%s\n", xmlBuffer); //now show it! setFromMem(xmlBuffer); g_free(xmlBuffer); } static bool hasSuffix(Glib::ustring &str, Glib::ustring &ext) { int strLen = str.length(); int extLen = ext.length(); if (extLen > strLen) { return false; } int strpos = strLen-1; for (int extpos = extLen-1 ; extpos>=0 ; extpos--, strpos--) { Glib::ustring::value_type ch = str[strpos]; if (ch != ext[extpos]) { if ( ((ch & 0xff80) != 0) || static_cast( g_ascii_tolower( static_cast(0x07f & ch) ) ) != ext[extpos] ) { return false; } } } return true; } /** * Return true if the image is loadable by Gdk, else false */ static bool isValidImageFile(Glib::ustring &fileName) { std::vectorformats = Gdk::Pixbuf::get_formats(); for (unsigned int i=0; iextensions = format.get_extensions(); for (unsigned int j=0; j 0x150000L) { showingNoPreview = false; showTooLarge(fileLen); return FALSE; } } Glib::ustring svg = ".svg"; Glib::ustring svgz = ".svgz"; if ((dialogType == SVG_TYPES || dialogType == IMPORT_TYPES) && (hasSuffix(fileName, svg) || hasSuffix(fileName, svgz) ) ) { bool retval = setFileName(fileName); showingNoPreview = false; return retval; } else if (isValidImageFile(fileName)) { showImage(fileName); showingNoPreview = false; return true; } else { showNoPreview(); return false; } } SVGPreview::SVGPreview() { if (!INKSCAPE) inkscape_application_init("",false); document = NULL; viewerGtk = NULL; set_size_request(150,150); showingNoPreview = false; } SVGPreview::~SVGPreview() { } /*######################################################################### ### F I L E O P E N #########################################################################*/ /** * Our implementation class for the FileOpenDialog interface.. */ class FileOpenDialogImpl : public FileOpenDialog, public Gtk::FileChooserDialog { public: FileOpenDialogImpl(char const *dir, FileDialogType fileTypes, char const *title); virtual ~FileOpenDialogImpl(); bool show(); Inkscape::Extension::Extension *getSelectionType(); gchar *getFilename(); Glib::SListHandle getFilenames (); protected: private: /** * What type of 'open' are we? (open, import, place, etc) */ FileDialogType dialogType; /** * Our svg preview widget */ SVGPreview svgPreview; /** * Callback for seeing if the preview needs to be drawn */ void updatePreviewCallback(); /** * Fix to allow the user to type the file name */ Gtk::Entry fileNameEntry; /** * Create a filter menu for this type of dialog */ void createFilterMenu(); /** * Callback for user input into fileNameEntry */ void fileNameEntryChangedCallback(); /** * Callback for user changing which item is selected on the list */ void fileSelectedCallback(); /** * Filter name->extension lookup */ std::map extensionMap; /** * The extension to use to write this file */ Inkscape::Extension::Extension *extension; /** * Filename that was given */ Glib::ustring myFilename; }; /** * Callback for checking if the preview needs to be redrawn */ void FileOpenDialogImpl::updatePreviewCallback() { Glib::ustring fileName = get_preview_filename(); if (fileName.length() < 1) return; svgPreview.set(fileName, dialogType); } /** * Callback for fileNameEntry widget */ void FileOpenDialogImpl::fileNameEntryChangedCallback() { Glib::ustring fileName = fileNameEntry.get_text(); // TODO remove this leak fileName = Glib::filename_from_utf8(fileName); //g_message("User hit return. Text is '%s'\n", fName.c_str()); if (!Glib::path_is_absolute(fileName)) { //try appending to the current path // not this way: fileName = get_current_folder() + "/" + fName; std::vector pathSegments; pathSegments.push_back( get_current_folder() ); pathSegments.push_back( fileName ); fileName = Glib::build_filename(pathSegments); } //g_message("path:'%s'\n", fName.c_str()); if (Glib::file_test(fileName, Glib::FILE_TEST_IS_DIR)) { set_current_folder(fileName); } else if (Glib::file_test(fileName, Glib::FILE_TEST_IS_REGULAR)) { //dialog with either (1) select a regular file or (2) cd to dir //simulate an 'OK' set_filename(fileName); response(Gtk::RESPONSE_OK); } } /** * Callback for fileNameEntry widget */ void FileOpenDialogImpl::fileSelectedCallback() { Glib::ustring fileName = get_filename(); if (!Glib::get_charset()) //If we are not utf8 fileName = Glib::filename_to_utf8(fileName); //g_message("User selected '%s'\n", // filename().c_str()); #ifdef INK_DUMP_FILENAME_CONV ::dump_ustr( get_filename() ); #endif fileNameEntry.set_text(fileName); } void FileOpenDialogImpl::createFilterMenu() { //patterns added dynamically below Gtk::FileFilter allImageFilter; allImageFilter.set_name(_("All Images")); extensionMap[Glib::ustring(_("All Images"))]=NULL; add_filter(allImageFilter); Gtk::FileFilter allFilter; allFilter.set_name(_("All Files")); extensionMap[Glib::ustring(_("All Files"))]=NULL; allFilter.add_pattern("*"); add_filter(allFilter); //patterns added dynamically below Gtk::FileFilter allInkscapeFilter; allInkscapeFilter.set_name(_("All Inkscape Files")); extensionMap[Glib::ustring(_("All Inkscape Files"))]=NULL; add_filter(allInkscapeFilter); Inkscape::Extension::DB::InputList extension_list; Inkscape::Extension::db.get_input_list(extension_list); for (Inkscape::Extension::DB::InputList::iterator current_item = extension_list.begin(); current_item != extension_list.end(); current_item++) { Inkscape::Extension::Input * imod = *current_item; // FIXME: would be nice to grey them out instead of not listing them if (imod->deactivated()) continue; Glib::ustring upattern("*"); FileDialogExtensionToPattern (upattern, imod->get_extension()); Gtk::FileFilter filter; Glib::ustring uname(_(imod->get_filetypename())); filter.set_name(uname); filter.add_pattern(upattern); add_filter(filter); extensionMap[uname] = imod; //g_message("ext %s:%s '%s'\n", ioext->name, ioext->mimetype, upattern.c_str()); allInkscapeFilter.add_pattern(upattern); if ( strncmp("image", imod->get_mimetype(), 5)==0 ) allImageFilter.add_pattern(upattern); } return; } /** * Constructor. Not called directly. Use the factory. */ FileOpenDialogImpl::FileOpenDialogImpl(char const *dir, FileDialogType fileTypes, char const *title) : Gtk::FileChooserDialog(Glib::ustring(title)) { /* One file at a time */ /* And also Multiple Files */ set_select_multiple(true); /* Initalize to Autodetect */ extension = NULL; /* No filename to start out with */ myFilename = ""; /* Set our dialog type (open, import, etc...)*/ dialogType = fileTypes; /* Set the pwd and/or the filename */ if (dir != NULL) { Glib::ustring udir(dir); Glib::ustring::size_type len = udir.length(); // leaving a trailing backslash on the directory name leads to the infamous // double-directory bug on win32 if (len != 0 && udir[len - 1] == '\\') udir.erase(len - 1); set_current_folder(udir.c_str()); } //###### Add the file types menu createFilterMenu(); //###### Add a preview widget set_preview_widget(svgPreview); set_preview_widget_active(true); set_use_preview_label (false); //Catch selection-changed events, so we can adjust the text widget signal_update_preview().connect( sigc::mem_fun(*this, &FileOpenDialogImpl::updatePreviewCallback) ); //###### Add a text entry bar, and tie it to file chooser events fileNameEntry.set_text(get_current_folder()); set_extra_widget(fileNameEntry); fileNameEntry.grab_focus(); //Catch when user hits [return] on the text field fileNameEntry.signal_activate().connect( sigc::mem_fun(*this, &FileOpenDialogImpl::fileNameEntryChangedCallback) ); //Catch selection-changed events, so we can adjust the text widget signal_selection_changed().connect( sigc::mem_fun(*this, &FileOpenDialogImpl::fileSelectedCallback) ); add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL); add_button(Gtk::Stock::OPEN, Gtk::RESPONSE_OK); } /** * Public factory. Called by file.cpp, among others. */ FileOpenDialog *FileOpenDialog::create(char const *path, FileDialogType fileTypes, char const *title) { FileOpenDialog *dialog = new FileOpenDialogImpl(path, fileTypes, title); return dialog; } /** * Destructor */ FileOpenDialogImpl::~FileOpenDialogImpl() { } /** * Show this dialog modally. Return true if user hits [OK] */ bool FileOpenDialogImpl::show() { set_current_folder(get_current_folder()); //hack to force initial dir listing set_modal (TRUE); //Window sp_transientize((GtkWidget *)gobj()); //Make transient gint b = run(); //Dialog hide(); if (b == Gtk::RESPONSE_OK) { //This is a hack, to avoid the warning messages that //Gtk::FileChooser::get_filter() returns //should be: Gtk::FileFilter *filter = get_filter(); GtkFileChooser *gtkFileChooser = Gtk::FileChooser::gobj(); GtkFileFilter *filter = gtk_file_chooser_get_filter(gtkFileChooser); if (filter) { //Get which extension was chosen, if any extension = extensionMap[gtk_file_filter_get_name(filter)]; } myFilename = get_filename(); return TRUE; } else { return FALSE; } } /** * Get the file extension type that was selected by the user. Valid after an [OK] */ Inkscape::Extension::Extension * FileOpenDialogImpl::getSelectionType() { return extension; } /** * Get the file name chosen by the user. Valid after an [OK] */ gchar * FileOpenDialogImpl::getFilename (void) { return g_strdup(myFilename.c_str()); } /** * To Get Multiple filenames selected at-once. */ Glib::SListHandleFileOpenDialogImpl::getFilenames() { return get_filenames(); } /*######################################################################### # F I L E S A V E #########################################################################*/ class FileType { public: FileType() {} ~FileType() {} Glib::ustring name; Glib::ustring pattern; Inkscape::Extension::Extension *extension; }; /** * Our implementation of the FileSaveDialog interface. */ class FileSaveDialogImpl : public FileSaveDialog, public Gtk::FileChooserDialog { public: FileSaveDialogImpl(char const *dir, FileDialogType fileTypes, char const *title, char const *default_key); virtual ~FileSaveDialogImpl(); bool show(); Inkscape::Extension::Extension *getSelectionType(); gchar *getFilename(); private: /** * What type of 'open' are we? (save, export, etc) */ FileDialogType dialogType; /** * Our svg preview widget */ SVGPreview svgPreview; /** * Fix to allow the user to type the file name */ Gtk::Entry *fileNameEntry; /** * Callback for seeing if the preview needs to be drawn */ void updatePreviewCallback(); /** * Allow the specification of the output file type */ Gtk::HBox fileTypeBox; /** * Allow the specification of the output file type */ Gtk::ComboBoxText fileTypeComboBox; /** * Data mirror of the combo box */ std::vector fileTypes; //# Child widgets Gtk::CheckButton fileTypeCheckbox; /** * Callback for user input into fileNameEntry */ void fileTypeChangedCallback(); /** * Create a filter menu for this type of dialog */ void createFileTypeMenu(); bool append_extension; /** * The extension to use to write this file */ Inkscape::Extension::Extension *extension; /** * Callback for user input into fileNameEntry */ void fileNameEntryChangedCallback(); /** * Filename that was given */ Glib::ustring myFilename; }; /** * Callback for checking if the preview needs to be redrawn */ void FileSaveDialogImpl::updatePreviewCallback() { Glib::ustring fileName = get_preview_filename(); if (!fileName.c_str()) return; bool retval = svgPreview.set(fileName, dialogType); set_preview_widget_active(retval); } /** * Callback for fileNameEntry widget */ void FileSaveDialogImpl::fileNameEntryChangedCallback() { if (!fileNameEntry) return; Glib::ustring fileName = fileNameEntry->get_text(); if (!Glib::get_charset()) //If we are not utf8 fileName = Glib::filename_to_utf8(fileName); //g_message("User hit return. Text is '%s'\n", fileName.c_str()); if (!Glib::path_is_absolute(fileName)) { //try appending to the current path // not this way: fileName = get_current_folder() + "/" + fileName; std::vector pathSegments; pathSegments.push_back( get_current_folder() ); pathSegments.push_back( fileName ); fileName = Glib::build_filename(pathSegments); } //g_message("path:'%s'\n", fileName.c_str()); if (Glib::file_test(fileName, Glib::FILE_TEST_IS_DIR)) { set_current_folder(fileName); } else if (/*Glib::file_test(fileName, Glib::FILE_TEST_IS_REGULAR)*/1) { //dialog with either (1) select a regular file or (2) cd to dir //simulate an 'OK' set_filename(fileName); response(Gtk::RESPONSE_OK); } } /** * Callback for fileNameEntry widget */ void FileSaveDialogImpl::fileTypeChangedCallback() { int sel = fileTypeComboBox.get_active_row_number(); if (sel<0 || sel >= (int)fileTypes.size()) return; FileType type = fileTypes[sel]; //g_message("selected: %s\n", type.name.c_str()); Gtk::FileFilter filter; filter.add_pattern(type.pattern); set_filter(filter); } void FileSaveDialogImpl::createFileTypeMenu() { Inkscape::Extension::DB::OutputList extension_list; Inkscape::Extension::db.get_output_list(extension_list); for (Inkscape::Extension::DB::OutputList::iterator current_item = extension_list.begin(); current_item != extension_list.end(); current_item++) { Inkscape::Extension::Output * omod = *current_item; // FIXME: would be nice to grey them out instead of not listing them if (omod->deactivated()) continue; FileType type; type.name = (_(omod->get_filetypename())); type.pattern = "*"; FileDialogExtensionToPattern (type.pattern, omod->get_extension()); type.extension= omod; fileTypeComboBox.append_text(type.name); fileTypes.push_back(type); } //#Let user choose FileType guessType; guessType.name = _("Guess from extension"); guessType.pattern = "*"; guessType.extension = NULL; fileTypeComboBox.append_text(guessType.name); fileTypes.push_back(guessType); fileTypeComboBox.set_active(0); fileTypeChangedCallback(); //call at least once to set the filter } void findEntryWidgets(Gtk::Container *parent, std::vector &result) { if (!parent) return; std::vector children = parent->get_children(); for (unsigned int i=0; igobj(); if (GTK_IS_ENTRY(wid)) result.push_back((Gtk::Entry *)child); else if (GTK_IS_CONTAINER(wid)) findEntryWidgets((Gtk::Container *)child, result); } } void findExpanderWidgets(Gtk::Container *parent, std::vector &result) { if (!parent) return; std::vector children = parent->get_children(); for (unsigned int i=0; igobj(); if (GTK_IS_EXPANDER(wid)) result.push_back((Gtk::Expander *)child); else if (GTK_IS_CONTAINER(wid)) findExpanderWidgets((Gtk::Container *)child, result); } } /** * Constructor */ FileSaveDialogImpl::FileSaveDialogImpl(char const *dir, FileDialogType fileTypes, char const *title, char const *default_key) : Gtk::FileChooserDialog(Glib::ustring(title), Gtk::FILE_CHOOSER_ACTION_SAVE) { append_extension = (bool)prefs_get_int_attribute("dialogs.save_as", "append_extension", 1); /* One file at a time */ set_select_multiple(false); /* Initalize to Autodetect */ extension = NULL; /* No filename to start out with */ myFilename = ""; /* Set our dialog type (save, export, etc...)*/ dialogType = fileTypes; /* Set the pwd and/or the filename */ if (dir != NULL) { Glib::ustring udir(dir); Glib::ustring::size_type len = udir.length(); // leaving a trailing backslash on the directory name leads to the infamous // double-directory bug on win32 if (len != 0 && udir[len - 1] == '\\') udir.erase(len - 1); set_current_folder(udir.c_str()); } //###### Add the file types menu //createFilterMenu(); //###### Do we want the .xxx extension automatically added? fileTypeCheckbox.set_label(Glib::ustring(_("Append filename extension automatically"))); fileTypeCheckbox.set_active(append_extension); fileTypeBox.pack_start(fileTypeCheckbox); createFileTypeMenu(); fileTypeComboBox.set_size_request(200,40); fileTypeComboBox.signal_changed().connect( sigc::mem_fun(*this, &FileSaveDialogImpl::fileTypeChangedCallback) ); fileTypeBox.pack_start(fileTypeComboBox); set_extra_widget(fileTypeBox); //get_vbox()->pack_start(fileTypeBox, false, false, 0); //get_vbox()->reorder_child(fileTypeBox, 2); //###### Add a preview widget set_preview_widget(svgPreview); set_preview_widget_active(true); set_use_preview_label (false); //Catch selection-changed events, so we can adjust the text widget signal_update_preview().connect( sigc::mem_fun(*this, &FileSaveDialogImpl::updatePreviewCallback) ); //Let's do some customization fileNameEntry = NULL; Gtk::Container *cont = get_toplevel(); std::vector entries; findEntryWidgets(cont, entries); //g_message("Found %d entry widgets\n", entries.size()); if (entries.size() >=1 ) { //Catch when user hits [return] on the text field fileNameEntry = entries[0]; fileNameEntry->signal_activate().connect( sigc::mem_fun(*this, &FileSaveDialogImpl::fileNameEntryChangedCallback) ); } //Let's do more customization std::vector expanders; findExpanderWidgets(cont, expanders); //g_message("Found %d expander widgets\n", expanders.size()); if (expanders.size() >=1 ) { //Always show the file list Gtk::Expander *expander = expanders[0]; expander->set_expanded(true); } //if (extension == NULL) // checkbox.set_sensitive(FALSE); add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL); add_button(Gtk::Stock::SAVE, Gtk::RESPONSE_OK); show_all_children(); } /** * Public factory method. Used in file.cpp */ FileSaveDialog *FileSaveDialog::create(char const *path, FileDialogType fileTypes, char const *title, char const *default_key) { FileSaveDialog *dialog = new FileSaveDialogImpl(path, fileTypes, title, default_key); return dialog; } /** * Destructor */ FileSaveDialogImpl::~FileSaveDialogImpl() { } /** * Show this dialog modally. Return true if user hits [OK] */ bool FileSaveDialogImpl::show() { set_current_folder(get_current_folder()); //hack to force initial dir listing set_modal (TRUE); //Window sp_transientize((GtkWidget *)gobj()); //Make transient gint b = run(); //Dialog hide(); if (b == Gtk::RESPONSE_OK) { int sel = fileTypeComboBox.get_active_row_number (); if (sel>=0 && sel< (int)fileTypes.size()) { FileType &type = fileTypes[sel]; extension = type.extension; } myFilename = get_filename(); /* // FIXME: Why do we have more code append_extension = checkbox.get_active(); prefs_set_int_attribute("dialogs.save_as", "append_extension", append_extension); prefs_set_string_attribute("dialogs.save_as", "default", ( extension != NULL ? extension->get_id() : "" )); */ return TRUE; } else { return FALSE; } } /** * Get the file extension type that was selected by the user. Valid after an [OK] */ Inkscape::Extension::Extension * FileSaveDialogImpl::getSelectionType() { return extension; } /** * Get the file name chosen by the user. Valid after an [OK] */ gchar * FileSaveDialogImpl::getFilename() { return g_strdup(myFilename.c_str()); } /** \brief A quick function to turn a standard extension into a searchable pattern for the file dialogs \param pattern The patter that the extension should be written to \param in_file_extension The C string that represents the extension This function just goes through the string, and takes all characters and puts a [] so that both are searched and shown in the file dialog. This function edits the pattern string to make this happen. */ void FileDialogExtensionToPattern (Glib::ustring &pattern, gchar * in_file_extension) { Glib::ustring tmp(in_file_extension); for ( guint i = 0; i < tmp.length(); i++ ) { Glib::ustring::value_type ch = tmp.at(i); if ( Glib::Unicode::isalpha(ch) ) { pattern += '['; pattern += Glib::Unicode::toupper(ch); pattern += Glib::Unicode::tolower(ch); pattern += ']'; } else { pattern += ch; } } } } //namespace Dialogs } //namespace UI } //namespace Inkscape /* Local Variables: mode:c++ c-file-style:"stroustrup" c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +)) indent-tabs-mode:nil fill-column:99 End: */ // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4 :