static GdkPixbufAnimation *
splash_image_load (gboolean be_verbose)
{
GdkPixbufAnimation *pixbuf;
gchar *filename;
filename = gimp_personal_rc_file ("gimp-splash.png");
if (be_verbose)
g_printerr ("Trying splash '%s' ... ", filename);
pixbuf = gdk_pixbuf_animation_new_from_file (filename, NULL);
g_free (filename);
if (be_verbose)
g_printerr (pixbuf ? "OK\n" : "failed\n");
if (pixbuf)
return pixbuf;
filename = gimp_personal_rc_file ("splashes");
pixbuf = splash_image_pick_from_dir (filename, be_verbose);
g_free (filename);
if (pixbuf)
return pixbuf;
filename = g_build_filename (gimp_data_directory (),
"images", "gimp-splash.png", NULL);
if (be_verbose)
g_printerr ("Trying splash '%s' ... ", filename);
pixbuf = gdk_pixbuf_animation_new_from_file (filename, NULL);
g_free (filename);
if (be_verbose)
g_printerr (pixbuf ? "OK\n" : "failed\n");
if (pixbuf)
return pixbuf;
filename = g_build_filename (gimp_data_directory (), "splashes", NULL);
pixbuf = splash_image_pick_from_dir (filename, be_verbose);
g_free (filename);
return pixbuf;
}
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;
}
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;
}
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;
}
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;
}
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);
}
/**
* gimp_ui_init:
* @prog_name: The name of the plug-in which will be passed as argv[0] to
* gtk_init(). It's a convention to use the name of the
* executable and _not_ the PDB procedure name.
* @preview: This parameter is unused and exists for historical
* reasons only.
*
* This function initializes GTK+ with gtk_init() and initializes GDK's
* image rendering subsystem (GdkRGB) to follow the GIMP main program's
* colormap allocation/installation policy.
*
* It also sets up various other things so that the plug-in user looks
* and behaves like the GIMP core. This includes selecting the GTK+
* theme and setting up the help system as chosen in the GIMP
* preferences. Any plug-in that provides a user interface should call
* this function.
**/
void
gimp_ui_init (const gchar *prog_name,
gboolean preview)
{
GdkScreen *screen;
const gchar *display_name;
gchar *themerc;
g_return_if_fail (prog_name != NULL);
if (gimp_ui_initialized)
return;
g_set_prgname (prog_name);
display_name = gimp_display_name ();
if (display_name)
{
#if defined (GDK_WINDOWING_X11)
g_setenv ("DISPLAY", display_name, TRUE);
#else
g_setenv ("GDK_DISPLAY", display_name, TRUE);
#endif
}
if (gimp_user_time ())
{
/* Construct a fake startup ID as we only want to pass the
* interaction timestamp, see _gdk_windowing_set_default_display().
*/
gchar *startup_id = g_strdup_printf ("_TIME%u", gimp_user_time ());
g_setenv ("DESKTOP_STARTUP_ID", startup_id, TRUE);
g_free (startup_id);
}
gtk_init (NULL, NULL);
themerc = gimp_personal_rc_file ("themerc");
gtk_rc_add_default_file (themerc);
g_free (themerc);
gdk_set_program_class (gimp_wm_class ());
screen = gdk_screen_get_default ();
gtk_widget_set_default_colormap (gdk_screen_get_rgb_colormap (screen));
gimp_widgets_init (gimp_ui_help_func,
gimp_context_get_foreground,
gimp_context_get_background,
gimp_ensure_modules);
if (! gimp_show_tool_tips ())
gimp_help_disable_tooltips ();
gimp_dialogs_show_help_button (gimp_show_help_button ());
gimp_ui_initialized = TRUE;
}
/**
* gimp_templates_migrate:
* @olddir: the old user directory
*
* Migrating the templaterc from GIMP 2.0 to GIMP 2.2 needs this special
* hack since we changed the way that units are handled. This function
* merges the user's templaterc with the systemwide templaterc. The goal
* is to replace the unit for a couple of default templates with "pixels".
**/
void
gimp_templates_migrate (const gchar *olddir)
{
GimpContainer *templates = gimp_list_new (GIMP_TYPE_TEMPLATE, TRUE);
gchar *filename = gimp_personal_rc_file ("templaterc");
if (gimp_config_deserialize_file (GIMP_CONFIG (templates), filename,
NULL, NULL))
{
gchar *tmp = g_build_filename (gimp_sysconf_directory (),
"templaterc", NULL);
if (olddir && (strstr (olddir, "2.0") || strstr (olddir, "2.2")))
{
/* We changed the spelling of a couple of template names:
*
* - from upper to lower case between 2.0 and 2.2
* - from "dpi" to "ppi" between 2.2 and 2.4
*/
GimpContainerClass *class = GIMP_CONTAINER_GET_CLASS (templates);
gpointer func = class->get_child_by_name;
class->get_child_by_name = gimp_templates_migrate_get_child_by_name;
gimp_config_deserialize_file (GIMP_CONFIG (templates),
tmp, NULL, NULL);
class->get_child_by_name = func;
}
else
{
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 gchar *
gimp_plug_in_manager_get_pluginrc (GimpPlugInManager *manager)
{
Gimp *gimp = manager->gimp;
gchar *pluginrc;
if (gimp->config->plug_in_rc_path)
{
pluginrc = gimp_config_path_expand (gimp->config->plug_in_rc_path,
TRUE, NULL);
if (! g_path_is_absolute (pluginrc))
{
gchar *str = g_build_filename (gimp_directory (), pluginrc, NULL);
g_free (pluginrc);
pluginrc = str;
}
}
else
{
pluginrc = gimp_personal_rc_file ("pluginrc");
}
return pluginrc;
}
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);
}
/**
* gimp_ui_init:
* @prog_name: The name of the plug-in which will be passed as argv[0] to
* gtk_init(). It's a convention to use the name of the
* executable and _not_ the PDB procedure name or something.
* @preview: This parameter is unused and exists for historical
* reasons only.
*
* This function initializes GTK+ with gtk_init() and initializes GDK's
* image rendering subsystem (GdkRGB) to follow the GIMP main program's
* colormap allocation/installation policy.
*
* GIMP's colormap policy can be determinded by the user with the
* gimprc variables @min_colors and @install_cmap.
**/
void
gimp_ui_init (const gchar *prog_name,
gboolean preview)
{
const gchar *display_name;
gchar *themerc;
GdkScreen *screen;
g_return_if_fail (prog_name != NULL);
if (gimp_ui_initialized)
return;
g_set_prgname (prog_name);
display_name = gimp_display_name ();
if (display_name)
{
#if defined (GDK_WINDOWING_X11)
const gchar var_name[] = "DISPLAY";
#else
const gchar var_name[] = "GDK_DISPLAY";
#endif
putenv (g_strdup_printf ("%s=%s", var_name, display_name));
}
gtk_init (NULL, NULL);
themerc = gimp_personal_rc_file ("themerc");
gtk_rc_add_default_file (themerc);
g_free (themerc);
gdk_set_program_class (gimp_wm_class ());
gdk_rgb_set_min_colors (gimp_min_colors ());
gdk_rgb_set_install (gimp_install_cmap ());
screen = gdk_screen_get_default ();
gtk_widget_set_default_colormap (gdk_screen_get_rgb_colormap (screen));
gimp_widgets_init (gimp_ui_help_func,
gimp_context_get_foreground,
gimp_context_get_background,
gimp_ensure_modules);
if (! gimp_show_tool_tips ())
gimp_help_disable_tooltips ();
gimp_dialogs_show_help_button (gimp_show_help_button ());
gimp_ui_initialized = TRUE;
}
static char *
dialogs_get_dockrc_filename (void)
{
const gchar *basename;
basename = g_getenv ("GIMP_TESTING_DOCKRC_NAME");
if (! basename)
basename = "dockrc";
return gimp_personal_rc_file (basename);
}
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);
}
static GtkWidget *
cdisplay_proof_configure (GimpColorDisplay *display)
{
CdisplayProof *proof = CDISPLAY_PROOF (display);
GtkWidget *table;
GtkWidget *combo;
GtkWidget *toggle;
GtkWidget *dialog;
gchar *history;
table = gtk_table_new (3, 2, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 6);
gtk_table_set_row_spacings (GTK_TABLE (table), 6);
dialog = cdisplay_proof_file_chooser_dialog_new ();
history = gimp_personal_rc_file ("profilerc");
combo = gimp_color_profile_combo_box_new (dialog, history);
g_free (history);
g_signal_connect (dialog, "response",
G_CALLBACK (cdisplay_proof_file_chooser_dialog_response),
combo);
g_signal_connect (combo, "changed",
G_CALLBACK (cdisplay_proof_profile_changed),
proof);
if (proof->profile)
cdisplay_proof_combo_box_set_active (GIMP_COLOR_PROFILE_COMBO_BOX (combo),
proof->profile);
gimp_table_attach_aligned (GTK_TABLE (table), 0, 0,
_("_Profile:"), 0.0, 0.5,
combo, 1, FALSE);
combo = gimp_prop_enum_combo_box_new (G_OBJECT (proof), "intent", 0, 0);
gimp_table_attach_aligned (GTK_TABLE (table), 0, 1,
_("_Intent:"), 0.0, 0.5,
combo, 1, FALSE);
toggle = gimp_prop_check_button_new (G_OBJECT (proof),
"black-point-compensation",
_("_Black Point Compensation"));
gtk_table_attach_defaults (GTK_TABLE (table), toggle, 1, 2, 2, 3);
gtk_widget_show (toggle);
return table;
}
void
gimp_fonts_load (Gimp *gimp)
{
FcConfig *config;
gchar *fonts_conf;
gchar *path;
g_return_if_fail (GIMP_IS_FONT_LIST (gimp->fonts));
gimp_set_busy (gimp);
if (gimp->be_verbose)
g_print ("Loading fonts\n");
gimp_container_freeze (GIMP_CONTAINER (gimp->fonts));
gimp_container_clear (GIMP_CONTAINER (gimp->fonts));
config = FcInitLoadConfig ();
if (! config)
goto cleanup;
fonts_conf = gimp_personal_rc_file (CONF_FNAME);
if (! gimp_fonts_load_fonts_conf (config, fonts_conf))
goto cleanup;
fonts_conf = g_build_filename (gimp_sysconf_directory (), CONF_FNAME, NULL);
if (! gimp_fonts_load_fonts_conf (config, fonts_conf))
goto cleanup;
path = gimp_config_path_expand (gimp->config->font_path, TRUE, NULL);
gimp_fonts_add_directories (config, path);
g_free (path);
if (! FcConfigBuildFonts (config))
{
FcConfigDestroy (config);
goto cleanup;
}
FcConfigSetCurrent (config);
gimp_font_list_restore (GIMP_FONT_LIST (gimp->fonts));
cleanup:
gimp_container_thaw (GIMP_CONTAINER (gimp->fonts));
gimp_unset_busy (gimp);
}
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);
}
}
}
static void
gimp_rc_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec)
{
GimpRc *rc = GIMP_RC (object);
const gchar *filename = NULL;
switch (property_id)
{
case PROP_SYSTEM_GIMPRC:
case PROP_USER_GIMPRC:
filename = g_value_get_string (value);
break;
default:
break;
}
switch (property_id)
{
case PROP_VERBOSE:
rc->verbose = g_value_get_boolean (value);
break;
case PROP_SYSTEM_GIMPRC:
g_free (rc->system_gimprc);
if (filename)
rc->system_gimprc = g_strdup (filename);
else
rc->system_gimprc = g_build_filename (gimp_sysconf_directory (),
"gimprc", NULL);
break;
case PROP_USER_GIMPRC:
g_free (rc->user_gimprc);
if (filename)
rc->user_gimprc = g_strdup (filename);
else
rc->user_gimprc = gimp_personal_rc_file ("gimprc");
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
static gchar *
session_filename (Gimp *gimp)
{
gchar *filename = gimp_personal_rc_file ("sessionrc");
if (gimp->session_name)
{
gchar *tmp = g_strconcat (filename, ".", gimp->session_name, NULL);
g_free (filename);
filename = tmp;
}
return filename;
}
void
menus_restore (Gimp *gimp)
{
gchar *filename;
g_return_if_fail (GIMP_IS_GIMP (gimp));
filename = gimp_personal_rc_file ("menurc");
if (gimp->be_verbose)
g_print ("Parsing '%s'\n", gimp_filename_to_utf8 (filename));
gtk_accel_map_load (filename);
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;
cmsHPROFILE profile;
dialog = lcms_icc_file_chooser_dialog_new ();
history = gimp_personal_rc_file ("profilerc");
combo = gimp_color_profile_combo_box_new (dialog, history);
g_free (history);
g_signal_connect (dialog, "response",
G_CALLBACK (lcms_icc_file_chooser_dialog_response),
combo);
if (config->rgb_profile)
profile = lcms_load_profile (config->rgb_profile, NULL);
else
profile = cmsCreate_sRGBProfile ();
name = lcms_icc_profile_get_desc (profile);
if (! name)
name = lcms_icc_profile_get_name (profile);
cmsCloseProfile (profile);
label = g_strdup_printf (_("RGB workspace (%s)"), name);
g_free (name);
gimp_color_profile_combo_box_add (GIMP_COLOR_PROFILE_COMBO_BOX (combo),
config->rgb_profile, label);
g_free (label);
if (filename)
lcms_icc_combo_box_set_active (GIMP_COLOR_PROFILE_COMBO_BOX (combo),
filename);
else
gtk_combo_box_set_active (GTK_COMBO_BOX (combo), 0);
return combo;
}
void
gimp_tools_save (Gimp *gimp,
gboolean save_tool_options,
gboolean always_save)
{
gchar *filename;
g_return_if_fail (GIMP_IS_GIMP (gimp));
if (save_tool_options && (! tool_options_deleted || always_save))
{
GList *list;
GError *error = NULL;
if (! gimp_contexts_save (gimp, &error))
{
gimp_message_literal (gimp, NULL, GIMP_MESSAGE_WARNING,
error->message);
g_clear_error (&error);
}
gimp_tool_options_create_folder ();
for (list = gimp_get_tool_info_iter (gimp);
list;
list = g_list_next (list))
{
GimpToolInfo *tool_info = GIMP_TOOL_INFO (list->data);
gimp_tool_options_serialize (tool_info->tool_options, NULL);
}
}
filename = gimp_personal_rc_file ("toolrc");
if (gimp->be_verbose)
g_print ("Writing '%s'\n", gimp_filename_to_utf8 (filename));
gimp_config_serialize_to_file (GIMP_CONFIG (gimp->tool_info_list),
filename,
"GIMP toolrc",
"end of toolrc",
NULL, NULL);
g_free (filename);
}
void
gimp_templates_load (Gimp *gimp)
{
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 ("Parsing '%s'\n", gimp_filename_to_utf8 (filename));
if (! gimp_config_deserialize_file (GIMP_CONFIG (gimp->templates),
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 (),
"templaterc", NULL);
if (! gimp_config_deserialize_file (GIMP_CONFIG (gimp->templates),
filename, NULL, &error))
{
gimp_message_literal (gimp, NULL, GIMP_MESSAGE_ERROR,
error->message);
}
}
else
{
gimp_message_literal (gimp, NULL, GIMP_MESSAGE_ERROR, error->message);
}
g_clear_error (&error);
}
gimp_list_reverse (GIMP_LIST (gimp->templates));
g_free (filename);
}
void
menus_save (Gimp *gimp,
gboolean always_save)
{
gchar *filename;
g_return_if_fail (GIMP_IS_GIMP (gimp));
if (menurc_deleted && ! always_save)
return;
filename = gimp_personal_rc_file ("menurc");
if (gimp->be_verbose)
g_print ("Writing '%s'\n", gimp_filename_to_utf8 (filename));
gtk_accel_map_save (filename);
g_free (filename);
menurc_deleted = FALSE;
}
static void
get_saved_plugin_data (void)
{
gchar *pspirc_name = gimp_personal_rc_file (PSPIRC);
gchar *contents;
gsize length;
GMarkupParseContext *context;
static GMarkupParser parser = {
start_element_handler,
end_element_handler,
NULL,
NULL,
NULL
};
UserData user_data;
plug_in_hash = g_hash_table_new (g_str_hash, g_str_equal);
entry_hash = g_hash_table_new (g_str_hash, g_str_equal);
/* Read data for the PS plug-ins found last time */
if (!g_file_get_contents (pspirc_name, &contents, &length, NULL))
{
g_free (pspirc_name);
return;
}
user_data.pspi = NULL;
context = g_markup_parse_context_new (&parser, 0, &user_data, NULL);
if (!g_markup_parse_context_parse (context, contents, length, NULL))
{
g_markup_parse_context_free (context);
g_free (pspirc_name);
return;
}
g_free (contents);
g_markup_parse_context_end_parse (context, NULL);
g_markup_parse_context_free (context);
}
/* This function is memoized. Once it finds the value it permanently
* caches it
* */
GList *
parsepath (void)
{
gchar *rc_path, *path;
if (parsepath_cached_path)
return parsepath_cached_path;
path = gimp_gimprc_query ("gimpressionist-path");
if (path)
{
rc_path = g_filename_from_utf8 (path, -1, NULL, NULL, NULL);
g_free (path);
}
else
{
gchar *gimprc = gimp_personal_rc_file ("gimprc");
gchar *full_path = gimp_config_build_data_path ("gimpressionist");
gchar *esc_path = g_strescape (full_path, NULL);
g_message (_("No %s in gimprc:\n"
"You need to add an entry like\n"
"(%s \"%s\")\n"
"to your %s file."),
"gflare-path", "gflare-path",
esc_path, gimp_filename_to_utf8 (gimprc));
g_free (gimprc);
g_free (esc_path);
rc_path = gimp_config_path_expand (full_path, TRUE, NULL);
g_free (full_path);
}
parsepath_cached_path = gimp_path_parse (rc_path, 16, FALSE, NULL);
g_free (rc_path);
return parsepath_cached_path;
}
void
themes_init (Gimp *gimp)
{
GimpGuiConfig *config;
gchar *themerc;
g_return_if_fail (GIMP_IS_GIMP (gimp));
config = GIMP_GUI_CONFIG (gimp->config);
themes_hash = g_hash_table_new_full (g_str_hash,
g_str_equal,
g_free,
g_free);
if (config->theme_path)
{
gchar *path;
path = gimp_config_path_expand (config->theme_path, TRUE, NULL);
gimp_datafiles_read_directories (path,
G_FILE_TEST_IS_DIR,
themes_directories_foreach,
gimp);
g_free (path);
}
themes_apply_theme (gimp, config->theme);
themerc = gimp_personal_rc_file ("themerc");
gtk_rc_parse (themerc);
g_free (themerc);
g_signal_connect (config, "notify::theme",
G_CALLBACK (themes_theme_change_notify),
gimp);
}
static gchar *
session_filename (Gimp *gimp)
{
const gchar *basename;
gchar *filename;
basename = g_getenv ("GIMP_TESTING_SESSIONRC_NAME");
if (! basename)
basename = "sessionrc";
filename = gimp_personal_rc_file (basename);
if (gimp->session_name)
{
gchar *tmp = g_strconcat (filename, ".", gimp->session_name, NULL);
g_free (filename);
filename = tmp;
}
return filename;
}
gboolean
gimp_contexts_clear (Gimp *gimp,
GError **error)
{
gchar *filename;
gboolean success = TRUE;
g_return_val_if_fail (GIMP_IS_GIMP (gimp), FALSE);
filename = gimp_personal_rc_file ("contextrc");
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;
}
g_free (filename);
return success;
}
