X-Git-Url: https://www.irasnyder.com/gitweb/?p=tilda-gobject.git;a=blobdiff_plain;f=tilda-window.c;h=44a04e8e2fd3bea7b7dfef00bd047900601aca5a;hp=618e862125c81d3d27faaef668a2c93b78ce7c4a;hb=HEAD;hpb=0ce420ceaa8a1d85098e7ca1b75991e2d2d121e6

diff --git a/tilda-window.c b/tilda-window.c
index 618e862..44a04e8 100644
--- a/tilda-window.c
+++ b/tilda-window.c
@@ -67,6 +67,26 @@ tilda_window_find_next_free_terminal_number (TildaWindow *self)
 	return 0;
 }
 
+static void
+tilda_window_show_hide_tabs_if_appropriate (TildaWindow *self)
+{
+	debug_enter  ();
+	debug_assert (TILDA_IS_WINDOW(self));
+
+	/* If we only have one tab, we have a choice to make, otherwise, always show tabs */
+	if (gtk_notebook_get_n_pages (GTK_NOTEBOOK(self->notebook)) <= 1)
+	{
+		if (self->always_show_tabs)
+			gtk_notebook_set_show_tabs (GTK_NOTEBOOK(self->notebook), TRUE);
+		else
+			gtk_notebook_set_show_tabs (GTK_NOTEBOOK(self->notebook), FALSE);
+	}
+	else
+	{
+		gtk_notebook_set_show_tabs (GTK_NOTEBOOK(self->notebook), TRUE);
+	}
+}
+
 /**
  * Clean up and remove self completely from the program
  *
@@ -91,6 +111,8 @@ tilda_window_add_terminal (TildaWindow *self)
 
 	gint number;
 	TildaTerminal *tt;
+	GtkWidget *label;
+	gint notebook_index;
 
 	number = tilda_window_find_next_free_terminal_number (self);
 	tt = g_object_new (TILDA_TYPE_TERMINAL,
@@ -99,13 +121,14 @@ tilda_window_add_terminal (TildaWindow *self)
 					   NULL);
 	g_ptr_array_add (self->terms, tt);
 
-	GtkWidget *label = gtk_label_new ("Tilda");
-	gint index = gtk_notebook_prepend_page (GTK_NOTEBOOK(self->notebook), tt->hbox, label);
-	gtk_notebook_set_tab_label_packing (GTK_NOTEBOOK(self->notebook), tt->hbox, TRUE, TRUE, GTK_PACK_END);
-	gtk_notebook_set_current_page (GTK_NOTEBOOK(self->notebook), index);
+	label = gtk_label_new ("Tilda");
+	notebook_index = gtk_notebook_append_page (GTK_NOTEBOOK(self->notebook), tt->hbox, label);
+	gtk_notebook_set_tab_label_packing (GTK_NOTEBOOK(self->notebook), tt->hbox,
+										self->full_width_tabs, TRUE, GTK_PACK_START);
+	gtk_notebook_set_current_page (GTK_NOTEBOOK(self->notebook), notebook_index);
 
-	if (gtk_notebook_get_n_pages (GTK_NOTEBOOK(self->notebook)) > 1)
-		gtk_notebook_set_show_tabs (GTK_NOTEBOOK(self->notebook), TRUE);
+	/* Always show tabs if we have > 1 tab open */
+	tilda_window_show_hide_tabs_if_appropriate (self);
 
 	/* Focus the VTE Terminal */
 	gtk_widget_grab_focus (tt->vte_term);
@@ -147,8 +170,7 @@ tilda_window_remove_terminal (TildaWindow *self, gint terminal_number)
 			gtk_notebook_remove_page (GTK_NOTEBOOK (self->notebook), notebook_index);
 
 			/* We should hide the tabs if there is only one tab left */
-			if (gtk_notebook_get_n_pages (GTK_NOTEBOOK (self->notebook)) == 1)
-				gtk_notebook_set_show_tabs (GTK_NOTEBOOK (self->notebook), FALSE);
+			tilda_window_show_hide_tabs_if_appropriate (self);
 
 			/* Remove the term from our lists, then free it */
 			g_ptr_array_remove_fast (self->terms, tt);
@@ -224,6 +246,65 @@ tilda_window_center_vertically (TildaWindow *self)
 	g_object_set (G_OBJECT(self), "y-position", center_coord, NULL);
 }
 
+/* Shamelessly adapted (read: ripped off) from gdk_window_focus() and
+ * http://code.google.com/p/ttm/ trunk/src/window.c set_active()
+ *
+ * Also, more thanks to halfline and marnanel from irc.gnome.org #gnome
+ * for their help in figuring this out.
+ *
+ * Thank you.
+ */
+
+/* This function will make sure that tilda window becomes active (gains
+ * the focus) when it is called.
+ *
+ * This has to be the worst possible way of making this work, but it was the
+ * only way to get metacity to play nicely. All the other WM's are so nice,
+ * why oh why does metacity hate us so?
+ */
+static void
+tilda_window_set_active (TildaWindow *self)
+{
+	debug_enter  ();
+	debug_assert (TILDA_IS_WINDOW(self));
+
+	Display *x11_display = GDK_WINDOW_XDISPLAY( self->window->window );
+	Window *x11_window = GDK_WINDOW_XWINDOW( self->window->window );
+	Window *x11_root_window = GDK_WINDOW_XWINDOW( gtk_widget_get_root_window (self->window) );
+	GdkScreen *screen = gtk_widget_get_screen (self->window);
+
+	XEvent event;
+	long mask = SubstructureRedirectMask | SubstructureNotifyMask;
+
+	if (gdk_x11_screen_supports_net_wm_hint (screen,
+											 gdk_atom_intern_static_string ("_NET_ACTIVE_WINDOW")))
+	{
+		event.xclient.type = ClientMessage;
+		event.xclient.serial = 0;
+		event.xclient.send_event = True;
+		event.xclient.display = x11_display;
+		event.xclient.window = x11_window;
+		event.xclient.message_type = gdk_x11_get_xatom_by_name ("_NET_ACTIVE_WINDOW");
+
+		event.xclient.format = 32;
+		event.xclient.data.l[0] = 2; /* pager */
+		event.xclient.data.l[1] = tomboy_keybinder_get_current_event_time(); /* timestamp */
+		event.xclient.data.l[2] = 0;
+		event.xclient.data.l[3] = 0;
+		event.xclient.data.l[4] = 0;
+
+		XSendEvent (x11_display, x11_root_window, False, mask, &event);
+	}
+	else
+	{
+		/* The WM doesn't support the EWMH standards. We'll print a warning and
+		 * try this, though it probably won't work... */
+		g_printerr (_("WARNING: Window manager (%s) does not support EWMH hints\n"),
+					gdk_x11_screen_get_window_manager_name (screen));
+		XRaiseWindow (x11_display, x11_window);
+	}
+}
+
 static void
 tilda_window_keybinding_cb (const gchar *keystr, gpointer data)
 {
@@ -259,6 +340,9 @@ tilda_window_keybinding_cb (const gchar *keystr, gpointer data)
 					NULL);
 			gtk_widget_show (GTK_WIDGET(self->window));
 
+			/* Bugfix: this code fixes metacity-2.22 */
+			tilda_window_set_active (self);
+
 			/* Focusing the term here works perfectly, near as I can tell */
 			tt = tilda_window_find_current_terminal (self);
 			gtk_widget_grab_focus (GTK_WIDGET(tt->vte_term));
@@ -344,167 +428,300 @@ tilda_window_dbus_register_object (TildaWindow *self)
 
 	gchar *object_path;
 
-	// Register this object with DBus
+	/* If DBus is not running, leave */
+	if (!dbus_connection)
+		return;
+
+	/* Register this object with DBus */
 	object_path = g_strdup_printf ("/net/sourceforge/Tilda/Window%d", self->number);
 	dbus_g_connection_register_g_object (dbus_connection, object_path, G_OBJECT(self));
 	g_free (object_path);
 }
 
 /*******************************************************************************
- * All configuration subsystem code is below
+ * All accelerator-related stuff below
  ******************************************************************************/
 
+typedef gboolean (*TildaWindowAccelCallback) (TildaWindow *self, gpointer data);
+
 /**
- * Lookup a setting in the config file for this TildaWindow.
+ * This function updates the accelerator used to call the given function for this
+ * TildaWindow. If accel is NULL, then func will be removed (no accelerator will
+ * cause func to be called).
  *
- * The returned string MUST be g_strdup()'d if you want to actually use
- * it as a value. It is owned by the config system. You MUST NOT g_free() it.
+ * Returns: TRUE on success, FALSE on failure
  */
-static gchar *
-tilda_window_lookup_from_config (TildaWindow *self, const gchar key[])
+static gboolean
+tilda_window_update_accelerator (TildaWindow *self,				/* object */
+								 gchar **accel_to_update,		/* self->??? */
+								 const gchar *accel,			/* new accel */
+								 const TildaWindowAccelCallback func)
 {
 	debug_enter  ();
 	debug_assert (TILDA_IS_WINDOW(self));
-	debug_assert (key != NULL);
+	debug_assert (accel_to_update != NULL);
+	debug_assert (func != NULL);
 
-	GError *error = NULL;
-	gchar *group_name;
-	gpointer value;
+	gboolean ret;
+	guint key;
+	GdkModifierType mod;
+	GClosure *closure;
 
-	/* Do the bottom-most lookup */
-	group_name = g_strdup_printf ("Window%d", self->number);
-	value = g_key_file_get_string (config_userprefs, group_name, key, &error);
-	g_free (group_name);
+	/* Remove the old accelerator if there was a previous one set */
+	if (*accel_to_update != NULL)
+	{
+		/* This should always parse, we've done it before! */
+		gtk_accelerator_parse (*accel_to_update, &key, &mod);
+		ret = gtk_accel_group_disconnect_key (self->accel_group, key, mod);
+	}
 
-	if (!error)
-		return value;
-	else
-		g_clear_error (&error);
+	/* If we are just removing the old accelerator, we're already done */
+	if (accel == NULL)
+	{
+		g_free (*accel_to_update);
+		*accel_to_update = NULL;
+		return TRUE;
+	}
 
-	/* Do the global lookup */
-	value = g_key_file_get_string (config_userprefs, "Global", key, &error);
+	/* Create the closure for this function */
+	closure = g_cclosure_new_swap (G_CALLBACK(func), self, NULL);
 
-	if (!error)
-		return value;
-	else
-		g_clear_error (&error);
+	/* Try to parse the new accelerator */
+	gtk_accelerator_parse (accel, &key, &mod);
 
-	/* Look in the defaults */
-	if (!g_hash_table_lookup_extended (config_defaults, key, NULL, &value))
+	if (!gtk_accelerator_valid (key, mod))
 	{
-		/* If this happened, the developers forgot to set the default for
-		 * a key they added. Please email them. */
-		g_critical ("Error: unable to find the default for key=%s\n", key);
-		exit (1);
+		g_warning (_("Failed to parse accelerator: %s\n"), accel);
+
+		/* Re-install the old accelerator */
+		if (*accel_to_update != NULL)
+		{
+			gtk_accelerator_parse (*accel_to_update, &key, &mod);
+			gtk_accel_group_connect (self->accel_group, key, mod, GTK_ACCEL_VISIBLE, closure);
+		}
+		return FALSE;
 	}
 
-	/* Return the default key */
-	return value;
+	/* All good, g_free() the old accelerator, g_strdup() the new one */
+	g_free (*accel_to_update);
+	*accel_to_update = g_strdup(accel);
+
+	/* Add the new accelerator */
+	gtk_accel_group_connect (self->accel_group, key, mod, GTK_ACCEL_VISIBLE, closure);
+
+	return TRUE;
 }
 
-/**
- * Set one of TildaWindow's integer properties from the config file or defaults.
- */
-static void
-tilda_window_config_int_property (TildaWindow *self, const gchar *property)
+static gboolean
+tilda_window_accel_quit_cb (TildaWindow *self, gpointer data)
 {
 	debug_enter  ();
 	debug_assert (TILDA_IS_WINDOW(self));
-	debug_assert (property != NULL);
 
-	gint config_value;
-	gchar *config_value_raw;
+	tilda_window_close (self);
 
-	config_value_raw = tilda_window_lookup_from_config (self, property);
-	config_value = atoi (config_value_raw);
-	g_object_set (G_OBJECT(self), property, config_value, NULL);
+	/* Do not keep propagating */
+	return TRUE;
 }
 
-static void
-tilda_window_config_enum_property (TildaWindow *self, const gchar *property)
+static gboolean
+tilda_window_accel_next_tab_cb (TildaWindow *self, gpointer data)
 {
 	debug_enter  ();
 	debug_assert (TILDA_IS_WINDOW(self));
-	debug_assert (property != NULL);
 
-	gint config_value;
-	gchar *config_value_raw;
+	gint num_pages;
+	gint current_page;
 
-	/* Copy, then strip spaces off of the string from the config */
-	config_value_raw = g_strstrip (g_strdup (tilda_window_lookup_from_config (self, property)));
+	num_pages = gtk_notebook_get_n_pages (GTK_NOTEBOOK(self->notebook));
+	current_page = gtk_notebook_get_current_page (GTK_NOTEBOOK(self->notebook));
 
-begin_parsing:
+	/* Go to next page (with wrapping) */
+	if (num_pages != (current_page + num_pages))
+		gtk_notebook_next_page (GTK_NOTEBOOK(self->notebook));
+	else
+		gtk_notebook_set_current_page (GTK_NOTEBOOK(self->notebook), num_pages-1);
 
-	/* Just try all of the possible enums */
-	if (g_ascii_strcasecmp (config_value_raw, "LEFT") == 0)
-		config_value = GTK_POS_LEFT;
-	else if (g_ascii_strcasecmp (config_value_raw, "RIGHT") == 0)
-		config_value = GTK_POS_RIGHT;
-	else if (g_ascii_strcasecmp (config_value_raw, "TOP") == 0)
-		config_value = GTK_POS_TOP;
-	else if (g_ascii_strcasecmp (config_value_raw, "BOTTOM") == 0)
-		config_value = GTK_POS_BOTTOM;
+	/* Do not keep propagating */
+	return TRUE;
+}
+
+static gboolean
+tilda_window_accel_prev_tab_cb (TildaWindow *self, gpointer data)
+{
+	debug_enter  ();
+	debug_assert (TILDA_IS_WINDOW(self));
+
+	gint num_pages;
+	gint current_page;
+
+	num_pages = gtk_notebook_get_n_pages (GTK_NOTEBOOK(self->notebook));
+	current_page = gtk_notebook_get_current_page (GTK_NOTEBOOK(self->notebook));
+
+	if ((num_pages-1) != current_page)
+		gtk_notebook_prev_page (GTK_NOTEBOOK(self->notebook));
 	else
-	{
-		g_critical ("Unable to parse: '%s' as an enum\n", config_value_raw);
+		gtk_notebook_set_current_page (GTK_NOTEBOOK(self->notebook), 0);
 
-		/* Use the default -- which I sure hope is valid (famous last words) */
-		config_value_raw = g_hash_table_lookup (config_defaults, property);
-		goto begin_parsing;
-	}
+	/* Do not keep propagating */
+	return TRUE;
+}
 
-	/* Free the value from the config system */
-	g_free (config_value_raw);
+static gboolean
+tilda_window_accel_add_term_cb (TildaWindow *self, gpointer data)
+{
+	debug_enter  ();
+	debug_assert (TILDA_IS_WINDOW(self));
 
-	g_object_set (G_OBJECT(self), property, config_value, NULL);
+	tilda_window_add_terminal (self);
+
+	/* Do not keep propagating */
+	return TRUE;
 }
 
-static void
-tilda_window_config_string_property (TildaWindow *self, const gchar *property)
+static gboolean
+tilda_window_accel_remove_term_cb (TildaWindow *self, gpointer data)
 {
 	debug_enter  ();
 	debug_assert (TILDA_IS_WINDOW(self));
-	debug_assert (property != NULL);
 
-	gchar *config_value_raw;
+	TildaTerminal *tt = tilda_window_find_current_terminal (self);
 
-	config_value_raw = tilda_window_lookup_from_config (self, property);
+	tilda_window_remove_terminal (self, tt->number);
 
-	/* The property system g_strdup()s strings for us! */
-	g_object_set (G_OBJECT(self), property, config_value_raw, NULL);
+	/* Do not keep propagating */
+	return TRUE;
 }
 
-static void
-tilda_window_config_boolean_property (TildaWindow *self, const gchar *property)
+static gboolean
+tilda_window_accel_copy_cb (TildaWindow *self, gpointer data)
 {
 	debug_enter  ();
 	debug_assert (TILDA_IS_WINDOW(self));
-	debug_assert (property != NULL);
 
-	gboolean config_value;
-	gchar *config_value_raw;
+	TildaTerminal *tt = tilda_window_find_current_terminal (self);
 
-	config_value_raw = tilda_window_lookup_from_config (self, property);
+	vte_terminal_copy_clipboard (VTE_TERMINAL(tt->vte_term));
 
-begin_parsing:
+	/* Do not keep propagating */
+	return TRUE;
+}
 
-	if (g_ascii_strcasecmp (config_value_raw, "true") == 0)
-		config_value = TRUE;
-	else if (g_ascii_strcasecmp (config_value_raw, "false") == 0)
-		config_value = FALSE;
-	else
-	{
-		g_critical ("Unable to parse: '%s' as a boolean\n", config_value_raw);
+static gboolean
+tilda_window_accel_paste_cb (TildaWindow *self, gpointer data)
+{
+	debug_enter  ();
+	debug_assert (TILDA_IS_WINDOW(self));
 
-		/* Use the default -- which I sure hope is valid (famous last words) */
-		config_value_raw = g_hash_table_lookup (config_defaults, property);
-		goto begin_parsing;
-	}
+	TildaTerminal *tt = tilda_window_find_current_terminal (self);
 
-	g_object_set (G_OBJECT(self), property, config_value, NULL);
+	vte_terminal_paste_clipboard (VTE_TERMINAL(tt->vte_term));
+
+	/* Do not keep propagating */
+	return TRUE;
 }
 
+static gboolean
+tilda_window_accel_goto_generic (TildaWindow *self, guint number)
+{
+	debug_enter  ();
+	debug_assert (TILDA_IS_WINDOW(self));
 
+	gtk_notebook_set_current_page (GTK_NOTEBOOK(self->notebook), number-1);
+
+	/* Do not keep propagating */
+	return TRUE;
+}
+
+static gboolean
+tilda_window_accel_goto_1_cb (TildaWindow *self, gpointer data)
+{
+	debug_enter  ();
+	debug_assert (TILDA_IS_WINDOW(self));
+
+	return tilda_window_accel_goto_generic (self, 1);
+}
+
+static gboolean
+tilda_window_accel_goto_2_cb (TildaWindow *self, gpointer data)
+{
+	debug_enter  ();
+	debug_assert (TILDA_IS_WINDOW(self));
+
+	return tilda_window_accel_goto_generic (self, 2);
+}
+
+static gboolean
+tilda_window_accel_goto_3_cb (TildaWindow *self, gpointer data)
+{
+	debug_enter  ();
+	debug_assert (TILDA_IS_WINDOW(self));
+
+	return tilda_window_accel_goto_generic (self, 3);
+}
+
+static gboolean
+tilda_window_accel_goto_4_cb (TildaWindow *self, gpointer data)
+{
+	debug_enter  ();
+	debug_assert (TILDA_IS_WINDOW(self));
+
+	return tilda_window_accel_goto_generic (self, 4);
+}
+
+static gboolean
+tilda_window_accel_goto_5_cb (TildaWindow *self, gpointer data)
+{
+	debug_enter  ();
+	debug_assert (TILDA_IS_WINDOW(self));
+
+	return tilda_window_accel_goto_generic (self, 5);
+}
+
+static gboolean
+tilda_window_accel_goto_6_cb (TildaWindow *self, gpointer data)
+{
+	debug_enter  ();
+	debug_assert (TILDA_IS_WINDOW(self));
+
+	return tilda_window_accel_goto_generic (self, 6);
+}
+
+static gboolean
+tilda_window_accel_goto_7_cb (TildaWindow *self, gpointer data)
+{
+	debug_enter  ();
+	debug_assert (TILDA_IS_WINDOW(self));
+
+	return tilda_window_accel_goto_generic (self, 7);
+}
+
+static gboolean
+tilda_window_accel_goto_8_cb (TildaWindow *self, gpointer data)
+{
+	debug_enter  ();
+	debug_assert (TILDA_IS_WINDOW(self));
+
+	return tilda_window_accel_goto_generic (self, 8);
+}
+
+static gboolean
+tilda_window_accel_goto_9_cb (TildaWindow *self, gpointer data)
+{
+	debug_enter  ();
+	debug_assert (TILDA_IS_WINDOW(self));
+
+	return tilda_window_accel_goto_generic (self, 9);
+}
+
+static gboolean
+tilda_window_accel_goto_10_cb (TildaWindow *self, gpointer data)
+{
+	debug_enter  ();
+	debug_assert (TILDA_IS_WINDOW(self));
+
+	return tilda_window_accel_goto_generic (self, 10);
+}
 
 /*******************************************************************************
  * ALL GOBJECT STUFF BELOW PLEASE
@@ -516,12 +733,31 @@ enum tilda_window_properties {
 	TILDA_WINDOW_NUMBER = 1,
 	TILDA_WINDOW_CONTROLLER,
 
+	TILDA_WINDOW_ACCEL_QUIT,
+	TILDA_WINDOW_ACCEL_NEXT_TAB,
+	TILDA_WINDOW_ACCEL_PREV_TAB,
+	TILDA_WINDOW_ACCEL_ADD_TERM,
+	TILDA_WINDOW_ACCEL_REMOVE_TERM,
+	TILDA_WINDOW_ACCEL_COPY,
+	TILDA_WINDOW_ACCEL_PASTE,
+	TILDA_WINDOW_ACCEL_GOTO_1,
+	TILDA_WINDOW_ACCEL_GOTO_2,
+	TILDA_WINDOW_ACCEL_GOTO_3,
+	TILDA_WINDOW_ACCEL_GOTO_4,
+	TILDA_WINDOW_ACCEL_GOTO_5,
+	TILDA_WINDOW_ACCEL_GOTO_6,
+	TILDA_WINDOW_ACCEL_GOTO_7,
+	TILDA_WINDOW_ACCEL_GOTO_8,
+	TILDA_WINDOW_ACCEL_GOTO_9,
+	TILDA_WINDOW_ACCEL_GOTO_10,
+
 	TILDA_WINDOW_KEY,
 
 	TILDA_WINDOW_HEIGHT,
 	TILDA_WINDOW_WIDTH,
 	TILDA_WINDOW_X_POSITION,
 	TILDA_WINDOW_Y_POSITION,
+	TILDA_WINDOW_INITIAL_TERMINALS,
 
 	TILDA_WINDOW_TAB_POSITION,
 	TILDA_WINDOW_ANIMATION_ORIENTATION,
@@ -533,6 +769,9 @@ enum tilda_window_properties {
 	TILDA_WINDOW_HIDDEN_AT_START,
 	TILDA_WINDOW_CENTERED_HORIZONTALLY,
 	TILDA_WINDOW_CENTERED_VERTICALLY,
+	TILDA_WINDOW_FULL_WIDTH_TABS,
+	TILDA_WINDOW_ALWAYS_SHOW_TABS,
+	TILDA_WINDOW_ALWAYS_SHOW_BORDER,
 
 	TILDA_WINDOW_HAVE_REAL_TRANSPARENCY,
 };
@@ -551,6 +790,10 @@ tilda_window_instance_init (GTypeInstance *instance,
 	self->notebook = gtk_notebook_new ();
 	self->terms = g_ptr_array_new ();
 
+	/* Accelerators */
+	self->accel_group = gtk_accel_group_new ();
+	gtk_window_add_accel_group (GTK_WINDOW(self->window), self->accel_group);
+
 	/* Somewhat of a "poison" value, incase we don't set this */
 	self->number = 0xdeadbeef;
 	self->controller = NULL;
@@ -565,6 +808,7 @@ tilda_window_set_property (GObject      *object,
 						   GParamSpec   *pspec)
 {
 	TildaWindow *self = (TildaWindow *) object;
+	gint i;
 
 	switch (property_id) {
 
@@ -575,7 +819,143 @@ tilda_window_set_property (GObject      *object,
 
 		case TILDA_WINDOW_CONTROLLER:
 			self->controller = g_value_get_pointer (value);
-			debug_printf ("window controller: 0x%x\n", self->controller);
+			debug_printf ("window controller: 0x%p\n", self->controller);
+			break;
+
+		case TILDA_WINDOW_ACCEL_QUIT:
+			tilda_window_update_accelerator (self,
+											 &self->accel_quit,
+											 g_value_get_string (value),
+											 tilda_window_accel_quit_cb);
+			debug_printf ("window accel quit: %s\n", self->accel_quit);
+			break;
+
+		case TILDA_WINDOW_ACCEL_NEXT_TAB:
+			tilda_window_update_accelerator (self,
+											 &self->accel_next_tab,
+											 g_value_get_string (value),
+											 tilda_window_accel_next_tab_cb);
+			debug_printf ("window accel next tab: %s\n", self->accel_next_tab);
+			break;
+
+		case TILDA_WINDOW_ACCEL_PREV_TAB:
+			tilda_window_update_accelerator (self,
+											 &self->accel_prev_tab,
+											 g_value_get_string (value),
+											 tilda_window_accel_prev_tab_cb);
+			debug_printf ("window accel prev tab: %s\n", self->accel_prev_tab);
+			break;
+
+		case TILDA_WINDOW_ACCEL_ADD_TERM:
+			tilda_window_update_accelerator (self,
+											 &self->accel_add_term,
+											 g_value_get_string (value),
+											 tilda_window_accel_add_term_cb);
+			debug_printf ("window accel add term: %s\n", self->accel_add_term);
+			break;
+
+		case TILDA_WINDOW_ACCEL_REMOVE_TERM:
+			tilda_window_update_accelerator (self,
+											 &self->accel_remove_term,
+											 g_value_get_string (value),
+											 tilda_window_accel_remove_term_cb);
+			debug_printf ("window accel remove term: %s\n", self->accel_remove_term);
+			break;
+
+		case TILDA_WINDOW_ACCEL_COPY:
+			tilda_window_update_accelerator (self,
+											 &self->accel_copy,
+											 g_value_get_string (value),
+											 tilda_window_accel_copy_cb);
+			debug_printf ("window accel copy: %s\n", self->accel_copy);
+			break;
+
+		case TILDA_WINDOW_ACCEL_PASTE:
+			tilda_window_update_accelerator (self,
+											 &self->accel_paste,
+											 g_value_get_string (value),
+											 tilda_window_accel_paste_cb);
+			debug_printf ("window accel paste: %s\n", self->accel_paste);
+			break;
+
+		case TILDA_WINDOW_ACCEL_GOTO_1:
+			tilda_window_update_accelerator (self,
+											 &self->accel_goto_1,
+											 g_value_get_string (value),
+											 tilda_window_accel_goto_1_cb);
+			debug_printf ("window accel goto 1: %s\n", self->accel_goto_1);
+			break;
+
+		case TILDA_WINDOW_ACCEL_GOTO_2:
+			tilda_window_update_accelerator (self,
+											 &self->accel_goto_2,
+											 g_value_get_string (value),
+											 tilda_window_accel_goto_2_cb);
+			debug_printf ("window accel goto 2: %s\n", self->accel_goto_2);
+			break;
+
+		case TILDA_WINDOW_ACCEL_GOTO_3:
+			tilda_window_update_accelerator (self,
+											 &self->accel_goto_3,
+											 g_value_get_string (value),
+											 tilda_window_accel_goto_3_cb);
+			debug_printf ("window accel goto 3: %s\n", self->accel_goto_3);
+			break;
+
+		case TILDA_WINDOW_ACCEL_GOTO_4:
+			tilda_window_update_accelerator (self,
+											 &self->accel_goto_4,
+											 g_value_get_string (value),
+											 tilda_window_accel_goto_4_cb);
+			debug_printf ("window accel goto 4: %s\n", self->accel_goto_4);
+			break;
+
+		case TILDA_WINDOW_ACCEL_GOTO_5:
+			tilda_window_update_accelerator (self,
+											 &self->accel_goto_5,
+											 g_value_get_string (value),
+											 tilda_window_accel_goto_5_cb);
+			debug_printf ("window accel goto 5: %s\n", self->accel_goto_5);
+			break;
+
+		case TILDA_WINDOW_ACCEL_GOTO_6:
+			tilda_window_update_accelerator (self,
+											 &self->accel_goto_6,
+											 g_value_get_string (value),
+											 tilda_window_accel_goto_6_cb);
+			debug_printf ("window accel goto 6: %s\n", self->accel_goto_6);
+			break;
+
+		case TILDA_WINDOW_ACCEL_GOTO_7:
+			tilda_window_update_accelerator (self,
+											 &self->accel_goto_7,
+											 g_value_get_string (value),
+											 tilda_window_accel_goto_7_cb);
+			debug_printf ("window accel goto 7: %s\n", self->accel_goto_7);
+			break;
+
+		case TILDA_WINDOW_ACCEL_GOTO_8:
+			tilda_window_update_accelerator (self,
+											 &self->accel_goto_8,
+											 g_value_get_string (value),
+											 tilda_window_accel_goto_8_cb);
+			debug_printf ("window accel goto 8: %s\n", self->accel_goto_8);
+			break;
+
+		case TILDA_WINDOW_ACCEL_GOTO_9:
+			tilda_window_update_accelerator (self,
+											 &self->accel_goto_9,
+											 g_value_get_string (value),
+											 tilda_window_accel_goto_9_cb);
+			debug_printf ("window accel goto 9: %s\n", self->accel_goto_9);
+			break;
+
+		case TILDA_WINDOW_ACCEL_GOTO_10:
+			tilda_window_update_accelerator (self,
+											 &self->accel_goto_10,
+											 g_value_get_string (value),
+											 tilda_window_accel_goto_10_cb);
+			debug_printf ("window accel goto 10: %s\n", self->accel_goto_10);
 			break;
 
 		case TILDA_WINDOW_KEY:
@@ -609,14 +989,19 @@ tilda_window_set_property (GObject      *object,
 			debug_printf ("window y position: %d\n", self->y_position);
 			break;
 
+		case TILDA_WINDOW_INITIAL_TERMINALS:
+			self->initial_terminals = g_value_get_int (value);
+			debug_printf ("window initial terminals: %d\n", self->initial_terminals);
+			break;
+
 		case TILDA_WINDOW_TAB_POSITION:
-			self->tab_position = g_value_get_int (value);
+			self->tab_position = g_value_get_enum (value);
 			gtk_notebook_set_tab_pos (GTK_NOTEBOOK(self->notebook), self->tab_position);
 			debug_printf ("window tab position: %d\n", self->tab_position);
 			break;
 
 		case TILDA_WINDOW_ANIMATION_ORIENTATION:
-			self->animation_orientation = g_value_get_int (value);
+			self->animation_orientation = g_value_get_enum (value);
 			debug_printf ("window animation orientation: %d\n", self->animation_orientation);
 			break;
 
@@ -665,6 +1050,29 @@ tilda_window_set_property (GObject      *object,
 			debug_printf ("window centered vertically: %d\n", self->centered_vertically);
 			break;
 
+		case TILDA_WINDOW_FULL_WIDTH_TABS:
+			self->full_width_tabs = g_value_get_boolean (value);
+			for (i=0; i<self->terms->len; ++i)
+				gtk_notebook_set_tab_label_packing (GTK_NOTEBOOK(self->notebook),
+													TILDA_TERMINAL(g_ptr_array_index(self->terms, i))->hbox,
+													self->full_width_tabs,
+													TRUE,
+													GTK_PACK_START);
+			debug_printf ("window full width tabs: %d\n", self->full_width_tabs);
+			break;
+
+		case TILDA_WINDOW_ALWAYS_SHOW_TABS:
+			self->always_show_tabs = g_value_get_boolean (value);
+			tilda_window_show_hide_tabs_if_appropriate (self);
+			debug_printf ("window always show tabs: %d\n", self->always_show_tabs);
+			break;
+
+		case TILDA_WINDOW_ALWAYS_SHOW_BORDER:
+			self->always_show_border = g_value_get_boolean (value);
+			gtk_notebook_set_show_border (GTK_NOTEBOOK(self->notebook), self->always_show_border);
+			debug_printf ("window always show border: %d\n", self->always_show_border);
+			break;
+
 		case TILDA_WINDOW_HAVE_REAL_TRANSPARENCY:
 			self->have_real_transparency = g_value_get_boolean (value);
 			debug_printf ("window have real transp: %d\n", self->have_real_transparency);
@@ -695,6 +1103,74 @@ tilda_window_get_property (GObject    *object,
 			g_value_set_pointer (value, self->controller);
 			break;
 
+		case TILDA_WINDOW_ACCEL_QUIT:
+			g_value_set_string (value, self->accel_quit);
+			break;
+
+		case TILDA_WINDOW_ACCEL_NEXT_TAB:
+			g_value_set_string (value, self->accel_next_tab);
+			break;
+
+		case TILDA_WINDOW_ACCEL_PREV_TAB:
+			g_value_set_string (value, self->accel_prev_tab);
+			break;
+
+		case TILDA_WINDOW_ACCEL_ADD_TERM:
+			g_value_set_string (value, self->accel_prev_tab);
+			break;
+
+		case TILDA_WINDOW_ACCEL_REMOVE_TERM:
+			g_value_set_string (value, self->accel_remove_term);
+			break;
+
+		case TILDA_WINDOW_ACCEL_COPY:
+			g_value_set_string (value, self->accel_copy);
+			break;
+
+		case TILDA_WINDOW_ACCEL_PASTE:
+			g_value_set_string (value, self->accel_paste);
+			break;
+
+		case TILDA_WINDOW_ACCEL_GOTO_1:
+			g_value_set_string (value, self->accel_goto_1);
+			break;
+
+		case TILDA_WINDOW_ACCEL_GOTO_2:
+			g_value_set_string (value, self->accel_goto_2);
+			break;
+
+		case TILDA_WINDOW_ACCEL_GOTO_3:
+			g_value_set_string (value, self->accel_goto_3);
+			break;
+
+		case TILDA_WINDOW_ACCEL_GOTO_4:
+			g_value_set_string (value, self->accel_goto_4);
+			break;
+
+		case TILDA_WINDOW_ACCEL_GOTO_5:
+			g_value_set_string (value, self->accel_goto_5);
+			break;
+
+		case TILDA_WINDOW_ACCEL_GOTO_6:
+			g_value_set_string (value, self->accel_goto_6);
+			break;
+
+		case TILDA_WINDOW_ACCEL_GOTO_7:
+			g_value_set_string (value, self->accel_goto_7);
+			break;
+
+		case TILDA_WINDOW_ACCEL_GOTO_8:
+			g_value_set_string (value, self->accel_goto_8);
+			break;
+
+		case TILDA_WINDOW_ACCEL_GOTO_9:
+			g_value_set_string (value, self->accel_goto_9);
+			break;
+
+		case TILDA_WINDOW_ACCEL_GOTO_10:
+			g_value_set_string (value, self->accel_goto_10);
+			break;
+
 		case TILDA_WINDOW_KEY:
 			g_value_set_string (value, self->key);
 			break;
@@ -715,12 +1191,16 @@ tilda_window_get_property (GObject    *object,
 			g_value_set_int (value, self->y_position);
 			break;
 
+		case TILDA_WINDOW_INITIAL_TERMINALS:
+			g_value_set_int (value, self->initial_terminals);
+			break;
+
 		case TILDA_WINDOW_TAB_POSITION:
-			g_value_set_int (value, self->tab_position);
+			g_value_set_enum (value, self->tab_position);
 			break;
 
 		case TILDA_WINDOW_ANIMATION_ORIENTATION:
-			g_value_set_int (value, self->animation_orientation);
+			g_value_set_enum (value, self->animation_orientation);
 			break;
 
 		case TILDA_WINDOW_ANIMATION_DELAY:
@@ -751,6 +1231,18 @@ tilda_window_get_property (GObject    *object,
 			g_value_set_boolean (value, self->centered_vertically);
 			break;
 
+		case TILDA_WINDOW_FULL_WIDTH_TABS:
+			g_value_set_boolean (value, self->full_width_tabs);
+			break;
+
+		case TILDA_WINDOW_ALWAYS_SHOW_TABS:
+			g_value_set_boolean (value, self->always_show_tabs);
+			break;
+
+		case TILDA_WINDOW_ALWAYS_SHOW_BORDER:
+			g_value_set_boolean (value, self->always_show_border);
+			break;
+
 		case TILDA_WINDOW_HAVE_REAL_TRANSPARENCY:
 			g_value_set_boolean (value, self->have_real_transparency);
 			break;
@@ -771,6 +1263,7 @@ tilda_window_constructor (GType                  type,
 
 	GObject *obj;
 	TildaWindow *self;
+	gint i;
 
 	/* Invoke parent constructor */
 	TildaWindowClass *klass;
@@ -795,7 +1288,7 @@ tilda_window_constructor (GType                  type,
 	gtk_window_set_decorated (GTK_WINDOW(self->window), FALSE);
 
 	/* Set all of the properties out of the config file */
-	tilda_window_config_string_property (self, "key");
+	tilda_window_set_property_from_config (self, "key");
 
 	// FIXME: hack -- start the wizard in this case :)
 	if (!self->key)
@@ -807,35 +1300,55 @@ tilda_window_constructor (GType                  type,
 		g_critical ("HACK: start the wizard here\n");
 	}
 
-	tilda_window_config_int_property (self, "height");
-	tilda_window_config_int_property (self, "width");
-	tilda_window_config_int_property (self, "x-position");
-	tilda_window_config_int_property (self, "y-position");
-	tilda_window_config_int_property (self, "animation-delay");
-
-	tilda_window_config_enum_property (self, "tab-position");
-	tilda_window_config_enum_property (self, "animation-orientation");
-
-	tilda_window_config_boolean_property (self, "keep-above");
-	tilda_window_config_boolean_property (self, "skip-taskbar-hint");
-	tilda_window_config_boolean_property (self, "stick");
-	tilda_window_config_boolean_property (self, "hidden-at-start");
-	tilda_window_config_boolean_property (self, "centered-horizontally");
-	tilda_window_config_boolean_property (self, "centered-vertically");
-
-	// FIXME: It should be configurable how many terms we add at startup
-	tilda_window_add_terminal (self);
-	tilda_window_add_terminal (self);
+	tilda_window_set_property_from_config (self, "accelerator-quit");
+	tilda_window_set_property_from_config (self, "accelerator-next-tab");
+	tilda_window_set_property_from_config (self, "accelerator-previous-tab");
+	tilda_window_set_property_from_config (self, "accelerator-add-terminal");
+	tilda_window_set_property_from_config (self, "accelerator-remove-terminal");
+	tilda_window_set_property_from_config (self, "accelerator-copy");
+	tilda_window_set_property_from_config (self, "accelerator-paste");
+	tilda_window_set_property_from_config (self, "accelerator-goto-1");
+	tilda_window_set_property_from_config (self, "accelerator-goto-2");
+	tilda_window_set_property_from_config (self, "accelerator-goto-3");
+	tilda_window_set_property_from_config (self, "accelerator-goto-4");
+	tilda_window_set_property_from_config (self, "accelerator-goto-5");
+	tilda_window_set_property_from_config (self, "accelerator-goto-6");
+	tilda_window_set_property_from_config (self, "accelerator-goto-7");
+	tilda_window_set_property_from_config (self, "accelerator-goto-8");
+	tilda_window_set_property_from_config (self, "accelerator-goto-9");
+	tilda_window_set_property_from_config (self, "accelerator-goto-10");
+
+	tilda_window_set_property_from_config (self, "height");
+	tilda_window_set_property_from_config (self, "width");
+	tilda_window_set_property_from_config (self, "x-position");
+	tilda_window_set_property_from_config (self, "y-position");
+	tilda_window_set_property_from_config (self, "initial-terminals");
+	tilda_window_set_property_from_config (self, "animation-delay");
+
+	tilda_window_set_property_from_config (self, "tab-position");
+	tilda_window_set_property_from_config (self, "animation-orientation");
+
+	tilda_window_set_property_from_config (self, "keep-above");
+	tilda_window_set_property_from_config (self, "skip-taskbar-hint");
+	tilda_window_set_property_from_config (self, "stick");
+	tilda_window_set_property_from_config (self, "hidden-at-start");
+	tilda_window_set_property_from_config (self, "centered-horizontally");
+	tilda_window_set_property_from_config (self, "centered-vertically");
+	tilda_window_set_property_from_config (self, "full-width-tabs");
+	tilda_window_set_property_from_config (self, "always-show-tabs");
+	tilda_window_set_property_from_config (self, "always-show-border");
+
+	/* Add the initial terminal(s) */
+	for (i=0; i<self->initial_terminals; ++i)
+		tilda_window_add_terminal (self);
+
+	/* Realize the window (only sets up X resources), and set its current state */
+	gtk_widget_realize (self->window);
+	self->state = WINDOW_UP;
 
-	/* Show us if we're ready. If not, just remain hidden. All sub-widgets must
-	 * be gtk_widget_show()n by this point. */
+	/* If we should be shown now, do a mock call of the global callback */
 	if (!self->hidden_at_start)
-	{
-		gtk_widget_show (self->window);
-		self->state = WINDOW_DOWN;
-	}
-	else
-		self->state = WINDOW_UP;
+		tilda_window_keybinding_cb (NULL, self);
 
 	/* Register this object with DBus */
 	tilda_window_dbus_register_object (self);
@@ -863,6 +1376,7 @@ tilda_window_dispose (GObject *obj)
 	 * NOTE: See the following for how to deal with GtkObject-derived things:
 	 * http://library.gnome.org/devel/gtk/unstable/GtkObject.html
 	 */
+	g_object_unref (G_OBJECT(self->accel_group));
 	g_ptr_array_foreach (self->terms, g_object_unref, NULL);
 	gtk_widget_destroy (self->window);
 
@@ -934,6 +1448,176 @@ tilda_window_class_init (gpointer g_class,
 									 TILDA_WINDOW_CONTROLLER,
 									 pspec);
 
+	pspec = g_param_spec_string ("accelerator-quit",
+								 _("Accelerator to quit this window"),
+								 NULL,
+								 NULL,
+								 G_PARAM_READWRITE);
+
+	g_object_class_install_property (gobject_class,
+									 TILDA_WINDOW_ACCEL_QUIT,
+									 pspec);
+
+	pspec = g_param_spec_string ("accelerator-next-tab",
+								 _("Accelerator to go to the next tab"),
+								 NULL,
+								 NULL,
+								 G_PARAM_READWRITE);
+
+	g_object_class_install_property (gobject_class,
+									 TILDA_WINDOW_ACCEL_NEXT_TAB,
+									 pspec);
+
+	pspec = g_param_spec_string ("accelerator-previous-tab",
+								 _("Accelerator to go to the previous tab"),
+								 NULL,
+								 NULL,
+								 G_PARAM_READWRITE);
+
+	g_object_class_install_property (gobject_class,
+									 TILDA_WINDOW_ACCEL_PREV_TAB,
+									 pspec);
+
+	pspec = g_param_spec_string ("accelerator-add-terminal",
+								 _("Accelerator to add a terminal"),
+								 NULL,
+								 NULL,
+								 G_PARAM_READWRITE);
+
+	g_object_class_install_property (gobject_class,
+									 TILDA_WINDOW_ACCEL_ADD_TERM,
+									 pspec);
+
+	pspec = g_param_spec_string ("accelerator-remove-terminal",
+								 _("Accelerator to remove a terminal"),
+								 NULL,
+								 NULL,
+								 G_PARAM_READWRITE);
+
+	g_object_class_install_property (gobject_class,
+									 TILDA_WINDOW_ACCEL_REMOVE_TERM,
+									 pspec);
+
+	pspec = g_param_spec_string ("accelerator-copy",
+								 _("Accelerator to copy to the clipboard"),
+								 NULL,
+								 NULL,
+								 G_PARAM_READWRITE);
+
+	g_object_class_install_property (gobject_class,
+									 TILDA_WINDOW_ACCEL_COPY,
+									 pspec);
+
+	pspec = g_param_spec_string ("accelerator-paste",
+								 _("Accelerator to paste from the clipboard"),
+								 NULL,
+								 NULL,
+								 G_PARAM_READWRITE);
+
+	g_object_class_install_property (gobject_class,
+									 TILDA_WINDOW_ACCEL_PASTE,
+									 pspec);
+
+	pspec = g_param_spec_string ("accelerator-goto-1",
+								 _("Accelerator to go to tab 1"),
+								 NULL,
+								 NULL,
+								 G_PARAM_READWRITE);
+
+	g_object_class_install_property (gobject_class,
+									 TILDA_WINDOW_ACCEL_GOTO_1,
+									 pspec);
+
+	pspec = g_param_spec_string ("accelerator-goto-2",
+								 _("Accelerator to go to tab 2"),
+								 NULL,
+								 NULL,
+								 G_PARAM_READWRITE);
+
+	g_object_class_install_property (gobject_class,
+									 TILDA_WINDOW_ACCEL_GOTO_2,
+									 pspec);
+
+	pspec = g_param_spec_string ("accelerator-goto-3",
+								 _("Accelerator to go to tab 3"),
+								 NULL,
+								 NULL,
+								 G_PARAM_READWRITE);
+
+	g_object_class_install_property (gobject_class,
+									 TILDA_WINDOW_ACCEL_GOTO_3,
+									 pspec);
+
+	pspec = g_param_spec_string ("accelerator-goto-4",
+								 _("Accelerator to go to tab 4"),
+								 NULL,
+								 NULL,
+								 G_PARAM_READWRITE);
+
+	g_object_class_install_property (gobject_class,
+									 TILDA_WINDOW_ACCEL_GOTO_4,
+									 pspec);
+
+	pspec = g_param_spec_string ("accelerator-goto-5",
+								 _("Accelerator to go to tab 5"),
+								 NULL,
+								 NULL,
+								 G_PARAM_READWRITE);
+
+	g_object_class_install_property (gobject_class,
+									 TILDA_WINDOW_ACCEL_GOTO_5,
+									 pspec);
+
+	pspec = g_param_spec_string ("accelerator-goto-6",
+								 _("Accelerator to go to tab 6"),
+								 NULL,
+								 NULL,
+								 G_PARAM_READWRITE);
+
+	g_object_class_install_property (gobject_class,
+									 TILDA_WINDOW_ACCEL_GOTO_6,
+									 pspec);
+
+	pspec = g_param_spec_string ("accelerator-goto-7",
+								 _("Accelerator to go to tab 7"),
+								 NULL,
+								 NULL,
+								 G_PARAM_READWRITE);
+
+	g_object_class_install_property (gobject_class,
+									 TILDA_WINDOW_ACCEL_GOTO_7,
+									 pspec);
+
+	pspec = g_param_spec_string ("accelerator-goto-8",
+								 _("Accelerator to go to tab 8"),
+								 NULL,
+								 NULL,
+								 G_PARAM_READWRITE);
+
+	g_object_class_install_property (gobject_class,
+									 TILDA_WINDOW_ACCEL_GOTO_8,
+									 pspec);
+
+	pspec = g_param_spec_string ("accelerator-goto-9",
+								 _("Accelerator to go to tab 9"),
+								 NULL,
+								 NULL,
+								 G_PARAM_READWRITE);
+
+	g_object_class_install_property (gobject_class,
+									 TILDA_WINDOW_ACCEL_GOTO_9,
+									 pspec);
+
+	pspec = g_param_spec_string ("accelerator-goto-10",
+								 _("Accelerator to go to tab 10"),
+								 NULL,
+								 NULL,
+								 G_PARAM_READWRITE);
+
+	g_object_class_install_property (gobject_class,
+									 TILDA_WINDOW_ACCEL_GOTO_10,
+									 pspec);
+
 	pspec = g_param_spec_string ("key",
 								 _("Window's drop-down keybinding"),
 								 NULL,
@@ -992,25 +1676,35 @@ tilda_window_class_init (gpointer g_class,
 									 TILDA_WINDOW_Y_POSITION,
 									 pspec);
 
-	pspec = g_param_spec_int ("tab-position",
-							  _("Position of window's tab bar"),
+	pspec = g_param_spec_int ("initial-terminals",
+							  _("Window's inital number of terminals"),
 							  NULL,
-							  0,
+							  1,
 							  INT_MAX,
-							  0,
+							  1,
 							  G_PARAM_READWRITE);
 
+	g_object_class_install_property (gobject_class,
+									 TILDA_WINDOW_INITIAL_TERMINALS,
+									 pspec);
+
+	pspec = g_param_spec_enum ("tab-position",
+							   _("Position of window's tab bar"),
+							   NULL,
+							   gtk_position_type_get_type(),
+							   GTK_POS_TOP,
+							   G_PARAM_READWRITE);
+
 	g_object_class_install_property (gobject_class,
 									 TILDA_WINDOW_TAB_POSITION,
 									 pspec);
 
-	pspec = g_param_spec_int ("animation-orientation",
-							  _("Window's animation orientation"),
-							  NULL,
-							  0,
-							  INT_MAX,
-							  0,
-							  G_PARAM_READWRITE);
+	pspec = g_param_spec_enum ("animation-orientation",
+							   _("Window's animation orientation"),
+							   NULL,
+							   gtk_position_type_get_type(),
+							   GTK_POS_TOP,
+							   G_PARAM_READWRITE);
 
 	g_object_class_install_property (gobject_class,
 									 TILDA_WINDOW_ANIMATION_ORIENTATION,
@@ -1088,6 +1782,36 @@ tilda_window_class_init (gpointer g_class,
 									 TILDA_WINDOW_CENTERED_VERTICALLY,
 									 pspec);
 
+	pspec = g_param_spec_boolean ("full-width-tabs",
+								  _("Tabs should have full width of window"),
+								  NULL,
+								  TRUE,
+								  G_PARAM_READWRITE);
+
+	g_object_class_install_property (gobject_class,
+									 TILDA_WINDOW_FULL_WIDTH_TABS,
+									 pspec);
+
+	pspec = g_param_spec_boolean ("always-show-tabs",
+								  _("Always show the tab bar, regardless of the number of open tabs"),
+								  NULL,
+								  TRUE,
+								  G_PARAM_READWRITE);
+
+	g_object_class_install_property (gobject_class,
+									 TILDA_WINDOW_ALWAYS_SHOW_TABS,
+									 pspec);
+
+	pspec = g_param_spec_boolean ("always-show-border",
+								  _("Always show the window borders, regardless of the number of open tabs"),
+								  NULL,
+								  TRUE,
+								  G_PARAM_READWRITE);
+
+	g_object_class_install_property (gobject_class,
+									 TILDA_WINDOW_ALWAYS_SHOW_BORDER,
+									 pspec);
+
 	pspec = g_param_spec_boolean ("have-real-transparency",
 								  NULL, NULL, FALSE, G_PARAM_READABLE);