/** * 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); GFile *file = gimp_directory_file ("templaterc", NULL); if (gimp_config_deserialize_gfile (GIMP_CONFIG (templates), file, NULL, NULL)) { GFile *sysconf_file; sysconf_file = gimp_sysconf_directory_file ("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_gfile (GIMP_CONFIG (templates), sysconf_file, NULL, NULL); class->get_child_by_name = func; } else {
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"; GFile *file; GError *error = NULL; g_return_if_fail (GIMP_IS_GIMP (gimp)); g_return_if_fail (GIMP_IS_LIST (gimp->templates)); file = gimp_directory_file ("templaterc", NULL); if (gimp->be_verbose) g_print ("Writing '%s'\n", gimp_file_get_utf8_name (file)); if (! gimp_config_serialize_to_gfile (GIMP_CONFIG (gimp->templates), file, header, footer, NULL, &error)) { gimp_message_literal (gimp, NULL, GIMP_MESSAGE_ERROR, error->message); g_error_free (error); } g_object_unref (file); }
gboolean gimp_contexts_clear (Gimp *gimp, GError **error) { GFile *file; GError *my_error = NULL; gboolean success = TRUE; g_return_val_if_fail (GIMP_IS_GIMP (gimp), FALSE); file = gimp_directory_file ("contextrc", NULL); if (! g_file_delete (file, NULL, &my_error) && my_error->code != G_IO_ERROR_NOT_FOUND) { success = FALSE; g_set_error (error, GIMP_ERROR, GIMP_FAILED, _("Deleting \"%s\" failed: %s"), gimp_file_get_utf8_name (file), my_error->message); } g_clear_error (&my_error); g_object_unref (file); return success; }
gboolean gimp_contexts_save (Gimp *gimp, GError **error) { GFile *file; gboolean success; g_return_val_if_fail (GIMP_IS_GIMP (gimp), FALSE); g_return_val_if_fail (error == NULL || *error == NULL, FALSE); file = gimp_directory_file ("contextrc", NULL); if (gimp->be_verbose) g_print ("Writing '%s'\n", gimp_file_get_utf8_name (file)); success = gimp_config_serialize_to_gfile (GIMP_CONFIG (gimp_get_user_context (gimp)), file, "GIMP user context", "end of user context", NULL, error); g_object_unref (file); return success; }
void gimp_fonts_load (Gimp *gimp) { FcConfig *config; GFile *fonts_conf; GList *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_directory_file (CONF_FNAME, NULL); if (! gimp_fonts_load_fonts_conf (config, fonts_conf)) goto cleanup; fonts_conf = gimp_sysconf_directory_file (CONF_FNAME, NULL); if (! gimp_fonts_load_fonts_conf (config, fonts_conf)) goto cleanup; path = gimp_config_path_expand_to_files (gimp->config->font_path, FALSE); gimp_fonts_add_directories (config, path); g_list_free_full (path, (GDestroyNotify) g_object_unref); 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; 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); } } }
static GtkWidget * gimp_operation_tool_get_settings_ui (GimpImageMapTool *im_tool, GimpContainer *settings, GFile *settings_file, const gchar *import_dialog_title, const gchar *export_dialog_title, const gchar *file_dialog_help_id, GFile *default_folder, GtkWidget **settings_box) { GimpOperationTool *tool = GIMP_OPERATION_TOOL (im_tool); GType type = G_TYPE_FROM_INSTANCE (im_tool->config); GtkWidget *widget; gchar *basename; GFile *file; gchar *import_title; gchar *export_title; settings = gimp_gegl_get_config_container (type); if (! gimp_list_get_sort_func (GIMP_LIST (settings))) gimp_list_set_sort_func (GIMP_LIST (settings), (GCompareFunc) gimp_settings_compare); basename = g_strconcat (G_OBJECT_TYPE_NAME (im_tool->config), ".settings", NULL); file = gimp_directory_file ("filters", basename, NULL); g_free (basename); import_title = g_strdup_printf (_("Import '%s' Settings"), tool->undo_desc); export_title = g_strdup_printf (_("Export '%s' Settings"), tool->undo_desc); widget = GIMP_IMAGE_MAP_TOOL_CLASS (parent_class)->get_settings_ui (im_tool, settings, file, import_title, export_title, "help-foo", NULL, /* sic */ settings_box); g_free (import_title); g_free (export_title); g_object_unref (file); return widget; }
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); }
GFile * gimp_tool_info_get_options_file (GimpToolInfo *tool_info, const gchar *suffix) { gchar *basename; GFile *file; g_return_val_if_fail (GIMP_IS_TOOL_INFO (tool_info), NULL); /* also works for a NULL suffix */ basename = g_strconcat (gimp_object_get_name (tool_info), suffix, NULL); file = gimp_directory_file ("tool-options", basename, NULL); g_free (basename); return file; }
void gimp_tools_save (Gimp *gimp, gboolean save_tool_options, gboolean always_save) { GFile *file; 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); } } file = gimp_directory_file ("toolrc", NULL); if (gimp->be_verbose) g_print ("Writing '%s'\n", gimp_file_get_utf8_name (file)); gimp_config_serialize_to_gfile (GIMP_CONFIG (gimp->tool_info_list), file, "GIMP toolrc", "end of toolrc", NULL, NULL); g_object_unref (file); }
void gimp_templates_load (Gimp *gimp) { GFile *file; GError *error = NULL; g_return_if_fail (GIMP_IS_GIMP (gimp)); g_return_if_fail (GIMP_IS_LIST (gimp->templates)); file = gimp_directory_file ("templaterc", NULL); if (gimp->be_verbose) g_print ("Parsing '%s'\n", gimp_file_get_utf8_name (file)); if (! gimp_config_deserialize_gfile (GIMP_CONFIG (gimp->templates), file, NULL, &error)) { if (error->code == GIMP_CONFIG_ERROR_OPEN_ENOENT) { g_clear_error (&error); g_object_unref (file); file = gimp_sysconf_directory_file ("templaterc", NULL); if (! gimp_config_deserialize_gfile (GIMP_CONFIG (gimp->templates), file, 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_object_unref (file); }
static void gimp_rc_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec) { GimpRc *rc = GIMP_RC (object); switch (property_id) { case PROP_VERBOSE: rc->verbose = g_value_get_boolean (value); break; case PROP_SYSTEM_GIMPRC: if (rc->system_gimprc) g_object_unref (rc->system_gimprc); if (g_value_get_object (value)) rc->system_gimprc = g_value_dup_object (value); else rc->system_gimprc = gimp_sysconf_directory_file ("gimprc", NULL); break; case PROP_USER_GIMPRC: if (rc->user_gimprc) g_object_unref (rc->user_gimprc); if (g_value_get_object (value)) rc->user_gimprc = g_value_dup_object (value); else rc->user_gimprc = gimp_directory_file ("gimprc", NULL); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); break; } }
static GFile * session_file (Gimp *gimp) { const gchar *basename; gchar *filename; GFile *file; basename = g_getenv ("GIMP_TESTING_SESSIONRC_NAME"); if (! basename) basename = "sessionrc"; if (gimp->session_name) filename = g_strconcat (basename, ".", gimp->session_name, NULL); else filename = g_strdup (basename); file = gimp_directory_file (filename, NULL); g_free (filename); return file; }
gboolean gimp_contexts_load (Gimp *gimp, GError **error) { GFile *file; GError *my_error = NULL; gboolean success; g_return_val_if_fail (GIMP_IS_GIMP (gimp), FALSE); g_return_val_if_fail (error == NULL || *error == NULL, FALSE); file = gimp_directory_file ("contextrc", NULL); if (gimp->be_verbose) g_print ("Parsing '%s'\n", gimp_file_get_utf8_name (file)); success = gimp_config_deserialize_gfile (GIMP_CONFIG (gimp_get_user_context (gimp)), file, NULL, &my_error); g_object_unref (file); if (! success) { if (my_error->code == GIMP_CONFIG_ERROR_OPEN_ENOENT) { g_clear_error (&my_error); success = TRUE; } else { g_propagate_error (error, my_error); } } return success; }
void gimp_parasiterc_load (Gimp *gimp) { GFile *file; GError *error = NULL; g_return_if_fail (GIMP_IS_GIMP (gimp)); file = gimp_directory_file ("parasiterc", NULL); if (gimp->be_verbose) g_print ("Parsing '%s'\n", gimp_file_get_utf8_name (file)); if (! gimp_config_deserialize_gfile (GIMP_CONFIG (gimp->parasites), file, NULL, &error)) { if (error->code != GIMP_CONFIG_ERROR_OPEN_ENOENT) gimp_message_literal (gimp, NULL, GIMP_MESSAGE_ERROR, error->message); g_error_free (error); } g_object_unref (file); }
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); } }
void gimp_unitrc_load (Gimp *gimp) { GFile *file; GScanner *scanner; GTokenType token; GError *error = NULL; g_return_if_fail (GIMP_IS_GIMP (gimp)); file = gimp_directory_file ("unitrc", NULL); if (gimp->be_verbose) g_print ("Parsing '%s'\n", gimp_file_get_utf8_name (file)); scanner = gimp_scanner_new_gfile (file, &error); if (! scanner && error->code == GIMP_CONFIG_ERROR_OPEN_ENOENT) { g_clear_error (&error); g_object_unref (file); file = gimp_sysconf_directory_file ("unitrc", NULL); scanner = gimp_scanner_new_gfile (file, NULL); } if (! scanner) { g_clear_error (&error); g_object_unref (file); return; } g_scanner_scope_add_symbol (scanner, 0, "unit-info", GINT_TO_POINTER (UNIT_INFO)); g_scanner_scope_add_symbol (scanner, UNIT_INFO, "factor", GINT_TO_POINTER (UNIT_FACTOR)); g_scanner_scope_add_symbol (scanner, UNIT_INFO, "digits", GINT_TO_POINTER (UNIT_DIGITS)); g_scanner_scope_add_symbol (scanner, UNIT_INFO, "symbol", GINT_TO_POINTER (UNIT_SYMBOL)); g_scanner_scope_add_symbol (scanner, UNIT_INFO, "abbreviation", GINT_TO_POINTER (UNIT_ABBREV)); g_scanner_scope_add_symbol (scanner, UNIT_INFO, "singular", GINT_TO_POINTER (UNIT_SINGULAR)); g_scanner_scope_add_symbol (scanner, UNIT_INFO, "plural", GINT_TO_POINTER (UNIT_PLURAL)); token = G_TOKEN_LEFT_PAREN; while (g_scanner_peek_next_token (scanner) == token) { token = g_scanner_get_next_token (scanner); switch (token) { case G_TOKEN_LEFT_PAREN: token = G_TOKEN_SYMBOL; break; case G_TOKEN_SYMBOL: if (scanner->value.v_symbol == GINT_TO_POINTER (UNIT_INFO)) { g_scanner_set_scope (scanner, UNIT_INFO); token = gimp_unitrc_unit_info_deserialize (scanner, gimp); if (token == G_TOKEN_RIGHT_PAREN) g_scanner_set_scope (scanner, 0); } break; case G_TOKEN_RIGHT_PAREN: token = G_TOKEN_LEFT_PAREN; break; default: /* do nothing */ break; } } if (token != G_TOKEN_LEFT_PAREN) { g_scanner_get_next_token (scanner); g_scanner_unexp_token (scanner, token, NULL, NULL, NULL, _("fatal parse error"), TRUE); gimp_message_literal (gimp, NULL, GIMP_MESSAGE_ERROR, error->message); g_clear_error (&error); gimp_config_file_backup_on_error (file, "unitrc", NULL); } gimp_scanner_destroy (scanner); g_object_unref (file); }
void gimp_tools_restore (Gimp *gimp) { GimpContainer *gimp_list; GimpObject *object; GFile *file; GList *list; GError *error = NULL; g_return_if_fail (GIMP_IS_GIMP (gimp)); gimp_list = gimp_list_new (GIMP_TYPE_TOOL_INFO, FALSE); file = gimp_directory_file ("toolrc", NULL); if (gimp->be_verbose) g_print ("Parsing '%s'\n", gimp_file_get_utf8_name (file)); if (gimp_config_deserialize_gfile (GIMP_CONFIG (gimp_list), file, NULL, NULL)) { gint n = gimp_container_get_n_children (gimp->tool_info_list); gint i; gimp_list_reverse (GIMP_LIST (gimp_list)); for (list = GIMP_LIST (gimp_list)->list, i = 0; list; list = g_list_next (list), i++) { const gchar *name; name = gimp_object_get_name (list->data); object = gimp_container_get_child_by_name (gimp->tool_info_list, name); if (object) { g_object_set (object, "visible", GIMP_TOOL_INFO (list->data)->visible, NULL); gimp_container_reorder (gimp->tool_info_list, object, MIN (i, n - 1)); } } } g_object_unref (file); g_object_unref (gimp_list); /* make the generic operation tool invisible by default */ object = gimp_container_get_child_by_name (gimp->tool_info_list, "gimp-operation-tool"); if (object) g_object_set (object, "visible", FALSE, NULL); for (list = gimp_get_tool_info_iter (gimp); list; list = g_list_next (list)) { GimpToolInfo *tool_info = GIMP_TOOL_INFO (list->data); /* get default values from prefs (see bug #120832) */ gimp_config_reset (GIMP_CONFIG (tool_info->tool_options)); } if (! gimp_contexts_load (gimp, &error)) { gimp_message_literal (gimp, NULL, GIMP_MESSAGE_WARNING, error->message); g_clear_error (&error); } /* make sure there is always a tool active, so broken config files * can't leave us with no initial tool */ if (! gimp_context_get_tool (gimp_get_user_context (gimp))) { gimp_context_set_tool (gimp_get_user_context (gimp), gimp_get_tool_info_iter (gimp)->data); } for (list = gimp_get_tool_info_iter (gimp); list; list = g_list_next (list)) { GimpToolInfo *tool_info = GIMP_TOOL_INFO (list->data); GimpToolOptionsGUIFunc options_gui_func; GtkWidget *options_gui; /* copy all context properties except those the tool actually * uses, because the subsequent deserialize() on the tool * options will only set the properties that were set to * non-default values at the time of saving, and we want to * keep these default values as if they have been saved. * (see bug #541586). */ gimp_context_copy_properties (gimp_get_user_context (gimp), GIMP_CONTEXT (tool_info->tool_options), GIMP_CONTEXT_PROP_MASK_ALL &~ (tool_info->context_props | GIMP_CONTEXT_PROP_MASK_TOOL | GIMP_CONTEXT_PROP_MASK_PAINT_INFO)); gimp_tool_options_deserialize (tool_info->tool_options, NULL); options_gui_func = g_object_get_data (G_OBJECT (tool_info), "gimp-tool-options-gui-func"); if (options_gui_func) { options_gui = (* options_gui_func) (tool_info->tool_options); } else { GtkWidget *label; options_gui = gimp_tool_options_gui (tool_info->tool_options); label = gtk_label_new (_("This tool has\nno options.")); gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_CENTER); gimp_label_set_attributes (GTK_LABEL (label), PANGO_ATTR_STYLE, PANGO_STYLE_ITALIC, -1); gtk_box_pack_start (GTK_BOX (options_gui), label, FALSE, FALSE, 6); gtk_widget_show (label); } gimp_tools_set_tool_options_gui (tool_info->tool_options, g_object_ref_sink (options_gui)); } }
void gimp_modules_load (Gimp *gimp) { GFile *file; GScanner *scanner; gchar *module_load_inhibit = NULL; g_return_if_fail (GIMP_IS_GIMP (gimp)); if (gimp->no_interface) return; /* FIXME, gimp->be_verbose is not yet initialized in init() */ gimp->module_db->verbose = gimp->be_verbose; file = gimp_directory_file ("modulerc", NULL); if (gimp->be_verbose) g_print ("Parsing '%s'\n", gimp_file_get_utf8_name (file)); scanner = gimp_scanner_new_gfile (file, NULL); g_object_unref (file); if (scanner) { GTokenType token; GError *error = NULL; #define MODULE_LOAD_INHIBIT 1 g_scanner_scope_add_symbol (scanner, 0, "module-load-inhibit", GINT_TO_POINTER (MODULE_LOAD_INHIBIT)); token = G_TOKEN_LEFT_PAREN; while (g_scanner_peek_next_token (scanner) == token) { token = g_scanner_get_next_token (scanner); switch (token) { case G_TOKEN_LEFT_PAREN: token = G_TOKEN_SYMBOL; break; case G_TOKEN_SYMBOL: if (scanner->value.v_symbol == GINT_TO_POINTER (MODULE_LOAD_INHIBIT)) { token = G_TOKEN_STRING; if (! gimp_scanner_parse_string_no_validate (scanner, &module_load_inhibit)) goto error; } token = G_TOKEN_RIGHT_PAREN; break; case G_TOKEN_RIGHT_PAREN: token = G_TOKEN_LEFT_PAREN; break; default: /* do nothing */ break; } } #undef MODULE_LOAD_INHIBIT if (token != G_TOKEN_LEFT_PAREN) { g_scanner_get_next_token (scanner); g_scanner_unexp_token (scanner, token, NULL, NULL, NULL, _("fatal parse error"), TRUE); } error: if (error) { gimp_message_literal (gimp, NULL, GIMP_MESSAGE_ERROR, error->message); g_clear_error (&error); } gimp_scanner_destroy (scanner); } if (module_load_inhibit) { gimp_module_db_set_load_inhibit (gimp->module_db, module_load_inhibit); g_free (module_load_inhibit); } gimp_module_db_load (gimp->module_db, gimp->config->module_path); }
void app_run (const gchar *full_prog_name, const gchar **filenames, GFile *alternate_system_gimprc, GFile *alternate_gimprc, const gchar *session_name, const gchar *batch_interpreter, const gchar **batch_commands, gboolean as_new, gboolean no_interface, gboolean no_data, gboolean no_fonts, gboolean no_splash, gboolean be_verbose, gboolean use_shm, gboolean use_cpu_accel, gboolean console_messages, gboolean use_debug_handler, gboolean show_playground, GimpStackTraceMode stack_trace_mode, GimpPDBCompatMode pdb_compat_mode) { GimpInitStatusFunc update_status_func = NULL; Gimp *gimp; GMainLoop *loop; GMainLoop *run_loop; GFile *default_folder = NULL; GFile *gimpdir; if (filenames && filenames[0] && ! filenames[1] && g_file_test (filenames[0], G_FILE_TEST_IS_DIR)) { if (g_path_is_absolute (filenames[0])) { default_folder = g_file_new_for_path (filenames[0]); } else { gchar *absolute = g_build_path (G_DIR_SEPARATOR_S, g_get_current_dir (), filenames[0], NULL); default_folder = g_file_new_for_path (absolute); g_free (absolute); } filenames = NULL; } /* Create an instance of the "Gimp" object which is the root of the * core object system */ gimp = gimp_new (full_prog_name, session_name, default_folder, be_verbose, no_data, no_fonts, no_interface, use_shm, use_cpu_accel, console_messages, show_playground, stack_trace_mode, pdb_compat_mode); if (default_folder) g_object_unref (default_folder); gimp_cpu_accel_set_use (use_cpu_accel); errors_init (gimp, full_prog_name, use_debug_handler, stack_trace_mode); units_init (gimp); /* Check if the user's gimp_directory exists */ gimpdir = gimp_directory_file (NULL); if (g_file_query_file_type (gimpdir, G_FILE_QUERY_INFO_NONE, NULL) != G_FILE_TYPE_DIRECTORY) { GimpUserInstall *install = gimp_user_install_new (be_verbose); #ifdef GIMP_CONSOLE_COMPILATION gimp_user_install_run (install); #else if (! (no_interface ? gimp_user_install_run (install) : user_install_dialog_run (install))) exit (EXIT_FAILURE); #endif gimp_user_install_free (install); } g_object_unref (gimpdir); gimp_load_config (gimp, alternate_system_gimprc, alternate_gimprc); /* change the locale if a language if specified */ language_init (gimp->config->language); /* initialize lowlevel stuff */ gimp_gegl_init (gimp); /* Connect our restore_after callback before gui_init() connects * theirs, so ours runs first and can grab the initial monitor * before the GUI's restore_after callback resets it. */ g_signal_connect_after (gimp, "restore", G_CALLBACK (app_restore_after_callback), NULL); #ifndef GIMP_CONSOLE_COMPILATION if (! no_interface) update_status_func = gui_init (gimp, no_splash); #endif if (! update_status_func) update_status_func = app_init_update_noop; /* Create all members of the global Gimp instance which need an already * parsed gimprc, e.g. the data factories */ gimp_initialize (gimp, update_status_func); /* Load all data files */ gimp_restore (gimp, update_status_func); /* enable autosave late so we don't autosave when the * monitor resolution is set in gui_init() */ gimp_rc_set_autosave (GIMP_RC (gimp->edit_config), TRUE); loop = run_loop = g_main_loop_new (NULL, FALSE); g_signal_connect_after (gimp, "exit", G_CALLBACK (app_exit_after_callback), &run_loop); /* Load the images given on the command-line. */ if (filenames) { gint i; for (i = 0; filenames[i] != NULL; i++) { if (run_loop) { GFile *file = g_file_new_for_commandline_arg (filenames[i]); file_open_from_command_line (gimp, file, as_new, initial_screen, initial_monitor); g_object_unref (file); } } } if (run_loop) batch_run (gimp, batch_interpreter, batch_commands); if (run_loop) { gimp_threads_leave (gimp); g_main_loop_run (loop); gimp_threads_enter (gimp); } g_main_loop_unref (loop); g_object_unref (gimp); gimp_debug_instances (); errors_exit (); gegl_exit (); }
void gimp_action_history_init (Gimp *gimp) { GimpGuiConfig *config; GFile *file; GScanner *scanner; GTokenType token; gint count = 0; gint n_items = 0; g_return_if_fail (GIMP_IS_GIMP (gimp)); config = GIMP_GUI_CONFIG (gimp->config); if (history.items != NULL) { g_warning ("%s: must be run only once.", G_STRFUNC); return; } file = gimp_directory_file (GIMP_ACTION_HISTORY_FILENAME, NULL); if (gimp->be_verbose) g_print ("Parsing '%s'\n", gimp_file_get_utf8_name (file)); scanner = gimp_scanner_new_gfile (file, NULL); g_object_unref (file); if (! scanner) return; g_scanner_scope_add_symbol (scanner, 0, "history-item", GINT_TO_POINTER (HISTORY_ITEM)); token = G_TOKEN_LEFT_PAREN; while (g_scanner_peek_next_token (scanner) == token) { token = g_scanner_get_next_token (scanner); switch (token) { case G_TOKEN_LEFT_PAREN: token = G_TOKEN_SYMBOL; break; case G_TOKEN_SYMBOL: if (scanner->value.v_symbol == GINT_TO_POINTER (HISTORY_ITEM)) { gchar *action_name; token = G_TOKEN_STRING; if (g_scanner_peek_next_token (scanner) != token) break; if (! gimp_scanner_parse_string (scanner, &action_name)) break; token = G_TOKEN_INT; if (g_scanner_peek_next_token (scanner) != token || ! gimp_scanner_parse_int (scanner, &count)) { g_free (action_name); break; } history.items = g_list_insert_sorted (history.items, gimp_action_history_item_new (action_name, count), (GCompareFunc) gimp_action_history_init_compare_func); n_items++; g_free (action_name); } token = G_TOKEN_RIGHT_PAREN; break; case G_TOKEN_RIGHT_PAREN: token = G_TOKEN_LEFT_PAREN; if (n_items >= config->action_history_size) goto done; break; default: /* do nothing */ break; } } done: gimp_scanner_destroy (scanner); if (count > 1) { GList *actions; gint i; for (actions = history.items, i = 0; actions && i < config->action_history_size; actions = g_list_next (actions), i++) { GimpActionHistoryItem *action = actions->data; action->count -= count - 1; } } }
gboolean gimp_tags_user_install (void) { GFile *file; GOutputStream *output; GMarkupParser markup_parser; GimpXmlParser *xml_parser; const char *tags_locale; GimpTagsInstaller tags_installer = { 0, }; GError *error = NULL; gboolean result = TRUE; /* This is a special string to specify the language identifier to * look for in the gimp-tags-default.xml file. Please translate the * C in it according to the name of the po file used for * gimp-tags-default.xml. E.g. lithuanian for the translation, * that would be "tags-locale:lt". */ tags_locale = _("tags-locale:C"); if (g_str_has_prefix (tags_locale, "tags-locale:")) { tags_locale += strlen ("tags-locale:"); if (*tags_locale && *tags_locale != 'C') tags_installer.locale = tags_locale; } else { g_warning ("Wrong translation for 'tags-locale:', fix the translation!"); } tags_installer.buf = g_string_new (NULL); g_string_append (tags_installer.buf, "<?xml version='1.0' encoding='UTF-8'?>\n"); g_string_append (tags_installer.buf, "<tags>\n"); markup_parser.start_element = gimp_tags_installer_load_start_element; markup_parser.end_element = gimp_tags_installer_load_end_element; markup_parser.text = gimp_tags_installer_load_text; markup_parser.passthrough = NULL; markup_parser.error = NULL; xml_parser = gimp_xml_parser_new (&markup_parser, &tags_installer); file = gimp_data_directory_file ("tags", "gimp-tags-default.xml", NULL); result = gimp_xml_parser_parse_gfile (xml_parser, file, &error); g_object_unref (file); gimp_xml_parser_free (xml_parser); if (! result) { g_string_free (tags_installer.buf, TRUE); return FALSE; } g_string_append (tags_installer.buf, "\n</tags>\n"); file = gimp_directory_file (GIMP_TAGS_FILE, NULL); output = G_OUTPUT_STREAM (g_file_replace (file, NULL, FALSE, G_FILE_CREATE_NONE, NULL, &error)); if (! output) { g_printerr ("%s\n", error->message); result = FALSE; } else if (! g_output_stream_write_all (output, tags_installer.buf->str, tags_installer.buf->len, NULL, NULL, &error)) { GCancellable *cancellable = g_cancellable_new (); g_printerr (_("Error writing '%s': %s"), gimp_file_get_utf8_name (file), error->message); result = FALSE; /* Cancel the overwrite initiated by g_file_replace(). */ g_cancellable_cancel (cancellable); g_output_stream_close (output, cancellable, NULL); g_object_unref (cancellable); } else if (! g_output_stream_close (output, NULL, &error)) { g_printerr (_("Error closing '%s': %s"), gimp_file_get_utf8_name (file), error->message); result = FALSE; } if (output) g_object_unref (output); g_clear_error (&error); g_object_unref (file); g_string_free (tags_installer.buf, TRUE); return result; }
void gimp_fonts_load (Gimp *gimp, GimpInitStatusFunc status_callback) { FcConfig *config; GFile *fonts_conf; GList *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_directory_file (CONF_FNAME, NULL); if (! gimp_fonts_load_fonts_conf (config, fonts_conf)) goto cleanup; fonts_conf = gimp_sysconf_directory_file (CONF_FNAME, NULL); if (! gimp_fonts_load_fonts_conf (config, fonts_conf)) goto cleanup; path = gimp_config_path_expand_to_files (gimp->config->font_path, FALSE); gimp_fonts_add_directories (config, path); g_list_free_full (path, (GDestroyNotify) g_object_unref); if (status_callback) { gint64 end_time; GThread *cache_thread; GimpFontsLoadFuncData data; /* We perform font cache initialization in a separate thread, so * in the case a cache rebuild is to be done it will not block * the UI. */ data.config = config; g_mutex_init (&data.mutex); g_cond_init (&data.cond); data.caching_complete = FALSE; cache_thread = g_thread_new ("font-cacher", (GThreadFunc) gimp_fonts_load_thread, &data); g_mutex_lock (&data.mutex); end_time = g_get_monotonic_time () + 0.1 * G_TIME_SPAN_SECOND; while (! data.caching_complete) if (! g_cond_wait_until (&data.cond, &data.mutex, end_time)) { status_callback (NULL, NULL, 0.6); end_time += 0.1 * G_TIME_SPAN_SECOND; continue; } g_mutex_unlock (&data.mutex); g_thread_join (cache_thread); g_mutex_clear (&data.mutex); g_cond_clear (&data.cond); } else { gimp_fonts_load_func (config); } gimp_font_list_restore (GIMP_FONT_LIST (gimp->fonts)); cleanup: gimp_container_thaw (GIMP_CONTAINER (gimp->fonts)); gimp_unset_busy (gimp); }
static gboolean gimp_image_map_tool_initialize (GimpTool *tool, GimpDisplay *display, GError **error) { GimpImageMapTool *im_tool = GIMP_IMAGE_MAP_TOOL (tool); GimpToolInfo *tool_info = tool->tool_info; GimpImage *image = gimp_display_get_image (display); GimpDrawable *drawable = gimp_image_get_active_drawable (image); GimpDisplayShell *shell = gimp_display_get_shell (display); if (! drawable) return FALSE; if (gimp_viewable_get_children (GIMP_VIEWABLE (drawable))) { g_set_error_literal (error, GIMP_ERROR, GIMP_FAILED, _("Cannot modify the pixels of layer groups.")); return FALSE; } if (gimp_item_is_content_locked (GIMP_ITEM (drawable))) { g_set_error_literal (error, GIMP_ERROR, GIMP_FAILED, _("The active layer's pixels are locked.")); return FALSE; } if (! gimp_item_is_visible (GIMP_ITEM (drawable))) { g_set_error_literal (error, GIMP_ERROR, GIMP_FAILED, _("The active layer is not visible.")); return FALSE; } if (im_tool->active_picker) gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (im_tool->active_picker), FALSE); /* set display so the dialog can be hidden on display destruction */ tool->display = display; if (im_tool->config) gimp_config_reset (GIMP_CONFIG (im_tool->config)); if (! im_tool->gui) { GimpImageMapToolClass *klass = GIMP_IMAGE_MAP_TOOL_GET_CLASS (im_tool); GtkWidget *vbox; GtkWidget *hbox; GtkWidget *toggle; gchar *operation_name; /* disabled for at least GIMP 2.8 */ im_tool->overlay = FALSE; im_tool->gui = gimp_tool_gui_new (tool_info, im_tool->title, im_tool->description, im_tool->icon_name, im_tool->help_id, gtk_widget_get_screen (GTK_WIDGET (shell)), gimp_widget_get_monitor (GTK_WIDGET (shell)), im_tool->overlay, GIMP_STOCK_RESET, RESPONSE_RESET, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gimp_tool_gui_set_default_response (im_tool->gui, GTK_RESPONSE_OK); gimp_tool_gui_set_alternative_button_order (im_tool->gui, RESPONSE_RESET, GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); vbox = gimp_tool_gui_get_vbox (im_tool->gui); g_signal_connect_object (im_tool->gui, "response", G_CALLBACK (gimp_image_map_tool_response), G_OBJECT (im_tool), 0); if (im_tool->config && klass->settings_name) { GType type = G_TYPE_FROM_INSTANCE (im_tool->config); GimpContainer *settings; GFile *settings_file; GFile *default_folder; GtkWidget *settings_ui; settings = gimp_gegl_config_get_container (type); if (! gimp_list_get_sort_func (GIMP_LIST (settings))) gimp_list_set_sort_func (GIMP_LIST (settings), (GCompareFunc) gimp_settings_compare); settings_file = gimp_tool_info_get_options_file (tool_info, ".settings"); default_folder = gimp_directory_file (klass->settings_name, NULL); settings_ui = klass->get_settings_ui (im_tool, settings, settings_file, klass->import_dialog_title, klass->export_dialog_title, im_tool->help_id, default_folder, &im_tool->settings_box); g_object_unref (default_folder); g_object_unref (settings_file); gtk_box_pack_start (GTK_BOX (vbox), settings_ui, FALSE, FALSE, 0); gtk_widget_show (settings_ui); } /* The gamma hack toggle */ toggle = gtk_check_button_new_with_label ("Gamma hack (temp hack, please ignore)"); gtk_box_pack_end (GTK_BOX (vbox), toggle, FALSE, FALSE, 0); gtk_widget_show (toggle); g_signal_connect (toggle, "toggled", G_CALLBACK (gamma_hack), im_tool); /* The preview and split view toggles */ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4); gtk_box_pack_end (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); toggle = gimp_prop_check_button_new (G_OBJECT (tool_info->tool_options), "preview", NULL); gtk_box_pack_start (GTK_BOX (hbox), toggle, TRUE, TRUE, 0); gtk_widget_show (toggle); toggle = gimp_prop_check_button_new (G_OBJECT (tool_info->tool_options), "preview-split", NULL); gtk_box_pack_start (GTK_BOX (hbox), toggle, FALSE, FALSE, 0); gtk_widget_show (toggle); g_object_bind_property (G_OBJECT (tool_info->tool_options), "preview", toggle, "sensitive", G_BINDING_SYNC_CREATE); /* The area combo */ gegl_node_get (im_tool->operation, "operation", &operation_name, NULL); im_tool->region_combo = gimp_prop_enum_combo_box_new (G_OBJECT (tool_info->tool_options), "region", 0, 0); gtk_box_pack_end (GTK_BOX (vbox), im_tool->region_combo, FALSE, FALSE, 0); if (operation_name && gegl_operation_get_key (operation_name, "position-dependent")) { gtk_widget_show (im_tool->region_combo); } g_free (operation_name); /* Fill in subclass widgets */ gimp_image_map_tool_dialog (im_tool); } else { gimp_tool_gui_set_title (im_tool->gui, im_tool->title); gimp_tool_gui_set_description (im_tool->gui, im_tool->description); gimp_tool_gui_set_icon_name (im_tool->gui, im_tool->icon_name); gimp_tool_gui_set_help_id (im_tool->gui, im_tool->help_id); } gimp_tool_gui_set_shell (im_tool->gui, shell); gimp_tool_gui_set_viewable (im_tool->gui, GIMP_VIEWABLE (drawable)); gimp_tool_gui_show (im_tool->gui); im_tool->drawable = drawable; gimp_image_map_tool_create_map (im_tool); gimp_image_map_tool_preview (im_tool); return TRUE; }