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);
}
}
