static void
file_open_dialog_show (Gimp *gimp,
GtkWidget *parent,
const gchar *title,
GimpImage *image,
const gchar *uri,
gboolean open_as_layers)
{
GtkWidget *dialog;
dialog = gimp_dialog_factory_dialog_new (gimp_dialog_factory_get_singleton (),
gtk_widget_get_screen (parent),
NULL /*ui_manager*/,
"gimp-file-open-dialog", -1, FALSE);
if (dialog)
{
if (! uri && image)
uri = gimp_image_get_uri (image);
if (! uri)
uri = g_object_get_data (G_OBJECT (gimp), GIMP_FILE_OPEN_LAST_URI_KEY);
if (uri)
gtk_file_chooser_set_uri (GTK_FILE_CHOOSER (dialog), uri);
gimp_file_dialog_set_open_image (GIMP_FILE_DIALOG (dialog),
image, open_as_layers);
gtk_window_set_transient_for (GTK_WINDOW (dialog),
GTK_WINDOW (gtk_widget_get_toplevel (parent)));
gtk_window_present (GTK_WINDOW (dialog));
}
}
char *
go_gtk_select_image (GtkWindow *toplevel, const char *initial)
{
const char *key = "go_gtk_select_image";
char *uri = NULL;
GtkFileChooser *fsel;
g_return_val_if_fail (GTK_IS_WINDOW (toplevel), NULL);
fsel = gui_image_chooser_new (FALSE);
if (!initial)
initial = g_object_get_data (G_OBJECT (toplevel), key);
if (initial)
gtk_file_chooser_set_uri (fsel, initial);
g_object_set (G_OBJECT (fsel), "title", _("Select an Image"), NULL);
/* Show file selector */
if (go_gtk_file_sel_dialog (toplevel, GTK_WIDGET (fsel))) {
uri = gtk_file_chooser_get_uri (fsel);
g_object_set_data_full (G_OBJECT (toplevel),
key, g_strdup (uri),
g_free);
}
gtk_widget_destroy (GTK_WIDGET (fsel));
return uri;
}
static char * select_file (bool_t save, const char * default_filename)
{
GtkWidget * dialog = gtk_file_chooser_dialog_new (save ?
_("Export Playlist") : _("Import Playlist"), NULL, save ?
GTK_FILE_CHOOSER_ACTION_SAVE : GTK_FILE_CHOOSER_ACTION_OPEN, NULL, NULL);
if (default_filename)
gtk_file_chooser_set_uri ((GtkFileChooser *) dialog, default_filename);
gtk_dialog_add_button ((GtkDialog *) dialog, GTK_STOCK_CANCEL,
GTK_RESPONSE_REJECT);
gtk_dialog_add_button ((GtkDialog *) dialog, save ? GTK_STOCK_SAVE :
GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT);
gtk_dialog_set_default_response ((GtkDialog *) dialog, GTK_RESPONSE_ACCEPT);
char * path = aud_get_string ("audgui", "playlist_path");
if (path[0])
gtk_file_chooser_set_current_folder_uri ((GtkFileChooser *) dialog, path);
g_free (path);
char * filename = NULL;
if (gtk_dialog_run ((GtkDialog *) dialog) == GTK_RESPONSE_ACCEPT)
filename = gtk_file_chooser_get_uri ((GtkFileChooser *) dialog);
path = gtk_file_chooser_get_current_folder_uri ((GtkFileChooser *) dialog);
aud_set_string ("audgui", "playlist_path", path);
g_free (path);
gtk_widget_destroy (dialog);
return filename;
}
Php::Value GtkFileChooserDialog_::set_uri(Php::Parameters ¶meters)
{
std::string s_uri = parameters[0];
gchar *uri = (gchar *)s_uri.c_str();
gboolean ret = gtk_file_chooser_set_uri (GTK_FILE_CHOOSER(instance), uri);
return ret;
}
/*
* "Save as" dialog.
*/
void
gtr_save_file_as_dialog (GtkAction * action, GtrWindow * window)
{
GtkWidget *dialog = NULL;
GtrTab *current_page;
GtrPo *po;
GFile *location;
gchar *uri = NULL;
if (dialog != NULL)
{
gtk_window_present (GTK_WINDOW (dialog));
return;
}
current_page = gtr_window_get_active_tab (window);
po = gtr_tab_get_po (current_page);
dialog = gtr_file_chooser_new (GTK_WINDOW (window),
FILESEL_SAVE,
_("Save file as..."),
_gtr_application_get_last_dir (GTR_APP));
gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dialog),
TRUE);
g_signal_connect (dialog,
"confirm-overwrite",
G_CALLBACK (confirm_overwrite_callback), NULL);
gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
/*Set the suggested file */
location = gtr_po_get_location (po);
uri = g_file_get_uri (location);
g_object_unref (location);
if (uri)
gtk_file_chooser_set_uri (GTK_FILE_CHOOSER (dialog), uri);
g_free (uri);
/*
* FIXME: If we can't set the uri we should add a default path and name
*/
g_object_set_data (G_OBJECT (dialog), GTR_TAB_SAVE_AS, current_page);
g_signal_connect (dialog,
"response", G_CALLBACK (save_dialog_response_cb), window);
gtk_widget_show (GTK_WIDGET (dialog));
}
static void
edit_plugin_item_to_widgets (PluginEditorDialog *dlg, GnomeUIInfo *gui)
{
GttPlugin *plg;
if (!gui) return;
plg = gui->user_data;
gtk_entry_set_text (dlg->plugin_name, plg->name);
gtk_file_chooser_set_uri (dlg->plugin_path, plg->path);
gtk_entry_set_text (dlg->plugin_tooltip, plg->tooltip);
}
unsigned int gui_add_uris(GSList *uris, enum gui_view_e view)
{
g_assert(uris);
GSList *readable = NULL;
unsigned int readable_len = 0;
{
GSList *tmp = uris;
do {
char *error = g_strdup(_("Unknown error"));
if (!gui_can_add_uri(tmp->data, &error)) {
GtkWidget *dialog = gtk_message_dialog_new(NULL,
GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE,
_("Failed to add \"%s\":\n%s"), (char *)tmp->data, error);
g_free(error);
gtk_window_set_title(GTK_WINDOW(dialog), PACKAGE_NAME);
gtk_dialog_run(GTK_DIALOG(dialog));
gtk_widget_destroy(dialog);
continue;
}
if (!g_slist_find_custom(readable, tmp->data,
(GCompareFunc)g_strcmp0))
{
readable = g_slist_prepend(readable, tmp->data);
readable_len++;
}
} while ((tmp = tmp->next));
}
readable = g_slist_reverse(readable);
if (view == GUI_VIEW_INVALID) {
if (readable_len == 1)
view = GUI_VIEW_FILE;
else if (readable_len > 1)
view = GUI_VIEW_FILE_LIST;
}
if (readable_len && (view == GUI_VIEW_FILE)) {
gtk_file_chooser_set_uri(GTK_FILE_CHOOSER(gui.filechooserbutton),
readable->data);
} else if (readable_len && (view == GUI_VIEW_FILE_LIST)) {
GSList *tmp = readable;
do {
list_append_row(tmp->data);
} while ((tmp = tmp->next));
}
g_slist_free(readable);
return readable_len;
}
static void
panel_properties_dialog_image_changed (GSettings *settings,
char *key,
PanelPropertiesDialog *dialog)
{
char *uri = g_settings_get_string (dialog->priv->settings_background,
PANEL_BACKGROUND_IMAGE_KEY);
if (!uri) {
gtk_file_chooser_unselect_all (GTK_FILE_CHOOSER (dialog->priv->filechooser_button));
} else {
gtk_file_chooser_set_uri (GTK_FILE_CHOOSER (dialog->priv->filechooser_button), uri);
}
g_free (uri);
}
static void
panel_properties_dialog_background_image_update (PanelPropertiesDialog *dialog)
{
char *uri;
uri = g_settings_get_string (dialog->settings_background,
PANEL_BACKGROUND_IMAGE_URI_KEY);
if (PANEL_GLIB_STR_EMPTY (uri))
gtk_file_chooser_unselect_all (GTK_FILE_CHOOSER (dialog->image_chooser));
else
gtk_file_chooser_set_uri (GTK_FILE_CHOOSER (dialog->image_chooser),
uri);
g_free (uri);
}
/* A function that is called when the button for browsing for file
* locations was clicked */
static void
choose_file_call (GtkWidget *browse_button,
gpointer file_entry)
{
GFile *file = g_file_new_for_path (gtk_entry_get_text (GTK_ENTRY (file_entry)));
gtk_file_chooser_set_uri (GTK_FILE_CHOOSER (file_choose), g_file_get_uri (file));
if (gtk_dialog_run (GTK_DIALOG (file_choose)) == GTK_RESPONSE_OK)
{
file = gtk_file_chooser_get_file (GTK_FILE_CHOOSER (file_choose));
gtk_entry_set_text (GTK_ENTRY (file_entry), g_file_get_path (file));
};
file_name = g_file_get_path (file);
gtk_widget_hide (file_choose);
}
/* Fills the widgets with audio alarm data */
static void
alarm_to_aalarm_widgets (Dialog *dialog, ECalComponentAlarm *alarm)
{
const char *url;
icalattach *attach;
e_cal_component_alarm_get_attach (alarm, (&attach));
url = icalattach_get_url (attach);
icalattach_unref (attach);
if ( !(url && *url) )
return;
e_dialog_toggle_set (dialog->aalarm_sound, TRUE);
gtk_file_chooser_set_uri (
GTK_FILE_CHOOSER (dialog->aalarm_file_chooser), url);
}
int
clip_GTK_FILECHOOSERSETURI(ClipMachine * ClipMachineMemory)
{
C_object *cchooser = _fetch_co_arg(ClipMachineMemory);
gchar *uri = _clip_parc(ClipMachineMemory, 2);
CHECKCOBJ(cchooser, GTK_IS_FILE_CHOOSER(cchooser->object));
CHECKARG(2, CHARACTER_type_of_ClipVarType);
LOCALE_TO_UTF(uri);
gtk_file_chooser_set_uri(GTK_FILE_CHOOSER(cchooser->object), uri);
FREE_TEXT(uri);
return 0;
err:
return 1;
}
static void create_selector (ImportExportJob * job, const char * filename, const char * folder)
{
const char * title, * verb, * icon;
GtkFileChooserAction action;
if (job->save)
{
title = _("Export Playlist");
verb = _("Export");
icon = "document-save";
action = GTK_FILE_CHOOSER_ACTION_SAVE;
}
else
{
title = _("Import Playlist");
verb = _("Import");
icon = "document-open";
action = GTK_FILE_CHOOSER_ACTION_OPEN;
}
job->selector = gtk_file_chooser_dialog_new (title, NULL, action, NULL, NULL);
if (filename)
gtk_file_chooser_set_uri ((GtkFileChooser *) job->selector, filename);
else if (folder)
gtk_file_chooser_set_current_folder_uri ((GtkFileChooser *) job->selector, folder);
GtkWidget * button1 = audgui_button_new (verb, icon, check_overwrite, job);
GtkWidget * button2 = audgui_button_new (_("Cancel"), "process-stop",
(AudguiCallback) gtk_widget_destroy, job->selector);
gtk_dialog_add_action_widget ((GtkDialog *) job->selector, button2, GTK_RESPONSE_NONE);
gtk_dialog_add_action_widget ((GtkDialog *) job->selector, button1, GTK_RESPONSE_NONE);
gtk_widget_set_can_default (button1, TRUE);
gtk_widget_grab_default (button1);
g_signal_connect_swapped (job->selector, "destroy", (GCallback) cleanup_job, job);
gtk_widget_show_all (job->selector);
}
JNIEXPORT jboolean JNICALL
Java_org_gnome_gtk_GtkFileChooser_gtk_1file_1chooser_1set_1uri
(
JNIEnv* env,
jclass cls,
jlong _self,
jstring _uri
)
{
gboolean result;
jboolean _result;
GtkFileChooser* self;
const char* uri;
// convert parameter self
self = (GtkFileChooser*) _self;
// convert parameter uri
uri = (const char*) bindings_java_getString(env, _uri);
if (uri == NULL) {
return JNI_FALSE; // Java Exception already thrown
}
// call function
result = gtk_file_chooser_set_uri(self, uri);
// cleanup parameter self
// cleanup parameter uri
bindings_java_releaseString(uri);
// translate return value to JNI type
_result = (jboolean) result;
// and finally
return _result;
}
void on_save_as1_activate(GtkWidget *widget)
{
GtkWidget *file_selection_box;
gchar *filename;
const gchar *last_opened_folder;
if (document_manager_get_current_document(main_window.docmg)) {
// Create the selector widget
file_selection_box = gtk_file_chooser_dialog_new (_("Please type the filename to save as..."),
GTK_WINDOW(main_window.window), GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT, NULL);
gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER(file_selection_box), FALSE);
gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER(file_selection_box), TRUE);
gtk_dialog_set_default_response (GTK_DIALOG(file_selection_box), GTK_RESPONSE_ACCEPT);
if (document_manager_get_current_document(main_window.docmg)) { //FIXME: rework this code
filename = document_get_filename(document_manager_get_current_document(main_window.docmg));
if (!document_get_untitled(document_manager_get_current_document(main_window.docmg))) {
gtk_file_chooser_set_uri(GTK_FILE_CHOOSER(file_selection_box), filename);
}
else {
last_opened_folder = get_preferences_manager_last_opened_folder(main_window.prefmg);
gphpedit_debug_message(DEBUG_MAIN_WINDOW,"last_opened_folder: %s", last_opened_folder);
if (last_opened_folder) {
gphpedit_debug_message(DEBUG_MAIN_WINDOW,"Setting current_folder_uri to %s", last_opened_folder);
gtk_file_chooser_set_current_folder_uri(GTK_FILE_CHOOSER(file_selection_box), last_opened_folder);
}
}
g_free(filename);
}
if (gtk_dialog_run (GTK_DIALOG(file_selection_box)) == GTK_RESPONSE_ACCEPT) {
save_file_as_ok(GTK_FILE_CHOOSER(file_selection_box));
}
gtk_widget_destroy(file_selection_box);
}
}
void
dlg_media_viewer_preferences (GtkWindow *parent)
{
DialogData *data;
char *uri;
data = g_new0 (DialogData, 1);
data->builder = _gtk_builder_new_from_file ("media-viewer-preferences.ui", "gstreamer_tools");
data->settings = g_settings_new (GTHUMB_GSTREAMER_TOOLS_SCHEMA);
/* Get the widgets. */
data->dialog = _gtk_builder_get_widget (data->builder, "preferences_dialog");
/* Set widgets data. */
uri = _g_settings_get_uri_or_special_dir (data->settings, PREF_GSTREAMER_TOOLS_SCREESHOT_LOCATION, G_USER_DIRECTORY_PICTURES);
gtk_file_chooser_set_uri (GTK_FILE_CHOOSER (gtk_builder_get_object (data->builder, "screenshots_filechooserbutton")), uri);
g_free (uri);
/* Set the signals handlers. */
g_signal_connect (G_OBJECT (data->dialog),
"destroy",
G_CALLBACK (destroy_cb),
data);
g_signal_connect_swapped (gtk_builder_get_object (data->builder, "close_button"),
"clicked",
G_CALLBACK (gtk_widget_destroy),
G_OBJECT (data->dialog));
/* run dialog. */
gtk_window_set_transient_for (GTK_WINDOW (data->dialog), parent);
gtk_window_set_modal (GTK_WINDOW (data->dialog), TRUE);
gtk_widget_show (data->dialog);
}
static void
file_open_dialog_show (GtkWidget *parent,
GimpImage *image,
const gchar *uri,
gboolean open_as_layers)
{
GtkWidget *dialog;
dialog = gimp_dialog_factory_dialog_new (global_dialog_factory,
gtk_widget_get_screen (parent),
"gimp-file-open-dialog", -1, FALSE);
if (dialog)
{
if (uri)
gtk_file_chooser_set_uri (GTK_FILE_CHOOSER (dialog), uri);
if (open_as_layers)
{
gtk_window_set_title (GTK_WINDOW (dialog), _("Open Image as Layers"));
GIMP_FILE_DIALOG (dialog)->image = image;
}
else
{
gtk_window_set_title (GTK_WINDOW (dialog), _("Open Image"));
GIMP_FILE_DIALOG (dialog)->image = NULL;
}
parent = gtk_widget_get_toplevel (parent);
if (GTK_IS_WINDOW (parent))
gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (parent));
gtk_window_present (GTK_WINDOW (dialog));
}
}
static void
html_editor_image_dialog_show (GtkWidget *widget)
{
EHTMLEditorImageDialog *dialog;
EHTMLEditor *editor;
EHTMLEditorSelection *selection;
EHTMLEditorView *view;
WebKitDOMElement *link;
gchar *tmp;
glong val;
dialog = E_HTML_EDITOR_IMAGE_DIALOG (widget);
if (!dialog->priv->image) {
return;
}
editor = e_html_editor_dialog_get_editor (E_HTML_EDITOR_DIALOG (dialog));
view = e_html_editor_get_view (editor);
selection = e_html_editor_view_get_selection (view);
if (!e_html_editor_view_is_undo_redo_in_progress (view)) {
EHTMLEditorViewHistoryEvent *ev;
ev = g_new0 (EHTMLEditorViewHistoryEvent, 1);
ev->type = HISTORY_IMAGE_DIALOG;
e_html_editor_selection_get_selection_coordinates (
selection, &ev->before.start.x, &ev->before.start.y, &ev->before.end.x, &ev->before.end.y);
ev->data.dom.from = webkit_dom_node_clone_node (
WEBKIT_DOM_NODE (dialog->priv->image), FALSE);
dialog->priv->history_event = ev;
}
tmp = webkit_dom_element_get_attribute (
WEBKIT_DOM_ELEMENT (dialog->priv->image), "data-uri");
if (tmp && *tmp) {
gtk_file_chooser_set_uri (
GTK_FILE_CHOOSER (dialog->priv->file_chooser), tmp);
gtk_widget_set_sensitive (
GTK_WIDGET (dialog->priv->file_chooser), TRUE);
} else {
gtk_file_chooser_set_uri (
GTK_FILE_CHOOSER (dialog->priv->file_chooser), "");
gtk_widget_set_sensitive (
GTK_WIDGET (dialog->priv->file_chooser), FALSE);
}
g_free (tmp);
tmp = webkit_dom_html_image_element_get_alt (dialog->priv->image);
gtk_entry_set_text (GTK_ENTRY (dialog->priv->description_edit), tmp ? tmp : "");
g_free (tmp);
val = webkit_dom_html_image_element_get_width (dialog->priv->image);
gtk_spin_button_set_value (
GTK_SPIN_BUTTON (dialog->priv->width_edit), val);
gtk_combo_box_set_active_id (
GTK_COMBO_BOX (dialog->priv->width_units), "units-px");
val = webkit_dom_html_image_element_get_height (dialog->priv->image);
gtk_spin_button_set_value (
GTK_SPIN_BUTTON (dialog->priv->height_edit), val);
gtk_combo_box_set_active_id (
GTK_COMBO_BOX (dialog->priv->height_units), "units-px");
tmp = webkit_dom_html_image_element_get_border (dialog->priv->image);
gtk_combo_box_set_active_id (
GTK_COMBO_BOX (dialog->priv->alignment),
(tmp && *tmp) ? tmp : "bottom");
g_free (tmp);
val = webkit_dom_html_image_element_get_hspace (dialog->priv->image);
gtk_spin_button_set_value (
GTK_SPIN_BUTTON (dialog->priv->x_padding_edit), val);
val = webkit_dom_html_image_element_get_vspace (dialog->priv->image);
gtk_spin_button_set_value (
GTK_SPIN_BUTTON (dialog->priv->y_padding_edit), val);
link = e_html_editor_dom_node_find_parent_element (
WEBKIT_DOM_NODE (dialog->priv->image), "A");
if (link) {
tmp = webkit_dom_html_anchor_element_get_href (
WEBKIT_DOM_HTML_ANCHOR_ELEMENT (link));
gtk_entry_set_text (GTK_ENTRY (dialog->priv->url_edit), tmp);
g_free (tmp);
}
/* Chain up to parent implementation */
GTK_WIDGET_CLASS (e_html_editor_image_dialog_parent_class)->show (widget);
}
char *
gui_get_image_save_info (GtkWindow *toplevel, GSList *supported_formats,
GOImageFormat *ret_format, double *resolution)
{
GOImageFormat format;
GOImageFormatInfo const *format_info;
GtkComboBox *format_combo = NULL;
GtkFileChooser *fsel = gui_image_chooser_new (TRUE);
GtkWidget *expander = NULL;
GtkWidget *resolution_spin = NULL;
GtkWidget *resolution_table;
GladeXML *gui;
SaveInfoState *state;
const char *key = "gui_get_image_save_info";
char *uri = NULL;
state = g_object_get_data (G_OBJECT (toplevel), key);
if (state == NULL) {
state = g_new (SaveInfoState, 1);
g_return_val_if_fail (state != NULL, NULL);
state->uri = NULL;
state->resolution = 150.0;
state->is_expanded = FALSE;
state->format = GO_IMAGE_FORMAT_SVG;
g_object_set_data_full (G_OBJECT (toplevel), key,
state, (GDestroyNotify) save_info_state_free);
}
g_object_set (G_OBJECT (fsel), "title", _("Save as"), NULL);
gui = go_libglade_new ("go-image-save-dialog-extra.glade",
"image_save_dialog_extra",
GETTEXT_PACKAGE, NULL);
if (gui != NULL) {
GtkWidget *widget;
/* Format selection UI */
if (supported_formats != NULL && ret_format != NULL) {
int i;
GSList *l;
format_combo = GTK_COMBO_BOX (glade_xml_get_widget (gui, "format_combo"));
for (l = supported_formats, i = 0; l != NULL; l = l->next, i++) {
format = GPOINTER_TO_UINT (l->data);
format_info = go_image_get_format_info (format);
gtk_combo_box_append_text (format_combo, _(format_info->desc));
if (format == state->format)
gtk_combo_box_set_active (format_combo, i);
}
if (gtk_combo_box_get_active (format_combo) < 0)
gtk_combo_box_set_active (format_combo, 0);
} else {
widget = glade_xml_get_widget (gui, "file_type_box");
gtk_widget_hide (widget);
}
/* Export setting expander */
expander = glade_xml_get_widget (gui, "export_expander");
if (resolution != NULL) {
gtk_expander_set_expanded (GTK_EXPANDER (expander), state->is_expanded);
resolution_spin = glade_xml_get_widget (gui, "resolution_spin");
gtk_spin_button_set_value (GTK_SPIN_BUTTON (resolution_spin), state->resolution);
} else
gtk_widget_hide (expander);
if (resolution != NULL && supported_formats != NULL && ret_format != NULL) {
widget = glade_xml_get_widget (gui, "image_save_dialog_extra");
gtk_file_chooser_set_extra_widget (fsel, widget);
resolution_table = glade_xml_get_widget (gui, "resolution_table");
cb_format_combo_changed (format_combo, resolution_table);
g_signal_connect (GTK_WIDGET (format_combo), "changed",
G_CALLBACK (cb_format_combo_changed), resolution_table);
}
g_object_unref (G_OBJECT (gui));
}
if (state->uri != NULL) {
gtk_file_chooser_set_uri (fsel, state->uri);
gtk_file_chooser_unselect_all (fsel);
}
/* Show file selector */
loop:
if (!go_gtk_file_sel_dialog (toplevel, GTK_WIDGET (fsel)))
goto out;
uri = gtk_file_chooser_get_uri (fsel);
if (format_combo) {
char *new_uri = NULL;
format = GPOINTER_TO_UINT (g_slist_nth_data
(supported_formats,
gtk_combo_box_get_active (format_combo)));
format_info = go_image_get_format_info (format);
if (!go_url_check_extension (uri, format_info->ext, &new_uri) &&
!go_gtk_query_yes_no (GTK_WINDOW (fsel), TRUE,
_("The given file extension does not match the"
" chosen file type. Do you want to use this name"
" anyway?"))) {
g_free (new_uri);
g_free (uri);
uri = NULL;
goto out;
} else {
g_free (uri);
uri = new_uri;
}
*ret_format = format;
}
if (!go_gtk_url_is_writeable (GTK_WINDOW (fsel), uri, TRUE)) {
g_free (uri);
uri = NULL;
goto loop;
}
out:
if (uri != NULL) {
g_free (state->uri);
state->uri = g_strdup (uri);
state->format = *ret_format;
if (resolution != NULL) {
state->is_expanded = gtk_expander_get_expanded (GTK_EXPANDER (expander));
*resolution = gtk_spin_button_get_value (GTK_SPIN_BUTTON (resolution_spin));
state->resolution = *resolution;
}
}
gtk_widget_destroy (GTK_WIDGET (fsel));
return uri;
}
static void * file_configure (void)
{
GtkWidget * configure_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
GtkWidget * fileext_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
gtk_box_pack_start(GTK_BOX(configure_vbox), fileext_hbox, FALSE, FALSE, 0);
GtkWidget * fileext_label = gtk_label_new (_("Output file format:"));
gtk_box_pack_start(GTK_BOX(fileext_hbox), fileext_label, FALSE, FALSE, 0);
fileext_combo = gtk_combo_box_text_new ();
gtk_combo_box_text_append_text ((GtkComboBoxText *) fileext_combo, "WAV");
#ifdef FILEWRITER_MP3
gtk_combo_box_text_append_text ((GtkComboBoxText *) fileext_combo, "MP3");
#endif
#ifdef FILEWRITER_VORBIS
gtk_combo_box_text_append_text ((GtkComboBoxText *) fileext_combo, "Vorbis");
#endif
#ifdef FILEWRITER_FLAC
gtk_combo_box_text_append_text ((GtkComboBoxText *) fileext_combo, "FLAC");
#endif
gtk_box_pack_start(GTK_BOX(fileext_hbox), fileext_combo, FALSE, FALSE, 0);
gtk_combo_box_set_active(GTK_COMBO_BOX(fileext_combo), fileext);
plugin_button = gtk_button_new_with_label(_("Configure"));
gtk_widget_set_sensitive(plugin_button, plugin->configure != NULL);
gtk_box_pack_end(GTK_BOX(fileext_hbox), plugin_button, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(configure_vbox), gtk_separator_new(GTK_ORIENTATION_HORIZONTAL), FALSE, FALSE, 0);
GtkWidget * saveplace_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
gtk_container_add(GTK_CONTAINER(configure_vbox), saveplace_hbox);
GtkWidget * saveplace1 = gtk_radio_button_new_with_label (NULL,
_("Save into original directory"));
gtk_box_pack_start ((GtkBox *) saveplace_hbox, saveplace1, FALSE, FALSE, 0);
GtkWidget * saveplace2 = gtk_radio_button_new_with_label_from_widget
((GtkRadioButton *) saveplace1, _("Save into custom directory"));
if (!save_original)
gtk_toggle_button_set_active ((GtkToggleButton *) saveplace2, TRUE);
gtk_box_pack_start ((GtkBox *) saveplace_hbox, saveplace2, FALSE, FALSE, 0);
path_hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5);
gtk_box_pack_start(GTK_BOX(configure_vbox), path_hbox, FALSE, FALSE, 0);
GtkWidget * path_label = gtk_label_new (_("Output file folder:"));
gtk_box_pack_start ((GtkBox *) path_hbox, path_label, FALSE, FALSE, 0);
path_dirbrowser =
gtk_file_chooser_button_new (_("Pick a folder"),
GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER);
gtk_file_chooser_set_uri ((GtkFileChooser *) path_dirbrowser, file_path);
gtk_box_pack_start(GTK_BOX(path_hbox), path_dirbrowser, TRUE, TRUE, 0);
if (save_original)
gtk_widget_set_sensitive(path_hbox, FALSE);
gtk_box_pack_start(GTK_BOX(configure_vbox), gtk_separator_new(GTK_ORIENTATION_HORIZONTAL), FALSE, FALSE, 0);
filenamefrom_hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5);
gtk_container_add(GTK_CONTAINER(configure_vbox), filenamefrom_hbox);
filenamefrom_label = gtk_label_new(_("Get filename from:"));
gtk_box_pack_start(GTK_BOX(filenamefrom_hbox), filenamefrom_label, FALSE, FALSE, 0);
GtkWidget * filenamefrom_toggle1 = gtk_radio_button_new_with_label
(NULL, _("original file tags"));
gtk_box_pack_start ((GtkBox *) filenamefrom_hbox, filenamefrom_toggle1, FALSE, FALSE, 0);
GtkWidget * filenamefrom_toggle2 =
gtk_radio_button_new_with_label_from_widget
((GtkRadioButton *) filenamefrom_toggle1, _("original filename"));
gtk_box_pack_start ((GtkBox *) filenamefrom_hbox, filenamefrom_toggle2, FALSE, FALSE, 0);
if (!filenamefromtags)
gtk_toggle_button_set_active ((GtkToggleButton *) filenamefrom_toggle2, TRUE);
use_suffix_toggle = gtk_check_button_new_with_label(_("Don't strip file name extension"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(use_suffix_toggle), use_suffix);
gtk_box_pack_start(GTK_BOX(configure_vbox), use_suffix_toggle, FALSE, FALSE, 0);
if (filenamefromtags)
gtk_widget_set_sensitive(use_suffix_toggle, FALSE);
gtk_box_pack_start(GTK_BOX(configure_vbox), gtk_separator_new(GTK_ORIENTATION_HORIZONTAL), FALSE, FALSE, 0);
prependnumber_toggle = gtk_check_button_new_with_label(_("Prepend track number to filename"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(prependnumber_toggle), prependnumber);
gtk_box_pack_start(GTK_BOX(configure_vbox), prependnumber_toggle, FALSE, FALSE, 0);
g_signal_connect (fileext_combo, "changed", (GCallback) fileext_cb, NULL);
g_signal_connect (plugin_button, "clicked", (GCallback) plugin_configure_cb, NULL);
g_signal_connect (saveplace1, "toggled", (GCallback) saveplace_original_cb, NULL);
g_signal_connect (saveplace2, "toggled", (GCallback) saveplace_custom_cb, NULL);
g_signal_connect (filenamefrom_toggle1, "toggled", (GCallback) filenamefromtags_cb, NULL);
g_signal_connect (filenamefrom_toggle2, "toggled",
(GCallback) filenamefromfilename_cb, NULL);
return configure_vbox;
}
static void file_configure(void)
{
if (!configure_win)
{
configure_win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_type_hint(GTK_WINDOW(configure_win), GDK_WINDOW_TYPE_HINT_DIALOG);
g_signal_connect (configure_win, "destroy", (GCallback)
configure_destroy, NULL);
g_signal_connect (configure_win, "destroy", (GCallback)
gtk_widget_destroyed, & configure_win);
gtk_window_set_title(GTK_WINDOW(configure_win),
_("File Writer Configuration"));
gtk_window_set_position(GTK_WINDOW(configure_win), GTK_WIN_POS_MOUSE);
gtk_container_set_border_width(GTK_CONTAINER(configure_win), 10);
configure_vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 10);
gtk_container_add(GTK_CONTAINER(configure_win), configure_vbox);
fileext_hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5);
gtk_box_pack_start(GTK_BOX(configure_vbox), fileext_hbox, FALSE, FALSE, 0);
fileext_label = gtk_label_new(_("Output file format:"));
gtk_box_pack_start(GTK_BOX(fileext_hbox), fileext_label, FALSE, FALSE, 0);
fileext_combo = gtk_combo_box_text_new ();
gtk_combo_box_text_append_text ((GtkComboBoxText *) fileext_combo, "WAV");
#ifdef FILEWRITER_MP3
gtk_combo_box_text_append_text ((GtkComboBoxText *) fileext_combo, "MP3");
#endif
#ifdef FILEWRITER_VORBIS
gtk_combo_box_text_append_text ((GtkComboBoxText *) fileext_combo, "Vorbis");
#endif
#ifdef FILEWRITER_FLAC
gtk_combo_box_text_append_text ((GtkComboBoxText *) fileext_combo, "FLAC");
#endif
gtk_box_pack_start(GTK_BOX(fileext_hbox), fileext_combo, FALSE, FALSE, 0);
gtk_combo_box_set_active(GTK_COMBO_BOX(fileext_combo), fileext);
g_signal_connect(G_OBJECT(fileext_combo), "changed", G_CALLBACK(fileext_cb), NULL);
plugin_button = gtk_button_new_with_label(_("Configure"));
gtk_widget_set_sensitive(plugin_button, plugin->configure != NULL);
g_signal_connect(G_OBJECT(plugin_button), "clicked", G_CALLBACK(plugin_configure_cb), NULL);
gtk_box_pack_end(GTK_BOX(fileext_hbox), plugin_button, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(configure_vbox), gtk_separator_new(GTK_ORIENTATION_HORIZONTAL), FALSE, FALSE, 0);
saveplace_hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5);
gtk_container_add(GTK_CONTAINER(configure_vbox), saveplace_hbox);
saveplace = gtk_radio_button_new_with_label(NULL, _("Save into original directory"));
g_signal_connect(G_OBJECT(saveplace), "toggled", G_CALLBACK(saveplace_original_cb), NULL);
gtk_box_pack_start(GTK_BOX(saveplace_hbox), saveplace, FALSE, FALSE, 0);
saveplace = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(saveplace),
_("Save into custom directory"));
if (!save_original)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(saveplace), TRUE);
g_signal_connect(G_OBJECT(saveplace), "toggled", G_CALLBACK(saveplace_custom_cb), NULL);
gtk_box_pack_start(GTK_BOX(saveplace_hbox), saveplace, FALSE, FALSE, 0);
path_hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5);
gtk_box_pack_start(GTK_BOX(configure_vbox), path_hbox, FALSE, FALSE, 0);
path_label = gtk_label_new(_("Output file folder:"));
gtk_box_pack_start(GTK_BOX(path_hbox), path_label, FALSE, FALSE, 0);
path_dirbrowser =
gtk_file_chooser_button_new (_("Pick a folder"),
GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER);
gtk_file_chooser_set_uri ((GtkFileChooser *) path_dirbrowser, file_path);
gtk_box_pack_start(GTK_BOX(path_hbox), path_dirbrowser, TRUE, TRUE, 0);
if (save_original)
gtk_widget_set_sensitive(path_hbox, FALSE);
gtk_box_pack_start(GTK_BOX(configure_vbox), gtk_separator_new(GTK_ORIENTATION_HORIZONTAL), FALSE, FALSE, 0);
filenamefrom_hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5);
gtk_container_add(GTK_CONTAINER(configure_vbox), filenamefrom_hbox);
filenamefrom_label = gtk_label_new(_("Get filename from:"));
gtk_box_pack_start(GTK_BOX(filenamefrom_hbox), filenamefrom_label, FALSE, FALSE, 0);
filenamefrom_toggle = gtk_radio_button_new_with_label(NULL, _("original file tags"));
g_signal_connect(G_OBJECT(filenamefrom_toggle), "toggled", G_CALLBACK(filenamefromtags_cb), NULL);
gtk_box_pack_start(GTK_BOX(filenamefrom_hbox), filenamefrom_toggle, FALSE, FALSE, 0);
filenamefrom_toggle =
gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(filenamefrom_toggle),
_("original filename"));
g_signal_connect(G_OBJECT(filenamefrom_toggle), "toggled", G_CALLBACK(filenamefromfilename_cb), NULL);
gtk_box_pack_start(GTK_BOX(filenamefrom_hbox), filenamefrom_toggle, FALSE, FALSE, 0);
if (!filenamefromtags)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(filenamefrom_toggle), TRUE);
use_suffix_toggle = gtk_check_button_new_with_label(_("Don't strip file name extension"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(use_suffix_toggle), use_suffix);
gtk_box_pack_start(GTK_BOX(configure_vbox), use_suffix_toggle, FALSE, FALSE, 0);
if (filenamefromtags)
gtk_widget_set_sensitive(use_suffix_toggle, FALSE);
gtk_box_pack_start(GTK_BOX(configure_vbox), gtk_separator_new(GTK_ORIENTATION_HORIZONTAL), FALSE, FALSE, 0);
prependnumber_toggle = gtk_check_button_new_with_label(_("Prepend track number to filename"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(prependnumber_toggle), prependnumber);
gtk_box_pack_start(GTK_BOX(configure_vbox), prependnumber_toggle, FALSE, FALSE, 0);
configure_bbox = gtk_button_box_new(GTK_ORIENTATION_HORIZONTAL);
gtk_button_box_set_layout(GTK_BUTTON_BOX(configure_bbox),
GTK_BUTTONBOX_END);
gtk_box_pack_start(GTK_BOX(configure_vbox), configure_bbox,
FALSE, FALSE, 0);
configure_cancel = gtk_button_new_from_stock(GTK_STOCK_CANCEL);
g_signal_connect_swapped (configure_cancel, "clicked", (GCallback)
gtk_widget_destroy, configure_win);
gtk_box_pack_start(GTK_BOX(configure_bbox), configure_cancel,
TRUE, TRUE, 0);
configure_ok = gtk_button_new_from_stock(GTK_STOCK_OK);
g_signal_connect (configure_ok, "clicked", (GCallback) configure_ok_cb,
NULL);
gtk_box_pack_start(GTK_BOX(configure_bbox), configure_ok,
TRUE, TRUE, 0);
gtk_widget_show_all(configure_win);
}
}
void
dlg_web_exporter (GthBrowser *browser,
GList *file_list)
{
DialogData *data;
int i;
int active_index;
char *default_sort_type;
GList *sort_types;
GList *scan;
char *caption;
char *s_value;
if (gth_browser_get_dialog (browser, "web_exporter") != NULL) {
gtk_window_present (GTK_WINDOW (gth_browser_get_dialog (browser, "web_exporter")));
return;
}
data = g_new0 (DialogData, 1);
data->browser = browser;
data->file_list = _g_object_list_ref (file_list);
data->builder = _gtk_builder_new_from_file ("web-album-exporter.ui", "webalbums");
data->settings = g_settings_new (PIX_WEBALBUMS_SCHEMA);
data->dialog = _gtk_builder_get_widget (data->builder, "web_album_dialog");
gth_browser_set_dialog (browser, "web_exporter", data->dialog);
g_object_set_data (G_OBJECT (data->dialog), "dialog_data", data);
data->thumbnail_caption_chooser = gth_metadata_chooser_new (GTH_METADATA_ALLOW_IN_FILE_LIST);
gtk_widget_show (data->thumbnail_caption_chooser);
gtk_container_add (GTK_CONTAINER (GET_WIDGET ("thumbnail_caption_scrolledwindow")), data->thumbnail_caption_chooser);
data->image_attributes_chooser = gth_metadata_chooser_new (GTH_METADATA_ALLOW_IN_PROPERTIES_VIEW);
gtk_widget_show (data->image_attributes_chooser);
gtk_container_add (GTK_CONTAINER (GET_WIDGET ("image_caption_scrolledwindow")), data->image_attributes_chooser);
/* Set widgets data. */
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (GET_WIDGET ("copy_images_checkbutton")),
g_settings_get_boolean (data->settings, PREF_WEBALBUMS_COPY_IMAGES));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (GET_WIDGET ("resize_images_checkbutton")),
g_settings_get_boolean (data->settings, PREF_WEBALBUMS_RESIZE_IMAGES));
gtk_spin_button_set_value (GTK_SPIN_BUTTON (GET_WIDGET ("images_per_index_spinbutton")), g_settings_get_int (data->settings, PREF_WEBALBUMS_IMAGES_PER_INDEX));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (GET_WIDGET ("single_index_checkbutton")),
g_settings_get_boolean (data->settings, PREF_WEBALBUMS_SINGLE_INDEX));
gtk_spin_button_set_value (GTK_SPIN_BUTTON (GET_WIDGET ("cols_spinbutton")),
g_settings_get_int (data->settings, PREF_WEBALBUMS_COLUMNS));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (GET_WIDGET ("adapt_column_checkbutton")),
g_settings_get_boolean (data->settings, PREF_WEBALBUMS_ADAPT_TO_WIDTH));
_gtk_combo_box_add_image_sizes (GTK_COMBO_BOX (GET_WIDGET ("resize_images_combobox")),
g_settings_get_int (data->settings, PREF_WEBALBUMS_RESIZE_WIDTH),
g_settings_get_int (data->settings, PREF_WEBALBUMS_RESIZE_HEIGHT));
default_sort_type = g_settings_get_string (data->settings, PREF_WEBALBUMS_SORT_TYPE);
active_index = 0;
sort_types = gth_main_get_all_sort_types ();
for (i = 0, scan = sort_types; scan; scan = scan->next, i++) {
GthFileDataSort *sort_type = scan->data;
GtkTreeIter iter;
if (g_str_equal (sort_type->name, default_sort_type))
active_index = i;
gtk_list_store_append (GTK_LIST_STORE (GET_WIDGET ("sort_liststore")), &iter);
gtk_list_store_set (GTK_LIST_STORE (GET_WIDGET ("sort_liststore")), &iter,
SORT_TYPE_COLUMN_DATA, sort_type,
SORT_TYPE_COLUMN_NAME, _(sort_type->display_name),
-1);
}
g_list_free (sort_types);
gtk_combo_box_set_active (GTK_COMBO_BOX (GET_WIDGET ("sort_combobox")), active_index);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (GET_WIDGET ("reverse_order_checkbutton")), g_settings_get_boolean (data->settings, PREF_WEBALBUMS_SORT_INVERSE));
g_free (default_sort_type);
gtk_entry_set_text (GTK_ENTRY (GET_WIDGET ("header_entry")),
g_file_info_get_edit_name (gth_browser_get_location_data (browser)->info));
s_value = g_settings_get_string (data->settings, PREF_WEBALBUMS_FOOTER);
gtk_entry_set_text (GTK_ENTRY (GET_WIDGET ("footer_entry")), s_value);
g_free (s_value);
s_value = g_settings_get_string (data->settings, PREF_WEBALBUMS_IMAGE_PAGE_FOOTER);
gtk_entry_set_text (GTK_ENTRY (GET_WIDGET ("image_page_footer_entry")), s_value);
g_free (s_value);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (GET_WIDGET ("thumbnail_caption_checkbutton")), g_settings_get_boolean (data->settings, PREF_WEBALBUMS_ENABLE_THUMBNAIL_CAPTION));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (GET_WIDGET ("image_description_checkbutton")), g_settings_get_boolean (data->settings, PREF_WEBALBUMS_ENABLE_IMAGE_DESCRIPTION));
caption = g_settings_get_string (data->settings, PREF_WEBALBUMS_THUMBNAIL_CAPTION);
gth_metadata_chooser_set_selection (GTH_METADATA_CHOOSER (data->thumbnail_caption_chooser), caption);
g_free (caption);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (GET_WIDGET ("image_attributes_checkbutton")), g_settings_get_boolean (data->settings, PREF_WEBALBUMS_ENABLE_IMAGE_ATTRIBUTES));
caption = g_settings_get_string (data->settings, PREF_WEBALBUMS_IMAGE_ATTRIBUTES);
gth_metadata_chooser_set_selection (GTH_METADATA_CHOOSER (data->image_attributes_chooser), caption);
g_free (caption);
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (GET_WIDGET ("theme_liststore")),
THEME_COLUMN_NAME,
GTK_SORT_ASCENDING);
load_themes (data);
update_sensitivity (data);
{
char *destination;
destination = _g_settings_get_uri (data->settings, PREF_WEBALBUMS_DESTINATION);
if (destination == NULL)
destination = g_strdup (get_home_uri ());
gtk_file_chooser_set_uri (GTK_FILE_CHOOSER (GET_WIDGET ("destination_filechooserbutton")), destination);
g_free (destination);
}
/* Set the signals handlers. */
g_signal_connect (G_OBJECT (data->dialog),
"destroy",
G_CALLBACK (destroy_cb),
data);
g_signal_connect (GET_WIDGET ("ok_button"),
"clicked",
G_CALLBACK (ok_clicked_cb),
data);
g_signal_connect (GET_WIDGET ("help_button"),
"clicked",
G_CALLBACK (help_clicked_cb),
data);
g_signal_connect_swapped (GET_WIDGET ("cancel_button"),
"clicked",
G_CALLBACK (gtk_widget_destroy),
data->dialog);
g_signal_connect_swapped (GET_WIDGET ("copy_images_checkbutton"),
"clicked",
G_CALLBACK (update_sensitivity),
data);
g_signal_connect_swapped (GET_WIDGET ("resize_images_checkbutton"),
"clicked",
G_CALLBACK (update_sensitivity),
data);
g_signal_connect (GET_WIDGET ("header_entry"),
"icon-press",
G_CALLBACK (footer_entry_icon_press_cb),
data);
g_signal_connect (GET_WIDGET ("footer_entry"),
"icon-press",
G_CALLBACK (footer_entry_icon_press_cb),
data);
g_signal_connect (GET_WIDGET ("image_page_header_entry"),
"icon-press",
G_CALLBACK (footer_entry_icon_press_cb),
data);
g_signal_connect (GET_WIDGET ("image_page_footer_entry"),
"icon-press",
G_CALLBACK (footer_entry_icon_press_cb),
data);
g_signal_connect_swapped (GET_WIDGET ("single_index_checkbutton"),
"toggled",
G_CALLBACK (update_sensitivity),
data);
g_signal_connect_swapped (GET_WIDGET ("adapt_column_checkbutton"),
"toggled",
G_CALLBACK (update_sensitivity),
data);
g_signal_connect_swapped (GET_WIDGET ("image_attributes_checkbutton"),
"toggled",
G_CALLBACK (update_sensitivity),
data);
g_signal_connect_swapped (GET_WIDGET ("thumbnail_caption_checkbutton"),
"toggled",
G_CALLBACK (update_sensitivity),
data);
/* Run dialog. */
gtk_window_set_transient_for (GTK_WINDOW (data->dialog), GTK_WINDOW (browser));
gtk_window_set_modal (GTK_WINDOW (data->dialog), FALSE);
gtk_widget_show (data->dialog);
}
static void
copy_to_folder_dialog (GthBrowser *browser,
GList *files,
gboolean move)
{
GSettings *settings;
GtkWidget *dialog;
char *start_uri;
GList *history;
GList *scan;
GtkWidget *box;
GtkWidget *view_destination_button;
settings = g_settings_new (GTHUMB_FILE_MANAGER_SCHEMA);
dialog = gtk_file_chooser_dialog_new (move ? _("Move To") : _("Copy To"),
GTK_WINDOW (browser),
GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,
_GTK_LABEL_CANCEL, GTK_RESPONSE_CANCEL,
(move ? _("Move") : _("Copy")), GTK_RESPONSE_ACCEPT,
NULL);
_gtk_dialog_add_class_to_response (GTK_DIALOG (dialog), GTK_RESPONSE_ACCEPT, GTK_STYLE_CLASS_SUGGESTED_ACTION);
start_uri = g_settings_get_string (settings, PREF_FILE_MANAGER_COPY_LAST_FOLDER);
if ((start_uri == NULL) || (strcmp (start_uri, "") == 0)) {
g_free (start_uri);
start_uri = g_strdup (get_home_uri ());
}
gtk_file_chooser_set_uri (GTK_FILE_CHOOSER (dialog), start_uri);
g_free(start_uri);
history = _g_settings_get_string_list (settings, PREF_FILE_MANAGER_COPY_HISTORY);
for (scan = history; scan; scan = scan->next) {
char *uri = scan->data;
gtk_file_chooser_add_shortcut_folder_uri (GTK_FILE_CHOOSER (dialog), uri, NULL);
}
box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_container_set_border_width (GTK_CONTAINER (box), 6);
gtk_widget_show (box);
view_destination_button = gtk_check_button_new_with_mnemonic (_("_View the destination"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (view_destination_button),
g_settings_get_boolean (settings, PREF_FILE_MANAGER_COPY_VIEW_DESTINATION));
gtk_widget_show (view_destination_button);
gtk_box_pack_start (GTK_BOX (box), view_destination_button, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), box, FALSE, FALSE, 0);
if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT) {
char *destination_uri;
destination_uri = gtk_file_chooser_get_uri (GTK_FILE_CHOOSER (dialog));
if (destination_uri != NULL) {
gboolean view_destination;
/* save the options */
view_destination = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (view_destination_button));
g_settings_set_boolean (settings, PREF_FILE_MANAGER_COPY_VIEW_DESTINATION, view_destination);
g_settings_set_string (settings, PREF_FILE_MANAGER_COPY_LAST_FOLDER, destination_uri);
/* save the destination in the history list, prevent
* the list from growing without limit. */
history = g_list_prepend (history, g_strdup (destination_uri));
while (g_list_length (history) > MAX_HISTORY_LENGTH) {
GList *link = g_list_last (history);
history = g_list_remove_link (history, link);
_g_string_list_free (link);
}
_g_settings_set_string_list (settings, PREF_FILE_MANAGER_COPY_HISTORY, history);
/* copy / move the files */
copy_files_to_folder (browser, files, move, destination_uri, view_destination);
}
g_free (destination_uri);
}
_g_string_list_free (history);
gtk_widget_destroy (dialog);
g_object_unref (settings);
}
static gboolean
verify_start (SeahorseToolMode *mode, const gchar *uri, gpgme_data_t uridata,
SeahorsePGPOperation *pop, GError **err)
{
gpgme_data_t plain;
gpgme_error_t gerr;
gchar *original, *unesc_uri;
/* File to decrypt to */
original = seahorse_util_remove_suffix (uri, NULL);
/* The original file doesn't exist, prompt for it */
if (!seahorse_util_uri_exists (original)) {
GtkWidget *dialog;
gchar *t;
unesc_uri = g_uri_unescape_string (seahorse_util_uri_get_last (uri), NULL);
t = g_strdup_printf (_("Choose Original File for '%s'"),
unesc_uri);
dialog = gtk_file_chooser_dialog_new (t,
NULL, GTK_FILE_CHOOSER_ACTION_OPEN,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
NULL);
g_free (unesc_uri);
g_free (t);
gtk_file_chooser_set_uri (GTK_FILE_CHOOSER (dialog), original);
gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (dialog), FALSE);
g_free (original);
original = NULL;
seahorse_tool_progress_block (TRUE);
if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT)
original = gtk_file_chooser_get_uri (GTK_FILE_CHOOSER (dialog));
seahorse_tool_progress_block (FALSE);
gtk_widget_destroy (dialog);
}
if (!original)
return FALSE;
g_object_set_data_full (G_OBJECT (pop), "original-file", original, g_free);
/* Open necessary files, release with operation */
plain = seahorse_vfs_data_create (original, SEAHORSE_VFS_READ, err);
if (!plain)
return FALSE;
g_object_set_data_full (G_OBJECT (pop), "plain-data", plain,
(GDestroyNotify)gpgme_data_release);
/* Start actual verify */
gerr = gpgme_op_verify_start (pop->gctx, uridata, plain, NULL);
if (gerr != 0) {
seahorse_util_gpgme_to_error (gerr, err);
return FALSE;
}
return TRUE;
}
void XAP_UnixDialog_FileOpenSaveAs::runModal(XAP_Frame * pFrame)
{
const XAP_StringSet * pSS = m_pApp->getStringSet();
std::string szTitle;
std::string szFileTypeLabel;
switch (m_id)
{
case XAP_DIALOG_ID_INSERT_PICTURE:
{
pSS->getValueUTF8(XAP_STRING_ID_DLG_IP_Title, szTitle);
pSS->getValueUTF8(XAP_STRING_ID_DLG_FOSA_FileOpenTypeLabel, szFileTypeLabel);
m_bSave = false;
break;
}
case XAP_DIALOG_ID_FILE_OPEN:
{
pSS->getValueUTF8(XAP_STRING_ID_DLG_FOSA_OpenTitle,szTitle);
pSS->getValueUTF8(XAP_STRING_ID_DLG_FOSA_FileOpenTypeLabel,szFileTypeLabel);
m_bSave = false;
break;
}
case XAP_DIALOG_ID_FILE_IMPORT:
{
pSS->getValueUTF8(XAP_STRING_ID_DLG_FOSA_ImportTitle,szTitle);
pSS->getValueUTF8(XAP_STRING_ID_DLG_FOSA_FileOpenTypeLabel,szFileTypeLabel);
m_bSave = false;
break;
}
case XAP_DIALOG_ID_INSERTMATHML:
{
pSS->getValueUTF8(XAP_STRING_ID_DLG_FOSA_InsertMath,szTitle);
pSS->getValueUTF8(XAP_STRING_ID_DLG_FOSA_FileInsertMath,szFileTypeLabel);
m_bSave = false;
break;
}
case XAP_DIALOG_ID_INSERTOBJECT:
{
pSS->getValueUTF8(XAP_STRING_ID_DLG_FOSA_InsertObject,szTitle);
pSS->getValueUTF8(XAP_STRING_ID_DLG_FOSA_FileInsertObject,szFileTypeLabel);
m_bSave = false;
break;
}
case XAP_DIALOG_ID_INSERT_FILE:
{
pSS->getValueUTF8(XAP_STRING_ID_DLG_FOSA_InsertTitle,szTitle);
pSS->getValueUTF8(XAP_STRING_ID_DLG_FOSA_FileOpenTypeLabel,szFileTypeLabel);
m_bSave = false;
break;
}
case XAP_DIALOG_ID_FILE_SAVEAS:
case XAP_DIALOG_ID_FILE_SAVE_IMAGE:
{
pSS->getValueUTF8(XAP_STRING_ID_DLG_FOSA_SaveAsTitle,szTitle);
pSS->getValueUTF8(XAP_STRING_ID_DLG_FOSA_FileSaveTypeLabel,szFileTypeLabel);
m_bSave = true;
break;
}
case XAP_DIALOG_ID_FILE_EXPORT:
{
pSS->getValueUTF8(XAP_STRING_ID_DLG_FOSA_ExportTitle,szTitle);
pSS->getValueUTF8(XAP_STRING_ID_DLG_FOSA_FileSaveTypeLabel,szFileTypeLabel);
m_bSave = true;
break;
}
case XAP_DIALOG_ID_PRINTTOFILE:
{
pSS->getValueUTF8(XAP_STRING_ID_DLG_FOSA_PrintToFileTitle,szTitle);
pSS->getValueUTF8(XAP_STRING_ID_DLG_FOSA_FilePrintTypeLabel,szFileTypeLabel);
m_bSave = true;
break;
}
case XAP_DIALOG_ID_RECORDTOFILE:
{
pSS->getValueUTF8(XAP_STRING_ID_DLG_FOSA_RecordToFileTitle,szTitle);
pSS->getValueUTF8(XAP_STRING_ID_DLG_FOSA_RecordToFileLabel,szFileTypeLabel);
m_bSave = true;
break;
}
case XAP_DIALOG_ID_REPLAYFROMFILE:
{
pSS->getValueUTF8(XAP_STRING_ID_DLG_FOSA_ReplayFromFileTitle,szTitle);
pSS->getValueUTF8(XAP_STRING_ID_DLG_FOSA_ReplayFromFileLabel,szFileTypeLabel);
m_bSave = false;
break;
}
default:
UT_ASSERT(UT_SHOULD_NOT_HAPPEN);
m_bSave = false;
break;
}
// NOTE: we use our string mechanism to localize the dialog's
// NOTE: title and the error/confirmation message boxes. we
// NOTE: let GTK take care of the localization of the actual
// NOTE: buttons and labels on the FileSelection dialog.
// Get the GtkWindow of the parent frame
XAP_UnixFrameImpl * pUnixFrameImpl = static_cast<XAP_UnixFrameImpl *>(pFrame->getFrameImpl());
GtkWidget * parent = pUnixFrameImpl->getTopLevelWindow();
if(parent && (GTK_WIDGET_TOPLEVEL(parent) != TRUE))
{
parent = gtk_widget_get_toplevel (parent);
}
#if defined(EMBEDDED_TARGET) && EMBEDDED_TARGET == EMBEDDED_TARGET_HILDON
m_FC = GTK_FILE_CHOOSER( hildon_file_chooser_dialog_new(GTK_WINDOW(parent),
(!m_bSave ? GTK_FILE_CHOOSER_ACTION_OPEN : GTK_FILE_CHOOSER_ACTION_SAVE))
);
#else
m_FC = GTK_FILE_CHOOSER( gtk_file_chooser_dialog_new (szTitle.c_str(),
GTK_WINDOW(parent),
(!m_bSave ? GTK_FILE_CHOOSER_ACTION_OPEN : GTK_FILE_CHOOSER_ACTION_SAVE),
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
(m_bSave ? GTK_STOCK_SAVE : GTK_STOCK_OPEN), GTK_RESPONSE_ACCEPT,
(gchar*)NULL)
);
#endif
gtk_file_chooser_set_local_only(m_FC, FALSE);
abiSetupModalDialog(GTK_DIALOG(m_FC), pFrame, this, GTK_RESPONSE_ACCEPT);
GtkWidget * filetypes_pulldown = NULL;
std::string s;
/*
Add a drop-down list of known types to facilitate a file-types selection.
We store an indexer in the user data for each menu item in the popup, so
we can read the type we need to return.
*/
if (m_id == XAP_DIALOG_ID_INSERT_PICTURE)
{
GtkWidget * preview = createDrawingArea ();
gtk_widget_show (preview);
m_preview = preview;
gtk_widget_set_size_request (preview, PREVIEW_WIDTH, PREVIEW_HEIGHT);
// place the preview area inside a container to get a nice border
GtkWidget * preview_hbox = gtk_hbox_new(FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER(preview_hbox), 4);
gtk_box_pack_start(GTK_BOX(preview_hbox), preview, TRUE, TRUE, 0);
// attach the preview area to the dialog
gtk_file_chooser_set_preview_widget (m_FC, preview_hbox);
gtk_file_chooser_set_preview_widget_active (m_FC, true);
// connect some signals
g_signal_connect (m_FC, "update_preview",
G_CALLBACK (file_selection_changed), static_cast<gpointer>(this));
g_signal_connect (preview, "expose_event",
G_CALLBACK (s_preview_exposed), static_cast<gpointer>(this));
}
#if defined(EMBEDDED_TARGET) && EMBEDDED_TARGET == EMBEDDED_TARGET_HILDON
filetypes_pulldown = gtk_combo_box_new();
gtk_widget_show(filetypes_pulldown);
GtkWidget * pulldown_hbox = filetypes_pulldown;
#else
// hbox for our pulldown menu (GTK does its pulldown this way */
GtkWidget * pulldown_hbox = gtk_hbox_new(FALSE, 15);
gtk_widget_show(pulldown_hbox);
// pulldown label
GtkWidget * filetypes_label = gtk_label_new_with_mnemonic(convertMnemonics(szFileTypeLabel).c_str());
gtk_label_set_justify(GTK_LABEL(filetypes_label), GTK_JUSTIFY_RIGHT);
gtk_misc_set_alignment(GTK_MISC(filetypes_label), 1.0, 0.5);
gtk_widget_show(filetypes_label);
gtk_box_pack_start(GTK_BOX(pulldown_hbox), filetypes_label, TRUE, TRUE, 0);
// pulldown menu
filetypes_pulldown = gtk_combo_box_new();
gtk_widget_show(filetypes_pulldown);
gtk_box_pack_end(GTK_BOX(pulldown_hbox), filetypes_pulldown, TRUE, TRUE, 0);
gtk_label_set_mnemonic_widget(GTK_LABEL(filetypes_label), filetypes_pulldown);
#endif
//
// add the filters to the dropdown list
//
GtkComboBox* combo = GTK_COMBO_BOX(filetypes_pulldown);
XAP_makeGtkComboBoxText(combo, G_TYPE_INT);
// Auto-detect is always an option, but a special one, so we use
// a pre-defined constant for the type, and don't use the user-supplied
// types yet.
pSS->getValueUTF8(XAP_STRING_ID_DLG_FOSA_FileTypeAutoDetect,s);
XAP_appendComboBoxTextAndInt(combo, s.c_str(), XAP_DIALOG_FILEOPENSAVEAS_FILE_TYPE_AUTO);
UT_sint32 activeItemIndex = -1;
// add list items
{
UT_ASSERT(g_strv_length((gchar **) m_szSuffixes) == g_strv_length((gchar **) m_szDescriptions));
// measure one list, they should all be the same length
UT_uint32 end = g_strv_length((gchar **) m_szDescriptions);
for (UT_uint32 i = 0; i < end; i++)
{
// If this type is default, save its index (i) for later use
if (m_nTypeList[i] == m_nDefaultFileType)
activeItemIndex = i;
XAP_appendComboBoxTextAndInt(combo, m_szDescriptions[i], m_nTypeList[i]);
//
// Attach a callback when it is activated to change the file suffix
//
// g_signal_connect(G_OBJECT(thismenuitem), "activate",
// G_CALLBACK(s_filetypechanged),
// reinterpret_cast<gpointer>(this));
}
}
m_wFileTypes_PullDown = filetypes_pulldown;
// dialog; open dialog always does auto-detect
// TODO: should this also apply to the open dialog?
if (m_id == XAP_DIALOG_ID_FILE_SAVEAS || m_id == XAP_DIALOG_ID_FILE_SAVE_IMAGE)
{
gtk_combo_box_set_active(combo, activeItemIndex + 1);
}
else
{
gtk_combo_box_set_active(combo, 0);
}
#if defined(EMBEDDED_TARGET) && EMBEDDED_TARGET == EMBEDDED_TARGET_HILDON
hildon_file_chooser_dialog_add_extra ((HildonFileChooserDialog*)m_FC,
pulldown_hbox);
#else
gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER(m_FC), pulldown_hbox);
#endif
// connect the signals for OK and CANCEL and the requisite clean-close signals
g_signal_connect(G_OBJECT(m_FC),
"delete-event",
G_CALLBACK(s_delete_clicked),
this);
g_signal_connect(G_OBJECT(m_FC),
"key_press_event",
G_CALLBACK(fsel_key_event), &m_answer);
g_signal_connect (G_OBJECT (m_FC),
"response",
G_CALLBACK(dialog_response), &m_answer);
g_signal_connect (G_OBJECT (m_FC),
"file-activated",
G_CALLBACK(s_file_activated), &m_answer);
g_signal_connect(G_OBJECT(filetypes_pulldown), "changed",
G_CALLBACK(s_filetypechanged),
reinterpret_cast<gpointer>(this));
// use the persistence info and/or the suggested filename
// to properly seed the dialog.
gchar * szPersistDirectory = NULL; // we must g_free this
if (!m_szInitialPathname || !*m_szInitialPathname)
{
// the caller did not supply initial pathname
// (or supplied an empty one). see if we have
// some persistent info.
UT_ASSERT(!m_bSuggestName);
if (m_szPersistPathname)
{
// we have a pathname from a previous use,
// extract the directory portion and start
// the dialog there (but without a filename).
szPersistDirectory = UT_go_dirname_from_uri(m_szPersistPathname, FALSE);
gtk_file_chooser_set_current_folder_uri(m_FC, szPersistDirectory);
}
else
{
// no initial pathname given and we don't have
// a pathname from a previous use, so just let
// it come up in the current working directory.
}
}
else
{
// we have an initial pathname (the name of the document
// in the frame that we were invoked on). if the caller
// wanted us to suggest a filename, use the initial
// pathname as is. if not, use the directory portion of
// it.
if (m_bSuggestName)
{
xxx_UT_DEBUGMSG(("Iniitial filename is %s \n",m_szInitialPathname));
#if 0
if (!g_path_is_absolute (m_szInitialPathname)) { // DAL: todo: is this correct?
gchar *dir = g_get_current_dir ();
gchar *file = m_szInitialPathname;
gchar *filename = g_build_filename (dir, file, (gchar *)NULL);
m_szInitialPathname = UT_go_filename_to_uri(filename);
g_free(filename);
g_free (dir);
g_free (file);
}
#endif
if(m_id == XAP_DIALOG_ID_FILE_SAVEAS)
{
std::string szInitialSuffix = UT_pathSuffix(m_szInitialPathname);
std::string szSaveTypeSuffix = IE_Exp::preferredSuffixForFileType(m_nDefaultFileType).utf8_str();
if(!szInitialSuffix.empty() && !szSaveTypeSuffix.empty()
&& (szSaveTypeSuffix != szInitialSuffix))
{
std::string sFileName = m_szInitialPathname;
std::string::size_type i = sFileName.find_last_of('.');
if(i != std::string::npos)
{
// erase to the end()
sFileName.erase(i);
sFileName += szSaveTypeSuffix;
FREEP(m_szInitialPathname);
m_szInitialPathname = g_strdup(sFileName.c_str());
}
}
}
if (UT_go_path_is_uri(m_szInitialPathname) || UT_go_path_is_path(m_szInitialPathname))
{
gtk_file_chooser_set_uri(m_FC, m_szInitialPathname);
}
}
else
{
if (UT_go_path_is_uri(m_szInitialPathname) || UT_go_path_is_path(m_szInitialPathname))
{
szPersistDirectory = UT_go_dirname_from_uri(m_szInitialPathname, FALSE);
gtk_file_chooser_set_current_folder_uri(m_FC, szPersistDirectory);
}
else
{
// we are dealing with a plain filename, not an URI or path, so
// just let it come up in the current working directory.
}
}
}
// center the dialog
xxx_UT_DEBUGMSG(("before center IS WIDGET_TOP_LEVL %d \n",(GTK_WIDGET_TOPLEVEL(parent))));
xxx_UT_DEBUGMSG(("before center IS WIDGET WINDOW %d \n",(GTK_IS_WINDOW(parent))));
centerDialog(parent, GTK_WIDGET(m_FC));
xxx_UT_DEBUGMSG(("After center IS WIDGET WINDOW %d \n",(GTK_IS_WINDOW(parent))));
gtk_widget_show(GTK_WIDGET(m_FC));
gtk_grab_add(GTK_WIDGET(m_FC));
bool bResult = _run_gtk_main(pFrame,filetypes_pulldown);
if (bResult)
{
UT_ASSERT(m_szFinalPathnameCandidate);
// store final path name and file type
m_szFinalPathname = g_strdup(m_szFinalPathnameCandidate);
FREEP(m_szFinalPathnameCandidate);
// what a long ugly line of code
m_nFileType = XAP_comboBoxGetActiveInt(GTK_COMBO_BOX(filetypes_pulldown));
}
if (m_FC != NULL) {
gtk_grab_remove (GTK_WIDGET(m_FC));
gtk_widget_destroy (GTK_WIDGET(m_FC));
m_FC = NULL;
FREEP(szPersistDirectory);
}
return;
}
static void
gimp_file_dialog_proc_changed (GimpFileProcView *view,
GimpFileDialog *dialog)
{
GtkFileChooser *chooser = GTK_FILE_CHOOSER (dialog);
gchar *name;
dialog->file_proc = gimp_file_proc_view_get_proc (view, &name);
if (name)
{
gchar *label = g_strdup_printf (_("Select File _Type (%s)"), name);
gtk_expander_set_label (GTK_EXPANDER (dialog->proc_expander), label);
g_free (label);
g_free (name);
}
if (gtk_file_chooser_get_action (chooser) == GTK_FILE_CHOOSER_ACTION_SAVE)
{
GimpPlugInProcedure *proc = dialog->file_proc;
if (proc && proc->extensions_list)
{
gchar *uri = gtk_file_chooser_get_uri (chooser);
if (uri && strlen (uri))
{
const gchar *last_dot = strrchr (uri, '.');
/* if the dot is before the last slash, ignore it */
if (last_dot && strrchr (uri, '/') > last_dot)
last_dot = NULL;
/* check if the uri has a "meta extension" (e.g. foo.bar.gz)
* and try to truncate both extensions away.
*/
if (last_dot && last_dot != uri)
{
GList *list;
for (list = view->meta_extensions;
list;
list = g_list_next (list))
{
const gchar *ext = list->data;
if (! strcmp (ext, last_dot + 1))
{
const gchar *p = last_dot - 1;
while (p > uri && *p != '.')
p--;
if (p != uri && *p == '.')
{
last_dot = p;
break;
}
}
}
}
if (last_dot != uri)
{
GString *s = g_string_new (uri);
gchar *basename;
if (last_dot)
g_string_truncate (s, last_dot - uri);
g_string_append (s, ".");
g_string_append (s, (gchar *) proc->extensions_list->data);
gtk_file_chooser_set_uri (chooser, s->str);
basename = file_utils_uri_display_basename (s->str);
gtk_file_chooser_set_current_name (chooser, basename);
g_free (basename);
g_string_free (s, TRUE);
}
}
g_free (uri);
}
}
}
gboolean
anjuta_docman_save_document_as (AnjutaDocman *docman, IAnjutaDocument *doc,
GtkWidget *parent_window)
{
gchar* uri;
GFile* file;
const gchar* filename;
GtkWidget *parent;
GtkWidget *dialog;
gint response;
gboolean file_saved = TRUE;
g_return_val_if_fail (ANJUTA_IS_DOCMAN (docman), FALSE);
g_return_val_if_fail (IANJUTA_IS_DOCUMENT (doc), FALSE);
if (parent_window)
{
parent = parent_window;
}
else
{
parent = gtk_widget_get_toplevel (GTK_WIDGET (docman));
}
dialog = create_file_save_dialog_gui (GTK_WINDOW (parent), docman);
if ((file = ianjuta_file_get_file (IANJUTA_FILE (doc), NULL)) != NULL)
{
gchar* file_uri = g_file_get_uri (file);
gtk_file_chooser_set_uri (GTK_FILE_CHOOSER (dialog), file_uri);
g_free (file_uri);
g_object_unref (file);
}
else if ((filename = ianjuta_document_get_filename (doc, NULL)) != NULL)
gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (dialog), filename);
else
gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (dialog), "");
response = gtk_dialog_run (GTK_DIALOG (dialog));
if (response != GTK_RESPONSE_ACCEPT)
{
gtk_widget_destroy (dialog);
return FALSE;
}
uri = gtk_file_chooser_get_uri(GTK_FILE_CHOOSER(dialog));
file = g_file_new_for_uri (uri);
if (g_file_query_exists (file, NULL))
{
GtkWidget *msg_dialog;
gchar* parse_uri = g_file_get_parse_name (file);
msg_dialog = gtk_message_dialog_new (GTK_WINDOW (dialog),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_QUESTION,
GTK_BUTTONS_NONE,
_("The file '%s' already exists.\n"
"Do you want to replace it with the"
" one you are saving?"),
parse_uri);
g_free (parse_uri);
gtk_dialog_add_button (GTK_DIALOG (msg_dialog),
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL);
anjuta_util_dialog_add_button (GTK_DIALOG (msg_dialog),
_("_Replace"),
GTK_STOCK_REFRESH,
GTK_RESPONSE_YES);
if (gtk_dialog_run (GTK_DIALOG (msg_dialog)) == GTK_RESPONSE_YES)
ianjuta_file_savable_save_as (IANJUTA_FILE_SAVABLE (doc), file,
NULL);
else
file_saved = FALSE;
gtk_widget_destroy (msg_dialog);
}
else
{
ianjuta_file_savable_save_as (IANJUTA_FILE_SAVABLE (doc), file, NULL);
}
if (g_settings_get_boolean (docman->priv->settings,
EDITOR_TABS_ORDERING))
anjuta_docman_order_tabs (docman);
gtk_widget_destroy (dialog);
g_free (uri);
if (file_saved)
{
/* Update mime icons */
AnjutaDocmanPage* page = anjuta_docman_get_page_for_document (docman, doc);
GdkPixbuf* pixbuf = anjuta_docman_get_pixbuf_for_file (file);
if (pixbuf)
{
gtk_image_set_from_pixbuf (GTK_IMAGE(page->menu_icon), pixbuf);
gtk_image_set_from_pixbuf (GTK_IMAGE(page->mime_icon), pixbuf);
g_object_unref (pixbuf);
}
}
g_object_unref (file);
return file_saved;
}
