void gimp_plug_in_add_temp_proc (GimpPlugIn *plug_in, GimpTemporaryProcedure *proc) { GimpPlugInProcedure *overridden; const gchar *locale_domain; const gchar *help_domain; g_return_if_fail (GIMP_IS_PLUG_IN (plug_in)); g_return_if_fail (GIMP_IS_TEMPORARY_PROCEDURE (proc)); overridden = gimp_plug_in_procedure_find (plug_in->temp_procedures, gimp_object_get_name (proc)); if (overridden) gimp_plug_in_remove_temp_proc (plug_in, GIMP_TEMPORARY_PROCEDURE (overridden)); locale_domain = gimp_plug_in_manager_get_locale_domain (plug_in->manager, plug_in->prog, NULL); help_domain = gimp_plug_in_manager_get_help_domain (plug_in->manager, plug_in->prog, NULL); gimp_plug_in_procedure_set_locale_domain (GIMP_PLUG_IN_PROCEDURE (proc), locale_domain); gimp_plug_in_procedure_set_help_domain (GIMP_PLUG_IN_PROCEDURE (proc), help_domain); plug_in->temp_procedures = g_slist_prepend (plug_in->temp_procedures, g_object_ref (proc)); gimp_plug_in_manager_add_temp_proc (plug_in->manager, proc); }
static gint gimp_plug_in_manager_file_proc_compare (gconstpointer a, gconstpointer b, gpointer data) { GimpPlugInProcedure *proc_a = GIMP_PLUG_IN_PROCEDURE (a); GimpPlugInProcedure *proc_b = GIMP_PLUG_IN_PROCEDURE (b); const gchar *label_a; const gchar *label_b; gint retval = 0; if (g_str_has_prefix (proc_a->prog, "gimp-xcf")) return -1; if (g_str_has_prefix (proc_b->prog, "gimp-xcf")) return 1; label_a = gimp_plug_in_procedure_get_label (proc_a); label_b = gimp_plug_in_procedure_get_label (proc_b); if (label_a && label_b) retval = g_utf8_collate (label_a, label_b); return retval; }
static void gimp_plug_in_handle_proc_return (GimpPlugIn *plug_in, GPProcReturn *proc_return) { GimpPlugInProcFrame *proc_frame = &plug_in->main_proc_frame; g_return_if_fail (proc_return != NULL); proc_frame->return_vals = plug_in_params_to_args (proc_frame->procedure->values, proc_frame->procedure->num_values, proc_return->params, proc_return->nparams, TRUE, TRUE); if (proc_frame->main_loop) { g_main_loop_quit (proc_frame->main_loop); } else { /* the plug-in is run asynchronously, so display its error * messages here because nobody else will do it */ gimp_plug_in_procedure_handle_return_values (GIMP_PLUG_IN_PROCEDURE (proc_frame->procedure), plug_in->manager->gimp, proc_frame->progress, proc_frame->return_vals); } gimp_plug_in_close (plug_in, FALSE); }
static void plug_in_actions_unregister_procedure (GimpPDB *pdb, GimpProcedure *procedure, GimpActionGroup *group) { if (GIMP_IS_PLUG_IN_PROCEDURE (procedure)) { GimpPlugInProcedure *plug_in_proc = GIMP_PLUG_IN_PROCEDURE (procedure); g_signal_handlers_disconnect_by_func (plug_in_proc, plug_in_actions_menu_path_added, group); if ((plug_in_proc->menu_label || plug_in_proc->menu_paths) && ! plug_in_proc->file_proc) { GtkAction *action; #if 0 g_print ("%s: %s\n", G_STRFUNC, gimp_object_get_name (GIMP_OBJECT (procedure))); #endif action = gtk_action_group_get_action (GTK_ACTION_GROUP (group), GIMP_OBJECT (procedure)->name); if (action) gtk_action_group_remove_action (GTK_ACTION_GROUP (group), action); } } }
static void gimp_temporary_procedure_execute_async (GimpProcedure *procedure, Gimp *gimp, GimpContext *context, GimpProgress *progress, GimpValueArray *args, GimpObject *display) { GimpTemporaryProcedure *temp_procedure = GIMP_TEMPORARY_PROCEDURE (procedure); GimpValueArray *return_vals; return_vals = gimp_plug_in_manager_call_run_temp (gimp->plug_in_manager, context, progress, temp_procedure, args); if (return_vals) { GimpPlugInProcedure *proc = GIMP_PLUG_IN_PROCEDURE (procedure); gimp_plug_in_procedure_handle_return_values (proc, gimp, progress, return_vals); gimp_value_array_unref (return_vals); } }
static void gimp_plug_in_procedure_finalize (GObject *object) { GimpPlugInProcedure *proc = GIMP_PLUG_IN_PROCEDURE (object); g_free (proc->prog); g_free (proc->menu_label); g_list_free_full (proc->menu_paths, (GDestroyNotify) g_free); g_free (proc->label); g_free (proc->icon_data); g_free (proc->image_types); g_free (proc->extensions); g_free (proc->prefixes); g_free (proc->magics); g_free (proc->mime_type); 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_free (proc->thumb_loader); G_OBJECT_CLASS (parent_class)->finalize (object); }
static void plug_in_actions_register_procedure (GimpPDB *pdb, GimpProcedure *procedure, GimpActionGroup *group) { if (GIMP_IS_PLUG_IN_PROCEDURE (procedure)) { GimpPlugInProcedure *plug_in_proc = GIMP_PLUG_IN_PROCEDURE (procedure); g_signal_connect_object (plug_in_proc, "menu-path-added", G_CALLBACK (plug_in_actions_menu_path_added), group, 0); if ((plug_in_proc->menu_label || plug_in_proc->menu_paths) && ! plug_in_proc->file_proc) { #if 0 g_print ("%s: %s\n", G_STRFUNC, gimp_object_get_name (GIMP_OBJECT (procedure))); #endif plug_in_actions_add_proc (group, plug_in_proc); } } }
static void plug_in_menus_register_procedure (GimpPDB *pdb, GimpProcedure *procedure, GimpUIManager *manager) { if (GIMP_IS_PLUG_IN_PROCEDURE (procedure)) { GimpPlugInProcedure *plug_in_proc = GIMP_PLUG_IN_PROCEDURE (procedure); g_signal_connect_object (plug_in_proc, "menu-path-added", G_CALLBACK (plug_in_menus_menu_path_added), manager, 0); if ((plug_in_proc->menu_label || plug_in_proc->menu_paths) && ! plug_in_proc->file_proc) { GList *list; GIMP_LOG (MENUS, "register procedure: %s", gimp_object_get_name (procedure)); for (list = plug_in_proc->menu_paths; list; list = g_list_next (list)) plug_in_menus_menu_path_added (plug_in_proc, list->data, manager); } } }
GimpProcedure * gimp_temporary_procedure_new (GimpPlugIn *plug_in) { GimpTemporaryProcedure *proc; g_return_val_if_fail (GIMP_IS_PLUG_IN (plug_in), NULL); proc = g_object_new (GIMP_TYPE_TEMPORARY_PROCEDURE, NULL); proc->plug_in = plug_in; GIMP_PLUG_IN_PROCEDURE (proc)->file = g_file_new_for_path ("none"); 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; }
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_string_get_memsize (proc->prog); 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_STOCK_ID: 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_type); 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); return memsize + GIMP_OBJECT_CLASS (parent_class)->get_memsize (object, gui_size); }
static GValueArray * gimp_plug_in_procedure_execute (GimpProcedure *procedure, Gimp *gimp, GimpContext *context, GimpProgress *progress, GValueArray *args, GError **error) { 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_cleanup_item (GimpPlugInProcFrame *proc_frame, GimpPlugInCleanupItem *cleanup) { GimpItem *item = cleanup->item; if (cleanup->shadow_buffer) { GimpProcedure *proc = proc_frame->procedure; GIMP_LOG (SHADOW_TILES, "Freeing shadow buffer of drawable '%s' on behalf of '%s'.", gimp_object_get_name (item), gimp_plug_in_procedure_get_label (GIMP_PLUG_IN_PROCEDURE (proc))); gimp_drawable_free_shadow_buffer (GIMP_DRAWABLE (item)); } }
static void plug_in_menus_unregister_procedure (GimpPDB *pdb, GimpProcedure *procedure, GimpUIManager *manager) { if (GIMP_IS_PLUG_IN_PROCEDURE (procedure)) { GimpPlugInProcedure *plug_in_proc = GIMP_PLUG_IN_PROCEDURE (procedure); g_signal_handlers_disconnect_by_func (plug_in_proc, plug_in_menus_menu_path_added, manager); if ((plug_in_proc->menu_label || plug_in_proc->menu_paths) && ! plug_in_proc->file_proc) { GList *list; GIMP_LOG (MENUS, "unregister procedure: %s", gimp_object_get_name (procedure)); for (list = plug_in_proc->menu_paths; list; list = g_list_next (list)) { if (g_str_has_prefix (list->data, manager->name)) { gchar *merge_key; guint merge_id; merge_key = g_strdup_printf ("%s-merge-id", gimp_object_get_name (plug_in_proc)); merge_id = GPOINTER_TO_UINT (g_object_get_data (G_OBJECT (manager), merge_key)); g_free (merge_key); if (merge_id) gtk_ui_manager_remove_ui (GTK_UI_MANAGER (manager), merge_id); break; } } } } }
void gimp_plug_in_cleanup (GimpPlugIn *plug_in, GimpPlugInProcFrame *proc_frame) { GList *list; g_return_if_fail (GIMP_IS_PLUG_IN (plug_in)); g_return_if_fail (proc_frame != NULL); for (list = proc_frame->cleanups; list; list = g_list_next (list)) { GimpPlugInCleanupImage *cleanup = list->data; GimpImage *image = cleanup->image; if (! gimp_container_have (plug_in->manager->gimp->images, (GimpObject *) image)) continue; if (image->pushing_undo_group == GIMP_UNDO_GROUP_NONE) continue; if (cleanup->undo_group_count != image->group_count) { GimpProcedure *proc = proc_frame->procedure; g_message ("Plug-In '%s' left image undo in inconsistent state, " "closing open undo groups.", gimp_plug_in_procedure_get_label (GIMP_PLUG_IN_PROCEDURE (proc))); while (image->pushing_undo_group != GIMP_UNDO_GROUP_NONE && cleanup->undo_group_count < image->group_count) { if (! gimp_image_undo_group_end (image)) break; } } g_slice_free (GimpPlugInCleanupImage, cleanup); } g_list_free (proc_frame->cleanups); proc_frame->cleanups = NULL; }
GimpPlugInProcFrame * gimp_plug_in_proc_frame_push (GimpPlugIn *plug_in, GimpContext *context, GimpProgress *progress, GimpTemporaryProcedure *procedure) { GimpPlugInProcFrame *proc_frame; g_return_val_if_fail (GIMP_IS_PLUG_IN (plug_in), NULL); g_return_val_if_fail (GIMP_IS_PDB_CONTEXT (context), NULL); g_return_val_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress), NULL); g_return_val_if_fail (GIMP_IS_TEMPORARY_PROCEDURE (procedure), NULL); proc_frame = gimp_plug_in_proc_frame_new (context, progress, GIMP_PLUG_IN_PROCEDURE (procedure)); plug_in->temp_proc_frames = g_list_prepend (plug_in->temp_proc_frames, proc_frame); return proc_frame; }
const gchar * gimp_plug_in_get_undo_desc (GimpPlugIn *plug_in) { GimpPlugInProcFrame *proc_frame; const gchar *undo_desc = NULL; g_return_val_if_fail (GIMP_IS_PLUG_IN (plug_in), NULL); proc_frame = gimp_plug_in_get_proc_frame (plug_in); if (proc_frame) { GimpPlugInProcedure *proc; proc = GIMP_PLUG_IN_PROCEDURE (proc_frame->procedure); if (proc) undo_desc = gimp_plug_in_procedure_get_label (proc); } return undo_desc ? undo_desc : gimp_object_get_name (plug_in); }
static void gimp_plug_in_cleanup_image (GimpPlugInProcFrame *proc_frame, GimpPlugInCleanupImage *cleanup) { GimpImage *image = cleanup->image; if (gimp_image_get_undo_group_count (image) == 0) return; if (cleanup->undo_group_count != gimp_image_get_undo_group_count (image)) { GimpProcedure *proc = proc_frame->procedure; g_message ("Plug-In '%s' left image undo in inconsistent state, " "closing open undo groups.", gimp_plug_in_procedure_get_label (GIMP_PLUG_IN_PROCEDURE (proc))); while (cleanup->undo_group_count < gimp_image_get_undo_group_count (image)) { if (! gimp_image_undo_group_end (image)) break; } } }
static void gimp_plug_in_procedure_execute_async (GimpProcedure *procedure, Gimp *gimp, GimpContext *context, GimpProgress *progress, GValueArray *args, GimpObject *display) { GimpPlugInProcedure *plug_in_procedure = GIMP_PLUG_IN_PROCEDURE (procedure); GValueArray *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); g_value_array_free (return_vals); } }
void xcf_init (Gimp *gimp) { GimpPlugInProcedure *proc; GimpProcedure *procedure; g_return_if_fail (GIMP_IS_GIMP (gimp)); /* So this is sort of a hack, but its better than it was before. To * do this right there would be a file load-save handler type and * the whole interface would change but there isn't, and currently * the plug-in structure contains all the load-save info, so it * makes sense to use that for the XCF load/save handlers, even * though they are internal. The only thing it requires is using a * PlugInProcDef struct. -josh */ /* gimp-xcf-save */ procedure = gimp_plug_in_procedure_new (GIMP_PLUGIN, "gimp-xcf-save"); procedure->proc_type = GIMP_INTERNAL; procedure->marshal_func = xcf_save_invoker; proc = GIMP_PLUG_IN_PROCEDURE (procedure); proc->menu_label = g_strdup (N_("GIMP XCF image")); gimp_plug_in_procedure_set_icon (proc, GIMP_ICON_TYPE_STOCK_ID, (const guint8 *) "gimp-wilber", strlen ("gimp-wilber") + 1); gimp_plug_in_procedure_set_image_types (proc, "RGB*, GRAY*, INDEXED*"); gimp_plug_in_procedure_set_file_proc (proc, "xcf", "", NULL); gimp_plug_in_procedure_set_mime_type (proc, "image/xcf"); gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-xcf-save"); gimp_procedure_set_static_strings (procedure, "gimp-xcf-save", "Saves file in the .xcf file format", "The XCF file format has been designed " "specifically for loading and saving " "tiled and layered images in GIMP. " "This procedure will save the specified " "image in the xcf file format.", "Spencer Kimball & Peter Mattis", "Spencer Kimball & Peter Mattis", "1995-1996", NULL); gimp_procedure_add_argument (procedure, gimp_param_spec_int32 ("dummy-param", "Dummy Param", "Dummy parameter", G_MININT32, G_MAXINT32, 0, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, gimp_param_spec_image_id ("image", "Image", "Input image", gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, gimp_param_spec_drawable_id ("drawable", "Drawable", "Active drawable of input image", gimp, TRUE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, gimp_param_spec_string ("filename", "Filename", "The name of the file " "to save the image in, " "in the on-disk " "character set and " "encoding", TRUE, FALSE, TRUE, NULL, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, gimp_param_spec_string ("raw-filename", "Raw filename", "The basename of the " "file, in UTF-8", FALSE, FALSE, TRUE, NULL, GIMP_PARAM_READWRITE)); gimp_plug_in_manager_add_procedure (gimp->plug_in_manager, proc); g_object_unref (procedure); /* gimp-xcf-load */ procedure = gimp_plug_in_procedure_new (GIMP_PLUGIN, "gimp-xcf-load"); procedure->proc_type = GIMP_INTERNAL; procedure->marshal_func = xcf_load_invoker; proc = GIMP_PLUG_IN_PROCEDURE (procedure); proc->menu_label = g_strdup (N_("GIMP XCF image")); gimp_plug_in_procedure_set_icon (proc, GIMP_ICON_TYPE_STOCK_ID, (const guint8 *) "gimp-wilber", strlen ("gimp-wilber") + 1); gimp_plug_in_procedure_set_image_types (proc, NULL); gimp_plug_in_procedure_set_file_proc (proc, "xcf", "", "0,string,gimp\\040xcf\\040"); gimp_plug_in_procedure_set_mime_type (proc, "image/xcf"); gimp_object_set_static_name (GIMP_OBJECT (procedure), "gimp-xcf-load"); gimp_procedure_set_static_strings (procedure, "gimp-xcf-load", "Loads file saved in the .xcf file format", "The XCF file format has been designed " "specifically for loading and saving " "tiled and layered images in GIMP. " "This procedure will load the specified " "file.", "Spencer Kimball & Peter Mattis", "Spencer Kimball & Peter Mattis", "1995-1996", NULL); gimp_procedure_add_argument (procedure, gimp_param_spec_int32 ("dummy-param", "Dummy Param", "Dummy parameter", G_MININT32, G_MAXINT32, 0, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, gimp_param_spec_string ("filename", "Filename", "The name of the file " "to load, in the " "on-disk character " "set and encoding", TRUE, FALSE, TRUE, NULL, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, gimp_param_spec_string ("raw-filename", "Raw filename", "The basename of the " "file, in UTF-8", FALSE, FALSE, TRUE, NULL, GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, gimp_param_spec_image_id ("image", "Image", "Output image", gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_plug_in_manager_add_procedure (gimp->plug_in_manager, proc); g_object_unref (procedure); }
static void gimp_plug_in_handle_proc_install (GimpPlugIn *plug_in, GPProcInstall *proc_install) { GimpPlugInProcedure *proc = NULL; GimpProcedure *procedure = NULL; gchar *canonical; gboolean null_name = FALSE; gboolean valid_utf8 = FALSE; gint i; g_return_if_fail (proc_install != NULL); g_return_if_fail (proc_install->name != NULL); canonical = gimp_canonicalize_identifier (proc_install->name); /* Sanity check for array arguments */ for (i = 1; i < proc_install->nparams; i++) { if ((proc_install->params[i].type == GIMP_PDB_INT32ARRAY || proc_install->params[i].type == GIMP_PDB_INT8ARRAY || proc_install->params[i].type == GIMP_PDB_FLOATARRAY || proc_install->params[i].type == GIMP_PDB_STRINGARRAY || proc_install->params[i].type == GIMP_PDB_COLORARRAY) && proc_install->params[i - 1].type != GIMP_PDB_INT32) { gimp_message (plug_in->manager->gimp, NULL, GIMP_MESSAGE_ERROR, "Plug-In \"%s\"\n(%s)\n\n" "attempted to install procedure \"%s\" " "which fails to comply with the array parameter " "passing standard. Argument %d is noncompliant.", gimp_object_get_name (plug_in), gimp_file_get_utf8_name (plug_in->file), canonical, i); g_free (canonical); return; } } /* Sanity check strings for UTF-8 validity */ #define VALIDATE(str) (g_utf8_validate ((str), -1, NULL)) #define VALIDATE_OR_NULL(str) ((str) == NULL || g_utf8_validate ((str), -1, NULL)) if (VALIDATE_OR_NULL (proc_install->menu_path) && VALIDATE (canonical) && VALIDATE_OR_NULL (proc_install->blurb) && VALIDATE_OR_NULL (proc_install->help) && VALIDATE_OR_NULL (proc_install->author) && VALIDATE_OR_NULL (proc_install->copyright) && VALIDATE_OR_NULL (proc_install->date)) { null_name = FALSE; valid_utf8 = TRUE; for (i = 0; i < proc_install->nparams && valid_utf8 && !null_name; i++) { if (! proc_install->params[i].name) { null_name = TRUE; } else if (! (VALIDATE (proc_install->params[i].name) && VALIDATE_OR_NULL (proc_install->params[i].description))) { valid_utf8 = FALSE; } } for (i = 0; i < proc_install->nreturn_vals && valid_utf8 && !null_name; i++) { if (! proc_install->return_vals[i].name) { null_name = TRUE; } else if (! (VALIDATE (proc_install->return_vals[i].name) && VALIDATE_OR_NULL (proc_install->return_vals[i].description))) { valid_utf8 = FALSE; } } } #undef VALIDATE #undef VALIDATE_OR_NULL if (null_name) { gimp_message (plug_in->manager->gimp, NULL, GIMP_MESSAGE_ERROR, "Plug-In \"%s\"\n(%s)\n\n" "attempted to install a procedure NULL parameter name.", gimp_object_get_name (plug_in), gimp_file_get_utf8_name (plug_in->file)); g_free (canonical); return; } if (! valid_utf8) { gimp_message (plug_in->manager->gimp, NULL, GIMP_MESSAGE_ERROR, "Plug-In \"%s\"\n(%s)\n\n" "attempted to install a procedure with invalid UTF-8 strings.", gimp_object_get_name (plug_in), gimp_file_get_utf8_name (plug_in->file)); g_free (canonical); return; } /* Create the procedure object */ switch (proc_install->type) { case GIMP_PLUGIN: case GIMP_EXTENSION: procedure = gimp_plug_in_procedure_new (proc_install->type, plug_in->file); break; case GIMP_TEMPORARY: procedure = gimp_temporary_procedure_new (plug_in); break; } proc = GIMP_PLUG_IN_PROCEDURE (procedure); proc->mtime = time (NULL); proc->installed_during_init = (plug_in->call_mode == GIMP_PLUG_IN_CALL_INIT); gimp_object_take_name (GIMP_OBJECT (procedure), canonical); gimp_procedure_set_strings (procedure, proc_install->name, proc_install->blurb, proc_install->help, proc_install->author, proc_install->copyright, proc_install->date, NULL); gimp_plug_in_procedure_set_image_types (proc, proc_install->image_types); for (i = 0; i < proc_install->nparams; i++) { GParamSpec *pspec = gimp_pdb_compat_param_spec (plug_in->manager->gimp, proc_install->params[i].type, proc_install->params[i].name, proc_install->params[i].description); gimp_procedure_add_argument (procedure, pspec); } for (i = 0; i < proc_install->nreturn_vals; i++) { GParamSpec *pspec = gimp_pdb_compat_param_spec (plug_in->manager->gimp, proc_install->return_vals[i].type, proc_install->return_vals[i].name, proc_install->return_vals[i].description); gimp_procedure_add_return_value (procedure, pspec); } /* Sanity check menu path */ if (proc_install->menu_path && strlen (proc_install->menu_path)) { if (proc_install->menu_path[0] == '<') { GError *error = NULL; if (! gimp_plug_in_procedure_add_menu_path (proc, proc_install->menu_path, &error)) { gimp_message_literal (plug_in->manager->gimp, NULL, GIMP_MESSAGE_WARNING, error->message); g_clear_error (&error); } } else { proc->menu_label = g_strdup (proc_install->menu_path); } } /* Install the procedure */ switch (proc_install->type) { case GIMP_PLUGIN: case GIMP_EXTENSION: gimp_plug_in_def_add_procedure (plug_in->plug_in_def, proc); break; case GIMP_TEMPORARY: gimp_plug_in_add_temp_proc (plug_in, GIMP_TEMPORARY_PROCEDURE (proc)); break; } g_object_unref (proc); }
void file_data_init (Gimp *gimp) { GimpPlugInProcedure *proc; GFile *file; GimpProcedure *procedure; g_return_if_fail (GIMP_IS_GIMP (gimp)); /* file-gbr-load */ file = g_file_new_for_path ("file-gbr-load"); procedure = gimp_plug_in_procedure_new (GIMP_PLUGIN, file); g_object_unref (file); procedure->proc_type = GIMP_INTERNAL; procedure->marshal_func = file_gbr_load_invoker; proc = GIMP_PLUG_IN_PROCEDURE (procedure); proc->menu_label = g_strdup (N_("GIMP brush")); gimp_plug_in_procedure_set_icon (proc, GIMP_ICON_TYPE_ICON_NAME, (const guint8 *) "gimp-brush", strlen ("gimp-brush") + 1); gimp_plug_in_procedure_set_image_types (proc, NULL); gimp_plug_in_procedure_set_file_proc (proc, "gbr, gbp", "", "20, string, GIMP"); gimp_plug_in_procedure_set_mime_types (proc, "image/gimp-x-gbr"); gimp_plug_in_procedure_set_handles_uri (proc); gimp_object_set_static_name (GIMP_OBJECT (procedure), "file-gbr-load"); gimp_procedure_set_static_strings (procedure, "file-gbr-load", "Loads GIMP brushes", "Loads GIMP brushes (1 or 4 bpp " "and old .gpb format)", "Tim Newsome, Jens Lautenbacher, " "Sven Neumann, Michael Natterer", "Tim Newsome, Jens Lautenbacher, " "Sven Neumann, Michael Natterer", "1995-2019", NULL); gimp_procedure_add_argument (procedure, gimp_param_spec_int32 ("dummy-param", "Dummy Param", "Dummy parameter", G_MININT32, G_MAXINT32, 0, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, gimp_param_spec_string ("uri", "URI", "The URI of the file " "to load", TRUE, FALSE, TRUE, NULL, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, gimp_param_spec_string ("raw-uri", "Raw URI", "The URI of the file " "to load", TRUE, FALSE, TRUE, NULL, GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, gimp_param_spec_image_id ("image", "Image", "Output image", gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_plug_in_manager_add_procedure (gimp->plug_in_manager, proc); g_object_unref (procedure); /* file-gbr-save-internal */ file = g_file_new_for_path ("file-gbr-save-internal"); procedure = gimp_plug_in_procedure_new (GIMP_PLUGIN, file); g_object_unref (file); procedure->proc_type = GIMP_INTERNAL; procedure->marshal_func = file_gbr_save_invoker; proc = GIMP_PLUG_IN_PROCEDURE (procedure); proc->menu_label = g_strdup (N_("GIMP brush")); gimp_plug_in_procedure_set_icon (proc, GIMP_ICON_TYPE_ICON_NAME, (const guint8 *) "gimp-brush", strlen ("gimp-brush") + 1); #if 0 /* do not register as file procedure */ gimp_plug_in_procedure_set_image_types (proc, "RGB*, GRAY*, INDEXED*"); gimp_plug_in_procedure_set_file_proc (proc, "gbr", "", NULL); gimp_plug_in_procedure_set_mime_types (proc, "image/x-gimp-gbr"); gimp_plug_in_procedure_set_handles_uri (proc); #endif gimp_object_set_static_name (GIMP_OBJECT (procedure), "file-gbr-save-internal"); gimp_procedure_set_static_strings (procedure, "file-gbr-save-internal", "Exports Gimp brush file (.GBR)", "Exports Gimp brush file (.GBR)", "Tim Newsome, Michael Natterer", "Tim Newsome, Michael Natterer", "1995-2019", NULL); gimp_procedure_add_argument (procedure, gimp_param_spec_int32 ("dummy-param", "Dummy Param", "Dummy parameter", G_MININT32, G_MAXINT32, 0, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, gimp_param_spec_image_id ("image", "Image", "Input image", gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, gimp_param_spec_drawable_id ("drawable", "Drawable", "Active drawable " "of input image", gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, gimp_param_spec_string ("uri", "URI", "The URI of the file " "to export", FALSE, FALSE, TRUE, NULL, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, gimp_param_spec_string ("raw-uri", "Raw URI", "The URI of the file " "to export", FALSE, FALSE, TRUE, NULL, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, gimp_param_spec_int32 ("spacing", "spacing", "Spacing of the brush", 1, 1000, 10, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, gimp_param_spec_string ("name", "name", "The name of the " "brush", FALSE, FALSE, TRUE, "GIMP Brush", GIMP_PARAM_READWRITE)); gimp_plug_in_manager_add_procedure (gimp->plug_in_manager, proc); g_object_unref (procedure); /* file-gih-load */ file = g_file_new_for_path ("file-gih-load"); procedure = gimp_plug_in_procedure_new (GIMP_PLUGIN, file); g_object_unref (file); procedure->proc_type = GIMP_INTERNAL; procedure->marshal_func = file_gih_load_invoker; proc = GIMP_PLUG_IN_PROCEDURE (procedure); proc->menu_label = g_strdup (N_("GIMP brush (animated)")); gimp_plug_in_procedure_set_icon (proc, GIMP_ICON_TYPE_ICON_NAME, (const guint8 *) "gimp-brush", strlen ("gimp-brush") + 1); gimp_plug_in_procedure_set_image_types (proc, NULL); gimp_plug_in_procedure_set_file_proc (proc, "gih", "", ""); gimp_plug_in_procedure_set_mime_types (proc, "image/gimp-x-gih"); gimp_plug_in_procedure_set_handles_uri (proc); gimp_object_set_static_name (GIMP_OBJECT (procedure), "file-gih-load"); gimp_procedure_set_static_strings (procedure, "file-gih-load", "Loads GIMP animated brushes", "This procedure loads a GIMP brush " "pipe as an image.", "Tor Lillqvist, Michael Natterer", "Tor Lillqvist, Michael Natterer", "1999-2019", NULL); gimp_procedure_add_argument (procedure, gimp_param_spec_int32 ("dummy-param", "Dummy Param", "Dummy parameter", G_MININT32, G_MAXINT32, 0, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, gimp_param_spec_string ("uri", "URI", "The URI of the file " "to load", TRUE, FALSE, TRUE, NULL, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, gimp_param_spec_string ("raw-uri", "Raw URI", "The URI of the file " "to load", TRUE, FALSE, TRUE, NULL, GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, gimp_param_spec_image_id ("image", "Image", "Output image", gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_plug_in_manager_add_procedure (gimp->plug_in_manager, proc); g_object_unref (procedure); /* file-gih-save-internal */ file = g_file_new_for_path ("file-gih-save-internal"); procedure = gimp_plug_in_procedure_new (GIMP_PLUGIN, file); g_object_unref (file); procedure->proc_type = GIMP_INTERNAL; procedure->marshal_func = file_gih_save_invoker; proc = GIMP_PLUG_IN_PROCEDURE (procedure); proc->menu_label = g_strdup (N_("GIMP brush (animated)")); gimp_plug_in_procedure_set_icon (proc, GIMP_ICON_TYPE_ICON_NAME, (const guint8 *) "gimp-brush", strlen ("gimp-brush") + 1); #if 0 /* do not register as file procedure */ gimp_plug_in_procedure_set_image_types (proc, "RGB*, GRAY*, INDEXED*"); gimp_plug_in_procedure_set_file_proc (proc, "gih", "", NULL); gimp_plug_in_procedure_set_mime_types (proc, "image/x-gimp-gih"); gimp_plug_in_procedure_set_handles_uri (proc); #endif gimp_object_set_static_name (GIMP_OBJECT (procedure), "file-gih-save-internal"); gimp_procedure_set_static_strings (procedure, "file-gih-save-internal", "Exports Gimp animated brush file (.gih)", "Exports Gimp animated brush file (.gih)", "Tor Lillqvist, Michael Natterer", "Tor Lillqvist, Michael Natterer", "1999-2019", NULL); gimp_procedure_add_argument (procedure, gimp_param_spec_int32 ("dummy-param", "Dummy Param", "Dummy parameter", G_MININT32, G_MAXINT32, 0, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, gimp_param_spec_image_id ("image", "Image", "Input image", gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, gimp_param_spec_drawable_id ("drawable", "Drawable", "Active drawable " "of input image", gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, gimp_param_spec_string ("uri", "URI", "The URI of the file " "to export", FALSE, FALSE, TRUE, NULL, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, gimp_param_spec_string ("raw-uri", "Raw URI", "The URI of the file " "to export", FALSE, FALSE, TRUE, NULL, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, gimp_param_spec_int32 ("spacing", "spacing", "Spacing of the brush", 1, 1000, 10, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, gimp_param_spec_string ("name", "name", "The name of the " "brush", FALSE, FALSE, TRUE, "GIMP Brush", GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, gimp_param_spec_string ("params", "params", "The pipe's parameters", FALSE, FALSE, TRUE, NULL, GIMP_PARAM_READWRITE)); gimp_plug_in_manager_add_procedure (gimp->plug_in_manager, proc); g_object_unref (procedure); /* file-pat-load */ file = g_file_new_for_path ("file-pat-load"); procedure = gimp_plug_in_procedure_new (GIMP_PLUGIN, file); g_object_unref (file); procedure->proc_type = GIMP_INTERNAL; procedure->marshal_func = file_pat_load_invoker; proc = GIMP_PLUG_IN_PROCEDURE (procedure); proc->menu_label = g_strdup (N_("GIMP pattern")); gimp_plug_in_procedure_set_icon (proc, GIMP_ICON_TYPE_ICON_NAME, (const guint8 *) "gimp-pattern", strlen ("gimp-pattern") + 1); gimp_plug_in_procedure_set_image_types (proc, NULL); gimp_plug_in_procedure_set_file_proc (proc, "pat", "", "20,string,GPAT"); gimp_plug_in_procedure_set_mime_types (proc, "image/gimp-x-pat"); gimp_plug_in_procedure_set_handles_uri (proc); gimp_object_set_static_name (GIMP_OBJECT (procedure), "file-pat-load"); gimp_procedure_set_static_strings (procedure, "file-pat-load", "Loads GIMP patterns", "Loads GIMP patterns", "Tim Newsome, Michael Natterer", "Tim Newsome, Michael Natterer", "1997-2019", NULL); gimp_procedure_add_argument (procedure, gimp_param_spec_int32 ("dummy-param", "Dummy Param", "Dummy parameter", G_MININT32, G_MAXINT32, 0, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, gimp_param_spec_string ("uri", "URI", "The URI of the file " "to load", TRUE, FALSE, TRUE, NULL, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, gimp_param_spec_string ("raw-uri", "Raw URI", "The URI of the file " "to load", TRUE, FALSE, TRUE, NULL, GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, gimp_param_spec_image_id ("image", "Image", "Output image", gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_plug_in_manager_add_procedure (gimp->plug_in_manager, proc); g_object_unref (procedure); /* file-pat-save-internal */ file = g_file_new_for_path ("file-pat-save-internal"); procedure = gimp_plug_in_procedure_new (GIMP_PLUGIN, file); g_object_unref (file); procedure->proc_type = GIMP_INTERNAL; procedure->marshal_func = file_pat_save_invoker; proc = GIMP_PLUG_IN_PROCEDURE (procedure); proc->menu_label = g_strdup (N_("GIMP pattern")); gimp_plug_in_procedure_set_icon (proc, GIMP_ICON_TYPE_ICON_NAME, (const guint8 *) "gimp-pattern", strlen ("gimp-pattern") + 1); #if 0 /* do not register as file procedure */ gimp_plug_in_procedure_set_image_types (proc, "RGB*, GRAY*, INDEXED*"); gimp_plug_in_procedure_set_file_proc (proc, "pat", "", NULL); gimp_plug_in_procedure_set_mime_types (proc, "image/x-gimp-pat"); gimp_plug_in_procedure_set_handles_uri (proc); #endif gimp_object_set_static_name (GIMP_OBJECT (procedure), "file-pat-save-internal"); gimp_procedure_set_static_strings (procedure, "file-pat-save-internal", "Exports Gimp pattern file (.PAT)", "Exports Gimp pattern file (.PAT)", "Tim Newsome, Michael Natterer", "Tim Newsome, Michael Natterer", "1995-2019", NULL); gimp_procedure_add_argument (procedure, gimp_param_spec_int32 ("dummy-param", "Dummy Param", "Dummy parameter", G_MININT32, G_MAXINT32, 0, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, gimp_param_spec_image_id ("image", "Image", "Input image", gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, gimp_param_spec_drawable_id ("drawable", "Drawable", "Active drawable " "of input image", gimp, FALSE, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, gimp_param_spec_string ("uri", "URI", "The URI of the file " "to export", FALSE, FALSE, TRUE, NULL, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, gimp_param_spec_string ("raw-uri", "Raw URI", "The URI of the file " "to export", FALSE, FALSE, TRUE, NULL, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, gimp_param_spec_string ("name", "name", "The name of the " "pattern", FALSE, FALSE, TRUE, "GIMP Pattern", GIMP_PARAM_READWRITE)); gimp_plug_in_manager_add_procedure (gimp->plug_in_manager, proc); g_object_unref (procedure); /* file-gex-load */ file = g_file_new_for_path ("file-gex-load"); procedure = gimp_plug_in_procedure_new (GIMP_PLUGIN, file); g_object_unref (file); procedure->proc_type = GIMP_INTERNAL; procedure->marshal_func = file_gex_load_invoker; proc = GIMP_PLUG_IN_PROCEDURE (procedure); proc->menu_label = g_strdup (N_("GIMP extension")); gimp_plug_in_procedure_set_icon (proc, GIMP_ICON_TYPE_ICON_NAME, (const guint8 *) "gimp-plugin", strlen ("gimp-plugin") + 1); gimp_plug_in_procedure_set_file_proc (proc, "gex", "", "20, string, GIMP"); gimp_plug_in_procedure_set_generic_file_proc (proc, TRUE); gimp_plug_in_procedure_set_mime_types (proc, "image/gimp-x-gex"); gimp_plug_in_procedure_set_handles_uri (proc); gimp_object_set_static_name (GIMP_OBJECT (procedure), "file-gex-load"); gimp_procedure_set_static_strings (procedure, "file-gex-load", "Loads GIMP extension", "Loads GIMP extension", "Jehan", "Jehan", "2019", NULL); gimp_procedure_add_argument (procedure, gimp_param_spec_int32 ("dummy-param", "Dummy Param", "Dummy parameter", G_MININT32, G_MAXINT32, 0, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, gimp_param_spec_string ("uri", "URI", "The URI of the file " "to load", TRUE, FALSE, TRUE, NULL, GIMP_PARAM_READWRITE)); gimp_procedure_add_argument (procedure, gimp_param_spec_string ("raw-uri", "Raw URI", "The URI of the file " "to load", TRUE, FALSE, TRUE, NULL, GIMP_PARAM_READWRITE)); gimp_procedure_add_return_value (procedure, gimp_param_spec_string ("extension-id", "ID of installed extension", "Identifier of the newly installed extension", FALSE, TRUE, FALSE, NULL, GIMP_PARAM_READWRITE)); gimp_plug_in_manager_add_procedure (gimp->plug_in_manager, proc); g_object_unref (procedure); }
static GTokenType plug_in_procedure_deserialize (GScanner *scanner, Gimp *gimp, GFile *file, GimpPlugInProcedure **proc) { GimpProcedure *procedure; GTokenType token; gchar *str; gint proc_type; gint n_args; gint n_return_vals; gint n_menu_paths; gint i; if (! gimp_scanner_parse_string (scanner, &str)) return G_TOKEN_STRING; if (! gimp_scanner_parse_int (scanner, &proc_type)) { g_free (str); return G_TOKEN_INT; } procedure = gimp_plug_in_procedure_new (proc_type, file); *proc = GIMP_PLUG_IN_PROCEDURE (procedure); gimp_object_take_name (GIMP_OBJECT (procedure), gimp_canonicalize_identifier (str)); procedure->original_name = str; if (! gimp_scanner_parse_string (scanner, &procedure->blurb)) return G_TOKEN_STRING; if (! gimp_scanner_parse_string (scanner, &procedure->help)) return G_TOKEN_STRING; if (! gimp_scanner_parse_string (scanner, &procedure->author)) return G_TOKEN_STRING; if (! gimp_scanner_parse_string (scanner, &procedure->copyright)) return G_TOKEN_STRING; if (! gimp_scanner_parse_string (scanner, &procedure->date)) return G_TOKEN_STRING; if (! gimp_scanner_parse_string (scanner, &(*proc)->menu_label)) return G_TOKEN_STRING; if (! gimp_scanner_parse_int (scanner, &n_menu_paths)) return G_TOKEN_INT; for (i = 0; i < n_menu_paths; i++) { token = plug_in_menu_path_deserialize (scanner, *proc); if (token != G_TOKEN_LEFT_PAREN) return token; } token = plug_in_icon_deserialize (scanner, *proc); if (token != G_TOKEN_LEFT_PAREN) return token; token = plug_in_file_proc_deserialize (scanner, *proc); if (token != G_TOKEN_LEFT_PAREN) return token; if (! gimp_scanner_parse_string (scanner, &str)) return G_TOKEN_STRING; gimp_plug_in_procedure_set_image_types (*proc, str); g_free (str); if (! gimp_scanner_parse_int (scanner, (gint *) &n_args)) return G_TOKEN_INT; if (! gimp_scanner_parse_int (scanner, (gint *) &n_return_vals)) return G_TOKEN_INT; for (i = 0; i < n_args; i++) { token = plug_in_proc_arg_deserialize (scanner, gimp, procedure, FALSE); if (token != G_TOKEN_LEFT_PAREN) return token; } for (i = 0; i < n_return_vals; i++) { token = plug_in_proc_arg_deserialize (scanner, gimp, procedure, TRUE); if (token != G_TOKEN_LEFT_PAREN) return token; } if (! gimp_scanner_parse_token (scanner, G_TOKEN_RIGHT_PAREN)) return G_TOKEN_RIGHT_PAREN; return G_TOKEN_LEFT_PAREN; }