static void
cm_save_file_response_callback (GtkWidget *dialog,
gint response_id,
CmParamsType *mix)
{
gchar *filename;
FILE *file = NULL;
if (response_id != GTK_RESPONSE_OK)
{
gtk_widget_hide (dialog);
return;
}
filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
if (! filename)
return;
file = g_fopen (filename, "wb");
if (! file)
{
g_message (_("Could not open '%s' for writing: %s"),
gimp_filename_to_utf8 (filename), g_strerror (errno));
g_free (filename);
return;
}
cm_save_file (mix, file);
g_message (_("Parameters were saved to '%s'"),
gimp_filename_to_utf8 (filename));
gtk_widget_hide (dialog);
}
/* read the pluginrc file for cached data */
static void
gimp_plug_in_manager_read_pluginrc (GimpPlugInManager *manager,
const gchar *pluginrc,
GimpInitStatusFunc status_callback)
{
GSList *rc_defs;
GError *error = NULL;
status_callback (_("Resource configuration"),
gimp_filename_to_utf8 (pluginrc), 0.0);
if (manager->gimp->be_verbose)
g_print ("Parsing '%s'\n", gimp_filename_to_utf8 (pluginrc));
rc_defs = plug_in_rc_parse (manager->gimp, pluginrc, &error);
if (rc_defs)
{
GSList *list;
for (list = rc_defs; list; list = g_slist_next (list))
gimp_plug_in_manager_add_from_rc (manager, list->data); /* consumes list->data */
g_slist_free (rc_defs);
}
else if (error)
{
if (error->code != GIMP_CONFIG_ERROR_OPEN_ENOENT)
gimp_message_literal (manager->gimp, NULL, GIMP_MESSAGE_ERROR,
error->message);
g_clear_error (&error);
}
}
/**
* gimp_config_writer_new_file:
* @filename: a filename
* @atomic: if %TRUE the file is written atomically
* @header: text to include as comment at the top of the file
* @error: return location for errors
*
* Creates a new #GimpConfigWriter and sets it up to write to
* @filename. If @atomic is %TRUE, a temporary file is used to avoid
* possible race conditions. The temporary file is then moved to
* @filename when the writer is closed.
*
* Return value: a new #GimpConfigWriter or %NULL in case of an error
*
* Since: GIMP 2.4
**/
GimpConfigWriter *
gimp_config_writer_new_file (const gchar *filename,
gboolean atomic,
const gchar *header,
GError **error)
{
GimpConfigWriter *writer;
gchar *tmpname = NULL;
gint fd;
g_return_val_if_fail (filename != NULL, NULL);
g_return_val_if_fail (error == NULL || *error == NULL, NULL);
if (atomic)
{
tmpname = g_strconcat (filename, "XXXXXX", NULL);
fd = g_mkstemp (tmpname);
if (fd == -1)
{
g_set_error (error, GIMP_CONFIG_ERROR, GIMP_CONFIG_ERROR_WRITE,
_("Could not create temporary file for '%s': %s"),
gimp_filename_to_utf8 (filename), g_strerror (errno));
g_free (tmpname);
return NULL;
}
}
else
{
fd = g_creat (filename, 0644);
if (fd == -1)
{
g_set_error (error, GIMP_CONFIG_ERROR, GIMP_CONFIG_ERROR_WRITE,
_("Could not open '%s' for writing: %s"),
gimp_filename_to_utf8 (filename), g_strerror (errno));
return NULL;
}
}
writer = g_slice_new0 (GimpConfigWriter);
writer->fd = fd;
writer->filename = g_strdup (filename);
writer->tmpname = tmpname;
writer->buffer = g_string_new (NULL);
if (header)
{
gimp_config_writer_comment (writer, header);
gimp_config_writer_linefeed (writer);
}
return writer;
}
GList *
gimp_gradient_load_svg (GimpContext *context,
const gchar *filename,
GError **error)
{
GimpXmlParser *xml_parser;
SvgParser parser = { NULL, };
gboolean success;
g_return_val_if_fail (filename != NULL, NULL);
g_return_val_if_fail (g_path_is_absolute (filename), NULL);
g_return_val_if_fail (error == NULL || *error == NULL, NULL);
xml_parser = gimp_xml_parser_new (&markup_parser, &parser);
success = gimp_xml_parser_parse_file (xml_parser, filename, error);
gimp_xml_parser_free (xml_parser);
if (success && ! parser.gradients)
{
g_set_error (error, GIMP_DATA_ERROR, GIMP_DATA_ERROR_READ,
_("No linear gradients found in '%s'"),
gimp_filename_to_utf8 (filename));
}
else
{
if (error && *error) /* parser reported an error */
{
gchar *msg = (*error)->message;
(*error)->message =
g_strdup_printf (_("Failed to import gradients from '%s': %s"),
gimp_filename_to_utf8 (filename), msg);
g_free (msg);
}
}
if (parser.gradient)
g_object_unref (parser.gradient);
if (parser.stops)
{
GList *list;
for (list = parser.stops; list; list = list->next)
g_slice_free (SvgStop, list->data);
g_list_free (parser.stops);
}
return g_list_reverse (parser.gradients);
}
static gboolean
gimp_plug_in_flush (GIOChannel *channel,
gpointer data)
{
GimpPlugIn *plug_in = data;
if (plug_in->write_buffer_index > 0)
{
GIOStatus status;
GError *error = NULL;
gint count;
gsize bytes;
count = 0;
while (count != plug_in->write_buffer_index)
{
do
{
bytes = 0;
status = g_io_channel_write_chars (channel,
&plug_in->write_buffer[count],
(plug_in->write_buffer_index - count),
&bytes,
&error);
}
while (status == G_IO_STATUS_AGAIN);
if (status != G_IO_STATUS_NORMAL)
{
if (error)
{
g_warning ("%s: plug_in_flush(): error: %s",
gimp_filename_to_utf8 (g_get_prgname ()),
error->message);
g_error_free (error);
}
else
{
g_warning ("%s: plug_in_flush(): error",
gimp_filename_to_utf8 (g_get_prgname ()));
}
return FALSE;
}
count += bytes;
}
plug_in->write_buffer_index = 0;
}
return TRUE;
}
static gboolean
gimp_levels_tool_settings_import (GimpImageMapTool *image_map_tool,
const gchar *filename,
GError **error)
{
GimpLevelsTool *tool = GIMP_LEVELS_TOOL (image_map_tool);
FILE *file;
gchar header[64];
file = g_fopen (filename, "rt");
if (! file)
{
g_set_error (error, G_FILE_ERROR, g_file_error_from_errno (errno),
_("Could not open '%s' for reading: %s"),
gimp_filename_to_utf8 (filename),
g_strerror (errno));
return FALSE;
}
if (! fgets (header, sizeof (header), file))
{
g_set_error (error, G_FILE_ERROR, g_file_error_from_errno (errno),
_("Could not read header from '%s': %s"),
gimp_filename_to_utf8 (filename),
g_strerror (errno));
fclose (file);
return FALSE;
}
if (g_str_has_prefix (header, "# GIMP Levels File\n"))
{
gboolean success;
rewind (file);
success = gimp_levels_config_load_cruft (tool->config, file, error);
fclose (file);
return success;
}
fclose (file);
return GIMP_IMAGE_MAP_TOOL_CLASS (parent_class)->settings_import (image_map_tool,
filename,
error);
}
gboolean
gimp_contexts_save (Gimp *gimp,
GError **error)
{
gchar *filename;
gboolean success;
g_return_val_if_fail (GIMP_IS_GIMP (gimp), FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
filename = gimp_personal_rc_file ("contextrc");
if (gimp->be_verbose)
g_print ("Writing '%s'\n", gimp_filename_to_utf8 (filename));
success = gimp_config_serialize_to_file (GIMP_CONFIG (gimp_get_user_context (gimp)),
filename,
"GIMP user context",
"end of user context",
NULL, error);
g_free (filename);
return success;
}
/**
* gimp_scanner_new_file:
* @filename:
* @error:
*
* Return value:
*
* Since: GIMP 2.4
**/
GScanner *
gimp_scanner_new_file (const gchar *filename,
GError **error)
{
GScanner *scanner;
GMappedFile *file;
g_return_val_if_fail (filename != NULL, NULL);
g_return_val_if_fail (error == NULL || *error == NULL, NULL);
file = g_mapped_file_new (filename, FALSE, error);
if (! file)
{
if (error)
{
(*error)->domain = GIMP_CONFIG_ERROR;
(*error)->code = ((*error)->code == G_FILE_ERROR_NOENT ?
GIMP_CONFIG_ERROR_OPEN_ENOENT :
GIMP_CONFIG_ERROR_OPEN);
}
return NULL;
}
/* gimp_scanner_new() takes a "name" for the scanner, not a filename */
scanner = gimp_scanner_new (gimp_filename_to_utf8 (filename), file, error);
g_scanner_input_text (scanner,
g_mapped_file_get_contents (file),
g_mapped_file_get_length (file));
return scanner;
}
gboolean
gimp_config_file_backup_on_error (const gchar *filename,
const gchar *name,
GError **error)
{
gchar *backup;
gboolean success;
g_return_val_if_fail (filename != NULL, FALSE);
g_return_val_if_fail (name != NULL, FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
backup = g_strconcat (filename, "~", NULL);
success = gimp_config_file_copy (filename, backup, error);
if (success)
g_message (_("There was an error parsing your '%s' file. "
"Default values will be used. A backup of your "
"configuration has been created at '%s'."),
name, gimp_filename_to_utf8 (backup));
g_free (backup);
return success;
}
gboolean
gimp_devices_clear (Gimp *gimp,
GError **error)
{
GimpDeviceManager *manager;
gchar *filename;
gboolean success = TRUE;
g_return_val_if_fail (GIMP_IS_GIMP (gimp), FALSE);
manager = gimp_devices_get_manager (gimp);
g_return_val_if_fail (GIMP_IS_DEVICE_MANAGER (manager), FALSE);
filename = gimp_personal_rc_file ("devicerc");
if (g_unlink (filename) != 0 && errno != ENOENT)
{
g_set_error (error, G_FILE_ERROR, g_file_error_from_errno (errno),
_("Deleting \"%s\" failed: %s"),
gimp_filename_to_utf8 (filename), g_strerror (errno));
success = FALSE;
}
else
{
devicerc_deleted = TRUE;
}
g_free (filename);
return success;
}
void
gimp_templates_save (Gimp *gimp)
{
const gchar *header =
"GIMP templaterc\n"
"\n"
"This file will be entirely rewritten each time you exit.";
const gchar *footer =
"end of templaterc";
gchar *filename;
GError *error = NULL;
g_return_if_fail (GIMP_IS_GIMP (gimp));
g_return_if_fail (GIMP_IS_LIST (gimp->templates));
filename = gimp_personal_rc_file ("templaterc");
if (gimp->be_verbose)
g_print ("Writing '%s'\n", gimp_filename_to_utf8 (filename));
if (! gimp_config_serialize_to_file (GIMP_CONFIG (gimp->templates),
filename,
header, footer, NULL,
&error))
{
gimp_message_literal (gimp, NULL, GIMP_MESSAGE_ERROR, error->message);
g_error_free (error);
}
g_free (filename);
}
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);
}
GList *
gimp_curve_load (const gchar *filename,
GError **error)
{
FILE *file;
g_return_val_if_fail (filename != NULL, NULL);
g_return_val_if_fail (g_path_is_absolute (filename), NULL);
g_return_val_if_fail (error == NULL || *error == NULL, NULL);
file = g_fopen (filename, "rb");
if (! file)
{
g_set_error (error, GIMP_DATA_ERROR, GIMP_DATA_ERROR_OPEN,
_("Could not open '%s' for reading: %s"),
gimp_filename_to_utf8 (filename), g_strerror (errno));
return NULL;
}
/* load curves */
fclose (file);
return NULL;
}
static gboolean
gimp_levels_tool_settings_export (GimpImageMapTool *image_map_tool,
const gchar *filename,
GError **error)
{
GimpLevelsTool *tool = GIMP_LEVELS_TOOL (image_map_tool);
if (tool->export_old_format)
{
FILE *file;
gboolean success;
file = g_fopen (filename, "wt");
if (! file)
{
g_set_error (error, G_FILE_ERROR, g_file_error_from_errno (errno),
_("Could not open '%s' for writing: %s"),
gimp_filename_to_utf8 (filename),
g_strerror (errno));
return FALSE;
}
success = gimp_levels_config_save_cruft (tool->config, file, error);
fclose (file);
return success;
}
return GIMP_IMAGE_MAP_TOOL_CLASS (parent_class)->settings_export (image_map_tool,
filename,
error);
}
gboolean
gimp_curve_save (GimpData *data,
GError **error)
{
/* GimpCurve *curve; */
FILE *file;
g_return_val_if_fail (GIMP_IS_CURVE (data), FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
/* curve = GIMP_CURVE (data); */
file = g_fopen (gimp_data_get_filename (data), "wb");
if (! file)
{
g_set_error (error, GIMP_DATA_ERROR, GIMP_DATA_ERROR_OPEN,
_("Could not open '%s' for writing: %s"),
gimp_filename_to_utf8 (gimp_data_get_filename (data)),
g_strerror (errno));
return FALSE;
}
/* FIXME: write curve */
fclose (file);
return TRUE;
}
void
dialogs_load_recent_docks (Gimp *gimp)
{
gchar *filename;
GError *error = NULL;
g_return_if_fail (GIMP_IS_GIMP (gimp));
filename = dialogs_get_dockrc_filename ();
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_literal (gimp, NULL, GIMP_MESSAGE_ERROR, error->message);
g_clear_error (&error);
}
/* In GIMP 2.6 dockrc did not contain the factory entries for the
* session infos, so set that up manually if needed
*/
gimp_container_foreach (global_recent_docks,
(GFunc) dialogs_ensure_factory_entry_on_recent_dock,
NULL);
gimp_list_reverse (GIMP_LIST (global_recent_docks));
g_free (filename);
}
static void
gimp_module_db_module_dump_func (gpointer data,
gpointer user_data)
{
GimpModule *module = data;
g_print ("\n%s: %s\n",
gimp_filename_to_utf8 (module->filename),
gimp_module_state_name (module->state));
g_print (" module: %p lasterr: %s query: %p register: %p\n",
module->module,
module->last_module_error ? module->last_module_error : "NONE",
module->query_module,
module->register_module);
if (module->info)
{
g_print (" purpose: %s\n"
" author: %s\n"
" version: %s\n"
" copyright: %s\n"
" date: %s\n",
module->info->purpose ? module->info->purpose : "NONE",
module->info->author ? module->info->author : "NONE",
module->info->version ? module->info->version : "NONE",
module->info->copyright ? module->info->copyright : "NONE",
module->info->date ? module->info->date : "NONE");
}
}
GimpPDBStatusType
file_vtf_save_image (const gchar *fname, gint32 image, gint32 run_mode,
GError **error)
{
SaveInfo info;
info.version = 4;
info.format = Vtf::FormatDXT5;
info.layer = 0;
info.mipmap = TRUE;
info.lowres = TRUE;
info.crc = TRUE;
if (run_mode == GIMP_RUN_INTERACTIVE)
if (!file_vtf_save_dialog (&info))
return GIMP_PDB_CANCEL;
gimp_progress_init_printf ("Saving '%s'", gimp_filename_to_utf8 (fname));
std::auto_ptr<Vtf::File> vtf (new Vtf::File);
try {
Vtf::HiresImageResource* vres = new Vtf::HiresImageResource;
// vres->setup (info.format, info.width, info.height, info);
vres->check ();
vtf->addResource (vres);
vtf->save (fname, info.version);
} catch (std::exception& e) {
}
gimp_progress_update (1.0);
return GIMP_PDB_SUCCESS;
}
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
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 GtkWidget *
lcms_icc_combo_box_new (GimpColorConfig *config,
const gchar *filename)
{
GtkWidget *combo;
GtkWidget *dialog;
gchar *history;
gchar *label;
gchar *name;
const gchar *rgb_filename = NULL;
cmsHPROFILE profile = NULL;
dialog = gimp_color_profile_chooser_dialog_new (_("Select destination profile"));
history = gimp_personal_rc_file ("profilerc");
combo = gimp_color_profile_combo_box_new (dialog, history);
g_free (history);
if (config->rgb_profile)
{
GError *error = NULL;
profile = gimp_lcms_profile_open_from_file (config->rgb_profile, &error);
if (! profile)
{
g_message ("%s", error->message);
g_clear_error (&error);
}
else if (! gimp_lcms_profile_is_rgb (profile))
{
g_message (_("Color profile '%s' is not for RGB color space."),
gimp_filename_to_utf8 (config->rgb_profile));
cmsCloseProfile (profile);
profile = NULL;
}
else
{
rgb_filename = config->rgb_profile;
}
}
if (! profile)
profile = gimp_lcms_create_srgb_profile ();
name = gimp_lcms_profile_get_label (profile);
label = g_strdup_printf (_("RGB workspace (%s)"), name);
g_free (name);
cmsCloseProfile (profile);
gimp_color_profile_combo_box_add (GIMP_COLOR_PROFILE_COMBO_BOX (combo),
rgb_filename, label);
g_free (label);
gimp_color_profile_combo_box_set_active (GIMP_COLOR_PROFILE_COMBO_BOX (combo),
filename, NULL);
return combo;
}
GimpColorProfile
gimp_lcms_profile_open_from_file (const gchar *filename,
GError **error)
{
GimpColorProfile profile;
GMappedFile *file;
const guint8 *data;
gsize length;
g_return_val_if_fail (filename != NULL, NULL);
g_return_val_if_fail (error == NULL || *error == NULL, NULL);
file = g_mapped_file_new (filename, FALSE, error);
if (! file)
return NULL;
data = (const guint8 *) g_mapped_file_get_contents (file);
length = g_mapped_file_get_length (file);
profile = cmsOpenProfileFromMem (data, length);
if (! profile)
g_set_error (error, gimp_lcms_error_quark (), 0,
_("'%s' does not appear to be an ICC color profile"),
gimp_filename_to_utf8 (filename));
g_mapped_file_unref (file);
return profile;
}
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 gboolean
gimp_ui_manager_entry_load (GimpUIManager *manager,
GimpUIManagerUIEntry *entry,
GError **error)
{
gchar *filename = NULL;
const gchar *menus_dir_override = g_getenv ("GIMP_TESTING_MENUS_DIR");
/* In order for test cases to be able to run without GIMP being
* installed yet, allow them to override the menus directory to the
* menus dir in the source root
*/
if (menus_dir_override)
filename = g_build_filename (menus_dir_override, entry->basename, NULL);
else
filename = g_build_filename (gimp_data_directory (), "menus",
entry->basename, NULL);
if (manager->gimp->be_verbose)
g_print ("loading menu '%s' for %s\n",
gimp_filename_to_utf8 (filename), entry->ui_path);
entry->merge_id = gtk_ui_manager_add_ui_from_file (GTK_UI_MANAGER (manager),
filename, error);
g_free (filename);
if (! entry->merge_id)
return FALSE;
return TRUE;
}
gboolean
menus_clear (Gimp *gimp,
GError **error)
{
gchar *filename;
gchar *source;
gboolean success = TRUE;
g_return_val_if_fail (GIMP_IS_GIMP (gimp), FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
filename = gimp_personal_rc_file ("menurc");
source = g_build_filename (gimp_sysconf_directory (), "menurc", NULL);
if (gimp_config_file_copy (source, filename, NULL, NULL, NULL))
{
menurc_deleted = TRUE;
}
else if (g_unlink (filename) != 0 && errno != ENOENT)
{
g_set_error (error, G_FILE_ERROR, g_file_error_from_errno (errno),
_("Deleting \"%s\" failed: %s"),
gimp_filename_to_utf8 (filename), g_strerror (errno));
success = FALSE;
}
else
{
menurc_deleted = TRUE;
}
g_free (source);
g_free (filename);
return success;
}
gboolean
session_clear (Gimp *gimp,
GError **error)
{
gchar *filename;
gboolean success = TRUE;
g_return_val_if_fail (GIMP_IS_GIMP (gimp), FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
filename = session_filename (gimp);
if (g_unlink (filename) != 0 && errno != ENOENT)
{
g_set_error (error, G_FILE_ERROR, g_file_error_from_errno (errno),
_("Deleting \"%s\" failed: %s"),
gimp_filename_to_utf8 (filename), g_strerror (errno));
success = FALSE;
}
else
{
sessionrc_deleted = TRUE;
}
g_free (filename);
return success;
}
static void
gimp_eek (const gchar *reason,
const gchar *message,
gboolean use_handler)
{
#ifndef G_OS_WIN32
g_printerr ("%s: %s: %s\n", gimp_filename_to_utf8 (full_prog_name),
reason, message);
if (use_handler)
{
switch (stack_trace_mode)
{
case GIMP_STACK_TRACE_NEVER:
break;
case GIMP_STACK_TRACE_QUERY:
{
sigset_t sigset;
sigemptyset (&sigset);
sigprocmask (SIG_SETMASK, &sigset, NULL);
if (the_errors_gimp)
gimp_gui_ungrab (the_errors_gimp);
g_on_error_query (full_prog_name);
}
break;
case GIMP_STACK_TRACE_ALWAYS:
{
sigset_t sigset;
sigemptyset (&sigset);
sigprocmask (SIG_SETMASK, &sigset, NULL);
g_on_error_stack_trace (full_prog_name);
}
break;
default:
break;
}
}
#else
/* g_on_error_* don't do anything reasonable on Win32. */
MessageBox (NULL, g_strdup_printf ("%s: %s", reason, message),
full_prog_name, MB_OK|MB_ICONERROR);
#endif /* ! G_OS_WIN32 */
exit (EXIT_FAILURE);
}
static inline void
gimp_config_writer_flush (GimpConfigWriter *writer)
{
if (write (writer->fd, writer->buffer->str, writer->buffer->len) < 0)
g_set_error (&writer->error, GIMP_CONFIG_ERROR, GIMP_CONFIG_ERROR_WRITE,
_("Error writing to '%s': %s"),
gimp_filename_to_utf8 (writer->filename), g_strerror (errno));
g_string_truncate (writer->buffer, 0);
}
static GimpPDBStatusType
save_image (const gchar *uri,
gint32 image_ID,
gint32 drawable_ID,
gint32 run_mode,
GError **error)
{
GimpPDBStatusType status = GIMP_PDB_EXECUTION_ERROR;
gchar *tmpname;
gboolean mapped = FALSE;
tmpname = uri_backend_map_image (uri, run_mode);
if (tmpname)
mapped = TRUE;
else
tmpname = get_temp_name (uri, NULL);
if (gimp_file_save (run_mode,
image_ID,
drawable_ID,
tmpname,
tmpname))
{
if (mapped)
{
status = GIMP_PDB_SUCCESS;
}
else if (valid_file (tmpname))
{
if (uri_backend_save_image (uri, tmpname, run_mode, error))
{
status = GIMP_PDB_SUCCESS;
}
}
else
{
g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
_("Failed to save to temporary file '%s'"),
gimp_filename_to_utf8 (tmpname));
}
}
else
{
g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
"%s", gimp_get_pdb_error ());
}
if (! mapped)
g_unlink (tmpname);
g_free (tmpname);
return status;
}
void
gimp_devices_restore (Gimp *gimp)
{
GimpDeviceManager *manager;
GimpContext *user_context;
GimpDeviceInfo *current_device;
GList *list;
gchar *filename;
GError *error = NULL;
g_return_if_fail (GIMP_IS_GIMP (gimp));
manager = gimp_devices_get_manager (gimp);
g_return_if_fail (GIMP_IS_DEVICE_MANAGER (manager));
user_context = gimp_get_user_context (gimp);
for (list = GIMP_LIST (manager)->list;
list;
list = g_list_next (list))
{
GimpDeviceInfo *device_info = list->data;
gimp_context_copy_properties (user_context, GIMP_CONTEXT (device_info),
GIMP_DEVICE_INFO_CONTEXT_MASK);
gimp_device_info_set_default_tool (device_info);
}
filename = gimp_personal_rc_file ("devicerc");
if (gimp->be_verbose)
g_print ("Parsing '%s'\n", gimp_filename_to_utf8 (filename));
if (! gimp_config_deserialize_file (GIMP_CONFIG (manager),
filename,
gimp,
&error))
{
if (error->code != GIMP_CONFIG_ERROR_OPEN_ENOENT)
gimp_message_literal (gimp, NULL, GIMP_MESSAGE_ERROR, error->message);
g_error_free (error);
/* don't bail out here */
}
g_free (filename);
current_device = gimp_device_manager_get_current_device (manager);
gimp_context_copy_properties (GIMP_CONTEXT (current_device), user_context,
GIMP_DEVICE_INFO_CONTEXT_MASK);
gimp_context_set_parent (GIMP_CONTEXT (current_device), user_context);
}
