[gimp] pdb: move the file procedure register API from "fileops" to "pdb"
- From: Michael Natterer <mitch src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [gimp] pdb: move the file procedure register API from "fileops" to "pdb"
- Date: Tue, 10 Sep 2019 19:28:52 +0000 (UTC)
commit 7c5cb29ca6a8e88d1f8452474ffd2b733ca5b778
Author: Michael Natterer <mitch gimp org>
Date: Tue Sep 10 21:24:09 2019 +0200
pdb: move the file procedure register API from "fileops" to "pdb"
because it has nothing to do with the other procedures in fileops and
only sets properties on procedures.
app/pdb/fileops-cmds.c | 474 --------------------------------------------
app/pdb/pdb-cmds.c | 466 +++++++++++++++++++++++++++++++++++++++++++
libgimp/gimpfileops_pdb.c | 287 ---------------------------
libgimp/gimpfileops_pdb.h | 49 ++---
libgimp/gimploadprocedure.c | 25 +--
libgimp/gimppdb_pdb.c | 287 +++++++++++++++++++++++++++
libgimp/gimppdb_pdb.h | 129 ++++++------
libgimp/gimpsaveprocedure.c | 17 +-
pdb/groups/fileops.pdb | 309 +----------------------------
pdb/groups/pdb.pdb | 298 +++++++++++++++++++++++++++-
10 files changed, 1164 insertions(+), 1177 deletions(-)
---
diff --git a/app/pdb/fileops-cmds.c b/app/pdb/fileops-cmds.c
index ffad31b343..c686f9aa14 100644
--- a/app/pdb/fileops-cmds.c
+++ b/app/pdb/fileops-cmds.c
@@ -25,14 +25,10 @@
#include <gdk-pixbuf/gdk-pixbuf.h>
-#include "libgimpbase/gimpbase.h"
-#include "libgimpconfig/gimpconfig.h"
-
#include "libgimpbase/gimpbase.h"
#include "pdb-types.h"
-#include "core/gimp-utils.h"
#include "core/gimp.h"
#include "core/gimpimage.h"
#include "core/gimplayer.h"
@@ -40,13 +36,9 @@
#include "file/file-open.h"
#include "file/file-save.h"
#include "file/file-utils.h"
-#include "plug-in/gimpplugin-proc.h"
#include "plug-in/gimppluginmanager-file.h"
-#include "plug-in/gimppluginmanager.h"
-#include "plug-in/gimppluginprocedure.h"
#include "gimppdb.h"
-#include "gimppdb-utils.h"
#include "gimpprocedure.h"
#include "internal-procs.h"
@@ -403,249 +395,6 @@ file_save_thumbnail_invoker (GimpProcedure *procedure,
error ? *error : NULL);
}
-static GimpValueArray *
-register_load_handler_invoker (GimpProcedure *procedure,
- Gimp *gimp,
- GimpContext *context,
- GimpProgress *progress,
- const GimpValueArray *args,
- GError **error)
-{
- gboolean success = TRUE;
- const gchar *procedure_name;
- const gchar *extensions;
- const gchar *prefixes;
- const gchar *magics;
-
- procedure_name = g_value_get_string (gimp_value_array_index (args, 0));
- extensions = g_value_get_string (gimp_value_array_index (args, 1));
- prefixes = g_value_get_string (gimp_value_array_index (args, 2));
- magics = g_value_get_string (gimp_value_array_index (args, 3));
-
- if (success)
- {
- GimpPlugIn *plug_in = gimp->plug_in_manager->current_plug_in;
-
- if (plug_in &&
- gimp_pdb_is_canonical_procedure (procedure_name, error))
- {
- success = gimp_plug_in_set_file_proc_load_handler (plug_in,
- procedure_name,
- extensions, prefixes,
- magics, error);
- }
- else
- success = FALSE;
- }
-
- return gimp_procedure_get_return_values (procedure, success,
- error ? *error : NULL);
-}
-
-static GimpValueArray *
-register_save_handler_invoker (GimpProcedure *procedure,
- Gimp *gimp,
- GimpContext *context,
- GimpProgress *progress,
- const GimpValueArray *args,
- GError **error)
-{
- gboolean success = TRUE;
- const gchar *procedure_name;
- const gchar *extensions;
- const gchar *prefixes;
-
- procedure_name = g_value_get_string (gimp_value_array_index (args, 0));
- extensions = g_value_get_string (gimp_value_array_index (args, 1));
- prefixes = g_value_get_string (gimp_value_array_index (args, 2));
-
- if (success)
- {
- GimpPlugIn *plug_in = gimp->plug_in_manager->current_plug_in;
-
- if (plug_in &&
- gimp_pdb_is_canonical_procedure (procedure_name, error))
- {
- success = gimp_plug_in_set_file_proc_save_handler (plug_in,
- procedure_name,
- extensions, prefixes,
- error);
- }
- else
- success = FALSE;
- }
-
- return gimp_procedure_get_return_values (procedure, success,
- error ? *error : NULL);
-}
-
-static GimpValueArray *
-register_file_handler_priority_invoker (GimpProcedure *procedure,
- Gimp *gimp,
- GimpContext *context,
- GimpProgress *progress,
- const GimpValueArray *args,
- GError **error)
-{
- gboolean success = TRUE;
- const gchar *procedure_name;
- gint priority;
-
- procedure_name = g_value_get_string (gimp_value_array_index (args, 0));
- priority = g_value_get_int (gimp_value_array_index (args, 1));
-
- if (success)
- {
- GimpPlugIn *plug_in = gimp->plug_in_manager->current_plug_in;
-
- if (plug_in &&
- gimp_pdb_is_canonical_procedure (procedure_name, error))
- {
- success = gimp_plug_in_set_file_proc_priority (plug_in,
- procedure_name,
- priority, error);
- }
- else
- success = FALSE;
- }
-
- return gimp_procedure_get_return_values (procedure, success,
- error ? *error : NULL);
-}
-
-static GimpValueArray *
-register_file_handler_mime_invoker (GimpProcedure *procedure,
- Gimp *gimp,
- GimpContext *context,
- GimpProgress *progress,
- const GimpValueArray *args,
- GError **error)
-{
- gboolean success = TRUE;
- const gchar *procedure_name;
- const gchar *mime_types;
-
- procedure_name = g_value_get_string (gimp_value_array_index (args, 0));
- mime_types = g_value_get_string (gimp_value_array_index (args, 1));
-
- if (success)
- {
- GimpPlugIn *plug_in = gimp->plug_in_manager->current_plug_in;
-
- if (plug_in &&
- gimp_pdb_is_canonical_procedure (procedure_name, error))
- {
- success = gimp_plug_in_set_file_proc_mime_types (plug_in,
- procedure_name,
- mime_types, error);
- }
- else
- success = FALSE;
- }
-
- return gimp_procedure_get_return_values (procedure, success,
- error ? *error : NULL);
-}
-
-static GimpValueArray *
-register_file_handler_remote_invoker (GimpProcedure *procedure,
- Gimp *gimp,
- GimpContext *context,
- GimpProgress *progress,
- const GimpValueArray *args,
- GError **error)
-{
- gboolean success = TRUE;
- const gchar *procedure_name;
-
- procedure_name = g_value_get_string (gimp_value_array_index (args, 0));
-
- if (success)
- {
- GimpPlugIn *plug_in = gimp->plug_in_manager->current_plug_in;
-
- if (plug_in &&
- gimp_pdb_is_canonical_procedure (procedure_name, error))
- {
- success = gimp_plug_in_set_file_proc_handles_remote (plug_in,
- procedure_name,
- error);
- }
- else
- success = FALSE;
- }
-
- return gimp_procedure_get_return_values (procedure, success,
- error ? *error : NULL);
-}
-
-static GimpValueArray *
-register_file_handler_raw_invoker (GimpProcedure *procedure,
- Gimp *gimp,
- GimpContext *context,
- GimpProgress *progress,
- const GimpValueArray *args,
- GError **error)
-{
- gboolean success = TRUE;
- const gchar *procedure_name;
-
- procedure_name = g_value_get_string (gimp_value_array_index (args, 0));
-
- if (success)
- {
- GimpPlugIn *plug_in = gimp->plug_in_manager->current_plug_in;
-
- if (plug_in &&
- gimp_pdb_is_canonical_procedure (procedure_name, error))
- {
- success = gimp_plug_in_set_file_proc_handles_raw (plug_in,
- procedure_name,
- error);
- }
- else
- success = FALSE;
- }
-
- return gimp_procedure_get_return_values (procedure, success,
- error ? *error : NULL);
-}
-
-static GimpValueArray *
-register_thumbnail_loader_invoker (GimpProcedure *procedure,
- Gimp *gimp,
- GimpContext *context,
- GimpProgress *progress,
- const GimpValueArray *args,
- GError **error)
-{
- gboolean success = TRUE;
- const gchar *load_proc;
- const gchar *thumb_proc;
-
- load_proc = g_value_get_string (gimp_value_array_index (args, 0));
- thumb_proc = g_value_get_string (gimp_value_array_index (args, 1));
-
- if (success)
- {
- GimpPlugIn *plug_in = gimp->plug_in_manager->current_plug_in;
-
- if (plug_in &&
- gimp_pdb_is_canonical_procedure (load_proc, error) &&
- gimp_pdb_is_canonical_procedure (thumb_proc, error))
- {
- success = gimp_plug_in_set_file_proc_thumb_loader (plug_in,
- load_proc, thumb_proc,
- error);
- }
- else
- success = FALSE;
- }
-
- return gimp_procedure_get_return_values (procedure, success,
- error ? *error : NULL);
-}
-
void
register_fileops_procs (GimpPDB *pdb)
{
@@ -919,227 +668,4 @@ register_fileops_procs (GimpPDB *pdb)
GIMP_PARAM_READWRITE));
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
-
- /*
- * gimp-register-load-handler
- */
- procedure = gimp_procedure_new (register_load_handler_invoker);
- gimp_object_set_static_name (GIMP_OBJECT (procedure),
- "gimp-register-load-handler");
- gimp_procedure_set_static_help (procedure,
- "Registers a file load handler procedure.",
- "Registers a procedural database procedure to be called to load files of a
particular file format using magic file information.",
- NULL);
- gimp_procedure_set_static_attribution (procedure,
- "Spencer Kimball & Peter Mattis",
- "Spencer Kimball & Peter Mattis",
- "1995-1996");
- gimp_procedure_add_argument (procedure,
- gimp_param_spec_string ("procedure-name",
- "procedure name",
- "The name of the procedure to be used for loading",
- FALSE, FALSE, TRUE,
- NULL,
- GIMP_PARAM_READWRITE));
- gimp_procedure_add_argument (procedure,
- gimp_param_spec_string ("extensions",
- "extensions",
- "comma separated list of extensions this handler can
load (i.e. \"jpg,jpeg\")",
- FALSE, FALSE, FALSE,
- NULL,
- GIMP_PARAM_READWRITE | GIMP_PARAM_NO_VALIDATE));
- gimp_procedure_add_argument (procedure,
- gimp_param_spec_string ("prefixes",
- "prefixes",
- "comma separated list of prefixes this handler can
load (i.e. \"http:,ftp:\")",
- FALSE, FALSE, FALSE,
- NULL,
- GIMP_PARAM_READWRITE | GIMP_PARAM_NO_VALIDATE));
- gimp_procedure_add_argument (procedure,
- gimp_param_spec_string ("magics",
- "magics",
- "comma separated list of magic file information this
handler can load (i.e. \"0,string,GIF\")",
- FALSE, FALSE, FALSE,
- NULL,
- GIMP_PARAM_READWRITE | GIMP_PARAM_NO_VALIDATE));
- gimp_pdb_register_procedure (pdb, procedure);
- g_object_unref (procedure);
-
- /*
- * gimp-register-save-handler
- */
- procedure = gimp_procedure_new (register_save_handler_invoker);
- gimp_object_set_static_name (GIMP_OBJECT (procedure),
- "gimp-register-save-handler");
- gimp_procedure_set_static_help (procedure,
- "Registers a file save handler procedure.",
- "Registers a procedural database procedure to be called to save files in a
particular file format.",
- NULL);
- gimp_procedure_set_static_attribution (procedure,
- "Spencer Kimball & Peter Mattis",
- "Spencer Kimball & Peter Mattis",
- "1995-1996");
- gimp_procedure_add_argument (procedure,
- gimp_param_spec_string ("procedure-name",
- "procedure name",
- "The name of the procedure to be used for saving",
- FALSE, FALSE, TRUE,
- NULL,
- GIMP_PARAM_READWRITE));
- gimp_procedure_add_argument (procedure,
- gimp_param_spec_string ("extensions",
- "extensions",
- "comma separated list of extensions this handler can
save (i.e. \"jpg,jpeg\")",
- FALSE, FALSE, FALSE,
- NULL,
- GIMP_PARAM_READWRITE | GIMP_PARAM_NO_VALIDATE));
- gimp_procedure_add_argument (procedure,
- gimp_param_spec_string ("prefixes",
- "prefixes",
- "comma separated list of prefixes this handler can
save (i.e. \"http:,ftp:\")",
- FALSE, FALSE, FALSE,
- NULL,
- GIMP_PARAM_READWRITE | GIMP_PARAM_NO_VALIDATE));
- gimp_pdb_register_procedure (pdb, procedure);
- g_object_unref (procedure);
-
- /*
- * gimp-register-file-handler-priority
- */
- procedure = gimp_procedure_new (register_file_handler_priority_invoker);
- gimp_object_set_static_name (GIMP_OBJECT (procedure),
- "gimp-register-file-handler-priority");
- gimp_procedure_set_static_help (procedure,
- "Sets the priority of a file handler procedure.",
- "Sets the priority of a file handler procedure. When more than one
procedure matches a given file, the procedure with the lowest priority is used; if more than one procedure
has the lowest priority, it is unspecified which one of them is used. The default priority for file handler
procedures is 0.",
- NULL);
- gimp_procedure_set_static_attribution (procedure,
- "Ell",
- "Ell",
- "2018");
- gimp_procedure_add_argument (procedure,
- gimp_param_spec_string ("procedure-name",
- "procedure name",
- "The name of the procedure to set the priority of.",
- FALSE, FALSE, TRUE,
- NULL,
- GIMP_PARAM_READWRITE));
- gimp_procedure_add_argument (procedure,
- g_param_spec_int ("priority",
- "priority",
- "The procedure priority.",
- G_MININT32, G_MAXINT32, 0,
- GIMP_PARAM_READWRITE));
- gimp_pdb_register_procedure (pdb, procedure);
- g_object_unref (procedure);
-
- /*
- * gimp-register-file-handler-mime
- */
- procedure = gimp_procedure_new (register_file_handler_mime_invoker);
- gimp_object_set_static_name (GIMP_OBJECT (procedure),
- "gimp-register-file-handler-mime");
- gimp_procedure_set_static_help (procedure,
- "Associates MIME types with a file handler procedure.",
- "Registers MIME types for a file handler procedure. This allows GIMP to
determine the MIME type of the file opened or saved using this procedure. It is recommended that only one
MIME type is registered per file procedure; when registering more than one MIME type, GIMP will associate the
first one with files opened or saved with this procedure.",
- NULL);
- gimp_procedure_set_static_attribution (procedure,
- "Sven Neumann <sven gimp org>",
- "Sven Neumann",
- "2004");
- gimp_procedure_add_argument (procedure,
- gimp_param_spec_string ("procedure-name",
- "procedure name",
- "The name of the procedure to associate a MIME type
with.",
- FALSE, FALSE, TRUE,
- NULL,
- GIMP_PARAM_READWRITE));
- gimp_procedure_add_argument (procedure,
- gimp_param_spec_string ("mime-types",
- "mime types",
- "A comma-separated list of MIME types, such as
\"image/jpeg\".",
- FALSE, FALSE, FALSE,
- NULL,
- GIMP_PARAM_READWRITE));
- gimp_pdb_register_procedure (pdb, procedure);
- g_object_unref (procedure);
-
- /*
- * gimp-register-file-handler-remote
- */
- procedure = gimp_procedure_new (register_file_handler_remote_invoker);
- gimp_object_set_static_name (GIMP_OBJECT (procedure),
- "gimp-register-file-handler-remote");
- gimp_procedure_set_static_help (procedure,
- "Registers a file handler procedure as capable of handling remote URIs.",
- "Registers a file handler procedure as capable of handling remote URIs.
This allows GIMP to call the procedure directly for all kinds of URIs, not only on local file:// URIs.",
- NULL);
- gimp_procedure_set_static_attribution (procedure,
- "Michael Natterer <mitch gimp org>",
- "Michael Natterer",
- "2012");
- gimp_procedure_add_argument (procedure,
- gimp_param_spec_string ("procedure-name",
- "procedure name",
- "The name of the procedure to enable remote URIs
for.",
- FALSE, FALSE, TRUE,
- NULL,
- GIMP_PARAM_READWRITE));
- gimp_pdb_register_procedure (pdb, procedure);
- g_object_unref (procedure);
-
- /*
- * gimp-register-file-handler-raw
- */
- procedure = gimp_procedure_new (register_file_handler_raw_invoker);
- gimp_object_set_static_name (GIMP_OBJECT (procedure),
- "gimp-register-file-handler-raw");
- gimp_procedure_set_static_help (procedure,
- "Registers a file handler procedure as capable of handling raw camera
files.",
- "Registers a file handler procedure as capable of handling raw digital
camera files. Use this procedure only to register raw load handlers, calling it on a save handler will
generate an error.",
- NULL);
- gimp_procedure_set_static_attribution (procedure,
- "Michael Natterer <mitch gimp org>",
- "Michael Natterer",
- "2017");
- gimp_procedure_add_argument (procedure,
- gimp_param_spec_string ("procedure-name",
- "procedure name",
- "The name of the procedure to enable raw handling
for.",
- FALSE, FALSE, TRUE,
- NULL,
- GIMP_PARAM_READWRITE));
- gimp_pdb_register_procedure (pdb, procedure);
- g_object_unref (procedure);
-
- /*
- * gimp-register-thumbnail-loader
- */
- procedure = gimp_procedure_new (register_thumbnail_loader_invoker);
- gimp_object_set_static_name (GIMP_OBJECT (procedure),
- "gimp-register-thumbnail-loader");
- gimp_procedure_set_static_help (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.",
- NULL);
- gimp_procedure_set_static_attribution (procedure,
- "Sven Neumann <sven gimp org>",
- "Sven Neumann",
- "2004");
- gimp_procedure_add_argument (procedure,
- gimp_param_spec_string ("load-proc",
- "load proc",
- "The name of the procedure the thumbnail loader
with.",
- FALSE, FALSE, TRUE,
- NULL,
- GIMP_PARAM_READWRITE));
- gimp_procedure_add_argument (procedure,
- gimp_param_spec_string ("thumb-proc",
- "thumb proc",
- "The name of the thumbnail load procedure.",
- FALSE, FALSE, TRUE,
- NULL,
- GIMP_PARAM_READWRITE));
- gimp_pdb_register_procedure (pdb, procedure);
- g_object_unref (procedure);
}
diff --git a/app/pdb/pdb-cmds.c b/app/pdb/pdb-cmds.c
index 7464994394..8e48ec57f3 100644
--- a/app/pdb/pdb-cmds.c
+++ b/app/pdb/pdb-cmds.c
@@ -811,6 +811,249 @@ pdb_get_proc_attribution_invoker (GimpProcedure *procedure,
return return_vals;
}
+static GimpValueArray *
+pdb_set_file_proc_load_handler_invoker (GimpProcedure *procedure,
+ Gimp *gimp,
+ GimpContext *context,
+ GimpProgress *progress,
+ const GimpValueArray *args,
+ GError **error)
+{
+ gboolean success = TRUE;
+ const gchar *procedure_name;
+ const gchar *extensions;
+ const gchar *prefixes;
+ const gchar *magics;
+
+ procedure_name = g_value_get_string (gimp_value_array_index (args, 0));
+ extensions = g_value_get_string (gimp_value_array_index (args, 1));
+ prefixes = g_value_get_string (gimp_value_array_index (args, 2));
+ magics = g_value_get_string (gimp_value_array_index (args, 3));
+
+ if (success)
+ {
+ GimpPlugIn *plug_in = gimp->plug_in_manager->current_plug_in;
+
+ if (plug_in &&
+ gimp_pdb_is_canonical_procedure (procedure_name, error))
+ {
+ success = gimp_plug_in_set_file_proc_load_handler (plug_in,
+ procedure_name,
+ extensions, prefixes,
+ magics, error);
+ }
+ else
+ success = FALSE;
+ }
+
+ return gimp_procedure_get_return_values (procedure, success,
+ error ? *error : NULL);
+}
+
+static GimpValueArray *
+pdb_set_file_proc_save_handler_invoker (GimpProcedure *procedure,
+ Gimp *gimp,
+ GimpContext *context,
+ GimpProgress *progress,
+ const GimpValueArray *args,
+ GError **error)
+{
+ gboolean success = TRUE;
+ const gchar *procedure_name;
+ const gchar *extensions;
+ const gchar *prefixes;
+
+ procedure_name = g_value_get_string (gimp_value_array_index (args, 0));
+ extensions = g_value_get_string (gimp_value_array_index (args, 1));
+ prefixes = g_value_get_string (gimp_value_array_index (args, 2));
+
+ if (success)
+ {
+ GimpPlugIn *plug_in = gimp->plug_in_manager->current_plug_in;
+
+ if (plug_in &&
+ gimp_pdb_is_canonical_procedure (procedure_name, error))
+ {
+ success = gimp_plug_in_set_file_proc_save_handler (plug_in,
+ procedure_name,
+ extensions, prefixes,
+ error);
+ }
+ else
+ success = FALSE;
+ }
+
+ return gimp_procedure_get_return_values (procedure, success,
+ error ? *error : NULL);
+}
+
+static GimpValueArray *
+pdb_set_file_proc_priority_invoker (GimpProcedure *procedure,
+ Gimp *gimp,
+ GimpContext *context,
+ GimpProgress *progress,
+ const GimpValueArray *args,
+ GError **error)
+{
+ gboolean success = TRUE;
+ const gchar *procedure_name;
+ gint priority;
+
+ procedure_name = g_value_get_string (gimp_value_array_index (args, 0));
+ priority = g_value_get_int (gimp_value_array_index (args, 1));
+
+ if (success)
+ {
+ GimpPlugIn *plug_in = gimp->plug_in_manager->current_plug_in;
+
+ if (plug_in &&
+ gimp_pdb_is_canonical_procedure (procedure_name, error))
+ {
+ success = gimp_plug_in_set_file_proc_priority (plug_in,
+ procedure_name,
+ priority, error);
+ }
+ else
+ success = FALSE;
+ }
+
+ return gimp_procedure_get_return_values (procedure, success,
+ error ? *error : NULL);
+}
+
+static GimpValueArray *
+pdb_set_file_proc_mime_types_invoker (GimpProcedure *procedure,
+ Gimp *gimp,
+ GimpContext *context,
+ GimpProgress *progress,
+ const GimpValueArray *args,
+ GError **error)
+{
+ gboolean success = TRUE;
+ const gchar *procedure_name;
+ const gchar *mime_types;
+
+ procedure_name = g_value_get_string (gimp_value_array_index (args, 0));
+ mime_types = g_value_get_string (gimp_value_array_index (args, 1));
+
+ if (success)
+ {
+ GimpPlugIn *plug_in = gimp->plug_in_manager->current_plug_in;
+
+ if (plug_in &&
+ gimp_pdb_is_canonical_procedure (procedure_name, error))
+ {
+ success = gimp_plug_in_set_file_proc_mime_types (plug_in,
+ procedure_name,
+ mime_types, error);
+ }
+ else
+ success = FALSE;
+ }
+
+ return gimp_procedure_get_return_values (procedure, success,
+ error ? *error : NULL);
+}
+
+static GimpValueArray *
+pdb_set_file_proc_handles_remote_invoker (GimpProcedure *procedure,
+ Gimp *gimp,
+ GimpContext *context,
+ GimpProgress *progress,
+ const GimpValueArray *args,
+ GError **error)
+{
+ gboolean success = TRUE;
+ const gchar *procedure_name;
+
+ procedure_name = g_value_get_string (gimp_value_array_index (args, 0));
+
+ if (success)
+ {
+ GimpPlugIn *plug_in = gimp->plug_in_manager->current_plug_in;
+
+ if (plug_in &&
+ gimp_pdb_is_canonical_procedure (procedure_name, error))
+ {
+ success = gimp_plug_in_set_file_proc_handles_remote (plug_in,
+ procedure_name,
+ error);
+ }
+ else
+ success = FALSE;
+ }
+
+ return gimp_procedure_get_return_values (procedure, success,
+ error ? *error : NULL);
+}
+
+static GimpValueArray *
+pdb_set_file_proc_handles_raw_invoker (GimpProcedure *procedure,
+ Gimp *gimp,
+ GimpContext *context,
+ GimpProgress *progress,
+ const GimpValueArray *args,
+ GError **error)
+{
+ gboolean success = TRUE;
+ const gchar *procedure_name;
+
+ procedure_name = g_value_get_string (gimp_value_array_index (args, 0));
+
+ if (success)
+ {
+ GimpPlugIn *plug_in = gimp->plug_in_manager->current_plug_in;
+
+ if (plug_in &&
+ gimp_pdb_is_canonical_procedure (procedure_name, error))
+ {
+ success = gimp_plug_in_set_file_proc_handles_raw (plug_in,
+ procedure_name,
+ error);
+ }
+ else
+ success = FALSE;
+ }
+
+ return gimp_procedure_get_return_values (procedure, success,
+ error ? *error : NULL);
+}
+
+static GimpValueArray *
+pdb_set_file_proc_thumbnail_loader_invoker (GimpProcedure *procedure,
+ Gimp *gimp,
+ GimpContext *context,
+ GimpProgress *progress,
+ const GimpValueArray *args,
+ GError **error)
+{
+ gboolean success = TRUE;
+ const gchar *load_proc;
+ const gchar *thumb_proc;
+
+ load_proc = g_value_get_string (gimp_value_array_index (args, 0));
+ thumb_proc = g_value_get_string (gimp_value_array_index (args, 1));
+
+ if (success)
+ {
+ GimpPlugIn *plug_in = gimp->plug_in_manager->current_plug_in;
+
+ if (plug_in &&
+ gimp_pdb_is_canonical_procedure (load_proc, error) &&
+ gimp_pdb_is_canonical_procedure (thumb_proc, error))
+ {
+ success = gimp_plug_in_set_file_proc_thumb_loader (plug_in,
+ load_proc, thumb_proc,
+ error);
+ }
+ else
+ success = FALSE;
+ }
+
+ return gimp_procedure_get_return_values (procedure, success,
+ error ? *error : NULL);
+}
+
static GimpValueArray *
pdb_get_data_invoker (GimpProcedure *procedure,
Gimp *gimp,
@@ -1612,6 +1855,229 @@ register_pdb_procs (GimpPDB *pdb)
gimp_pdb_register_procedure (pdb, procedure);
g_object_unref (procedure);
+ /*
+ * gimp-pdb-set-file-proc-load-handler
+ */
+ procedure = gimp_procedure_new (pdb_set_file_proc_load_handler_invoker);
+ gimp_object_set_static_name (GIMP_OBJECT (procedure),
+ "gimp-pdb-set-file-proc-load-handler");
+ gimp_procedure_set_static_help (procedure,
+ "Registers a file load handler procedure.",
+ "Registers a procedural database procedure to be called to load files of a
particular file format using magic file information.",
+ NULL);
+ gimp_procedure_set_static_attribution (procedure,
+ "Spencer Kimball & Peter Mattis",
+ "Spencer Kimball & Peter Mattis",
+ "1995-1996");
+ gimp_procedure_add_argument (procedure,
+ gimp_param_spec_string ("procedure-name",
+ "procedure name",
+ "The name of the procedure to be used for loading",
+ FALSE, FALSE, TRUE,
+ NULL,
+ GIMP_PARAM_READWRITE));
+ gimp_procedure_add_argument (procedure,
+ gimp_param_spec_string ("extensions",
+ "extensions",
+ "comma separated list of extensions this handler can
load (i.e. \"jpg,jpeg\")",
+ FALSE, FALSE, FALSE,
+ NULL,
+ GIMP_PARAM_READWRITE | GIMP_PARAM_NO_VALIDATE));
+ gimp_procedure_add_argument (procedure,
+ gimp_param_spec_string ("prefixes",
+ "prefixes",
+ "comma separated list of prefixes this handler can
load (i.e. \"http:,ftp:\")",
+ FALSE, FALSE, FALSE,
+ NULL,
+ GIMP_PARAM_READWRITE | GIMP_PARAM_NO_VALIDATE));
+ gimp_procedure_add_argument (procedure,
+ gimp_param_spec_string ("magics",
+ "magics",
+ "comma separated list of magic file information this
handler can load (i.e. \"0,string,GIF\")",
+ FALSE, FALSE, FALSE,
+ NULL,
+ GIMP_PARAM_READWRITE | GIMP_PARAM_NO_VALIDATE));
+ gimp_pdb_register_procedure (pdb, procedure);
+ g_object_unref (procedure);
+
+ /*
+ * gimp-pdb-set-file-proc-save-handler
+ */
+ procedure = gimp_procedure_new (pdb_set_file_proc_save_handler_invoker);
+ gimp_object_set_static_name (GIMP_OBJECT (procedure),
+ "gimp-pdb-set-file-proc-save-handler");
+ gimp_procedure_set_static_help (procedure,
+ "Registers a file save handler procedure.",
+ "Registers a procedural database procedure to be called to save files in a
particular file format.",
+ NULL);
+ gimp_procedure_set_static_attribution (procedure,
+ "Spencer Kimball & Peter Mattis",
+ "Spencer Kimball & Peter Mattis",
+ "1995-1996");
+ gimp_procedure_add_argument (procedure,
+ gimp_param_spec_string ("procedure-name",
+ "procedure name",
+ "The name of the procedure to be used for saving",
+ FALSE, FALSE, TRUE,
+ NULL,
+ GIMP_PARAM_READWRITE));
+ gimp_procedure_add_argument (procedure,
+ gimp_param_spec_string ("extensions",
+ "extensions",
+ "comma separated list of extensions this handler can
save (i.e. \"jpg,jpeg\")",
+ FALSE, FALSE, FALSE,
+ NULL,
+ GIMP_PARAM_READWRITE | GIMP_PARAM_NO_VALIDATE));
+ gimp_procedure_add_argument (procedure,
+ gimp_param_spec_string ("prefixes",
+ "prefixes",
+ "comma separated list of prefixes this handler can
save (i.e. \"http:,ftp:\")",
+ FALSE, FALSE, FALSE,
+ NULL,
+ GIMP_PARAM_READWRITE | GIMP_PARAM_NO_VALIDATE));
+ gimp_pdb_register_procedure (pdb, procedure);
+ g_object_unref (procedure);
+
+ /*
+ * gimp-pdb-set-file-proc-priority
+ */
+ procedure = gimp_procedure_new (pdb_set_file_proc_priority_invoker);
+ gimp_object_set_static_name (GIMP_OBJECT (procedure),
+ "gimp-pdb-set-file-proc-priority");
+ gimp_procedure_set_static_help (procedure,
+ "Sets the priority of a file handler procedure.",
+ "Sets the priority of a file handler procedure. When more than one
procedure matches a given file, the procedure with the lowest priority is used; if more than one procedure
has the lowest priority, it is unspecified which one of them is used. The default priority for file handler
procedures is 0.",
+ NULL);
+ gimp_procedure_set_static_attribution (procedure,
+ "Ell",
+ "Ell",
+ "2018");
+ gimp_procedure_add_argument (procedure,
+ gimp_param_spec_string ("procedure-name",
+ "procedure name",
+ "The name of the procedure to set the priority of.",
+ FALSE, FALSE, TRUE,
+ NULL,
+ GIMP_PARAM_READWRITE));
+ gimp_procedure_add_argument (procedure,
+ g_param_spec_int ("priority",
+ "priority",
+ "The procedure priority.",
+ G_MININT32, G_MAXINT32, 0,
+ GIMP_PARAM_READWRITE));
+ gimp_pdb_register_procedure (pdb, procedure);
+ g_object_unref (procedure);
+
+ /*
+ * gimp-pdb-set-file-proc-mime-types
+ */
+ procedure = gimp_procedure_new (pdb_set_file_proc_mime_types_invoker);
+ gimp_object_set_static_name (GIMP_OBJECT (procedure),
+ "gimp-pdb-set-file-proc-mime-types");
+ gimp_procedure_set_static_help (procedure,
+ "Associates MIME types with a file handler procedure.",
+ "Registers MIME types for a file handler procedure. This allows GIMP to
determine the MIME type of the file opened or saved using this procedure. It is recommended that only one
MIME type is registered per file procedure; when registering more than one MIME type, GIMP will associate the
first one with files opened or saved with this procedure.",
+ NULL);
+ gimp_procedure_set_static_attribution (procedure,
+ "Sven Neumann <sven gimp org>",
+ "Sven Neumann",
+ "2004");
+ gimp_procedure_add_argument (procedure,
+ gimp_param_spec_string ("procedure-name",
+ "procedure name",
+ "The name of the procedure to associate a MIME type
with.",
+ FALSE, FALSE, TRUE,
+ NULL,
+ GIMP_PARAM_READWRITE));
+ gimp_procedure_add_argument (procedure,
+ gimp_param_spec_string ("mime-types",
+ "mime types",
+ "A comma-separated list of MIME types, such as
\"image/jpeg\".",
+ FALSE, FALSE, FALSE,
+ NULL,
+ GIMP_PARAM_READWRITE));
+ gimp_pdb_register_procedure (pdb, procedure);
+ g_object_unref (procedure);
+
+ /*
+ * gimp-pdb-set-file-proc-handles-remote
+ */
+ procedure = gimp_procedure_new (pdb_set_file_proc_handles_remote_invoker);
+ gimp_object_set_static_name (GIMP_OBJECT (procedure),
+ "gimp-pdb-set-file-proc-handles-remote");
+ gimp_procedure_set_static_help (procedure,
+ "Registers a file handler procedure as capable of handling remote URIs.",
+ "Registers a file handler procedure as capable of handling remote URIs.
This allows GIMP to call the procedure directly for all kinds of URIs, not only on local file:// URIs.",
+ NULL);
+ gimp_procedure_set_static_attribution (procedure,
+ "Michael Natterer <mitch gimp org>",
+ "Michael Natterer",
+ "2012");
+ gimp_procedure_add_argument (procedure,
+ gimp_param_spec_string ("procedure-name",
+ "procedure name",
+ "The name of the procedure to enable remote URIs
for.",
+ FALSE, FALSE, TRUE,
+ NULL,
+ GIMP_PARAM_READWRITE));
+ gimp_pdb_register_procedure (pdb, procedure);
+ g_object_unref (procedure);
+
+ /*
+ * gimp-pdb-set-file-proc-handles-raw
+ */
+ procedure = gimp_procedure_new (pdb_set_file_proc_handles_raw_invoker);
+ gimp_object_set_static_name (GIMP_OBJECT (procedure),
+ "gimp-pdb-set-file-proc-handles-raw");
+ gimp_procedure_set_static_help (procedure,
+ "Registers a file handler procedure as capable of handling raw camera
files.",
+ "Registers a file handler procedure as capable of handling raw digital
camera files. Use this procedure only to register raw load handlers, calling it on a save handler will
generate an error.",
+ NULL);
+ gimp_procedure_set_static_attribution (procedure,
+ "Michael Natterer <mitch gimp org>",
+ "Michael Natterer",
+ "2017");
+ gimp_procedure_add_argument (procedure,
+ gimp_param_spec_string ("procedure-name",
+ "procedure name",
+ "The name of the procedure to enable raw handling
for.",
+ FALSE, FALSE, TRUE,
+ NULL,
+ GIMP_PARAM_READWRITE));
+ gimp_pdb_register_procedure (pdb, procedure);
+ g_object_unref (procedure);
+
+ /*
+ * gimp-pdb-set-file-proc-thumbnail-loader
+ */
+ procedure = gimp_procedure_new (pdb_set_file_proc_thumbnail_loader_invoker);
+ gimp_object_set_static_name (GIMP_OBJECT (procedure),
+ "gimp-pdb-set-file-proc-thumbnail-loader");
+ gimp_procedure_set_static_help (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.",
+ NULL);
+ gimp_procedure_set_static_attribution (procedure,
+ "Sven Neumann <sven gimp org>",
+ "Sven Neumann",
+ "2004");
+ gimp_procedure_add_argument (procedure,
+ gimp_param_spec_string ("load-proc",
+ "load proc",
+ "The name of the procedure the thumbnail loader
with.",
+ FALSE, FALSE, TRUE,
+ NULL,
+ GIMP_PARAM_READWRITE));
+ gimp_procedure_add_argument (procedure,
+ gimp_param_spec_string ("thumb-proc",
+ "thumb proc",
+ "The name of the thumbnail load procedure.",
+ FALSE, FALSE, TRUE,
+ NULL,
+ GIMP_PARAM_READWRITE));
+ gimp_pdb_register_procedure (pdb, procedure);
+ g_object_unref (procedure);
+
/*
* gimp-pdb-get-data
*/
diff --git a/libgimp/gimpfileops_pdb.c b/libgimp/gimpfileops_pdb.c
index 059511ddd3..a6b751e0c3 100644
--- a/libgimp/gimpfileops_pdb.c
+++ b/libgimp/gimpfileops_pdb.c
@@ -270,290 +270,3 @@ gimp_file_save_thumbnail (GimpImage *image,
return success;
}
-
-/**
- * _gimp_register_load_handler:
- * @procedure_name: The name of the procedure to be used for loading.
- * @extensions: comma separated list of extensions this handler can load (i.e. \"jpg,jpeg\").
- * @prefixes: comma separated list of prefixes this handler can load (i.e. \"http:,ftp:\").
- * @magics: comma separated list of magic file information this handler can load (i.e. \"0,string,GIF\").
- *
- * Registers a file load handler procedure.
- *
- * Registers a procedural database procedure to be called to load files
- * of a particular file format using magic file information.
- *
- * Returns: TRUE on success.
- **/
-gboolean
-_gimp_register_load_handler (const gchar *procedure_name,
- const gchar *extensions,
- const gchar *prefixes,
- const gchar *magics)
-{
- GimpValueArray *args;
- GimpValueArray *return_vals;
- gboolean success = TRUE;
-
- args = gimp_value_array_new_from_types (NULL,
- G_TYPE_STRING, procedure_name,
- G_TYPE_STRING, extensions,
- G_TYPE_STRING, prefixes,
- G_TYPE_STRING, magics,
- G_TYPE_NONE);
-
- return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
- "gimp-register-load-handler",
- args);
- gimp_value_array_unref (args);
-
- success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS;
-
- gimp_value_array_unref (return_vals);
-
- return success;
-}
-
-/**
- * _gimp_register_save_handler:
- * @procedure_name: The name of the procedure to be used for saving.
- * @extensions: comma separated list of extensions this handler can save (i.e. \"jpg,jpeg\").
- * @prefixes: comma separated list of prefixes this handler can save (i.e. \"http:,ftp:\").
- *
- * Registers a file save handler procedure.
- *
- * Registers a procedural database procedure to be called to save files
- * in a particular file format.
- *
- * Returns: TRUE on success.
- **/
-gboolean
-_gimp_register_save_handler (const gchar *procedure_name,
- const gchar *extensions,
- const gchar *prefixes)
-{
- GimpValueArray *args;
- GimpValueArray *return_vals;
- gboolean success = TRUE;
-
- args = gimp_value_array_new_from_types (NULL,
- G_TYPE_STRING, procedure_name,
- G_TYPE_STRING, extensions,
- G_TYPE_STRING, prefixes,
- G_TYPE_NONE);
-
- return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
- "gimp-register-save-handler",
- args);
- gimp_value_array_unref (args);
-
- success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS;
-
- gimp_value_array_unref (return_vals);
-
- return success;
-}
-
-/**
- * _gimp_register_file_handler_priority:
- * @procedure_name: The name of the procedure to set the priority of.
- * @priority: The procedure priority.
- *
- * Sets the priority of a file handler procedure.
- *
- * Sets the priority of a file handler procedure. When more than one
- * procedure matches a given file, the procedure with the lowest
- * priority is used; if more than one procedure has the lowest
- * priority, it is unspecified which one of them is used. The default
- * priority for file handler procedures is 0.
- *
- * Returns: TRUE on success.
- *
- * Since: 2.10.6
- **/
-gboolean
-_gimp_register_file_handler_priority (const gchar *procedure_name,
- gint priority)
-{
- GimpValueArray *args;
- GimpValueArray *return_vals;
- gboolean success = TRUE;
-
- args = gimp_value_array_new_from_types (NULL,
- G_TYPE_STRING, procedure_name,
- G_TYPE_INT, priority,
- G_TYPE_NONE);
-
- return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
- "gimp-register-file-handler-priority",
- args);
- gimp_value_array_unref (args);
-
- success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS;
-
- gimp_value_array_unref (return_vals);
-
- return success;
-}
-
-/**
- * _gimp_register_file_handler_mime:
- * @procedure_name: The name of the procedure to associate a MIME type with.
- * @mime_types: A comma-separated list of MIME types, such as \"image/jpeg\".
- *
- * Associates MIME types with a file handler procedure.
- *
- * Registers MIME types for a file handler procedure. This allows GIMP
- * to determine the MIME type of the file opened or saved using this
- * procedure. It is recommended that only one MIME type is registered
- * per file procedure; when registering more than one MIME type, GIMP
- * will associate the first one with files opened or saved with this
- * procedure.
- *
- * Returns: TRUE on success.
- *
- * Since: 2.2
- **/
-gboolean
-_gimp_register_file_handler_mime (const gchar *procedure_name,
- const gchar *mime_types)
-{
- GimpValueArray *args;
- GimpValueArray *return_vals;
- gboolean success = TRUE;
-
- args = gimp_value_array_new_from_types (NULL,
- G_TYPE_STRING, procedure_name,
- G_TYPE_STRING, mime_types,
- G_TYPE_NONE);
-
- return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
- "gimp-register-file-handler-mime",
- args);
- gimp_value_array_unref (args);
-
- success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS;
-
- gimp_value_array_unref (return_vals);
-
- return success;
-}
-
-/**
- * _gimp_register_file_handler_remote:
- * @procedure_name: The name of the procedure to enable remote URIs for.
- *
- * Registers a file handler procedure as capable of handling remote
- * URIs.
- *
- * Registers a file handler procedure as capable of handling remote
- * URIs. This allows GIMP to call the procedure directly for all kinds
- * of URIs, not only on local file:// URIs.
- *
- * Returns: TRUE on success.
- *
- * Since: 2.10
- **/
-gboolean
-_gimp_register_file_handler_remote (const gchar *procedure_name)
-{
- GimpValueArray *args;
- GimpValueArray *return_vals;
- gboolean success = TRUE;
-
- args = gimp_value_array_new_from_types (NULL,
- G_TYPE_STRING, procedure_name,
- G_TYPE_NONE);
-
- return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
- "gimp-register-file-handler-remote",
- args);
- gimp_value_array_unref (args);
-
- success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS;
-
- gimp_value_array_unref (return_vals);
-
- return success;
-}
-
-/**
- * _gimp_register_file_handler_raw:
- * @procedure_name: The name of the procedure to enable raw handling for.
- *
- * Registers a file handler procedure as capable of handling raw camera
- * files.
- *
- * Registers a file handler procedure as capable of handling raw
- * digital camera files. Use this procedure only to register raw load
- * handlers, calling it on a save handler will generate an error.
- *
- * Returns: TRUE on success.
- *
- * Since: 2.10
- **/
-gboolean
-_gimp_register_file_handler_raw (const gchar *procedure_name)
-{
- GimpValueArray *args;
- GimpValueArray *return_vals;
- gboolean success = TRUE;
-
- args = gimp_value_array_new_from_types (NULL,
- G_TYPE_STRING, procedure_name,
- G_TYPE_NONE);
-
- return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
- "gimp-register-file-handler-raw",
- args);
- gimp_value_array_unref (args);
-
- success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS;
-
- gimp_value_array_unref (return_vals);
-
- 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: 2.2
- **/
-gboolean
-_gimp_register_thumbnail_loader (const gchar *load_proc,
- const gchar *thumb_proc)
-{
- GimpValueArray *args;
- GimpValueArray *return_vals;
- gboolean success = TRUE;
-
- args = gimp_value_array_new_from_types (NULL,
- G_TYPE_STRING, load_proc,
- G_TYPE_STRING, thumb_proc,
- G_TYPE_NONE);
-
- return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
- "gimp-register-thumbnail-loader",
- args);
- gimp_value_array_unref (args);
-
- success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS;
-
- gimp_value_array_unref (return_vals);
-
- return success;
-}
diff --git a/libgimp/gimpfileops_pdb.h b/libgimp/gimpfileops_pdb.h
index 7f287cca9c..98a8b2087c 100644
--- a/libgimp/gimpfileops_pdb.h
+++ b/libgimp/gimpfileops_pdb.h
@@ -32,38 +32,23 @@ G_BEGIN_DECLS
/* For information look into the C source or the html documentation */
-GimpImage* gimp_file_load (GimpRunMode run_mode,
- const gchar *filename,
- const gchar *raw_filename);
-GimpLayer* gimp_file_load_layer (GimpRunMode run_mode,
- GimpImage *image,
- const gchar *filename);
-GimpLayer** gimp_file_load_layers (GimpRunMode run_mode,
- GimpImage *image,
- const gchar *filename,
- gint *num_layers);
-gboolean gimp_file_save (GimpRunMode run_mode,
- GimpImage *image,
- GimpDrawable *drawable,
- const gchar *filename,
- const gchar *raw_filename);
-gboolean gimp_file_save_thumbnail (GimpImage *image,
- const gchar *filename);
-G_GNUC_INTERNAL gboolean _gimp_register_load_handler (const gchar *procedure_name,
- const gchar *extensions,
- const gchar *prefixes,
- const gchar *magics);
-G_GNUC_INTERNAL gboolean _gimp_register_save_handler (const gchar *procedure_name,
- const gchar *extensions,
- const gchar *prefixes);
-G_GNUC_INTERNAL gboolean _gimp_register_file_handler_priority (const gchar *procedure_name,
- gint priority);
-G_GNUC_INTERNAL gboolean _gimp_register_file_handler_mime (const gchar *procedure_name,
- const gchar *mime_types);
-G_GNUC_INTERNAL gboolean _gimp_register_file_handler_remote (const gchar *procedure_name);
-G_GNUC_INTERNAL gboolean _gimp_register_file_handler_raw (const gchar *procedure_name);
-G_GNUC_INTERNAL gboolean _gimp_register_thumbnail_loader (const gchar *load_proc,
- const gchar *thumb_proc);
+GimpImage* gimp_file_load (GimpRunMode run_mode,
+ const gchar *filename,
+ const gchar *raw_filename);
+GimpLayer* gimp_file_load_layer (GimpRunMode run_mode,
+ GimpImage *image,
+ const gchar *filename);
+GimpLayer** gimp_file_load_layers (GimpRunMode run_mode,
+ GimpImage *image,
+ const gchar *filename,
+ gint *num_layers);
+gboolean gimp_file_save (GimpRunMode run_mode,
+ GimpImage *image,
+ GimpDrawable *drawable,
+ const gchar *filename,
+ const gchar *raw_filename);
+gboolean gimp_file_save_thumbnail (GimpImage *image,
+ const gchar *filename);
G_END_DECLS
diff --git a/libgimp/gimploadprocedure.c b/libgimp/gimploadprocedure.c
index b9d91ccbf0..c4f6ede306 100644
--- a/libgimp/gimploadprocedure.c
+++ b/libgimp/gimploadprocedure.c
@@ -23,6 +23,7 @@
#include "gimp.h"
#include "gimploadprocedure.h"
+#include "gimppdb_pdb.h"
struct _GimpLoadProcedurePrivate
@@ -119,30 +120,30 @@ gimp_load_procedure_install (GimpProcedure *procedure)
GIMP_PROCEDURE_CLASS (parent_class)->install (procedure);
- _gimp_register_load_handler (gimp_procedure_get_name (procedure),
- gimp_file_procedure_get_extensions (file_proc),
- gimp_file_procedure_get_prefixes (file_proc),
- gimp_file_procedure_get_magics (file_proc));
+ _gimp_pdb_set_file_proc_load_handler (gimp_procedure_get_name (procedure),
+ gimp_file_procedure_get_extensions (file_proc),
+ gimp_file_procedure_get_prefixes (file_proc),
+ gimp_file_procedure_get_magics (file_proc));
if (gimp_file_procedure_get_handles_remote (file_proc))
- _gimp_register_file_handler_remote (gimp_procedure_get_name (procedure));
+ _gimp_pdb_set_file_proc_handles_remote (gimp_procedure_get_name (procedure));
mime_types = gimp_file_procedure_get_mime_types (file_proc);
if (mime_types)
- _gimp_register_file_handler_mime (gimp_procedure_get_name (procedure),
- mime_types);
+ _gimp_pdb_set_file_proc_mime_types (gimp_procedure_get_name (procedure),
+ mime_types);
priority = gimp_file_procedure_get_priority (file_proc);
if (priority != 0)
- _gimp_register_file_handler_priority (gimp_procedure_get_name (procedure),
- priority);
+ _gimp_pdb_set_file_proc_priority (gimp_procedure_get_name (procedure),
+ priority);
if (load_proc->priv->handles_raw)
- _gimp_register_file_handler_raw (gimp_procedure_get_name (procedure));
+ _gimp_pdb_set_file_proc_handles_raw (gimp_procedure_get_name (procedure));
if (load_proc->priv->thumbnail_proc)
- _gimp_register_thumbnail_loader (gimp_procedure_get_name (procedure),
- load_proc->priv->thumbnail_proc);
+ _gimp_pdb_set_file_proc_thumbnail_loader (gimp_procedure_get_name (procedure),
+ load_proc->priv->thumbnail_proc);
}
static GimpValueArray *
diff --git a/libgimp/gimppdb_pdb.c b/libgimp/gimppdb_pdb.c
index 930db82693..7e9407a4a0 100644
--- a/libgimp/gimppdb_pdb.c
+++ b/libgimp/gimppdb_pdb.c
@@ -823,6 +823,293 @@ _gimp_pdb_get_proc_attribution (const gchar *procedure_name,
return success;
}
+/**
+ * _gimp_pdb_set_file_proc_load_handler:
+ * @procedure_name: The name of the procedure to be used for loading.
+ * @extensions: comma separated list of extensions this handler can load (i.e. \"jpg,jpeg\").
+ * @prefixes: comma separated list of prefixes this handler can load (i.e. \"http:,ftp:\").
+ * @magics: comma separated list of magic file information this handler can load (i.e. \"0,string,GIF\").
+ *
+ * Registers a file load handler procedure.
+ *
+ * Registers a procedural database procedure to be called to load files
+ * of a particular file format using magic file information.
+ *
+ * Returns: TRUE on success.
+ **/
+gboolean
+_gimp_pdb_set_file_proc_load_handler (const gchar *procedure_name,
+ const gchar *extensions,
+ const gchar *prefixes,
+ const gchar *magics)
+{
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
+ gboolean success = TRUE;
+
+ args = gimp_value_array_new_from_types (NULL,
+ G_TYPE_STRING, procedure_name,
+ G_TYPE_STRING, extensions,
+ G_TYPE_STRING, prefixes,
+ G_TYPE_STRING, magics,
+ G_TYPE_NONE);
+
+ return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
+ "gimp-pdb-set-file-proc-load-handler",
+ args);
+ gimp_value_array_unref (args);
+
+ success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
+
+ return success;
+}
+
+/**
+ * _gimp_pdb_set_file_proc_save_handler:
+ * @procedure_name: The name of the procedure to be used for saving.
+ * @extensions: comma separated list of extensions this handler can save (i.e. \"jpg,jpeg\").
+ * @prefixes: comma separated list of prefixes this handler can save (i.e. \"http:,ftp:\").
+ *
+ * Registers a file save handler procedure.
+ *
+ * Registers a procedural database procedure to be called to save files
+ * in a particular file format.
+ *
+ * Returns: TRUE on success.
+ **/
+gboolean
+_gimp_pdb_set_file_proc_save_handler (const gchar *procedure_name,
+ const gchar *extensions,
+ const gchar *prefixes)
+{
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
+ gboolean success = TRUE;
+
+ args = gimp_value_array_new_from_types (NULL,
+ G_TYPE_STRING, procedure_name,
+ G_TYPE_STRING, extensions,
+ G_TYPE_STRING, prefixes,
+ G_TYPE_NONE);
+
+ return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
+ "gimp-pdb-set-file-proc-save-handler",
+ args);
+ gimp_value_array_unref (args);
+
+ success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
+
+ return success;
+}
+
+/**
+ * _gimp_pdb_set_file_proc_priority:
+ * @procedure_name: The name of the procedure to set the priority of.
+ * @priority: The procedure priority.
+ *
+ * Sets the priority of a file handler procedure.
+ *
+ * Sets the priority of a file handler procedure. When more than one
+ * procedure matches a given file, the procedure with the lowest
+ * priority is used; if more than one procedure has the lowest
+ * priority, it is unspecified which one of them is used. The default
+ * priority for file handler procedures is 0.
+ *
+ * Returns: TRUE on success.
+ *
+ * Since: 2.10.6
+ **/
+gboolean
+_gimp_pdb_set_file_proc_priority (const gchar *procedure_name,
+ gint priority)
+{
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
+ gboolean success = TRUE;
+
+ args = gimp_value_array_new_from_types (NULL,
+ G_TYPE_STRING, procedure_name,
+ G_TYPE_INT, priority,
+ G_TYPE_NONE);
+
+ return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
+ "gimp-pdb-set-file-proc-priority",
+ args);
+ gimp_value_array_unref (args);
+
+ success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
+
+ return success;
+}
+
+/**
+ * _gimp_pdb_set_file_proc_mime_types:
+ * @procedure_name: The name of the procedure to associate a MIME type with.
+ * @mime_types: A comma-separated list of MIME types, such as \"image/jpeg\".
+ *
+ * Associates MIME types with a file handler procedure.
+ *
+ * Registers MIME types for a file handler procedure. This allows GIMP
+ * to determine the MIME type of the file opened or saved using this
+ * procedure. It is recommended that only one MIME type is registered
+ * per file procedure; when registering more than one MIME type, GIMP
+ * will associate the first one with files opened or saved with this
+ * procedure.
+ *
+ * Returns: TRUE on success.
+ *
+ * Since: 2.2
+ **/
+gboolean
+_gimp_pdb_set_file_proc_mime_types (const gchar *procedure_name,
+ const gchar *mime_types)
+{
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
+ gboolean success = TRUE;
+
+ args = gimp_value_array_new_from_types (NULL,
+ G_TYPE_STRING, procedure_name,
+ G_TYPE_STRING, mime_types,
+ G_TYPE_NONE);
+
+ return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
+ "gimp-pdb-set-file-proc-mime-types",
+ args);
+ gimp_value_array_unref (args);
+
+ success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
+
+ return success;
+}
+
+/**
+ * _gimp_pdb_set_file_proc_handles_remote:
+ * @procedure_name: The name of the procedure to enable remote URIs for.
+ *
+ * Registers a file handler procedure as capable of handling remote
+ * URIs.
+ *
+ * Registers a file handler procedure as capable of handling remote
+ * URIs. This allows GIMP to call the procedure directly for all kinds
+ * of URIs, not only on local file:// URIs.
+ *
+ * Returns: TRUE on success.
+ *
+ * Since: 2.10
+ **/
+gboolean
+_gimp_pdb_set_file_proc_handles_remote (const gchar *procedure_name)
+{
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
+ gboolean success = TRUE;
+
+ args = gimp_value_array_new_from_types (NULL,
+ G_TYPE_STRING, procedure_name,
+ G_TYPE_NONE);
+
+ return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
+ "gimp-pdb-set-file-proc-handles-remote",
+ args);
+ gimp_value_array_unref (args);
+
+ success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
+
+ return success;
+}
+
+/**
+ * _gimp_pdb_set_file_proc_handles_raw:
+ * @procedure_name: The name of the procedure to enable raw handling for.
+ *
+ * Registers a file handler procedure as capable of handling raw camera
+ * files.
+ *
+ * Registers a file handler procedure as capable of handling raw
+ * digital camera files. Use this procedure only to register raw load
+ * handlers, calling it on a save handler will generate an error.
+ *
+ * Returns: TRUE on success.
+ *
+ * Since: 2.10
+ **/
+gboolean
+_gimp_pdb_set_file_proc_handles_raw (const gchar *procedure_name)
+{
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
+ gboolean success = TRUE;
+
+ args = gimp_value_array_new_from_types (NULL,
+ G_TYPE_STRING, procedure_name,
+ G_TYPE_NONE);
+
+ return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
+ "gimp-pdb-set-file-proc-handles-raw",
+ args);
+ gimp_value_array_unref (args);
+
+ success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
+
+ return success;
+}
+
+/**
+ * _gimp_pdb_set_file_proc_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: 2.2
+ **/
+gboolean
+_gimp_pdb_set_file_proc_thumbnail_loader (const gchar *load_proc,
+ const gchar *thumb_proc)
+{
+ GimpValueArray *args;
+ GimpValueArray *return_vals;
+ gboolean success = TRUE;
+
+ args = gimp_value_array_new_from_types (NULL,
+ G_TYPE_STRING, load_proc,
+ G_TYPE_STRING, thumb_proc,
+ G_TYPE_NONE);
+
+ return_vals = gimp_pdb_run_procedure_array (gimp_get_pdb (),
+ "gimp-pdb-set-file-proc-thumbnail-loader",
+ args);
+ gimp_value_array_unref (args);
+
+ success = GIMP_VALUES_GET_ENUM (return_vals, 0) == GIMP_PDB_SUCCESS;
+
+ gimp_value_array_unref (return_vals);
+
+ return success;
+}
+
/**
* _gimp_pdb_get_data:
* @identifier: The identifier associated with data.
diff --git a/libgimp/gimppdb_pdb.h b/libgimp/gimppdb_pdb.h
index 72cc240853..fbfa9e6d5a 100644
--- a/libgimp/gimppdb_pdb.h
+++ b/libgimp/gimppdb_pdb.h
@@ -32,63 +32,78 @@ G_BEGIN_DECLS
/* For information look into the C source or the html documentation */
-G_GNUC_INTERNAL gchar* _gimp_pdb_temp_name (void);
-G_GNUC_INTERNAL gboolean _gimp_pdb_dump (const gchar *filename);
-G_GNUC_INTERNAL gboolean _gimp_pdb_query (const gchar *name,
- const gchar *blurb,
- const gchar *help,
- const gchar *authors,
- const gchar *copyright,
- const gchar *date,
- const gchar *proc_type,
- gint *num_matches,
- gchar ***procedure_names);
-G_GNUC_INTERNAL gboolean _gimp_pdb_proc_exists (const gchar *procedure_name);
-G_GNUC_INTERNAL gboolean _gimp_pdb_get_proc_info (const gchar *procedure_name,
- GimpPDBProcType *proc_type,
- gint *num_args,
- gint *num_values);
-G_GNUC_INTERNAL GParamSpec* _gimp_pdb_get_proc_argument (const gchar *procedure_name,
- gint arg_num);
-G_GNUC_INTERNAL GParamSpec* _gimp_pdb_get_proc_return_value (const gchar *procedure_name,
- gint val_num);
-G_GNUC_INTERNAL gboolean _gimp_pdb_set_proc_image_types (const gchar *procedure_name,
- const gchar *image_types);
-G_GNUC_INTERNAL gchar* _gimp_pdb_get_proc_image_types (const gchar *procedure_name);
-G_GNUC_INTERNAL gboolean _gimp_pdb_set_proc_menu_label (const gchar *procedure_name,
- const gchar *menu_label);
-G_GNUC_INTERNAL gchar* _gimp_pdb_get_proc_menu_label (const gchar *procedure_name);
-G_GNUC_INTERNAL gboolean _gimp_pdb_add_proc_menu_path (const gchar *procedure_name,
- const gchar *menu_path);
-G_GNUC_INTERNAL gchar** _gimp_pdb_get_proc_menu_paths (const gchar *procedure_name,
- gint *num_menu_paths);
-G_GNUC_INTERNAL gboolean _gimp_pdb_set_proc_icon (const gchar *procedure_name,
- GimpIconType icon_type,
- gint icon_data_length,
- const guint8 *icon_data);
-G_GNUC_INTERNAL gboolean _gimp_pdb_set_proc_documentation (const gchar *procedure_name,
- const gchar *blurb,
- const gchar *help,
- const gchar *help_id);
-G_GNUC_INTERNAL gboolean _gimp_pdb_get_proc_documentation (const gchar *procedure_name,
- gchar **blurb,
- gchar **help,
- gchar **help_id);
-G_GNUC_INTERNAL gboolean _gimp_pdb_set_proc_attribution (const gchar *procedure_name,
- const gchar *authors,
- const gchar *copyright,
- const gchar *date);
-G_GNUC_INTERNAL gboolean _gimp_pdb_get_proc_attribution (const gchar *procedure_name,
- gchar **authors,
- gchar **copyright,
- gchar **date);
-G_GNUC_INTERNAL gboolean _gimp_pdb_get_data (const gchar *identifier,
- gint *bytes,
- guint8 **data);
-G_GNUC_INTERNAL gint _gimp_pdb_get_data_size (const gchar *identifier);
-G_GNUC_INTERNAL gboolean _gimp_pdb_set_data (const gchar *identifier,
- gint bytes,
- const guint8 *data);
+G_GNUC_INTERNAL gchar* _gimp_pdb_temp_name (void);
+G_GNUC_INTERNAL gboolean _gimp_pdb_dump (const gchar *filename);
+G_GNUC_INTERNAL gboolean _gimp_pdb_query (const gchar *name,
+ const gchar *blurb,
+ const gchar *help,
+ const gchar *authors,
+ const gchar *copyright,
+ const gchar *date,
+ const gchar *proc_type,
+ gint *num_matches,
+ gchar ***procedure_names);
+G_GNUC_INTERNAL gboolean _gimp_pdb_proc_exists (const gchar *procedure_name);
+G_GNUC_INTERNAL gboolean _gimp_pdb_get_proc_info (const gchar *procedure_name,
+ GimpPDBProcType *proc_type,
+ gint *num_args,
+ gint *num_values);
+G_GNUC_INTERNAL GParamSpec* _gimp_pdb_get_proc_argument (const gchar *procedure_name,
+ gint arg_num);
+G_GNUC_INTERNAL GParamSpec* _gimp_pdb_get_proc_return_value (const gchar *procedure_name,
+ gint val_num);
+G_GNUC_INTERNAL gboolean _gimp_pdb_set_proc_image_types (const gchar *procedure_name,
+ const gchar *image_types);
+G_GNUC_INTERNAL gchar* _gimp_pdb_get_proc_image_types (const gchar *procedure_name);
+G_GNUC_INTERNAL gboolean _gimp_pdb_set_proc_menu_label (const gchar *procedure_name,
+ const gchar *menu_label);
+G_GNUC_INTERNAL gchar* _gimp_pdb_get_proc_menu_label (const gchar *procedure_name);
+G_GNUC_INTERNAL gboolean _gimp_pdb_add_proc_menu_path (const gchar *procedure_name,
+ const gchar *menu_path);
+G_GNUC_INTERNAL gchar** _gimp_pdb_get_proc_menu_paths (const gchar *procedure_name,
+ gint *num_menu_paths);
+G_GNUC_INTERNAL gboolean _gimp_pdb_set_proc_icon (const gchar *procedure_name,
+ GimpIconType icon_type,
+ gint icon_data_length,
+ const guint8 *icon_data);
+G_GNUC_INTERNAL gboolean _gimp_pdb_set_proc_documentation (const gchar *procedure_name,
+ const gchar *blurb,
+ const gchar *help,
+ const gchar *help_id);
+G_GNUC_INTERNAL gboolean _gimp_pdb_get_proc_documentation (const gchar *procedure_name,
+ gchar **blurb,
+ gchar **help,
+ gchar **help_id);
+G_GNUC_INTERNAL gboolean _gimp_pdb_set_proc_attribution (const gchar *procedure_name,
+ const gchar *authors,
+ const gchar *copyright,
+ const gchar *date);
+G_GNUC_INTERNAL gboolean _gimp_pdb_get_proc_attribution (const gchar *procedure_name,
+ gchar **authors,
+ gchar **copyright,
+ gchar **date);
+G_GNUC_INTERNAL gboolean _gimp_pdb_set_file_proc_load_handler (const gchar *procedure_name,
+ const gchar *extensions,
+ const gchar *prefixes,
+ const gchar *magics);
+G_GNUC_INTERNAL gboolean _gimp_pdb_set_file_proc_save_handler (const gchar *procedure_name,
+ const gchar *extensions,
+ const gchar *prefixes);
+G_GNUC_INTERNAL gboolean _gimp_pdb_set_file_proc_priority (const gchar *procedure_name,
+ gint priority);
+G_GNUC_INTERNAL gboolean _gimp_pdb_set_file_proc_mime_types (const gchar *procedure_name,
+ const gchar *mime_types);
+G_GNUC_INTERNAL gboolean _gimp_pdb_set_file_proc_handles_remote (const gchar *procedure_name);
+G_GNUC_INTERNAL gboolean _gimp_pdb_set_file_proc_handles_raw (const gchar *procedure_name);
+G_GNUC_INTERNAL gboolean _gimp_pdb_set_file_proc_thumbnail_loader (const gchar *load_proc,
+ const gchar *thumb_proc);
+G_GNUC_INTERNAL gboolean _gimp_pdb_get_data (const gchar *identifier,
+ gint *bytes,
+ guint8 **data);
+G_GNUC_INTERNAL gint _gimp_pdb_get_data_size (const gchar *identifier);
+G_GNUC_INTERNAL gboolean _gimp_pdb_set_data (const gchar *identifier,
+ gint bytes,
+ const guint8 *data);
G_END_DECLS
diff --git a/libgimp/gimpsaveprocedure.c b/libgimp/gimpsaveprocedure.c
index c08713f58d..f73d06db58 100644
--- a/libgimp/gimpsaveprocedure.c
+++ b/libgimp/gimpsaveprocedure.c
@@ -23,6 +23,7 @@
#include "gimp.h"
#include "gimpsaveprocedure.h"
+#include "gimppdb_pdb.h"
struct _GimpSaveProcedurePrivate
@@ -119,22 +120,22 @@ gimp_save_procedure_install (GimpProcedure *procedure)
GIMP_PROCEDURE_CLASS (parent_class)->install (procedure);
- _gimp_register_save_handler (gimp_procedure_get_name (procedure),
- gimp_file_procedure_get_extensions (file_proc),
- gimp_file_procedure_get_prefixes (file_proc));
+ _gimp_pdb_set_file_proc_save_handler (gimp_procedure_get_name (procedure),
+ gimp_file_procedure_get_extensions (file_proc),
+ gimp_file_procedure_get_prefixes (file_proc));
if (gimp_file_procedure_get_handles_remote (file_proc))
- _gimp_register_file_handler_remote (gimp_procedure_get_name (procedure));
+ _gimp_pdb_set_file_proc_handles_remote (gimp_procedure_get_name (procedure));
mime_types = gimp_file_procedure_get_mime_types (file_proc);
if (mime_types)
- _gimp_register_file_handler_mime (gimp_procedure_get_name (procedure),
- mime_types);
+ _gimp_pdb_set_file_proc_mime_types (gimp_procedure_get_name (procedure),
+ mime_types);
priority = gimp_file_procedure_get_priority (file_proc);
if (priority != 0)
- _gimp_register_file_handler_priority (gimp_procedure_get_name (procedure),
- priority);
+ _gimp_pdb_set_file_proc_priority (gimp_procedure_get_name (procedure),
+ priority);
}
static GimpValueArray *
diff --git a/pdb/groups/fileops.pdb b/pdb/groups/fileops.pdb
index ecc24d86ea..a0bfd3d42f 100644
--- a/pdb/groups/fileops.pdb
+++ b/pdb/groups/fileops.pdb
@@ -436,303 +436,9 @@ CODE
);
}
-sub register_load_handler {
- $blurb = 'Registers a file load handler procedure.';
- $help = <<'HELP';
-Registers a procedural database procedure to be called to load files of a
-particular file format using magic file information.
-HELP
-
- &std_pdb_misc;
-
- $lib_private = 1;
-
- @inargs = (
- { name => 'procedure_name', type => 'string', non_empty => 1,
- desc => 'The name of the procedure to be used for loading' },
- { name => 'extensions', type => 'string', no_validate => 1,
- desc => 'comma separated list of extensions this handler
- can load (i.e. "jpg,jpeg")' },
- { name => 'prefixes', type => 'string', no_validate => 1,
- desc => 'comma separated list of prefixes this handler
- can load (i.e. "http:,ftp:")' },
- { name => 'magics', type => 'string', no_validate => 1,
- desc => 'comma separated list of magic file information
- this handler can load (i.e. "0,string,GIF")' }
- );
-
- %invoke = (
- code => <<'CODE'
-{
- GimpPlugIn *plug_in = gimp->plug_in_manager->current_plug_in;
-
- if (plug_in &&
- gimp_pdb_is_canonical_procedure (procedure_name, error))
- {
- success = gimp_plug_in_set_file_proc_load_handler (plug_in,
- procedure_name,
- extensions, prefixes,
- magics, error);
- }
- else
- success = FALSE;
-}
-CODE
- );
-}
-
-sub register_save_handler {
- $blurb = 'Registers a file save handler procedure.';
-
- $help = <<'HELP';
-Registers a procedural database procedure to be called to save files in a
-particular file format.
-HELP
-
- &std_pdb_misc;
-
- $lib_private = 1;
-
- @inargs = (
- { name => 'procedure_name', type => 'string', non_empty => 1,
- desc => 'The name of the procedure to be used for saving' },
- { name => 'extensions', type => 'string', no_validate => 1,
- desc => 'comma separated list of extensions this handler
- can save (i.e. "jpg,jpeg")' },
- { name => 'prefixes', type => 'string', no_validate => 1,
- desc => 'comma separated list of prefixes this handler
- can save (i.e. "http:,ftp:")' }
- );
-
- %invoke = (
- code => <<'CODE'
-{
- GimpPlugIn *plug_in = gimp->plug_in_manager->current_plug_in;
-
- if (plug_in &&
- gimp_pdb_is_canonical_procedure (procedure_name, error))
- {
- success = gimp_plug_in_set_file_proc_save_handler (plug_in,
- procedure_name,
- extensions, prefixes,
- error);
- }
- else
- success = FALSE;
-}
-CODE
- );
-}
-
-sub register_file_handler_priority {
- $blurb = 'Sets the priority of a file handler procedure.';
-
- $help = <<'HELP';
-Sets the priority of a file handler procedure. When more than one
-procedure matches a given file, the procedure with the lowest priority
-is used; if more than one procedure has the lowest priority, it is
-unspecified which one of them is used. The default priority for file
-handler procedures is 0.
-HELP
-
- &ell_pdb_misc('2018', '2.10.6');
-
- $lib_private = 1;
-
- @inargs = (
- { name => 'procedure_name', type => 'string', non_empty => 1,
- desc => "The name of the procedure to set the priority of." },
- { name => 'priority', type => 'int32',
- desc => "The procedure priority." }
- );
-
- %invoke = (
- code => <<'CODE'
-{
- GimpPlugIn *plug_in = gimp->plug_in_manager->current_plug_in;
-
- if (plug_in &&
- gimp_pdb_is_canonical_procedure (procedure_name, error))
- {
- success = gimp_plug_in_set_file_proc_priority (plug_in,
- procedure_name,
- priority, error);
- }
- else
- success = FALSE;
-}
-CODE
- );
-}
-
-sub register_file_handler_remote {
- $blurb = 'Registers a file handler procedure as capable of handling remote URIs.';
-
- $help = <<'HELP';
-Registers a file handler procedure as capable of handling remote
-URIs. This allows GIMP to call the procedure directly for all kinds of
-URIs, not only on local file:// URIs.
-HELP
-
- &mitch_pdb_misc('2012', '2.10');
-
- $lib_private = 1;
-
- @inargs = (
- { name => 'procedure_name', type => 'string', non_empty => 1,
- desc => "The name of the procedure to enable remote URIs for." }
- );
-
- %invoke = (
- code => <<'CODE'
-{
- GimpPlugIn *plug_in = gimp->plug_in_manager->current_plug_in;
-
- if (plug_in &&
- gimp_pdb_is_canonical_procedure (procedure_name, error))
- {
- success = gimp_plug_in_set_file_proc_handles_remote (plug_in,
- procedure_name,
- error);
- }
- else
- success = FALSE;
-}
-CODE
- );
-}
-
-sub register_file_handler_mime {
- $blurb = 'Associates MIME types with a file handler procedure.';
-
- $help = <<'HELP';
-Registers MIME types for a file handler procedure. This allows GIMP to
-determine the MIME type of the file opened or saved using this
-procedure. It is recommended that only one MIME type is registered per
-file procedure; when registering more than one MIME type, GIMP will
-associate the first one with files opened or saved with this procedure.
-HELP
-
- &neo_pdb_misc('2004', '2.2');
-
- $lib_private = 1;
-
- @inargs = (
- { name => 'procedure_name', type => 'string', non_empty => 1,
- desc => "The name of the procedure to associate a MIME type with." },
- { name => 'mime_types', type => 'string',
- desc => 'A comma-separated list of MIME types, such as "image/jpeg".' }
- );
-
- %invoke = (
- code => <<'CODE'
-{
- GimpPlugIn *plug_in = gimp->plug_in_manager->current_plug_in;
-
- if (plug_in &&
- gimp_pdb_is_canonical_procedure (procedure_name, error))
- {
- success = gimp_plug_in_set_file_proc_mime_types (plug_in,
- procedure_name,
- mime_types, error);
- }
- else
- success = FALSE;
-}
-CODE
- );
-}
-
-sub register_file_handler_raw {
- $blurb = 'Registers a file handler procedure as capable of handling raw camera files.';
-
- $help = <<'HELP';
-Registers a file handler procedure as capable of handling raw digital
-camera files. Use this procedure only to register raw load handlers,
-calling it on a save handler will generate an error.
-HELP
-
- &mitch_pdb_misc('2017', '2.10');
-
- $lib_private = 1;
-
- @inargs = (
- { name => 'procedure_name', type => 'string', non_empty => 1,
- desc => "The name of the procedure to enable raw handling for." }
- );
-
- %invoke = (
- code => <<'CODE'
-{
- GimpPlugIn *plug_in = gimp->plug_in_manager->current_plug_in;
-
- if (plug_in &&
- gimp_pdb_is_canonical_procedure (procedure_name, error))
- {
- success = gimp_plug_in_set_file_proc_handles_raw (plug_in,
- procedure_name,
- error);
- }
- else
- success = FALSE;
-}
-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
-
- &neo_pdb_misc('2004', '2.2');
-
- $lib_private = 1;
-
- @inargs = (
- { name => 'load_proc', type => 'string', non_empty => 1,
- desc => "The name of the procedure the thumbnail loader with." },
- { name => 'thumb_proc', type => 'string', non_empty => 1,
- desc => "The name of the thumbnail load procedure." }
- );
- %invoke = (
- code => <<'CODE'
-{
- GimpPlugIn *plug_in = gimp->plug_in_manager->current_plug_in;
-
- if (plug_in &&
- gimp_pdb_is_canonical_procedure (load_proc, error) &&
- gimp_pdb_is_canonical_procedure (thumb_proc, error))
- {
- success = gimp_plug_in_set_file_proc_thumb_loader (plug_in,
- load_proc, thumb_proc,
- error);
- }
- else
- success = FALSE;
-}
-CODE
- );
-}
-
-
-@headers = qw("libgimpbase/gimpbase.h"
- "libgimpconfig/gimpconfig.h"
- "core/gimp.h"
- "core/gimp-utils.h"
- "plug-in/gimpplugin-proc.h"
- "plug-in/gimppluginmanager.h"
+@headers = qw("core/gimp.h"
"plug-in/gimppluginmanager-file.h"
- "plug-in/gimppluginprocedure.h"
- "gimppdb-utils.h"
"file/file-open.h"
"file/file-save.h"
"file/file-utils.h");
@@ -742,16 +448,9 @@ CODE
file_load_layers
file_save
file_load_thumbnail
- file_save_thumbnail
- register_load_handler
- register_save_handler
- register_file_handler_priority
- register_file_handler_mime
- register_file_handler_remote
- register_file_handler_raw
- register_thumbnail_loader);
-
-%exports = (app => [@procs], lib => [@procs[0..3,5..12]]);
+ file_save_thumbnail);
+
+%exports = (app => [@procs], lib => [@procs[0..3,5]]);
$desc = 'File Operations';
$doc_title = 'gimpfileops';
diff --git a/pdb/groups/pdb.pdb b/pdb/groups/pdb.pdb
index 4a7b46d01c..c40db9ad97 100644
--- a/pdb/groups/pdb.pdb
+++ b/pdb/groups/pdb.pdb
@@ -838,6 +838,293 @@ CODE
);
}
+sub pdb_set_file_proc_load_handler {
+ $blurb = 'Registers a file load handler procedure.';
+
+ $help = <<'HELP';
+Registers a procedural database procedure to be called to load files of a
+particular file format using magic file information.
+HELP
+
+ &std_pdb_misc;
+
+ $lib_private = 1;
+
+ @inargs = (
+ { name => 'procedure_name', type => 'string', non_empty => 1,
+ desc => 'The name of the procedure to be used for loading' },
+ { name => 'extensions', type => 'string', no_validate => 1,
+ desc => 'comma separated list of extensions this handler
+ can load (i.e. "jpg,jpeg")' },
+ { name => 'prefixes', type => 'string', no_validate => 1,
+ desc => 'comma separated list of prefixes this handler
+ can load (i.e. "http:,ftp:")' },
+ { name => 'magics', type => 'string', no_validate => 1,
+ desc => 'comma separated list of magic file information
+ this handler can load (i.e. "0,string,GIF")' }
+ );
+
+ %invoke = (
+ code => <<'CODE'
+{
+ GimpPlugIn *plug_in = gimp->plug_in_manager->current_plug_in;
+
+ if (plug_in &&
+ gimp_pdb_is_canonical_procedure (procedure_name, error))
+ {
+ success = gimp_plug_in_set_file_proc_load_handler (plug_in,
+ procedure_name,
+ extensions, prefixes,
+ magics, error);
+ }
+ else
+ success = FALSE;
+}
+CODE
+ );
+}
+
+sub pdb_set_file_proc_save_handler {
+ $blurb = 'Registers a file save handler procedure.';
+
+ $help = <<'HELP';
+Registers a procedural database procedure to be called to save files in a
+particular file format.
+HELP
+
+ &std_pdb_misc;
+
+ $lib_private = 1;
+
+ @inargs = (
+ { name => 'procedure_name', type => 'string', non_empty => 1,
+ desc => 'The name of the procedure to be used for saving' },
+ { name => 'extensions', type => 'string', no_validate => 1,
+ desc => 'comma separated list of extensions this handler
+ can save (i.e. "jpg,jpeg")' },
+ { name => 'prefixes', type => 'string', no_validate => 1,
+ desc => 'comma separated list of prefixes this handler
+ can save (i.e. "http:,ftp:")' }
+ );
+
+ %invoke = (
+ code => <<'CODE'
+{
+ GimpPlugIn *plug_in = gimp->plug_in_manager->current_plug_in;
+
+ if (plug_in &&
+ gimp_pdb_is_canonical_procedure (procedure_name, error))
+ {
+ success = gimp_plug_in_set_file_proc_save_handler (plug_in,
+ procedure_name,
+ extensions, prefixes,
+ error);
+ }
+ else
+ success = FALSE;
+}
+CODE
+ );
+}
+
+sub pdb_set_file_proc_priority {
+ $blurb = 'Sets the priority of a file handler procedure.';
+
+ $help = <<'HELP';
+Sets the priority of a file handler procedure. When more than one
+procedure matches a given file, the procedure with the lowest priority
+is used; if more than one procedure has the lowest priority, it is
+unspecified which one of them is used. The default priority for file
+handler procedures is 0.
+HELP
+
+ &ell_pdb_misc('2018', '2.10.6');
+
+ $lib_private = 1;
+
+ @inargs = (
+ { name => 'procedure_name', type => 'string', non_empty => 1,
+ desc => "The name of the procedure to set the priority of." },
+ { name => 'priority', type => 'int32',
+ desc => "The procedure priority." }
+ );
+
+ %invoke = (
+ code => <<'CODE'
+{
+ GimpPlugIn *plug_in = gimp->plug_in_manager->current_plug_in;
+
+ if (plug_in &&
+ gimp_pdb_is_canonical_procedure (procedure_name, error))
+ {
+ success = gimp_plug_in_set_file_proc_priority (plug_in,
+ procedure_name,
+ priority, error);
+ }
+ else
+ success = FALSE;
+}
+CODE
+ );
+}
+
+sub pdb_set_file_proc_mime_types {
+ $blurb = 'Associates MIME types with a file handler procedure.';
+
+ $help = <<'HELP';
+Registers MIME types for a file handler procedure. This allows GIMP to
+determine the MIME type of the file opened or saved using this
+procedure. It is recommended that only one MIME type is registered per
+file procedure; when registering more than one MIME type, GIMP will
+associate the first one with files opened or saved with this procedure.
+HELP
+
+ &neo_pdb_misc('2004', '2.2');
+
+ $lib_private = 1;
+
+ @inargs = (
+ { name => 'procedure_name', type => 'string', non_empty => 1,
+ desc => "The name of the procedure to associate a MIME type with." },
+ { name => 'mime_types', type => 'string',
+ desc => 'A comma-separated list of MIME types, such as "image/jpeg".' }
+ );
+
+ %invoke = (
+ code => <<'CODE'
+{
+ GimpPlugIn *plug_in = gimp->plug_in_manager->current_plug_in;
+
+ if (plug_in &&
+ gimp_pdb_is_canonical_procedure (procedure_name, error))
+ {
+ success = gimp_plug_in_set_file_proc_mime_types (plug_in,
+ procedure_name,
+ mime_types, error);
+ }
+ else
+ success = FALSE;
+}
+CODE
+ );
+}
+
+sub pdb_set_file_proc_handles_remote {
+ $blurb = 'Registers a file handler procedure as capable of handling remote URIs.';
+
+ $help = <<'HELP';
+Registers a file handler procedure as capable of handling remote
+URIs. This allows GIMP to call the procedure directly for all kinds of
+URIs, not only on local file:// URIs.
+HELP
+
+ &mitch_pdb_misc('2012', '2.10');
+
+ $lib_private = 1;
+
+ @inargs = (
+ { name => 'procedure_name', type => 'string', non_empty => 1,
+ desc => "The name of the procedure to enable remote URIs for." }
+ );
+
+ %invoke = (
+ code => <<'CODE'
+{
+ GimpPlugIn *plug_in = gimp->plug_in_manager->current_plug_in;
+
+ if (plug_in &&
+ gimp_pdb_is_canonical_procedure (procedure_name, error))
+ {
+ success = gimp_plug_in_set_file_proc_handles_remote (plug_in,
+ procedure_name,
+ error);
+ }
+ else
+ success = FALSE;
+}
+CODE
+ );
+}
+
+sub pdb_set_file_proc_handles_raw {
+ $blurb = 'Registers a file handler procedure as capable of handling raw camera files.';
+
+ $help = <<'HELP';
+Registers a file handler procedure as capable of handling raw digital
+camera files. Use this procedure only to register raw load handlers,
+calling it on a save handler will generate an error.
+HELP
+
+ &mitch_pdb_misc('2017', '2.10');
+
+ $lib_private = 1;
+
+ @inargs = (
+ { name => 'procedure_name', type => 'string', non_empty => 1,
+ desc => "The name of the procedure to enable raw handling for." }
+ );
+
+ %invoke = (
+ code => <<'CODE'
+{
+ GimpPlugIn *plug_in = gimp->plug_in_manager->current_plug_in;
+
+ if (plug_in &&
+ gimp_pdb_is_canonical_procedure (procedure_name, error))
+ {
+ success = gimp_plug_in_set_file_proc_handles_raw (plug_in,
+ procedure_name,
+ error);
+ }
+ else
+ success = FALSE;
+}
+CODE
+ );
+}
+
+sub pdb_set_file_proc_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
+
+ &neo_pdb_misc('2004', '2.2');
+
+ $lib_private = 1;
+
+ @inargs = (
+ { name => 'load_proc', type => 'string', non_empty => 1,
+ desc => "The name of the procedure the thumbnail loader with." },
+ { name => 'thumb_proc', type => 'string', non_empty => 1,
+ desc => "The name of the thumbnail load procedure." }
+ );
+ %invoke = (
+ code => <<'CODE'
+{
+ GimpPlugIn *plug_in = gimp->plug_in_manager->current_plug_in;
+
+ if (plug_in &&
+ gimp_pdb_is_canonical_procedure (load_proc, error) &&
+ gimp_pdb_is_canonical_procedure (thumb_proc, error))
+ {
+ success = gimp_plug_in_set_file_proc_thumb_loader (plug_in,
+ load_proc, thumb_proc,
+ error);
+ }
+ else
+ success = FALSE;
+}
+CODE
+ );
+}
+
sub pdb_get_data {
$blurb = 'Returns data associated with the specified identifier.';
@@ -1018,9 +1305,16 @@ CODE
pdb_get_proc_documentation
pdb_set_proc_attribution
pdb_get_proc_attribution
- pdb_get_data
+ pdb_set_file_proc_load_handler
+ pdb_set_file_proc_save_handler
+ pdb_set_file_proc_priority
+ pdb_set_file_proc_mime_types
+ pdb_set_file_proc_handles_remote
+ pdb_set_file_proc_handles_raw
+ pdb_set_file_proc_thumbnail_loader
+ pdb_get_data
pdb_get_data_size
- pdb_set_data);
+ pdb_set_data);
%exports = (app => [@procs], lib => [@procs]);
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
