dnrops
/
gimp
mirror of https://github.com/GNOME/gimp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

app/plug-in/plug-in-proc-def.[ch] app/plug-in/plug-in-rc.c allow to 

2004-11-13  Sven Neumann  <sven@gimp.org>

	* app/plug-in/plug-in-proc-def.[ch]
	* app/plug-in/plug-in-rc.c
	* app/plug-in/plug-ins.[ch]: allow to associate a procedure for
	thumbnail loading with any file load procedure.

	* tools/pdbgen/pdb/fileops.pdb: export this functionality to the
	PDB as gimp_register_thumbnail_loader().

	* app/pdb/fileops_cmds.c
	* app/pdb/internal_procs.c
	* libgimp/gimpfileops_pdb.[ch]: regenerated.

	* app/core/gimpimagefile.c
	* app/file/file-open.[ch]: when creating a thumbnail for an image
	file, use a thumbnail load procedure if available.

	* plug-ins/common/svg.c: added "file_svg_load_thumb", a procedure
	that allows to load a small preview of the SVG image.
This commit is contained in:
Sven Neumann 2004-11-13 17:06:06 +00:00 committed by Sven Neumann
parent 4a0f6aa775
commit b62ca985aa
24 changed files with 612 additions and 122 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
ChangeLog
View File

@ -1,3 +1,24 @@
2004-11-13 Sven Neumann <sven@gimp.org>
* app/plug-in/plug-in-proc-def.[ch]
* app/plug-in/plug-in-rc.c
* app/plug-in/plug-ins.[ch]: allow to associate a procedure for
thumbnail loading with any file load procedure.
* tools/pdbgen/pdb/fileops.pdb: export this functionality to the
PDB as gimp_register_thumbnail_loader().
* app/pdb/fileops_cmds.c
* app/pdb/internal_procs.c
* libgimp/gimpfileops_pdb.[ch]: regenerated.
* app/core/gimpimagefile.c
* app/file/file-open.[ch]: when creating a thumbnail for an image
file, use a thumbnail load procedure if available.
* plug-ins/common/svg.c: added "file_svg_load_thumb", a procedure
that allows to load a small preview of the SVG image.
2004-11-13 DindinX <dindinx@gimp.org> 2004-11-13 DindinX <dindinx@gimp.org>
* app/actions/layers-actions.c: added back <control>H as a shortcut * app/actions/layers-actions.c: added back <control>H as a shortcut

131
app/core/gimpimagefile.c
View File

@ -78,6 +78,15 @@ static gboolean gimp_imagefile_save_thumb (GimpImagefile *imagefile,
static gchar * gimp_imagefile_get_description (GimpViewable *viewable, static gchar * gimp_imagefile_get_description (GimpViewable *viewable,
gchar **tooltip); gchar **tooltip);
static void gimp_thumbnail_set_info_from_image (GimpThumbnail *thumbnail,
const gchar *mime_type,
GimpImage *image);
static void gimp_thumbnail_set_info (GimpThumbnail *thumbnail,
const gchar *mime_type,
gint width,
gint height);
static guint gimp_imagefile_signals[LAST_SIGNAL] = { 0 }; static guint gimp_imagefile_signals[LAST_SIGNAL] = { 0 };
@ -253,34 +262,46 @@ gimp_imagefile_create_thumbnail (GimpImagefile *imagefile,
if (gimp_thumbnail_peek_image (thumbnail) >= GIMP_THUMB_STATE_EXISTS) if (gimp_thumbnail_peek_image (thumbnail) >= GIMP_THUMB_STATE_EXISTS)
{ {
GimpImage *gimage; GimpImage *image;
GimpPDBStatusType dummy; gboolean success;
gboolean success; gint width = 0;
const gchar *mime_type = NULL; gint height = 0;
GError *error = NULL; const gchar *mime_type = NULL;
GError *error = NULL;
g_object_ref (imagefile); g_object_ref (imagefile);
gimage = file_open_image (imagefile->gimp, context, progress, image = file_open_thumbnail (imagefile->gimp, context, progress,
thumbnail->image_uri, thumbnail->image_uri, size,
thumbnail->image_uri, &mime_type, &width, &height);
NULL,
GIMP_RUN_NONINTERACTIVE,
&dummy,
&mime_type,
NULL);
if (gimage) if (image)
{ {
if (mime_type) gimp_thumbnail_set_info (imagefile->thumbnail,
g_object_set (thumbnail, mime_type, width, height);
"image-mimetype", mime_type,
NULL);
}
else
{
GimpPDBStatusType status;
image = file_open_image (imagefile->gimp, context, progress,
thumbnail->image_uri, thumbnail->image_uri,
NULL, GIMP_RUN_NONINTERACTIVE,
&status, &mime_type, NULL);
if (image)
gimp_thumbnail_set_info_from_image (imagefile->thumbnail,
mime_type, image);
}
if (image)
{
success = gimp_imagefile_save_thumb (imagefile, success = gimp_imagefile_save_thumb (imagefile,
gimage, size, replace, &error); image, size, replace,
&error);
g_object_unref (gimage); g_object_unref (image);
} }
else else
{ {
@ -386,13 +407,11 @@ gimp_imagefile_save_thumbnail (GimpImagefile *imagefile,
if (size > 0) if (size > 0)
{ {
/* peek the thumbnail to make sure that mtime and filesize are set */ gimp_thumbnail_set_info_from_image (imagefile->thumbnail, NULL, gimage);
gimp_thumbnail_peek_image (imagefile->thumbnail);
success = gimp_imagefile_save_thumb (imagefile, success = gimp_imagefile_save_thumb (imagefile,
gimage, size, FALSE, gimage, size, FALSE,
&error); &error);
if (! success) if (! success)
{ {
g_message (error->message); g_message (error->message);
@ -719,9 +738,6 @@ gimp_imagefile_save_thumb (GimpImagefile *imagefile,
{ {
GimpThumbnail *thumbnail = imagefile->thumbnail; GimpThumbnail *thumbnail = imagefile->thumbnail;
GdkPixbuf *pixbuf; GdkPixbuf *pixbuf;
GimpEnumDesc *enum_desc;
GimpImageType type;
gint num_layers;
gint width, height; gint width, height;
gboolean success = FALSE; gboolean success = FALSE;
@ -755,24 +771,6 @@ gimp_imagefile_save_thumb (GimpImagefile *imagefile,
if (! pixbuf) if (! pixbuf)
return TRUE; return TRUE;
type = GIMP_IMAGE_TYPE_FROM_BASE_TYPE (gimp_image_base_type (gimage));
if (gimp_image_has_alpha (gimage))
type = GIMP_IMAGE_TYPE_WITH_ALPHA (type);
enum_desc = gimp_enum_get_desc (g_type_class_peek (GIMP_TYPE_IMAGE_TYPE),
type);
num_layers = gimp_container_num_children (gimage->layers);
g_object_set (thumbnail,
"image-width", gimage->width,
"image-height", gimage->height,
"image-type", enum_desc->value_desc,
"image-num-layers", num_layers,
NULL);
success = gimp_thumbnail_save_thumb (thumbnail, success = gimp_thumbnail_save_thumb (thumbnail,
pixbuf, pixbuf,
"The GIMP " GIMP_VERSION, "The GIMP " GIMP_VERSION,
@ -792,3 +790,48 @@ gimp_imagefile_save_thumb (GimpImagefile *imagefile,
return success; return success;
} }
static void
gimp_thumbnail_set_info_from_image (GimpThumbnail *thumbnail,
const gchar *mime_type,
GimpImage *image)
{
GimpEnumDesc *desc;
GimpImageType type;
/* peek the thumbnail to make sure that mtime and filesize are set */
gimp_thumbnail_peek_image (thumbnail);
type = GIMP_IMAGE_TYPE_FROM_BASE_TYPE (gimp_image_base_type (image));
if (gimp_image_has_alpha (image))
type = GIMP_IMAGE_TYPE_WITH_ALPHA (type);
desc = gimp_enum_get_desc (g_type_class_peek (GIMP_TYPE_IMAGE_TYPE), type);
g_object_set (thumbnail,
"image-mimetype", mime_type,
"image-width", gimp_image_get_width (image),
"image-height", gimp_image_get_height (image),
"image-type", desc->value_desc,
"image-num-layers", gimp_container_num_children (image->layers),
NULL);
}
static void
gimp_thumbnail_set_info (GimpThumbnail *thumbnail,
const gchar *mime_type,
gint width,
gint height)
{
/* peek the thumbnail to make sure that mtime and filesize are set */
gimp_thumbnail_peek_image (thumbnail);
g_object_set (thumbnail,
"image-mimetype", mime_type,
"image-width", width,
"image-height", height,
"image-type", NULL,
"image-num-layers", NULL,
NULL);
}

131
app/file/file-open.c
View File

@ -64,6 +64,9 @@
#include "gimp-intl.h" #include "gimp-intl.h"
static void file_open_sanitize_image (GimpImage *gimage);
/* public functions */ /* public functions */
GimpImage * GimpImage *
@ -81,7 +84,7 @@ file_open_image (Gimp *gimp,
const ProcRecord *proc; const ProcRecord *proc;
Argument *args; Argument *args;
Argument *return_vals; Argument *return_vals;
gint gimage_id; gint image_id;
gint i; gint i;
gchar *filename; gchar *filename;
@ -89,7 +92,6 @@ file_open_image (Gimp *gimp,
g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL); g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL);
g_return_val_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress), NULL); g_return_val_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress), NULL);
g_return_val_if_fail (status != NULL, NULL); g_return_val_if_fail (status != NULL, NULL);
g_return_val_if_fail (mime_type == NULL || *mime_type == NULL, NULL);
g_return_val_if_fail (error == NULL || *error == NULL, NULL); g_return_val_if_fail (error == NULL || *error == NULL, NULL);
*status = GIMP_PDB_EXECUTION_ERROR; *status = GIMP_PDB_EXECUTION_ERROR;
@ -146,31 +148,19 @@ file_open_image (Gimp *gimp,
if (filename) if (filename)
g_free (filename); g_free (filename);
*status = return_vals[0].value.pdb_int; *status = return_vals[0].value.pdb_int;
gimage_id = return_vals[1].value.pdb_int; image_id = return_vals[1].value.pdb_int;
procedural_db_destroy_args (return_vals, proc->num_values); procedural_db_destroy_args (return_vals, proc->num_values);
g_free (args); g_free (args);
if (*status == GIMP_PDB_SUCCESS) if (*status == GIMP_PDB_SUCCESS)
{ {
if (gimage_id != -1) if (image_id != -1)
{ {
GimpImage *gimage = gimp_image_get_by_ID (gimp, gimage_id); GimpImage *gimage = gimp_image_get_by_ID (gimp, image_id);
/* clear all undo steps */ file_open_sanitize_image (gimage);
gimp_image_undo_free (gimage);
/* make sure that undo is enabled */
while (gimage->undo_freeze_count)
gimp_image_undo_thaw (gimage);
/* set the image to clean */
gimp_image_clean_all (gimage);
gimp_image_invalidate_layer_previews (gimage);
gimp_image_invalidate_channel_previews (gimage);
gimp_viewable_invalidate_preview (GIMP_VIEWABLE (gimage));
if (mime_type) if (mime_type)
*mime_type = file_proc->mime_type; *mime_type = file_proc->mime_type;
@ -194,6 +184,88 @@ file_open_image (Gimp *gimp,
return NULL; return NULL;
} }
/* Attempts to load a thumbnail by using a registered thumbnail loader. */
GimpImage *
file_open_thumbnail (Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
const gchar *uri,
gint size,
const gchar **mime_type,
gint *image_width,
gint *image_height)
{
PlugInProcDef *file_proc;
const ProcRecord *proc;
g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL);
g_return_val_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress), NULL);
g_return_val_if_fail (mime_type != NULL, NULL);
g_return_val_if_fail (image_width != NULL, NULL);
g_return_val_if_fail (image_height != NULL, NULL);
*image_width = 0;
*image_height = 0;
file_proc = file_utils_find_proc (gimp->load_procs, uri);
if (! file_proc || ! file_proc->thumb_loader)
return NULL;
proc = procedural_db_lookup (gimp, file_proc->thumb_loader);
if (proc && proc->num_args >= 2)
{
GimpPDBStatusType status;
Argument *args;
Argument *return_vals;
gchar *filename;
gint image_id;
gint i;
filename = g_filename_from_uri (uri, NULL, NULL);
args = g_new0 (Argument, proc->num_args);
for (i = 0; i < proc->num_args; i++)
args[i].arg_type = proc->args[i].arg_type;
args[0].value.pdb_pointer = filename ? filename : (gchar *) uri;
args[1].value.pdb_int = size;
return_vals = procedural_db_execute (gimp, context, progress,
proc->name, args);
if (filename)
g_free (filename);
status = return_vals[0].value.pdb_int;
image_id = return_vals[1].value.pdb_int;
*image_width = MAX (0, return_vals[2].value.pdb_int);
*image_height = MAX (0, return_vals[3].value.pdb_int);
procedural_db_destroy_args (return_vals, proc->num_values);
g_free (args);
if (status == GIMP_PDB_SUCCESS && image_id != -1)
{
GimpImage *image = gimp_image_get_by_ID (gimp, image_id);
file_open_sanitize_image (image);
*mime_type = file_proc->mime_type;
g_printerr ("opened thumbnail at %d x %d\n",
image->width, image->height);
return image;
}
}
return NULL;
}
GimpImage * GimpImage *
file_open_with_display (Gimp *gimp, file_open_with_display (Gimp *gimp,
GimpContext *context, GimpContext *context,
@ -347,3 +419,24 @@ file_open_layer (Gimp *gimp,
return new_layer; return new_layer;
} }
/* private functions */
static void
file_open_sanitize_image (GimpImage *gimage)
{
/* clear all undo steps */
gimp_image_undo_free (gimage);
/* make sure that undo is enabled */
while (gimage->undo_freeze_count)
gimp_image_undo_thaw (gimage);
/* set the image to clean */
gimp_image_clean_all (gimage);
gimp_image_invalidate_layer_previews (gimage);
gimp_image_invalidate_channel_previews (gimage);
gimp_viewable_invalidate_preview (GIMP_VIEWABLE (gimage));
}

8
app/file/file-open.h
View File

@ -33,6 +33,14 @@ GimpImage * file_open_image (Gimp *gimp,
const gchar **mime_type, const gchar **mime_type,
GError **error); GError **error);
GimpImage * file_open_thumbnail (Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
const gchar *uri,
gint size,
const gchar **mime_type,
gint *image_width,
gint *image_height);
GimpImage * file_open_with_display (Gimp *gimp, GimpImage * file_open_with_display (Gimp *gimp,
GimpContext *context, GimpContext *context,
GimpProgress *progress, GimpProgress *progress,

61
app/pdb/fileops_cmds.c
View File

@ -63,6 +63,7 @@ static ProcRecord register_magic_load_handler_proc;
static ProcRecord register_load_handler_proc; static ProcRecord register_load_handler_proc;
static ProcRecord register_save_handler_proc; static ProcRecord register_save_handler_proc;
static ProcRecord register_file_handler_mime_proc; static ProcRecord register_file_handler_mime_proc;
static ProcRecord register_thumbnail_loader_proc;
void void
register_fileops_procs (Gimp *gimp) register_fileops_procs (Gimp *gimp)
@ -76,6 +77,7 @@ register_fileops_procs (Gimp *gimp)
procedural_db_register (gimp, &register_load_handler_proc); procedural_db_register (gimp, &register_load_handler_proc);
procedural_db_register (gimp, &register_save_handler_proc); procedural_db_register (gimp, &register_save_handler_proc);
procedural_db_register (gimp, &register_file_handler_mime_proc); procedural_db_register (gimp, &register_file_handler_mime_proc);
procedural_db_register (gimp, &register_thumbnail_loader_proc);
} }
static Argument * static Argument *
@ -861,3 +863,62 @@ static ProcRecord register_file_handler_mime_proc =
NULL, NULL,
{ { register_file_handler_mime_invoker } } { { register_file_handler_mime_invoker } }
}; };
static Argument *
register_thumbnail_loader_invoker (Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
Argument *args)
{
gboolean success = TRUE;
gchar *load_proc;
gchar *thumb_proc;
load_proc = (gchar *) args[0].value.pdb_pointer;
if (load_proc == NULL || !g_utf8_validate (load_proc, -1, NULL))
success = FALSE;
thumb_proc = (gchar *) args[1].value.pdb_pointer;
if (thumb_proc == NULL || !g_utf8_validate (thumb_proc, -1, NULL))
success = FALSE;
if (success)
{
success = (plug_ins_file_register_thumb_loader (gimp,
load_proc,
thumb_proc) != NULL);
}
return procedural_db_return_args (&register_thumbnail_loader_proc, success);
}
static ProcArg register_thumbnail_loader_inargs[] =
{
{
GIMP_PDB_STRING,
"load_proc",
"The name of the procedure the thumbnail loader with."
},
{
GIMP_PDB_STRING,
"thumb_proc",
"The name of the thumbnail load procedure."
}
};
static ProcRecord register_thumbnail_loader_proc =
{
"gimp_register_thumbnail_loader",
"Associates a thumbnail loader with a file load procedure.",
"Some file formats allow for embedded thumbnails, other file formats contain a scalable image or provide the image data in different resolutions. A file plug-in for such a format may register a special procedure that allows GIMP to load a thumbnail preview of the image. This procedure is then associated with the standard load procedure using this function.",
"Sven Neumann",
"Sven Neumann",
"2004",
NULL,
GIMP_INTERNAL,
2,
register_thumbnail_loader_inargs,
0,
NULL,
{ { register_thumbnail_loader_invoker } }
};

2
app/pdb/gimppluginprocedure.c
View File

@ -100,6 +100,8 @@ plug_in_proc_def_free (PlugInProcDef *proc_def)
g_slist_foreach (proc_def->magics_list, (GFunc) g_free, NULL); g_slist_foreach (proc_def->magics_list, (GFunc) g_free, NULL);
g_slist_free (proc_def->magics_list); g_slist_free (proc_def->magics_list);
g_free (proc_def->thumb_loader);
g_free (proc_def); g_free (proc_def);
} }

1
app/pdb/gimppluginprocedure.h
View File

@ -51,6 +51,7 @@ struct _PlugInProcDef
GSList *extensions_list; GSList *extensions_list;
GSList *prefixes_list; GSList *prefixes_list;
GSList *magics_list; GSList *magics_list;
gchar *thumb_loader;
}; };

44
app/pdb/internal_procs.c
View File

@ -74,7 +74,7 @@ void register_transform_tools_procs (Gimp *gimp);
void register_undo_procs (Gimp *gimp); void register_undo_procs (Gimp *gimp);
void register_unit_procs (Gimp *gimp); void register_unit_procs (Gimp *gimp);
/* 433 procedures registered total */ /* 434 procedures registered total */
void void
internal_procs_init (Gimp *gimp, internal_procs_init (Gimp *gimp,
@ -98,7 +98,7 @@ internal_procs_init (Gimp *gimp,
(* status_callback) (NULL, _("Color"), 0.06); (* status_callback) (NULL, _("Color"), 0.06);
register_color_procs (gimp); register_color_procs (gimp);
(* status_callback) (NULL, _("Context"), 0.095); (* status_callback) (NULL, _("Context"), 0.094);
register_context_procs (gimp); register_context_procs (gimp);
(* status_callback) (NULL, _("Convert"), 0.145); (* status_callback) (NULL, _("Convert"), 0.145);
@ -107,61 +107,61 @@ internal_procs_init (Gimp *gimp,
(* status_callback) (NULL, _("Display procedures"), 0.152); (* status_callback) (NULL, _("Display procedures"), 0.152);
register_display_procs (gimp); register_display_procs (gimp);
(* status_callback) (NULL, _("Drawable procedures"), 0.162); (* status_callback) (NULL, _("Drawable procedures"), 0.161);
register_drawable_procs (gimp); register_drawable_procs (gimp);
(* status_callback) (NULL, _("Transformation procedures"), 0.238); (* status_callback) (NULL, _("Transformation procedures"), 0.237);
register_drawable_transform_procs (gimp); register_drawable_transform_procs (gimp);
(* status_callback) (NULL, _("Edit procedures"), 0.275); (* status_callback) (NULL, _("Edit procedures"), 0.274);
register_edit_procs (gimp); register_edit_procs (gimp);
(* status_callback) (NULL, _("File Operations"), 0.293); (* status_callback) (NULL, _("File Operations"), 0.293);
register_fileops_procs (gimp); register_fileops_procs (gimp);
(* status_callback) (NULL, _("Floating selections"), 0.314); (* status_callback) (NULL, _("Floating selections"), 0.316);
register_floating_sel_procs (gimp); register_floating_sel_procs (gimp);
(* status_callback) (NULL, _("Font UI"), 0.328); (* status_callback) (NULL, _("Font UI"), 0.329);
register_font_select_procs (gimp); register_font_select_procs (gimp);
(* status_callback) (NULL, _("Fonts"), 0.335); (* status_callback) (NULL, _("Fonts"), 0.336);
register_fonts_procs (gimp); register_fonts_procs (gimp);
(* status_callback) (NULL, _("Gimprc procedures"), 0.339); (* status_callback) (NULL, _("Gimprc procedures"), 0.341);
register_gimprc_procs (gimp); register_gimprc_procs (gimp);
(* status_callback) (NULL, _("Gradient"), 0.353); (* status_callback) (NULL, _("Gradient"), 0.355);
register_gradient_procs (gimp); register_gradient_procs (gimp);
(* status_callback) (NULL, _("Gradient UI"), 0.42); (* status_callback) (NULL, _("Gradient UI"), 0.422);
register_gradient_select_procs (gimp); register_gradient_select_procs (gimp);
(* status_callback) (NULL, _("Gradients"), 0.427); (* status_callback) (NULL, _("Gradients"), 0.429);
register_gradients_procs (gimp); register_gradients_procs (gimp);
(* status_callback) (NULL, _("Guide procedures"), 0.439); (* status_callback) (NULL, _("Guide procedures"), 0.44);
register_guides_procs (gimp); register_guides_procs (gimp);
(* status_callback) (NULL, _("Help procedures"), 0.453); (* status_callback) (NULL, _("Help procedures"), 0.454);
register_help_procs (gimp); register_help_procs (gimp);
(* status_callback) (NULL, _("Image"), 0.455); (* status_callback) (NULL, _("Image"), 0.456);
register_image_procs (gimp); register_image_procs (gimp);
(* status_callback) (NULL, _("Layer"), 0.603); (* status_callback) (NULL, _("Layer"), 0.604);
register_layer_procs (gimp); register_layer_procs (gimp);
(* status_callback) (NULL, _("Message procedures"), 0.665); (* status_callback) (NULL, _("Message procedures"), 0.666);
register_message_procs (gimp); register_message_procs (gimp);
(* status_callback) (NULL, _("Miscellaneous"), 0.672); (* status_callback) (NULL, _("Miscellaneous"), 0.673);
register_misc_procs (gimp); register_misc_procs (gimp);
(* status_callback) (NULL, _("Paint Tool procedures"), 0.677); (* status_callback) (NULL, _("Paint Tool procedures"), 0.677);
register_paint_tools_procs (gimp); register_paint_tools_procs (gimp);
(* status_callback) (NULL, _("Palette"), 0.711); (* status_callback) (NULL, _("Palette"), 0.712);
register_palette_procs (gimp); register_palette_procs (gimp);
(* status_callback) (NULL, _("Palette UI"), 0.737); (* status_callback) (NULL, _("Palette UI"), 0.737);
@ -176,7 +176,7 @@ internal_procs_init (Gimp *gimp,
(* status_callback) (NULL, _("Paths"), 0.781); (* status_callback) (NULL, _("Paths"), 0.781);
register_paths_procs (gimp); register_paths_procs (gimp);
(* status_callback) (NULL, _("Pattern"), 0.815); (* status_callback) (NULL, _("Pattern"), 0.816);
register_pattern_procs (gimp); register_pattern_procs (gimp);
(* status_callback) (NULL, _("Pattern UI"), 0.82); (* status_callback) (NULL, _("Pattern UI"), 0.82);
@ -191,13 +191,13 @@ internal_procs_init (Gimp *gimp,
(* status_callback) (NULL, _("Procedural database"), 0.848); (* status_callback) (NULL, _("Procedural database"), 0.848);
register_procedural_db_procs (gimp); register_procedural_db_procs (gimp);
(* status_callback) (NULL, _("Progress"), 0.868); (* status_callback) (NULL, _("Progress"), 0.869);
register_progress_procs (gimp); register_progress_procs (gimp);
(* status_callback) (NULL, _("Image mask"), 0.88); (* status_callback) (NULL, _("Image mask"), 0.88);
register_selection_procs (gimp); register_selection_procs (gimp);
(* status_callback) (NULL, _("Selection Tool procedures"), 0.921); (* status_callback) (NULL, _("Selection Tool procedures"), 0.922);
register_selection_tools_procs (gimp); register_selection_tools_procs (gimp);
(* status_callback) (NULL, _("Text procedures"), 0.933); (* status_callback) (NULL, _("Text procedures"), 0.933);

33
app/plug-in/gimppluginmanager.c
View File

@ -514,6 +514,39 @@ plug_ins_file_register_mime (Gimp *gimp,
return NULL; return NULL;
} }
PlugInProcDef *
plug_ins_file_register_thumb_loader (Gimp *gimp,
const gchar *load_proc,
const gchar *thumb_proc)
{
GSList *list;
g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
g_return_val_if_fail (load_proc, NULL);
g_return_val_if_fail (thumb_proc, NULL);
if (gimp->current_plug_in && gimp->current_plug_in->plug_in_def)
list = gimp->current_plug_in->plug_in_def->proc_defs;
else
list = gimp->plug_in_proc_defs;
for (; list; list = list->next)
{
PlugInProcDef *proc_def = list->data;
if (strcmp (proc_def->db_info.name, load_proc) == 0)
{
if (proc_def->thumb_loader)
g_free (proc_def->thumb_loader);
proc_def->thumb_loader = g_strdup (thumb_proc);
return proc_def;
}
}
return NULL;
}
void void
plug_ins_def_add_from_rc (Gimp *gimp, plug_ins_def_add_from_rc (Gimp *gimp,
PlugInDef *plug_in_def) PlugInDef *plug_in_def)

6
app/plug-in/gimppluginmanager.h
View File

@ -45,6 +45,12 @@ PlugInProcDef * plug_ins_file_register_mime (Gimp *gimp,
const gchar *name, const gchar *name,
const gchar *mime_type); const gchar *mime_type);
PlugInProcDef * plug_ins_file_register_thumb_loader
(Gimp *gimp,
const gchar *load_proc,
const gchar *thumb_proc);
/* Add a plug-in definition. */ /* Add a plug-in definition. */
void plug_ins_def_add_from_rc (Gimp *gimp, void plug_ins_def_add_from_rc (Gimp *gimp,
PlugInDef *plug_in_def); PlugInDef *plug_in_def);

2
app/plug-in/gimppluginprocedure.c
View File

@ -100,6 +100,8 @@ plug_in_proc_def_free (PlugInProcDef *proc_def)
g_slist_foreach (proc_def->magics_list, (GFunc) g_free, NULL); g_slist_foreach (proc_def->magics_list, (GFunc) g_free, NULL);
g_slist_free (proc_def->magics_list); g_slist_free (proc_def->magics_list);
g_free (proc_def->thumb_loader);
g_free (proc_def); g_free (proc_def);
} }

1
app/plug-in/gimppluginprocedure.h
View File

@ -51,6 +51,7 @@ struct _PlugInProcDef
GSList *extensions_list; GSList *extensions_list;
GSList *prefixes_list; GSList *prefixes_list;
GSList *magics_list; GSList *magics_list;
gchar *thumb_loader;
}; };

2
app/plug-in/plug-in-proc-def.c
View File

@ -100,6 +100,8 @@ plug_in_proc_def_free (PlugInProcDef *proc_def)
g_slist_foreach (proc_def->magics_list, (GFunc) g_free, NULL); g_slist_foreach (proc_def->magics_list, (GFunc) g_free, NULL);
g_slist_free (proc_def->magics_list); g_slist_free (proc_def->magics_list);
g_free (proc_def->thumb_loader);
g_free (proc_def); g_free (proc_def);
} }

1
app/plug-in/plug-in-proc-def.h
View File

@ -51,6 +51,7 @@ struct _PlugInProcDef
GSList *extensions_list; GSList *extensions_list;
GSList *prefixes_list; GSList *prefixes_list;
GSList *magics_list; GSList *magics_list;
gchar *thumb_loader;
}; };

74
app/plug-in/plug-in-rc.c
View File

@ -57,7 +57,7 @@ static GTokenType plug_in_icon_deserialize (GScanner *scanner,
PlugInProcDef *proc_def); PlugInProcDef *proc_def);
static GTokenType plug_in_proc_arg_deserialize (GScanner *scanner, static GTokenType plug_in_proc_arg_deserialize (GScanner *scanner,
ProcArg *arg); ProcArg *arg);
static GTokenType plug_in_mime_type_deserialize (GScanner *scanner, static GTokenType plug_in_extra_deserialize (GScanner *scanner,
PlugInProcDef *proc_def); PlugInProcDef *proc_def);
static GTokenType plug_in_locale_def_deserialize (GScanner *scanner, static GTokenType plug_in_locale_def_deserialize (GScanner *scanner,
PlugInDef *plug_in_def); PlugInDef *plug_in_def);
@ -78,7 +78,8 @@ enum
PROC_ARG, PROC_ARG,
MENU_PATH, MENU_PATH,
ICON, ICON,
MIME_TYPE MIME_TYPE,
THUMB_LOADER
}; };
@ -125,6 +126,8 @@ plug_in_rc_parse (Gimp *gimp,
"icon", GINT_TO_POINTER (ICON)); "icon", GINT_TO_POINTER (ICON));
g_scanner_scope_add_symbol (scanner, PLUG_IN_DEF, g_scanner_scope_add_symbol (scanner, PLUG_IN_DEF,
"mime-type", GINT_TO_POINTER (MIME_TYPE)); "mime-type", GINT_TO_POINTER (MIME_TYPE));
g_scanner_scope_add_symbol (scanner, PLUG_IN_DEF,
"thumb-loader", GINT_TO_POINTER (THUMB_LOADER));
token = G_TOKEN_LEFT_PAREN; token = G_TOKEN_LEFT_PAREN;
@ -357,13 +360,10 @@ plug_in_proc_def_deserialize (GScanner *scanner,
return token; return token;
} }
if (g_scanner_peek_next_token (scanner) == G_TOKEN_LEFT_PAREN) token = plug_in_extra_deserialize (scanner, proc_def);
{
token = plug_in_mime_type_deserialize (scanner, proc_def);
if (token != G_TOKEN_LEFT_PAREN) if (token != G_TOKEN_LEFT_PAREN)
return token; return token;
}
if (! gimp_scanner_parse_token (scanner, G_TOKEN_RIGHT_PAREN)) if (! gimp_scanner_parse_token (scanner, G_TOKEN_RIGHT_PAREN))
return G_TOKEN_RIGHT_PAREN; return G_TOKEN_RIGHT_PAREN;
@ -490,29 +490,50 @@ plug_in_icon_deserialize (GScanner *scanner,
return G_TOKEN_LEFT_PAREN; return G_TOKEN_LEFT_PAREN;
} }
/* Handle extra info such as mime-type and thumb-loader. */
static GTokenType static GTokenType
plug_in_mime_type_deserialize (GScanner *scanner, plug_in_extra_deserialize (GScanner *scanner,
PlugInProcDef *proc_def) PlugInProcDef *proc_def)
{ {
gchar *mime_type; GTokenType token;
gchar *value;
if (! gimp_scanner_parse_token (scanner, G_TOKEN_LEFT_PAREN)) while (g_scanner_peek_next_token (scanner) == G_TOKEN_LEFT_PAREN)
return G_TOKEN_LEFT_PAREN; {
token = token = g_scanner_get_next_token (scanner);
if (! gimp_scanner_parse_token (scanner, G_TOKEN_SYMBOL) || if (token != G_TOKEN_LEFT_PAREN)
GPOINTER_TO_INT (scanner->value.v_symbol) != MIME_TYPE) return token;
return G_TOKEN_SYMBOL;
if (! gimp_scanner_parse_string (scanner, &mime_type)) if (! gimp_scanner_parse_token (scanner, G_TOKEN_SYMBOL))
return G_TOKEN_STRING; return G_TOKEN_SYMBOL;
if (proc_def->mime_type) switch (GPOINTER_TO_INT (scanner->value.v_symbol))
g_free (proc_def->mime_type); {
case MIME_TYPE:
if (! gimp_scanner_parse_string (scanner, &value))
return G_TOKEN_STRING;
proc_def->mime_type = mime_type; g_free (proc_def->mime_type);
proc_def->mime_type = value;
break;
if (! gimp_scanner_parse_token (scanner, G_TOKEN_RIGHT_PAREN)) case THUMB_LOADER:
return G_TOKEN_RIGHT_PAREN; if (! gimp_scanner_parse_string (scanner, &value))
return G_TOKEN_STRING;
g_free (proc_def->thumb_loader);
proc_def->thumb_loader = value;
break;
default:
return G_TOKEN_SYMBOL;
}
if (! gimp_scanner_parse_token (scanner, G_TOKEN_RIGHT_PAREN))
return G_TOKEN_RIGHT_PAREN;
}
return G_TOKEN_LEFT_PAREN; return G_TOKEN_LEFT_PAREN;
} }
@ -752,6 +773,13 @@ plug_in_rc_write (GSList *plug_in_defs,
gimp_config_writer_close (writer); gimp_config_writer_close (writer);
} }
if (proc_def->thumb_loader)
{
gimp_config_writer_open (writer, "thumb-loader");
gimp_config_writer_string (writer, proc_def->thumb_loader);
gimp_config_writer_close (writer);
}
gimp_config_writer_close (writer); gimp_config_writer_close (writer);
} }

33
app/plug-in/plug-ins.c
View File

@ -514,6 +514,39 @@ plug_ins_file_register_mime (Gimp *gimp,
return NULL; return NULL;
} }
PlugInProcDef *
plug_ins_file_register_thumb_loader (Gimp *gimp,
const gchar *load_proc,
const gchar *thumb_proc)
{
GSList *list;
g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
g_return_val_if_fail (load_proc, NULL);
g_return_val_if_fail (thumb_proc, NULL);
if (gimp->current_plug_in && gimp->current_plug_in->plug_in_def)
list = gimp->current_plug_in->plug_in_def->proc_defs;
else
list = gimp->plug_in_proc_defs;
for (; list; list = list->next)
{
PlugInProcDef *proc_def = list->data;
if (strcmp (proc_def->db_info.name, load_proc) == 0)
{
if (proc_def->thumb_loader)
g_free (proc_def->thumb_loader);
proc_def->thumb_loader = g_strdup (thumb_proc);
return proc_def;
}
}
return NULL;
}
void void
plug_ins_def_add_from_rc (Gimp *gimp, plug_ins_def_add_from_rc (Gimp *gimp,
PlugInDef *plug_in_def) PlugInDef *plug_in_def)

6
app/plug-in/plug-ins.h
View File

@ -45,6 +45,12 @@ PlugInProcDef * plug_ins_file_register_mime (Gimp *gimp,
const gchar *name, const gchar *name,
const gchar *mime_type); const gchar *mime_type);
PlugInProcDef * plug_ins_file_register_thumb_loader
(Gimp *gimp,
const gchar *load_proc,
const gchar *thumb_proc);
/* Add a plug-in definition. */ /* Add a plug-in definition. */
void plug_ins_def_add_from_rc (Gimp *gimp, void plug_ins_def_add_from_rc (Gimp *gimp,
PlugInDef *plug_in_def); PlugInDef *plug_in_def);

1
devel-docs/libgimp/libgimp-sections.txt
View File

@ -367,6 +367,7 @@ gimp_register_magic_load_handler
gimp_register_load_handler gimp_register_load_handler
gimp_register_save_handler gimp_register_save_handler
gimp_register_file_handler_mime gimp_register_file_handler_mime
gimp_register_thumbnail_loader
</SECTION> </SECTION>
<SECTION> <SECTION>

10
devel-docs/libgimp/tmpl/gimpfileops.sgml
View File

@ -92,3 +92,13 @@ File operations (load, save, etc.)
@Returns: @Returns:
<!-- ##### FUNCTION gimp_register_thumbnail_loader ##### -->
<para>
</para>
@load_proc:
@thumb_proc:
@Returns:

1
libgimp/gimp.def
View File

@ -479,6 +479,7 @@ EXPORTS
gimp_register_load_handler gimp_register_load_handler
gimp_register_magic_load_handler gimp_register_magic_load_handler
gimp_register_save_handler gimp_register_save_handler
gimp_register_thumbnail_loader
gimp_repeat_mode_get_type gimp_repeat_mode_get_type
gimp_rgn_iterate1 gimp_rgn_iterate1
gimp_rgn_iterate2 gimp_rgn_iterate2

39
libgimp/gimpfileops_pdb.c
View File

@ -290,3 +290,42 @@ gimp_register_file_handler_mime (const gchar *procedure_name,
return success; return success;
} }
/**
* gimp_register_thumbnail_loader:
* @load_proc: The name of the procedure the thumbnail loader with.
* @thumb_proc: The name of the thumbnail load procedure.
*
* Associates a thumbnail loader with a file load procedure.
*
* Some file formats allow for embedded thumbnails, other file formats
* contain a scalable image or provide the image data in different
* resolutions. A file plug-in for such a format may register a special
* procedure that allows GIMP to load a thumbnail preview of the image.
* This procedure is then associated with the standard load procedure
* using this function.
*
* Returns: TRUE on success.
*
* Since: GIMP 2.2
*/
gboolean
gimp_register_thumbnail_loader (const gchar *load_proc,
const gchar *thumb_proc)
{
GimpParam *return_vals;
gint nreturn_vals;
gboolean success = TRUE;
return_vals = gimp_run_procedure ("gimp_register_thumbnail_loader",
&nreturn_vals,
GIMP_PDB_STRING, load_proc,
GIMP_PDB_STRING, thumb_proc,
GIMP_PDB_END);
success = return_vals[0].data.d_status == GIMP_PDB_SUCCESS;
gimp_destroy_params (return_vals, nreturn_vals);
return success;
}

2
libgimp/gimpfileops_pdb.h
View File

@ -50,6 +50,8 @@ gboolean gimp_register_save_handler (const gchar *procedure_name,
const gchar *prefixes); const gchar *prefixes);
gboolean gimp_register_file_handler_mime (const gchar *procedure_name, gboolean gimp_register_file_handler_mime (const gchar *procedure_name,
const gchar *mime_type); const gchar *mime_type);
gboolean gimp_register_thumbnail_loader (const gchar *load_proc,
const gchar *thumb_proc);
G_END_DECLS G_END_DECLS

91
plug-ins/common/svg.c
View File

@ -69,14 +69,14 @@ static void run (const gchar *name,
gint *nreturn_vals, gint *nreturn_vals,
GimpParam **return_vals); GimpParam **return_vals);
static gint32 load_image (const gchar *filename); static gint32 load_image (const gchar *filename);
static GdkPixbuf * load_rsvg_pixbuf (const gchar *filename, static GdkPixbuf * load_rsvg_pixbuf (const gchar *filename,
SvgLoadVals *vals, SvgLoadVals *vals,
GError **error); GError **error);
static gboolean load_rsvg_size (const gchar *filename, static gboolean load_rsvg_size (const gchar *filename,
SvgLoadVals *vals, SvgLoadVals *vals,
GError **error); GError **error);
static gboolean load_dialog (const gchar *filename); static gboolean load_dialog (const gchar *filename);
GimpPlugInInfo PLUG_IN_INFO = GimpPlugInInfo PLUG_IN_INFO =
@ -115,6 +115,18 @@ query (void)
{ GIMP_PDB_IMAGE, "image", "Output image" } { GIMP_PDB_IMAGE, "image", "Output image" }
}; };
static GimpParamDef thumb_args[] =
{
{ GIMP_PDB_STRING, "filename", "The name of the file to load" },
{ GIMP_PDB_INT32, "thumb_size", "Preferred thumbnail size" }
};
static GimpParamDef thumb_return_vals[] =
{
{ GIMP_PDB_IMAGE, "image", "Thumbnail image" },
{ GIMP_PDB_INT32, "image_width", "Width of full-sized image" },
{ GIMP_PDB_INT32, "image_height", "Height of full-sized image" }
};
gimp_install_procedure ("file_svg_load", gimp_install_procedure ("file_svg_load",
"Loads files in the SVG file format", "Loads files in the SVG file format",
"Renders SVG files to raster graphics using librsvg.", "Renders SVG files to raster graphics using librsvg.",
@ -132,6 +144,21 @@ query (void)
gimp_register_magic_load_handler ("file_svg_load", gimp_register_magic_load_handler ("file_svg_load",
"svg", "", "svg", "",
"0,string,<?xml,0,string,<svg"); "0,string,<?xml,0,string,<svg");
gimp_install_procedure ("file_svg_load_thumb",
"Loads a small preview from an SVG image",
"",
"Dom Lachowicz, Sven Neumann",
"Dom Lachowicz <cinamod@hotmail.com>",
SVG_VERSION,
N_("Scalable SVG image"),
NULL,
GIMP_PLUGIN,
G_N_ELEMENTS (thumb_args),
G_N_ELEMENTS (thumb_return_vals),
thumb_args, thumb_return_vals);
gimp_register_thumbnail_loader ("file_svg_load", "file_svg_load_thumb");
} }
static void static void
@ -192,14 +219,13 @@ run (const gchar *name,
if (status == GIMP_PDB_SUCCESS) if (status == GIMP_PDB_SUCCESS)
{ {
gint32 image_ID = load_image (param[1].data.d_string); const gchar *filename = param[1].data.d_string;
gint32 image_ID = load_image (filename);
if (image_ID != -1) if (image_ID != -1)
{ {
if (load_vals.import) if (load_vals.import)
gimp_path_import (image_ID, gimp_path_import (image_ID, filename, load_vals.merge, TRUE);
param[1].data.d_string,
load_vals.merge, TRUE);
*nreturn_vals = 2; *nreturn_vals = 2;
values[1].type = GIMP_PDB_IMAGE; values[1].type = GIMP_PDB_IMAGE;
@ -213,6 +239,47 @@ run (const gchar *name,
gimp_set_data ("file_svg_load", &load_vals, sizeof (load_vals)); gimp_set_data ("file_svg_load", &load_vals, sizeof (load_vals));
} }
} }
else if (strcmp (name, "file_svg_load_thumb") == 0)
{
if (nparams < 2)
{
status = GIMP_PDB_CALLING_ERROR;
}
else
{
const gchar *filename = param[0].data.d_string;
gint width = 0;
gint height = 0;
gint32 image_ID;
if (load_rsvg_size (filename, &load_vals, NULL))
{
width = load_vals.width;
height = load_vals.height;
}
load_vals.resolution = SVG_DEFAULT_RESOLUTION;
load_vals.width = - param[1].data.d_int32;
load_vals.height = - param[1].data.d_int32;
image_ID = load_image (filename);
if (image_ID != -1)
{
*nreturn_vals = 4;
values[1].type = GIMP_PDB_IMAGE;
values[1].data.d_image = image_ID;
values[2].type = GIMP_PDB_INT32;
values[2].data.d_int32 = width;
values[3].type = GIMP_PDB_INT32;
values[3].data.d_int32 = height;
}
else
{
status = GIMP_PDB_EXECUTION_ERROR;
}
}
}
else else
{ {
status = GIMP_PDB_CALLING_ERROR; status = GIMP_PDB_CALLING_ERROR;

33
tools/pdbgen/pdb/fileops.pdb
View File

@ -528,6 +528,34 @@ CODE
); );
} }
sub register_thumbnail_loader {
$blurb = 'Associates a thumbnail loader with a file load procedure.';
$help = <<'HELP';
Some file formats allow for embedded thumbnails, other file formats contain a scalable image or provide the image data in different resolutions. A file plug-in for such a format may register a special procedure that allows GIMP to load a thumbnail preview of the image. This procedure is then associated with the standard load procedure using this function.
HELP
$author = $copyright = 'Sven Neumann';
$date = '2004';
$since = '2.2';
@inargs = (
{ name => 'load_proc', type => 'string',
desc => "The name of the procedure the thumbnail loader with." },
{ name => 'thumb_proc', type => 'string',
desc => "The name of the thumbnail load procedure." }
);
%invoke = (
code => <<'CODE'
{
success = (plug_ins_file_register_thumb_loader (gimp,
load_proc,
thumb_proc) != NULL);
}
CODE
);
}
@headers = qw(<sys/types.h> <unistd.h> <gdk-pixbuf/gdk-pixbuf.h> @headers = qw(<sys/types.h> <unistd.h> <gdk-pixbuf/gdk-pixbuf.h>
"libgimpbase/gimpbase.h" "libgimpthumb/gimpthumb.h" "libgimpbase/gimpbase.h" "libgimpthumb/gimpthumb.h"
"core/gimp.h" "core/gimpimagefile.h" "core/gimp.h" "core/gimpimagefile.h"
@ -537,8 +565,9 @@ CODE
@procs = qw(file_load file_save file_load_thumbnail file_save_thumbnail @procs = qw(file_load file_save file_load_thumbnail file_save_thumbnail
temp_name register_magic_load_handler register_load_handler temp_name register_magic_load_handler register_load_handler
register_save_handler register_file_handler_mime); register_save_handler register_file_handler_mime
%exports = (app => [@procs], lib => [@procs[0,1,4..8]]); register_thumbnail_loader);
%exports = (app => [@procs], lib => [@procs[0,1,4..9]]);
$desc = 'File Operations'; $desc = 'File Operations';