gboolean
gimp_pdb_item_is_group (GimpItem *item,
GError **error)
{
g_return_val_if_fail (GIMP_IS_ITEM (item), FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
if (! gimp_viewable_get_children (GIMP_VIEWABLE (item)))
{
g_set_error (error, GIMP_PDB_ERROR, GIMP_PDB_INVALID_ARGUMENT,
_("Item '%s' (%d) cannot be used because it is "
"not a group item"),
gimp_object_get_name (item),
gimp_item_get_ID (item));
return FALSE;
}
return TRUE;
}
gboolean
gimp_pdb_item_is_writable (GimpItem *item,
GError **error)
{
g_return_val_if_fail (GIMP_IS_ITEM (item), FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
if (gimp_item_is_content_locked (item))
{
g_set_error (error, GIMP_PDB_ERROR, GIMP_PDB_INVALID_ARGUMENT,
_("Item '%s' (%d) cannot be modified because its "
"contents are locked"),
gimp_object_get_name (item),
gimp_item_get_ID (item));
return FALSE;
}
return TRUE;
}
gboolean
gimp_pdb_layer_is_text_layer (GimpLayer *layer,
GimpPDBItemModify modify,
GError **error)
{
g_return_val_if_fail (GIMP_IS_LAYER (layer), FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
if (! gimp_item_is_text_layer (GIMP_ITEM (layer)))
{
g_set_error (error, GIMP_PDB_ERROR, GIMP_PDB_ERROR_INVALID_ARGUMENT,
_("Layer '%s' (%d) cannot be used because it is not "
"a text layer"),
gimp_object_get_name (layer),
gimp_item_get_ID (GIMP_ITEM (layer)));
return FALSE;
}
return gimp_pdb_item_is_attached (GIMP_ITEM (layer), NULL, modify, error);
}
static void
gimp_viewable_dialog_name_changed (GimpObject *object,
GimpViewableDialog *dialog)
{
gchar *name;
name = gimp_viewable_get_description (GIMP_VIEWABLE (object), NULL);
if (GIMP_IS_ITEM (object))
{
GimpImage *image = gimp_item_get_image (GIMP_ITEM (object));
gchar *tmp;
tmp = name;
name = g_strdup_printf ("%s-%d (%s)",
tmp,
gimp_item_get_ID (GIMP_ITEM (object)),
gimp_image_get_display_name (image));
g_free (tmp);
}
gtk_label_set_text (GTK_LABEL (dialog->viewable_label), name);
g_free (name);
}
GimpPDBStatusType
file_save (Gimp *gimp,
GimpImage *image,
GimpProgress *progress,
const gchar *uri,
GimpPlugInProcedure *file_proc,
GimpRunMode run_mode,
gboolean change_saved_state,
gboolean export_backward,
gboolean export_forward,
GError **error)
{
GimpDrawable *drawable;
GimpValueArray *return_vals;
GimpPDBStatusType status;
gchar *filename;
gint32 image_ID;
gint32 drawable_ID;
g_return_val_if_fail (GIMP_IS_GIMP (gimp), GIMP_PDB_CALLING_ERROR);
g_return_val_if_fail (GIMP_IS_IMAGE (image), GIMP_PDB_CALLING_ERROR);
g_return_val_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress),
GIMP_PDB_CALLING_ERROR);
g_return_val_if_fail (uri != NULL, GIMP_PDB_CALLING_ERROR);
g_return_val_if_fail (GIMP_IS_PLUG_IN_PROCEDURE (file_proc),
GIMP_PDB_CALLING_ERROR);
g_return_val_if_fail ((export_backward && export_forward) == FALSE,
GIMP_PDB_CALLING_ERROR);
g_return_val_if_fail (error == NULL || *error == NULL,
GIMP_PDB_CALLING_ERROR);
drawable = gimp_image_get_active_drawable (image);
if (! drawable)
return GIMP_PDB_EXECUTION_ERROR;
filename = file_utils_filename_from_uri (uri);
if (filename)
{
/* check if we are saving to a file */
if (g_file_test (filename, G_FILE_TEST_EXISTS))
{
if (! g_file_test (filename, G_FILE_TEST_IS_REGULAR))
{
g_set_error_literal (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
_("Not a regular file"));
status = GIMP_PDB_EXECUTION_ERROR;
goto out;
}
if (g_access (filename, W_OK) != 0)
{
g_set_error_literal (error, G_FILE_ERROR, G_FILE_ERROR_ACCES,
g_strerror (errno));
status = GIMP_PDB_EXECUTION_ERROR;
goto out;
}
}
if (file_proc->handles_uri)
{
g_free (filename);
filename = g_strdup (uri);
}
}
else
{
filename = g_strdup (uri);
}
/* ref the image, so it can't get deleted during save */
g_object_ref (image);
image_ID = gimp_image_get_ID (image);
drawable_ID = gimp_item_get_ID (GIMP_ITEM (drawable));
return_vals =
gimp_pdb_execute_procedure_by_name (image->gimp->pdb,
gimp_get_user_context (gimp),
progress, error,
gimp_object_get_name (file_proc),
GIMP_TYPE_INT32, run_mode,
GIMP_TYPE_IMAGE_ID, image_ID,
GIMP_TYPE_DRAWABLE_ID, drawable_ID,
G_TYPE_STRING, filename,
G_TYPE_STRING, uri,
G_TYPE_NONE);
status = g_value_get_enum (gimp_value_array_index (return_vals, 0));
gimp_value_array_unref (return_vals);
if (status == GIMP_PDB_SUCCESS)
{
GimpDocumentList *documents;
GimpImagefile *imagefile;
if (change_saved_state)
{
gimp_image_set_uri (image, uri);
gimp_image_set_save_proc (image, file_proc);
/* Forget the import source when we save. We interpret a
* save as that the user is not interested in being able
* to quickly export back to the original any longer
*/
gimp_image_set_imported_uri (image, NULL);
gimp_image_clean_all (image);
}
else if (export_backward)
{
/* We exported the image back to its imported source,
* change nothing about export/import flags, only set
* the export state to clean
*/
gimp_image_export_clean_all (image);
gimp_object_name_changed (GIMP_OBJECT (image));
}
else if (export_forward)
{
/* Remember the last entered Export URI for the image. We
* only need to do this explicitly when exporting. It
* happens implicitly when saving since the GimpObject name
* of a GimpImage is the last-save URI
*/
gimp_image_set_exported_uri (image, uri);
/* An image can not be considered both exported and imported
* at the same time, so stop consider it as imported now
* that we consider it exported.
*/
gimp_image_set_imported_uri (image, NULL);
gimp_image_export_clean_all (image);
}
if (export_backward || export_forward)
gimp_image_exported (image, uri);
else
gimp_image_saved (image, uri);
documents = GIMP_DOCUMENT_LIST (image->gimp->documents);
imagefile = gimp_document_list_add_uri (documents,
uri,
file_proc->mime_type);
/* only save a thumbnail if we are saving as XCF, see bug #25272 */
if (GIMP_PROCEDURE (file_proc)->proc_type == GIMP_INTERNAL)
gimp_imagefile_save_thumbnail (imagefile, file_proc->mime_type, image);
}
else if (status != GIMP_PDB_CANCEL)
{
if (error && *error == NULL)
{
g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
_("%s plug-in could not save image"),
gimp_plug_in_procedure_get_label (file_proc));
}
}
gimp_image_flush (image);
g_object_unref (image);
out:
g_free (filename);
return status;
}
GimpPDBStatusType
file_save (Gimp *gimp,
GimpImage *image,
GimpProgress *progress,
GFile *file,
GimpPlugInProcedure *file_proc,
GimpRunMode run_mode,
gboolean change_saved_state,
gboolean export_backward,
gboolean export_forward,
GError **error)
{
GimpDrawable *drawable;
GimpValueArray *return_vals;
GimpPDBStatusType status = GIMP_PDB_EXECUTION_ERROR;
GFile *local_file = NULL;
gchar *path = NULL;
gchar *uri = NULL;
gint32 image_ID;
gint32 drawable_ID;
GError *my_error = NULL;
g_return_val_if_fail (GIMP_IS_GIMP (gimp), GIMP_PDB_CALLING_ERROR);
g_return_val_if_fail (GIMP_IS_IMAGE (image), GIMP_PDB_CALLING_ERROR);
g_return_val_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress),
GIMP_PDB_CALLING_ERROR);
g_return_val_if_fail (G_IS_FILE (file), GIMP_PDB_CALLING_ERROR);
g_return_val_if_fail (GIMP_IS_PLUG_IN_PROCEDURE (file_proc),
GIMP_PDB_CALLING_ERROR);
g_return_val_if_fail ((export_backward && export_forward) == FALSE,
GIMP_PDB_CALLING_ERROR);
g_return_val_if_fail (error == NULL || *error == NULL,
GIMP_PDB_CALLING_ERROR);
/* ref image and file, so they can't get deleted during save */
g_object_ref (image);
g_object_ref (file);
drawable = gimp_image_get_active_drawable (image);
if (! drawable)
goto out;
/* FIXME enable these tests for remote files again, needs testing */
if (g_file_is_native (file) &&
g_file_query_exists (file, NULL))
{
GFileInfo *info;
info = g_file_query_info (file,
G_FILE_ATTRIBUTE_STANDARD_TYPE ","
G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE,
G_FILE_QUERY_INFO_NONE,
NULL, error);
if (! info)
goto out;
if (g_file_info_get_file_type (info) != G_FILE_TYPE_REGULAR)
{
g_set_error_literal (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
_("Not a regular file"));
g_object_unref (info);
goto out;
}
if (! g_file_info_get_attribute_boolean (info,
G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE))
{
g_set_error_literal (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
_("Permission denied"));
g_object_unref (info);
goto out;
}
g_object_unref (info);
}
if (! g_file_is_native (file) &&
! file_remote_mount_file (gimp, file, progress, &my_error))
{
if (my_error)
g_propagate_error (error, my_error);
else
status = GIMP_PDB_CANCEL;
goto out;
}
if (! file_proc->handles_uri)
{
path = g_file_get_path (file);
if (! path)
{
local_file = file_remote_upload_image_prepare (gimp, file, progress,
&my_error);
if (! local_file)
{
if (my_error)
g_propagate_error (error, my_error);
else
status = GIMP_PDB_CANCEL;
goto out;
}
path = g_file_get_path (local_file);
}
}
if (! path)
path = g_file_get_uri (file);
uri = g_file_get_uri (file);
image_ID = gimp_image_get_ID (image);
drawable_ID = gimp_item_get_ID (GIMP_ITEM (drawable));
return_vals =
gimp_pdb_execute_procedure_by_name (image->gimp->pdb,
gimp_get_user_context (gimp),
progress, error,
gimp_object_get_name (file_proc),
GIMP_TYPE_INT32, run_mode,
GIMP_TYPE_IMAGE_ID, image_ID,
GIMP_TYPE_DRAWABLE_ID, drawable_ID,
G_TYPE_STRING, path,
G_TYPE_STRING, uri,
G_TYPE_NONE);
status = g_value_get_enum (gimp_value_array_index (return_vals, 0));
gimp_value_array_unref (return_vals);
if (local_file)
{
if (status == GIMP_PDB_SUCCESS)
{
GError *my_error = NULL;
if (! file_remote_upload_image_finish (gimp, file, local_file,
progress, &my_error))
{
status = GIMP_PDB_EXECUTION_ERROR;
if (my_error)
g_propagate_error (error, my_error);
else
status = GIMP_PDB_CANCEL;
}
}
g_file_delete (local_file, NULL, NULL);
g_object_unref (local_file);
}
if (status == GIMP_PDB_SUCCESS)
{
GimpDocumentList *documents;
GimpImagefile *imagefile;
if (change_saved_state)
{
gimp_image_set_file (image, file);
gimp_image_set_save_proc (image, file_proc);
/* Forget the import source when we save. We interpret a
* save as that the user is not interested in being able
* to quickly export back to the original any longer
*/
gimp_image_set_imported_file (image, NULL);
gimp_image_clean_all (image);
}
else if (export_backward)
{
/* We exported the image back to its imported source,
* change nothing about export/import flags, only set
* the export state to clean
*/
gimp_image_export_clean_all (image);
gimp_object_name_changed (GIMP_OBJECT (image));
}
else if (export_forward)
{
/* Remember the last entered Export URI for the image. We
* only need to do this explicitly when exporting. It
* happens implicitly when saving since the GimpObject name
* of a GimpImage is the last-save URI
*/
gimp_image_set_exported_file (image, file);
gimp_image_set_export_proc (image, file_proc);
/* An image can not be considered both exported and imported
* at the same time, so stop consider it as imported now
* that we consider it exported.
*/
gimp_image_set_imported_file (image, NULL);
gimp_image_export_clean_all (image);
}
if (export_backward || export_forward)
gimp_image_exported (image, file);
else
gimp_image_saved (image, file);
documents = GIMP_DOCUMENT_LIST (image->gimp->documents);
imagefile = gimp_document_list_add_file (documents, file,
file_proc->mime_type);
/* only save a thumbnail if we are saving as XCF, see bug #25272 */
if (GIMP_PROCEDURE (file_proc)->proc_type == GIMP_INTERNAL)
gimp_imagefile_save_thumbnail (imagefile, file_proc->mime_type, image,
NULL);
}
else if (status != GIMP_PDB_CANCEL)
{
if (error && *error == NULL)
{
g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
_("%s plug-in could not save image"),
gimp_plug_in_procedure_get_label (file_proc));
}
}
gimp_image_flush (image);
out:
g_object_unref (file);
g_object_unref (image);
g_free (path);
g_free (uri);
return status;
}
static gint
gimp_display_shell_format_title (GimpDisplayShell *shell,
gchar *title,
gint title_len,
const gchar *format)
{
GimpImage *image;
gint num, denom;
gint i = 0;
g_return_val_if_fail (GIMP_IS_DISPLAY_SHELL (shell), 0);
image = gimp_display_get_image (shell->display);
if (! image)
{
title[0] = '\n';
return 0;
}
gimp_zoom_model_get_fraction (shell->zoom, &num, &denom);
while (i < title_len && *format)
{
switch (*format)
{
case '%':
format++;
switch (*format)
{
case 0:
/* format string ends within %-sequence, print literal '%' */
case '%':
title[i++] = '%';
break;
case 'f': /* base filename */
i += print (title, title_len, i, "%s",
gimp_image_get_display_name (image));
break;
case 'F': /* full filename */
i += print (title, title_len, i, "%s",
gimp_image_get_display_path (image));
break;
case 'p': /* PDB id */
i += print (title, title_len, i, "%d", gimp_image_get_ID (image));
break;
case 'i': /* instance */
i += print (title, title_len, i, "%d",
gimp_display_get_instance (shell->display));
break;
case 't': /* image type */
i += print (title, title_len, i, "%s %s",
gimp_display_shell_title_image_type (image),
gimp_display_shell_title_image_precision (image));
break;
case 'T': /* drawable type */
{
GimpDrawable *drawable = gimp_image_get_active_drawable (image);
const Babl *format = gimp_drawable_get_format (drawable);
if (drawable)
i += print (title, title_len, i, "%s",
gimp_babl_get_description (format));
}
break;
case 's': /* user source zoom factor */
i += print (title, title_len, i, "%d", denom);
break;
case 'd': /* user destination zoom factor */
i += print (title, title_len, i, "%d", num);
break;
case 'z': /* user zoom factor (percentage) */
{
gdouble scale = gimp_zoom_model_get_factor (shell->zoom);
i += print (title, title_len, i,
scale >= 0.15 ? "%.0f" : "%.2f", 100.0 * scale);
}
break;
case 'D': /* dirty flag */
if (format[1] == 0)
{
/* format string ends within %D-sequence, print literal '%D' */
i += print (title, title_len, i, "%%D");
break;
}
if (gimp_image_is_dirty (image))
title[i++] = format[1];
format++;
break;
case 'C': /* clean flag */
if (format[1] == 0)
{
/* format string ends within %C-sequence, print literal '%C' */
i += print (title, title_len, i, "%%C");
break;
}
if (! gimp_image_is_dirty (image))
title[i++] = format[1];
format++;
break;
case 'B': /* dirty flag (long) */
if (gimp_image_is_dirty (image))
i += print (title, title_len, i, "%s", _("(modified)"));
break;
case 'A': /* clean flag (long) */
if (! gimp_image_is_dirty (image))
i += print (title, title_len, i, "%s", _("(clean)"));
break;
case 'm': /* memory used by image */
{
GimpObject *object = GIMP_OBJECT (image);
gchar *str;
str = g_format_size (gimp_object_get_memsize (object, NULL));
i += print (title, title_len, i, "%s", str);
g_free (str);
}
break;
case 'M': /* image size in megapixels */
i += print (title, title_len, i, "%.1f",
(gdouble) gimp_image_get_width (image) *
(gdouble) gimp_image_get_height (image) / 1000000.0);
break;
case 'l': /* number of layers */
i += print (title, title_len, i, "%d",
gimp_image_get_n_layers (image));
break;
case 'L': /* number of layers (long) */
{
gint num = gimp_image_get_n_layers (image);
i += print (title, title_len, i,
ngettext ("%d layer", "%d layers", num), num);
}
break;
case 'n': /* active drawable name */
{
GimpDrawable *drawable = gimp_image_get_active_drawable (image);
if (drawable)
{
gchar *desc;
desc = gimp_viewable_get_description (GIMP_VIEWABLE (drawable),
NULL);
i += print (title, title_len, i, "%s", desc);
g_free (desc);
}
else
{
i += print (title, title_len, i, "%s", _("(none)"));
}
}
break;
case 'P': /* active drawable PDB id */
{
GimpDrawable *drawable = gimp_image_get_active_drawable (image);
if (drawable)
i += print (title, title_len, i, "%d",
gimp_item_get_ID (GIMP_ITEM (drawable)));
else
i += print (title, title_len, i, "%s", _("(none)"));
}
break;
case 'W': /* width in real-world units */
if (shell->unit != GIMP_UNIT_PIXEL)
{
gdouble xres;
gdouble yres;
gchar unit_format[8];
gimp_image_get_resolution (image, &xres, &yres);
g_snprintf (unit_format, sizeof (unit_format), "%%.%df",
gimp_unit_get_digits (shell->unit) + 1);
i += print (title, title_len, i, unit_format,
gimp_pixels_to_units (gimp_image_get_width (image),
shell->unit, xres));
break;
}
/* else fallthru */
case 'w': /* width in pixels */
i += print (title, title_len, i, "%d",
gimp_image_get_width (image));
break;
case 'H': /* height in real-world units */
if (shell->unit != GIMP_UNIT_PIXEL)
{
gdouble xres;
gdouble yres;
gchar unit_format[8];
gimp_image_get_resolution (image, &xres, &yres);
g_snprintf (unit_format, sizeof (unit_format), "%%.%df",
gimp_unit_get_digits (shell->unit) + 1);
i += print (title, title_len, i, unit_format,
gimp_pixels_to_units (gimp_image_get_height (image),
shell->unit, yres));
break;
}
/* else fallthru */
case 'h': /* height in pixels */
i += print (title, title_len, i, "%d",
gimp_image_get_height (image));
break;
case 'u': /* unit symbol */
i += print (title, title_len, i, "%s",
gimp_unit_get_symbol (shell->unit));
break;
case 'U': /* unit abbreviation */
i += print (title, title_len, i, "%s",
gimp_unit_get_abbreviation (shell->unit));
break;
/* Other cool things to be added:
* %r = xresolution
* %R = yresolution
* %ø = image's fractal dimension
* %þ = the answer to everything
*/
default:
/* format string contains unknown %-sequence, print it literally */
i += print (title, title_len, i, "%%%c", *format);
break;
}
break;
default:
title[i++] = *format;
break;
}
format++;
}
title[MIN (i, title_len - 1)] = '\0';
return i;
}
static void
gimp_display_shell_format_title (GimpDisplayShell *shell,
gchar *title,
gint title_len,
const gchar *format)
{
Gimp *gimp;
GimpImage *image;
gint num, denom;
gint i = 0;
g_return_if_fail (GIMP_IS_DISPLAY_SHELL (shell));
image = shell->display->image;
gimp = image->gimp;
gimp_zoom_model_get_fraction (shell->zoom, &num, &denom);
while (i < title_len && *format)
{
switch (*format)
{
case '%':
format++;
switch (*format)
{
case 0:
/* format string ends within %-sequence, print literal '%' */
case '%':
title[i++] = '%';
break;
case 'f': /* pruned filename */
{
const gchar *uri = gimp_image_get_uri (image);
gchar *basename;
basename = file_utils_uri_display_basename (uri);
i += print (title, title_len, i, "%s", basename);
g_free (basename);
}
break;
case 'F': /* full filename */
{
gchar *filename;
const gchar *uri = gimp_image_get_uri (image);
filename = file_utils_uri_display_name (uri);
i += print (title, title_len, i, "%s", filename);
g_free (filename);
}
break;
case 'p': /* PDB id */
i += print (title, title_len, i, "%d", gimp_image_get_ID (image));
break;
case 'i': /* instance */
i += print (title, title_len, i, "%d", shell->display->instance);
break;
case 't': /* type */
{
const gchar *image_type_str = NULL;
gboolean empty = gimp_image_is_empty (image);
switch (gimp_image_base_type (image))
{
case GIMP_RGB:
image_type_str = empty ? _("RGB-empty") : _("RGB");
break;
case GIMP_GRAY:
image_type_str = empty ? _("grayscale-empty") : _("grayscale");
break;
case GIMP_INDEXED:
image_type_str = empty ? _("indexed-empty") : _("indexed");
break;
default:
g_assert_not_reached ();
break;
}
i += print (title, title_len, i, "%s", image_type_str);
}
break;
case 's': /* user source zoom factor */
i += print (title, title_len, i, "%d", denom);
break;
case 'd': /* user destination zoom factor */
i += print (title, title_len, i, "%d", num);
break;
case 'z': /* user zoom factor (percentage) */
{
gdouble scale = gimp_zoom_model_get_factor (shell->zoom);
i += print (title, title_len, i,
scale >= 0.15 ? "%.0f" : "%.2f", 100.0 * scale);
}
break;
case 'D': /* dirty flag */
if (format[1] == 0)
{
/* format string ends within %D-sequence, print literal '%D' */
i += print (title, title_len, i, "%%D");
break;
}
if (image->dirty)
title[i++] = format[1];
format++;
break;
case 'C': /* clean flag */
if (format[1] == 0)
{
/* format string ends within %C-sequence, print literal '%C' */
i += print (title, title_len, i, "%%C");
break;
}
if (! image->dirty)
title[i++] = format[1];
format++;
break;
case 'B': /* dirty flag (long) */
if (image->dirty)
i += print (title, title_len, i, "%s", _("(modified)"));
break;
case 'A': /* clean flag (long) */
if (! image->dirty)
i += print (title, title_len, i, "%s", _("(clean)"));
break;
case 'm': /* memory used by image */
{
GimpObject *object = GIMP_OBJECT (image);
gchar *str;
str = gimp_memsize_to_string (gimp_object_get_memsize (object,
NULL));
i += print (title, title_len, i, "%s", str);
g_free (str);
}
break;
case 'l': /* number of layers */
i += print (title, title_len, i, "%d",
gimp_container_num_children (image->layers));
break;
case 'L': /* number of layers (long) */
{
gint num = gimp_container_num_children (image->layers);
i += print (title, title_len, i,
ngettext ("%d layer", "%d layers", num), num);
}
break;
case 'n': /* active drawable name */
{
GimpDrawable *drawable = gimp_image_get_active_drawable (image);
if (drawable)
i += print (title, title_len, i, "%s",
gimp_object_get_name (GIMP_OBJECT (drawable)));
else
i += print (title, title_len, i, "%s", _("(none)"));
}
break;
case 'P': /* active drawable PDB id */
{
GimpDrawable *drawable = gimp_image_get_active_drawable (image);
if (drawable)
i += print (title, title_len, i, "%d",
gimp_item_get_ID (GIMP_ITEM (drawable)));
else
i += print (title, title_len, i, "%s", _("(none)"));
}
break;
case 'W': /* width in real-world units */
if (shell->unit != GIMP_UNIT_PIXEL)
{
gchar unit_format[8];
g_snprintf (unit_format, sizeof (unit_format), "%%.%df",
_gimp_unit_get_digits (gimp, shell->unit) + 1);
i += print (title, title_len, i, unit_format,
(image->width *
_gimp_unit_get_factor (gimp, shell->unit) /
image->xresolution));
break;
}
/* else fallthru */
case 'w': /* width in pixels */
i += print (title, title_len, i, "%d", image->width);
break;
case 'H': /* height in real-world units */
if (shell->unit != GIMP_UNIT_PIXEL)
{
gchar unit_format[8];
g_snprintf (unit_format, sizeof (unit_format), "%%.%df",
_gimp_unit_get_digits (gimp, shell->unit) + 1);
i += print (title, title_len, i, unit_format,
(image->height *
_gimp_unit_get_factor (gimp, shell->unit) /
image->yresolution));
break;
}
/* else fallthru */
case 'h': /* height in pixels */
i += print (title, title_len, i, "%d", image->height);
break;
case 'u': /* unit symbol */
i += print (title, title_len, i, "%s",
_gimp_unit_get_symbol (gimp, shell->unit));
break;
case 'U': /* unit abbreviation */
i += print (title, title_len, i, "%s",
_gimp_unit_get_abbreviation (gimp, shell->unit));
break;
/* Other cool things to be added:
* %r = xresolution
* %R = yresolution
* %ø = image's fractal dimension
* %þ = the answer to everything
*/
default:
/* format string contains unknown %-sequence, print it literally */
i += print (title, title_len, i, "%%%c", *format);
break;
}
break;
default:
title[i++] = *format;
break;
}
format++;
}
title[MIN (i, title_len - 1)] = '\0';
}
static GimpValueArray *
file_load_layers_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
const GimpValueArray *args,
GError **error)
{
gboolean success = TRUE;
GimpValueArray *return_vals;
gint32 run_mode;
GimpImage *image;
const gchar *filename;
gint32 num_layers = 0;
gint32 *layer_ids = NULL;
run_mode = g_value_get_enum (gimp_value_array_index (args, 0));
image = gimp_value_get_image (gimp_value_array_index (args, 1), gimp);
filename = g_value_get_string (gimp_value_array_index (args, 2));
if (success)
{
gchar *uri = file_utils_filename_to_uri (gimp, filename, error);
if (uri)
{
GList *layers;
GimpPDBStatusType status;
layers = file_open_layers (gimp, context, progress,
image, FALSE,
uri, run_mode, NULL, &status, error);
if (layers)
{
GList *list;
gint i;
num_layers = g_list_length (layers);
layer_ids = g_new (gint32, num_layers);
for (i = 0, list = layers;
i < num_layers;
i++, list = g_list_next (list))
layer_ids[i] = gimp_item_get_ID (GIMP_ITEM (list->data));
g_list_free (layers);
}
else
success = FALSE;
}
else
success = FALSE;
}
return_vals = gimp_procedure_get_return_values (procedure, success,
error ? *error : NULL);
if (success)
{
g_value_set_int (gimp_value_array_index (return_vals, 1), num_layers);
gimp_value_take_int32array (gimp_value_array_index (return_vals, 2), layer_ids, num_layers);
}
return return_vals;
}
GimpPDBStatusType
file_save (GimpImage *image,
GimpContext *context,
GimpProgress *progress,
const gchar *uri,
GimpPlugInProcedure *file_proc,
GimpRunMode run_mode,
gboolean save_a_copy,
GError **error)
{
GimpDrawable *drawable;
GValueArray *return_vals;
GimpPDBStatusType status;
gchar *filename;
gint32 image_ID;
gint32 drawable_ID;
g_return_val_if_fail (GIMP_IS_IMAGE (image), GIMP_PDB_CALLING_ERROR);
g_return_val_if_fail (GIMP_IS_CONTEXT (context), GIMP_PDB_CALLING_ERROR);
g_return_val_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress),
GIMP_PDB_CALLING_ERROR);
g_return_val_if_fail (uri != NULL, GIMP_PDB_CALLING_ERROR);
g_return_val_if_fail (GIMP_IS_PLUG_IN_PROCEDURE (file_proc),
GIMP_PDB_CALLING_ERROR);
g_return_val_if_fail (error == NULL || *error == NULL,
GIMP_PDB_CALLING_ERROR);
drawable = gimp_image_get_active_drawable (image);
if (! drawable)
return GIMP_PDB_EXECUTION_ERROR;
filename = file_utils_filename_from_uri (uri);
if (filename)
{
/* check if we are saving to a file */
if (g_file_test (filename, G_FILE_TEST_EXISTS))
{
if (! g_file_test (filename, G_FILE_TEST_IS_REGULAR))
{
g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
"%s", _("Not a regular file"));
status = GIMP_PDB_EXECUTION_ERROR;
goto out;
}
if (g_access (filename, W_OK) != 0)
{
g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_ACCES,
"%s", g_strerror (errno));
status = GIMP_PDB_EXECUTION_ERROR;
goto out;
}
}
}
else
{
filename = g_strdup (uri);
}
/* ref the image, so it can't get deleted during save */
g_object_ref (image);
image_ID = gimp_image_get_ID (image);
drawable_ID = gimp_item_get_ID (GIMP_ITEM (drawable));
return_vals =
gimp_pdb_execute_procedure_by_name (image->gimp->pdb,
context, progress, error,
GIMP_OBJECT (file_proc)->name,
GIMP_TYPE_INT32, run_mode,
GIMP_TYPE_IMAGE_ID, image_ID,
GIMP_TYPE_DRAWABLE_ID, drawable_ID,
G_TYPE_STRING, filename,
G_TYPE_STRING, uri,
G_TYPE_NONE);
status = g_value_get_enum (&return_vals->values[0]);
g_value_array_free (return_vals);
if (status == GIMP_PDB_SUCCESS)
{
GimpDocumentList *documents;
GimpImagefile *imagefile;
if (save_a_copy)
{
/* remember the "save-a-copy" filename for the next invocation */
g_object_set_data_full (G_OBJECT (image), "gimp-image-save-a-copy",
g_strdup (uri),
(GDestroyNotify) g_free);
}
else
{
/* reset the "save-a-copy" filename when the image URI changes */
if (strcmp (uri, gimp_image_get_uri (image)))
g_object_set_data (G_OBJECT (image),
"gimp-image-save-a-copy", NULL);
gimp_image_set_uri (image, uri);
gimp_image_set_save_proc (image, file_proc);
gimp_image_clean_all (image);
}
gimp_image_saved (image, uri);
documents = GIMP_DOCUMENT_LIST (image->gimp->documents);
imagefile = gimp_document_list_add_uri (documents,
uri,
file_proc->mime_type);
/* only save a thumbnail if we are saving as XCF, see bug #25272 */
if (GIMP_PROCEDURE (file_proc)->proc_type == GIMP_INTERNAL)
gimp_imagefile_save_thumbnail (imagefile, file_proc->mime_type, image);
}
else if (status != GIMP_PDB_CANCEL)
{
if (error && *error == NULL)
{
g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
_("%s plug-in could not save image"),
gimp_plug_in_procedure_get_label (file_proc));
}
}
gimp_image_flush (image);
g_object_unref (image);
out:
g_free (filename);
return status;
}