static void
dump_gimprc_system (GimpConfig *rc,
GimpConfigWriter *writer,
GOutputStream *output)
{
GObjectClass *klass;
GParamSpec **property_specs;
guint n_property_specs;
guint i;
gimp_config_writer_comment (writer, system_gimprc_header);
gimp_config_writer_linefeed (writer);
klass = G_OBJECT_GET_CLASS (rc);
property_specs = g_object_class_list_properties (klass, &n_property_specs);
for (i = 0; i < n_property_specs; i++)
{
GParamSpec *prop_spec = property_specs[i];
gchar *comment;
if (! (prop_spec->flags & GIMP_CONFIG_PARAM_SERIALIZE))
continue;
if (prop_spec->flags & GIMP_CONFIG_PARAM_IGNORE)
continue;
comment = dump_describe_param (prop_spec);
if (comment)
{
gimp_config_writer_comment (writer, comment);
g_free (comment);
}
gimp_config_writer_comment_mode (writer, TRUE);
gimp_config_writer_linefeed (writer);
gimp_config_serialize_property (rc, prop_spec, writer);
gimp_config_writer_comment_mode (writer, FALSE);
gimp_config_writer_linefeed (writer);
}
g_free (property_specs);
}
/**
* 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;
}
/**
* gimp_config_writer_new_gfile:
* @file: a #GFile
* @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
* @file. If @atomic is %TRUE, a temporary file is used to avoid
* possible race conditions. The temporary file is then moved to @file
* when the writer is closed.
*
* Return value: a new #GimpConfigWriter or %NULL in case of an error
*
* Since: GIMP 2.10
**/
GimpConfigWriter *
gimp_config_writer_new_gfile (GFile *file,
gboolean atomic,
const gchar *header,
GError **error)
{
GimpConfigWriter *writer;
GOutputStream *output;
GError *my_error = NULL;
g_return_val_if_fail (G_IS_FILE (file), NULL);
g_return_val_if_fail (error == NULL || *error == NULL, NULL);
if (atomic)
{
output = G_OUTPUT_STREAM (g_file_replace (file, NULL, FALSE,
G_FILE_CREATE_NONE,
NULL, &my_error));
if (! output)
g_set_error (error, GIMP_CONFIG_ERROR, GIMP_CONFIG_ERROR_WRITE,
_("Could not create temporary file for '%s': %s"),
gimp_file_get_utf8_name (file), my_error->message);
}
else
{
output = G_OUTPUT_STREAM (g_file_replace (file, NULL, FALSE,
G_FILE_CREATE_REPLACE_DESTINATION,
NULL, &my_error));
if (! output)
g_set_error (error, GIMP_CONFIG_ERROR, GIMP_CONFIG_ERROR_WRITE,
_("Could not open '%s' for writing: %s"),
gimp_file_get_utf8_name (file), my_error->message);
}
if (! output)
{
g_clear_error (&my_error);
return NULL;
}
writer = g_slice_new0 (GimpConfigWriter);
writer->output = output;
writer->file = g_object_ref (file);
writer->buffer = g_string_new (NULL);
if (header)
{
gimp_config_writer_comment (writer, header);
gimp_config_writer_linefeed (writer);
}
return writer;
}
/**
* gimp_config_writer_finish:
* @writer: a #GimpConfigWriter
* @footer: text to include as comment at the bottom of the file
* @error: return location for possible errors
*
* This function finishes the work of @writer and frees it afterwards.
* It closes all open elements, appends an optional comment and
* releases all resources allocated by @writer. You must not access
* the @writer afterwards.
*
* Return value: %TRUE if everything could be successfully written,
* %FALSE otherwise
*
* Since: GIMP 2.4
**/
gboolean
gimp_config_writer_finish (GimpConfigWriter *writer,
const gchar *footer,
GError **error)
{
gboolean success = TRUE;
g_return_val_if_fail (writer != NULL, FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
if (writer->depth < 0)
{
g_warning ("gimp_config_writer_finish: depth < 0 !!");
}
else
{
while (writer->depth)
gimp_config_writer_close (writer);
}
if (footer)
{
gimp_config_writer_linefeed (writer);
gimp_config_writer_comment (writer, footer);
}
if (writer->output)
{
success = gimp_config_writer_close_output (writer, error);
if (writer->file)
g_object_unref (writer->file);
g_string_free (writer->buffer, TRUE);
}
if (writer->error)
{
if (error && *error == NULL)
g_propagate_error (error, writer->error);
else
g_clear_error (&writer->error);
success = FALSE;
}
g_slice_free (GimpConfigWriter, writer);
return success;
}
gboolean
gimp_config_dump (GObject *gimp,
GimpConfigDumpFormat format)
{
GOutputStream *output;
GimpConfigWriter *writer;
GimpConfig *rc;
g_return_val_if_fail (G_IS_OBJECT (gimp), FALSE);
rc = g_object_new (GIMP_TYPE_RC,
"gimp", gimp,
NULL);
#ifdef G_OS_WIN32
output = g_win32_output_stream_new ((gpointer) 1, FALSE);
#else
output = g_unix_output_stream_new (1, FALSE);
#endif
writer = gimp_config_writer_new_stream (output, NULL, NULL);
switch (format)
{
case GIMP_CONFIG_DUMP_NONE:
break;
case GIMP_CONFIG_DUMP_GIMPRC:
gimp_config_writer_comment (writer,
"Dump of the GIMP default configuration");
gimp_config_writer_linefeed (writer);
gimp_config_serialize_properties (rc, writer);
gimp_config_writer_linefeed (writer);
break;
case GIMP_CONFIG_DUMP_GIMPRC_SYSTEM:
dump_gimprc_system (rc, writer, output);
break;
case GIMP_CONFIG_DUMP_GIMPRC_MANPAGE:
dump_gimprc_manpage (rc, writer, output);
break;
}
gimp_config_writer_finish (writer, NULL, NULL);
g_object_unref (output);
g_object_unref (rc);
return TRUE;
}
/**
* gimp_config_writer_new_stream:
* @output: a #GOutputStream
* @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
* @output.
*
* Return value: a new #GimpConfigWriter or %NULL in case of an error
*
* Since: GIMP 2.10
**/
GimpConfigWriter *
gimp_config_writer_new_stream (GOutputStream *output,
const gchar *header,
GError **error)
{
GimpConfigWriter *writer;
g_return_val_if_fail (G_IS_OUTPUT_STREAM (output), NULL);
g_return_val_if_fail (error == NULL || *error == NULL, NULL);
writer = g_slice_new0 (GimpConfigWriter);
writer->output = g_object_ref (output);
writer->buffer = g_string_new (NULL);
if (header)
{
gimp_config_writer_comment (writer, header);
gimp_config_writer_linefeed (writer);
}
return writer;
}
gboolean
gimp_config_dump (GimpConfigDumpFormat format)
{
GimpConfigWriter *writer;
GimpConfig *rc;
rc = g_object_new (GIMP_TYPE_RC, NULL);
writer = gimp_config_writer_new_fd (1);
switch (format)
{
case GIMP_CONFIG_DUMP_NONE:
break;
case GIMP_CONFIG_DUMP_GIMPRC:
gimp_config_writer_comment (writer,
"Dump of the GIMP default configuration");
gimp_config_writer_linefeed (writer);
gimp_config_serialize_properties (rc, writer);
gimp_config_writer_linefeed (writer);
break;
case GIMP_CONFIG_DUMP_GIMPRC_SYSTEM:
dump_gimprc_system (rc, writer, 1);
break;
case GIMP_CONFIG_DUMP_GIMPRC_MANPAGE:
dump_gimprc_manpage (rc, writer, 1);
break;
}
gimp_config_writer_finish (writer, NULL, NULL);
g_object_unref (rc);
return TRUE;
}
/**
* gimp_config_writer_new_gfile:
* @file: a #GFile
* @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
* @file. If @atomic is %TRUE, a temporary file is used to avoid
* possible race conditions. The temporary file is then moved to @file
* when the writer is closed.
*
* Return value: a new #GimpConfigWriter or %NULL in case of an error
*
* Since: 2.10
**/
GimpConfigWriter *
gimp_config_writer_new_gfile (GFile *file,
gboolean atomic,
const gchar *header,
GError **error)
{
GimpConfigWriter *writer;
GOutputStream *output;
GFile *dir;
g_return_val_if_fail (G_IS_FILE (file), NULL);
g_return_val_if_fail (error == NULL || *error == NULL, NULL);
dir = g_file_get_parent (file);
if (dir && ! g_file_query_exists (dir, NULL))
{
if (! g_file_make_directory_with_parents (dir, NULL, error))
g_prefix_error (error,
_("Could not create directory '%s' for '%s': "),
gimp_file_get_utf8_name (dir),
gimp_file_get_utf8_name (file));
}
g_object_unref (dir);
if (error && *error)
return NULL;
if (atomic)
{
output = G_OUTPUT_STREAM (g_file_replace (file,
NULL, FALSE, G_FILE_CREATE_NONE,
NULL, error));
if (! output)
g_prefix_error (error,
_("Could not create temporary file for '%s': "),
gimp_file_get_utf8_name (file));
}
else
{
output = G_OUTPUT_STREAM (g_file_replace (file,
NULL, FALSE,
G_FILE_CREATE_REPLACE_DESTINATION,
NULL, error));
}
if (! output)
return NULL;
writer = g_slice_new0 (GimpConfigWriter);
writer->output = output;
writer->file = g_object_ref (file);
writer->buffer = g_string_new (NULL);
if (header)
{
gimp_config_writer_comment (writer, header);
gimp_config_writer_linefeed (writer);
}
return writer;
}
