dallasgroot/Gimp
dallasgroot/Gimp
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

save the number of layers in the thumbnail and show it in the description.

Browse source 
2002-04-18  Michael Natterer  <mitch@gimp.org>

	* app/core/gimpimagefile.[ch]: save the number of layers in the
	thumbnail and show it in the description.

	* app/gui/file-dialog-utils.[ch]: added file_dialog_new() which
	contains a lot of factored out code from file-open and file-save.

	* app/gui/file-open-dialog.c
	* app/gui/file-save-dialog.c: use file_dialog_new(), reduce use of
	global variables, added utility functions to reduce code
	duplication, cleanup.

	* app/gui/file-open-dialog.c: use a temporary imagefile to create
	previews so the dialog's preview can show the progress when
	creating many thumbnails.

2002-04-18  Michael Natterer  <mitch@gimp.org>

	* POTFILES.in: added app/gui/file-dialog-utils.c
This commit is contained in:
Michael Natterer 2002-04-18 01:18:24 +00:00 committed by Michael Natterer
parent c811d2bb94
commit 31c19e8d1f
13 changed files with 893 additions and 825 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

17
ChangeLog
View file

@ -1,3 +1,20 @@
2002-04-18 Michael Natterer <mitch@gimp.org>
* app/core/gimpimagefile.[ch]: save the number of layers in the
thumbnail and show it in the description.
* app/gui/file-dialog-utils.[ch]: added file_dialog_new() which
contains a lot of factored out code from file-open and file-save.
* app/gui/file-open-dialog.c
* app/gui/file-save-dialog.c: use file_dialog_new(), reduce use of
global variables, added utility functions to reduce code
duplication, cleanup.
* app/gui/file-open-dialog.c: use a temporary imagefile to create
previews so the dialog's preview can show the progress when
creating many thumbnails.
2002-04-17 Michael Natterer <mitch@gimp.org>
* app/file/file-save.c: shouldn't free the filename before using it :)

63
app/core/gimpimagefile.c
View file

@ -63,6 +63,7 @@
#define TAG_THUMB_IMAGE_WIDTH "tEXt::Thumb::Image::Width"
#define TAG_THUMB_IMAGE_HEIGHT "tEXt::Thumb::Image::Height"
#define TAG_THUMB_GIMP_TYPE "tEXt::Thumb::X-GIMP::Type"
#define TAG_THUMB_GIMP_LAYERS "tEXt::Thumb::X-GIMP::Layers"
enum
@ -93,7 +94,8 @@ static void gimp_imagefile_set_info (GimpImagefile *imagefile,
gint width,
gint height,
gint size,
GimpImageType type);
GimpImageType type,
gint n_layers);
static TempBuf * gimp_imagefile_get_new_preview (GimpViewable *viewable,
gint width,
gint height);
@ -188,6 +190,7 @@ gimp_imagefile_init (GimpImagefile *imagefile)
imagefile->height = -1;
imagefile->size = -1;
imagefile->type = -1;
imagefile->n_layers = -1;
imagefile->description = NULL;
imagefile->image_state = GIMP_IMAGEFILE_STATE_UNKNOWN;
imagefile->image_mtime = 0;
@ -372,6 +375,7 @@ gimp_imagefile_create_thumbnail (GimpImagefile *imagefile)
gchar *w_str;
gchar *h_str;
gchar *s_str;
gchar *l_str;
GError *error = NULL;
type = GIMP_IMAGE_TYPE_FROM_BASE_TYPE (gimp_image_base_type (gimage));
@ -387,6 +391,7 @@ gimp_imagefile_create_thumbnail (GimpImagefile *imagefile)
w_str = g_strdup_printf ("%d", gimage->width);
h_str = g_strdup_printf ("%d", gimage->height);
s_str = g_strdup_printf ("%ld", size);
l_str = g_strdup_printf ("%d", gimage->layers->num_children);
if (! gdk_pixbuf_save (pixbuf, thumb_name, "png", &error,
TAG_DESCRIPTION, desc,
@ -397,6 +402,7 @@ gimp_imagefile_create_thumbnail (GimpImagefile *imagefile)
TAG_THUMB_IMAGE_WIDTH, w_str,
TAG_THUMB_IMAGE_HEIGHT, h_str,
TAG_THUMB_GIMP_TYPE, type_str,
TAG_THUMB_GIMP_LAYERS, l_str,
NULL))
{
g_message (_("Couldn't write thumbnail for '%s'\nas '%s'.\n%s"),
@ -409,6 +415,7 @@ gimp_imagefile_create_thumbnail (GimpImagefile *imagefile)
g_free (w_str);
g_free (h_str);
g_free (s_str);
g_free (l_str);
}
g_object_unref (G_OBJECT (pixbuf));
@ -438,7 +445,7 @@ gimp_imagefile_name_changed (GimpObject *object)
imagefile->thumb_state = GIMP_IMAGEFILE_STATE_UNKNOWN;
imagefile->thumb_mtime = 0;
gimp_imagefile_set_info (imagefile, TRUE, -1, -1, -1, -1);
gimp_imagefile_set_info (imagefile, TRUE, -1, -1, -1, -1, -1);
}
static void
@ -447,19 +454,22 @@ gimp_imagefile_set_info (GimpImagefile *imagefile,
gint width,
gint height,
gint size,
GimpImageType type)
GimpImageType type,
gint n_layers)
{
gboolean changed;
changed = (imagefile->width != width ||
imagefile->height != height ||
imagefile->size != size ||
imagefile->type != type);
changed = (imagefile->width != width ||
imagefile->height != height ||
imagefile->size != size ||
imagefile->type != type ||
imagefile->n_layers != n_layers);
imagefile->width = width;
imagefile->height = height;
imagefile->size = size;
imagefile->type = type;
imagefile->width = width;
imagefile->height = height;
imagefile->size = size;
imagefile->type = type;
imagefile->n_layers = n_layers;
if (imagefile->description)
{
@ -482,6 +492,7 @@ gimp_imagefile_set_info_from_pixbuf (GimpImagefile *imagefile,
gint img_height = -1;
gint img_size = -1;
GimpImageType img_type = -1;
gint img_layers = -1;
option = gdk_pixbuf_get_option (pixbuf, TAG_THUMB_IMAGE_WIDTH);
if (!option || sscanf (option, "%d", &img_width) != 1)
@ -508,8 +519,13 @@ gimp_imagefile_set_info_from_pixbuf (GimpImagefile *imagefile,
img_type = enum_value->value;
}
option = gdk_pixbuf_get_option (pixbuf, TAG_THUMB_GIMP_LAYERS);
if (!option || sscanf (option, "%d", &img_layers) != 1)
img_size = -1;
gimp_imagefile_set_info (imagefile, FALSE,
img_width, img_height, img_size, img_type);
img_width, img_height, img_size,
img_type, img_layers);
}
static TempBuf *
@ -595,6 +611,27 @@ gimp_imagefile_get_description (GimpImagefile *imagefile)
g_free (size);
}
if (imagefile->n_layers > -1)
{
gchar *n_layers;
if (imagefile->n_layers == 1)
n_layers = g_strdup_printf (_("%d Layer"), imagefile->n_layers);
else
n_layers = g_strdup_printf (_("%d Layers"), imagefile->n_layers);
if (str->len)
{
if (imagefile->size > -1)
g_string_append_len (str, ", ", 2);
else
g_string_append_len (str, "\n", 1);
}
g_string_append (str, n_layers);
g_free (n_layers);
}
imagefile->static_desc = FALSE;
imagefile->description = g_string_free (str, FALSE);
}
@ -900,7 +937,7 @@ gimp_imagefile_read_xv_thumb (GimpImagefile *imagefile)
img_height = 0;
}
gimp_imagefile_set_info (imagefile, FALSE,
img_width, img_height, -1, -1);
img_width, img_height, -1, -1, -1);
g_free (image_info);
}

1
app/core/gimpimagefile.h
View file

@ -54,6 +54,7 @@ struct _GimpImagefile
gint height;
gssize size;
GimpImageType type;
gint n_layers;
GimpImagefileState image_state;
time_t image_mtime;

75
app/dialogs/file-dialog-utils.c
View file

@ -23,14 +23,89 @@
#include <gtk/gtk.h>
#include "libgimpwidgets/gimpwidgets.h"
#include "gui-types.h"
#include "core/gimp.h"
#include "plug-in/plug-in-proc.h"
#include "widgets/gimpitemfactory.h"
#include "file-dialog-utils.h"
#include "libgimp/gimpintl.h"
GtkWidget *
file_dialog_new (Gimp *gimp,
GimpItemFactory *item_factory,
const gchar *title,
const gchar *wmclass_name,
const gchar *help_data,
GCallback ok_callback)
{
GtkWidget *filesel;
GtkFileSelection *fs;
g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
g_return_val_if_fail (GIMP_IS_ITEM_FACTORY (item_factory), NULL);
g_return_val_if_fail (title != NULL, NULL);
g_return_val_if_fail (wmclass_name != NULL, NULL);
g_return_val_if_fail (help_data != NULL, NULL);
g_return_val_if_fail (ok_callback != NULL, NULL);
filesel = gtk_file_selection_new (title);
fs = GTK_FILE_SELECTION (filesel);
g_object_set_data (G_OBJECT (filesel), "gimp", gimp);
gtk_window_set_position (GTK_WINDOW (filesel), GTK_WIN_POS_MOUSE);
gtk_window_set_wmclass (GTK_WINDOW (filesel), wmclass_name, "Gimp");
gimp_help_connect (filesel, gimp_standard_help_func, help_data);
gtk_container_set_border_width (GTK_CONTAINER (fs->button_area), 2);
gtk_container_set_border_width (GTK_CONTAINER (filesel), 2);
g_signal_connect_swapped (G_OBJECT (fs->cancel_button), "clicked",
G_CALLBACK (file_dialog_hide),
filesel);
g_signal_connect (G_OBJECT (filesel), "delete_event",
G_CALLBACK (file_dialog_hide),
NULL);
g_signal_connect (G_OBJECT (fs->ok_button), "clicked",
G_CALLBACK (ok_callback),
filesel);
/* The file type menu */
{
GtkWidget *hbox;
GtkWidget *option_menu;
GtkWidget *label;
hbox = gtk_hbox_new (FALSE, 4);
option_menu = gtk_option_menu_new ();
gtk_box_pack_end (GTK_BOX (hbox), option_menu, FALSE, FALSE, 0);
gtk_widget_show (option_menu);
gtk_option_menu_set_menu (GTK_OPTION_MENU (option_menu),
GTK_ITEM_FACTORY (item_factory)->widget);
gtk_box_pack_end (GTK_BOX (fs->main_vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
label = gtk_label_new (_("Determine File Type:"));
gtk_box_pack_end (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
}
return filesel;
}
void
file_dialog_show (GtkWidget *filesel)

19
app/dialogs/file-dialog-utils.h
View file

@ -20,13 +20,20 @@
#define __FILE_DIALOG_UTILS_H__
void file_dialog_show (GtkWidget *filesel);
gboolean file_dialog_hide (GtkWidget *filesel);
GtkWidget * file_dialog_new (Gimp *gimp,
GimpItemFactory *item_factory,
const gchar *title,
const gchar *wmclass_name,
const gchar *help_data,
GCallback ok_callback);
void file_dialog_update_name (PlugInProcDef *proc,
GtkFileSelection *filesel);
void file_dialog_update_menus (GSList *procs,
GimpImageType image_type);
void file_dialog_show (GtkWidget *filesel);
gboolean file_dialog_hide (GtkWidget *filesel);
void file_dialog_update_name (PlugInProcDef *proc,
GtkFileSelection *filesel);
void file_dialog_update_menus (GSList *procs,
GimpImageType image_type);
#endif /* __FILE_DIALOG_UTILS_H__ */

386
app/dialogs/file-open-dialog.c
View file

@ -68,27 +68,30 @@
/* local function prototypes */
static void file_open_dialog_create (Gimp *gimp);
static void file_open_genbutton_callback (GtkWidget *widget,
gpointer data);
static void file_open_selchanged_callback (GtkTreeSelection *sel,
gpointer data);
static void file_open_ok_callback (GtkWidget *widget,
gpointer data);
static void file_open_type_callback (GtkWidget *widget,
gpointer data);
static void file_open_imagefile_info_changed (GimpImagefile *imagefile,
gpointer data);
static GtkWidget * file_open_dialog_create (Gimp *gimp);
static void file_open_type_callback (GtkWidget *widget,
gpointer data);
static void file_open_selchanged_callback (GtkTreeSelection *sel,
GtkWidget *open_dialog);
static void file_open_imagefile_info_changed (GimpImagefile *imagefile,
GtkLabel *label);
static void file_open_genbutton_callback (GtkWidget *widget,
GtkWidget *open_dialog);
static void file_open_ok_callback (GtkWidget *widget,
GtkWidget *open_dialog);
static void file_open_dialog_open_image (GtkWidget *open_dialog,
Gimp *gimp,
const gchar *uri,
const gchar *entered_filename,
PlugInProcDef *load_proc);
static GtkWidget *fileload = NULL;
static GtkWidget *open_options_hbox = NULL;
static GtkWidget *open_options_frame = NULL;
static GimpImagefile *open_options_imagefile = NULL;
static GtkWidget *open_options_frame = NULL;
static GtkWidget *open_options_title = NULL;
static GtkWidget *open_options_label = NULL;
static GimpImagefile *open_options_imagefile = NULL;
static GtkWidget *open_options_preview = NULL;
static PlugInProcDef *load_file_proc = NULL;
@ -157,7 +160,7 @@ file_open_dialog_show (Gimp *gimp)
g_return_if_fail (GIMP_IS_GIMP (gimp));
if (! fileload)
file_open_dialog_create (gimp);
fileload = file_open_dialog_create (gimp);
gtk_widget_set_sensitive (GTK_WIDGET (fileload), TRUE);
if (GTK_WIDGET_VISIBLE (fileload))
@ -173,81 +176,37 @@ file_open_dialog_show (Gimp *gimp)
/* private functions */
static void
static GtkWidget *
file_open_dialog_create (Gimp *gimp)
{
GtkFileSelection *file_sel;
GtkWidget *open_dialog;
GtkFileSelection *fs;
GtkTreeSelection *tree_sel;
fileload = gtk_file_selection_new (_("Open Image"));
open_dialog = file_dialog_new (gimp,
gimp_item_factory_from_path ("<Load>"),
_("Open Image"), "open_image",
"open/dialogs/file_open.html",
G_CALLBACK (file_open_ok_callback));
g_object_set_data (G_OBJECT (fileload), "gimp", gimp);
fs = GTK_FILE_SELECTION (open_dialog);
gtk_window_set_position (GTK_WINDOW (fileload), GTK_WIN_POS_MOUSE);
gtk_window_set_wmclass (GTK_WINDOW (fileload), "load_image", "Gimp");
file_sel = GTK_FILE_SELECTION (fileload);
gtk_container_set_border_width (GTK_CONTAINER (fileload), 2);
gtk_container_set_border_width (GTK_CONTAINER (file_sel->button_area), 2);
g_signal_connect_swapped (G_OBJECT (file_sel->cancel_button), "clicked",
G_CALLBACK (file_dialog_hide),
fileload);
g_signal_connect (G_OBJECT (fileload), "delete_event",
G_CALLBACK (file_dialog_hide),
NULL);
g_signal_connect (G_OBJECT (file_sel->ok_button), "clicked",
G_CALLBACK (file_open_ok_callback),
fileload);
gtk_file_selection_set_select_multiple (GTK_FILE_SELECTION (fileload), TRUE);
tree_sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (GTK_FILE_SELECTION (fileload)->file_list));
gtk_file_selection_set_select_multiple (fs, TRUE);
tree_sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (fs->file_list));
/* Catch file-list clicks so we can update the preview thumbnail */
g_signal_connect (G_OBJECT (tree_sel), "changed",
G_CALLBACK (file_open_selchanged_callback),
fileload);
/* Connect the "F1" help key */
gimp_help_connect (fileload,
gimp_standard_help_func,
"open/dialogs/file_open.html");
open_dialog);
/* The preview frame */
{
GimpItemFactory *item_factory;
GtkWidget *label;
GtkWidget *vbox;
GtkWidget *ebox;
GtkWidget *hbox;
GtkWidget *option_menu;
GtkWidget *button;
GtkWidget *preview;
GtkStyle *style;
/* File type menu */
open_options_hbox = gtk_hbox_new (FALSE, 4);
option_menu = gtk_option_menu_new ();
gtk_box_pack_end (GTK_BOX (open_options_hbox), option_menu,
FALSE, FALSE, 0);
gtk_widget_show (option_menu);
item_factory = gimp_item_factory_from_path ("<Load>");
gtk_option_menu_set_menu (GTK_OPTION_MENU (option_menu),
GTK_ITEM_FACTORY (item_factory)->widget);
gtk_box_pack_end (GTK_BOX (GTK_FILE_SELECTION (fileload)->main_vbox),
open_options_hbox, FALSE, FALSE, 0);
gtk_widget_show (open_options_hbox);
label = gtk_label_new (_("Determine File Type:"));
gtk_box_pack_end (GTK_BOX (open_options_hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
/* Preview frame */
GtkWidget *vbox;
GtkWidget *ebox;
GtkWidget *hbox;
GtkWidget *button;
GtkWidget *label;
GtkStyle *style;
open_options_frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (open_options_frame), GTK_SHADOW_IN);
@ -275,7 +234,7 @@ file_open_dialog_create (Gimp *gimp)
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (file_open_genbutton_callback),
fileload);
open_dialog);
gimp_help_set_help_data (button, _("Click to create preview"), NULL);
@ -285,42 +244,43 @@ file_open_dialog_create (Gimp *gimp)
open_options_imagefile = gimp_imagefile_new (NULL);
preview = gimp_preview_new (GIMP_VIEWABLE (open_options_imagefile),
128, 0, FALSE);
open_options_preview =
gimp_preview_new (GIMP_VIEWABLE (open_options_imagefile),
128, 0, FALSE);
gtk_widget_ensure_style (preview);
style = gtk_widget_get_style (preview);
gtk_widget_modify_bg (preview, GTK_STATE_NORMAL,
gtk_widget_ensure_style (open_options_preview);
style = gtk_widget_get_style (open_options_preview);
gtk_widget_modify_bg (open_options_preview, GTK_STATE_NORMAL,
&style->base[GTK_STATE_NORMAL]);
gtk_widget_modify_bg (preview, GTK_STATE_INSENSITIVE,
gtk_widget_modify_bg (open_options_preview, GTK_STATE_INSENSITIVE,
&style->base[GTK_STATE_NORMAL]);
gtk_box_pack_start (GTK_BOX (hbox), preview, TRUE, FALSE, 4);
gtk_widget_show (preview);
g_signal_connect (G_OBJECT (open_options_imagefile), "info_changed",
G_CALLBACK (file_open_imagefile_info_changed),
NULL);
gtk_box_pack_start (GTK_BOX (hbox), open_options_preview, TRUE, FALSE, 4);
gtk_widget_show (open_options_preview);
open_options_title = gtk_label_new (_("No Selection"));
gtk_box_pack_start (GTK_BOX (vbox), open_options_title, FALSE, FALSE, 0);
gtk_widget_show (open_options_title);
open_options_label = gtk_label_new (" \n ");
gtk_label_set_justify (GTK_LABEL (open_options_label), GTK_JUSTIFY_CENTER);
gtk_box_pack_start (GTK_BOX (vbox), open_options_label, FALSE, FALSE, 0);
gtk_widget_show (open_options_label);
label = gtk_label_new (" \n ");
gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_CENTER);
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
g_signal_connect (G_OBJECT (open_options_imagefile), "info_changed",
G_CALLBACK (file_open_imagefile_info_changed),
label);
/* pack the containing open_options hbox into the open-dialog */
for (hbox = GTK_FILE_SELECTION (fileload)->dir_list;
! GTK_IS_HBOX (hbox);
hbox = hbox->parent);
for (hbox = fs->dir_list; ! GTK_IS_HBOX (hbox); hbox = hbox->parent);
gtk_box_pack_end (GTK_BOX (hbox), open_options_frame, FALSE, FALSE, 0);
gtk_widget_show (open_options_frame);
gtk_widget_set_sensitive (GTK_WIDGET (open_options_frame), FALSE);
}
gtk_widget_set_sensitive (GTK_WIDGET (open_options_frame), FALSE);
return open_dialog;
}
static void
@ -336,10 +296,9 @@ file_open_type_callback (GtkWidget *widget,
static void
file_open_imagefile_info_changed (GimpImagefile *imagefile,
gpointer data)
GtkLabel *label)
{
gtk_label_set_text (GTK_LABEL (open_options_label),
gimp_imagefile_get_description (imagefile));
gtk_label_set_text (label, gimp_imagefile_get_description (imagefile));
}
static void
@ -355,9 +314,9 @@ selchanged_foreach (GtkTreeModel *model,
static void
file_open_selchanged_callback (GtkTreeSelection *sel,
gpointer data)
GtkWidget *open_dialog)
{
GtkFileSelection *fileload;
GtkFileSelection *fs;
Gimp *gimp;
const gchar *fullfname;
gboolean selected = FALSE;
@ -370,13 +329,11 @@ file_open_selchanged_callback (GtkTreeSelection *sel,
gchar *uri;
gchar *basename;
fileload = GTK_FILE_SELECTION (data);
fs = GTK_FILE_SELECTION (open_dialog);
gimp = GIMP (g_object_get_data (G_OBJECT (fileload), "gimp"));
gimp = GIMP (g_object_get_data (G_OBJECT (open_dialog), "gimp"));
fullfname = gtk_file_selection_get_filename (fileload);
gtk_widget_set_sensitive (GTK_WIDGET (open_options_frame), TRUE);
fullfname = gtk_file_selection_get_filename (fs);
uri = file_utils_filename_to_uri (gimp->load_procs, fullfname, NULL);
basename = file_utils_uri_to_utf8_basename (uri);
@ -393,130 +350,131 @@ file_open_selchanged_callback (GtkTreeSelection *sel,
gtk_label_set_text (GTK_LABEL (open_options_title), _("No Selection"));
}
gtk_widget_set_sensitive (GTK_WIDGET (open_options_frame), selected);
gimp_imagefile_update (open_options_imagefile);
}
static void
file_open_create_thumbnail (const gchar *filename)
{
if (g_file_test (filename, G_FILE_TEST_IS_REGULAR))
{
GimpImagefile *imagefile;
gchar *basename;
gchar *uri;
uri = g_filename_to_uri (filename, NULL, NULL);
imagefile = gimp_imagefile_new (uri);
gimp_imagefile_create_thumbnail (imagefile);
g_object_unref (G_OBJECT (imagefile));
basename = file_utils_uri_to_utf8_basename (uri);
gtk_label_set_text (GTK_LABEL (open_options_title), basename);
g_free (basename);
gimp_object_set_name (GIMP_OBJECT (open_options_imagefile), uri);
gimp_imagefile_update (open_options_imagefile);
g_free (uri);
}
}
static void
file_open_genbutton_callback (GtkWidget *widget,
gpointer data)
GtkWidget *open_dialog)
{
GtkFileSelection *fs;
Gimp *gimp;
gchar **selections;
gint i;
fs = GTK_FILE_SELECTION (data);
fs = GTK_FILE_SELECTION (open_dialog);
gimp = GIMP (g_object_get_data (G_OBJECT (fs), "gimp"));
gimp_set_busy (gimp);
gtk_widget_set_sensitive (GTK_WIDGET (fs), FALSE);
selections = gtk_file_selection_get_selections (fs);
for (i = 0; selections[i] != NULL; i++)
if (gimp->config->write_thumbnails)
{
if (g_file_test (selections[i], G_FILE_TEST_IS_REGULAR))
{
gchar *uri = g_filename_to_uri (selections[i], NULL, NULL);
gchar **selections;
gint i;
if (gimp->config->write_thumbnails)
{
gimp_object_set_name (GIMP_OBJECT (open_options_imagefile),
uri);
gimp_imagefile_create_thumbnail (open_options_imagefile);
}
gimp_set_busy (gimp);
gtk_widget_set_sensitive (open_dialog, FALSE);
#if 0
{
gtk_label_set_text (GTK_LABEL (open_options_label),
_("Failed to generate preview."));
}
#endif
selections = gtk_file_selection_get_selections (fs);
g_free (uri);
}
}
for (i = 1; selections[i] != NULL; i++)
file_open_create_thumbnail (selections[i]);
g_strfreev (selections);
if (selections[0])
file_open_create_thumbnail (selections[0]);
gtk_widget_set_sensitive (GTK_WIDGET (fs), TRUE);
gimp_unset_busy (gimp);
g_strfreev (selections);
gtk_widget_set_sensitive (open_dialog, TRUE);
gimp_unset_busy (gimp);
}
}
static void
file_open_ok_callback (GtkWidget *widget,
gpointer data)
GtkWidget *open_dialog)
{
GtkFileSelection *fs;
Gimp *gimp;
gchar *entered_filename;
GimpPDBStatusType status;
gchar **selections;
gint i;
gchar *uri;
GtkFileSelection *fs;
Gimp *gimp;
gchar **selections;
gchar *uri;
const gchar *entered_filename;
gint i;
fs = GTK_FILE_SELECTION (data);
fs = GTK_FILE_SELECTION (open_dialog);
gimp = GIMP (g_object_get_data (G_OBJECT (fs), "gimp"));
gimp = GIMP (g_object_get_data (G_OBJECT (open_dialog), "gimp"));
selections = gtk_file_selection_get_selections (fs);
if (selections == NULL)
return;
if (g_file_test (selections[0], G_FILE_TEST_IS_DIR))
entered_filename = gtk_entry_get_text (GTK_ENTRY (fs->selection_entry));
if (g_file_test (selections[0], G_FILE_TEST_EXISTS))
{
if (selections[0][strlen (selections[0]) - 1] != G_DIR_SEPARATOR)
{
gchar *s = g_strconcat (selections[0], G_DIR_SEPARATOR_S, NULL);
gtk_file_selection_set_filename (fs, s);
g_free (s);
}
else
if (g_file_test (selections[0], G_FILE_TEST_IS_DIR))
{
gtk_file_selection_set_filename (fs, selections[0]);
if (selections[0][strlen (selections[0]) - 1] != G_DIR_SEPARATOR)
{
gchar *s = g_strconcat (selections[0], G_DIR_SEPARATOR_S, NULL);
gtk_file_selection_set_filename (fs, s);
g_free (s);
}
else
{
gtk_file_selection_set_filename (fs, selections[0]);
}
g_strfreev (selections);
return;
}
g_strfreev (selections);
return;
uri = g_filename_to_uri (selections[0], NULL, NULL);
}
entered_filename =
g_strdup (gtk_entry_get_text (GTK_ENTRY (fs->selection_entry)));
gtk_widget_set_sensitive (GTK_WIDGET (fs), FALSE);
if (! g_file_test (selections[0], G_FILE_TEST_EXISTS))
{
else
{
/* try with the entered filename in case the user typed an URI */
uri = g_strdup (entered_filename);
}
else
{
uri = g_filename_to_uri (selections[0], NULL, NULL);
}
status = file_open_with_proc_and_display (gimp,
uri,
entered_filename,
load_file_proc);
gtk_widget_set_sensitive (open_dialog, FALSE);
file_open_dialog_open_image (open_dialog,
gimp,
uri,
entered_filename,
load_file_proc);
g_free (entered_filename);
g_free (uri);
if (status == GIMP_PDB_SUCCESS)
{
file_dialog_hide (data);
}
else if (status != GIMP_PDB_CANCEL)
{
/* Hackery required. Please add error message. --bex */
g_message (_("Opening '%s' failed."), uri);
}
/*
* Now deal with multiple selections from the filesel list
*/
@ -527,20 +485,11 @@ file_open_ok_callback (GtkWidget *widget,
{
uri = g_filename_to_uri (selections[i], NULL, NULL);
status = file_open_with_proc_and_display (gimp,
uri,
uri,
load_file_proc);
if (status == GIMP_PDB_SUCCESS)
{
file_dialog_hide (data);
}
else if (status != GIMP_PDB_CANCEL)
{
/* same as previous. --bex */
g_message (_("Opening '%s' failed."), uri);
}
file_open_dialog_open_image (open_dialog,
gimp,
uri,
uri,
load_file_proc);
g_free (uri);
}
@ -548,5 +497,30 @@ file_open_ok_callback (GtkWidget *widget,
g_strfreev (selections);
gtk_widget_set_sensitive (GTK_WIDGET (fs), TRUE);
gtk_widget_set_sensitive (open_dialog, TRUE);
}
static void
file_open_dialog_open_image (GtkWidget *open_dialog,
Gimp *gimp,
const gchar *uri,
const gchar *entered_filename,
PlugInProcDef *load_proc)
{
GimpPDBStatusType status;
status = file_open_with_proc_and_display (gimp,
uri,
entered_filename,
load_proc);
if (status == GIMP_PDB_SUCCESS)
{
file_dialog_hide (open_dialog);
}
else if (status != GIMP_PDB_CANCEL)
{
/* Hackery required. Please add error message. --bex */
g_message (_("Opening '%s' failed."), uri);
}
}

336
app/dialogs/file-save-dialog.c
View file

@ -55,37 +55,32 @@
#include "libgimp/gimpintl.h"
typedef struct _OverwriteData OverwriteData;
/* local function prototypes */
struct _OverwriteData
{
gchar *uri;
gchar *raw_filename;
};
static GtkWidget * file_save_dialog_create (Gimp *gimp);
static void file_save_type_callback (GtkWidget *widget,
gpointer data);
static void file_save_ok_callback (GtkWidget *widget,
GtkWidget *save_dialog);
static void file_save_overwrite (GtkWidget *save_dialog,
const gchar *uri,
const gchar *raw_filename);
static void file_save_overwrite_callback (GtkWidget *widget,
gboolean overwrite,
gpointer data);
static void file_save_dialog_save_image (GtkWidget *save_dialog,
GimpImage *gimage,
const gchar *uri,
const gchar *raw_filename,
PlugInProcDef *save_proc,
gboolean set_uri);
static void file_save_dialog_create (void);
static void file_overwrite (const gchar *uri,
const gchar *raw_filename);
static void file_overwrite_callback (GtkWidget *widget,
gboolean overwrite,
gpointer data);
static void file_save_ok_callback (GtkWidget *widget,
gpointer data);
static void file_save_type_callback (GtkWidget *widget,
gpointer data);
static GtkWidget *filesave = NULL;
static GtkWidget *save_options = NULL;
static GtkWidget *filesave = NULL;
static PlugInProcDef *save_file_proc = NULL;
static GimpImage *the_gimage = NULL;
static gboolean set_uri = TRUE;
static GimpImage *the_gimage = NULL;
static gboolean set_uri = TRUE;
/* public functions */
@ -160,8 +155,7 @@ file_save_dialog_show (GimpImage *gimage)
return;
the_gimage = gimage;
set_uri = TRUE;
set_uri = TRUE;
uri = gimp_object_get_name (GIMP_OBJECT (gimage));
@ -169,7 +163,7 @@ file_save_dialog_show (GimpImage *gimage)
filename = g_filename_from_uri (uri, NULL, NULL);
if (! filesave)
file_save_dialog_create ();
filesave = file_save_dialog_create (gimage->gimp);
gtk_widget_set_sensitive (GTK_WIDGET (filesave), TRUE);
if (GTK_WIDGET_VISIBLE (filesave))
@ -200,8 +194,7 @@ file_save_a_copy_dialog_show (GimpImage *gimage)
return;
the_gimage = gimage;
set_uri = FALSE;
set_uri = FALSE;
uri = gimp_object_get_name (GIMP_OBJECT (gimage));
@ -209,7 +202,7 @@ file_save_a_copy_dialog_show (GimpImage *gimage)
filename = g_filename_from_uri (uri, NULL, NULL);
if (! filesave)
file_save_dialog_create ();
filesave = file_save_dialog_create (gimage->gimp);
gtk_widget_set_sensitive (GTK_WIDGET (filesave), TRUE);
if (GTK_WIDGET_VISIBLE (filesave))
@ -231,74 +224,14 @@ file_save_a_copy_dialog_show (GimpImage *gimage)
/* private functions */
static void
file_save_dialog_create (void)
static GtkWidget *
file_save_dialog_create (Gimp *gimp)
{
GtkFileSelection *file_sel;
filesave = gtk_file_selection_new (_("Save Image"));
gtk_window_set_wmclass (GTK_WINDOW (filesave), "save_image", "Gimp");
gtk_window_set_position (GTK_WINDOW (filesave), GTK_WIN_POS_MOUSE);
file_sel = GTK_FILE_SELECTION (filesave);
gtk_container_set_border_width (GTK_CONTAINER (filesave), 2);
gtk_container_set_border_width (GTK_CONTAINER (file_sel->button_area), 2);
g_signal_connect_swapped (G_OBJECT (file_sel->cancel_button), "clicked",
G_CALLBACK (file_dialog_hide),
filesave);
g_signal_connect (G_OBJECT (filesave), "delete_event",
G_CALLBACK (file_dialog_hide),
NULL);
g_signal_connect (G_OBJECT (file_sel->ok_button), "clicked",
G_CALLBACK (file_save_ok_callback),
filesave);
/* Connect the "F1" help key */
gimp_help_connect (filesave,
gimp_standard_help_func,
"save/dialogs/file_save.html");
{
GimpItemFactory *item_factory;
GtkWidget *frame;
GtkWidget *hbox;
GtkWidget *label;
GtkWidget *option_menu;
save_options = gtk_hbox_new (TRUE, 1);
frame = gtk_frame_new (_("Save Options"));
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
gtk_box_pack_start (GTK_BOX (save_options), frame, TRUE, TRUE, 4);
hbox = gtk_hbox_new (FALSE, 4);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 4);
gtk_container_add (GTK_CONTAINER (frame), hbox);
gtk_widget_show (hbox);
label = gtk_label_new (_("Determine File Type:"));
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
option_menu = gtk_option_menu_new ();
gtk_box_pack_start (GTK_BOX (hbox), option_menu, TRUE, TRUE, 0);
gtk_widget_show (option_menu);
item_factory = gimp_item_factory_from_path ("<Save>");
gtk_option_menu_set_menu (GTK_OPTION_MENU (option_menu),
GTK_ITEM_FACTORY (item_factory)->widget);
gtk_widget_show (frame);
/* pack the containing save_options hbox into the save-dialog */
gtk_box_pack_end (GTK_BOX (GTK_FILE_SELECTION (filesave)->main_vbox),
save_options, FALSE, FALSE, 0);
}
gtk_widget_show (save_options);
return file_dialog_new (gimp,
gimp_item_factory_from_path ("<Save>"),
_("Save Image"), "save_image",
"save/dialogs/file_save.html",
G_CALLBACK (file_save_ok_callback));
}
static void
@ -314,18 +247,14 @@ file_save_type_callback (GtkWidget *widget,
static void
file_save_ok_callback (GtkWidget *widget,
gpointer data)
GtkWidget *save_dialog)
{
GtkFileSelection *fs;
const gchar *filename;
const gchar *raw_filename;
gchar *uri;
gchar *dot;
gint x;
struct stat buf;
gint err;
fs = GTK_FILE_SELECTION (data);
fs = GTK_FILE_SELECTION (save_dialog);
filename = gtk_file_selection_get_filename (fs);
raw_filename = gtk_entry_get_text (GTK_ENTRY (fs->selection_entry));
@ -334,48 +263,53 @@ file_save_ok_callback (GtkWidget *widget,
uri = g_filename_to_uri (filename, NULL, NULL);
for (dot = strrchr (filename, '.'), x = 0; dot && *(++dot);)
{
gchar *dot;
gint x;
for (dot = strrchr (filename, '.'), x = 0; dot && *(++dot);)
{
if (*dot != 'e' || ++x < 0)
{
break;
}
else if (x > 3 && !strcmp (dot + 1, "k"))
{
ProcRecord *proc_rec;
Argument *args;
GimpDrawable *drawable;
file_dialog_hide (save_dialog);
drawable = gimp_image_active_drawable (the_gimage);
if (! drawable)
return;
proc_rec = procedural_db_lookup (the_gimage->gimp,
"plug_in_the_slimy_egg");
if (! proc_rec)
return;
args = g_new (Argument, 3);
args[0].arg_type = GIMP_PDB_INT32;
args[0].value.pdb_int = GIMP_RUN_INTERACTIVE;
args[1].arg_type = GIMP_PDB_IMAGE;
args[1].value.pdb_int = gimp_image_get_ID (the_gimage);
args[2].arg_type = GIMP_PDB_DRAWABLE;
args[2].value.pdb_int = gimp_item_get_ID (GIMP_ITEM (drawable));
plug_in_run (the_gimage->gimp, proc_rec, args, 3, FALSE, TRUE, 0);
g_free (args);
return;
}
}
}
if (g_file_test (filename, G_FILE_TEST_EXISTS))
{
if (*dot != 'e' || ++x < 0)
break;
else if (x > 3 && !strcmp (dot + 1, "k"))
{
ProcRecord *proc_rec;
Argument *args;
GimpDrawable *the_drawable;
the_drawable = gimp_image_active_drawable (the_gimage);
if (!the_drawable)
return;
proc_rec = procedural_db_lookup (the_gimage->gimp,
"plug_in_the_slimy_egg");
if (!proc_rec)
break;
file_dialog_hide (filesave);
args = g_new (Argument, 3);
args[0].arg_type = GIMP_PDB_INT32;
args[0].value.pdb_int = GIMP_RUN_INTERACTIVE;
args[1].arg_type = GIMP_PDB_IMAGE;
args[1].value.pdb_int = gimp_image_get_ID (the_gimage);
args[2].arg_type = GIMP_PDB_DRAWABLE;
args[2].value.pdb_int = gimp_item_get_ID (GIMP_ITEM (the_drawable));
plug_in_run (the_gimage->gimp, proc_rec, args, 3, FALSE, TRUE, 0);
g_free (args);
return;
}
}
err = stat (filename, &buf);
if (err == 0)
{
if (buf.st_mode & S_IFDIR)
if (g_file_test (filename, G_FILE_TEST_IS_DIR))
{
if (filename[strlen (filename) - 1] != G_DIR_SEPARATOR)
{
@ -390,41 +324,37 @@ file_save_ok_callback (GtkWidget *widget,
}
else
{
gtk_widget_set_sensitive (GTK_WIDGET (fs), FALSE);
file_overwrite (uri, raw_filename);
file_save_overwrite (save_dialog, uri, raw_filename);
}
}
else
{
GimpPDBStatusType status;
gtk_widget_set_sensitive (GTK_WIDGET (fs), FALSE);
status = file_save (the_gimage,
uri,
raw_filename,
save_file_proc,
GIMP_RUN_INTERACTIVE,
set_uri);
if (status != GIMP_PDB_SUCCESS &&
status != GIMP_PDB_CANCEL)
{
/* Please add error. (: %s) --bex */
g_message (_("Saving %s failed."), uri);
}
else
{
file_dialog_hide (GTK_WIDGET (fs));
}
file_save_dialog_save_image (save_dialog,
the_gimage,
uri,
raw_filename,
save_file_proc,
set_uri);
gtk_widget_set_sensitive (GTK_WIDGET (fs), TRUE);
}
}
typedef struct _OverwriteData OverwriteData;
struct _OverwriteData
{
GtkWidget *save_dialog;
gchar *uri;
gchar *raw_filename;
};
static void
file_overwrite (const gchar *uri,
const gchar *raw_filename)
file_save_overwrite (GtkWidget *save_dialog,
const gchar *uri,
const gchar *raw_filename)
{
OverwriteData *overwrite_data;
GtkWidget *query_box;
@ -432,6 +362,7 @@ file_overwrite (const gchar *uri,
overwrite_data = g_new0 (OverwriteData, 1);
overwrite_data->save_dialog = save_dialog;
overwrite_data->uri = g_strdup (uri);
overwrite_data->raw_filename = g_strdup (raw_filename);
@ -445,18 +376,20 @@ file_overwrite (const gchar *uri,
overwrite_text,
GTK_STOCK_YES, GTK_STOCK_NO,
NULL, NULL,
file_overwrite_callback,
file_save_overwrite_callback,
overwrite_data);
g_free (overwrite_text);
gtk_widget_show (query_box);
gtk_widget_set_sensitive (save_dialog, FALSE);
}
static void
file_overwrite_callback (GtkWidget *widget,
gboolean overwrite,
gpointer data)
file_save_overwrite_callback (GtkWidget *widget,
gboolean overwrite,
gpointer data)
{
OverwriteData *overwrite_data;
@ -464,31 +397,46 @@ file_overwrite_callback (GtkWidget *widget,
if (overwrite)
{
GimpPDBStatusType status;
status = file_save (the_gimage,
overwrite_data->uri,
overwrite_data->raw_filename,
save_file_proc,
GIMP_RUN_INTERACTIVE,
set_uri);
if (status != GIMP_PDB_SUCCESS &&
status != GIMP_PDB_CANCEL)
{
/* Another error required. --bex */
g_message (_("Saving '%s' failed."), overwrite_data->uri);
}
else
{
file_dialog_hide (GTK_WIDGET (filesave));
}
file_save_dialog_save_image (overwrite_data->save_dialog,
the_gimage,
overwrite_data->uri,
overwrite_data->raw_filename,
save_file_proc,
set_uri);
}
/* always make file save dialog sensitive */
gtk_widget_set_sensitive (GTK_WIDGET (filesave), TRUE);
gtk_widget_set_sensitive (overwrite_data->save_dialog, TRUE);
g_free (overwrite_data->uri);
g_free (overwrite_data->raw_filename);
g_free (overwrite_data);
}
static void
file_save_dialog_save_image (GtkWidget *save_dialog,
GimpImage *gimage,
const gchar *uri,
const gchar *raw_filename,
PlugInProcDef *save_proc,
gboolean set_uri)
{
GimpPDBStatusType status;
status = file_save (gimage,
uri,
raw_filename,
save_proc,
GIMP_RUN_INTERACTIVE,
set_uri);
if (status != GIMP_PDB_SUCCESS &&
status != GIMP_PDB_CANCEL)
{
/* Another error required. --bex */
g_message (_("Saving '%s' failed."), uri);
}
else
{
file_dialog_hide (save_dialog);
}
}

75
app/gui/file-dialog-utils.c
View file

@ -23,14 +23,89 @@
#include <gtk/gtk.h>
#include "libgimpwidgets/gimpwidgets.h"
#include "gui-types.h"
#include "core/gimp.h"
#include "plug-in/plug-in-proc.h"
#include "widgets/gimpitemfactory.h"
#include "file-dialog-utils.h"
#include "libgimp/gimpintl.h"
GtkWidget *
file_dialog_new (Gimp *gimp,
GimpItemFactory *item_factory,
const gchar *title,
const gchar *wmclass_name,
const gchar *help_data,
GCallback ok_callback)
{
GtkWidget *filesel;
GtkFileSelection *fs;
g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
g_return_val_if_fail (GIMP_IS_ITEM_FACTORY (item_factory), NULL);
g_return_val_if_fail (title != NULL, NULL);
g_return_val_if_fail (wmclass_name != NULL, NULL);
g_return_val_if_fail (help_data != NULL, NULL);
g_return_val_if_fail (ok_callback != NULL, NULL);
filesel = gtk_file_selection_new (title);
fs = GTK_FILE_SELECTION (filesel);
g_object_set_data (G_OBJECT (filesel), "gimp", gimp);
gtk_window_set_position (GTK_WINDOW (filesel), GTK_WIN_POS_MOUSE);
gtk_window_set_wmclass (GTK_WINDOW (filesel), wmclass_name, "Gimp");
gimp_help_connect (filesel, gimp_standard_help_func, help_data);
gtk_container_set_border_width (GTK_CONTAINER (fs->button_area), 2);
gtk_container_set_border_width (GTK_CONTAINER (filesel), 2);
g_signal_connect_swapped (G_OBJECT (fs->cancel_button), "clicked",
G_CALLBACK (file_dialog_hide),
filesel);
g_signal_connect (G_OBJECT (filesel), "delete_event",
G_CALLBACK (file_dialog_hide),
NULL);
g_signal_connect (G_OBJECT (fs->ok_button), "clicked",
G_CALLBACK (ok_callback),
filesel);
/* The file type menu */
{
GtkWidget *hbox;
GtkWidget *option_menu;
GtkWidget *label;
hbox = gtk_hbox_new (FALSE, 4);
option_menu = gtk_option_menu_new ();
gtk_box_pack_end (GTK_BOX (hbox), option_menu, FALSE, FALSE, 0);
gtk_widget_show (option_menu);
gtk_option_menu_set_menu (GTK_OPTION_MENU (option_menu),
GTK_ITEM_FACTORY (item_factory)->widget);
gtk_box_pack_end (GTK_BOX (fs->main_vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
label = gtk_label_new (_("Determine File Type:"));
gtk_box_pack_end (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
}
return filesel;
}
void
file_dialog_show (GtkWidget *filesel)

19
app/gui/file-dialog-utils.h
View file

@ -20,13 +20,20 @@
#define __FILE_DIALOG_UTILS_H__
void file_dialog_show (GtkWidget *filesel);
gboolean file_dialog_hide (GtkWidget *filesel);
GtkWidget * file_dialog_new (Gimp *gimp,
GimpItemFactory *item_factory,
const gchar *title,
const gchar *wmclass_name,
const gchar *help_data,
GCallback ok_callback);
void file_dialog_update_name (PlugInProcDef *proc,
GtkFileSelection *filesel);
void file_dialog_update_menus (GSList *procs,
GimpImageType image_type);
void file_dialog_show (GtkWidget *filesel);
gboolean file_dialog_hide (GtkWidget *filesel);
void file_dialog_update_name (PlugInProcDef *proc,
GtkFileSelection *filesel);
void file_dialog_update_menus (GSList *procs,
GimpImageType image_type);
#endif /* __FILE_DIALOG_UTILS_H__ */

386
app/gui/file-open-dialog.c
View file

@ -68,27 +68,30 @@
/* local function prototypes */
static void file_open_dialog_create (Gimp *gimp);
static void file_open_genbutton_callback (GtkWidget *widget,
gpointer data);
static void file_open_selchanged_callback (GtkTreeSelection *sel,
gpointer data);
static void file_open_ok_callback (GtkWidget *widget,
gpointer data);
static void file_open_type_callback (GtkWidget *widget,
gpointer data);
static void file_open_imagefile_info_changed (GimpImagefile *imagefile,
gpointer data);
static GtkWidget * file_open_dialog_create (Gimp *gimp);
static void file_open_type_callback (GtkWidget *widget,
gpointer data);
static void file_open_selchanged_callback (GtkTreeSelection *sel,
GtkWidget *open_dialog);
static void file_open_imagefile_info_changed (GimpImagefile *imagefile,
GtkLabel *label);
static void file_open_genbutton_callback (GtkWidget *widget,
GtkWidget *open_dialog);
static void file_open_ok_callback (GtkWidget *widget,
GtkWidget *open_dialog);
static void file_open_dialog_open_image (GtkWidget *open_dialog,
Gimp *gimp,
const gchar *uri,
const gchar *entered_filename,
PlugInProcDef *load_proc);
static GtkWidget *fileload = NULL;
static GtkWidget *open_options_hbox = NULL;
static GtkWidget *open_options_frame = NULL;
static GimpImagefile *open_options_imagefile = NULL;
static GtkWidget *open_options_frame = NULL;
static GtkWidget *open_options_title = NULL;
static GtkWidget *open_options_label = NULL;
static GimpImagefile *open_options_imagefile = NULL;
static GtkWidget *open_options_preview = NULL;
static PlugInProcDef *load_file_proc = NULL;
@ -157,7 +160,7 @@ file_open_dialog_show (Gimp *gimp)
g_return_if_fail (GIMP_IS_GIMP (gimp));
if (! fileload)
file_open_dialog_create (gimp);
fileload = file_open_dialog_create (gimp);
gtk_widget_set_sensitive (GTK_WIDGET (fileload), TRUE);
if (GTK_WIDGET_VISIBLE (fileload))
@ -173,81 +176,37 @@ file_open_dialog_show (Gimp *gimp)
/* private functions */
static void
static GtkWidget *
file_open_dialog_create (Gimp *gimp)
{
GtkFileSelection *file_sel;
GtkWidget *open_dialog;
GtkFileSelection *fs;
GtkTreeSelection *tree_sel;
fileload = gtk_file_selection_new (_("Open Image"));
open_dialog = file_dialog_new (gimp,
gimp_item_factory_from_path ("<Load>"),
_("Open Image"), "open_image",
"open/dialogs/file_open.html",
G_CALLBACK (file_open_ok_callback));
g_object_set_data (G_OBJECT (fileload), "gimp", gimp);
fs = GTK_FILE_SELECTION (open_dialog);
gtk_window_set_position (GTK_WINDOW (fileload), GTK_WIN_POS_MOUSE);
gtk_window_set_wmclass (GTK_WINDOW (fileload), "load_image", "Gimp");
file_sel = GTK_FILE_SELECTION (fileload);
gtk_container_set_border_width (GTK_CONTAINER (fileload), 2);
gtk_container_set_border_width (GTK_CONTAINER (file_sel->button_area), 2);
g_signal_connect_swapped (G_OBJECT (file_sel->cancel_button), "clicked",
G_CALLBACK (file_dialog_hide),
fileload);
g_signal_connect (G_OBJECT (fileload), "delete_event",
G_CALLBACK (file_dialog_hide),
NULL);
g_signal_connect (G_OBJECT (file_sel->ok_button), "clicked",
G_CALLBACK (file_open_ok_callback),
fileload);
gtk_file_selection_set_select_multiple (GTK_FILE_SELECTION (fileload), TRUE);
tree_sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (GTK_FILE_SELECTION (fileload)->file_list));
gtk_file_selection_set_select_multiple (fs, TRUE);
tree_sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (fs->file_list));
/* Catch file-list clicks so we can update the preview thumbnail */
g_signal_connect (G_OBJECT (tree_sel), "changed",
G_CALLBACK (file_open_selchanged_callback),
fileload);
/* Connect the "F1" help key */
gimp_help_connect (fileload,
gimp_standard_help_func,
"open/dialogs/file_open.html");
open_dialog);
/* The preview frame */
{
GimpItemFactory *item_factory;
GtkWidget *label;
GtkWidget *vbox;
GtkWidget *ebox;
GtkWidget *hbox;
GtkWidget *option_menu;
GtkWidget *button;
GtkWidget *preview;
GtkStyle *style;
/* File type menu */
open_options_hbox = gtk_hbox_new (FALSE, 4);
option_menu = gtk_option_menu_new ();
gtk_box_pack_end (GTK_BOX (open_options_hbox), option_menu,
FALSE, FALSE, 0);
gtk_widget_show (option_menu);
item_factory = gimp_item_factory_from_path ("<Load>");
gtk_option_menu_set_menu (GTK_OPTION_MENU (option_menu),
GTK_ITEM_FACTORY (item_factory)->widget);
gtk_box_pack_end (GTK_BOX (GTK_FILE_SELECTION (fileload)->main_vbox),
open_options_hbox, FALSE, FALSE, 0);
gtk_widget_show (open_options_hbox);
label = gtk_label_new (_("Determine File Type:"));
gtk_box_pack_end (GTK_BOX (open_options_hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
/* Preview frame */
GtkWidget *vbox;
GtkWidget *ebox;
GtkWidget *hbox;
GtkWidget *button;
GtkWidget *label;
GtkStyle *style;
open_options_frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (open_options_frame), GTK_SHADOW_IN);
@ -275,7 +234,7 @@ file_open_dialog_create (Gimp *gimp)
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (file_open_genbutton_callback),
fileload);
open_dialog);
gimp_help_set_help_data (button, _("Click to create preview"), NULL);
@ -285,42 +244,43 @@ file_open_dialog_create (Gimp *gimp)
open_options_imagefile = gimp_imagefile_new (NULL);
preview = gimp_preview_new (GIMP_VIEWABLE (open_options_imagefile),
128, 0, FALSE);
open_options_preview =
gimp_preview_new (GIMP_VIEWABLE (open_options_imagefile),
128, 0, FALSE);
gtk_widget_ensure_style (preview);
style = gtk_widget_get_style (preview);
gtk_widget_modify_bg (preview, GTK_STATE_NORMAL,
gtk_widget_ensure_style (open_options_preview);
style = gtk_widget_get_style (open_options_preview);
gtk_widget_modify_bg (open_options_preview, GTK_STATE_NORMAL,
&style->base[GTK_STATE_NORMAL]);
gtk_widget_modify_bg (preview, GTK_STATE_INSENSITIVE,
gtk_widget_modify_bg (open_options_preview, GTK_STATE_INSENSITIVE,
&style->base[GTK_STATE_NORMAL]);
gtk_box_pack_start (GTK_BOX (hbox), preview, TRUE, FALSE, 4);
gtk_widget_show (preview);
g_signal_connect (G_OBJECT (open_options_imagefile), "info_changed",
G_CALLBACK (file_open_imagefile_info_changed),
NULL);
gtk_box_pack_start (GTK_BOX (hbox), open_options_preview, TRUE, FALSE, 4);
gtk_widget_show (open_options_preview);
open_options_title = gtk_label_new (_("No Selection"));
gtk_box_pack_start (GTK_BOX (vbox), open_options_title, FALSE, FALSE, 0);
gtk_widget_show (open_options_title);
open_options_label = gtk_label_new (" \n ");
gtk_label_set_justify (GTK_LABEL (open_options_label), GTK_JUSTIFY_CENTER);
gtk_box_pack_start (GTK_BOX (vbox), open_options_label, FALSE, FALSE, 0);
gtk_widget_show (open_options_label);
label = gtk_label_new (" \n ");
gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_CENTER);
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
g_signal_connect (G_OBJECT (open_options_imagefile), "info_changed",
G_CALLBACK (file_open_imagefile_info_changed),
label);
/* pack the containing open_options hbox into the open-dialog */
for (hbox = GTK_FILE_SELECTION (fileload)->dir_list;
! GTK_IS_HBOX (hbox);
hbox = hbox->parent);
for (hbox = fs->dir_list; ! GTK_IS_HBOX (hbox); hbox = hbox->parent);
gtk_box_pack_end (GTK_BOX (hbox), open_options_frame, FALSE, FALSE, 0);
gtk_widget_show (open_options_frame);
gtk_widget_set_sensitive (GTK_WIDGET (open_options_frame), FALSE);
}
gtk_widget_set_sensitive (GTK_WIDGET (open_options_frame), FALSE);
return open_dialog;
}
static void
@ -336,10 +296,9 @@ file_open_type_callback (GtkWidget *widget,
static void
file_open_imagefile_info_changed (GimpImagefile *imagefile,
gpointer data)
GtkLabel *label)
{
gtk_label_set_text (GTK_LABEL (open_options_label),
gimp_imagefile_get_description (imagefile));
gtk_label_set_text (label, gimp_imagefile_get_description (imagefile));
}
static void
@ -355,9 +314,9 @@ selchanged_foreach (GtkTreeModel *model,
static void
file_open_selchanged_callback (GtkTreeSelection *sel,
gpointer data)
GtkWidget *open_dialog)
{
GtkFileSelection *fileload;
GtkFileSelection *fs;
Gimp *gimp;
const gchar *fullfname;
gboolean selected = FALSE;
@ -370,13 +329,11 @@ file_open_selchanged_callback (GtkTreeSelection *sel,
gchar *uri;
gchar *basename;
fileload = GTK_FILE_SELECTION (data);
fs = GTK_FILE_SELECTION (open_dialog);
gimp = GIMP (g_object_get_data (G_OBJECT (fileload), "gimp"));
gimp = GIMP (g_object_get_data (G_OBJECT (open_dialog), "gimp"));
fullfname = gtk_file_selection_get_filename (fileload);
gtk_widget_set_sensitive (GTK_WIDGET (open_options_frame), TRUE);
fullfname = gtk_file_selection_get_filename (fs);
uri = file_utils_filename_to_uri (gimp->load_procs, fullfname, NULL);
basename = file_utils_uri_to_utf8_basename (uri);
@ -393,130 +350,131 @@ file_open_selchanged_callback (GtkTreeSelection *sel,
gtk_label_set_text (GTK_LABEL (open_options_title), _("No Selection"));
}
gtk_widget_set_sensitive (GTK_WIDGET (open_options_frame), selected);
gimp_imagefile_update (open_options_imagefile);
}
static void
file_open_create_thumbnail (const gchar *filename)
{
if (g_file_test (filename, G_FILE_TEST_IS_REGULAR))
{
GimpImagefile *imagefile;
gchar *basename;
gchar *uri;
uri = g_filename_to_uri (filename, NULL, NULL);
imagefile = gimp_imagefile_new (uri);
gimp_imagefile_create_thumbnail (imagefile);
g_object_unref (G_OBJECT (imagefile));
basename = file_utils_uri_to_utf8_basename (uri);
gtk_label_set_text (GTK_LABEL (open_options_title), basename);
g_free (basename);
gimp_object_set_name (GIMP_OBJECT (open_options_imagefile), uri);
gimp_imagefile_update (open_options_imagefile);
g_free (uri);
}
}
static void
file_open_genbutton_callback (GtkWidget *widget,
gpointer data)
GtkWidget *open_dialog)
{
GtkFileSelection *fs;
Gimp *gimp;
gchar **selections;
gint i;
fs = GTK_FILE_SELECTION (data);
fs = GTK_FILE_SELECTION (open_dialog);
gimp = GIMP (g_object_get_data (G_OBJECT (fs), "gimp"));
gimp_set_busy (gimp);
gtk_widget_set_sensitive (GTK_WIDGET (fs), FALSE);
selections = gtk_file_selection_get_selections (fs);
for (i = 0; selections[i] != NULL; i++)
if (gimp->config->write_thumbnails)
{
if (g_file_test (selections[i], G_FILE_TEST_IS_REGULAR))
{
gchar *uri = g_filename_to_uri (selections[i], NULL, NULL);
gchar **selections;
gint i;
if (gimp->config->write_thumbnails)
{
gimp_object_set_name (GIMP_OBJECT (open_options_imagefile),
uri);
gimp_imagefile_create_thumbnail (open_options_imagefile);
}
gimp_set_busy (gimp);
gtk_widget_set_sensitive (open_dialog, FALSE);
#if 0
{
gtk_label_set_text (GTK_LABEL (open_options_label),
_("Failed to generate preview."));
}
#endif
selections = gtk_file_selection_get_selections (fs);
g_free (uri);
}
}
for (i = 1; selections[i] != NULL; i++)
file_open_create_thumbnail (selections[i]);
g_strfreev (selections);
if (selections[0])
file_open_create_thumbnail (selections[0]);
gtk_widget_set_sensitive (GTK_WIDGET (fs), TRUE);
gimp_unset_busy (gimp);
g_strfreev (selections);
gtk_widget_set_sensitive (open_dialog, TRUE);
gimp_unset_busy (gimp);
}
}
static void
file_open_ok_callback (GtkWidget *widget,
gpointer data)
GtkWidget *open_dialog)
{
GtkFileSelection *fs;
Gimp *gimp;
gchar *entered_filename;
GimpPDBStatusType status;
gchar **selections;
gint i;
gchar *uri;
GtkFileSelection *fs;
Gimp *gimp;
gchar **selections;
gchar *uri;
const gchar *entered_filename;
gint i;
fs = GTK_FILE_SELECTION (data);
fs = GTK_FILE_SELECTION (open_dialog);
gimp = GIMP (g_object_get_data (G_OBJECT (fs), "gimp"));
gimp = GIMP (g_object_get_data (G_OBJECT (open_dialog), "gimp"));
selections = gtk_file_selection_get_selections (fs);
if (selections == NULL)
return;
if (g_file_test (selections[0], G_FILE_TEST_IS_DIR))
entered_filename = gtk_entry_get_text (GTK_ENTRY (fs->selection_entry));
if (g_file_test (selections[0], G_FILE_TEST_EXISTS))
{
if (selections[0][strlen (selections[0]) - 1] != G_DIR_SEPARATOR)
{
gchar *s = g_strconcat (selections[0], G_DIR_SEPARATOR_S, NULL);
gtk_file_selection_set_filename (fs, s);
g_free (s);
}
else
if (g_file_test (selections[0], G_FILE_TEST_IS_DIR))
{
gtk_file_selection_set_filename (fs, selections[0]);
if (selections[0][strlen (selections[0]) - 1] != G_DIR_SEPARATOR)
{
gchar *s = g_strconcat (selections[0], G_DIR_SEPARATOR_S, NULL);
gtk_file_selection_set_filename (fs, s);
g_free (s);
}
else
{
gtk_file_selection_set_filename (fs, selections[0]);
}
g_strfreev (selections);
return;
}
g_strfreev (selections);
return;
uri = g_filename_to_uri (selections[0], NULL, NULL);
}
entered_filename =
g_strdup (gtk_entry_get_text (GTK_ENTRY (fs->selection_entry)));
gtk_widget_set_sensitive (GTK_WIDGET (fs), FALSE);
if (! g_file_test (selections[0], G_FILE_TEST_EXISTS))
{
else
{
/* try with the entered filename in case the user typed an URI */
uri = g_strdup (entered_filename);
}
else
{
uri = g_filename_to_uri (selections[0], NULL, NULL);
}
status = file_open_with_proc_and_display (gimp,
uri,
entered_filename,
load_file_proc);
gtk_widget_set_sensitive (open_dialog, FALSE);
file_open_dialog_open_image (open_dialog,
gimp,
uri,
entered_filename,
load_file_proc);
g_free (entered_filename);
g_free (uri);
if (status == GIMP_PDB_SUCCESS)
{
file_dialog_hide (data);
}
else if (status != GIMP_PDB_CANCEL)
{
/* Hackery required. Please add error message. --bex */
g_message (_("Opening '%s' failed."), uri);
}
/*
* Now deal with multiple selections from the filesel list
*/
@ -527,20 +485,11 @@ file_open_ok_callback (GtkWidget *widget,
{
uri = g_filename_to_uri (selections[i], NULL, NULL);
status = file_open_with_proc_and_display (gimp,
uri,
uri,
load_file_proc);
if (status == GIMP_PDB_SUCCESS)
{
file_dialog_hide (data);
}
else if (status != GIMP_PDB_CANCEL)
{
/* same as previous. --bex */
g_message (_("Opening '%s' failed."), uri);
}
file_open_dialog_open_image (open_dialog,
gimp,
uri,
uri,
load_file_proc);
g_free (uri);
}
@ -548,5 +497,30 @@ file_open_ok_callback (GtkWidget *widget,
g_strfreev (selections);
gtk_widget_set_sensitive (GTK_WIDGET (fs), TRUE);
gtk_widget_set_sensitive (open_dialog, TRUE);
}
static void
file_open_dialog_open_image (GtkWidget *open_dialog,
Gimp *gimp,
const gchar *uri,
const gchar *entered_filename,
PlugInProcDef *load_proc)
{
GimpPDBStatusType status;
status = file_open_with_proc_and_display (gimp,
uri,
entered_filename,
load_proc);
if (status == GIMP_PDB_SUCCESS)
{
file_dialog_hide (open_dialog);
}
else if (status != GIMP_PDB_CANCEL)
{
/* Hackery required. Please add error message. --bex */
g_message (_("Opening '%s' failed."), uri);
}
}

336
app/gui/file-save-dialog.c
View file

@ -55,37 +55,32 @@
#include "libgimp/gimpintl.h"
typedef struct _OverwriteData OverwriteData;
/* local function prototypes */
struct _OverwriteData
{
gchar *uri;
gchar *raw_filename;
};
static GtkWidget * file_save_dialog_create (Gimp *gimp);
static void file_save_type_callback (GtkWidget *widget,
gpointer data);
static void file_save_ok_callback (GtkWidget *widget,
GtkWidget *save_dialog);
static void file_save_overwrite (GtkWidget *save_dialog,
const gchar *uri,
const gchar *raw_filename);
static void file_save_overwrite_callback (GtkWidget *widget,
gboolean overwrite,
gpointer data);
static void file_save_dialog_save_image (GtkWidget *save_dialog,
GimpImage *gimage,
const gchar *uri,
const gchar *raw_filename,
PlugInProcDef *save_proc,
gboolean set_uri);
static void file_save_dialog_create (void);
static void file_overwrite (const gchar *uri,
const gchar *raw_filename);
static void file_overwrite_callback (GtkWidget *widget,
gboolean overwrite,
gpointer data);
static void file_save_ok_callback (GtkWidget *widget,
gpointer data);
static void file_save_type_callback (GtkWidget *widget,
gpointer data);
static GtkWidget *filesave = NULL;
static GtkWidget *save_options = NULL;
static GtkWidget *filesave = NULL;
static PlugInProcDef *save_file_proc = NULL;
static GimpImage *the_gimage = NULL;
static gboolean set_uri = TRUE;
static GimpImage *the_gimage = NULL;
static gboolean set_uri = TRUE;
/* public functions */
@ -160,8 +155,7 @@ file_save_dialog_show (GimpImage *gimage)
return;
the_gimage = gimage;
set_uri = TRUE;
set_uri = TRUE;
uri = gimp_object_get_name (GIMP_OBJECT (gimage));
@ -169,7 +163,7 @@ file_save_dialog_show (GimpImage *gimage)
filename = g_filename_from_uri (uri, NULL, NULL);
if (! filesave)
file_save_dialog_create ();
filesave = file_save_dialog_create (gimage->gimp);
gtk_widget_set_sensitive (GTK_WIDGET (filesave), TRUE);
if (GTK_WIDGET_VISIBLE (filesave))
@ -200,8 +194,7 @@ file_save_a_copy_dialog_show (GimpImage *gimage)
return;
the_gimage = gimage;
set_uri = FALSE;
set_uri = FALSE;
uri = gimp_object_get_name (GIMP_OBJECT (gimage));
@ -209,7 +202,7 @@ file_save_a_copy_dialog_show (GimpImage *gimage)
filename = g_filename_from_uri (uri, NULL, NULL);
if (! filesave)
file_save_dialog_create ();
filesave = file_save_dialog_create (gimage->gimp);
gtk_widget_set_sensitive (GTK_WIDGET (filesave), TRUE);
if (GTK_WIDGET_VISIBLE (filesave))
@ -231,74 +224,14 @@ file_save_a_copy_dialog_show (GimpImage *gimage)
/* private functions */
static void
file_save_dialog_create (void)
static GtkWidget *
file_save_dialog_create (Gimp *gimp)
{
GtkFileSelection *file_sel;
filesave = gtk_file_selection_new (_("Save Image"));
gtk_window_set_wmclass (GTK_WINDOW (filesave), "save_image", "Gimp");
gtk_window_set_position (GTK_WINDOW (filesave), GTK_WIN_POS_MOUSE);
file_sel = GTK_FILE_SELECTION (filesave);
gtk_container_set_border_width (GTK_CONTAINER (filesave), 2);
gtk_container_set_border_width (GTK_CONTAINER (file_sel->button_area), 2);
g_signal_connect_swapped (G_OBJECT (file_sel->cancel_button), "clicked",
G_CALLBACK (file_dialog_hide),
filesave);
g_signal_connect (G_OBJECT (filesave), "delete_event",
G_CALLBACK (file_dialog_hide),
NULL);
g_signal_connect (G_OBJECT (file_sel->ok_button), "clicked",
G_CALLBACK (file_save_ok_callback),
filesave);
/* Connect the "F1" help key */
gimp_help_connect (filesave,
gimp_standard_help_func,
"save/dialogs/file_save.html");
{
GimpItemFactory *item_factory;
GtkWidget *frame;
GtkWidget *hbox;
GtkWidget *label;
GtkWidget *option_menu;
save_options = gtk_hbox_new (TRUE, 1);
frame = gtk_frame_new (_("Save Options"));
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
gtk_box_pack_start (GTK_BOX (save_options), frame, TRUE, TRUE, 4);
hbox = gtk_hbox_new (FALSE, 4);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 4);
gtk_container_add (GTK_CONTAINER (frame), hbox);
gtk_widget_show (hbox);
label = gtk_label_new (_("Determine File Type:"));
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
option_menu = gtk_option_menu_new ();
gtk_box_pack_start (GTK_BOX (hbox), option_menu, TRUE, TRUE, 0);
gtk_widget_show (option_menu);
item_factory = gimp_item_factory_from_path ("<Save>");
gtk_option_menu_set_menu (GTK_OPTION_MENU (option_menu),
GTK_ITEM_FACTORY (item_factory)->widget);
gtk_widget_show (frame);
/* pack the containing save_options hbox into the save-dialog */
gtk_box_pack_end (GTK_BOX (GTK_FILE_SELECTION (filesave)->main_vbox),
save_options, FALSE, FALSE, 0);
}
gtk_widget_show (save_options);
return file_dialog_new (gimp,
gimp_item_factory_from_path ("<Save>"),
_("Save Image"), "save_image",
"save/dialogs/file_save.html",
G_CALLBACK (file_save_ok_callback));
}
static void
@ -314,18 +247,14 @@ file_save_type_callback (GtkWidget *widget,
static void
file_save_ok_callback (GtkWidget *widget,
gpointer data)
GtkWidget *save_dialog)
{
GtkFileSelection *fs;
const gchar *filename;
const gchar *raw_filename;
gchar *uri;
gchar *dot;
gint x;
struct stat buf;
gint err;
fs = GTK_FILE_SELECTION (data);
fs = GTK_FILE_SELECTION (save_dialog);
filename = gtk_file_selection_get_filename (fs);
raw_filename = gtk_entry_get_text (GTK_ENTRY (fs->selection_entry));
@ -334,48 +263,53 @@ file_save_ok_callback (GtkWidget *widget,
uri = g_filename_to_uri (filename, NULL, NULL);
for (dot = strrchr (filename, '.'), x = 0; dot && *(++dot);)
{
gchar *dot;
gint x;
for (dot = strrchr (filename, '.'), x = 0; dot && *(++dot);)
{
if (*dot != 'e' || ++x < 0)
{
break;
}
else if (x > 3 && !strcmp (dot + 1, "k"))
{
ProcRecord *proc_rec;
Argument *args;
GimpDrawable *drawable;
file_dialog_hide (save_dialog);
drawable = gimp_image_active_drawable (the_gimage);
if (! drawable)
return;
proc_rec = procedural_db_lookup (the_gimage->gimp,
"plug_in_the_slimy_egg");
if (! proc_rec)
return;
args = g_new (Argument, 3);
args[0].arg_type = GIMP_PDB_INT32;
args[0].value.pdb_int = GIMP_RUN_INTERACTIVE;
args[1].arg_type = GIMP_PDB_IMAGE;
args[1].value.pdb_int = gimp_image_get_ID (the_gimage);
args[2].arg_type = GIMP_PDB_DRAWABLE;
args[2].value.pdb_int = gimp_item_get_ID (GIMP_ITEM (drawable));
plug_in_run (the_gimage->gimp, proc_rec, args, 3, FALSE, TRUE, 0);
g_free (args);
return;
}
}
}
if (g_file_test (filename, G_FILE_TEST_EXISTS))
{
if (*dot != 'e' || ++x < 0)
break;
else if (x > 3 && !strcmp (dot + 1, "k"))
{
ProcRecord *proc_rec;
Argument *args;
GimpDrawable *the_drawable;
the_drawable = gimp_image_active_drawable (the_gimage);
if (!the_drawable)
return;
proc_rec = procedural_db_lookup (the_gimage->gimp,
"plug_in_the_slimy_egg");
if (!proc_rec)
break;
file_dialog_hide (filesave);
args = g_new (Argument, 3);
args[0].arg_type = GIMP_PDB_INT32;
args[0].value.pdb_int = GIMP_RUN_INTERACTIVE;
args[1].arg_type = GIMP_PDB_IMAGE;
args[1].value.pdb_int = gimp_image_get_ID (the_gimage);
args[2].arg_type = GIMP_PDB_DRAWABLE;
args[2].value.pdb_int = gimp_item_get_ID (GIMP_ITEM (the_drawable));
plug_in_run (the_gimage->gimp, proc_rec, args, 3, FALSE, TRUE, 0);
g_free (args);
return;
}
}
err = stat (filename, &buf);
if (err == 0)
{
if (buf.st_mode & S_IFDIR)
if (g_file_test (filename, G_FILE_TEST_IS_DIR))
{
if (filename[strlen (filename) - 1] != G_DIR_SEPARATOR)
{
@ -390,41 +324,37 @@ file_save_ok_callback (GtkWidget *widget,
}
else
{
gtk_widget_set_sensitive (GTK_WIDGET (fs), FALSE);
file_overwrite (uri, raw_filename);
file_save_overwrite (save_dialog, uri, raw_filename);
}
}
else
{
GimpPDBStatusType status;
gtk_widget_set_sensitive (GTK_WIDGET (fs), FALSE);
status = file_save (the_gimage,
uri,
raw_filename,
save_file_proc,
GIMP_RUN_INTERACTIVE,
set_uri);
if (status != GIMP_PDB_SUCCESS &&
status != GIMP_PDB_CANCEL)
{
/* Please add error. (: %s) --bex */
g_message (_("Saving %s failed."), uri);
}
else
{
file_dialog_hide (GTK_WIDGET (fs));
}
file_save_dialog_save_image (save_dialog,
the_gimage,
uri,
raw_filename,
save_file_proc,
set_uri);
gtk_widget_set_sensitive (GTK_WIDGET (fs), TRUE);
}
}
typedef struct _OverwriteData OverwriteData;
struct _OverwriteData
{
GtkWidget *save_dialog;
gchar *uri;
gchar *raw_filename;
};
static void
file_overwrite (const gchar *uri,
const gchar *raw_filename)
file_save_overwrite (GtkWidget *save_dialog,
const gchar *uri,
const gchar *raw_filename)
{
OverwriteData *overwrite_data;
GtkWidget *query_box;
@ -432,6 +362,7 @@ file_overwrite (const gchar *uri,
overwrite_data = g_new0 (OverwriteData, 1);
overwrite_data->save_dialog = save_dialog;
overwrite_data->uri = g_strdup (uri);
overwrite_data->raw_filename = g_strdup (raw_filename);
@ -445,18 +376,20 @@ file_overwrite (const gchar *uri,
overwrite_text,
GTK_STOCK_YES, GTK_STOCK_NO,
NULL, NULL,
file_overwrite_callback,
file_save_overwrite_callback,
overwrite_data);
g_free (overwrite_text);
gtk_widget_show (query_box);
gtk_widget_set_sensitive (save_dialog, FALSE);
}
static void
file_overwrite_callback (GtkWidget *widget,
gboolean overwrite,
gpointer data)
file_save_overwrite_callback (GtkWidget *widget,
gboolean overwrite,
gpointer data)
{
OverwriteData *overwrite_data;
@ -464,31 +397,46 @@ file_overwrite_callback (GtkWidget *widget,
if (overwrite)
{
GimpPDBStatusType status;
status = file_save (the_gimage,
overwrite_data->uri,
overwrite_data->raw_filename,
save_file_proc,
GIMP_RUN_INTERACTIVE,
set_uri);
if (status != GIMP_PDB_SUCCESS &&
status != GIMP_PDB_CANCEL)
{
/* Another error required. --bex */
g_message (_("Saving '%s' failed."), overwrite_data->uri);
}
else
{
file_dialog_hide (GTK_WIDGET (filesave));
}
file_save_dialog_save_image (overwrite_data->save_dialog,
the_gimage,
overwrite_data->uri,
overwrite_data->raw_filename,
save_file_proc,
set_uri);
}
/* always make file save dialog sensitive */
gtk_widget_set_sensitive (GTK_WIDGET (filesave), TRUE);
gtk_widget_set_sensitive (overwrite_data->save_dialog, TRUE);
g_free (overwrite_data->uri);
g_free (overwrite_data->raw_filename);
g_free (overwrite_data);
}
static void
file_save_dialog_save_image (GtkWidget *save_dialog,
GimpImage *gimage,
const gchar *uri,
const gchar *raw_filename,
PlugInProcDef *save_proc,
gboolean set_uri)
{
GimpPDBStatusType status;
status = file_save (gimage,
uri,
raw_filename,
save_proc,
GIMP_RUN_INTERACTIVE,
set_uri);
if (status != GIMP_PDB_SUCCESS &&
status != GIMP_PDB_CANCEL)
{
/* Another error required. --bex */
g_message (_("Saving '%s' failed."), uri);
}
else
{
file_dialog_hide (save_dialog);
}
}

4
po/ChangeLog
View file

@ -1,3 +1,7 @@
2002-04-18 Michael Natterer <mitch@gimp.org>
* POTFILES.in: added app/gui/file-dialog-utils.c
2002-04-15 Christophe Merlet <redfox@eikonex.org>
* fr.po: Updated French translation from work of

1
po/POTFILES.in
View file

@ -69,6 +69,7 @@ app/gui/drawable-commands.c
app/gui/edit-commands.c
app/gui/error-console-dialog.c
app/gui/file-commands.c
app/gui/file-dialog-utils.c
app/gui/file-new-dialog.c
app/gui/file-open-dialog.c
app/gui/file-save-dialog.c