static void gimp_plug_in_handle_proc_error (GimpPlugIn *plug_in, GimpPlugInProcFrame *proc_frame, const gchar *name, const GError *error) { switch (proc_frame->error_handler) { case GIMP_PDB_ERROR_HANDLER_INTERNAL: if (error->domain == GIMP_PDB_ERROR) { gimp_message (plug_in->manager->gimp, G_OBJECT (proc_frame->progress), GIMP_MESSAGE_ERROR, _("Calling error for procedure '%s':\n" "%s"), name, error->message); } else { gimp_message (plug_in->manager->gimp, G_OBJECT (proc_frame->progress), GIMP_MESSAGE_ERROR, _("Execution error for procedure '%s':\n" "%s"), name, error->message); } break; case GIMP_PDB_ERROR_HANDLER_PLUGIN: /* the plug-in is responsible for handling this error */ break; } }
static void preview_specular_only(gint32 image_ID) { gint32 drawableSpecular_ID = -1; gint32 nResult = 0; preview_ambient_occlusion_only(image_ID); if(local_vals.EdgeSpecular) { gtk_label_set_text(GTK_LABEL(progress_label), "Specular Edging"); drawableSpecular_ID = specularEdgeWorker(image_ID, local_vals.defSpecular, local_vals.ao, FALSE); if (drawableSpecular_ID == -1) { gimp_message("Specular Edge Worker returned -1!"); nResult = 0; } else nResult = 1; } else { gtk_label_set_text(GTK_LABEL(progress_label), "Specular Smoothing"); drawableSpecular_ID = specularSmoothWorker(image_ID, local_vals.defSpecular, local_vals.ao, FALSE); if (drawableSpecular_ID == -1) { gimp_message("Specular Smooth Worker returned -1!"); nResult = 0; } else nResult = 1; } gtk_label_set_text(GTK_LABEL(progress_label), "Idle..."); gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(progress), 1.0); if (nResult == 1) { pDrawables.drawable_s = gimp_drawable_get(drawableSpecular_ID); } else { pDrawables.drawable_s = NULL; } }
gboolean gimp_plug_in_manager_register_save_handler (GimpPlugInManager *manager, const gchar *name, const gchar *extensions, const gchar *prefixes) { GimpPlugInProcedure *file_proc; GimpProcedure *procedure; GSList *list; g_return_val_if_fail (GIMP_IS_PLUG_IN_MANAGER (manager), FALSE); g_return_val_if_fail (name != NULL, FALSE); if (manager->current_plug_in && manager->current_plug_in->plug_in_def) list = manager->current_plug_in->plug_in_def->procedures; else list = manager->plug_in_procedures; file_proc = gimp_plug_in_procedure_find (list, name); if (! file_proc) { gimp_message (manager->gimp, NULL, GIMP_MESSAGE_ERROR, "attempt to register nonexistent save handler \"%s\"", name); return FALSE; } procedure = GIMP_PROCEDURE (file_proc); if ((procedure->num_args < 5) || ! GIMP_IS_PARAM_SPEC_INT32 (procedure->args[0]) || ! GIMP_IS_PARAM_SPEC_IMAGE_ID (procedure->args[1]) || ! GIMP_IS_PARAM_SPEC_DRAWABLE_ID (procedure->args[2]) || ! G_IS_PARAM_SPEC_STRING (procedure->args[3]) || ! G_IS_PARAM_SPEC_STRING (procedure->args[4])) { gimp_message (manager->gimp, NULL, GIMP_MESSAGE_ERROR, "save handler \"%s\" does not take the standard " "save handler args", name); return FALSE; } gimp_plug_in_procedure_set_file_proc (file_proc, extensions, prefixes, NULL); if (file_procedure_in_group (file_proc, FILE_PROCEDURE_GROUP_SAVE)) { if (! g_slist_find (manager->save_procs, file_proc)) manager->save_procs = g_slist_prepend (manager->save_procs, file_proc); } if (file_procedure_in_group (file_proc, FILE_PROCEDURE_GROUP_EXPORT)) { if (! g_slist_find (manager->export_procs, file_proc)) manager->export_procs = g_slist_prepend (manager->export_procs, file_proc); } return TRUE; }
void gimp_controllers_restore (Gimp *gimp, GimpUIManager *ui_manager) { GimpControllerManager *manager; gchar *filename; GError *error = NULL; g_return_if_fail (GIMP_IS_GIMP (gimp)); g_return_if_fail (GIMP_IS_UI_MANAGER (ui_manager)); manager = gimp_controller_manager_get (gimp); g_return_if_fail (manager != NULL); g_return_if_fail (manager->ui_manager == NULL); manager->ui_manager = g_object_ref (ui_manager); filename = gimp_personal_rc_file ("controllerrc"); if (gimp->be_verbose) g_print ("Parsing '%s'\n", gimp_filename_to_utf8 (filename)); if (! gimp_config_deserialize_file (GIMP_CONFIG (manager->controllers), filename, NULL, &error)) { if (error->code == GIMP_CONFIG_ERROR_OPEN_ENOENT) { g_clear_error (&error); g_free (filename); filename = g_build_filename (gimp_sysconf_directory (), "controllerrc", NULL); if (! gimp_config_deserialize_file (GIMP_CONFIG (manager->controllers), filename, NULL, &error)) { gimp_message (gimp, NULL, GIMP_MESSAGE_ERROR, "%s", error->message); } } else { gimp_message (gimp, NULL, GIMP_MESSAGE_ERROR, "%s", error->message); } g_clear_error (&error); } gimp_list_reverse (GIMP_LIST (manager->controllers)); g_free (filename); }
gboolean gimp_plug_in_manager_register_load_handler (GimpPlugInManager *manager, const gchar *name, const gchar *extensions, const gchar *prefixes, const gchar *magics) { GimpPlugInProcedure *file_proc; GimpProcedure *procedure; GSList *list; g_return_val_if_fail (GIMP_IS_PLUG_IN_MANAGER (manager), FALSE); g_return_val_if_fail (name != NULL, FALSE); if (manager->current_plug_in && manager->current_plug_in->plug_in_def) list = manager->current_plug_in->plug_in_def->procedures; else list = manager->plug_in_procedures; file_proc = gimp_plug_in_procedure_find (list, name); if (! file_proc) { gimp_message (manager->gimp, NULL, GIMP_MESSAGE_ERROR, "attempt to register nonexistent load handler \"%s\"", name); return FALSE; } procedure = GIMP_PROCEDURE (file_proc); if ((procedure->num_args < 3) || (procedure->num_values < 1) || ! GIMP_IS_PARAM_SPEC_INT32 (procedure->args[0]) || ! G_IS_PARAM_SPEC_STRING (procedure->args[1]) || ! G_IS_PARAM_SPEC_STRING (procedure->args[2]) || ! GIMP_IS_PARAM_SPEC_IMAGE_ID (procedure->values[0])) { gimp_message (manager->gimp, NULL, GIMP_MESSAGE_ERROR, "load handler \"%s\" does not take the standard " "load handler args", name); return FALSE; } gimp_plug_in_procedure_set_file_proc (file_proc, extensions, prefixes, magics); if (! g_slist_find (manager->load_procs, file_proc)) manager->load_procs = g_slist_prepend (manager->load_procs, file_proc); return TRUE; }
void vectors_selection_to_vectors_cmd_callback (GtkAction *action, gint value, gpointer data) { GimpImage *image; GtkWidget *widget; GimpProcedure *procedure; GValueArray *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 (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 (&args->values[0], GIMP_RUN_INTERACTIVE); gimp_value_set_image (&args->values[1], image); gimp_procedure_execute_async (procedure, image->gimp, action_data_get_context (data), GIMP_PROGRESS (display), args, GIMP_OBJECT (display), &error); g_value_array_free (args); if (error) { gimp_message (image->gimp, G_OBJECT (widget), GIMP_MESSAGE_ERROR, "%s", error->message); g_error_free (error); } }
static GimpImage * file_open_dialog_open_image (GtkWidget *open_dialog, Gimp *gimp, const gchar *uri, GimpPlugInProcedure *load_proc) { GimpImage *image; GimpPDBStatusType status; GError *error = NULL; image = file_open_with_proc_and_display (gimp, gimp_get_user_context (gimp), GIMP_PROGRESS (open_dialog), uri, uri, FALSE, load_proc, &status, &error); if (! image && status != GIMP_PDB_CANCEL) { gchar *filename = file_utils_uri_display_name (uri); gimp_message (gimp, G_OBJECT (open_dialog), GIMP_MESSAGE_ERROR, _("Opening '%s' failed:\n\n%s"), filename, error->message); g_clear_error (&error); g_free (filename); } return image; }
static void vectors_export_response (GtkWidget *widget, gint response_id, VectorsExportDialog *dialog) { if (response_id == GTK_RESPONSE_OK) { GimpVectors *vectors = NULL; gchar *filename; GError *error = NULL; vectors_export_active_only = dialog->active_only; filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (widget)); if (vectors_export_active_only) vectors = gimp_image_get_active_vectors (dialog->image); if (! gimp_vectors_export_file (dialog->image, vectors, filename, &error)) { gimp_message (dialog->image->gimp, G_OBJECT (widget), GIMP_MESSAGE_ERROR, "%s", error->message); g_error_free (error); return; } g_free (filename); } gtk_widget_destroy (widget); }
static void vectors_import_response (GtkWidget *widget, gint response_id, VectorsImportDialog *dialog) { if (response_id == GTK_RESPONSE_OK) { gchar *filename; GError *error = NULL; vectors_import_merge = dialog->merge_vectors; vectors_import_scale = dialog->scale_vectors; filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (widget)); if (gimp_vectors_import_file (dialog->image, filename, vectors_import_merge, vectors_import_scale, -1, NULL, &error)) { gimp_image_flush (dialog->image); } else { gimp_message (dialog->image->gimp, G_OBJECT (widget), GIMP_MESSAGE_ERROR, "%s", error->message); g_error_free (error); return; } g_free (filename); } gtk_widget_destroy (widget); }
/* * Prints An Error Message */ void error ( const gchar *prod, const gchar *format, ... ) { GimpMessageHandlerType t; gchar *message, *str; va_list ap; if ( format == NULL ) return; str = ( gchar * ) g_malloc ( 512 ); message = (gchar *) g_malloc ( 512 ); t = gimp_message_get_handler ( ); gimp_message_set_handler ( GIMP_ERROR_CONSOLE ); va_start ( ap, format ); g_vsnprintf ( message, 512, format, ap ); va_end ( ap ); if ( prod != NULL ) g_snprintf ( str, 512, _("error in %s(): %s.\n"), prod, message ); else g_snprintf ( str, 512, _("error: %s.\n"), message ); gimp_message ( str ); gimp_message_set_handler ( t ); g_free ( message ); g_free ( str ); }
void tool_presets_save_cmd_callback (GtkAction *action, gpointer data) { GimpContainerEditor *editor = GIMP_CONTAINER_EDITOR (data); GimpContext *context; GimpToolPreset *preset; GimpToolInfo *tool_info; context = gimp_container_view_get_context (editor->view); preset = gimp_context_get_tool_preset (context); tool_info = gimp_context_get_tool (gimp_get_user_context (context->gimp)); if (tool_info && preset) { GimpToolInfo *preset_tool; preset_tool = gimp_context_get_tool (GIMP_CONTEXT (preset->tool_options)); if (tool_info != preset_tool) { gimp_message (context->gimp, G_OBJECT (editor), GIMP_MESSAGE_WARNING, _("Can't save '%s' tool options to an " "existing '%s' tool preset."), tool_info->blurb, preset_tool->blurb); return; } gimp_config_sync (G_OBJECT (tool_info->tool_options), G_OBJECT (preset->tool_options), 0); } }
void documents_show_in_file_manager_cmd_callback (GtkAction *action, gpointer data) { GimpContainerEditor *editor = GIMP_CONTAINER_EDITOR (data); GimpContext *context; GimpImagefile *imagefile; context = gimp_container_view_get_context (editor->view); imagefile = gimp_context_get_imagefile (context); if (imagefile) { GFile *file = g_file_new_for_uri (gimp_object_get_name (imagefile)); GError *error = NULL; if (! gimp_file_show_in_file_manager (file, &error)) { gimp_message (context->gimp, G_OBJECT (editor), GIMP_MESSAGE_ERROR, _("Can't show file in file manager: %s"), error->message); g_clear_error (&error); } g_object_unref (file); } }
static void documents_open_image (GtkWidget *editor, GimpContext *context, GimpImagefile *imagefile) { const gchar *uri; GimpImage *image; GimpPDBStatusType status; GError *error = NULL; uri = gimp_object_get_name (imagefile); image = file_open_with_display (context->gimp, context, NULL, uri, FALSE, &status, &error); if (! image && status != GIMP_PDB_CANCEL) { gchar *filename = file_utils_uri_display_name (uri); gimp_message (context->gimp, G_OBJECT (editor), GIMP_MESSAGE_ERROR, _("Opening '%s' failed:\n\n%s"), filename, error->message); g_clear_error (&error); g_free (filename); } }
static void gimp_plug_in_handle_temp_proc_return (GimpPlugIn *plug_in, GPProcReturn *proc_return) { g_return_if_fail (proc_return != NULL); if (plug_in->temp_proc_frames) { GimpPlugInProcFrame *proc_frame = plug_in->temp_proc_frames->data; 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); gimp_plug_in_main_loop_quit (plug_in); gimp_plug_in_proc_frame_pop (plug_in); } else { gimp_message (plug_in->manager->gimp, NULL, GIMP_MESSAGE_ERROR, "Plug-In \"%s\"\n(%s)\n\n" "sent a TEMP_PROC_RETURN message while not running " "a temporary procedure. This should not happen.", gimp_object_get_name (plug_in), gimp_file_get_utf8_name (plug_in->file)); gimp_plug_in_close (plug_in, TRUE); } }
static void documents_open_image (GtkWidget *editor, GimpContext *context, GimpImagefile *imagefile) { GFile *file; GimpImage *image; GimpPDBStatusType status; GError *error = NULL; file = gimp_imagefile_get_file (imagefile); image = file_open_with_display (context->gimp, context, NULL, file, FALSE, G_OBJECT (gtk_widget_get_screen (editor)), gimp_widget_get_monitor (editor), &status, &error); if (! image && status != GIMP_PDB_CANCEL) { gimp_message (context->gimp, G_OBJECT (editor), GIMP_MESSAGE_ERROR, _("Opening '%s' failed:\n\n%s"), gimp_file_get_utf8_name (file), error->message); g_clear_error (&error); } }
static void text_tool_load_dialog_response (GtkWidget *dialog, gint response_id, GimpTextTool *tool) { if (response_id == GTK_RESPONSE_OK) { gchar *filename; GError *error = NULL; filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog)); if (! gimp_text_buffer_load (tool->buffer, filename, &error)) { gimp_message (GIMP_TOOL (tool)->tool_info->gimp, G_OBJECT (dialog), GIMP_MESSAGE_ERROR, _("Could not open '%s' for reading: %s"), gimp_filename_to_utf8 (filename), error->message); g_clear_error (&error); g_free (filename); return; } g_free (filename); } gtk_widget_hide (dialog); }
void dialogs_save_recent_docks (Gimp *gimp) { gchar *filename; GError *error = NULL; g_return_if_fail (GIMP_IS_GIMP (gimp)); filename = gimp_personal_rc_file ("dockrc"); if (gimp->be_verbose) g_print ("Writing '%s'\n", gimp_filename_to_utf8 (filename)); if (! gimp_config_serialize_to_file (GIMP_CONFIG (global_recent_docks), filename, "recently closed docks", "end of recently closed docks", NULL, &error)) { gimp_message (gimp, NULL, GIMP_MESSAGE_ERROR, "%s", error->message); g_clear_error (&error); } g_free (filename); }
static GimpImage * file_open_dialog_open_image (GtkWidget *dialog, Gimp *gimp, GFile *file, GimpPlugInProcedure *load_proc) { GimpImage *image; GimpPDBStatusType status; GError *error = NULL; image = file_open_with_proc_and_display (gimp, gimp_get_user_context (gimp), GIMP_PROGRESS (dialog), file, file, FALSE, load_proc, G_OBJECT (gtk_widget_get_screen (dialog)), gimp_widget_get_monitor (dialog), &status, &error); if (! image && status != GIMP_PDB_CANCEL) { gimp_message (gimp, G_OBJECT (dialog), GIMP_MESSAGE_ERROR, _("Opening '%s' failed:\n\n%s"), gimp_file_get_utf8_name (file), error->message); g_clear_error (&error); } return image; }
/* A function that puts the images from the model inside the * images (pages) array */ static gboolean get_image_list (void) { GtkTreeIter iter; gboolean valid = gtk_tree_model_get_iter_first (model, &iter); gint32 image; multi_page.image_count = 0; if (!valid) { gimp_message (_("Error! In order to save the file, at least one image should be added!")); return FALSE; } while (valid) { gtk_tree_model_get (model, &iter, IMAGE_ID, &image, -1); multi_page.images[multi_page.image_count] = image; valid = gtk_tree_model_iter_next (model, &iter); multi_page.image_count++; } return TRUE; }
void dialogs_load_recent_docks (Gimp *gimp) { gchar *filename; GError *error = NULL; g_return_if_fail (GIMP_IS_GIMP (gimp)); filename = gimp_personal_rc_file ("dockrc"); if (gimp->be_verbose) g_print ("Parsing '%s'\n", gimp_filename_to_utf8 (filename)); if (! gimp_config_deserialize_file (GIMP_CONFIG (global_recent_docks), filename, NULL, &error)) { if (error->code != GIMP_CONFIG_ERROR_OPEN_ENOENT) gimp_message (gimp, NULL, GIMP_MESSAGE_ERROR, "%s", error->message); g_clear_error (&error); } gimp_list_reverse (GIMP_LIST (global_recent_docks)); g_free (filename); }
static void gimp_display_shell_drop_svg (GtkWidget *widget, gint x, gint y, const guchar *svg_data, gsize svg_data_len, gpointer data) { GimpDisplayShell *shell = GIMP_DISPLAY_SHELL (data); GimpImage *image = shell->display->image; GError *error = NULL; GIMP_LOG (DND, NULL); if (shell->display->gimp->busy) return; if (! image) return; if (! gimp_vectors_import_buffer (image, (const gchar *) svg_data, svg_data_len, TRUE, TRUE, -1, NULL, &error)) { gimp_message (shell->display->gimp, G_OBJECT (shell->display), GIMP_MESSAGE_ERROR, "%s", error->message); g_clear_error (&error); } else { gimp_display_shell_dnd_flush (shell, image); } }
void vectors_paste_cmd_callback (GtkAction *action, gpointer data) { GimpImage *image; GtkWidget *widget; gchar *svg; gsize svg_size; return_if_no_image (image, data); return_if_no_widget (widget, data); svg = gimp_clipboard_get_svg (image->gimp, &svg_size); if (svg) { GError *error = NULL; if (! gimp_vectors_import_buffer (image, svg, svg_size, TRUE, FALSE, GIMP_IMAGE_ACTIVE_PARENT, -1, NULL, &error)) { gimp_message (image->gimp, G_OBJECT (widget), GIMP_MESSAGE_ERROR, "%s", error->message); g_clear_error (&error); } else { gimp_image_flush (image); } g_free (svg); } }
void select_stroke_cmd_callback (GtkAction *action, gpointer data) { GimpImage *image; GimpDrawable *drawable; GtkWidget *widget; GtkWidget *dialog; return_if_no_image (image, data); return_if_no_widget (widget, data); drawable = gimp_image_get_active_drawable (image); if (! drawable) { gimp_message (image->gimp, G_OBJECT (widget), GIMP_MESSAGE_WARNING, _("There is no active layer or channel to stroke to.")); return; } dialog = stroke_dialog_new (GIMP_ITEM (gimp_image_get_mask (image)), action_data_get_context (data), _("Stroke Selection"), GIMP_STOCK_SELECTION_STROKE, GIMP_HELP_SELECTION_STROKE, widget); gtk_widget_show (dialog); }
static void error_console_save_response (GtkWidget *dialog, gint response_id, GimpErrorConsole *console) { if (response_id == GTK_RESPONSE_OK) { GError *error = NULL; gchar *filename; filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog)); if (! gimp_text_buffer_save (console->text_buffer, filename, console->save_selection, &error)) { gimp_message (console->gimp, G_OBJECT (dialog), GIMP_MESSAGE_ERROR, _("Error writing file '%s':\n%s"), gimp_filename_to_utf8 (filename), error->message); g_clear_error (&error); g_free (filename); return; } g_free (filename); } gtk_widget_destroy (dialog); }
void gimp_plug_in_procedure_handle_return_values (GimpPlugInProcedure *proc, Gimp *gimp, GimpProgress *progress, GimpValueArray *return_vals) { g_return_if_fail (GIMP_IS_PLUG_IN_PROCEDURE (proc)); g_return_if_fail (return_vals != NULL); if (! gimp_value_array_length (return_vals) > 0 || G_VALUE_TYPE (gimp_value_array_index (return_vals, 0)) != GIMP_TYPE_PDB_STATUS_TYPE) { return; } switch (g_value_get_enum (gimp_value_array_index (return_vals, 0))) { case GIMP_PDB_SUCCESS: break; case GIMP_PDB_CALLING_ERROR: if (gimp_value_array_length (return_vals) > 1 && G_VALUE_HOLDS_STRING (gimp_value_array_index (return_vals, 1))) { gimp_message (gimp, G_OBJECT (progress), GIMP_MESSAGE_ERROR, _("Calling error for '%s':\n" "%s"), gimp_plug_in_procedure_get_label (proc), g_value_get_string (gimp_value_array_index (return_vals, 1))); } break; case GIMP_PDB_EXECUTION_ERROR: if (gimp_value_array_length (return_vals) > 1 && G_VALUE_HOLDS_STRING (gimp_value_array_index (return_vals, 1))) { gimp_message (gimp, G_OBJECT (progress), GIMP_MESSAGE_ERROR, _("Execution error for '%s':\n" "%s"), gimp_plug_in_procedure_get_label (proc), g_value_get_string (gimp_value_array_index (return_vals, 1))); } break; } }
void vectors_stroke_last_vals_cmd_callback (GtkAction *action, gpointer data) { GimpImage *image; GimpVectors *vectors; GimpDrawable *drawable; GimpContext *context; GtkWidget *widget; GimpStrokeDesc *desc; GError *error = NULL; return_if_no_vectors (image, vectors, data); return_if_no_context (context, data); return_if_no_widget (widget, data); drawable = gimp_image_get_active_drawable (image); if (! drawable) { gimp_message (image->gimp, G_OBJECT (widget), GIMP_MESSAGE_WARNING, _("There is no active layer or channel to stroke to.")); return; } desc = g_object_get_data (G_OBJECT (image->gimp), "saved-stroke-desc"); if (desc) g_object_ref (desc); else desc = gimp_stroke_desc_new (image->gimp, context); if (! gimp_item_stroke (GIMP_ITEM (vectors), drawable, context, desc, FALSE, NULL, &error)) { gimp_message (image->gimp, G_OBJECT (widget), GIMP_MESSAGE_WARNING, "%s", error->message); g_clear_error (&error); } else { gimp_image_flush (image); } g_object_unref (desc); }
void PrintErrorIntern( char* fmt, va_list ap) { char message[255]; vsprintf(message, fmt, ap); gimp_message (message); }
/* This function is called for filenames passed on the command-line * or from the D-Bus service. */ gboolean file_open_from_command_line (Gimp *gimp, const gchar *filename, gboolean as_new) { GError *error = NULL; gchar *uri; gboolean success = FALSE; g_return_val_if_fail (GIMP_IS_GIMP (gimp), FALSE); g_return_val_if_fail (filename != NULL, FALSE); /* we accept URI or filename */ uri = file_utils_any_to_uri (gimp, filename, &error); if (uri) { GimpImage *image; GimpObject *display = gimp_get_empty_display (gimp); GimpPDBStatusType status; image = file_open_with_display (gimp, gimp_get_user_context (gimp), GIMP_PROGRESS (display), uri, as_new, &status, &error); if (image) { success = TRUE; g_object_set_data_full (G_OBJECT (gimp), GIMP_FILE_OPEN_LAST_URI_KEY, uri, (GDestroyNotify) g_free); } else if (status != GIMP_PDB_CANCEL) { gchar *filename = file_utils_uri_display_name (uri); gimp_message (gimp, G_OBJECT (display), GIMP_MESSAGE_ERROR, _("Opening '%s' failed: %s"), filename, error->message); g_clear_error (&error); g_free (filename); g_free (uri); } } else { g_printerr ("conversion filename -> uri failed: %s\n", error->message); g_clear_error (&error); } return success; }
void floating_sel_to_layer (GimpLayer *layer) { GimpItem *item; GimpImage *image; g_return_if_fail (GIMP_IS_LAYER (layer)); g_return_if_fail (gimp_layer_is_floating_sel (layer)); item = GIMP_ITEM (layer); if (! (image = gimp_item_get_image (item))) return; /* Check if the floating layer belongs to a channel... */ if (GIMP_IS_CHANNEL (layer->fs.drawable)) { gimp_message (image->gimp, NULL, GIMP_MESSAGE_WARNING, _("Cannot create a new layer from the floating selection " "because it belongs to a layer mask or channel.")); return; } gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_FS_TO_LAYER, _("Floating Selection to Layer")); /* restore the contents of the drawable */ floating_sel_restore (layer, item->offset_x, item->offset_y, item->width, item->height); gimp_image_undo_push_fs_to_layer (image, NULL, layer); /* clear the selection */ gimp_drawable_invalidate_boundary (GIMP_DRAWABLE (layer)); /* Set pointers */ layer->fs.drawable = NULL; image->floating_sel = NULL; gimp_item_set_visible (GIMP_ITEM (layer), TRUE, TRUE); gimp_layer_set_lock_alpha (layer, FALSE, TRUE); gimp_image_undo_group_end (image); gimp_object_name_changed (GIMP_OBJECT (layer)); gimp_drawable_update (GIMP_DRAWABLE (layer), 0, 0, GIMP_ITEM (layer)->width, GIMP_ITEM (layer)->height); gimp_image_floating_selection_changed (image); }
void file_open_recent_cmd_callback (GtkAction *action, gint value, gpointer data) { Gimp *gimp; GimpImagefile *imagefile; gint num_entries; return_if_no_gimp (gimp, data); num_entries = gimp_container_get_n_children (gimp->documents); if (value >= num_entries) return; imagefile = (GimpImagefile *) gimp_container_get_child_by_index (gimp->documents, value); if (imagefile) { GimpDisplay *display; GimpProgress *progress; GimpImage *image; GimpPDBStatusType status; GError *error = NULL; return_if_no_display (display, data); g_object_ref (display); g_object_ref (imagefile); progress = gimp_display_get_image (display) ? NULL : GIMP_PROGRESS (display); image = file_open_with_display (gimp, action_data_get_context (data), progress, gimp_object_get_name (imagefile), FALSE, &status, &error); if (! image && status != GIMP_PDB_CANCEL) { gchar *filename = file_utils_uri_display_name (gimp_object_get_name (imagefile)); gimp_message (gimp, G_OBJECT (display), GIMP_MESSAGE_ERROR, _("Opening '%s' failed:\n\n%s"), filename, error->message); g_clear_error (&error); g_free (filename); } g_object_unref (imagefile); g_object_unref (display); } }