void color_history_save (Gimp *gimp) { GimpConfigWriter *writer; GFile *file; gint i; g_return_if_fail (GIMP_IS_GIMP (gimp)); file = gimp_personal_rc_gfile ("colorrc"); if (gimp->be_verbose) g_print ("Writing '%s'\n", gimp_file_get_utf8_name (file)); writer = gimp_config_writer_new_gfile (file, TRUE, "GIMP colorrc\n\n" "This file holds a list of " "recently used colors.", NULL); g_object_unref (file); if (!writer) return; if (! color_history_initialized) color_history_init (); gimp_config_writer_open (writer, "color-history"); for (i = 0; i < COLOR_HISTORY_SIZE; i++) { gchar buf[4][G_ASCII_DTOSTR_BUF_SIZE]; g_ascii_formatd (buf[0], G_ASCII_DTOSTR_BUF_SIZE, "%f", color_history[i].r); g_ascii_formatd (buf[1], G_ASCII_DTOSTR_BUF_SIZE, "%f", color_history[i].g); g_ascii_formatd (buf[2], G_ASCII_DTOSTR_BUF_SIZE, "%f", color_history[i].b); g_ascii_formatd (buf[3], G_ASCII_DTOSTR_BUF_SIZE, "%f", color_history[i].a); gimp_config_writer_open (writer, "color-rgba"); gimp_config_writer_printf (writer, "%s %s %s %s", buf[0], buf[1], buf[2], buf[3]); gimp_config_writer_close (writer); } gimp_config_writer_close (writer); gimp_config_writer_finish (writer, "end of colorrc", NULL); }
void session_save (Gimp *gimp, gboolean always_save) { GimpConfigWriter *writer; gchar *filename; GError *error = NULL; g_return_if_fail (GIMP_IS_GIMP (gimp)); if (sessionrc_deleted && ! always_save) return; filename = session_filename (gimp); if (gimp->be_verbose) g_print ("Writing '%s'\n", gimp_filename_to_utf8 (filename)); writer = gimp_config_writer_new_file (filename, TRUE, "GIMP sessionrc\n\n" "This file takes session-specific info " "(that is info, you want to keep between " "two GIMP sessions). You are not supposed " "to edit it manually, but of course you " "can do. The sessionrc will be entirely " "rewritten every time you quit GIMP. " "If this file isn't found, defaults are " "used.", NULL); g_free (filename); if (!writer) return; gimp_dialog_factories_session_save (writer); gimp_config_writer_linefeed (writer); /* save last tip shown */ gimp_config_writer_open (writer, "last-tip-shown"); gimp_config_writer_printf (writer, "%d", GIMP_GUI_CONFIG (gimp->config)->last_tip + 1); gimp_config_writer_close (writer); if (! gimp_config_writer_finish (writer, "end of sessionrc", &error)) { gimp_message (gimp, NULL, GIMP_MESSAGE_ERROR, "%s", error->message); g_clear_error (&error); } sessionrc_deleted = FALSE; }
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; }
void gimp_modules_unload (Gimp *gimp) { g_return_if_fail (GIMP_IS_GIMP (gimp)); if (! gimp->no_interface && gimp->write_modulerc) { GimpConfigWriter *writer; GString *str; gchar *p; gchar *filename; GError *error = NULL; str = g_string_new (NULL); g_list_foreach (gimp->module_db->modules, add_to_inhibit_string, str); if (str->len > 0) p = str->str + 1; else p = ""; filename = gimp_personal_rc_file ("modulerc"); if (gimp->be_verbose) g_print ("Writing '%s'\n", gimp_filename_to_utf8 (filename)); writer = gimp_config_writer_new_file (filename, TRUE, "GIMP modulerc", &error); g_free (filename); if (writer) { gimp_config_writer_open (writer, "module-load-inhibit"); gimp_config_writer_printf (writer, "\"%s\"", p); gimp_config_writer_close (writer); gimp_config_writer_finish (writer, "end of modulerc", &error); gimp->write_modulerc = FALSE; } g_string_free (str, TRUE); if (error) { gimp_message (gimp, NULL, GIMP_MESSAGE_ERROR, "%s", error->message); g_clear_error (&error); } } }
void gimp_modules_unload (Gimp *gimp) { g_return_if_fail (GIMP_IS_GIMP (gimp)); if (! gimp->no_interface && gimp->write_modulerc) { GimpConfigWriter *writer; GString *str; const gchar *p; GFile *file; GError *error = NULL; str = g_string_new (NULL); g_list_foreach (gimp->module_db->modules, add_to_inhibit_string, str); if (str->len > 0) p = str->str + 1; else p = ""; file = gimp_directory_file ("modulerc", NULL); if (gimp->be_verbose) g_print ("Writing '%s'\n", gimp_file_get_utf8_name (file)); writer = gimp_config_writer_new_gfile (file, TRUE, "GIMP modulerc", &error); g_object_unref (file); if (writer) { gimp_config_writer_open (writer, "module-load-inhibit"); gimp_config_writer_string (writer, p); gimp_config_writer_close (writer); gimp_config_writer_finish (writer, "end of modulerc", &error); gimp->write_modulerc = FALSE; } g_string_free (str, TRUE); if (error) { gimp_message_literal (gimp, NULL, GIMP_MESSAGE_ERROR, error->message); g_clear_error (&error); } } }
void gimp_action_history_exit (Gimp *gimp) { GimpGuiConfig *config; GimpActionHistoryItem *item; GList *actions; GFile *file; GimpConfigWriter *writer; gint min_count = 0; gint i; g_return_if_fail (GIMP_IS_GIMP (gimp)); config = GIMP_GUI_CONFIG (gimp->config); /* If we have more items than current history size, trim the history * and move down all count so that 1 is lower. */ item = g_list_nth_data (history.items, config->action_history_size); if (item) min_count = item->count - 1; file = gimp_directory_file (GIMP_ACTION_HISTORY_FILENAME, NULL); if (gimp->be_verbose) g_print ("Writing '%s'\n", gimp_file_get_utf8_name (file)); writer = gimp_config_writer_new_gfile (file, TRUE, "GIMP action-history", NULL); g_object_unref (file); for (actions = history.items, i = 0; actions && i < config->action_history_size; actions = g_list_next (actions), i++) { item = actions->data; gimp_config_writer_open (writer, "history-item"); gimp_config_writer_string (writer, item->action_name); gimp_config_writer_printf (writer, "%d", item->count - min_count); gimp_config_writer_close (writer); } gimp_config_writer_finish (writer, "end of action-history", NULL); gimp_action_history_clear (gimp); }
/** * gimp_config_serialize_to_string: * @config: a #GObject that implements the #GimpConfigInterface. * @data: user data passed to the serialize implementation. * * Serializes the object properties of @config to a string. * * Return value: a newly allocated NUL-terminated string. * * Since: 2.4 **/ gchar * gimp_config_serialize_to_string (GimpConfig *config, gpointer data) { GimpConfigWriter *writer; GString *str; g_return_val_if_fail (GIMP_IS_CONFIG (config), NULL); str = g_string_new (NULL); writer = gimp_config_writer_new_string (str); GIMP_CONFIG_GET_INTERFACE (config)->serialize (config, writer, data); gimp_config_writer_finish (writer, NULL, NULL); return g_string_free (str, FALSE); }
/** * gimp_config_serialize_to_fd: * @config: a #GObject that implements the #GimpConfigInterface. * @fd: a file descriptor, opened for writing * @data: user data passed to the serialize implementation. * * Serializes the object properties of @config to the given file * descriptor. * * Return value: %TRUE if serialization succeeded, %FALSE otherwise. * * Since: 2.4 **/ gboolean gimp_config_serialize_to_fd (GimpConfig *config, gint fd, gpointer data) { GimpConfigWriter *writer; g_return_val_if_fail (GIMP_IS_CONFIG (config), FALSE); g_return_val_if_fail (fd > 0, FALSE); writer = gimp_config_writer_new_fd (fd); if (!writer) return FALSE; GIMP_CONFIG_GET_INTERFACE (config)->serialize (config, writer, data); return gimp_config_writer_finish (writer, NULL, NULL); }
/** * gimp_config_serialize_to_stream: * @config: a #GObject that implements the #GimpConfigInterface. * @output: the #GOutputStream to write the configuration to. * @header: optional file header (must be ASCII only) * @footer: optional file footer (must be ASCII only) * @data: user data passed to the serialize implementation. * @error: return location for a possible error * * Serializes the object properties of @config to the stream specified * by @output. * * Return value: %TRUE if serialization succeeded, %FALSE otherwise. * * Since: 2.10 **/ gboolean gimp_config_serialize_to_stream (GimpConfig *config, GOutputStream *output, const gchar *header, const gchar *footer, gpointer data, GError **error) { GimpConfigWriter *writer; g_return_val_if_fail (GIMP_IS_CONFIG (config), FALSE); g_return_val_if_fail (G_IS_OUTPUT_STREAM (output), FALSE); g_return_val_if_fail (error == NULL || *error == NULL, FALSE); writer = gimp_config_writer_new_stream (output, header, error); if (!writer) return FALSE; GIMP_CONFIG_GET_INTERFACE (config)->serialize (config, writer, data); return gimp_config_writer_finish (writer, footer, error); }
/** * gimp_config_serialize_to_gfile: * @config: a #GObject that implements the #GimpConfigInterface. * @file: the #GFile to write the configuration to. * @header: optional file header (must be ASCII only) * @footer: optional file footer (must be ASCII only) * @data: user data passed to the serialize implementation. * @error: return location for a possible error * * Serializes the object properties of @config to the file specified * by @file. If a file with that name already exists, it is * overwritten. Basically this function opens @file for you and calls * the serialize function of the @config's #GimpConfigInterface. * * Return value: %TRUE if serialization succeeded, %FALSE otherwise. * * Since: 2.10 **/ gboolean gimp_config_serialize_to_gfile (GimpConfig *config, GFile *file, const gchar *header, const gchar *footer, gpointer data, GError **error) { GimpConfigWriter *writer; g_return_val_if_fail (GIMP_IS_CONFIG (config), FALSE); g_return_val_if_fail (G_IS_FILE (file), FALSE); g_return_val_if_fail (error == NULL || *error == NULL, FALSE); writer = gimp_config_writer_new_gfile (file, TRUE, header, error); if (!writer) return FALSE; GIMP_CONFIG_GET_INTERFACE (config)->serialize (config, writer, data); return gimp_config_writer_finish (writer, footer, error); }
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; }
void gimp_unitrc_save (Gimp *gimp) { GimpConfigWriter *writer; GFile *file; gint i; GError *error = NULL; g_return_if_fail (GIMP_IS_GIMP (gimp)); file = gimp_directory_file ("unitrc", NULL); if (gimp->be_verbose) g_print ("Writing '%s'\n", gimp_file_get_utf8_name (file)); writer = gimp_config_writer_new_gfile (file, TRUE, "GIMP units\n\n" "This file contains the user unit database. " "You can edit this list with the unit " "editor. You are not supposed to edit it " "manually, but of course you can do.\n" "This file will be entirely rewritten each " "time you exit.", NULL); g_object_unref (file); if (!writer) return; /* save user defined units */ for (i = _gimp_unit_get_number_of_built_in_units (gimp); i < _gimp_unit_get_number_of_units (gimp); i++) { if (_gimp_unit_get_deletion_flag (gimp, i) == FALSE) { gchar buf[G_ASCII_DTOSTR_BUF_SIZE]; gimp_config_writer_open (writer, "unit-info"); gimp_config_writer_string (writer, _gimp_unit_get_identifier (gimp, i)); gimp_config_writer_open (writer, "factor"); gimp_config_writer_print (writer, g_ascii_formatd (buf, sizeof (buf), "%f", _gimp_unit_get_factor (gimp, i)), -1); gimp_config_writer_close (writer); gimp_config_writer_open (writer, "digits"); gimp_config_writer_printf (writer, "%d", _gimp_unit_get_digits (gimp, i)); gimp_config_writer_close (writer); gimp_config_writer_open (writer, "symbol"); gimp_config_writer_string (writer, _gimp_unit_get_symbol (gimp, i)); gimp_config_writer_close (writer); gimp_config_writer_open (writer, "abbreviation"); gimp_config_writer_string (writer, _gimp_unit_get_abbreviation (gimp, i)); gimp_config_writer_close (writer); gimp_config_writer_open (writer, "singular"); gimp_config_writer_string (writer, _gimp_unit_get_singular (gimp, i)); gimp_config_writer_close (writer); gimp_config_writer_open (writer, "plural"); gimp_config_writer_string (writer, _gimp_unit_get_plural (gimp, i)); gimp_config_writer_close (writer); gimp_config_writer_close (writer); } } if (! gimp_config_writer_finish (writer, "end of units", &error)) { gimp_message_literal (gimp, NULL, GIMP_MESSAGE_ERROR, error->message); g_clear_error (&error); } }
static gboolean gimp_color_profile_store_save (GimpColorProfileStore *store, const gchar *filename, GError **error) { GimpConfigWriter *writer; GtkTreeModel *model; GtkTreeIter iter; gchar *labels[HISTORY_SIZE] = { NULL, }; GFile *files[HISTORY_SIZE] = { NULL, }; gboolean iter_valid; gint i; writer = gimp_config_writer_new_file (filename, TRUE, "GIMP color profile history", error); if (! writer) return FALSE; model = GTK_TREE_MODEL (store); for (iter_valid = gtk_tree_model_get_iter_first (model, &iter); iter_valid; iter_valid = gtk_tree_model_iter_next (model, &iter)) { gint type; gint index; gtk_tree_model_get (model, &iter, GIMP_COLOR_PROFILE_STORE_ITEM_TYPE, &type, GIMP_COLOR_PROFILE_STORE_INDEX, &index, -1); if (type == GIMP_COLOR_PROFILE_STORE_ITEM_FILE && index >= 0 && index < HISTORY_SIZE) { if (labels[index] || files[index]) g_warning ("%s: double index %d", G_STRFUNC, index); gtk_tree_model_get (model, &iter, GIMP_COLOR_PROFILE_STORE_LABEL, &labels[index], GIMP_COLOR_PROFILE_STORE_FILE, &files[index], -1); } } for (i = 0; i < HISTORY_SIZE; i++) { if (files[i] && labels[i]) { gchar *uri = g_file_get_uri (files[i]); if (uri) { gimp_config_writer_open (writer, "color-profile"); gimp_config_writer_string (writer, labels[i]); gimp_config_writer_string (writer, uri); gimp_config_writer_close (writer); g_free (uri); } } if (files[i]) g_object_unref (files[i]); g_free (labels[i]); } return gimp_config_writer_finish (writer, "end of color profile history", error); }
gboolean plug_in_rc_write (GSList *plug_in_defs, GFile *file, GError **error) { GimpConfigWriter *writer; GEnumClass *enum_class; GSList *list; writer = gimp_config_writer_new_gfile (file, FALSE, "GIMP pluginrc\n\n" "This file can safely be removed and " "will be automatically regenerated by " "querying the installed plugins.", error); if (!writer) return FALSE; enum_class = g_type_class_ref (GIMP_TYPE_ICON_TYPE); gimp_config_writer_open (writer, "protocol-version"); gimp_config_writer_printf (writer, "%d", GIMP_PROTOCOL_VERSION); gimp_config_writer_close (writer); gimp_config_writer_open (writer, "file-version"); gimp_config_writer_printf (writer, "%d", PLUG_IN_RC_FILE_VERSION); gimp_config_writer_close (writer); gimp_config_writer_linefeed (writer); for (list = plug_in_defs; list; list = list->next) { GimpPlugInDef *plug_in_def = list->data; if (plug_in_def->procedures) { GSList *list2; gchar *path; gchar *utf8; path = g_file_get_path (plug_in_def->file); utf8 = g_filename_to_utf8 (path, -1, NULL, NULL, NULL); g_free (path); if (! utf8) continue; gimp_config_writer_open (writer, "plug-in-def"); gimp_config_writer_string (writer, utf8); gimp_config_writer_printf (writer, "%"G_GINT64_FORMAT, plug_in_def->mtime); g_free (utf8); for (list2 = plug_in_def->procedures; list2; list2 = list2->next) { GimpPlugInProcedure *proc = list2->data; GimpProcedure *procedure = GIMP_PROCEDURE (proc); GEnumValue *enum_value; GList *list3; gint i; if (proc->installed_during_init) continue; gimp_config_writer_open (writer, "proc-def"); gimp_config_writer_printf (writer, "\"%s\" %d", procedure->original_name, procedure->proc_type); gimp_config_writer_linefeed (writer); gimp_config_writer_string (writer, procedure->blurb); gimp_config_writer_linefeed (writer); gimp_config_writer_string (writer, procedure->help); gimp_config_writer_linefeed (writer); gimp_config_writer_string (writer, procedure->author); gimp_config_writer_linefeed (writer); gimp_config_writer_string (writer, procedure->copyright); gimp_config_writer_linefeed (writer); gimp_config_writer_string (writer, procedure->date); gimp_config_writer_linefeed (writer); gimp_config_writer_string (writer, proc->menu_label); gimp_config_writer_linefeed (writer); gimp_config_writer_printf (writer, "%d", g_list_length (proc->menu_paths)); for (list3 = proc->menu_paths; list3; list3 = list3->next) { gimp_config_writer_open (writer, "menu-path"); gimp_config_writer_string (writer, list3->data); gimp_config_writer_close (writer); } gimp_config_writer_open (writer, "icon"); enum_value = g_enum_get_value (enum_class, proc->icon_type); gimp_config_writer_identifier (writer, enum_value->value_nick); gimp_config_writer_printf (writer, "%d", proc->icon_data_length); switch (proc->icon_type) { case GIMP_ICON_TYPE_ICON_NAME: case GIMP_ICON_TYPE_IMAGE_FILE: gimp_config_writer_string (writer, (gchar *) proc->icon_data); break; case GIMP_ICON_TYPE_INLINE_PIXBUF: gimp_config_writer_data (writer, proc->icon_data_length, proc->icon_data); break; } gimp_config_writer_close (writer); if (proc->file_proc) { gimp_config_writer_open (writer, proc->image_types ? "save-proc" : "load-proc"); if (proc->extensions && *proc->extensions) { gimp_config_writer_open (writer, "extension"); gimp_config_writer_string (writer, proc->extensions); gimp_config_writer_close (writer); } if (proc->prefixes && *proc->prefixes) { gimp_config_writer_open (writer, "prefix"); gimp_config_writer_string (writer, proc->prefixes); gimp_config_writer_close (writer); } if (proc->magics && *proc->magics) { gimp_config_writer_open (writer, "magic"); gimp_config_writer_string (writer, proc->magics); gimp_config_writer_close (writer); } if (proc->mime_type) { gimp_config_writer_open (writer, "mime-type"); gimp_config_writer_string (writer, proc->mime_type); gimp_config_writer_close (writer); } if (proc->handles_uri) { gimp_config_writer_open (writer, "handles-uri"); gimp_config_writer_close (writer); } if (proc->thumb_loader) { gimp_config_writer_open (writer, "thumb-loader"); gimp_config_writer_string (writer, proc->thumb_loader); gimp_config_writer_close (writer); } gimp_config_writer_close (writer); } gimp_config_writer_linefeed (writer); gimp_config_writer_string (writer, proc->image_types); gimp_config_writer_linefeed (writer); gimp_config_writer_printf (writer, "%d %d", procedure->num_args, procedure->num_values); for (i = 0; i < procedure->num_args; i++) { GParamSpec *pspec = procedure->args[i]; gimp_config_writer_open (writer, "proc-arg"); gimp_config_writer_printf (writer, "%d", gimp_pdb_compat_arg_type_from_gtype (G_PARAM_SPEC_VALUE_TYPE (pspec))); gimp_config_writer_string (writer, g_param_spec_get_name (pspec)); gimp_config_writer_string (writer, g_param_spec_get_blurb (pspec)); gimp_config_writer_close (writer); } for (i = 0; i < procedure->num_values; i++) { GParamSpec *pspec = procedure->values[i]; gimp_config_writer_open (writer, "proc-arg"); gimp_config_writer_printf (writer, "%d", gimp_pdb_compat_arg_type_from_gtype (G_PARAM_SPEC_VALUE_TYPE (pspec))); gimp_config_writer_string (writer, g_param_spec_get_name (pspec)); gimp_config_writer_string (writer, g_param_spec_get_blurb (pspec)); gimp_config_writer_close (writer); } gimp_config_writer_close (writer); } if (plug_in_def->locale_domain_name) { gimp_config_writer_open (writer, "locale-def"); gimp_config_writer_string (writer, plug_in_def->locale_domain_name); if (plug_in_def->locale_domain_path) gimp_config_writer_string (writer, plug_in_def->locale_domain_path); gimp_config_writer_close (writer); } if (plug_in_def->help_domain_name) { gimp_config_writer_open (writer, "help-def"); gimp_config_writer_string (writer, plug_in_def->help_domain_name); if (plug_in_def->help_domain_uri) gimp_config_writer_string (writer, plug_in_def->help_domain_uri); gimp_config_writer_close (writer); } if (plug_in_def->has_init) { gimp_config_writer_open (writer, "has-init"); gimp_config_writer_close (writer); } gimp_config_writer_close (writer); } } g_type_class_unref (enum_class); return gimp_config_writer_finish (writer, "end of pluginrc", error); }
void session_save (Gimp *gimp, gboolean always_save) { GimpConfigWriter *writer; GFile *file; GError *error = NULL; g_return_if_fail (GIMP_IS_GIMP (gimp)); if (sessionrc_deleted && ! always_save) return; file = session_file (gimp); if (gimp->be_verbose) g_print ("Writing '%s'\n", gimp_file_get_utf8_name (file)); writer = gimp_config_writer_new_gfile (file, TRUE, "GIMP sessionrc\n\n" "This file takes session-specific info " "(that is info, you want to keep between " "two GIMP sessions). You are not supposed " "to edit it manually, but of course you " "can do. The sessionrc will be entirely " "rewritten every time you quit GIMP. " "If this file isn't found, defaults are " "used.", NULL); g_object_unref (file); if (!writer) return; gimp_dialog_factory_save (gimp_dialog_factory_get_singleton (), writer); gimp_config_writer_linefeed (writer); gimp_config_writer_open (writer, "hide-docks"); gimp_config_writer_identifier (writer, GIMP_GUI_CONFIG (gimp->config)->hide_docks ? "yes" : "no"); gimp_config_writer_close (writer); gimp_config_writer_open (writer, "single-window-mode"); gimp_config_writer_identifier (writer, GIMP_GUI_CONFIG (gimp->config)->single_window_mode ? "yes" : "no"); gimp_config_writer_close (writer); gimp_config_writer_open (writer, "show-tabs"); gimp_config_writer_printf (writer, GIMP_GUI_CONFIG (gimp->config)->show_tabs ? "yes" : "no"); gimp_config_writer_close (writer); gimp_config_writer_open (writer, "tabs-position"); gimp_config_writer_printf (writer, "%d", GIMP_GUI_CONFIG (gimp->config)->tabs_position); gimp_config_writer_close (writer); gimp_config_writer_open (writer, "last-tip-shown"); gimp_config_writer_printf (writer, "%d", GIMP_GUI_CONFIG (gimp->config)->last_tip_shown); gimp_config_writer_close (writer); if (! gimp_config_writer_finish (writer, "end of sessionrc", &error)) { gimp_message_literal (gimp, NULL, GIMP_MESSAGE_ERROR, error->message); g_clear_error (&error); } dialogs_save_recent_docks (gimp); sessionrc_deleted = FALSE; }