/* * Copyright © 2001 Havoc Pennington * Copyright © 2002 Mathias Hasselmann * Copyright © 2008 Christian Persch * * Mate-terminal is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 3 of the License, or * (at your option) any later version. * * Mate-terminal is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see . */ #include #include #include #include #include #include "terminal-app.h" #include "terminal-debug.h" #include "terminal-intl.h" #include "terminal-profile.h" #include "terminal-screen.h" #include "terminal-type-builtins.h" /* To add a new key, you need to: * * - add an entry to the enum below * - add a #define with its name in terminal-profile.h * - add a gobject property for it in terminal_profile_class_init * - if the property's type needs special casing, add that to * terminal_profile_mateconf_notify_cb and * terminal_profile_mateconf_changeset_add * - if necessary the default value cannot be handled via the paramspec, * handle that in terminal_profile_reset_property_internal */ enum { PROP_0, PROP_ALLOW_BOLD, PROP_BACKGROUND_COLOR, PROP_BACKGROUND_DARKNESS, PROP_BACKGROUND_IMAGE, PROP_BACKGROUND_IMAGE_FILE, PROP_BACKGROUND_TYPE, PROP_BACKSPACE_BINDING, PROP_BOLD_COLOR, PROP_BOLD_COLOR_SAME_AS_FG, PROP_CURSOR_BLINK_MODE, PROP_CURSOR_SHAPE, PROP_CUSTOM_COMMAND, PROP_DEFAULT_SIZE_COLUMNS, PROP_DEFAULT_SIZE_ROWS, PROP_DEFAULT_SHOW_MENUBAR, PROP_DELETE_BINDING, PROP_EXIT_ACTION, PROP_FONT, PROP_FOREGROUND_COLOR, PROP_LOGIN_SHELL, PROP_NAME, PROP_PALETTE, PROP_SCROLL_BACKGROUND, PROP_SCROLLBACK_LINES, PROP_SCROLLBACK_UNLIMITED, PROP_SCROLLBAR_POSITION, PROP_SCROLL_ON_KEYSTROKE, PROP_SCROLL_ON_OUTPUT, PROP_SILENT_BELL, PROP_TITLE, PROP_TITLE_MODE, PROP_UPDATE_RECORDS, PROP_USE_CUSTOM_COMMAND, PROP_USE_CUSTOM_DEFAULT_SIZE, PROP_USE_SKEY, PROP_USE_SYSTEM_FONT, PROP_USE_THEME_COLORS, PROP_VISIBLE_NAME, PROP_WORD_CHARS, LAST_PROP }; #define KEY_ALLOW_BOLD "allow_bold" #define KEY_BACKGROUND_COLOR "background_color" #define KEY_BACKGROUND_DARKNESS "background_darkness" #define KEY_BACKGROUND_IMAGE_FILE "background_image" #define KEY_BACKGROUND_TYPE "background_type" #define KEY_BACKSPACE_BINDING "backspace_binding" #define KEY_BOLD_COLOR "bold_color" #define KEY_BOLD_COLOR_SAME_AS_FG "bold_color_same_as_fg" #define KEY_CURSOR_BLINK_MODE "cursor_blink_mode" #define KEY_CURSOR_SHAPE "cursor_shape" #define KEY_CUSTOM_COMMAND "custom_command" #define KEY_DEFAULT_SHOW_MENUBAR "default_show_menubar" #define KEY_DEFAULT_SIZE_COLUMNS "default_size_columns" #define KEY_DEFAULT_SIZE_ROWS "default_size_rows" #define KEY_DELETE_BINDING "delete_binding" #define KEY_EXIT_ACTION "exit_action" #define KEY_FONT "font" #define KEY_FOREGROUND_COLOR "foreground_color" #define KEY_LOGIN_SHELL "login_shell" #define KEY_PALETTE "palette" #define KEY_SCROLL_BACKGROUND "scroll_background" #define KEY_SCROLLBACK_LINES "scrollback_lines" #define KEY_SCROLLBACK_UNLIMITED "scrollback_unlimited" #define KEY_SCROLLBAR_POSITION "scrollbar_position" #define KEY_SCROLL_ON_KEYSTROKE "scroll_on_keystroke" #define KEY_SCROLL_ON_OUTPUT "scroll_on_output" #define KEY_SILENT_BELL "silent_bell" #define KEY_TITLE_MODE "title_mode" #define KEY_TITLE "title" #define KEY_UPDATE_RECORDS "update_records" #define KEY_USE_CUSTOM_COMMAND "use_custom_command" #define KEY_USE_CUSTOM_DEFAULT_SIZE "use_custom_default_size" #define KEY_USE_SKEY "use_skey" #define KEY_USE_SYSTEM_FONT "use_system_font" #define KEY_USE_THEME_COLORS "use_theme_colors" #define KEY_VISIBLE_NAME "visible_name" #define KEY_WORD_CHARS "word_chars" /* Keep these in sync with the MateConf schema! */ #define DEFAULT_ALLOW_BOLD (TRUE) #define DEFAULT_BACKGROUND_COLOR ("#FFFFDD") #define DEFAULT_BOLD_COLOR_SAME_AS_FG (TRUE) #define DEFAULT_BACKGROUND_DARKNESS (0.5) #define DEFAULT_BACKGROUND_IMAGE_FILE ("") #define DEFAULT_BACKGROUND_IMAGE (NULL) #define DEFAULT_BACKGROUND_TYPE (TERMINAL_BACKGROUND_SOLID) #define DEFAULT_BACKSPACE_BINDING (VTE_ERASE_ASCII_DELETE) #define DEFAULT_CURSOR_BLINK_MODE (VTE_CURSOR_BLINK_SYSTEM) #define DEFAULT_CURSOR_SHAPE (VTE_CURSOR_SHAPE_BLOCK) #define DEFAULT_CUSTOM_COMMAND ("") #define DEFAULT_DEFAULT_SHOW_MENUBAR (TRUE) #define DEFAULT_DEFAULT_SIZE_COLUMNS (80) #define DEFAULT_DEFAULT_SIZE_ROWS (24) #define DEFAULT_DELETE_BINDING (VTE_ERASE_DELETE_SEQUENCE) #define DEFAULT_EXIT_ACTION (TERMINAL_EXIT_CLOSE) #define DEFAULT_FONT ("Monospace 12") #define DEFAULT_FOREGROUND_COLOR ("#000000") #define DEFAULT_LOGIN_SHELL (FALSE) #define DEFAULT_NAME (NULL) #define DEFAULT_PALETTE (terminal_palettes[TERMINAL_PALETTE_TANGO]) #define DEFAULT_SCROLL_BACKGROUND (TRUE) #define DEFAULT_SCROLLBACK_LINES (512) #define DEFAULT_SCROLLBACK_UNLIMITED (FALSE) #define DEFAULT_SCROLLBAR_POSITION (TERMINAL_SCROLLBAR_RIGHT) #define DEFAULT_SCROLL_ON_KEYSTROKE (TRUE) #define DEFAULT_SCROLL_ON_OUTPUT (FALSE) #define DEFAULT_SILENT_BELL (FALSE) #define DEFAULT_TITLE_MODE (TERMINAL_TITLE_REPLACE) #define DEFAULT_TITLE (N_("Terminal")) #define DEFAULT_UPDATE_RECORDS (TRUE) #define DEFAULT_USE_CUSTOM_COMMAND (FALSE) #define DEFAULT_USE_CUSTOM_DEFAULT_SIZE (FALSE) #define DEFAULT_USE_SKEY (TRUE) #define DEFAULT_USE_SYSTEM_FONT (TRUE) #define DEFAULT_USE_THEME_COLORS (TRUE) #define DEFAULT_VISIBLE_NAME (N_("Unnamed")) #define DEFAULT_WORD_CHARS ("-A-Za-z0-9,./?%&#:_=+@~") struct _TerminalProfilePrivate { GValueArray *properties; gboolean *locked; MateConfClient *conf; char *profile_dir; guint notify_id; GSList *dirty_pspecs; guint save_idle_id; GParamSpec *mateconf_notification_pspec; gboolean background_load_failed; guint forgotten : 1; }; /* We have to continue to use these since they're unfortunately different * from the value nicks of the vte_terminal_erase_binding_get_type() enum type. */ static const MateConfEnumStringPair erase_bindings[] = { { VTE_ERASE_AUTO, "auto" }, { VTE_ERASE_ASCII_BACKSPACE, "control-h" }, { VTE_ERASE_ASCII_DELETE, "ascii-del" }, { VTE_ERASE_DELETE_SEQUENCE, "escape-sequence" }, { VTE_ERASE_TTY, "tty" }, { -1, NULL } }; static const GdkColor terminal_palettes[TERMINAL_PALETTE_N_BUILTINS][TERMINAL_PALETTE_SIZE] = { /* Tango palette */ { { 0, 0x0000, 0x0000, 0x0000 }, { 0, 0xcccc, 0x0000, 0x0000 }, { 0, 0x4e4e, 0x9a9a, 0x0606 }, { 0, 0xc4c4, 0xa0a0, 0x0000 }, { 0, 0x3434, 0x6565, 0xa4a4 }, { 0, 0x7575, 0x5050, 0x7b7b }, { 0, 0x0606, 0x9820, 0x9a9a }, { 0, 0xd3d3, 0xd7d7, 0xcfcf }, { 0, 0x5555, 0x5757, 0x5353 }, { 0, 0xefef, 0x2929, 0x2929 }, { 0, 0x8a8a, 0xe2e2, 0x3434 }, { 0, 0xfcfc, 0xe9e9, 0x4f4f }, { 0, 0x7272, 0x9f9f, 0xcfcf }, { 0, 0xadad, 0x7f7f, 0xa8a8 }, { 0, 0x3434, 0xe2e2, 0xe2e2 }, { 0, 0xeeee, 0xeeee, 0xecec } }, /* Linux palette */ { { 0, 0x0000, 0x0000, 0x0000 }, { 0, 0xaaaa, 0x0000, 0x0000 }, { 0, 0x0000, 0xaaaa, 0x0000 }, { 0, 0xaaaa, 0x5555, 0x0000 }, { 0, 0x0000, 0x0000, 0xaaaa }, { 0, 0xaaaa, 0x0000, 0xaaaa }, { 0, 0x0000, 0xaaaa, 0xaaaa }, { 0, 0xaaaa, 0xaaaa, 0xaaaa }, { 0, 0x5555, 0x5555, 0x5555 }, { 0, 0xffff, 0x5555, 0x5555 }, { 0, 0x5555, 0xffff, 0x5555 }, { 0, 0xffff, 0xffff, 0x5555 }, { 0, 0x5555, 0x5555, 0xffff }, { 0, 0xffff, 0x5555, 0xffff }, { 0, 0x5555, 0xffff, 0xffff }, { 0, 0xffff, 0xffff, 0xffff } }, /* XTerm palette */ { { 0, 0x0000, 0x0000, 0x0000 }, { 0, 0xcdcb, 0x0000, 0x0000 }, { 0, 0x0000, 0xcdcb, 0x0000 }, { 0, 0xcdcb, 0xcdcb, 0x0000 }, { 0, 0x1e1a, 0x908f, 0xffff }, { 0, 0xcdcb, 0x0000, 0xcdcb }, { 0, 0x0000, 0xcdcb, 0xcdcb }, { 0, 0xe5e2, 0xe5e2, 0xe5e2 }, { 0, 0x4ccc, 0x4ccc, 0x4ccc }, { 0, 0xffff, 0x0000, 0x0000 }, { 0, 0x0000, 0xffff, 0x0000 }, { 0, 0xffff, 0xffff, 0x0000 }, { 0, 0x4645, 0x8281, 0xb4ae }, { 0, 0xffff, 0x0000, 0xffff }, { 0, 0x0000, 0xffff, 0xffff }, { 0, 0xffff, 0xffff, 0xffff } }, /* RXVT palette */ { { 0, 0x0000, 0x0000, 0x0000 }, { 0, 0xcdcd, 0x0000, 0x0000 }, { 0, 0x0000, 0xcdcd, 0x0000 }, { 0, 0xcdcd, 0xcdcd, 0x0000 }, { 0, 0x0000, 0x0000, 0xcdcd }, { 0, 0xcdcd, 0x0000, 0xcdcd }, { 0, 0x0000, 0xcdcd, 0xcdcd }, { 0, 0xfafa, 0xebeb, 0xd7d7 }, { 0, 0x4040, 0x4040, 0x4040 }, { 0, 0xffff, 0x0000, 0x0000 }, { 0, 0x0000, 0xffff, 0x0000 }, { 0, 0xffff, 0xffff, 0x0000 }, { 0, 0x0000, 0x0000, 0xffff }, { 0, 0xffff, 0x0000, 0xffff }, { 0, 0x0000, 0xffff, 0xffff }, { 0, 0xffff, 0xffff, 0xffff } } }; static const GdkColor default_fg_color = { 0, 0, 0, 0 }; static const GdkColor default_bg_color = { 0, 0xffff, 0xffff, 0xdddd }; enum { FORGOTTEN, LAST_SIGNAL }; static void terminal_profile_finalize (GObject *object); static void terminal_profile_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec); static void ensure_pixbuf_property (TerminalProfile *profile, guint path_prop_id, guint pixbuf_prop_id, gboolean *load_failed); static guint signals[LAST_SIGNAL]; static GQuark mateconf_key_quark; G_DEFINE_TYPE (TerminalProfile, terminal_profile, G_TYPE_OBJECT); static gboolean palette_cmp (const GdkColor *ca, const GdkColor *cb) { guint i; for (i = 0; i < TERMINAL_PALETTE_SIZE; ++i) if (!gdk_color_equal (&ca[i], &cb[i])) return FALSE; return TRUE; } static GParamSpec * get_pspec_from_name (TerminalProfile *profile, const char *prop_name) { TerminalProfileClass *klass = TERMINAL_PROFILE_GET_CLASS (profile); GParamSpec *pspec; pspec = g_object_class_find_property (G_OBJECT_CLASS (klass), prop_name); if (pspec && pspec->owner_type != TERMINAL_TYPE_PROFILE) pspec = NULL; return pspec; } static const GValue * get_prop_value_from_prop_name (TerminalProfile *profile, const char *prop_name) { TerminalProfilePrivate *priv = profile->priv; GParamSpec *pspec; pspec = get_pspec_from_name (profile, prop_name); if (!pspec) return NULL; if (G_UNLIKELY (pspec->param_id == PROP_BACKGROUND_IMAGE)) ensure_pixbuf_property (profile, PROP_BACKGROUND_IMAGE_FILE, PROP_BACKGROUND_IMAGE, &priv->background_load_failed); return g_value_array_get_nth (priv->properties, pspec->param_id); } static void set_value_from_palette (GValue *ret_value, const GdkColor *colors, guint n_colors) { GValueArray *array; guint i, max_n_colors; max_n_colors = MAX (n_colors, TERMINAL_PALETTE_SIZE); array = g_value_array_new (max_n_colors); for (i = 0; i < max_n_colors; ++i) g_value_array_append (array, NULL); for (i = 0; i < n_colors; ++i) { GValue *value = g_value_array_get_nth (array, i); g_value_init (value, GDK_TYPE_COLOR); g_value_set_boxed (value, &colors[i]); } /* If we haven't enough colours yet, fill up with the default palette */ for (i = n_colors; i < TERMINAL_PALETTE_SIZE; ++i) { GValue *value = g_value_array_get_nth (array, i); g_value_init (value, GDK_TYPE_COLOR); g_value_set_boxed (value, &DEFAULT_PALETTE[i]); } g_value_take_boxed (ret_value, array); } static int values_equal (GParamSpec *pspec, const GValue *va, const GValue *vb) { /* g_param_values_cmp isn't good enough for some types, since e.g. * it compares colours and font descriptions by pointer value, not * with the correct compare functions. Providing extra * PangoParamSpecFontDescription and GdkParamSpecColor wouldn't * have fixed this either, since it's unclear how to _order_ them. * Luckily we only need to check them for equality here. */ if (g_param_values_cmp (pspec, va, vb) == 0) return TRUE; if (G_PARAM_SPEC_VALUE_TYPE (pspec) == GDK_TYPE_COLOR) return gdk_color_equal (g_value_get_boxed (va), g_value_get_boxed (vb)); if (G_PARAM_SPEC_VALUE_TYPE (pspec) == PANGO_TYPE_FONT_DESCRIPTION) return pango_font_description_equal (g_value_get_boxed (va), g_value_get_boxed (vb)); if (G_IS_PARAM_SPEC_VALUE_ARRAY (pspec) && G_PARAM_SPEC_VALUE_TYPE (G_PARAM_SPEC_VALUE_ARRAY (pspec)->element_spec) == GDK_TYPE_COLOR) { GValueArray *ara, *arb; guint i; ara = g_value_get_boxed (va); arb = g_value_get_boxed (vb); if (!ara || !arb || ara->n_values != arb->n_values) return FALSE; for (i = 0; i < ara->n_values; ++i) if (!gdk_color_equal (g_value_get_boxed (g_value_array_get_nth (ara, i)), g_value_get_boxed (g_value_array_get_nth (arb, i)))) return FALSE; return TRUE; } return FALSE; } static void ensure_pixbuf_property (TerminalProfile *profile, guint path_prop_id, guint pixbuf_prop_id, gboolean *load_failed) { TerminalProfilePrivate *priv = profile->priv; GValue *path_value, *pixbuf_value; GdkPixbuf *pixbuf; const char *path_utf8; char *path; GError *error = NULL; pixbuf_value = g_value_array_get_nth (priv->properties, pixbuf_prop_id); pixbuf = g_value_get_object (pixbuf_value); if (pixbuf) return; if (*load_failed) return; path_value = g_value_array_get_nth (priv->properties, path_prop_id); path_utf8 = g_value_get_string (path_value); if (!path_utf8 || !path_utf8[0]) goto failed; path = g_filename_from_utf8 (path_utf8, -1, NULL, NULL, NULL); if (!path) goto failed; pixbuf = gdk_pixbuf_new_from_file (path, &error); if (!pixbuf) { _terminal_debug_print (TERMINAL_DEBUG_PROFILE, "Failed to load image \"%s\": %s\n", path, error->message); g_error_free (error); g_free (path); goto failed; } g_value_take_object (pixbuf_value, pixbuf); g_free (path); return; failed: *load_failed = TRUE; } static void terminal_profile_reset_property_internal (TerminalProfile *profile, GParamSpec *pspec, gboolean notify) { TerminalProfilePrivate *priv = profile->priv; GValue value_ = { 0, }; GValue *value; if (notify) { value = &value_; g_value_init (value, G_PARAM_SPEC_VALUE_TYPE (pspec)); } else value = g_value_array_get_nth (priv->properties, pspec->param_id); g_assert (value != NULL); /* A few properties don't have defaults via the param spec; set them explicitly */ switch (pspec->param_id) { case PROP_FOREGROUND_COLOR: case PROP_BOLD_COLOR: g_value_set_boxed (value, &DEFAULT_FOREGROUND_COLOR); break; case PROP_BACKGROUND_COLOR: g_value_set_boxed (value, &DEFAULT_BACKGROUND_COLOR); break; case PROP_FONT: g_value_take_boxed (value, pango_font_description_from_string (DEFAULT_FONT)); break; case PROP_PALETTE: set_value_from_palette (value, DEFAULT_PALETTE, TERMINAL_PALETTE_SIZE); break; default: g_param_value_set_default (pspec, value); break; } if (notify) { g_object_set_property (G_OBJECT (profile), pspec->name, value); g_value_unset (value); } } static void terminal_profile_mateconf_notify_cb (MateConfClient *client, guint cnxn_id, MateConfEntry *entry, gpointer user_data) { TerminalProfile *profile = TERMINAL_PROFILE (user_data); TerminalProfilePrivate *priv = profile->priv; TerminalProfileClass *klass; const char *key; MateConfValue *mateconf_value; GParamSpec *pspec; GValue value = { 0, }; gboolean equal; gboolean force_set = FALSE; key = mateconf_entry_get_key (entry); if (!key || !g_str_has_prefix (key, priv->profile_dir)) return; _terminal_debug_print (TERMINAL_DEBUG_PROFILE, "MateConf notification for key %s [%s]\n", key, mateconf_entry_get_is_writable (entry) ? "writable" : "LOCKED"); key += strlen (priv->profile_dir); if (!key[0]) return; key++; klass = TERMINAL_PROFILE_GET_CLASS (profile); pspec = g_hash_table_lookup (klass->mateconf_keys, key); if (!pspec) return; /* ignore unknown keys, for future extensibility */ priv->locked[pspec->param_id] = !mateconf_entry_get_is_writable (entry); mateconf_value = mateconf_entry_get_value (entry); if (!mateconf_value) return; g_value_init (&value, G_PARAM_SPEC_VALUE_TYPE (pspec)); if (G_IS_PARAM_SPEC_BOOLEAN (pspec)) { if (mateconf_value->type != MATECONF_VALUE_BOOL) goto out; g_value_set_boolean (&value, mateconf_value_get_bool (mateconf_value)); } else if (G_IS_PARAM_SPEC_STRING (pspec)) { if (mateconf_value->type != MATECONF_VALUE_STRING) goto out; g_value_set_string (&value, mateconf_value_get_string (mateconf_value)); } else if (G_IS_PARAM_SPEC_ENUM (pspec)) { const GEnumValue *eval; int enum_value; if (mateconf_value->type != MATECONF_VALUE_STRING) goto out; eval = g_enum_get_value_by_nick (G_PARAM_SPEC_ENUM (pspec)->enum_class, mateconf_value_get_string (mateconf_value)); if (eval) enum_value = eval->value; else if (G_PARAM_SPEC_VALUE_TYPE (pspec) == vte_terminal_erase_binding_get_type ()) { /* Backward compatibility */ if (!mateconf_string_to_enum ((MateConfEnumStringPair*) erase_bindings, mateconf_value_get_string (mateconf_value), &enum_value)) goto out; } else goto out; g_value_set_enum (&value, enum_value); } else if (G_PARAM_SPEC_VALUE_TYPE (pspec) == GDK_TYPE_COLOR) { GdkColor color; if (mateconf_value->type != MATECONF_VALUE_STRING) goto out; if (!gdk_color_parse (mateconf_value_get_string (mateconf_value), &color)) goto out; g_value_set_boxed (&value, &color); } else if (G_PARAM_SPEC_VALUE_TYPE (pspec) == PANGO_TYPE_FONT_DESCRIPTION) { if (mateconf_value->type != MATECONF_VALUE_STRING) goto out; g_value_take_boxed (&value, pango_font_description_from_string (mateconf_value_get_string (mateconf_value))); } else if (G_IS_PARAM_SPEC_DOUBLE (pspec)) { if (mateconf_value->type != MATECONF_VALUE_FLOAT) goto out; g_value_set_double (&value, mateconf_value_get_float (mateconf_value)); } else if (G_IS_PARAM_SPEC_INT (pspec)) { if (mateconf_value->type != MATECONF_VALUE_INT) goto out; g_value_set_int (&value, mateconf_value_get_int (mateconf_value)); } else if (G_IS_PARAM_SPEC_VALUE_ARRAY (pspec) && G_PARAM_SPEC_VALUE_TYPE (G_PARAM_SPEC_VALUE_ARRAY (pspec)->element_spec) == GDK_TYPE_COLOR) { char **color_strings; GdkColor *colors; int n_colors, i; if (mateconf_value->type != MATECONF_VALUE_STRING) goto out; color_strings = g_strsplit (mateconf_value_get_string (mateconf_value), ":", -1); if (!color_strings) goto out; n_colors = g_strv_length (color_strings); colors = g_new0 (GdkColor, n_colors); for (i = 0; i < n_colors; ++i) { if (!gdk_color_parse (color_strings[i], &colors[i])) continue; /* ignore errors */ } g_strfreev (color_strings); /* We continue even with a palette size != TERMINAL_PALETTE_SIZE, * so we can change the palette size in future versions without * causing too many issues. */ set_value_from_palette (&value, colors, n_colors); g_free (colors); } else { g_printerr ("Unhandled value type %s of pspec %s\n", g_type_name (G_PARAM_SPEC_VALUE_TYPE (pspec)), pspec->name); goto out; } if (g_param_value_validate (pspec, &value)) { _terminal_debug_print (TERMINAL_DEBUG_PROFILE, "Invalid value in mateconf for key %s was changed to comply with pspec %s\n", mateconf_entry_get_key (entry), pspec->name); force_set = TRUE; } /* Only set the property if the value is different than our current value, * so we don't go into an infinite loop. */ equal = values_equal (pspec, &value, g_value_array_get_nth (priv->properties, pspec->param_id)); #ifdef MATE_ENABLE_DEBUG _TERMINAL_DEBUG_IF (TERMINAL_DEBUG_PROFILE) { if (!equal) _terminal_debug_print (TERMINAL_DEBUG_PROFILE, "Setting property %s to a different value\n" " now: %s\n" " new: %s\n", pspec->name, g_strdup_value_contents (g_value_array_get_nth (priv->properties, pspec->param_id)), g_strdup_value_contents (&value)); } #endif if (!equal || force_set) { priv->mateconf_notification_pspec = pspec; g_object_set_property (G_OBJECT (profile), pspec->name, &value); priv->mateconf_notification_pspec = NULL; } out: /* FIXME: if we arrive here through goto in the error cases, * should we maybe reset the property to its default value? */ g_value_unset (&value); } static void terminal_profile_mateconf_changeset_add (TerminalProfile *profile, MateConfChangeSet *changeset, GParamSpec *pspec) { TerminalProfilePrivate *priv = profile->priv; const char *mateconf_key; char *key; const GValue *value; /* FIXME: do this? */ #if 0 if (priv->locked[pspec->param_id]) return; if (!mateconf_client_key_is_writable (priv->conf, mateconf_key, NULL)) return; #endif mateconf_key = g_param_spec_get_qdata (pspec, mateconf_key_quark); if (!mateconf_key) return; key = mateconf_concat_dir_and_key (priv->profile_dir, mateconf_key); value = g_value_array_get_nth (priv->properties, pspec->param_id); _terminal_debug_print (TERMINAL_DEBUG_PROFILE, "Adding pspec %s with value %s to the mateconf changeset\n", pspec->name, g_strdup_value_contents (value)); if (G_IS_PARAM_SPEC_BOOLEAN (pspec)) mateconf_change_set_set_bool (changeset, key, g_value_get_boolean (value)); else if (G_IS_PARAM_SPEC_STRING (pspec)) { const char *str; str = g_value_get_string (value); mateconf_change_set_set_string (changeset, key, str ? str : ""); } else if (G_IS_PARAM_SPEC_ENUM (pspec)) { const GEnumValue *eval; const char *string; eval = g_enum_get_value (G_PARAM_SPEC_ENUM (pspec)->enum_class, g_value_get_enum (value)); if (G_PARAM_SPEC_VALUE_TYPE (pspec) == vte_terminal_erase_binding_get_type ()) { /* Backward compatibility */ string = mateconf_enum_to_string ((MateConfEnumStringPair*) erase_bindings, g_value_get_enum (value)); if (!string) goto cleanup; } else if (eval) string = eval->value_nick; else goto cleanup; mateconf_change_set_set_string (changeset, key, string); } else if (G_PARAM_SPEC_VALUE_TYPE (pspec) == GDK_TYPE_COLOR) { GdkColor *color; char str[16]; color = g_value_get_boxed (value); if (!color) goto cleanup; g_snprintf (str, sizeof (str), "#%04X%04X%04X", color->red, color->green, color->blue); mateconf_change_set_set_string (changeset, key, str); } else if (G_PARAM_SPEC_VALUE_TYPE (pspec) == PANGO_TYPE_FONT_DESCRIPTION) { PangoFontDescription *font_desc; char *font; font_desc = g_value_get_boxed (value); if (!font_desc) goto cleanup; font = pango_font_description_to_string (font_desc); mateconf_change_set_set_string (changeset, key, font); g_free (font); } else if (G_IS_PARAM_SPEC_DOUBLE (pspec)) mateconf_change_set_set_float (changeset, key, (float) g_value_get_double (value)); else if (G_IS_PARAM_SPEC_INT (pspec)) mateconf_change_set_set_int (changeset, key, g_value_get_int (value)); else if (G_IS_PARAM_SPEC_VALUE_ARRAY (pspec) && G_PARAM_SPEC_VALUE_TYPE (G_PARAM_SPEC_VALUE_ARRAY (pspec)->element_spec) == GDK_TYPE_COLOR) { GValueArray *array; GString *string; guint n_colors, i; /* We need to do this ourselves, because the gtk_color_selection_palette_to_string * does not carry all the bytes, and xterm's palette is messed up... */ array = g_value_get_boxed (value); if (!array) goto cleanup; n_colors = array->n_values; string = g_string_sized_new (n_colors * (1 /* # */ + 3 * 4) + n_colors /* : separators and terminating \0 */); for (i = 0; i < n_colors; ++i) { GdkColor *color; if (i > 0) g_string_append_c (string, ':'); color = g_value_get_boxed (g_value_array_get_nth (array, i)); if (!color) continue; g_string_append_printf (string, "#%04X%04X%04X", color->red, color->green, color->blue); } mateconf_change_set_set_string (changeset, key, string->str); g_string_free (string, TRUE); } else g_printerr ("Unhandled value type %s of pspec %s\n", g_type_name (G_PARAM_SPEC_VALUE_TYPE (pspec)), pspec->name); cleanup: g_free (key); } static void terminal_profile_save (TerminalProfile *profile) { TerminalProfilePrivate *priv = profile->priv; MateConfChangeSet *changeset; GSList *l; GError *error = NULL; priv->save_idle_id = 0; changeset = mateconf_change_set_new (); for (l = priv->dirty_pspecs; l != NULL; l = l->next) { GParamSpec *pspec = (GParamSpec *) l->data; if (pspec->owner_type != TERMINAL_TYPE_PROFILE) continue; if ((pspec->flags & G_PARAM_WRITABLE) == 0) continue; terminal_profile_mateconf_changeset_add (profile, changeset, pspec); } g_slist_free (priv->dirty_pspecs); priv->dirty_pspecs = NULL; if (!mateconf_client_commit_change_set (priv->conf, changeset, TRUE, &error)) { g_message ("Failed to commit the changeset to mateconf: %s", error->message); g_error_free (error); } mateconf_change_set_unref (changeset); } static gboolean terminal_profile_save_idle_cb (TerminalProfile *profile) { terminal_profile_save (profile); /* don't run again */ return FALSE; } static void terminal_profile_schedule_save (TerminalProfile *profile, GParamSpec *pspec) { TerminalProfilePrivate *priv = profile->priv; g_assert (pspec != NULL); if (!g_slist_find (priv->dirty_pspecs, pspec)) priv->dirty_pspecs = g_slist_prepend (priv->dirty_pspecs, pspec); if (priv->save_idle_id != 0) return; priv->save_idle_id = g_idle_add ((GSourceFunc) terminal_profile_save_idle_cb, profile); } static void terminal_profile_init (TerminalProfile *profile) { TerminalProfilePrivate *priv; GObjectClass *object_class; GParamSpec **pspecs; guint n_pspecs, i; priv = profile->priv = G_TYPE_INSTANCE_GET_PRIVATE (profile, TERMINAL_TYPE_PROFILE, TerminalProfilePrivate); priv->mateconf_notification_pspec = NULL; priv->conf = mateconf_client_get_default (); priv->locked = g_new0 (gboolean, LAST_PROP); priv->properties = g_value_array_new (LAST_PROP); for (i = 0; i < LAST_PROP; ++i) g_value_array_append (priv->properties, NULL); pspecs = g_object_class_list_properties (G_OBJECT_CLASS (TERMINAL_PROFILE_GET_CLASS (profile)), &n_pspecs); for (i = 0; i < n_pspecs; ++i) { GParamSpec *pspec = pspecs[i]; GValue *value; if (pspec->owner_type != TERMINAL_TYPE_PROFILE) continue; g_assert (pspec->param_id < LAST_PROP); value = g_value_array_get_nth (priv->properties, pspec->param_id); g_value_init (value, pspec->value_type); g_param_value_set_default (pspec, value); } g_free (pspecs); /* A few properties don't have defaults via the param spec; set them explicitly */ object_class = G_OBJECT_CLASS (TERMINAL_PROFILE_GET_CLASS (profile)); terminal_profile_reset_property_internal (profile, g_object_class_find_property (object_class, TERMINAL_PROFILE_FOREGROUND_COLOR), FALSE); terminal_profile_reset_property_internal (profile, g_object_class_find_property (object_class, TERMINAL_PROFILE_BOLD_COLOR), FALSE); terminal_profile_reset_property_internal (profile, g_object_class_find_property (object_class, TERMINAL_PROFILE_BACKGROUND_COLOR), FALSE); terminal_profile_reset_property_internal (profile, g_object_class_find_property (object_class, TERMINAL_PROFILE_FONT), FALSE); terminal_profile_reset_property_internal (profile, g_object_class_find_property (object_class, TERMINAL_PROFILE_PALETTE), FALSE); } static GObject * terminal_profile_constructor (GType type, guint n_construct_properties, GObjectConstructParam *construct_params) { GObject *object; TerminalProfile *profile; TerminalProfilePrivate *priv; const char *name; GParamSpec **pspecs; guint n_pspecs, i; object = G_OBJECT_CLASS (terminal_profile_parent_class)->constructor (type, n_construct_properties, construct_params); profile = TERMINAL_PROFILE (object); priv = profile->priv; name = g_value_get_string (g_value_array_get_nth (priv->properties, PROP_NAME)); g_assert (name != NULL); /* Now load those properties from mateconf that were not set as construction params */ pspecs = g_object_class_list_properties (G_OBJECT_CLASS (TERMINAL_PROFILE_GET_CLASS (profile)), &n_pspecs); for (i = 0; i < n_pspecs; ++i) { GParamSpec *pspec = pspecs[i]; guint j; gboolean is_construct = FALSE; const char *mateconf_key; char *key; if (pspec->owner_type != TERMINAL_TYPE_PROFILE) continue; if ((pspec->flags & G_PARAM_WRITABLE) == 0 || (pspec->flags & G_PARAM_CONSTRUCT_ONLY) != 0) continue; for (j = 0; j < n_construct_properties; ++j) if (pspec == construct_params[j].pspec) { is_construct = TRUE; break; } if (is_construct) continue; mateconf_key = g_param_spec_get_qdata (pspec, mateconf_key_quark); if (!mateconf_key) continue; key = mateconf_concat_dir_and_key (priv->profile_dir, mateconf_key); mateconf_client_notify (priv->conf, key); g_free (key); } g_free (pspecs); return object; } static void terminal_profile_finalize (GObject *object) { TerminalProfile *profile = TERMINAL_PROFILE (object); TerminalProfilePrivate *priv = profile->priv; mateconf_client_notify_remove (priv->conf, priv->notify_id); priv->notify_id = 0; if (priv->save_idle_id) { g_source_remove (priv->save_idle_id); /* Save now */ terminal_profile_save (profile); } _terminal_profile_forget (profile); g_object_unref (priv->conf); g_free (priv->profile_dir); g_free (priv->locked); g_value_array_free (priv->properties); G_OBJECT_CLASS (terminal_profile_parent_class)->finalize (object); } static void terminal_profile_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec) { TerminalProfile *profile = TERMINAL_PROFILE (object); TerminalProfilePrivate *priv = profile->priv; if (prop_id == 0 || prop_id >= LAST_PROP) { G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); return; } /* Note: When adding things here, do the same in get_prop_value_from_prop_name! */ switch (prop_id) { case PROP_BACKGROUND_IMAGE: ensure_pixbuf_property (profile, PROP_BACKGROUND_IMAGE_FILE, PROP_BACKGROUND_IMAGE, &priv->background_load_failed); break; default: break; } g_value_copy (g_value_array_get_nth (priv->properties, prop_id), value); } static void terminal_profile_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec) { TerminalProfile *profile = TERMINAL_PROFILE (object); TerminalProfilePrivate *priv = profile->priv; GValue *prop_value; if (prop_id == 0 || prop_id >= LAST_PROP) { G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); return; } prop_value = g_value_array_get_nth (priv->properties, prop_id); /* Preprocessing */ switch (prop_id) { #if 0 case PROP_FONT: { PangoFontDescription *font_desc, *new_font_desc; font_desc = g_value_get_boxed (prop_value); new_font_desc = g_value_get_boxed (value); if (font_desc && new_font_desc) { /* Merge in case the new string isn't complete enough to load a font */ pango_font_description_merge (font_desc, new_font_desc, TRUE); pango_font_description_free (new_font_desc); break; } /* fall-through */ } #endif default: g_value_copy (value, prop_value); break; } /* Postprocessing */ switch (prop_id) { case PROP_NAME: { const char *name = g_value_get_string (value); g_assert (name != NULL); priv->profile_dir = mateconf_concat_dir_and_key (CONF_PROFILES_PREFIX, name); mateconf_client_add_dir (priv->conf, priv->profile_dir, MATECONF_CLIENT_PRELOAD_ONELEVEL, NULL); priv->notify_id = mateconf_client_notify_add (priv->conf, priv->profile_dir, terminal_profile_mateconf_notify_cb, profile, NULL, NULL); break; } case PROP_BACKGROUND_IMAGE_FILE: /* Clear the cached image */ g_value_set_object (g_value_array_get_nth (priv->properties, PROP_BACKGROUND_IMAGE), NULL); priv->background_load_failed = FALSE; g_object_notify (object, TERMINAL_PROFILE_BACKGROUND_IMAGE); break; default: break; } } static void terminal_profile_notify (GObject *object, GParamSpec *pspec) { TerminalProfilePrivate *priv = TERMINAL_PROFILE (object)->priv; void (* notify) (GObject *, GParamSpec *) = G_OBJECT_CLASS (terminal_profile_parent_class)->notify; _terminal_debug_print (TERMINAL_DEBUG_PROFILE, "Property notification for prop %s\n", pspec->name); if (notify) notify (object, pspec); if (pspec->owner_type == TERMINAL_TYPE_PROFILE && (pspec->flags & G_PARAM_WRITABLE) && g_param_spec_get_qdata (pspec, mateconf_key_quark) != NULL && pspec != priv->mateconf_notification_pspec) terminal_profile_schedule_save (TERMINAL_PROFILE (object), pspec); } static void terminal_profile_class_init (TerminalProfileClass *klass) { GObjectClass *object_class = G_OBJECT_CLASS (klass); mateconf_key_quark = g_quark_from_static_string ("GT::MateConfKey"); g_type_class_add_private (object_class, sizeof (TerminalProfilePrivate)); object_class->constructor = terminal_profile_constructor; object_class->finalize = terminal_profile_finalize; object_class->get_property = terminal_profile_get_property; object_class->set_property = terminal_profile_set_property; object_class->notify = terminal_profile_notify; signals[FORGOTTEN] = g_signal_new ("forgotten", G_OBJECT_CLASS_TYPE (object_class), G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (TerminalProfileClass, forgotten), NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0); /* mateconf_key -> pspec hash */ klass->mateconf_keys = g_hash_table_new (g_str_hash, g_str_equal); #define TERMINAL_PROFILE_PSPEC_STATIC (G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB) #define TERMINAL_PROFILE_PROPERTY(propId, propSpec, propMateConf) \ {\ GParamSpec *pspec = propSpec;\ g_object_class_install_property (object_class, propId, pspec);\ \ if (propMateConf)\ {\ g_param_spec_set_qdata (pspec, mateconf_key_quark, (gpointer) propMateConf);\ g_hash_table_insert (klass->mateconf_keys, (gpointer) propMateConf, pspec);\ }\ } #define TERMINAL_PROFILE_PROPERTY_BOOLEAN(prop, propDefault, propMateConf) \ TERMINAL_PROFILE_PROPERTY (PROP_##prop,\ g_param_spec_boolean (TERMINAL_PROFILE_##prop, NULL, NULL,\ propDefault,\ G_PARAM_READWRITE | TERMINAL_PROFILE_PSPEC_STATIC),\ propMateConf) #define TERMINAL_PROFILE_PROPERTY_BOXED(prop, propType, propMateConf)\ TERMINAL_PROFILE_PROPERTY (PROP_##prop,\ g_param_spec_boxed (TERMINAL_PROFILE_##prop, NULL, NULL,\ propType,\ G_PARAM_READWRITE | TERMINAL_PROFILE_PSPEC_STATIC),\ propMateConf) #define TERMINAL_PROFILE_PROPERTY_DOUBLE(prop, propMin, propMax, propDefault, propMateConf)\ TERMINAL_PROFILE_PROPERTY (PROP_##prop,\ g_param_spec_double (TERMINAL_PROFILE_##prop, NULL, NULL,\ propMin, propMax, propDefault,\ G_PARAM_READWRITE | TERMINAL_PROFILE_PSPEC_STATIC),\ propMateConf) #define TERMINAL_PROFILE_PROPERTY_ENUM(prop, propType, propDefault, propMateConf)\ TERMINAL_PROFILE_PROPERTY (PROP_##prop,\ g_param_spec_enum (TERMINAL_PROFILE_##prop, NULL, NULL,\ propType, propDefault,\ G_PARAM_READWRITE | TERMINAL_PROFILE_PSPEC_STATIC),\ propMateConf) #define TERMINAL_PROFILE_PROPERTY_INT(prop, propMin, propMax, propDefault, propMateConf)\ TERMINAL_PROFILE_PROPERTY (PROP_##prop,\ g_param_spec_int (TERMINAL_PROFILE_##prop, NULL, NULL,\ propMin, propMax, propDefault,\ G_PARAM_READWRITE | TERMINAL_PROFILE_PSPEC_STATIC),\ propMateConf) /* these are all read-only */ #define TERMINAL_PROFILE_PROPERTY_OBJECT(prop, propType, propMateConf)\ TERMINAL_PROFILE_PROPERTY (PROP_##prop,\ g_param_spec_object (TERMINAL_PROFILE_##prop, NULL, NULL,\ propType,\ G_PARAM_READABLE | TERMINAL_PROFILE_PSPEC_STATIC),\ propMateConf) #define TERMINAL_PROFILE_PROPERTY_STRING(prop, propDefault, propMateConf)\ TERMINAL_PROFILE_PROPERTY (PROP_##prop,\ g_param_spec_string (TERMINAL_PROFILE_##prop, NULL, NULL,\ propDefault,\ G_PARAM_READWRITE | TERMINAL_PROFILE_PSPEC_STATIC),\ propMateConf) #define TERMINAL_PROFILE_PROPERTY_STRING_CO(prop, propDefault, propMateConf)\ TERMINAL_PROFILE_PROPERTY (PROP_##prop,\ g_param_spec_string (TERMINAL_PROFILE_##prop, NULL, NULL,\ propDefault,\ G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | TERMINAL_PROFILE_PSPEC_STATIC),\ propMateConf) #define TERMINAL_PROFILE_PROPERTY_VALUE_ARRAY_BOXED(prop, propElementName, propElementType, propMateConf)\ TERMINAL_PROFILE_PROPERTY (PROP_##prop,\ g_param_spec_value_array (TERMINAL_PROFILE_##prop, NULL, NULL,\ g_param_spec_boxed (propElementName, NULL, NULL,\ propElementType, \ G_PARAM_READWRITE | TERMINAL_PROFILE_PSPEC_STATIC),\ G_PARAM_READWRITE | TERMINAL_PROFILE_PSPEC_STATIC),\ propMateConf) TERMINAL_PROFILE_PROPERTY_BOOLEAN (ALLOW_BOLD, DEFAULT_ALLOW_BOLD, KEY_ALLOW_BOLD); TERMINAL_PROFILE_PROPERTY_BOOLEAN (BOLD_COLOR_SAME_AS_FG, DEFAULT_BOLD_COLOR_SAME_AS_FG, KEY_BOLD_COLOR_SAME_AS_FG); TERMINAL_PROFILE_PROPERTY_BOOLEAN (DEFAULT_SHOW_MENUBAR, DEFAULT_DEFAULT_SHOW_MENUBAR, KEY_DEFAULT_SHOW_MENUBAR); TERMINAL_PROFILE_PROPERTY_BOOLEAN (LOGIN_SHELL, DEFAULT_LOGIN_SHELL, KEY_LOGIN_SHELL); TERMINAL_PROFILE_PROPERTY_BOOLEAN (SCROLL_BACKGROUND, DEFAULT_SCROLL_BACKGROUND, KEY_SCROLL_BACKGROUND); TERMINAL_PROFILE_PROPERTY_BOOLEAN (SCROLLBACK_UNLIMITED, DEFAULT_SCROLLBACK_UNLIMITED, KEY_SCROLLBACK_UNLIMITED); TERMINAL_PROFILE_PROPERTY_BOOLEAN (SCROLL_ON_KEYSTROKE, DEFAULT_SCROLL_ON_KEYSTROKE, KEY_SCROLL_ON_KEYSTROKE); TERMINAL_PROFILE_PROPERTY_BOOLEAN (SCROLL_ON_OUTPUT, DEFAULT_SCROLL_ON_OUTPUT, KEY_SCROLL_ON_OUTPUT); TERMINAL_PROFILE_PROPERTY_BOOLEAN (SILENT_BELL, DEFAULT_SILENT_BELL, KEY_SILENT_BELL); TERMINAL_PROFILE_PROPERTY_BOOLEAN (UPDATE_RECORDS, DEFAULT_UPDATE_RECORDS, KEY_UPDATE_RECORDS); TERMINAL_PROFILE_PROPERTY_BOOLEAN (USE_CUSTOM_COMMAND, DEFAULT_USE_CUSTOM_COMMAND, KEY_USE_CUSTOM_COMMAND); TERMINAL_PROFILE_PROPERTY_BOOLEAN (USE_CUSTOM_DEFAULT_SIZE, DEFAULT_USE_CUSTOM_DEFAULT_SIZE, KEY_USE_CUSTOM_DEFAULT_SIZE); TERMINAL_PROFILE_PROPERTY_BOOLEAN (USE_SKEY, DEFAULT_USE_SKEY, KEY_USE_SKEY); TERMINAL_PROFILE_PROPERTY_BOOLEAN (USE_SYSTEM_FONT, DEFAULT_USE_SYSTEM_FONT, KEY_USE_SYSTEM_FONT); TERMINAL_PROFILE_PROPERTY_BOOLEAN (USE_THEME_COLORS, DEFAULT_USE_THEME_COLORS, KEY_USE_THEME_COLORS); TERMINAL_PROFILE_PROPERTY_BOXED (BACKGROUND_COLOR, GDK_TYPE_COLOR, KEY_BACKGROUND_COLOR); TERMINAL_PROFILE_PROPERTY_BOXED (BOLD_COLOR, GDK_TYPE_COLOR, KEY_BOLD_COLOR); TERMINAL_PROFILE_PROPERTY_BOXED (FONT, PANGO_TYPE_FONT_DESCRIPTION, KEY_FONT); TERMINAL_PROFILE_PROPERTY_BOXED (FOREGROUND_COLOR, GDK_TYPE_COLOR, KEY_FOREGROUND_COLOR); /* 0.0 = normal bg, 1.0 = all black bg, 0.5 = half darkened */ TERMINAL_PROFILE_PROPERTY_DOUBLE (BACKGROUND_DARKNESS, 0.0, 1.0, DEFAULT_BACKGROUND_DARKNESS, KEY_BACKGROUND_DARKNESS); TERMINAL_PROFILE_PROPERTY_ENUM (BACKGROUND_TYPE, TERMINAL_TYPE_BACKGROUND_TYPE, DEFAULT_BACKGROUND_TYPE, KEY_BACKGROUND_TYPE); TERMINAL_PROFILE_PROPERTY_ENUM (BACKSPACE_BINDING, VTE_TYPE_TERMINAL_ERASE_BINDING, DEFAULT_BACKSPACE_BINDING, KEY_BACKSPACE_BINDING); TERMINAL_PROFILE_PROPERTY_ENUM (CURSOR_BLINK_MODE, VTE_TYPE_TERMINAL_CURSOR_BLINK_MODE, DEFAULT_CURSOR_BLINK_MODE, KEY_CURSOR_BLINK_MODE); TERMINAL_PROFILE_PROPERTY_ENUM (CURSOR_SHAPE, VTE_TYPE_TERMINAL_CURSOR_SHAPE, DEFAULT_CURSOR_SHAPE, KEY_CURSOR_SHAPE); TERMINAL_PROFILE_PROPERTY_ENUM (DELETE_BINDING, VTE_TYPE_TERMINAL_ERASE_BINDING, DEFAULT_DELETE_BINDING, KEY_DELETE_BINDING); TERMINAL_PROFILE_PROPERTY_ENUM (EXIT_ACTION, TERMINAL_TYPE_EXIT_ACTION, DEFAULT_EXIT_ACTION, KEY_EXIT_ACTION); TERMINAL_PROFILE_PROPERTY_ENUM (SCROLLBAR_POSITION, TERMINAL_TYPE_SCROLLBAR_POSITION, DEFAULT_SCROLLBAR_POSITION, KEY_SCROLLBAR_POSITION); TERMINAL_PROFILE_PROPERTY_ENUM (TITLE_MODE, TERMINAL_TYPE_TITLE_MODE, DEFAULT_TITLE_MODE, KEY_TITLE_MODE); TERMINAL_PROFILE_PROPERTY_INT (DEFAULT_SIZE_COLUMNS, 1, 1024, DEFAULT_DEFAULT_SIZE_COLUMNS, KEY_DEFAULT_SIZE_COLUMNS); TERMINAL_PROFILE_PROPERTY_INT (DEFAULT_SIZE_ROWS, 1, 1024, DEFAULT_DEFAULT_SIZE_ROWS, KEY_DEFAULT_SIZE_ROWS); TERMINAL_PROFILE_PROPERTY_INT (SCROLLBACK_LINES, 1, G_MAXINT, DEFAULT_SCROLLBACK_LINES, KEY_SCROLLBACK_LINES); TERMINAL_PROFILE_PROPERTY_OBJECT (BACKGROUND_IMAGE, GDK_TYPE_PIXBUF, NULL); TERMINAL_PROFILE_PROPERTY_STRING_CO (NAME, DEFAULT_NAME, NULL); TERMINAL_PROFILE_PROPERTY_STRING (BACKGROUND_IMAGE_FILE, DEFAULT_BACKGROUND_IMAGE_FILE, KEY_BACKGROUND_IMAGE_FILE); TERMINAL_PROFILE_PROPERTY_STRING (CUSTOM_COMMAND, DEFAULT_CUSTOM_COMMAND, KEY_CUSTOM_COMMAND); TERMINAL_PROFILE_PROPERTY_STRING (TITLE, _(DEFAULT_TITLE), KEY_TITLE); TERMINAL_PROFILE_PROPERTY_STRING (VISIBLE_NAME, _(DEFAULT_VISIBLE_NAME), KEY_VISIBLE_NAME); TERMINAL_PROFILE_PROPERTY_STRING (WORD_CHARS, DEFAULT_WORD_CHARS, KEY_WORD_CHARS); TERMINAL_PROFILE_PROPERTY_VALUE_ARRAY_BOXED (PALETTE, "palette-color", GDK_TYPE_COLOR, KEY_PALETTE); } /* Semi-Public API */ TerminalProfile* _terminal_profile_new (const char *name) { return g_object_new (TERMINAL_TYPE_PROFILE, "name", name, NULL); } void _terminal_profile_forget (TerminalProfile *profile) { TerminalProfilePrivate *priv = profile->priv; if (!priv->forgotten) { mateconf_client_remove_dir (priv->conf, priv->profile_dir, NULL); priv->forgotten = TRUE; g_signal_emit (G_OBJECT (profile), signals[FORGOTTEN], 0); } } gboolean _terminal_profile_get_forgotten (TerminalProfile *profile) { return profile->priv->forgotten; } TerminalProfile * _terminal_profile_clone (TerminalProfile *base_profile, const char *visible_name) { TerminalApp *app = terminal_app_get (); GObject *base_object = G_OBJECT (base_profile); TerminalProfilePrivate *new_priv; char profile_name[32]; GParameter *params; GParamSpec **pspecs; guint n_pspecs, i, n_params, profile_num; TerminalProfile *new_profile; g_object_ref (base_profile); profile_num = 0; do { g_snprintf (profile_name, sizeof (profile_name), "Profile%u", profile_num++); } while (terminal_app_get_profile_by_name (app, profile_name) != NULL); /* Now we have an unused profile name */ pspecs = g_object_class_list_properties (G_OBJECT_CLASS (TERMINAL_PROFILE_GET_CLASS (base_profile)), &n_pspecs); params = g_newa (GParameter, n_pspecs); n_params = 0; for (i = 0; i < n_pspecs; ++i) { GParamSpec *pspec = pspecs[i]; GValue *value; if (pspec->owner_type != TERMINAL_TYPE_PROFILE || (pspec->flags & G_PARAM_WRITABLE) == 0) continue; params[n_params].name = pspec->name; value = ¶ms[n_params].value; G_VALUE_TYPE (value) = 0; g_value_init (value, G_PARAM_SPEC_VALUE_TYPE (pspec)); if (pspec->name == I_(TERMINAL_PROFILE_NAME)) g_value_set_static_string (value, profile_name); else if (pspec->name == I_(TERMINAL_PROFILE_VISIBLE_NAME)) g_value_set_static_string (value, visible_name); else g_object_get_property (base_object, pspec->name, value); ++n_params; } new_profile = g_object_newv (TERMINAL_TYPE_PROFILE, n_params, params); g_object_unref (base_profile); for (i = 0; i < n_params; ++i) g_value_unset (¶ms[i].value); /* Flush the new profile to mateconf */ new_priv = new_profile->priv; g_slist_free (new_priv->dirty_pspecs); new_priv->dirty_pspecs = NULL; if (new_priv->save_idle_id != 0) { g_source_remove (new_priv->save_idle_id); new_priv->save_idle_id = 0; } for (i = 0; i < n_pspecs; ++i) { GParamSpec *pspec = pspecs[i]; if (pspec->owner_type != TERMINAL_TYPE_PROFILE || (pspec->flags & G_PARAM_WRITABLE) == 0) continue; new_priv->dirty_pspecs = g_slist_prepend (new_priv->dirty_pspecs, pspec); } g_free (pspecs); terminal_profile_save (new_profile); return new_profile; } /* Public API */ gboolean terminal_profile_get_property_boolean (TerminalProfile *profile, const char *prop_name) { const GValue *value; value = get_prop_value_from_prop_name (profile, prop_name); g_return_val_if_fail (value != NULL && G_VALUE_HOLDS_BOOLEAN (value), FALSE); if (!value || !G_VALUE_HOLDS_BOOLEAN (value)) return FALSE; return g_value_get_boolean (value); } gconstpointer terminal_profile_get_property_boxed (TerminalProfile *profile, const char *prop_name) { const GValue *value; value = get_prop_value_from_prop_name (profile, prop_name); g_return_val_if_fail (value != NULL && G_VALUE_HOLDS_BOXED (value), NULL); if (!value || !G_VALUE_HOLDS_BOXED (value)) return NULL; return g_value_get_boxed (value); } double terminal_profile_get_property_double (TerminalProfile *profile, const char *prop_name) { const GValue *value; value = get_prop_value_from_prop_name (profile, prop_name); g_return_val_if_fail (value != NULL && G_VALUE_HOLDS_DOUBLE (value), 0.0); if (!value || !G_VALUE_HOLDS_DOUBLE (value)) return 0.0; return g_value_get_double (value); } int terminal_profile_get_property_enum (TerminalProfile *profile, const char *prop_name) { const GValue *value; value = get_prop_value_from_prop_name (profile, prop_name); g_return_val_if_fail (value != NULL && G_VALUE_HOLDS_ENUM (value), 0); if (!value || !G_VALUE_HOLDS_ENUM (value)) return 0; return g_value_get_enum (value); } int terminal_profile_get_property_int (TerminalProfile *profile, const char *prop_name) { const GValue *value; value = get_prop_value_from_prop_name (profile, prop_name); g_return_val_if_fail (value != NULL && G_VALUE_HOLDS_INT (value), 0); if (!value || !G_VALUE_HOLDS_INT (value)) return 0; return g_value_get_int (value); } gpointer terminal_profile_get_property_object (TerminalProfile *profile, const char *prop_name) { const GValue *value; value = get_prop_value_from_prop_name (profile, prop_name); g_return_val_if_fail (value != NULL && G_VALUE_HOLDS_OBJECT (value), NULL); if (!value || !G_VALUE_HOLDS_OBJECT (value)) return NULL; return g_value_get_object (value); } const char* terminal_profile_get_property_string (TerminalProfile *profile, const char *prop_name) { const GValue *value; value = get_prop_value_from_prop_name (profile, prop_name); g_return_val_if_fail (value != NULL && G_VALUE_HOLDS_STRING (value), NULL); if (!value || !G_VALUE_HOLDS_STRING (value)) return NULL; return g_value_get_string (value); } gboolean terminal_profile_property_locked (TerminalProfile *profile, const char *prop_name) { TerminalProfilePrivate *priv = profile->priv; GParamSpec *pspec; pspec = get_pspec_from_name (profile, prop_name); g_return_val_if_fail (pspec != NULL, FALSE); if (!pspec) return FALSE; return priv->locked[pspec->param_id]; } void terminal_profile_reset_property (TerminalProfile *profile, const char *prop_name) { GParamSpec *pspec; pspec = get_pspec_from_name (profile, prop_name); g_return_if_fail (pspec != NULL); if (!pspec || (pspec->flags & G_PARAM_WRITABLE) == 0) return; terminal_profile_reset_property_internal (profile, pspec, TRUE); } gboolean terminal_profile_get_palette (TerminalProfile *profile, GdkColor *colors, guint *n_colors) { TerminalProfilePrivate *priv; GValueArray *array; guint i, n; g_return_val_if_fail (TERMINAL_IS_PROFILE (profile), FALSE); g_return_val_if_fail (colors != NULL && n_colors != NULL, FALSE); priv = profile->priv; array = g_value_get_boxed (g_value_array_get_nth (priv->properties, PROP_PALETTE)); if (!array) return FALSE; n = MIN (array->n_values, *n_colors); for (i = 0; i < n; ++i) { GdkColor *color = g_value_get_boxed (g_value_array_get_nth (array, i)); if (!color) continue; /* shouldn't happen!! */ colors[i] = *color; } *n_colors = n; return TRUE; } gboolean terminal_profile_get_palette_is_builtin (TerminalProfile *profile, guint *n) { GdkColor colors[TERMINAL_PALETTE_SIZE]; guint n_colors; guint i; n_colors = G_N_ELEMENTS (colors); if (!terminal_profile_get_palette (profile, colors, &n_colors) || n_colors != TERMINAL_PALETTE_SIZE) return FALSE; for (i = 0; i < TERMINAL_PALETTE_N_BUILTINS; ++i) if (palette_cmp (colors, terminal_palettes[i])) { *n = i; return TRUE; } return FALSE; } void terminal_profile_set_palette_builtin (TerminalProfile *profile, guint n) { GValue value = { 0, }; g_return_if_fail (n < TERMINAL_PALETTE_N_BUILTINS); g_value_init (&value, G_TYPE_VALUE_ARRAY); set_value_from_palette (&value, terminal_palettes[n], TERMINAL_PALETTE_SIZE); g_object_set_property (G_OBJECT (profile), TERMINAL_PROFILE_PALETTE, &value); g_value_unset (&value); } gboolean terminal_profile_modify_palette_entry (TerminalProfile *profile, guint i, const GdkColor *color) { TerminalProfilePrivate *priv = profile->priv; GValueArray *array; GValue *value; GdkColor *old_color; array = g_value_get_boxed (g_value_array_get_nth (priv->properties, PROP_PALETTE)); if (!array || i >= array->n_values) return FALSE; value = g_value_array_get_nth (array, i); old_color = g_value_get_boxed (value); if (!old_color || !gdk_color_equal (old_color, color)) { g_value_set_boxed (value, color); g_object_notify (G_OBJECT (profile), TERMINAL_PROFILE_PALETTE); } return TRUE; }