void gimp_procedure_execute_async (GimpProcedure *procedure, Gimp *gimp, GimpContext *context, GimpProgress *progress, GValueArray *args, GimpObject *display, GError **error) { g_return_if_fail (GIMP_IS_PROCEDURE (procedure)); g_return_if_fail (GIMP_IS_GIMP (gimp)); g_return_if_fail (GIMP_IS_CONTEXT (context)); g_return_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress)); g_return_if_fail (args != NULL); g_return_if_fail (display == NULL || GIMP_IS_OBJECT (display)); g_return_if_fail (error == NULL || *error == NULL); if (gimp_procedure_validate_args (procedure, procedure->args, procedure->num_args, args, FALSE, error)) { if (GIMP_IS_PDB_CONTEXT (context)) context = g_object_ref (context); else context = gimp_pdb_context_new (gimp, context, TRUE); GIMP_PROCEDURE_GET_CLASS (procedure)->execute_async (procedure, gimp, context, progress, args, display); g_object_unref (context); } }
GimpPlugIn * gimp_plug_in_new (GimpPlugInManager *manager, GimpContext *context, GimpProgress *progress, GimpPlugInProcedure *procedure, const gchar *prog) { 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 (procedure == NULL || GIMP_IS_PLUG_IN_PROCEDURE (procedure), NULL); g_return_val_if_fail (prog == NULL || g_path_is_absolute (prog), NULL); g_return_val_if_fail ((procedure != NULL || prog != NULL) && ! (procedure != NULL && prog != NULL), NULL); plug_in = g_object_new (GIMP_TYPE_PLUG_IN, NULL); if (! prog) prog = gimp_plug_in_procedure_get_progname (procedure); gimp_object_take_name (GIMP_OBJECT (plug_in), g_filename_display_basename (prog)); plug_in->manager = manager; plug_in->prog = g_strdup (prog); gimp_plug_in_proc_frame_init (&plug_in->main_proc_frame, context, progress, procedure); return plug_in; }
GimpPlugIn * gimp_plug_in_new (GimpPlugInManager *manager, GimpContext *context, GimpProgress *progress, GimpPlugInProcedure *procedure, GFile *file) { 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 (procedure == NULL || GIMP_IS_PLUG_IN_PROCEDURE (procedure), NULL); g_return_val_if_fail (file == NULL || G_IS_FILE (file), NULL); g_return_val_if_fail ((procedure != NULL || file != NULL) && ! (procedure != NULL && file != NULL), NULL); plug_in = g_object_new (GIMP_TYPE_PLUG_IN, NULL); if (! file) file = gimp_plug_in_procedure_get_file (procedure); gimp_object_take_name (GIMP_OBJECT (plug_in), g_path_get_basename (gimp_file_get_utf8_name (file))); plug_in->manager = manager; plug_in->file = g_object_ref (file); gimp_plug_in_proc_frame_init (&plug_in->main_proc_frame, context, progress, procedure); return plug_in; }
GimpPaintOptions * gimp_pdb_context_get_paint_options (GimpPDBContext *context, const gchar *name) { g_return_val_if_fail (GIMP_IS_PDB_CONTEXT (context), NULL); g_return_val_if_fail (name != NULL, NULL); return (GimpPaintOptions *) gimp_container_get_child_by_name (context->paint_options_list, name); }
GList * gimp_pdb_context_get_brush_options (GimpPDBContext *context) { GList *brush_options = NULL; GList *list; g_return_val_if_fail (GIMP_IS_PDB_CONTEXT (context), NULL); for (list = GIMP_LIST (context->paint_options_list)->list; list; list = g_list_next (list)) { GimpPaintOptions *options = list->data; if (g_type_is_a (options->paint_info->paint_type, GIMP_TYPE_BRUSH_CORE)) brush_options = g_list_prepend (brush_options, options); } return g_list_reverse (brush_options); }
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; }
void gimp_plug_in_manager_call_init (GimpPlugInManager *manager, GimpContext *context, GimpPlugInDef *plug_in_def) { GimpPlugIn *plug_in; g_return_if_fail (GIMP_IS_PLUG_IN_MANAGER (manager)); g_return_if_fail (GIMP_IS_PDB_CONTEXT (context)); g_return_if_fail (GIMP_IS_PLUG_IN_DEF (plug_in_def)); plug_in = gimp_plug_in_new (manager, context, NULL, NULL, plug_in_def->file); if (plug_in) { plug_in->plug_in_def = plug_in_def; if (gimp_plug_in_open (plug_in, GIMP_PLUG_IN_CALL_INIT, TRUE)) { while (plug_in->open) { GimpWireMessage msg; if (! gimp_wire_read_msg (plug_in->my_read, &msg, plug_in)) { gimp_plug_in_close (plug_in, TRUE); } else { gimp_plug_in_handle_message (plug_in, &msg); gimp_wire_destroy (&msg); } } } g_object_unref (plug_in); } }
GValueArray * gimp_procedure_execute (GimpProcedure *procedure, Gimp *gimp, GimpContext *context, GimpProgress *progress, GValueArray *args, GError **error) { GValueArray *return_vals; GError *pdb_error = NULL; g_return_val_if_fail (GIMP_IS_PROCEDURE (procedure), NULL); g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL); g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL); g_return_val_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress), NULL); g_return_val_if_fail (args != NULL, NULL); g_return_val_if_fail (error == NULL || *error == NULL, NULL); if (! gimp_procedure_validate_args (procedure, procedure->args, procedure->num_args, args, FALSE, &pdb_error)) { return_vals = gimp_procedure_get_return_values (procedure, FALSE, pdb_error); g_propagate_error (error, pdb_error); return return_vals; } if (GIMP_IS_PDB_CONTEXT (context)) context = g_object_ref (context); else context = gimp_pdb_context_new (gimp, context, TRUE); /* call the procedure */ return_vals = GIMP_PROCEDURE_GET_CLASS (procedure)->execute (procedure, gimp, context, progress, args, error); g_object_unref (context); if (return_vals) { switch (g_value_get_enum (&return_vals->values[0])) { case GIMP_PDB_CALLING_ERROR: case GIMP_PDB_EXECUTION_ERROR: /* If the error has not already been set, construct one * from the error message that is optionally passed with * the return values. */ if (error && *error == NULL) { if (return_vals->n_values > 1 && G_VALUE_HOLDS_STRING (&return_vals->values[1])) { g_set_error_literal (error, GIMP_PDB_ERROR, GIMP_PDB_FAILED, g_value_get_string (&return_vals->values[1])); } } break; default: break; } } else { g_warning ("%s: no return values, shouldn't happen", G_STRFUNC); pdb_error = g_error_new (GIMP_PDB_ERROR, GIMP_PDB_INVALID_RETURN_VALUE, _("Procedure '%s' returned no return values"), gimp_object_get_name (procedure)); return_vals = gimp_procedure_get_return_values (procedure, FALSE, pdb_error); if (error && *error == NULL) g_propagate_error (error, pdb_error); else g_error_free (pdb_error); } return return_vals; }
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; }