summaryrefslogtreecommitdiffstats
path: root/app/plug-in/gimppluginprocedure.c
diff options
context:
space:
mode:
Diffstat (limited to 'app/plug-in/gimppluginprocedure.c')
-rw-r--r--app/plug-in/gimppluginprocedure.c1293
1 files changed, 1293 insertions, 0 deletions
diff --git a/app/plug-in/gimppluginprocedure.c b/app/plug-in/gimppluginprocedure.c
new file mode 100644
index 0000000..db7d240
--- /dev/null
+++ b/app/plug-in/gimppluginprocedure.c
@@ -0,0 +1,1293 @@
+/* GIMP - The GNU Image Manipulation Program
+ * Copyright (C) 1995 Spencer Kimball and Peter Mattis
+ *
+ * gimppluginprocedure.c
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "config.h"
+
+#include <string.h>
+
+#include <gegl.h>
+#include <gdk-pixbuf/gdk-pixbuf.h>
+
+#include "libgimpbase/gimpbase.h"
+
+#include "plug-in-types.h"
+
+#include "gegl/gimp-babl-compat.h"
+
+#include "core/gimp.h"
+#include "core/gimp-memsize.h"
+#include "core/gimpdrawable.h"
+#include "core/gimpmarshal.h"
+#include "core/gimpparamspecs.h"
+
+#include "file/file-utils.h"
+
+#define __YES_I_NEED_GIMP_PLUG_IN_MANAGER_CALL__
+#include "gimppluginmanager-call.h"
+
+#include "gimppluginerror.h"
+#include "gimppluginprocedure.h"
+#include "plug-in-menu-path.h"
+
+#include "gimp-intl.h"
+
+
+enum
+{
+ MENU_PATH_ADDED,
+ LAST_SIGNAL
+};
+
+
+static void gimp_plug_in_procedure_finalize (GObject *object);
+
+static gint64 gimp_plug_in_procedure_get_memsize (GimpObject *object,
+ gint64 *gui_size);
+
+static gchar * gimp_plug_in_procedure_get_description (GimpViewable *viewable,
+ gchar **tooltip);
+
+static const gchar * gimp_plug_in_procedure_get_label (GimpProcedure *procedure);
+static const gchar * gimp_plug_in_procedure_get_menu_label
+ (GimpProcedure *procedure);
+static const gchar * gimp_plug_in_procedure_get_blurb (GimpProcedure *procedure);
+static const gchar * gimp_plug_in_procedure_get_help_id(GimpProcedure *procedure);
+static gboolean gimp_plug_in_procedure_get_sensitive (GimpProcedure *procedure,
+ GimpObject *object,
+ const gchar **tooltip);
+static GimpValueArray * gimp_plug_in_procedure_execute (GimpProcedure *procedure,
+ Gimp *gimp,
+ GimpContext *context,
+ GimpProgress *progress,
+ GimpValueArray *args,
+ GError **error);
+static void gimp_plug_in_procedure_execute_async (GimpProcedure *procedure,
+ Gimp *gimp,
+ GimpContext *context,
+ GimpProgress *progress,
+ GimpValueArray *args,
+ GimpObject *display);
+
+static GFile * gimp_plug_in_procedure_real_get_file (GimpPlugInProcedure *procedure);
+
+static gboolean gimp_plug_in_procedure_validate_args (GimpPlugInProcedure *proc,
+ Gimp *gimp,
+ GimpValueArray *args,
+ GError **error);
+
+
+G_DEFINE_TYPE (GimpPlugInProcedure, gimp_plug_in_procedure,
+ GIMP_TYPE_PROCEDURE)
+
+#define parent_class gimp_plug_in_procedure_parent_class
+
+static guint gimp_plug_in_procedure_signals[LAST_SIGNAL] = { 0 };
+
+
+static void
+gimp_plug_in_procedure_class_init (GimpPlugInProcedureClass *klass)
+{
+ GObjectClass *object_class = G_OBJECT_CLASS (klass);
+ GimpObjectClass *gimp_object_class = GIMP_OBJECT_CLASS (klass);
+ GimpViewableClass *viewable_class = GIMP_VIEWABLE_CLASS (klass);
+ GimpProcedureClass *proc_class = GIMP_PROCEDURE_CLASS (klass);
+
+ gimp_plug_in_procedure_signals[MENU_PATH_ADDED] =
+ g_signal_new ("menu-path-added",
+ G_TYPE_FROM_CLASS (klass),
+ G_SIGNAL_RUN_FIRST,
+ G_STRUCT_OFFSET (GimpPlugInProcedureClass, menu_path_added),
+ NULL, NULL,
+ gimp_marshal_VOID__STRING,
+ G_TYPE_NONE, 1,
+ G_TYPE_STRING);
+
+ object_class->finalize = gimp_plug_in_procedure_finalize;
+
+ gimp_object_class->get_memsize = gimp_plug_in_procedure_get_memsize;
+
+ viewable_class->default_icon_name = "system-run";
+ viewable_class->get_description = gimp_plug_in_procedure_get_description;
+
+ proc_class->get_label = gimp_plug_in_procedure_get_label;
+ proc_class->get_menu_label = gimp_plug_in_procedure_get_menu_label;
+ proc_class->get_blurb = gimp_plug_in_procedure_get_blurb;
+ proc_class->get_help_id = gimp_plug_in_procedure_get_help_id;
+ proc_class->get_sensitive = gimp_plug_in_procedure_get_sensitive;
+ proc_class->execute = gimp_plug_in_procedure_execute;
+ proc_class->execute_async = gimp_plug_in_procedure_execute_async;
+
+ klass->get_file = gimp_plug_in_procedure_real_get_file;
+ klass->menu_path_added = NULL;
+}
+
+static void
+gimp_plug_in_procedure_init (GimpPlugInProcedure *proc)
+{
+ GIMP_PROCEDURE (proc)->proc_type = GIMP_PLUGIN;
+
+ proc->icon_data_length = -1;
+}
+
+static void
+gimp_plug_in_procedure_finalize (GObject *object)
+{
+ GimpPlugInProcedure *proc = GIMP_PLUG_IN_PROCEDURE (object);
+
+ g_object_unref (proc->file);
+ g_free (proc->menu_label);
+
+ g_list_free_full (proc->menu_paths, (GDestroyNotify) g_free);
+
+ g_free (proc->label);
+ g_free (proc->help_id);
+
+ g_free (proc->icon_data);
+ g_free (proc->image_types);
+ g_free (proc->image_types_tooltip);
+
+ g_free (proc->extensions);
+ g_free (proc->prefixes);
+ g_free (proc->magics);
+ g_free (proc->mime_types);
+
+ g_slist_free_full (proc->extensions_list, (GDestroyNotify) g_free);
+ g_slist_free_full (proc->prefixes_list, (GDestroyNotify) g_free);
+ g_slist_free_full (proc->magics_list, (GDestroyNotify) g_free);
+ g_slist_free_full (proc->mime_types_list, (GDestroyNotify) g_free);
+
+ g_free (proc->thumb_loader);
+
+ G_OBJECT_CLASS (parent_class)->finalize (object);
+}
+
+static gint64
+gimp_plug_in_procedure_get_memsize (GimpObject *object,
+ gint64 *gui_size)
+{
+ GimpPlugInProcedure *proc = GIMP_PLUG_IN_PROCEDURE (object);
+ gint64 memsize = 0;
+ GList *list;
+ GSList *slist;
+
+ memsize += gimp_g_object_get_memsize (G_OBJECT (proc->file));
+ memsize += gimp_string_get_memsize (proc->menu_label);
+
+ for (list = proc->menu_paths; list; list = g_list_next (list))
+ memsize += sizeof (GList) + gimp_string_get_memsize (list->data);
+
+ switch (proc->icon_type)
+ {
+ case GIMP_ICON_TYPE_ICON_NAME:
+ case GIMP_ICON_TYPE_IMAGE_FILE:
+ memsize += gimp_string_get_memsize ((const gchar *) proc->icon_data);
+ break;
+
+ case GIMP_ICON_TYPE_INLINE_PIXBUF:
+ memsize += proc->icon_data_length;
+ break;
+ }
+
+ memsize += gimp_string_get_memsize (proc->extensions);
+ memsize += gimp_string_get_memsize (proc->prefixes);
+ memsize += gimp_string_get_memsize (proc->magics);
+ memsize += gimp_string_get_memsize (proc->mime_types);
+ memsize += gimp_string_get_memsize (proc->thumb_loader);
+
+ for (slist = proc->extensions_list; slist; slist = g_slist_next (slist))
+ memsize += sizeof (GSList) + gimp_string_get_memsize (slist->data);
+
+ for (slist = proc->prefixes_list; slist; slist = g_slist_next (slist))
+ memsize += sizeof (GSList) + gimp_string_get_memsize (slist->data);
+
+ for (slist = proc->magics_list; slist; slist = g_slist_next (slist))
+ memsize += sizeof (GSList) + gimp_string_get_memsize (slist->data);
+
+ for (slist = proc->mime_types_list; slist; slist = g_slist_next (slist))
+ memsize += sizeof (GSList) + gimp_string_get_memsize (slist->data);
+
+ return memsize + GIMP_OBJECT_CLASS (parent_class)->get_memsize (object,
+ gui_size);
+}
+
+static gchar *
+gimp_plug_in_procedure_get_description (GimpViewable *viewable,
+ gchar **tooltip)
+{
+ GimpProcedure *procedure = GIMP_PROCEDURE (viewable);
+
+ if (tooltip)
+ *tooltip = g_strdup (gimp_procedure_get_blurb (procedure));
+
+ return g_strdup (gimp_procedure_get_label (procedure));
+}
+
+static const gchar *
+gimp_plug_in_procedure_get_label (GimpProcedure *procedure)
+{
+ GimpPlugInProcedure *proc = GIMP_PLUG_IN_PROCEDURE (procedure);
+ const gchar *path;
+ gchar *stripped;
+ gchar *ellipsis;
+ gchar *label;
+
+ if (proc->label)
+ return proc->label;
+
+ if (proc->menu_label)
+ path = dgettext (gimp_plug_in_procedure_get_locale_domain (proc),
+ proc->menu_label);
+ else if (proc->menu_paths)
+ path = dgettext (gimp_plug_in_procedure_get_locale_domain (proc),
+ proc->menu_paths->data);
+ else
+ return NULL;
+
+ stripped = gimp_strip_uline (path);
+
+ if (proc->menu_label)
+ label = g_strdup (stripped);
+ else
+ label = g_path_get_basename (stripped);
+
+ g_free (stripped);
+
+ ellipsis = strstr (label, "...");
+
+ if (! ellipsis)
+ ellipsis = strstr (label, "\342\200\246" /* U+2026 HORIZONTAL ELLIPSIS */);
+
+ if (ellipsis && ellipsis == (label + strlen (label) - 3))
+ *ellipsis = '\0';
+
+ proc->label = label;
+
+ return proc->label;
+}
+
+static const gchar *
+gimp_plug_in_procedure_get_menu_label (GimpProcedure *procedure)
+{
+ GimpPlugInProcedure *proc = GIMP_PLUG_IN_PROCEDURE (procedure);
+
+ if (proc->menu_label)
+ {
+ return dgettext (gimp_plug_in_procedure_get_locale_domain (proc),
+ proc->menu_label);
+ }
+ else if (proc->menu_paths)
+ {
+ const gchar *translated;
+
+ translated = dgettext (gimp_plug_in_procedure_get_locale_domain (proc),
+ proc->menu_paths->data);
+
+ translated = strrchr (translated, '/');
+
+ if (translated)
+ return translated + 1;
+ }
+
+ return GIMP_PROCEDURE_CLASS (parent_class)->get_menu_label (procedure);
+}
+
+static const gchar *
+gimp_plug_in_procedure_get_blurb (GimpProcedure *procedure)
+{
+ GimpPlugInProcedure *proc = GIMP_PLUG_IN_PROCEDURE (procedure);
+
+ /* do not to pass the empty string to gettext() */
+ if (procedure->blurb && strlen (procedure->blurb))
+ return dgettext (gimp_plug_in_procedure_get_locale_domain (proc),
+ procedure->blurb);
+
+ return NULL;
+}
+
+static const gchar *
+gimp_plug_in_procedure_get_help_id (GimpProcedure *procedure)
+{
+ GimpPlugInProcedure *proc = GIMP_PLUG_IN_PROCEDURE (procedure);
+ const gchar *domain;
+
+ if (proc->help_id)
+ return proc->help_id;
+
+ domain = gimp_plug_in_procedure_get_help_domain (proc);
+
+ if (domain)
+ proc->help_id = g_strconcat (domain, "?", gimp_object_get_name (proc), NULL);
+ else
+ proc->help_id = g_strdup (gimp_object_get_name (proc));
+
+ return proc->help_id;
+}
+
+static gboolean
+gimp_plug_in_procedure_get_sensitive (GimpProcedure *procedure,
+ GimpObject *object,
+ const gchar **tooltip)
+{
+ GimpPlugInProcedure *proc = GIMP_PLUG_IN_PROCEDURE (procedure);
+ GimpDrawable *drawable;
+ GimpImageType image_type = -1;
+ gboolean sensitive = FALSE;
+
+ g_return_val_if_fail (object == NULL || GIMP_IS_DRAWABLE (object), FALSE);
+
+ drawable = GIMP_DRAWABLE (object);
+
+ if (drawable)
+ {
+ const Babl *format = gimp_drawable_get_format (drawable);
+
+ image_type = gimp_babl_format_get_image_type (format);
+ }
+
+ switch (image_type)
+ {
+ case GIMP_RGB_IMAGE:
+ sensitive = proc->image_types_val & GIMP_PLUG_IN_RGB_IMAGE;
+ break;
+ case GIMP_RGBA_IMAGE:
+ sensitive = proc->image_types_val & GIMP_PLUG_IN_RGBA_IMAGE;
+ break;
+ case GIMP_GRAY_IMAGE:
+ sensitive = proc->image_types_val & GIMP_PLUG_IN_GRAY_IMAGE;
+ break;
+ case GIMP_GRAYA_IMAGE:
+ sensitive = proc->image_types_val & GIMP_PLUG_IN_GRAYA_IMAGE;
+ break;
+ case GIMP_INDEXED_IMAGE:
+ sensitive = proc->image_types_val & GIMP_PLUG_IN_INDEXED_IMAGE;
+ break;
+ case GIMP_INDEXEDA_IMAGE:
+ sensitive = proc->image_types_val & GIMP_PLUG_IN_INDEXEDA_IMAGE;
+ break;
+ default:
+ break;
+ }
+
+ if (! sensitive)
+ *tooltip = proc->image_types_tooltip;
+
+ return sensitive ? TRUE : FALSE;
+}
+
+static GimpValueArray *
+gimp_plug_in_procedure_execute (GimpProcedure *procedure,
+ Gimp *gimp,
+ GimpContext *context,
+ GimpProgress *progress,
+ GimpValueArray *args,
+ GError **error)
+{
+ GimpPlugInProcedure *plug_in_procedure = GIMP_PLUG_IN_PROCEDURE (procedure);
+ GError *pdb_error = NULL;
+
+ if (! gimp_plug_in_procedure_validate_args (plug_in_procedure, gimp,
+ args, &pdb_error))
+ {
+ GimpValueArray *return_vals;
+
+ return_vals = gimp_procedure_get_return_values (procedure, FALSE,
+ pdb_error);
+ g_propagate_error (error, pdb_error);
+
+ return return_vals;
+ }
+
+ if (procedure->proc_type == GIMP_INTERNAL)
+ return GIMP_PROCEDURE_CLASS (parent_class)->execute (procedure, gimp,
+ context, progress,
+ args, error);
+
+ return gimp_plug_in_manager_call_run (gimp->plug_in_manager,
+ context, progress,
+ GIMP_PLUG_IN_PROCEDURE (procedure),
+ args, TRUE, NULL);
+}
+
+static void
+gimp_plug_in_procedure_execute_async (GimpProcedure *procedure,
+ Gimp *gimp,
+ GimpContext *context,
+ GimpProgress *progress,
+ GimpValueArray *args,
+ GimpObject *display)
+{
+ GimpPlugInProcedure *plug_in_procedure = GIMP_PLUG_IN_PROCEDURE (procedure);
+ GError *error = NULL;
+
+ if (gimp_plug_in_procedure_validate_args (plug_in_procedure, gimp,
+ args, &error))
+ {
+ GimpValueArray *return_vals;
+
+ return_vals = gimp_plug_in_manager_call_run (gimp->plug_in_manager,
+ context, progress,
+ plug_in_procedure,
+ args, FALSE, display);
+
+ if (return_vals)
+ {
+ gimp_plug_in_procedure_handle_return_values (plug_in_procedure,
+ gimp, progress,
+ return_vals);
+ gimp_value_array_unref (return_vals);
+ }
+ }
+ else
+ {
+ gimp_message_literal (gimp, G_OBJECT (progress), GIMP_MESSAGE_ERROR,
+ error->message);
+ g_error_free (error);
+ }
+}
+
+static GFile *
+gimp_plug_in_procedure_real_get_file (GimpPlugInProcedure *procedure)
+{
+ return procedure->file;
+}
+
+static gboolean
+gimp_plug_in_procedure_validate_args (GimpPlugInProcedure *proc,
+ Gimp *gimp,
+ GimpValueArray *args,
+ GError **error)
+{
+ if (proc->file_proc && proc->handles_uri)
+ {
+ /* for file procedures that handle URIs, make sure that the
+ * passed string actually is an URI, not just a file path
+ * (bug 758685)
+ */
+ GimpProcedure *procedure = GIMP_PROCEDURE (proc);
+ GValue *uri_value = NULL;
+
+ if ((procedure->num_args >= 3) &&
+ (procedure->num_values >= 1) &&
+ GIMP_IS_PARAM_SPEC_INT32 (procedure->args[0]) &&
+ G_IS_PARAM_SPEC_STRING (procedure->args[1]) &&
+ G_IS_PARAM_SPEC_STRING (procedure->args[2]) &&
+ GIMP_IS_PARAM_SPEC_IMAGE_ID (procedure->values[0]))
+ {
+ uri_value = gimp_value_array_index (args, 1);
+ }
+ else if ((procedure->num_args >= 5) &&
+ GIMP_IS_PARAM_SPEC_INT32 (procedure->args[0]) &&
+ GIMP_IS_PARAM_SPEC_IMAGE_ID (procedure->args[1]) &&
+ GIMP_IS_PARAM_SPEC_DRAWABLE_ID (procedure->args[2]) &&
+ G_IS_PARAM_SPEC_STRING (procedure->args[3]) &&
+ G_IS_PARAM_SPEC_STRING (procedure->args[4]))
+ {
+ uri_value = gimp_value_array_index (args, 3);
+ }
+
+ if (uri_value)
+ {
+ GFile *file;
+
+ file = file_utils_filename_to_file (gimp,
+ g_value_get_string (uri_value),
+ error);
+
+ if (! file)
+ return FALSE;
+
+ g_value_take_string (uri_value, g_file_get_uri (file));
+ g_object_unref (file);
+ }
+ }
+
+ return TRUE;
+}
+
+
+/* public functions */
+
+GimpProcedure *
+gimp_plug_in_procedure_new (GimpPDBProcType proc_type,
+ GFile *file)
+{
+ GimpPlugInProcedure *proc;
+
+ g_return_val_if_fail (proc_type == GIMP_PLUGIN ||
+ proc_type == GIMP_EXTENSION, NULL);
+ g_return_val_if_fail (G_IS_FILE (file), NULL);
+
+ proc = g_object_new (GIMP_TYPE_PLUG_IN_PROCEDURE, NULL);
+
+ proc->file = g_object_ref (file);
+
+ GIMP_PROCEDURE (proc)->proc_type = proc_type;
+
+ return GIMP_PROCEDURE (proc);
+}
+
+GimpPlugInProcedure *
+gimp_plug_in_procedure_find (GSList *list,
+ const gchar *proc_name)
+{
+ GSList *l;
+
+ for (l = list; l; l = g_slist_next (l))
+ {
+ GimpObject *object = l->data;
+
+ if (! strcmp (proc_name, gimp_object_get_name (object)))
+ return GIMP_PLUG_IN_PROCEDURE (object);
+ }
+
+ return NULL;
+}
+
+GFile *
+gimp_plug_in_procedure_get_file (GimpPlugInProcedure *proc)
+{
+ g_return_val_if_fail (GIMP_IS_PLUG_IN_PROCEDURE (proc), NULL);
+
+ return GIMP_PLUG_IN_PROCEDURE_GET_CLASS (proc)->get_file (proc);
+}
+
+void
+gimp_plug_in_procedure_set_locale_domain (GimpPlugInProcedure *proc,
+ const gchar *locale_domain)
+{
+ g_return_if_fail (GIMP_IS_PLUG_IN_PROCEDURE (proc));
+
+ proc->locale_domain = locale_domain ? g_quark_from_string (locale_domain) : 0;
+}
+
+const gchar *
+gimp_plug_in_procedure_get_locale_domain (GimpPlugInProcedure *proc)
+{
+ g_return_val_if_fail (GIMP_IS_PLUG_IN_PROCEDURE (proc), NULL);
+
+ return g_quark_to_string (proc->locale_domain);
+}
+
+void
+gimp_plug_in_procedure_set_help_domain (GimpPlugInProcedure *proc,
+ const gchar *help_domain)
+{
+ g_return_if_fail (GIMP_IS_PLUG_IN_PROCEDURE (proc));
+
+ proc->help_domain = help_domain ? g_quark_from_string (help_domain) : 0;
+}
+
+const gchar *
+gimp_plug_in_procedure_get_help_domain (GimpPlugInProcedure *proc)
+{
+ g_return_val_if_fail (GIMP_IS_PLUG_IN_PROCEDURE (proc), NULL);
+
+ return g_quark_to_string (proc->help_domain);
+}
+
+gboolean
+gimp_plug_in_procedure_add_menu_path (GimpPlugInProcedure *proc,
+ const gchar *menu_path,
+ GError **error)
+{
+ GimpProcedure *procedure;
+ gchar *basename = NULL;
+ const gchar *required = NULL;
+ gchar *p;
+ gchar *mapped_path;
+
+ g_return_val_if_fail (GIMP_IS_PLUG_IN_PROCEDURE (proc), FALSE);
+ g_return_val_if_fail (menu_path != NULL, FALSE);
+ g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
+
+ procedure = GIMP_PROCEDURE (proc);
+
+ p = strchr (menu_path, '>');
+ if (p == NULL || (*(++p) && *p != '/'))
+ {
+ basename = g_path_get_basename (gimp_file_get_utf8_name (proc->file));
+
+ g_set_error (error, GIMP_PLUG_IN_ERROR, GIMP_PLUG_IN_FAILED,
+ "Plug-in \"%s\"\n(%s)\n"
+ "attempted to install procedure \"%s\"\n"
+ "in the invalid menu location \"%s\".\n"
+ "The menu path must look like either \"<Prefix>\" "
+ "or \"<Prefix>/path/to/item\".",
+ basename, gimp_file_get_utf8_name (proc->file),
+ gimp_object_get_name (proc),
+ menu_path);
+ goto failure;
+ }
+
+ if (g_str_has_prefix (menu_path, "<Toolbox>") ||
+ g_str_has_prefix (menu_path, "<Image>"))
+ {
+ if ((procedure->num_args < 1) ||
+ ! GIMP_IS_PARAM_SPEC_INT32 (procedure->args[0]))
+ {
+ required = "INT32";
+ goto failure;
+ }
+ }
+ else if (g_str_has_prefix (menu_path, "<Layers>"))
+ {
+ if ((procedure->num_args < 3) ||
+ ! GIMP_IS_PARAM_SPEC_INT32 (procedure->args[0]) ||
+ ! GIMP_IS_PARAM_SPEC_IMAGE_ID (procedure->args[1]) ||
+ ! (G_TYPE_FROM_INSTANCE (procedure->args[2])
+ == GIMP_TYPE_PARAM_LAYER_ID ||
+ G_TYPE_FROM_INSTANCE (procedure->args[2])
+ == GIMP_TYPE_PARAM_DRAWABLE_ID))
+ {
+ required = "INT32, IMAGE, (LAYER | DRAWABLE)";
+ goto failure;
+ }
+ }
+ else if (g_str_has_prefix (menu_path, "<Channels>"))
+ {
+ if ((procedure->num_args < 3) ||
+ ! GIMP_IS_PARAM_SPEC_INT32 (procedure->args[0]) ||
+ ! GIMP_IS_PARAM_SPEC_IMAGE_ID (procedure->args[1]) ||
+ ! (G_TYPE_FROM_INSTANCE (procedure->args[2])
+ == GIMP_TYPE_PARAM_CHANNEL_ID ||
+ G_TYPE_FROM_INSTANCE (procedure->args[2])
+ == GIMP_TYPE_PARAM_DRAWABLE_ID))
+ {
+ required = "INT32, IMAGE, (CHANNEL | DRAWABLE)";
+ goto failure;
+ }
+ }
+ else if (g_str_has_prefix (menu_path, "<Vectors>"))
+ {
+ if ((procedure->num_args < 3) ||
+ ! GIMP_IS_PARAM_SPEC_INT32 (procedure->args[0]) ||
+ ! GIMP_IS_PARAM_SPEC_IMAGE_ID (procedure->args[1]) ||
+ ! GIMP_IS_PARAM_SPEC_VECTORS_ID (procedure->args[2]))
+ {
+ required = "INT32, IMAGE, VECTORS";
+ goto failure;
+ }
+ }
+ else if (g_str_has_prefix (menu_path, "<Colormap>"))
+ {
+ if ((procedure->num_args < 2) ||
+ ! GIMP_IS_PARAM_SPEC_INT32 (procedure->args[0]) ||
+ ! GIMP_IS_PARAM_SPEC_IMAGE_ID (procedure->args[1]))
+ {
+ required = "INT32, IMAGE";
+ goto failure;
+ }
+ }
+ else if (g_str_has_prefix (menu_path, "<Load>"))
+ {
+ if ((procedure->num_args < 3) ||
+ ! GIMP_IS_PARAM_SPEC_INT32 (procedure->args[0]) ||
+ ! G_IS_PARAM_SPEC_STRING (procedure->args[1]) ||
+ ! G_IS_PARAM_SPEC_STRING (procedure->args[2]))
+ {
+ required = "INT32, STRING, STRING";
+ goto failure;
+ }
+
+ if ((procedure->num_values < 1) ||
+ ! GIMP_IS_PARAM_SPEC_IMAGE_ID (procedure->values[0]))
+ {
+ required = "IMAGE";
+ goto failure;
+ }
+ }
+ else if (g_str_has_prefix (menu_path, "<Save>"))
+ {
+ if ((procedure->num_args < 5) ||
+ ! GIMP_IS_PARAM_SPEC_INT32 (procedure->args[0]) ||
+ ! GIMP_IS_PARAM_SPEC_IMAGE_ID (procedure->args[1]) ||
+ ! GIMP_IS_PARAM_SPEC_DRAWABLE_ID (procedure->args[2]) ||
+ ! G_IS_PARAM_SPEC_STRING (procedure->args[3]) ||
+ ! G_IS_PARAM_SPEC_STRING (procedure->args[4]))
+ {
+ required = "INT32, IMAGE, DRAWABLE, STRING, STRING";
+ goto failure;
+ }
+ }
+ else if (g_str_has_prefix (menu_path, "<Brushes>") ||
+ g_str_has_prefix (menu_path, "<Dynamics>") ||
+ g_str_has_prefix (menu_path, "<MyPaintBrushes>") ||
+ g_str_has_prefix (menu_path, "<Gradients>") ||
+ g_str_has_prefix (menu_path, "<Palettes>") ||
+ g_str_has_prefix (menu_path, "<Patterns>") ||
+ g_str_has_prefix (menu_path, "<ToolPresets>") ||
+ g_str_has_prefix (menu_path, "<Fonts>") ||
+ g_str_has_prefix (menu_path, "<Buffers>"))
+ {
+ if ((procedure->num_args < 1) ||
+ ! GIMP_IS_PARAM_SPEC_INT32 (procedure->args[0]))
+ {
+ required = "INT32";
+ goto failure;
+ }
+ }
+ else
+ {
+ basename = g_path_get_basename (gimp_file_get_utf8_name (proc->file));
+
+ g_set_error (error, GIMP_PLUG_IN_ERROR, GIMP_PLUG_IN_FAILED,
+ "Plug-in \"%s\"\n(%s)\n"
+ "attempted to install procedure \"%s\" "
+ "in the invalid menu location \"%s\".\n"
+ "Use either \"<Image>\", "
+ "\"<Layers>\", \"<Channels>\", \"<Vectors>\", "
+ "\"<Colormap>\", \"<Brushes>\", \"<Dynamics>\", "
+ "\"<MyPaintBrushes>\", \"<Gradients>\", \"<Palettes>\", "
+ "\"<Patterns>\", \"<ToolPresets>\", \"<Fonts>\" "
+ "or \"<Buffers>\".",
+ basename, gimp_file_get_utf8_name (proc->file),
+ gimp_object_get_name (proc),
+ menu_path);
+ goto failure;
+ }
+
+ g_free (basename);
+
+ mapped_path = plug_in_menu_path_map (menu_path, NULL);
+
+ proc->menu_paths = g_list_append (proc->menu_paths, mapped_path);
+
+ g_signal_emit (proc, gimp_plug_in_procedure_signals[MENU_PATH_ADDED], 0,
+ mapped_path);
+
+ return TRUE;
+
+ failure:
+ if (required)
+ {
+ gchar *prefix = g_strdup (menu_path);
+
+ p = strchr (prefix, '>') + 1;
+ *p = '\0';
+
+ basename = g_path_get_basename (gimp_file_get_utf8_name (proc->file));
+
+ g_set_error (error, GIMP_PLUG_IN_ERROR, GIMP_PLUG_IN_FAILED,
+ "Plug-in \"%s\"\n(%s)\n\n"
+ "attempted to install %s procedure \"%s\" "
+ "which does not take the standard %s plug-in's "
+ "arguments: (%s).",
+ basename, gimp_file_get_utf8_name (proc->file),
+ prefix, gimp_object_get_name (proc), prefix,
+ required);
+
+ g_free (prefix);
+ }
+
+ g_free (basename);
+
+ return FALSE;
+}
+
+void
+gimp_plug_in_procedure_set_icon (GimpPlugInProcedure *proc,
+ GimpIconType icon_type,
+ const guint8 *icon_data,
+ gint icon_data_length)
+{
+ guint8 *data_copy = NULL;
+
+ g_return_if_fail (GIMP_IS_PLUG_IN_PROCEDURE (proc));
+
+ switch (icon_type)
+ {
+ case GIMP_ICON_TYPE_ICON_NAME:
+ data_copy = (guint8 *) g_strdup ((gchar *) icon_data);
+ break;
+
+ case GIMP_ICON_TYPE_INLINE_PIXBUF:
+ data_copy = g_memdup (icon_data, icon_data_length);
+ break;
+
+ case GIMP_ICON_TYPE_IMAGE_FILE:
+ data_copy = (guint8 *) g_strdup ((gchar *) icon_data);
+ break;
+
+ default:
+ g_return_if_reached ();
+ }
+
+ gimp_plug_in_procedure_take_icon (proc, icon_type,
+ data_copy, icon_data_length);
+}
+
+void
+gimp_plug_in_procedure_take_icon (GimpPlugInProcedure *proc,
+ GimpIconType icon_type,
+ guint8 *icon_data,
+ gint icon_data_length)
+{
+ const gchar *icon_name = NULL;
+ GdkPixbuf *icon_pixbuf = NULL;
+ GError *error = NULL;
+
+ g_return_if_fail (GIMP_IS_PLUG_IN_PROCEDURE (proc));
+
+ if (proc->icon_data)
+ {
+ g_free (proc->icon_data);
+ proc->icon_data_length = -1;
+ proc->icon_data = NULL;
+ }
+
+ proc->icon_type = icon_type;
+
+ switch (proc->icon_type)
+ {
+ case GIMP_ICON_TYPE_ICON_NAME:
+ proc->icon_data_length = -1;
+ proc->icon_data = icon_data;
+
+ icon_name = (const gchar *) proc->icon_data;
+ break;
+
+ case GIMP_ICON_TYPE_INLINE_PIXBUF:
+ proc->icon_data_length = icon_data_length;
+ proc->icon_data = icon_data;
+
+ icon_pixbuf = gdk_pixbuf_new_from_inline (proc->icon_data_length,
+ proc->icon_data, TRUE, &error);
+ break;
+
+ case GIMP_ICON_TYPE_IMAGE_FILE:
+ proc->icon_data_length = -1;
+ proc->icon_data = icon_data;
+
+ icon_pixbuf = gdk_pixbuf_new_from_file ((gchar *) proc->icon_data,
+ &error);
+ break;
+ }
+
+ if (! icon_pixbuf && error)
+ {
+ g_printerr ("gimp_plug_in_procedure_take_icon: %s\n", error->message);
+ g_clear_error (&error);
+ }
+
+ gimp_viewable_set_icon_name (GIMP_VIEWABLE (proc), icon_name);
+ g_object_set (proc, "icon-pixbuf", icon_pixbuf, NULL);
+
+ if (icon_pixbuf)
+ g_object_unref (icon_pixbuf);
+}
+
+static GimpPlugInImageType
+image_types_parse (const gchar *name,
+ const gchar *image_types)
+{
+ const gchar *type_spec = image_types;
+ GimpPlugInImageType types = 0;
+
+ /* If the plug_in registers with image_type == NULL or "", return 0
+ * By doing so it won't be touched by plug_in_set_menu_sensitivity()
+ */
+ if (! image_types)
+ return types;
+
+ while (*image_types)
+ {
+ while (*image_types &&
+ ((*image_types == ' ') ||
+ (*image_types == '\t') ||
+ (*image_types == ',')))
+ image_types++;
+
+ if (*image_types)
+ {
+ if (g_str_has_prefix (image_types, "RGBA"))
+ {
+ types |= GIMP_PLUG_IN_RGBA_IMAGE;
+ image_types += strlen ("RGBA");
+ }
+ else if (g_str_has_prefix (image_types, "RGB*"))
+ {
+ types |= GIMP_PLUG_IN_RGB_IMAGE | GIMP_PLUG_IN_RGBA_IMAGE;
+ image_types += strlen ("RGB*");
+ }
+ else if (g_str_has_prefix (image_types, "RGB"))
+ {
+ types |= GIMP_PLUG_IN_RGB_IMAGE;
+ image_types += strlen ("RGB");
+ }
+ else if (g_str_has_prefix (image_types, "GRAYA"))
+ {
+ types |= GIMP_PLUG_IN_GRAYA_IMAGE;
+ image_types += strlen ("GRAYA");
+ }
+ else if (g_str_has_prefix (image_types, "GRAY*"))
+ {
+ types |= GIMP_PLUG_IN_GRAY_IMAGE | GIMP_PLUG_IN_GRAYA_IMAGE;
+ image_types += strlen ("GRAY*");
+ }
+ else if (g_str_has_prefix (image_types, "GRAY"))
+ {
+ types |= GIMP_PLUG_IN_GRAY_IMAGE;
+ image_types += strlen ("GRAY");
+ }
+ else if (g_str_has_prefix (image_types, "INDEXEDA"))
+ {
+ types |= GIMP_PLUG_IN_INDEXEDA_IMAGE;
+ image_types += strlen ("INDEXEDA");
+ }
+ else if (g_str_has_prefix (image_types, "INDEXED*"))
+ {
+ types |= GIMP_PLUG_IN_INDEXED_IMAGE | GIMP_PLUG_IN_INDEXEDA_IMAGE;
+ image_types += strlen ("INDEXED*");
+ }
+ else if (g_str_has_prefix (image_types, "INDEXED"))
+ {
+ types |= GIMP_PLUG_IN_INDEXED_IMAGE;
+ image_types += strlen ("INDEXED");
+ }
+ else if (g_str_has_prefix (image_types, "*"))
+ {
+ types |= (GIMP_PLUG_IN_RGB_IMAGE | GIMP_PLUG_IN_RGBA_IMAGE |
+ GIMP_PLUG_IN_GRAY_IMAGE | GIMP_PLUG_IN_GRAYA_IMAGE |
+ GIMP_PLUG_IN_INDEXED_IMAGE | GIMP_PLUG_IN_INDEXEDA_IMAGE);
+ image_types += strlen ("*");
+ }
+ else
+ {
+ g_printerr ("%s: image-type contains unrecognizable parts:"
+ "'%s'\n", name, type_spec);
+
+ /* skip to next token */
+ while (*image_types &&
+ *image_types != ' ' &&
+ *image_types != '\t' &&
+ *image_types != ',')
+ {
+ image_types++;
+ }
+ }
+ }
+ }
+
+ return types;
+}
+
+void
+gimp_plug_in_procedure_set_image_types (GimpPlugInProcedure *proc,
+ const gchar *image_types)
+{
+ GList *types = NULL;
+
+ g_return_if_fail (GIMP_IS_PLUG_IN_PROCEDURE (proc));
+
+ if (proc->image_types)
+ g_free (proc->image_types);
+
+ proc->image_types = g_strdup (image_types);
+ proc->image_types_val = image_types_parse (gimp_object_get_name (proc),
+ proc->image_types);
+
+ g_clear_pointer (&proc->image_types_tooltip, g_free);
+
+ if (proc->image_types_val &
+ (GIMP_PLUG_IN_RGB_IMAGE | GIMP_PLUG_IN_RGBA_IMAGE))
+ {
+ if ((proc->image_types_val & GIMP_PLUG_IN_RGB_IMAGE) &&
+ (proc->image_types_val & GIMP_PLUG_IN_RGBA_IMAGE))
+ {
+ types = g_list_prepend (types, _("RGB"));
+ }
+ else if (proc->image_types_val & GIMP_PLUG_IN_RGB_IMAGE)
+ {
+ types = g_list_prepend (types, _("RGB without alpha"));
+ }
+ else
+ {
+ types = g_list_prepend (types, _("RGB with alpha"));
+ }
+ }
+
+ if (proc->image_types_val &
+ (GIMP_PLUG_IN_GRAY_IMAGE | GIMP_PLUG_IN_GRAYA_IMAGE))
+ {
+ if ((proc->image_types_val & GIMP_PLUG_IN_GRAY_IMAGE) &&
+ (proc->image_types_val & GIMP_PLUG_IN_GRAYA_IMAGE))
+ {
+ types = g_list_prepend (types, _("Grayscale"));
+ }
+ else if (proc->image_types_val & GIMP_PLUG_IN_GRAY_IMAGE)
+ {
+ types = g_list_prepend (types, _("Grayscale without alpha"));
+ }
+ else
+ {
+ types = g_list_prepend (types, _("Grayscale with alpha"));
+ }
+ }
+
+ if (proc->image_types_val &
+ (GIMP_PLUG_IN_INDEXED_IMAGE | GIMP_PLUG_IN_INDEXEDA_IMAGE))
+ {
+ if ((proc->image_types_val & GIMP_PLUG_IN_INDEXED_IMAGE) &&
+ (proc->image_types_val & GIMP_PLUG_IN_INDEXEDA_IMAGE))
+ {
+ types = g_list_prepend (types, _("Indexed"));
+ }
+ else if (proc->image_types_val & GIMP_PLUG_IN_INDEXED_IMAGE)
+ {
+ types = g_list_prepend (types, _("Indexed without alpha"));
+ }
+ else
+ {
+ types = g_list_prepend (types, _("Indexed with alpha"));
+ }
+ }
+
+ if (types)
+ {
+ GString *string;
+ GList *list;
+
+ types = g_list_reverse (types);
+
+ string = g_string_new (gimp_procedure_get_blurb (GIMP_PROCEDURE (proc)));
+
+ g_string_append (string, "\n\n");
+ g_string_append (string, _("This plug-in only works on the "
+ "following layer types:"));
+ g_string_append (string, "\n");
+
+ for (list = types; list; list = g_list_next (list))
+ {
+ g_string_append (string, list->data);
+
+ if (list->next)
+ g_string_append (string, ", ");
+ else
+ g_string_append (string, ".");
+ }
+
+ g_list_free (types);
+
+ proc->image_types_tooltip = g_string_free (string, FALSE);
+ }
+}
+
+static GSList *
+extensions_parse (gchar *extensions)
+{
+ GSList *list = NULL;
+
+ /* extensions can be NULL. Avoid calling strtok if it is. */
+ if (extensions)
+ {
+ gchar *extension;
+ gchar *next_token;
+
+ /* work on a copy */
+ extensions = g_strdup (extensions);
+
+ next_token = extensions;
+ extension = strtok (next_token, " \t,");
+
+ while (extension)
+ {
+ list = g_slist_prepend (list, g_strdup (extension));
+ extension = strtok (NULL, " \t,");
+ }
+
+ g_free (extensions);
+ }
+
+ return g_slist_reverse (list);
+}
+
+void
+gimp_plug_in_procedure_set_file_proc (GimpPlugInProcedure *proc,
+ const gchar *extensions,
+ const gchar *prefixes,
+ const gchar *magics)
+{
+ GSList *list;
+
+ g_return_if_fail (GIMP_IS_PLUG_IN_PROCEDURE (proc));
+
+ proc->file_proc = TRUE;
+
+ /* extensions */
+
+ if (proc->extensions != extensions)
+ {
+ if (proc->extensions)
+ g_free (proc->extensions);
+
+ proc->extensions = g_strdup (extensions);
+ }
+
+ if (proc->extensions_list)
+ g_slist_free_full (proc->extensions_list, (GDestroyNotify) g_free);
+
+ proc->extensions_list = extensions_parse (proc->extensions);
+
+ /* prefixes */
+
+ if (proc->prefixes != prefixes)
+ {
+ if (proc->prefixes)
+ g_free (proc->prefixes);
+
+ proc->prefixes = g_strdup (prefixes);
+ }
+
+ if (proc->prefixes_list)
+ g_slist_free_full (proc->prefixes_list, (GDestroyNotify) g_free);
+
+ proc->prefixes_list = extensions_parse (proc->prefixes);
+
+ /* don't allow "file:" to be registered as prefix */
+ for (list = proc->prefixes_list; list; list = g_slist_next (list))
+ {
+ const gchar *prefix = list->data;
+
+ if (prefix && strcmp (prefix, "file:") == 0)
+ {
+ g_free (list->data);
+ proc->prefixes_list = g_slist_delete_link (proc->prefixes_list, list);
+ break;
+ }
+ }
+
+ /* magics */
+
+ if (proc->magics != magics)
+ {
+ if (proc->magics)
+ g_free (proc->magics);
+
+ proc->magics = g_strdup (magics);
+ }
+
+ if (proc->magics_list)
+ g_slist_free_full (proc->magics_list, (GDestroyNotify) g_free);
+
+ proc->magics_list = extensions_parse (proc->magics);
+}
+
+void
+gimp_plug_in_procedure_set_priority (GimpPlugInProcedure *proc,
+ gint priority)
+{
+ g_return_if_fail (GIMP_IS_PLUG_IN_PROCEDURE (proc));
+
+ proc->priority = priority;
+}
+
+void
+gimp_plug_in_procedure_set_mime_types (GimpPlugInProcedure *proc,
+ const gchar *mime_types)
+{
+ g_return_if_fail (GIMP_IS_PLUG_IN_PROCEDURE (proc));
+
+ if (proc->mime_types != mime_types)
+ {
+ if (proc->mime_types)
+ g_free (proc->mime_types);
+
+ proc->mime_types = g_strdup (mime_types);
+ }
+
+ if (proc->mime_types_list)
+ g_slist_free_full (proc->mime_types_list, (GDestroyNotify) g_free);
+
+ proc->mime_types_list = extensions_parse (proc->mime_types);
+}
+
+void
+gimp_plug_in_procedure_set_handles_uri (GimpPlugInProcedure *proc)
+{
+ g_return_if_fail (GIMP_IS_PLUG_IN_PROCEDURE (proc));
+
+ proc->handles_uri = TRUE;
+}
+
+void
+gimp_plug_in_procedure_set_handles_raw (GimpPlugInProcedure *proc)
+{
+ g_return_if_fail (GIMP_IS_PLUG_IN_PROCEDURE (proc));
+
+ proc->handles_raw = TRUE;
+}
+
+void
+gimp_plug_in_procedure_set_thumb_loader (GimpPlugInProcedure *proc,
+ const gchar *thumb_loader)
+{
+ g_return_if_fail (GIMP_IS_PLUG_IN_PROCEDURE (proc));
+
+ if (proc->thumb_loader)
+ g_free (proc->thumb_loader);
+
+ proc->thumb_loader = g_strdup (thumb_loader);
+}
+
+void
+gimp_plug_in_procedure_handle_return_values (GimpPlugInProcedure *proc,
+ Gimp *gimp,
+ GimpProgress *progress,
+ GimpValueArray *return_vals)
+{
+ g_return_if_fail (GIMP_IS_PLUG_IN_PROCEDURE (proc));
+ g_return_if_fail (return_vals != NULL);
+
+ if (gimp_value_array_length (return_vals) == 0 ||
+ G_VALUE_TYPE (gimp_value_array_index (return_vals, 0)) !=
+ GIMP_TYPE_PDB_STATUS_TYPE)
+ {
+ return;
+ }
+
+ switch (g_value_get_enum (gimp_value_array_index (return_vals, 0)))
+ {
+ case GIMP_PDB_SUCCESS:
+ break;
+
+ case GIMP_PDB_CALLING_ERROR:
+ if (gimp_value_array_length (return_vals) > 1 &&
+ G_VALUE_HOLDS_STRING (gimp_value_array_index (return_vals, 1)))
+ {
+ gimp_message (gimp, G_OBJECT (progress), GIMP_MESSAGE_ERROR,
+ _("Calling error for '%s':\n"
+ "%s"),
+ gimp_procedure_get_label (GIMP_PROCEDURE (proc)),
+ g_value_get_string (gimp_value_array_index (return_vals, 1)));
+ }
+ break;
+
+ case GIMP_PDB_EXECUTION_ERROR:
+ if (gimp_value_array_length (return_vals) > 1 &&
+ G_VALUE_HOLDS_STRING (gimp_value_array_index (return_vals, 1)))
+ {
+ gimp_message (gimp, G_OBJECT (progress), GIMP_MESSAGE_ERROR,
+ _("Execution error for '%s':\n"
+ "%s"),
+ gimp_procedure_get_label (GIMP_PROCEDURE (proc)),
+ g_value_get_string (gimp_value_array_index (return_vals, 1)));
+ }
+ break;
+ }
+}