gboolean gimp_pdb_proc_info (GimpPDB *pdb, const gchar *proc_name, gchar **blurb, gchar **help, gchar **author, gchar **copyright, gchar **date, GimpPDBProcType *proc_type, gint *num_args, gint *num_values, GError **error) { GimpProcedure *procedure; PDBStrings strings; g_return_val_if_fail (GIMP_IS_PDB (pdb), FALSE); g_return_val_if_fail (proc_name != NULL, FALSE); g_return_val_if_fail (error == NULL || *error == NULL, FALSE); procedure = gimp_pdb_lookup_procedure (pdb, proc_name); if (procedure) { gimp_pdb_get_strings (&strings, procedure, FALSE); } else { const gchar *compat_name; compat_name = gimp_pdb_lookup_compat_proc_name (pdb, proc_name); if (compat_name) { procedure = gimp_pdb_lookup_procedure (pdb, compat_name); if (procedure) gimp_pdb_get_strings (&strings, procedure, TRUE); } } if (procedure) { *blurb = strings.compat ? strings.blurb : g_strdup (strings.blurb); *help = strings.compat ? strings.help : g_strdup (strings.help); *author = strings.compat ? strings.author : g_strdup (strings.author); *copyright = strings.compat ? strings.copyright : g_strdup (strings.copyright); *date = strings.compat ? strings.date : g_strdup (strings.date); *proc_type = procedure->proc_type; *num_args = procedure->num_args; *num_values = procedure->num_values; return TRUE; } g_set_error (error, GIMP_PDB_ERROR, GIMP_PDB_PROCEDURE_NOT_FOUND, _("Procedure '%s' not found"), proc_name); return FALSE; }
void vectors_selection_to_vectors_cmd_callback (GtkAction *action, gint value, gpointer data) { GimpImage *image; GtkWidget *widget; GimpProcedure *procedure; GimpValueArray *args; GimpDisplay *display; GError *error = NULL; return_if_no_image (image, data); return_if_no_widget (widget, data); if (value) procedure = gimp_pdb_lookup_procedure (image->gimp->pdb, "plug-in-sel2path-advanced"); else procedure = gimp_pdb_lookup_procedure (image->gimp->pdb, "plug-in-sel2path"); if (! procedure) { gimp_message_literal (image->gimp, G_OBJECT (widget), GIMP_MESSAGE_ERROR, "Selection to path procedure lookup failed."); return; } display = gimp_context_get_display (action_data_get_context (data)); args = gimp_procedure_get_arguments (procedure); gimp_value_array_truncate (args, 2); g_value_set_int (gimp_value_array_index (args, 0), GIMP_RUN_INTERACTIVE); gimp_value_set_image (gimp_value_array_index (args, 1), image); gimp_procedure_execute_async (procedure, image->gimp, action_data_get_context (data), GIMP_PROGRESS (display), args, GIMP_OBJECT (display), &error); gimp_value_array_unref (args); if (error) { gimp_message_literal (image->gimp, G_OBJECT (widget), GIMP_MESSAGE_ERROR, error->message); g_error_free (error); } }
static GimpValueArray * fonts_set_popup_invoker (GimpProcedure *procedure, Gimp *gimp, GimpContext *context, GimpProgress *progress, const GimpValueArray *args, GError **error) { gboolean success = TRUE; const gchar *font_callback; const gchar *font_name; font_callback = g_value_get_string (gimp_value_array_index (args, 0)); font_name = g_value_get_string (gimp_value_array_index (args, 1)); if (success) { if (gimp->no_interface || ! gimp_pdb_lookup_procedure (gimp->pdb, font_callback) || ! gimp_pdb_dialog_set (gimp, gimp->fonts, font_callback, font_name, NULL)) success = FALSE; } return gimp_procedure_get_return_values (procedure, success, error ? *error : NULL); }
static GValueArray * palettes_set_popup_invoker (GimpProcedure *procedure, Gimp *gimp, GimpContext *context, GimpProgress *progress, const GValueArray *args, GError **error) { gboolean success = TRUE; const gchar *palette_callback; const gchar *palette_name; palette_callback = g_value_get_string (&args->values[0]); palette_name = g_value_get_string (&args->values[1]); if (success) { if (gimp->no_interface || ! gimp_pdb_lookup_procedure (gimp->pdb, palette_callback) || ! gimp_pdb_dialog_set (gimp, gimp->palette_factory->container, palette_callback, palette_name, NULL)) success = FALSE; } return gimp_procedure_get_return_values (procedure, success, error ? *error : NULL); }
gboolean plug_in_icc_profile_info (GimpImage *image, GimpContext *context, GimpProgress *progress, gchar **name, gchar **desc, gchar **info, GError **error) { Gimp *gimp; GimpProcedure *procedure; g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE); g_return_val_if_fail (GIMP_IS_CONTEXT (context), FALSE); g_return_val_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress), FALSE); g_return_val_if_fail (error == NULL || *error == NULL, FALSE); gimp = image->gimp; procedure = gimp_pdb_lookup_procedure (gimp->pdb, ICC_PROFILE_INFO_PROC); if (procedure && procedure->num_args >= 1 && GIMP_IS_PARAM_SPEC_IMAGE_ID (procedure->args[0])) { GimpValueArray *return_vals; GimpPDBStatusType status; return_vals = gimp_pdb_execute_procedure_by_name (gimp->pdb, context, progress, error, ICC_PROFILE_INFO_PROC, GIMP_TYPE_IMAGE_ID, gimp_image_get_ID (image), G_TYPE_NONE); status = g_value_get_enum (gimp_value_array_index (return_vals, 0)); switch (status) { case GIMP_PDB_SUCCESS: plug_in_icc_profile_info_return (return_vals, name, desc, info); break; default: if (error && *error == NULL) g_set_error (error, GIMP_PLUG_IN_ERROR, GIMP_PLUG_IN_FAILED, _("Error running '%s'"), ICC_PROFILE_INFO_PROC); break; } gimp_value_array_unref (return_vals); return (status == GIMP_PDB_SUCCESS); } g_set_error (error, GIMP_PLUG_IN_ERROR, GIMP_PLUG_IN_FAILED, _("Plug-In missing (%s)"), ICC_PROFILE_INFO_PROC); return FALSE; }
static GValueArray * palettes_popup_invoker (GimpProcedure *procedure, Gimp *gimp, GimpContext *context, GimpProgress *progress, const GValueArray *args, GError **error) { gboolean success = TRUE; const gchar *palette_callback; const gchar *popup_title; const gchar *initial_palette; palette_callback = g_value_get_string (&args->values[0]); popup_title = g_value_get_string (&args->values[1]); initial_palette = g_value_get_string (&args->values[2]); if (success) { if (gimp->no_interface || ! gimp_pdb_lookup_procedure (gimp->pdb, palette_callback) || ! gimp_pdb_dialog_new (gimp, context, progress, gimp_data_factory_get_container (gimp->palette_factory), popup_title, palette_callback, initial_palette, NULL)) success = FALSE; } return gimp_procedure_get_return_values (procedure, success, error ? *error : NULL); }
static GimpValueArray * procedural_db_proc_exists_invoker (GimpProcedure *procedure, Gimp *gimp, GimpContext *context, GimpProgress *progress, const GimpValueArray *args, GError **error) { gboolean success = TRUE; GimpValueArray *return_vals; const gchar *procedure_name; gboolean exists = FALSE; procedure_name = g_value_get_string (gimp_value_array_index (args, 0)); if (success) { GimpProcedure *procedure; gchar *canonical; canonical = gimp_canonicalize_identifier (procedure_name); procedure = gimp_pdb_lookup_procedure (gimp->pdb, canonical); if (! procedure) { procedure_name = gimp_pdb_lookup_compat_proc_name (gimp->pdb, canonical); if (procedure_name) procedure = gimp_pdb_lookup_procedure (gimp->pdb, procedure_name); } g_free (canonical); exists = (procedure != NULL); } return_vals = gimp_procedure_get_return_values (procedure, success, error ? *error : NULL); if (success) g_value_set_boolean (gimp_value_array_index (return_vals, 1), exists); return return_vals; }
gboolean gimp_plug_in_progress_install (GimpPlugIn *plug_in, const gchar *progress_callback) { GimpPlugInProcFrame *proc_frame; GimpProcedure *procedure; g_return_val_if_fail (GIMP_IS_PLUG_IN (plug_in), FALSE); g_return_val_if_fail (progress_callback != NULL, FALSE); procedure = gimp_pdb_lookup_procedure (plug_in->manager->gimp->pdb, progress_callback); if (! GIMP_IS_TEMPORARY_PROCEDURE (procedure) || GIMP_TEMPORARY_PROCEDURE (procedure)->plug_in != plug_in || procedure->num_args != 3 || ! GIMP_IS_PARAM_SPEC_INT32 (procedure->args[0]) || ! G_IS_PARAM_SPEC_STRING (procedure->args[1]) || ! G_IS_PARAM_SPEC_DOUBLE (procedure->args[2])) { return FALSE; } proc_frame = gimp_plug_in_get_proc_frame (plug_in); if (proc_frame->progress) { gimp_plug_in_progress_end (plug_in, proc_frame); if (proc_frame->progress) { g_object_unref (proc_frame->progress); proc_frame->progress = NULL; } } proc_frame->progress = g_object_new (GIMP_TYPE_PDB_PROGRESS, "pdb", plug_in->manager->gimp->pdb, "context", proc_frame->main_context, "callback-name", progress_callback, NULL); gimp_plug_in_progress_attach (proc_frame->progress); return TRUE; }
static GValueArray * patterns_close_popup_invoker (GimpProcedure *procedure, Gimp *gimp, GimpContext *context, GimpProgress *progress, const GValueArray *args) { gboolean success = TRUE; const gchar *pattern_callback; pattern_callback = g_value_get_string (&args->values[0]); if (success) { if (gimp->no_interface || ! gimp_pdb_lookup_procedure (gimp->pdb, pattern_callback) || ! gimp_pdb_dialog_close (gimp, gimp->pattern_factory->container, pattern_callback)) success = FALSE; } return gimp_procedure_get_return_values (procedure, success); }
/** * file_open_thumbnail: * @gimp: * @context: * @progress: * @file: an image file * @size: requested size of the thumbnail * @mime_type: return location for image MIME type * @image_width: return location for image width * @image_height: return location for image height * @format: return location for image format (set to NULL if unknown) * @num_layers: return location for number of layers * (set to -1 if the number of layers is not known) * @error: * * Attempts to load a thumbnail by using a registered thumbnail loader. * * Return value: the thumbnail image */ GimpImage * file_open_thumbnail (Gimp *gimp, GimpContext *context, GimpProgress *progress, GFile *file, gint size, const gchar **mime_type, gint *image_width, gint *image_height, const Babl **format, gint *num_layers, GError **error) { GimpPlugInProcedure *file_proc; GimpProcedure *procedure; 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 (G_IS_FILE (file), NULL); g_return_val_if_fail (mime_type != NULL, NULL); g_return_val_if_fail (image_width != NULL, NULL); g_return_val_if_fail (image_height != NULL, NULL); g_return_val_if_fail (format != NULL, NULL); g_return_val_if_fail (num_layers != NULL, NULL); g_return_val_if_fail (error == NULL || *error == NULL, NULL); *image_width = 0; *image_height = 0; *format = NULL; *num_layers = -1; file_proc = file_procedure_find (gimp->plug_in_manager->load_procs, file, NULL); if (! file_proc || ! file_proc->thumb_loader) return NULL; procedure = gimp_pdb_lookup_procedure (gimp->pdb, file_proc->thumb_loader); if (procedure && procedure->num_args >= 2 && procedure->num_values >= 1) { GimpPDBStatusType status; GimpValueArray *return_vals; GimpImage *image = NULL; gchar *path = NULL; if (! file_proc->handles_uri) path = g_file_get_path (file); if (! path) path = g_file_get_uri (file); return_vals = gimp_pdb_execute_procedure_by_name (gimp->pdb, context, progress, error, gimp_object_get_name (procedure), G_TYPE_STRING, path, GIMP_TYPE_INT32, size, G_TYPE_NONE); g_free (path); status = g_value_get_enum (gimp_value_array_index (return_vals, 0)); if (status == GIMP_PDB_SUCCESS && GIMP_VALUE_HOLDS_IMAGE_ID (gimp_value_array_index (return_vals, 1))) { image = gimp_value_get_image (gimp_value_array_index (return_vals, 1), gimp); if (gimp_value_array_length (return_vals) >= 3 && G_VALUE_HOLDS_INT (gimp_value_array_index (return_vals, 2)) && G_VALUE_HOLDS_INT (gimp_value_array_index (return_vals, 3))) { *image_width = MAX (0, g_value_get_int (gimp_value_array_index (return_vals, 2))); *image_height = MAX (0, g_value_get_int (gimp_value_array_index (return_vals, 3))); if (gimp_value_array_length (return_vals) >= 5 && G_VALUE_HOLDS_INT (gimp_value_array_index (return_vals, 4))) { gint value = g_value_get_int (gimp_value_array_index (return_vals, 4)); switch (value) { case GIMP_RGB_IMAGE: *format = gimp_babl_format (GIMP_RGB, GIMP_PRECISION_U8_GAMMA, FALSE); break; case GIMP_RGBA_IMAGE: *format = gimp_babl_format (GIMP_RGB, GIMP_PRECISION_U8_GAMMA, TRUE); break; case GIMP_GRAY_IMAGE: *format = gimp_babl_format (GIMP_GRAY, GIMP_PRECISION_U8_GAMMA, FALSE); break; case GIMP_GRAYA_IMAGE: *format = gimp_babl_format (GIMP_GRAY, GIMP_PRECISION_U8_GAMMA, TRUE); break; case GIMP_INDEXED_IMAGE: case GIMP_INDEXEDA_IMAGE: { const Babl *rgb; const Babl *rgba; babl_new_palette ("-gimp-indexed-format-dummy", &rgb, &rgba); if (value == GIMP_INDEXED_IMAGE) *format = rgb; else *format = rgba; } break; default: break; } } if (gimp_value_array_length (return_vals) >= 6 && G_VALUE_HOLDS_INT (gimp_value_array_index (return_vals, 5))) { *num_layers = MAX (0, g_value_get_int (gimp_value_array_index (return_vals, 5))); } } if (image) { file_open_sanitize_image (image, FALSE); *mime_type = file_proc->mime_type; #ifdef GIMP_UNSTABLE g_printerr ("opened thumbnail at %d x %d\n", gimp_image_get_width (image), gimp_image_get_height (image)); #endif } } gimp_value_array_unref (return_vals); return image; } return NULL; }
static void gimp_plug_in_handle_proc_run (GimpPlugIn *plug_in, GPProcRun *proc_run) { GimpPlugInProcFrame *proc_frame; gchar *canonical; const gchar *proc_name = NULL; GimpProcedure *procedure; GimpValueArray *args = NULL; GimpValueArray *return_vals = NULL; GError *error = NULL; g_return_if_fail (proc_run != NULL); g_return_if_fail (proc_run->name != NULL); canonical = gimp_canonicalize_identifier (proc_run->name); proc_frame = gimp_plug_in_get_proc_frame (plug_in); procedure = gimp_pdb_lookup_procedure (plug_in->manager->gimp->pdb, canonical); if (! procedure) { proc_name = gimp_pdb_lookup_compat_proc_name (plug_in->manager->gimp->pdb, canonical); if (proc_name) { procedure = gimp_pdb_lookup_procedure (plug_in->manager->gimp->pdb, proc_name); if (plug_in->manager->gimp->pdb_compat_mode == GIMP_PDB_COMPAT_WARN) { gimp_message (plug_in->manager->gimp, NULL, GIMP_MESSAGE_WARNING, "Plug-In \"%s\"\n(%s)\n" "called deprecated procedure '%s'.\n" "It should call '%s' instead!", gimp_object_get_name (plug_in), gimp_file_get_utf8_name (plug_in->file), canonical, proc_name); } } } else if (procedure->deprecated) { if (plug_in->manager->gimp->pdb_compat_mode == GIMP_PDB_COMPAT_WARN) { if (! strcmp (procedure->deprecated, "NONE")) { gimp_message (plug_in->manager->gimp, NULL, GIMP_MESSAGE_WARNING, "Plug-In \"%s\"\n(%s)\n" "called deprecated procedure '%s'.", gimp_object_get_name (plug_in), gimp_file_get_utf8_name (plug_in->file), canonical); } else { gimp_message (plug_in->manager->gimp, NULL, GIMP_MESSAGE_WARNING, "WARNING: Plug-In \"%s\"\n(%s)\n" "called deprecated procedure '%s'.\n" "It should call '%s' instead!", gimp_object_get_name (plug_in), gimp_file_get_utf8_name (plug_in->file), canonical, procedure->deprecated); } } } if (! proc_name) proc_name = canonical; args = plug_in_params_to_args (procedure ? procedure->args : NULL, procedure ? procedure->num_args : 0, proc_run->params, proc_run->nparams, FALSE, FALSE); /* Execute the procedure even if gimp_pdb_lookup_procedure() * returned NULL, gimp_pdb_execute_procedure_by_name_args() will * return appropriate error return_vals. */ gimp_plug_in_manager_plug_in_push (plug_in->manager, plug_in); return_vals = gimp_pdb_execute_procedure_by_name_args (plug_in->manager->gimp->pdb, proc_frame->context_stack ? proc_frame->context_stack->data : proc_frame->main_context, proc_frame->progress, &error, proc_name, args); gimp_plug_in_manager_plug_in_pop (plug_in->manager); gimp_value_array_unref (args); if (error) { gimp_plug_in_handle_proc_error (plug_in, proc_frame, canonical, error); g_error_free (error); } g_free (canonical); /* Don't bother to send the return value if executing the procedure * closed the plug-in (e.g. if the procedure is gimp-quit) */ if (plug_in->open) { GPProcReturn proc_return; /* Return the name we got called with, *not* proc_name or canonical, * since proc_name may have been remapped by gimp->procedural_compat_ht * and canonical may be different too. */ proc_return.name = proc_run->name; proc_return.nparams = gimp_value_array_length (return_vals); proc_return.params = plug_in_args_to_params (return_vals, FALSE); if (! gp_proc_return_write (plug_in->my_write, &proc_return, plug_in)) { gimp_message (plug_in->manager->gimp, NULL, GIMP_MESSAGE_ERROR, "%s: ERROR", G_STRFUNC); gimp_plug_in_close (plug_in, TRUE); } g_free (proc_return.params); } gimp_value_array_unref (return_vals); }
void batch_run (Gimp *gimp, const gchar *batch_interpreter, const gchar **batch_commands) { gulong exit_id; if (! batch_commands || ! batch_commands[0]) return; exit_id = g_signal_connect_after (gimp, "exit", G_CALLBACK (batch_exit_after_callback), NULL); if (! batch_interpreter) { batch_interpreter = g_getenv ("GIMP_BATCH_INTERPRETER"); if (! batch_interpreter) { batch_interpreter = BATCH_DEFAULT_EVAL_PROC; if (gimp->be_verbose) g_printerr (_("No batch interpreter specified, using the default " "'%s'.\n"), batch_interpreter); } } /* script-fu text console, hardcoded for backward compatibility */ if (strcmp (batch_interpreter, "plug-in-script-fu-eval") == 0 && strcmp (batch_commands[0], "-") == 0) { const gchar *proc_name = "plug-in-script-fu-text-console"; GimpProcedure *procedure = gimp_pdb_lookup_procedure (gimp->pdb, proc_name); if (procedure) batch_run_cmd (gimp, proc_name, procedure, GIMP_RUN_NONINTERACTIVE, NULL); else g_message (_("The batch interpreter '%s' is not available. " "Batch mode disabled."), proc_name); } else { GimpProcedure *eval_proc = gimp_pdb_lookup_procedure (gimp->pdb, batch_interpreter); if (eval_proc) { gint i; for (i = 0; batch_commands[i]; i++) batch_run_cmd (gimp, batch_interpreter, eval_proc, GIMP_RUN_NONINTERACTIVE, batch_commands[i]); } else { g_message (_("The batch interpreter '%s' is not available. " "Batch mode disabled."), batch_interpreter); } } g_signal_handler_disconnect (gimp, exit_id); }
GimpValueArray * gimp_pdb_execute_procedure_by_name (GimpPDB *pdb, GimpContext *context, GimpProgress *progress, GError **error, const gchar *name, ...) { GimpProcedure *procedure; GimpValueArray *args; GimpValueArray *return_vals; va_list va_args; gint i; g_return_val_if_fail (GIMP_IS_PDB (pdb), 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 (error == NULL || *error == NULL, NULL); g_return_val_if_fail (name != NULL, NULL); procedure = gimp_pdb_lookup_procedure (pdb, name); if (! procedure) { GError *pdb_error = g_error_new (GIMP_PDB_ERROR, GIMP_PDB_ERROR_PROCEDURE_NOT_FOUND, _("Procedure '%s' not found"), name); return_vals = gimp_procedure_get_return_values (NULL, FALSE, pdb_error); g_propagate_error (error, pdb_error); return return_vals; } args = gimp_procedure_get_arguments (procedure); va_start (va_args, name); for (i = 0; i < procedure->num_args; i++) { GValue *value; GType arg_type; gchar *error_msg = NULL; arg_type = va_arg (va_args, GType); if (arg_type == G_TYPE_NONE) break; value = gimp_value_array_index (args, i); if (arg_type != G_VALUE_TYPE (value)) { GError *pdb_error; const gchar *expected = g_type_name (G_VALUE_TYPE (value)); const gchar *got = g_type_name (arg_type); gimp_value_array_unref (args); pdb_error = g_error_new (GIMP_PDB_ERROR, GIMP_PDB_ERROR_INVALID_ARGUMENT, _("Procedure '%s' has been called with a " "wrong type for argument #%d. " "Expected %s, got %s."), gimp_object_get_name (procedure), i + 1, expected, got); return_vals = gimp_procedure_get_return_values (procedure, FALSE, pdb_error); g_propagate_error (error, pdb_error); va_end (va_args); return return_vals; } G_VALUE_COLLECT (value, va_args, G_VALUE_NOCOPY_CONTENTS, &error_msg); if (error_msg) { GError *pdb_error = g_error_new_literal (GIMP_PDB_ERROR, GIMP_PDB_ERROR_INTERNAL_ERROR, error_msg); g_warning ("%s: %s", G_STRFUNC, error_msg); g_free (error_msg); gimp_value_array_unref (args); return_vals = gimp_procedure_get_return_values (procedure, FALSE, pdb_error); g_propagate_error (error, pdb_error); va_end (va_args); return return_vals; } } va_end (va_args); return_vals = gimp_pdb_execute_procedure_by_name_args (pdb, context, progress, error, name, args); gimp_value_array_unref (args); return return_vals; }
gboolean plug_in_icc_profile_apply_rgb (GimpImage *image, GimpContext *context, GimpProgress *progress, GimpRunMode run_mode, GError **error) { Gimp *gimp; GimpProcedure *procedure; g_return_val_if_fail (GIMP_IS_IMAGE (image), FALSE); g_return_val_if_fail (GIMP_IS_CONTEXT (context), FALSE); g_return_val_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress), FALSE); g_return_val_if_fail (error == NULL || *error == NULL, FALSE); gimp = image->gimp; if (gimp_image_get_base_type (image) == GIMP_GRAY) { g_set_error (error, GIMP_PLUG_IN_ERROR, GIMP_PLUG_IN_EXECUTION_FAILED, _("Can't apply color profile to grayscale image (%s)"), ICC_PROFILE_APPLY_RGB_PROC); return FALSE; } procedure = gimp_pdb_lookup_procedure (gimp->pdb, ICC_PROFILE_APPLY_RGB_PROC); if (procedure && procedure->num_args >= 2 && GIMP_IS_PARAM_SPEC_INT32 (procedure->args[0]) && GIMP_IS_PARAM_SPEC_IMAGE_ID (procedure->args[1])) { GimpValueArray *return_vals; GimpPDBStatusType status; GimpColorProfilePolicy policy = GIMP_COLOR_PROFILE_POLICY_ASK; gboolean success; return_vals = gimp_pdb_execute_procedure_by_name (gimp->pdb, context, progress, error, ICC_PROFILE_APPLY_RGB_PROC, GIMP_TYPE_INT32, run_mode, GIMP_TYPE_IMAGE_ID, gimp_image_get_ID (image), G_TYPE_NONE); status = g_value_get_enum (gimp_value_array_index (return_vals, 0)); switch (status) { case GIMP_PDB_SUCCESS: policy = GIMP_COLOR_PROFILE_POLICY_CONVERT; success = TRUE; break; case GIMP_PDB_CANCEL: policy = GIMP_COLOR_PROFILE_POLICY_KEEP; success = TRUE; break; default: if (error && *error == NULL) g_set_error (error, GIMP_PLUG_IN_ERROR, GIMP_PLUG_IN_EXECUTION_FAILED, _("Error running '%s'"), ICC_PROFILE_APPLY_RGB_PROC); success = FALSE; break; } if (success && gimp_value_array_length (return_vals) > 1) { GValue *value = gimp_value_array_index (return_vals, 1); if (GIMP_VALUE_HOLDS_INT32 (value) && g_value_get_int (value)) { g_object_set (G_OBJECT (gimp->config), "color-profile-policy", policy, NULL); } } gimp_value_array_unref (return_vals); return success; } g_set_error (error, GIMP_PLUG_IN_ERROR, GIMP_PLUG_IN_NOT_FOUND, _("Plug-In missing (%s)"), ICC_PROFILE_APPLY_RGB_PROC); return FALSE; }
GtkWidget * about_dialog_create (GimpContext *context) { static GimpAboutDialog *dialog = NULL; g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL); if (! dialog) { GtkWidget *widget; GtkWidget *container; GdkPixbuf *pixbuf; GList *children; if (gimp_pdb_lookup_procedure (context->gimp->pdb, PDB_URL_LOAD)) gtk_about_dialog_set_url_hook (about_dialog_load_url, g_object_ref (context), (GDestroyNotify) g_object_unref); dialog = g_new0 (GimpAboutDialog, 1); dialog->n_authors = G_N_ELEMENTS (authors) - 1; pixbuf = about_dialog_load_logo (); widget = g_object_new (GTK_TYPE_ABOUT_DIALOG, "role", "about-dialog", "window-position", GTK_WIN_POS_CENTER, "title", _("About GIMP"), (gtk_check_version (2, 12, 0) ? "name" : "program-name"), GIMP_ACRONYM, "version", GIMP_VERSION, "copyright", GIMP_COPYRIGHT, "comments", GIMP_NAME, "license", GIMP_LICENSE, "wrap-license", TRUE, "logo", pixbuf, "website", "http://www.gimp.org/", "website-label", _("Visit the GIMP website"), "authors", authors, "artists", artists, "documenters", documenters, /* Translators: insert your names here, * separated by newline */ "translator-credits", _("translator-credits"), NULL); if (pixbuf) g_object_unref (pixbuf); dialog->dialog = widget; g_object_add_weak_pointer (G_OBJECT (widget), (gpointer) &dialog); g_signal_connect (widget, "response", G_CALLBACK (gtk_widget_destroy), NULL); g_signal_connect (widget, "map", G_CALLBACK (about_dialog_map), dialog); g_signal_connect (widget, "unmap", G_CALLBACK (about_dialog_unmap), dialog); /* kids, don't try this at home! */ container = GTK_DIALOG (widget)->vbox; children = gtk_container_get_children (GTK_CONTAINER (container)); if (GTK_IS_VBOX (children->data)) { about_dialog_add_animation (children->data, dialog); about_dialog_add_message (children->data); } else g_warning ("%s: ooops, no vbox in this container?", G_STRLOC); g_list_free (children); } gtk_window_present (GTK_WINDOW (dialog->dialog)); return dialog->dialog; }
static gboolean gimp_help_browser (Gimp *gimp) { static gboolean busy = FALSE; GimpProcedure *procedure; if (busy) return TRUE; busy = TRUE; /* Check if a help browser is already running */ procedure = gimp_pdb_lookup_procedure (gimp->pdb, "extension-gimp-help-browser-temp"); if (! procedure) { GValueArray *args = NULL; gint n_domains = 0; gchar **help_domains = NULL; gchar **help_uris = NULL; procedure = gimp_pdb_lookup_procedure (gimp->pdb, "extension-gimp-help-browser"); if (! procedure) { gimp_help_browser_error (gimp, _("Help browser not found"), _("Could not find GIMP help browser."), _("The GIMP help browser plug-in appears " "to be missing from your installation.")); busy = FALSE; return FALSE; } n_domains = gimp_plug_in_manager_get_help_domains (gimp->plug_in_manager, &help_domains, &help_uris); args = gimp_procedure_get_arguments (procedure); gimp_value_array_truncate (args, 5); g_value_set_int (&args->values[0], GIMP_RUN_INTERACTIVE); g_value_set_int (&args->values[1], n_domains); gimp_value_take_stringarray (&args->values[2], help_domains, n_domains); g_value_set_int (&args->values[3], n_domains); gimp_value_take_stringarray (&args->values[4], help_uris, n_domains); gimp_procedure_execute_async (procedure, gimp, gimp_get_user_context (gimp), NULL, args, NULL); g_value_array_free (args); } /* Check if the help browser started properly */ procedure = gimp_pdb_lookup_procedure (gimp->pdb, "extension-gimp-help-browser-temp"); if (! procedure) { gimp_help_browser_error (gimp, _("Help browser doesn't start"), _("Could not start the GIMP help browser plug-in."), NULL); busy = FALSE; return FALSE; } busy = FALSE; return TRUE; }
/** * file_open_thumbnail: * @gimp: * @context: * @progress: * @uri: the URI of the image file * @size: requested size of the thumbnail * @mime_type: return location for image MIME type * @image_width: return location for image width * @image_height: return location for image height * @type: return location for image type (set to -1 if unknown) * @num_layers: return location for number of layers * (set to -1 if the number of layers is not known) * @error: * * Attempts to load a thumbnail by using a registered thumbnail loader. * * Return value: the thumbnail image */ GimpImage * file_open_thumbnail (Gimp *gimp, GimpContext *context, GimpProgress *progress, const gchar *uri, gint size, const gchar **mime_type, gint *image_width, gint *image_height, GimpImageType *type, gint *num_layers, GError **error) { GimpPlugInProcedure *file_proc; GimpProcedure *procedure; 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 (mime_type != NULL, NULL); g_return_val_if_fail (image_width != NULL, NULL); g_return_val_if_fail (image_height != NULL, NULL); g_return_val_if_fail (type != NULL, NULL); g_return_val_if_fail (num_layers != NULL, NULL); g_return_val_if_fail (error == NULL || *error == NULL, NULL); *image_width = 0; *image_height = 0; *type = -1; *num_layers = -1; file_proc = file_procedure_find (gimp->plug_in_manager->load_procs, uri, NULL); if (! file_proc || ! file_proc->thumb_loader) return NULL; procedure = gimp_pdb_lookup_procedure (gimp->pdb, file_proc->thumb_loader); if (procedure && procedure->num_args >= 2 && procedure->num_values >= 1) { GimpPDBStatusType status; GValueArray *return_vals; gchar *filename; GimpImage *image = NULL; filename = file_utils_filename_from_uri (uri); if (! filename) filename = g_strdup (uri); return_vals = gimp_pdb_execute_procedure_by_name (gimp->pdb, context, progress, error, gimp_object_get_name (procedure), G_TYPE_STRING, filename, GIMP_TYPE_INT32, size, G_TYPE_NONE); g_free (filename); status = g_value_get_enum (&return_vals->values[0]); if (status == GIMP_PDB_SUCCESS && GIMP_VALUE_HOLDS_IMAGE_ID (&return_vals->values[1])) { image = gimp_value_get_image (&return_vals->values[1], gimp); if (return_vals->n_values >= 3 && G_VALUE_HOLDS_INT (&return_vals->values[2]) && G_VALUE_HOLDS_INT (&return_vals->values[3])) { *image_width = MAX (0, g_value_get_int (&return_vals->values[2])); *image_height = MAX (0, g_value_get_int (&return_vals->values[3])); if (return_vals->n_values >= 5 && G_VALUE_HOLDS_INT (&return_vals->values[4])) { gint value = g_value_get_int (&return_vals->values[4]); if (gimp_enum_get_value (GIMP_TYPE_IMAGE_TYPE, value, NULL, NULL, NULL, NULL)) { *type = value; } } if (return_vals->n_values >= 6 && G_VALUE_HOLDS_INT (&return_vals->values[5])) { *num_layers = MAX (0, g_value_get_int (&return_vals->values[5])); } } if (image) { file_open_sanitize_image (image, FALSE); *mime_type = file_proc->mime_type; #ifdef GIMP_UNSTABLE g_printerr ("opened thumbnail at %d x %d\n", gimp_image_get_width (image), gimp_image_get_height (image)); #endif } } g_value_array_free (return_vals); return image; } return NULL; }
static GimpValueArray * procedural_db_proc_val_invoker (GimpProcedure *procedure, Gimp *gimp, GimpContext *context, GimpProgress *progress, const GimpValueArray *args, GError **error) { gboolean success = TRUE; GimpValueArray *return_vals; const gchar *procedure_name; gint32 val_num; gint32 val_type = 0; gchar *val_name = NULL; gchar *val_desc = NULL; procedure_name = g_value_get_string (gimp_value_array_index (args, 0)); val_num = g_value_get_int (gimp_value_array_index (args, 1)); if (success) { GimpProcedure *proc; gchar *canonical; canonical = gimp_canonicalize_identifier (procedure_name); proc = gimp_pdb_lookup_procedure (gimp->pdb, canonical); if (! proc) { const gchar *compat_name; compat_name = gimp_pdb_lookup_compat_proc_name (gimp->pdb, canonical); if (compat_name) proc = gimp_pdb_lookup_procedure (gimp->pdb, compat_name); } g_free (canonical); if (proc && (val_num >= 0 && val_num < proc->num_values)) { GParamSpec *pspec = proc->values[val_num]; val_type = gimp_pdb_compat_arg_type_from_gtype (G_PARAM_SPEC_VALUE_TYPE (pspec)); val_name = g_strdup (g_param_spec_get_name (pspec)); val_desc = gimp_param_spec_get_desc (pspec); } else success = FALSE; } return_vals = gimp_procedure_get_return_values (procedure, success, error ? *error : NULL); if (success) { g_value_set_enum (gimp_value_array_index (return_vals, 1), val_type); g_value_take_string (gimp_value_array_index (return_vals, 2), val_name); g_value_take_string (gimp_value_array_index (return_vals, 3), val_desc); } return return_vals; }
static void gimp_help_call (Gimp *gimp, const gchar *procedure_name, const gchar *help_domain, const gchar *help_locales, const gchar *help_id) { GimpProcedure *procedure; /* Special case the help browser */ if (! strcmp (procedure_name, "extension-gimp-help-browser-temp")) { GValueArray *return_vals; return_vals = gimp_pdb_execute_procedure_by_name (gimp->pdb, gimp_get_user_context (gimp), NULL, procedure_name, G_TYPE_STRING, help_domain, G_TYPE_STRING, help_locales, G_TYPE_STRING, help_id, G_TYPE_NONE); g_value_array_free (return_vals); return; } /* Check if a help parser is already running */ procedure = gimp_pdb_lookup_procedure (gimp->pdb, "extension-gimp-help-temp"); if (! procedure) { GValueArray *args = NULL; gint n_domains = 0; gchar **help_domains = NULL; gchar **help_uris = NULL; procedure = gimp_pdb_lookup_procedure (gimp->pdb, "extension-gimp-help"); if (! procedure) /* FIXME: error msg */ return; n_domains = gimp_plug_in_manager_get_help_domains (gimp->plug_in_manager, &help_domains, &help_uris); args = gimp_procedure_get_arguments (procedure); gimp_value_array_truncate (args, 4); g_value_set_int (&args->values[0], n_domains); gimp_value_take_stringarray (&args->values[1], help_domains, n_domains); g_value_set_int (&args->values[2], n_domains); gimp_value_take_stringarray (&args->values[3], help_uris, n_domains); gimp_procedure_execute_async (procedure, gimp, gimp_get_user_context (gimp), NULL, args, NULL); g_value_array_free (args); } /* Check if the help parser started properly */ procedure = gimp_pdb_lookup_procedure (gimp->pdb, "extension-gimp-help-temp"); if (procedure) { GValueArray *return_vals; #ifdef GIMP_HELP_DEBUG g_printerr ("Calling help via %s: %s %s %s\n", procedure_name, help_domain ? help_domain : "(null)", help_locales ? help_locales : "(null)", help_id ? help_id : "(null)"); #endif return_vals = gimp_pdb_execute_procedure_by_name (gimp->pdb, gimp_get_user_context (gimp), NULL, "extension-gimp-help-temp", G_TYPE_STRING, procedure_name, G_TYPE_STRING, help_domain, G_TYPE_STRING, help_locales, G_TYPE_STRING, help_id, G_TYPE_NONE); g_value_array_free (return_vals); } }
GtkWidget * gimp_file_dialog_new (Gimp *gimp, GtkFileChooserAction action, const gchar *title, const gchar *role, const gchar *stock_id, const gchar *help_id) { GimpFileDialog *dialog; GSList *file_procs; const gchar *automatic; const gchar *automatic_help_id; const gchar *pictures; gboolean local_only; g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL); g_return_val_if_fail (title != NULL, NULL); g_return_val_if_fail (role != NULL, NULL); g_return_val_if_fail (stock_id != NULL, NULL); g_return_val_if_fail (help_id != NULL, NULL); switch (action) { case GTK_FILE_CHOOSER_ACTION_OPEN: file_procs = gimp->plug_in_manager->load_procs; automatic = _("Automatically Detected"); automatic_help_id = GIMP_HELP_FILE_OPEN_BY_EXTENSION; /* FIXME */ local_only = (gimp_pdb_lookup_procedure (gimp->pdb, "file-uri-load") == NULL); break; case GTK_FILE_CHOOSER_ACTION_SAVE: file_procs = gimp->plug_in_manager->save_procs; automatic = _("By Extension"); automatic_help_id = GIMP_HELP_FILE_SAVE_BY_EXTENSION; /* FIXME */ local_only = (gimp_pdb_lookup_procedure (gimp->pdb, "file-uri-save") == NULL); break; default: g_return_val_if_reached (NULL); return NULL; } dialog = g_object_new (GIMP_TYPE_FILE_DIALOG, "title", title, "role", role, "action", action, "local-only", local_only, "do-overwrite-confirmation", TRUE, NULL); gtk_dialog_add_buttons (GTK_DIALOG (dialog), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, stock_id, GTK_RESPONSE_OK, NULL); gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK); gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); gimp_help_connect (GTK_WIDGET (dialog), gimp_file_dialog_help_func, help_id, dialog); if (GIMP_GUI_CONFIG (gimp->config)->show_help_button && help_id) { GtkWidget *action_area = GTK_DIALOG (dialog)->action_area; GtkWidget *button = gtk_button_new_from_stock (GTK_STOCK_HELP); gtk_box_pack_end (GTK_BOX (action_area), button, FALSE, TRUE, 0); gtk_button_box_set_child_secondary (GTK_BUTTON_BOX (action_area), button, TRUE); gtk_widget_show (button); g_object_set_data_full (G_OBJECT (dialog), "gimp-dialog-help-id", g_strdup (help_id), (GDestroyNotify) g_free); g_signal_connect (button, "clicked", G_CALLBACK (gimp_file_dialog_help_clicked), dialog); g_object_set_data (G_OBJECT (dialog), "gimp-dialog-help-button", button); } pictures = gimp_user_directory (GIMP_USER_DIRECTORY_PICTURES); if (pictures) gtk_file_chooser_add_shortcut_folder (GTK_FILE_CHOOSER (dialog), pictures, NULL); gimp_file_dialog_add_preview (dialog, gimp); gimp_file_dialog_add_filters (dialog, gimp, file_procs); gimp_file_dialog_add_proc_selection (dialog, gimp, file_procs, automatic, automatic_help_id); dialog->progress = gimp_progress_box_new (); gtk_box_pack_end (GTK_BOX (GTK_DIALOG (dialog)->vbox), dialog->progress, FALSE, FALSE, 0); return GTK_WIDGET (dialog); }