void
gimp_plug_in_manager_data_free (GimpPlugInManager *manager)
{
g_return_if_fail (GIMP_IS_PLUG_IN_MANAGER (manager));
if (manager->data_list)
{
GList *list;
for (list = manager->data_list;
list;
list = g_list_next (list))
{
GimpPlugInData *data = list->data;
g_free (data->identifier);
g_free (data->data);
g_slice_free (GimpPlugInData, data);
}
g_list_free (manager->data_list);
manager->data_list = NULL;
}
}
void
gimp_plug_in_manager_restore (GimpPlugInManager *manager,
GimpContext *context,
GimpInitStatusFunc status_callback)
{
Gimp *gimp;
gchar *pluginrc;
GSList *list;
GError *error = NULL;
g_return_if_fail (GIMP_IS_PLUG_IN_MANAGER (manager));
g_return_if_fail (GIMP_IS_CONTEXT (context));
g_return_if_fail (status_callback != NULL);
gimp = manager->gimp;
/* need a GimpPDBContext for calling gimp_plug_in_manager_run_foo() */
context = gimp_pdb_context_new (gimp, context, TRUE);
/* search for binaries in the plug-in directory path */
gimp_plug_in_manager_search (manager, status_callback);
/* read the pluginrc file for cached data */
pluginrc = gimp_plug_in_manager_get_pluginrc (manager);
gimp_plug_in_manager_read_pluginrc (manager, pluginrc, status_callback);
/* query any plug-ins that changed since we last wrote out pluginrc */
gimp_plug_in_manager_query_new (manager, context, status_callback);
/* initialize the plug-ins */
gimp_plug_in_manager_init_plug_ins (manager, context, status_callback);
/* add the procedures to manager->plug_in_procedures */
for (list = manager->plug_in_defs; list; list = list->next)
{
GimpPlugInDef *plug_in_def = list->data;
GSList *list2;
for (list2 = plug_in_def->procedures; list2; list2 = list2->next)
{
gimp_plug_in_manager_add_procedure (manager, list2->data);
}
}
/* write the pluginrc file if necessary */
if (manager->write_pluginrc)
{
if (gimp->be_verbose)
g_print ("Writing '%s'\n", gimp_filename_to_utf8 (pluginrc));
if (! plug_in_rc_write (manager->plug_in_defs, pluginrc, &error))
{
gimp_message_literal (gimp,
NULL, GIMP_MESSAGE_ERROR, error->message);
g_clear_error (&error);
}
manager->write_pluginrc = FALSE;
}
g_free (pluginrc);
/* create locale and help domain lists */
for (list = manager->plug_in_defs; list; list = list->next)
{
GimpPlugInDef *plug_in_def = list->data;
if (plug_in_def->locale_domain_name)
gimp_plug_in_manager_add_locale_domain (manager,
plug_in_def->prog,
plug_in_def->locale_domain_name,
plug_in_def->locale_domain_path);
else
/* set the default plug-in locale domain */
gimp_plug_in_def_set_locale_domain (plug_in_def,
gimp_plug_in_manager_get_locale_domain (manager,
plug_in_def->prog,
NULL),
NULL);
if (plug_in_def->help_domain_name)
gimp_plug_in_manager_add_help_domain (manager,
plug_in_def->prog,
plug_in_def->help_domain_name,
plug_in_def->help_domain_uri);
}
/* we're done with the plug-in-defs */
g_slist_free_full (manager->plug_in_defs, (GDestroyNotify) g_object_unref);
manager->plug_in_defs = NULL;
/* bind plug-in text domains */
gimp_plug_in_manager_bind_text_domains (manager);
/* add the plug-in procs to the procedure database */
for (list = manager->plug_in_procedures; list; list = list->next)
{
gimp_plug_in_manager_add_to_db (manager, context, list->data);
}
/* sort the load, save and export procedures */
manager->load_procs =
g_slist_sort_with_data (manager->load_procs,
gimp_plug_in_manager_file_proc_compare, manager);
manager->save_procs =
g_slist_sort_with_data (manager->save_procs,
gimp_plug_in_manager_file_proc_compare, manager);
manager->export_procs =
g_slist_sort_with_data (manager->export_procs,
gimp_plug_in_manager_file_proc_compare, manager);
gimp_plug_in_manager_run_extensions (manager, context, status_callback);
g_object_unref (context);
}
static void
gimp_plug_in_manager_add_from_rc (GimpPlugInManager *manager,
GimpPlugInDef *plug_in_def)
{
GSList *list;
gchar *basename1;
g_return_if_fail (GIMP_IS_PLUG_IN_MANAGER (manager));
g_return_if_fail (plug_in_def != NULL);
g_return_if_fail (plug_in_def->prog != NULL);
if (! g_path_is_absolute (plug_in_def->prog))
{
g_warning ("plug_ins_def_add_from_rc: filename not absolute (skipping)");
g_object_unref (plug_in_def);
return;
}
basename1 = g_path_get_basename (plug_in_def->prog);
/* If this is a file load or save plugin, make sure we have
* something for one of the extensions, prefixes, or magic number.
* Other bits of code rely on detecting file plugins by the
* presence of one of these things, but the raw plug-in needs to be
* able to register no extensions, prefixes or magics.
*/
for (list = plug_in_def->procedures; list; list = list->next)
{
GimpPlugInProcedure *proc = list->data;
if (! proc->extensions &&
! proc->prefixes &&
! proc->magics &&
proc->menu_paths &&
(g_str_has_prefix (proc->menu_paths->data, "<Load>") ||
g_str_has_prefix (proc->menu_paths->data, "<Save>")))
{
proc->extensions = g_strdup ("");
}
}
/* Check if the entry mentioned in pluginrc matches an executable
* found in the plug_in_path.
*/
for (list = manager->plug_in_defs; list; list = list->next)
{
GimpPlugInDef *ondisk_plug_in_def = list->data;
gchar *basename2;
basename2 = g_path_get_basename (ondisk_plug_in_def->prog);
if (! strcmp (basename1, basename2))
{
if (! g_ascii_strcasecmp (plug_in_def->prog,
ondisk_plug_in_def->prog) &&
(plug_in_def->mtime == ondisk_plug_in_def->mtime))
{
/* Use pluginrc entry, deleting on-disk entry */
list->data = plug_in_def;
g_object_unref (ondisk_plug_in_def);
}
else
{
/* Use on-disk entry, deleting pluginrc entry */
g_object_unref (plug_in_def);
}
g_free (basename2);
g_free (basename1);
return;
}
g_free (basename2);
}
g_free (basename1);
manager->write_pluginrc = TRUE;
if (manager->gimp->be_verbose)
{
g_printerr ("pluginrc lists '%s', but it wasn't found\n",
gimp_filename_to_utf8 (plug_in_def->prog));
}
g_object_unref (plug_in_def);
}
GimpValueArray *
gimp_plug_in_manager_call_run_temp (GimpPlugInManager *manager,
GimpContext *context,
GimpProgress *progress,
GimpTemporaryProcedure *procedure,
GimpValueArray *args)
{
GimpValueArray *return_vals = NULL;
GimpPlugIn *plug_in;
g_return_val_if_fail (GIMP_IS_PLUG_IN_MANAGER (manager), 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);
g_return_val_if_fail (args != NULL, NULL);
plug_in = procedure->plug_in;
if (plug_in)
{
GimpPlugInProcFrame *proc_frame;
GPProcRun proc_run;
proc_frame = gimp_plug_in_proc_frame_push (plug_in, context, progress,
procedure);
proc_run.name = GIMP_PROCEDURE (procedure)->original_name;
proc_run.nparams = gimp_value_array_length (args);
proc_run.params = plug_in_args_to_params (args, FALSE);
if (! gp_temp_proc_run_write (plug_in->my_write, &proc_run, plug_in) ||
! gimp_wire_flush (plug_in->my_write, plug_in))
{
const gchar *name = gimp_object_get_name (plug_in);
GError *error = g_error_new (GIMP_PLUG_IN_ERROR,
GIMP_PLUG_IN_EXECUTION_FAILED,
_("Failed to run plug-in \"%s\""),
name);
g_free (proc_run.params);
gimp_plug_in_proc_frame_pop (plug_in);
return_vals = gimp_procedure_get_return_values (GIMP_PROCEDURE (procedure),
FALSE, error);
g_error_free (error);
return return_vals;
}
g_free (proc_run.params);
g_object_ref (plug_in);
gimp_plug_in_proc_frame_ref (proc_frame);
gimp_plug_in_main_loop (plug_in);
/* main_loop is quit and proc_frame is popped in
* gimp_plug_in_handle_temp_proc_return()
*/
return_vals = gimp_plug_in_proc_frame_get_return_values (proc_frame);
gimp_plug_in_proc_frame_unref (proc_frame, plug_in);
g_object_unref (plug_in);
}
return return_vals;
}
GimpValueArray *
gimp_plug_in_manager_call_run (GimpPlugInManager *manager,
GimpContext *context,
GimpProgress *progress,
GimpPlugInProcedure *procedure,
GimpValueArray *args,
gboolean synchronous,
GimpObject *display)
{
GimpValueArray *return_vals = NULL;
GimpPlugIn *plug_in;
g_return_val_if_fail (GIMP_IS_PLUG_IN_MANAGER (manager), 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_PLUG_IN_PROCEDURE (procedure), NULL);
g_return_val_if_fail (args != NULL, NULL);
g_return_val_if_fail (display == NULL || GIMP_IS_OBJECT (display), NULL);
plug_in = gimp_plug_in_new (manager, context, progress, procedure, NULL);
if (plug_in)
{
GimpCoreConfig *core_config = manager->gimp->config;
GimpGeglConfig *gegl_config = GIMP_GEGL_CONFIG (core_config);
GimpDisplayConfig *display_config = GIMP_DISPLAY_CONFIG (core_config);
GimpGuiConfig *gui_config = GIMP_GUI_CONFIG (core_config);
GPConfig config;
GPProcRun proc_run;
gint display_ID;
GObject *screen;
gint monitor;
if (! gimp_plug_in_open (plug_in, GIMP_PLUG_IN_CALL_RUN, FALSE))
{
const gchar *name = gimp_object_get_name (plug_in);
GError *error = g_error_new (GIMP_PLUG_IN_ERROR,
GIMP_PLUG_IN_EXECUTION_FAILED,
_("Failed to run plug-in \"%s\""),
name);
g_object_unref (plug_in);
return_vals = gimp_procedure_get_return_values (GIMP_PROCEDURE (procedure),
FALSE, error);
g_error_free (error);
return return_vals;
}
display_ID = display ? gimp_get_display_ID (manager->gimp, display) : -1;
config.version = GIMP_PROTOCOL_VERSION;
config.tile_width = GIMP_PLUG_IN_TILE_WIDTH;
config.tile_height = GIMP_PLUG_IN_TILE_HEIGHT;
config.shm_ID = (manager->shm ?
gimp_plug_in_shm_get_ID (manager->shm) : -1);
config.check_size = display_config->transparency_size;
config.check_type = display_config->transparency_type;
config.show_help_button = (gui_config->use_help &&
gui_config->show_help_button);
config.use_cpu_accel = manager->gimp->use_cpu_accel;
config.use_opencl = gegl_config->use_opencl;
config.gimp_reserved_6 = 0;
config.gimp_reserved_7 = 0;
config.gimp_reserved_8 = 0;
config.install_cmap = FALSE;
config.show_tooltips = gui_config->show_tooltips;
config.min_colors = 144;
config.gdisp_ID = display_ID;
config.app_name = (gchar *) g_get_application_name ();
config.wm_class = (gchar *) gimp_get_program_class (manager->gimp);
config.display_name = gimp_get_display_name (manager->gimp,
display_ID,
&screen, &monitor);
config.monitor_number = monitor;
config.timestamp = gimp_get_user_time (manager->gimp);
proc_run.name = GIMP_PROCEDURE (procedure)->original_name;
proc_run.nparams = gimp_value_array_length (args);
proc_run.params = plug_in_args_to_params (args, FALSE);
if (! gp_config_write (plug_in->my_write, &config, plug_in) ||
! gp_proc_run_write (plug_in->my_write, &proc_run, plug_in) ||
! gimp_wire_flush (plug_in->my_write, plug_in))
{
const gchar *name = gimp_object_get_name (plug_in);
GError *error = g_error_new (GIMP_PLUG_IN_ERROR,
GIMP_PLUG_IN_EXECUTION_FAILED,
_("Failed to run plug-in \"%s\""),
name);
g_free (config.display_name);
g_free (proc_run.params);
g_object_unref (plug_in);
return_vals = gimp_procedure_get_return_values (GIMP_PROCEDURE (procedure),
FALSE, error);
g_error_free (error);
return return_vals;
}
g_free (config.display_name);
g_free (proc_run.params);
/* If this is an extension,
* wait for an installation-confirmation message
*/
if (GIMP_PROCEDURE (procedure)->proc_type == GIMP_EXTENSION)
{
plug_in->ext_main_loop = g_main_loop_new (NULL, FALSE);
gimp_threads_leave (manager->gimp);
g_main_loop_run (plug_in->ext_main_loop);
gimp_threads_enter (manager->gimp);
/* main_loop is quit in gimp_plug_in_handle_extension_ack() */
g_main_loop_unref (plug_in->ext_main_loop);
plug_in->ext_main_loop = NULL;
}
/* If this plug-in is requested to run synchronously,
* wait for its return values
*/
if (synchronous)
{
GimpPlugInProcFrame *proc_frame = &plug_in->main_proc_frame;
proc_frame->main_loop = g_main_loop_new (NULL, FALSE);
gimp_threads_leave (manager->gimp);
g_main_loop_run (proc_frame->main_loop);
gimp_threads_enter (manager->gimp);
/* main_loop is quit in gimp_plug_in_handle_proc_return() */
g_main_loop_unref (proc_frame->main_loop);
proc_frame->main_loop = NULL;
return_vals = gimp_plug_in_proc_frame_get_return_values (proc_frame);
}
g_object_unref (plug_in);
}
return return_vals;
}
gint
gimp_plug_in_manager_query (GimpPlugInManager *manager,
const gchar *search_str,
gchar ***menu_strs,
gchar ***accel_strs,
gchar ***prog_strs,
gchar ***types_strs,
gchar ***realname_strs,
gint32 **time_ints)
{
gint32 num_plugins = 0;
GSList *list;
GSList *matched = NULL;
gint i = 0;
GRegex *sregex = NULL;
g_return_val_if_fail (GIMP_IS_PLUG_IN_MANAGER (manager), 0);
g_return_val_if_fail (menu_strs != NULL, 0);
g_return_val_if_fail (accel_strs != NULL, 0);
g_return_val_if_fail (prog_strs != NULL, 0);
g_return_val_if_fail (types_strs != NULL, 0);
g_return_val_if_fail (realname_strs != NULL, 0);
g_return_val_if_fail (time_ints != NULL, 0);
*menu_strs = NULL;
*accel_strs = NULL;
*prog_strs = NULL;
*types_strs = NULL;
*realname_strs = NULL;
*time_ints = NULL;
if (search_str && ! strlen (search_str))
search_str = NULL;
if (search_str)
{
sregex = g_regex_new (search_str, G_REGEX_CASELESS | G_REGEX_OPTIMIZE, 0,
NULL);
if (! sregex)
return 0;
}
/* count number of plugin entries, then allocate arrays of correct size
* where we can store the strings.
*/
for (list = manager->plug_in_procedures; list; list = g_slist_next (list))
{
GimpPlugInProcedure *proc = list->data;
if (proc->file && proc->menu_paths)
{
gchar *name;
if (proc->menu_label)
{
name = proc->menu_label;
}
else
{
name = strrchr (proc->menu_paths->data, '/');
if (name)
name = name + 1;
else
name = proc->menu_paths->data;
}
name = gimp_strip_uline (name);
if (! search_str || match_string (sregex, name))
{
num_plugins++;
matched = g_slist_prepend (matched, proc);
}
g_free (name);
}
}
*menu_strs = g_new (gchar *, num_plugins);
*accel_strs = g_new (gchar *, num_plugins);
*prog_strs = g_new (gchar *, num_plugins);
*types_strs = g_new (gchar *, num_plugins);
*realname_strs = g_new (gchar *, num_plugins);
*time_ints = g_new (gint, num_plugins);
matched = g_slist_reverse (matched);
for (list = matched; list; list = g_slist_next (list))
{
GimpPlugInProcedure *proc = list->data;
gchar *name;
if (proc->menu_label)
name = g_strdup_printf ("%s/%s",
(gchar *) proc->menu_paths->data,
proc->menu_label);
else
name = g_strdup (proc->menu_paths->data);
(*menu_strs)[i] = gimp_strip_uline (name);
(*accel_strs)[i] = NULL;
(*prog_strs)[i] = g_file_get_path (proc->file);
(*types_strs)[i] = g_strdup (proc->image_types);
(*realname_strs)[i] = g_strdup (gimp_object_get_name (proc));
(*time_ints)[i] = proc->mtime;
g_free (name);
i++;
}
g_slist_free (matched);
if (sregex)
g_regex_unref (sregex);
return num_plugins;
}