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