/*
 * pluma-window.c
 * This file is part of pluma
 *
 * Copyright (C) 2005 - Paolo Maggi 
 *
 * This program 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 2 of the License, or
 * (at your option) any later version.
 *
 * This program 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, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, 
 * Boston, MA 02110-1301, USA.
 */
 
/*
 * Modified by the pluma Team, 2005. See the AUTHORS file for a 
 * list of people on the pluma Team.  
 * See the ChangeLog files for a list of changes. 
 *
 * $Id$
 */

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <time.h>
#include <sys/types.h>
#include <string.h>

#include <glib/gi18n.h>
#include <gio/gio.h>
#include <gtk/gtk.h>
#if GTK_CHECK_VERSION (3, 0, 0)
#include <gtksourceview/gtksource.h>
#endif

#include "pluma-ui.h"
#include "pluma-window.h"
#include "pluma-window-private.h"
#include "pluma-app.h"
#include "pluma-notebook.h"
#include "pluma-statusbar.h"
#include "pluma-utils.h"
#include "pluma-commands.h"
#include "pluma-debug.h"
#include "pluma-language-manager.h"
#include "pluma-prefs-manager-app.h"
#include "pluma-panel.h"
#include "pluma-documents-panel.h"
#include "pluma-plugins-engine.h"
#include "pluma-enum-types.h"
#include "pluma-dirs.h"
#include "pluma-status-combo-box.h"

#define LANGUAGE_NONE (const gchar *)"LangNone"
#define PLUMA_UIFILE "pluma-ui.xml"
#define TAB_WIDTH_DATA "PlumaWindowTabWidthData"
#define LANGUAGE_DATA "PlumaWindowLanguageData"
#define FULLSCREEN_ANIMATION_SPEED 4

#define PLUMA_WINDOW_GET_PRIVATE(object)(G_TYPE_INSTANCE_GET_PRIVATE ((object),\
					 PLUMA_TYPE_WINDOW,                    \
					 PlumaWindowPrivate))

#if GTK_CHECK_VERSION (3, 0, 0)
#define gtk_vbox_new(X,Y) gtk_box_new(GTK_ORIENTATION_VERTICAL,Y)
#endif

/* Signals */
enum
{
	TAB_ADDED,
	TAB_REMOVED,
	TABS_REORDERED,
	ACTIVE_TAB_CHANGED,
	ACTIVE_TAB_STATE_CHANGED,
	LAST_SIGNAL
};

static guint signals[LAST_SIGNAL] = { 0 };

enum
{
	PROP_0,
	PROP_STATE
};

enum
{
	TARGET_URI_LIST = 100
};

G_DEFINE_TYPE(PlumaWindow, pluma_window, GTK_TYPE_WINDOW)

static void	recent_manager_changed	(GtkRecentManager *manager,
					 PlumaWindow *window);

static void
pluma_window_get_property (GObject    *object,
			   guint       prop_id,
			   GValue     *value,
			   GParamSpec *pspec)
{
	PlumaWindow *window = PLUMA_WINDOW (object);

	switch (prop_id)
	{
		case PROP_STATE:
			g_value_set_enum (value,
					  pluma_window_get_state (window));
			break;			
		default:
			G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
			break;			
	}
}

static void
save_panes_state (PlumaWindow *window)
{
	gint pane_page;

	pluma_debug (DEBUG_WINDOW);

	if (pluma_prefs_manager_window_size_can_set ())
		pluma_prefs_manager_set_window_size (window->priv->width,
						     window->priv->height);

	if (pluma_prefs_manager_window_state_can_set ())
		pluma_prefs_manager_set_window_state (window->priv->window_state);

	if ((window->priv->side_panel_size > 0) &&
	    pluma_prefs_manager_side_panel_size_can_set ())
		pluma_prefs_manager_set_side_panel_size	(
					window->priv->side_panel_size);

	pane_page = _pluma_panel_get_active_item_id (PLUMA_PANEL (window->priv->side_panel));
	if (pane_page != 0 &&
	    pluma_prefs_manager_side_panel_active_page_can_set ())
		pluma_prefs_manager_set_side_panel_active_page (pane_page);

	if ((window->priv->bottom_panel_size > 0) && 
	    pluma_prefs_manager_bottom_panel_size_can_set ())
		pluma_prefs_manager_set_bottom_panel_size (
					window->priv->bottom_panel_size);

	pane_page = _pluma_panel_get_active_item_id (PLUMA_PANEL (window->priv->bottom_panel));
	if (pane_page != 0 &&
	    pluma_prefs_manager_bottom_panel_active_page_can_set ())
		pluma_prefs_manager_set_bottom_panel_active_page (pane_page);
}

static void
pluma_window_dispose (GObject *object)
{
	PlumaWindow *window;

	pluma_debug (DEBUG_WINDOW);

	window = PLUMA_WINDOW (object);

	/* Stop tracking removal of panes otherwise we always
	 * end up with thinking we had no pane active, since they
	 * should all be removed below */
	if (window->priv->bottom_panel_item_removed_handler_id != 0)
	{
		g_signal_handler_disconnect (window->priv->bottom_panel,
					     window->priv->bottom_panel_item_removed_handler_id);
		window->priv->bottom_panel_item_removed_handler_id = 0;
	}

	/* First of all, force collection so that plugins
	 * really drop some of the references.
	 */
	pluma_plugins_engine_garbage_collect (pluma_plugins_engine_get_default ());

	/* save the panes position and make sure to deactivate plugins
	 * for this window, but only once */
	if (!window->priv->dispose_has_run)
	{
		save_panes_state (window);

		pluma_plugins_engine_deactivate_plugins (pluma_plugins_engine_get_default (),
					                  window);
		window->priv->dispose_has_run = TRUE;
	}

	if (window->priv->fullscreen_animation_timeout_id != 0)
	{
		g_source_remove (window->priv->fullscreen_animation_timeout_id);
		window->priv->fullscreen_animation_timeout_id = 0;
	}

	if (window->priv->fullscreen_controls != NULL)
	{
		gtk_widget_destroy (window->priv->fullscreen_controls);
		
		window->priv->fullscreen_controls = NULL;
	}

	if (window->priv->recents_handler_id != 0)
	{
		GtkRecentManager *recent_manager;

		recent_manager =  gtk_recent_manager_get_default ();
		g_signal_handler_disconnect (recent_manager,
					     window->priv->recents_handler_id);
		window->priv->recents_handler_id = 0;
	}

	if (window->priv->manager != NULL)
	{
		g_object_unref (window->priv->manager);
		window->priv->manager = NULL;
	}

	if (window->priv->message_bus != NULL)
	{
		g_object_unref (window->priv->message_bus);
		window->priv->message_bus = NULL;
	}

	if (window->priv->window_group != NULL)
	{
		g_object_unref (window->priv->window_group);
		window->priv->window_group = NULL;
	}
	
	/* Now that there have broken some reference loops,
	 * force collection again.
	 */
	pluma_plugins_engine_garbage_collect (pluma_plugins_engine_get_default ());

	G_OBJECT_CLASS (pluma_window_parent_class)->dispose (object);
}

static void
pluma_window_finalize (GObject *object)
{
	PlumaWindow *window; 

	pluma_debug (DEBUG_WINDOW);

	window = PLUMA_WINDOW (object);

	if (window->priv->default_location != NULL)
		g_object_unref (window->priv->default_location);

	G_OBJECT_CLASS (pluma_window_parent_class)->finalize (object);
}

static gboolean
pluma_window_window_state_event (GtkWidget           *widget,
				 GdkEventWindowState *event)
{
	PlumaWindow *window = PLUMA_WINDOW (widget);

	window->priv->window_state = event->new_window_state;

	if (event->changed_mask &
	    (GDK_WINDOW_STATE_MAXIMIZED | GDK_WINDOW_STATE_FULLSCREEN))
	{
		gboolean show;

		show = !(event->new_window_state &
			(GDK_WINDOW_STATE_MAXIMIZED | GDK_WINDOW_STATE_FULLSCREEN));
	}

	return FALSE;
}

static gboolean 
pluma_window_configure_event (GtkWidget         *widget,
			      GdkEventConfigure *event)
{
	PlumaWindow *window = PLUMA_WINDOW (widget);

	window->priv->width = event->width;
	window->priv->height = event->height;

	return GTK_WIDGET_CLASS (pluma_window_parent_class)->configure_event (widget, event);
}

/*
 * GtkWindow catches keybindings for the menu items _before_ passing them to
 * the focused widget. This is unfortunate and means that pressing ctrl+V
 * in an entry on a panel ends up pasting text in the TextView.
 * Here we override GtkWindow's handler to do the same things that it
 * does, but in the opposite order and then we chain up to the grand
 * parent handler, skipping gtk_window_key_press_event.
 */
static gboolean
pluma_window_key_press_event (GtkWidget   *widget,
			      GdkEventKey *event)
{
	static gpointer grand_parent_class = NULL;
	GtkWindow *window = GTK_WINDOW (widget);
	gboolean handled = FALSE;

	if (grand_parent_class == NULL)
		grand_parent_class = g_type_class_peek_parent (pluma_window_parent_class);

	/* handle focus widget key events */
	if (!handled)
		handled = gtk_window_propagate_key_event (window, event);

	/* handle mnemonics and accelerators */
	if (!handled)
		handled = gtk_window_activate_key (window, event);

	/* Chain up, invokes binding set */
	if (!handled)
		handled = GTK_WIDGET_CLASS (grand_parent_class)->key_press_event (widget, event);

	return handled;
}

static void
pluma_window_tab_removed (PlumaWindow *window,
			  PlumaTab    *tab) 
{
	pluma_plugins_engine_garbage_collect (pluma_plugins_engine_get_default ());
}

static void
pluma_window_class_init (PlumaWindowClass *klass)
{
	GObjectClass *object_class = G_OBJECT_CLASS (klass);
	GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);

	klass->tab_removed = pluma_window_tab_removed;

	object_class->dispose = pluma_window_dispose;
	object_class->finalize = pluma_window_finalize;
	object_class->get_property = pluma_window_get_property;

	widget_class->window_state_event = pluma_window_window_state_event;
	widget_class->configure_event = pluma_window_configure_event;
	widget_class->key_press_event = pluma_window_key_press_event;

	signals[TAB_ADDED] =
		g_signal_new ("tab_added",
			      G_OBJECT_CLASS_TYPE (object_class),
			      G_SIGNAL_RUN_FIRST,
			      G_STRUCT_OFFSET (PlumaWindowClass, tab_added),
			      NULL, NULL,
			      g_cclosure_marshal_VOID__OBJECT,
			      G_TYPE_NONE,
			      1,
			      PLUMA_TYPE_TAB);
	signals[TAB_REMOVED] =
		g_signal_new ("tab_removed",
			      G_OBJECT_CLASS_TYPE (object_class),
			      G_SIGNAL_RUN_FIRST,
			      G_STRUCT_OFFSET (PlumaWindowClass, tab_removed),
			      NULL, NULL,
			      g_cclosure_marshal_VOID__OBJECT,
			      G_TYPE_NONE,
			      1,
			      PLUMA_TYPE_TAB);
	signals[TABS_REORDERED] =
		g_signal_new ("tabs_reordered",
			      G_OBJECT_CLASS_TYPE (object_class),
			      G_SIGNAL_RUN_FIRST,
			      G_STRUCT_OFFSET (PlumaWindowClass, tabs_reordered),
			      NULL, NULL,
			      g_cclosure_marshal_VOID__VOID,
			      G_TYPE_NONE,
			      0);
	signals[ACTIVE_TAB_CHANGED] =
		g_signal_new ("active_tab_changed",
			      G_OBJECT_CLASS_TYPE (object_class),
			      G_SIGNAL_RUN_FIRST,
			      G_STRUCT_OFFSET (PlumaWindowClass, active_tab_changed),
			      NULL, NULL,
			      g_cclosure_marshal_VOID__OBJECT,
			      G_TYPE_NONE,
			      1,
			      PLUMA_TYPE_TAB);
	signals[ACTIVE_TAB_STATE_CHANGED] =
		g_signal_new ("active_tab_state_changed",
			      G_OBJECT_CLASS_TYPE (object_class),
			      G_SIGNAL_RUN_FIRST,
			      G_STRUCT_OFFSET (PlumaWindowClass, active_tab_state_changed),
			      NULL, NULL,
			      g_cclosure_marshal_VOID__VOID,
			      G_TYPE_NONE,
			      0);			      			      

	g_object_class_install_property (object_class,
					 PROP_STATE,
					 g_param_spec_flags ("state",
							     "State",
							     "The window's state",
							     PLUMA_TYPE_WINDOW_STATE,
							     PLUMA_WINDOW_STATE_NORMAL,
							     G_PARAM_READABLE |
							     G_PARAM_STATIC_STRINGS));

	g_type_class_add_private (object_class, sizeof(PlumaWindowPrivate));
}

static void
menu_item_select_cb (GtkMenuItem *proxy,
		     PlumaWindow *window)
{
	GtkAction *action;
	char *message;

	action = gtk_activatable_get_related_action (GTK_ACTIVATABLE (proxy));
	g_return_if_fail (action != NULL);

	g_object_get (G_OBJECT (action), "tooltip", &message, NULL);
	if (message)
	{
		gtk_statusbar_push (GTK_STATUSBAR (window->priv->statusbar),
				    window->priv->tip_message_cid, message);
		g_free (message);
	}
}

static void
menu_item_deselect_cb (GtkMenuItem *proxy,
                       PlumaWindow *window)
{
	gtk_statusbar_pop (GTK_STATUSBAR (window->priv->statusbar),
			   window->priv->tip_message_cid);
}

static void
connect_proxy_cb (GtkUIManager *manager,
                  GtkAction *action,
                  GtkWidget *proxy,
                  PlumaWindow *window)
{
	if (GTK_IS_MENU_ITEM (proxy))
	{
		g_signal_connect (proxy, "select",
				  G_CALLBACK (menu_item_select_cb), window);
		g_signal_connect (proxy, "deselect",
				  G_CALLBACK (menu_item_deselect_cb), window);
	}
}

static void
disconnect_proxy_cb (GtkUIManager *manager,
                     GtkAction *action,
                     GtkWidget *proxy,
                     PlumaWindow *window)
{
	if (GTK_IS_MENU_ITEM (proxy))
	{
		g_signal_handlers_disconnect_by_func
			(proxy, G_CALLBACK (menu_item_select_cb), window);
		g_signal_handlers_disconnect_by_func
			(proxy, G_CALLBACK (menu_item_deselect_cb), window);
	}
}

static void
apply_toolbar_style (PlumaWindow *window,
		     GtkWidget *toolbar)
{
	switch (window->priv->toolbar_style)
	{
		case PLUMA_TOOLBAR_SYSTEM:
			pluma_debug_message (DEBUG_WINDOW, "PLUMA: SYSTEM");
			gtk_toolbar_unset_style (
					GTK_TOOLBAR (toolbar));
			break;

		case PLUMA_TOOLBAR_ICONS:
			pluma_debug_message (DEBUG_WINDOW, "PLUMA: ICONS");
			gtk_toolbar_set_style (
					GTK_TOOLBAR (toolbar),
					GTK_TOOLBAR_ICONS);
			break;

		case PLUMA_TOOLBAR_ICONS_AND_TEXT:
			pluma_debug_message (DEBUG_WINDOW, "PLUMA: ICONS_AND_TEXT");
			gtk_toolbar_set_style (
					GTK_TOOLBAR (toolbar),
					GTK_TOOLBAR_BOTH);
			break;

		case PLUMA_TOOLBAR_ICONS_BOTH_HORIZ:
			pluma_debug_message (DEBUG_WINDOW, "PLUMA: ICONS_BOTH_HORIZ");
			gtk_toolbar_set_style (
					GTK_TOOLBAR (toolbar),
					GTK_TOOLBAR_BOTH_HORIZ);
			break;
	}
}

/* Returns TRUE if toolbar is visible */
static gboolean
set_toolbar_style (PlumaWindow *window,
		   PlumaWindow *origin)
{
	gboolean visible;
	PlumaToolbarSetting style;
	GtkAction *action;
	
	if (origin == NULL)
		visible = pluma_prefs_manager_get_toolbar_visible ();
	else
		visible = gtk_widget_get_visible (origin->priv->toolbar);
	
	/* Set visibility */
	if (visible)
		gtk_widget_show (window->priv->toolbar);
	else
		gtk_widget_hide (window->priv->toolbar);

	action = gtk_action_group_get_action (window->priv->always_sensitive_action_group,
					      "ViewToolbar");

	if (gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action)) != visible)
		gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action), visible);

	/* Set style */
	if (origin == NULL)
		style = pluma_prefs_manager_get_toolbar_buttons_style ();
	else
		style = origin->priv->toolbar_style;
	
	window->priv->toolbar_style = style;
	
	apply_toolbar_style (window, window->priv->toolbar);
	
	return visible;
}

static void
update_next_prev_doc_sensitivity (PlumaWindow *window,
				  PlumaTab    *tab)
{
	gint	     tab_number;
	GtkNotebook *notebook;
	GtkAction   *action;
	
	pluma_debug (DEBUG_WINDOW);
	
	notebook = GTK_NOTEBOOK (_pluma_window_get_notebook (window));
	
	tab_number = gtk_notebook_page_num (notebook, GTK_WIDGET (tab));
	g_return_if_fail (tab_number >= 0);
	
	action = gtk_action_group_get_action (window->priv->action_group,
					      "DocumentsPreviousDocument");
	gtk_action_set_sensitive (action, tab_number != 0);
	
	action = gtk_action_group_get_action (window->priv->action_group,
					      "DocumentsNextDocument");
	gtk_action_set_sensitive (action, 
				  tab_number < gtk_notebook_get_n_pages (notebook) - 1);
}

static void
update_next_prev_doc_sensitivity_per_window (PlumaWindow *window)
{
	PlumaTab  *tab;
	GtkAction *action;
	
	pluma_debug (DEBUG_WINDOW);
	
	tab = pluma_window_get_active_tab (window);
	if (tab != NULL)
	{
		update_next_prev_doc_sensitivity (window, tab);
		
		return;
	}
	
	action = gtk_action_group_get_action (window->priv->action_group,
					      "DocumentsPreviousDocument");
	gtk_action_set_sensitive (action, FALSE);
	
	action = gtk_action_group_get_action (window->priv->action_group,
					      "DocumentsNextDocument");
	gtk_action_set_sensitive (action, FALSE);
	
}

static void
received_clipboard_contents (GtkClipboard     *clipboard,
			     GtkSelectionData *selection_data,
			     PlumaWindow      *window)
{
	gboolean sens;
	GtkAction *action;

	/* getting clipboard contents is async, so we need to
	 * get the current tab and its state */

	if (window->priv->active_tab != NULL)
	{
		PlumaTabState state;
		gboolean state_normal;

		state = pluma_tab_get_state (window->priv->active_tab);
		state_normal = (state == PLUMA_TAB_STATE_NORMAL);

		sens = state_normal &&
		       gtk_selection_data_targets_include_text (selection_data);
	}
	else
	{
		sens = FALSE;
	}

	action = gtk_action_group_get_action (window->priv->action_group,
					      "EditPaste");

	gtk_action_set_sensitive (action, sens);

	g_object_unref (window);
}

static void
set_paste_sensitivity_according_to_clipboard (PlumaWindow  *window,
					      GtkClipboard *clipboard)
{
	GdkDisplay *display;

	display = gtk_clipboard_get_display (clipboard);

	if (gdk_display_supports_selection_notification (display))
	{
		gtk_clipboard_request_contents (clipboard,
						gdk_atom_intern_static_string ("TARGETS"),
						(GtkClipboardReceivedFunc) received_clipboard_contents,
						g_object_ref (window));
	}
	else
	{
		GtkAction *action;

		action = gtk_action_group_get_action (window->priv->action_group,
						      "EditPaste");

		/* XFIXES extension not availbale, make
		 * Paste always sensitive */
		gtk_action_set_sensitive (action, TRUE);
	}
}

static void
set_sensitivity_according_to_tab (PlumaWindow *window,
				  PlumaTab    *tab)
{
	PlumaDocument *doc;
	PlumaView     *view;
	GtkAction     *action;
	gboolean       b;
	gboolean       state_normal;
	gboolean       editable;
	PlumaTabState  state;
	GtkClipboard  *clipboard;
	PlumaLockdownMask lockdown;

	g_return_if_fail (PLUMA_TAB (tab));

	pluma_debug (DEBUG_WINDOW);

	lockdown = pluma_app_get_lockdown (pluma_app_get_default ());

	state = pluma_tab_get_state (tab);
	state_normal = (state == PLUMA_TAB_STATE_NORMAL);

	view = pluma_tab_get_view (tab);
	editable = gtk_text_view_get_editable (GTK_TEXT_VIEW (view));

	doc = PLUMA_DOCUMENT (gtk_text_view_get_buffer (GTK_TEXT_VIEW (view)));

	clipboard = gtk_widget_get_clipboard (GTK_WIDGET (window),
					      GDK_SELECTION_CLIPBOARD);

	action = gtk_action_group_get_action (window->priv->action_group,
					      "FileSave");
	gtk_action_set_sensitive (action,
				  (state_normal ||
				   (state == PLUMA_TAB_STATE_EXTERNALLY_MODIFIED_NOTIFICATION) ||
				   (state == PLUMA_TAB_STATE_SHOWING_PRINT_PREVIEW)) &&
				  !pluma_document_get_readonly (doc) &&
				  !(lockdown & PLUMA_LOCKDOWN_SAVE_TO_DISK));

	action = gtk_action_group_get_action (window->priv->action_group,
					      "FileSaveAs");
	gtk_action_set_sensitive (action,
				  (state_normal ||
				   (state == PLUMA_TAB_STATE_SAVING_ERROR) ||
				   (state == PLUMA_TAB_STATE_EXTERNALLY_MODIFIED_NOTIFICATION) ||
				   (state == PLUMA_TAB_STATE_SHOWING_PRINT_PREVIEW)) &&
				  !(lockdown & PLUMA_LOCKDOWN_SAVE_TO_DISK));

	action = gtk_action_group_get_action (window->priv->action_group,
					      "FileRevert");
	gtk_action_set_sensitive (action,
				  (state_normal ||
				   (state == PLUMA_TAB_STATE_EXTERNALLY_MODIFIED_NOTIFICATION)) &&
				  !pluma_document_is_untitled (doc));

	action = gtk_action_group_get_action (window->priv->action_group,
					      "FilePrintPreview");
	gtk_action_set_sensitive (action,
				  state_normal &&
				  !(lockdown & PLUMA_LOCKDOWN_PRINTING));

	action = gtk_action_group_get_action (window->priv->action_group,
					      "FilePrint");
	gtk_action_set_sensitive (action,
				  (state_normal ||
				  (state == PLUMA_TAB_STATE_SHOWING_PRINT_PREVIEW)) &&
				  !(lockdown & PLUMA_LOCKDOWN_PRINTING));
				  
	action = gtk_action_group_get_action (window->priv->close_action_group,
					      "FileClose");

	gtk_action_set_sensitive (action,
				  (state != PLUMA_TAB_STATE_CLOSING) &&
				  (state != PLUMA_TAB_STATE_SAVING) &&
				  (state != PLUMA_TAB_STATE_SHOWING_PRINT_PREVIEW) &&
				  (state != PLUMA_TAB_STATE_PRINTING) &&
				  (state != PLUMA_TAB_STATE_PRINT_PREVIEWING) &&
				  (state != PLUMA_TAB_STATE_SAVING_ERROR));

	action = gtk_action_group_get_action (window->priv->action_group,
					      "EditUndo");
	gtk_action_set_sensitive (action, 
				  state_normal &&
				  gtk_source_buffer_can_undo (GTK_SOURCE_BUFFER (doc)));

	action = gtk_action_group_get_action (window->priv->action_group,
					      "EditRedo");
	gtk_action_set_sensitive (action, 
				  state_normal &&
				  gtk_source_buffer_can_redo (GTK_SOURCE_BUFFER (doc)));

	action = gtk_action_group_get_action (window->priv->action_group,
					      "EditCut");
	gtk_action_set_sensitive (action,
				  state_normal &&
				  editable &&
				  gtk_text_buffer_get_has_selection (GTK_TEXT_BUFFER (doc)));

	action = gtk_action_group_get_action (window->priv->action_group,
					      "EditCopy");
	gtk_action_set_sensitive (action,
				  (state_normal ||
				   state == PLUMA_TAB_STATE_EXTERNALLY_MODIFIED_NOTIFICATION) &&
				  gtk_text_buffer_get_has_selection (GTK_TEXT_BUFFER (doc)));
				  
	action = gtk_action_group_get_action (window->priv->action_group,
					      "EditPaste");
	if (state_normal && editable)
	{
		set_paste_sensitivity_according_to_clipboard (window,
							      clipboard);
	}
	else
	{
		gtk_action_set_sensitive (action, FALSE);
	}

	action = gtk_action_group_get_action (window->priv->action_group,
					      "EditDelete");
	gtk_action_set_sensitive (action,
				  state_normal &&
				  editable &&
				  gtk_text_buffer_get_has_selection (GTK_TEXT_BUFFER (doc)));

	action = gtk_action_group_get_action (window->priv->action_group,
					      "SearchFind");
	gtk_action_set_sensitive (action,
				  (state_normal ||
				   state == PLUMA_TAB_STATE_EXTERNALLY_MODIFIED_NOTIFICATION));

	action = gtk_action_group_get_action (window->priv->action_group,
					      "SearchIncrementalSearch");
	gtk_action_set_sensitive (action,
				  (state_normal ||
				   state == PLUMA_TAB_STATE_EXTERNALLY_MODIFIED_NOTIFICATION));

	action = gtk_action_group_get_action (window->priv->action_group,
					      "SearchReplace");
	gtk_action_set_sensitive (action,
				  state_normal &&
				  editable);

	b = pluma_document_get_can_search_again (doc);
	action = gtk_action_group_get_action (window->priv->action_group,
					      "SearchFindNext");
	gtk_action_set_sensitive (action,
				  (state_normal ||
				   state == PLUMA_TAB_STATE_EXTERNALLY_MODIFIED_NOTIFICATION) && b);

	action = gtk_action_group_get_action (window->priv->action_group,
					      "SearchFindPrevious");
	gtk_action_set_sensitive (action,
				  (state_normal ||
				   state == PLUMA_TAB_STATE_EXTERNALLY_MODIFIED_NOTIFICATION) && b);

	action = gtk_action_group_get_action (window->priv->action_group,
					      "SearchClearHighlight");
	gtk_action_set_sensitive (action,
				  (state_normal ||
				   state == PLUMA_TAB_STATE_EXTERNALLY_MODIFIED_NOTIFICATION) && b);

	action = gtk_action_group_get_action (window->priv->action_group,
					      "SearchGoToLine");
	gtk_action_set_sensitive (action,
				  (state_normal ||
				   state == PLUMA_TAB_STATE_EXTERNALLY_MODIFIED_NOTIFICATION));
	
	action = gtk_action_group_get_action (window->priv->action_group,
					      "ViewHighlightMode");
	gtk_action_set_sensitive (action, 
				  (state != PLUMA_TAB_STATE_CLOSING) &&
				  pluma_prefs_manager_get_enable_syntax_highlighting ());

	update_next_prev_doc_sensitivity (window, tab);

	pluma_plugins_engine_update_plugins_ui (pluma_plugins_engine_get_default (),
						 window);
}

static void
language_toggled (GtkToggleAction *action,
		  PlumaWindow     *window)
{
	PlumaDocument *doc;
	GtkSourceLanguage *lang;
	const gchar *lang_id;

	if (gtk_toggle_action_get_active (action) == FALSE)
		return;

	doc = pluma_window_get_active_document (window);
	if (doc == NULL)
		return;

	lang_id = gtk_action_get_name (GTK_ACTION (action));
	
	if (strcmp (lang_id, LANGUAGE_NONE) == 0)
	{
		/* Normal (no highlighting) */
		lang = NULL;
	}
	else
	{
		lang = gtk_source_language_manager_get_language (
				pluma_get_language_manager (),
				lang_id);
		if (lang == NULL)
		{
			g_warning ("Could not get language %s\n", lang_id);
		}
	}

	pluma_document_set_language (doc, lang);
}

static gchar *
escape_section_name (const gchar *name)
{
	gchar *ret;

	ret = g_markup_escape_text (name, -1);

	/* Replace '/' with '-' to avoid problems in xml paths */
	g_strdelimit (ret, "/", '-');

	return ret;
}

static void
create_language_menu_item (GtkSourceLanguage *lang,
			   gint               index,
			   guint              ui_id,
			   PlumaWindow       *window)
{
	GtkAction *section_action;
	GtkRadioAction *action;
	GtkAction *normal_action;
	GSList *group;
	const gchar *section;
	gchar *escaped_section;
	const gchar *lang_id;
	const gchar *lang_name;
	gchar *escaped_lang_name;
	gchar *tip;
	gchar *path;

	section = gtk_source_language_get_section (lang);
	escaped_section = escape_section_name (section);

	/* check if the section submenu exists or create it */
	section_action = gtk_action_group_get_action (window->priv->languages_action_group,
						      escaped_section);

	if (section_action == NULL)
	{
		gchar *section_name;
		
		section_name = pluma_utils_escape_underscores (section, -1);
		
		section_action = gtk_action_new (escaped_section,
						 section_name,
						 NULL,
						 NULL);
						 
		g_free (section_name);

		gtk_action_group_add_action (window->priv->languages_action_group,
					     section_action);
		g_object_unref (section_action);

		gtk_ui_manager_add_ui (window->priv->manager,
				       ui_id,
				       "/MenuBar/ViewMenu/ViewHighlightModeMenu/LanguagesMenuPlaceholder",
				       escaped_section,
				       escaped_section,
				       GTK_UI_MANAGER_MENU,
				       FALSE);
	}

	/* now add the language item to the section */
	lang_name = gtk_source_language_get_name (lang);
	lang_id = gtk_source_language_get_id (lang);
	
	escaped_lang_name = pluma_utils_escape_underscores (lang_name, -1);
	
	tip = g_strdup_printf (_("Use %s highlight mode"), lang_name);
	path = g_strdup_printf ("/MenuBar/ViewMenu/ViewHighlightModeMenu/LanguagesMenuPlaceholder/%s",
				escaped_section);

	action = gtk_radio_action_new (lang_id,
				       escaped_lang_name,
				       tip,
				       NULL,
				       index);

	g_free (escaped_lang_name);

	/* Action is added with a NULL accel to make the accel overridable */
	gtk_action_group_add_action_with_accel (window->priv->languages_action_group,
						GTK_ACTION (action),
						NULL);
	g_object_unref (action);

	/* add the action to the same radio group of the "Normal" action */
	normal_action = gtk_action_group_get_action (window->priv->languages_action_group,
						     LANGUAGE_NONE);
	group = gtk_radio_action_get_group (GTK_RADIO_ACTION (normal_action));
	gtk_radio_action_set_group (action, group);

	g_signal_connect (action,
			  "activate",
			  G_CALLBACK (language_toggled),
			  window);

	gtk_ui_manager_add_ui (window->priv->manager,
			       ui_id,
			       path,
			       lang_id, 
			       lang_id,
			       GTK_UI_MANAGER_MENUITEM,
			       FALSE);

	g_free (path);
	g_free (tip);
	g_free (escaped_section);
}

static void
create_languages_menu (PlumaWindow *window)
{
	GtkRadioAction *action_none;
	GSList *languages;
	GSList *l;
	guint id;
	gint i;

	pluma_debug (DEBUG_WINDOW);

	/* add the "Plain Text" item before all the others */
	
	/* Translators: "Plain Text" means that no highlight mode is selected in the 
	 * "View->Highlight Mode" submenu and so syntax highlighting is disabled */
	action_none = gtk_radio_action_new (LANGUAGE_NONE, _("Plain Text"),
					    _("Disable syntax highlighting"),
					    NULL,
					    -1);

	gtk_action_group_add_action (window->priv->languages_action_group,
				     GTK_ACTION (action_none));
	g_object_unref (action_none);

	g_signal_connect (action_none,
			  "activate",
			  G_CALLBACK (language_toggled),
			  window);

	id = gtk_ui_manager_new_merge_id (window->priv->manager);

	gtk_ui_manager_add_ui (window->priv->manager,
			       id,
			       "/MenuBar/ViewMenu/ViewHighlightModeMenu/LanguagesMenuPlaceholder",
			       LANGUAGE_NONE, 
			       LANGUAGE_NONE,
			       GTK_UI_MANAGER_MENUITEM,
			       TRUE);

	gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action_none), TRUE);

	/* now add all the known languages */
	languages = pluma_language_manager_list_languages_sorted (
						pluma_get_language_manager (),
						FALSE);

	for (l = languages, i = 0; l != NULL; l = l->next, ++i)
	{
		create_language_menu_item (l->data,
					   i,
					   id,
					   window);
	}

	g_slist_free (languages);
}

static void
update_languages_menu (PlumaWindow *window)
{
	PlumaDocument *doc;
	GList *actions;
	GList *l;
	GtkAction *action;
	GtkSourceLanguage *lang;
	const gchar *lang_id;

	doc = pluma_window_get_active_document (window);
	if (doc == NULL)
		return;

	lang = pluma_document_get_language (doc);
	if (lang != NULL)
		lang_id = gtk_source_language_get_id (lang);
	else
		lang_id = LANGUAGE_NONE;

	actions = gtk_action_group_list_actions (window->priv->languages_action_group);

	/* prevent recursion */
	for (l = actions; l != NULL; l = l->next)
	{
		g_signal_handlers_block_by_func (GTK_ACTION (l->data),
						 G_CALLBACK (language_toggled),
						 window);
	}

	action = gtk_action_group_get_action (window->priv->languages_action_group,
					      lang_id);

	gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action), TRUE);

	for (l = actions; l != NULL; l = l->next)
	{
		g_signal_handlers_unblock_by_func (GTK_ACTION (l->data),
						   G_CALLBACK (language_toggled),
						   window);
	}

	g_list_free (actions);
}

void
_pluma_recent_add (PlumaWindow *window,
		   const gchar *uri,
		   const gchar *mime)
{
	GtkRecentManager *recent_manager;
	GtkRecentData *recent_data;

	static gchar *groups[2] = {
		"pluma",
		NULL
	};

	recent_manager =  gtk_recent_manager_get_default ();

	recent_data = g_slice_new (GtkRecentData);

	recent_data->display_name = NULL;
	recent_data->description = NULL;
	recent_data->mime_type = (gchar *) mime;
	recent_data->app_name = (gchar *) g_get_application_name ();
	recent_data->app_exec = g_strjoin (" ", g_get_prgname (), "%u", NULL);
	recent_data->groups = groups;
	recent_data->is_private = FALSE;

	gtk_recent_manager_add_full (recent_manager,
				     uri,
				     recent_data);

	g_free (recent_data->app_exec);

	g_slice_free (GtkRecentData, recent_data);
}

void
_pluma_recent_remove (PlumaWindow *window,
		      const gchar *uri)
{
	GtkRecentManager *recent_manager;

	recent_manager =  gtk_recent_manager_get_default ();

	gtk_recent_manager_remove_item (recent_manager, uri, NULL);
}

static void
open_recent_file (const gchar *uri,
		  PlumaWindow *window)
{
	GSList *uris = NULL;

	uris = g_slist_prepend (uris, (gpointer) uri);

	if (pluma_commands_load_uris (window, uris, NULL, 0) != 1)
	{
		_pluma_recent_remove (window, uri);
	}

	g_slist_free (uris);
}

static void
recent_chooser_item_activated (GtkRecentChooser *chooser,
			       PlumaWindow      *window)
{
	gchar *uri;

	uri = gtk_recent_chooser_get_current_uri (chooser);

	open_recent_file (uri, window);

	g_free (uri);
}

static void
recents_menu_activate (GtkAction   *action,
		       PlumaWindow *window)
{
	GtkRecentInfo *info;
	const gchar *uri;

	info = g_object_get_data (G_OBJECT (action), "gtk-recent-info");
	g_return_if_fail (info != NULL);

	uri = gtk_recent_info_get_uri (info);

	open_recent_file (uri, window);
}

static gint
sort_recents_mru (GtkRecentInfo *a, GtkRecentInfo *b)
{
	return (gtk_recent_info_get_modified (b) - gtk_recent_info_get_modified (a));
}

static void	update_recent_files_menu (PlumaWindow *window);

static void
recent_manager_changed (GtkRecentManager *manager,
			PlumaWindow      *window)
{
	/* regenerate the menu when the model changes */
	update_recent_files_menu (window);
}

/*
 * Manually construct the inline recents list in the File menu.
 * Hopefully gtk 2.12 will add support for it.
 */
static void
update_recent_files_menu (PlumaWindow *window)
{
	PlumaWindowPrivate *p = window->priv;
	GtkRecentManager *recent_manager;
	gint max_recents;
	GList *actions, *l, *items;
	GList *filtered_items = NULL;
	gint i;

	pluma_debug (DEBUG_WINDOW);

	max_recents = pluma_prefs_manager_get_max_recents ();

	g_return_if_fail (p->recents_action_group != NULL);

	if (p->recents_menu_ui_id != 0)
		gtk_ui_manager_remove_ui (p->manager,
					  p->recents_menu_ui_id);

	actions = gtk_action_group_list_actions (p->recents_action_group);
	for (l = actions; l != NULL; l = l->next)
	{
		g_signal_handlers_disconnect_by_func (GTK_ACTION (l->data),
						      G_CALLBACK (recents_menu_activate),
						      window);
 		gtk_action_group_remove_action (p->recents_action_group,
						GTK_ACTION (l->data));
	}
	g_list_free (actions);

	p->recents_menu_ui_id = gtk_ui_manager_new_merge_id (p->manager);

	recent_manager =  gtk_recent_manager_get_default ();
	items = gtk_recent_manager_get_items (recent_manager);

	/* filter */
	for (l = items; l != NULL; l = l->next)
	{
		GtkRecentInfo *info = l->data;

		if (!gtk_recent_info_has_group (info, "pluma"))
			continue;

		filtered_items = g_list_prepend (filtered_items, info);
	}

	/* sort */
	filtered_items = g_list_sort (filtered_items,
				      (GCompareFunc) sort_recents_mru);

	i = 0;
	for (l = filtered_items; l != NULL; l = l->next)
	{
		gchar *action_name;
		const gchar *display_name;
		gchar *escaped;
		gchar *label;
		gchar *uri;
		gchar *ruri;
		gchar *tip;
		GtkAction *action;
		GtkRecentInfo *info = l->data;

		/* clamp */
		if (i >= max_recents)
			break;

		i++;

		action_name = g_strdup_printf ("recent-info-%d", i);

		display_name = gtk_recent_info_get_display_name (info);
		escaped = pluma_utils_escape_underscores (display_name, -1);
		if (i >= 10)
			label = g_strdup_printf ("%d.  %s",
						 i, 
						 escaped);
		else
			label = g_strdup_printf ("_%d.  %s",
						 i, 
						 escaped);
		g_free (escaped);

		/* gtk_recent_info_get_uri_display (info) is buggy and
		 * works only for local files */
		uri = pluma_utils_uri_for_display (gtk_recent_info_get_uri (info));
		ruri = pluma_utils_replace_home_dir_with_tilde (uri);
		g_free (uri);

		/* Translators: %s is a URI */
		tip = g_strdup_printf (_("Open '%s'"), ruri);
		g_free (ruri);

		action = gtk_action_new (action_name,
					 label,
					 tip,
					 NULL);

		g_object_set_data_full (G_OBJECT (action),
					"gtk-recent-info",
					gtk_recent_info_ref (info),
					(GDestroyNotify) gtk_recent_info_unref);

		g_signal_connect (action,
				  "activate",
				  G_CALLBACK (recents_menu_activate),
				  window);

		gtk_action_group_add_action (p->recents_action_group,
					     action);
		g_object_unref (action);

		gtk_ui_manager_add_ui (p->manager,
				       p->recents_menu_ui_id,
				       "/MenuBar/FileMenu/FileRecentsPlaceholder",
				       action_name,
				       action_name,
				       GTK_UI_MANAGER_MENUITEM,
				       FALSE);

		g_free (action_name);
		g_free (label);
		g_free (tip);
	}

	g_list_free (filtered_items);

	g_list_foreach (items, (GFunc) gtk_recent_info_unref, NULL);
	g_list_free (items);
}

static void
set_non_homogeneus (GtkWidget *widget, gpointer data)
{
	gtk_tool_item_set_homogeneous (GTK_TOOL_ITEM (widget), FALSE);
}

static void
toolbar_visibility_changed (GtkWidget   *toolbar,
			    PlumaWindow *window)
{
	gboolean visible;
	GtkAction *action;

	visible = gtk_widget_get_visible (toolbar);

	if (pluma_prefs_manager_toolbar_visible_can_set ())
		pluma_prefs_manager_set_toolbar_visible (visible);

	action = gtk_action_group_get_action (window->priv->always_sensitive_action_group,
					      "ViewToolbar");

	if (gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action)) != visible)
		gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action), visible);
}

static GtkWidget *
setup_toolbar_open_button (PlumaWindow *window,
			   GtkWidget *toolbar)
{
	GtkRecentManager *recent_manager;
	GtkRecentFilter *filter;
	GtkWidget *toolbar_recent_menu;
	GtkToolItem *open_button;
	GtkAction *action;

	recent_manager = gtk_recent_manager_get_default ();

	/* recent files menu tool button */
	toolbar_recent_menu = gtk_recent_chooser_menu_new_for_manager (recent_manager);

	gtk_recent_chooser_set_local_only (GTK_RECENT_CHOOSER (toolbar_recent_menu),
					   FALSE);
	gtk_recent_chooser_set_sort_type (GTK_RECENT_CHOOSER (toolbar_recent_menu),
					  GTK_RECENT_SORT_MRU);
	gtk_recent_chooser_set_limit (GTK_RECENT_CHOOSER (toolbar_recent_menu),
				      pluma_prefs_manager_get_max_recents ());

	filter = gtk_recent_filter_new ();
	gtk_recent_filter_add_group (filter, "pluma");
	gtk_recent_chooser_set_filter (GTK_RECENT_CHOOSER (toolbar_recent_menu),
				       filter);

	g_signal_connect (toolbar_recent_menu,
			  "item_activated",
			  G_CALLBACK (recent_chooser_item_activated),
			  window);
	
	/* add the custom Open button to the toolbar */
	open_button = gtk_menu_tool_button_new_from_stock (GTK_STOCK_OPEN);
	gtk_menu_tool_button_set_menu (GTK_MENU_TOOL_BUTTON (open_button),
				       toolbar_recent_menu);

	gtk_tool_item_set_tooltip_text (open_button, _("Open a file"));
	gtk_menu_tool_button_set_arrow_tooltip_text (GTK_MENU_TOOL_BUTTON (open_button),
						     _("Open a recently used file"));

	action = gtk_action_group_get_action (window->priv->always_sensitive_action_group,
					      "FileOpen");
	g_object_set (action,
		      "is_important", TRUE,
		      "short_label", _("Open"),
		      NULL);
	gtk_activatable_set_related_action (GTK_ACTIVATABLE (open_button),
					    action);

	gtk_toolbar_insert (GTK_TOOLBAR (toolbar),
			    open_button,
			    1);
	
	return toolbar_recent_menu;
}

static void
create_menu_bar_and_toolbar (PlumaWindow *window, 
			     GtkWidget   *main_box)
{
	GtkActionGroup *action_group;
	GtkAction *action;
	GtkUIManager *manager;
	GtkRecentManager *recent_manager;
	GError *error = NULL;
	gchar *ui_file;

	pluma_debug (DEBUG_WINDOW);

	manager = gtk_ui_manager_new ();
	window->priv->manager = manager;

	gtk_window_add_accel_group (GTK_WINDOW (window),
				    gtk_ui_manager_get_accel_group (manager));

	action_group = gtk_action_group_new ("PlumaWindowAlwaysSensitiveActions");
	gtk_action_group_set_translation_domain (action_group, NULL);
	gtk_action_group_add_actions (action_group,
				      pluma_always_sensitive_menu_entries,
				      G_N_ELEMENTS (pluma_always_sensitive_menu_entries),
				      window);
	gtk_action_group_add_toggle_actions (action_group,
					     pluma_always_sensitive_toggle_menu_entries,
					     G_N_ELEMENTS (pluma_always_sensitive_toggle_menu_entries),
					     window);

	gtk_ui_manager_insert_action_group (manager, action_group, 0);
	g_object_unref (action_group);
	window->priv->always_sensitive_action_group = action_group;

	action_group = gtk_action_group_new ("PlumaWindowActions");
	gtk_action_group_set_translation_domain (action_group, NULL);
	gtk_action_group_add_actions (action_group,
				      pluma_menu_entries,
				      G_N_ELEMENTS (pluma_menu_entries),
				      window);
	gtk_ui_manager_insert_action_group (manager, action_group, 0);
	g_object_unref (action_group);
	window->priv->action_group = action_group;

	/* set short labels to use in the toolbar */
	action = gtk_action_group_get_action (action_group, "FileSave");
	g_object_set (action, "short_label", _("Save"), NULL);
	action = gtk_action_group_get_action (action_group, "FilePrint");
	g_object_set (action, "short_label", _("Print"), NULL);
	action = gtk_action_group_get_action (action_group, "SearchFind");
	g_object_set (action, "short_label", _("Find"), NULL);
	action = gtk_action_group_get_action (action_group, "SearchReplace");
	g_object_set (action, "short_label", _("Replace"), NULL);

	/* set which actions should have priority on the toolbar */
	action = gtk_action_group_get_action (action_group, "FileSave");
	g_object_set (action, "is_important", TRUE, NULL);
	action = gtk_action_group_get_action (action_group, "EditUndo");
	g_object_set (action, "is_important", TRUE, NULL);

	action_group = gtk_action_group_new ("PlumaQuitWindowActions");
	gtk_action_group_set_translation_domain (action_group, NULL);
	gtk_action_group_add_actions (action_group,
				      pluma_quit_menu_entries,
				      G_N_ELEMENTS (pluma_quit_menu_entries),
				      window);

	gtk_ui_manager_insert_action_group (manager, action_group, 0);
	g_object_unref (action_group);
	window->priv->quit_action_group = action_group;

	action_group = gtk_action_group_new ("PlumaCloseWindowActions");
	gtk_action_group_set_translation_domain (action_group, NULL);
	gtk_action_group_add_actions (action_group,
	                              pluma_close_menu_entries,
	                              G_N_ELEMENTS (pluma_close_menu_entries),
	                              window);

	gtk_ui_manager_insert_action_group (manager, action_group, 0);
	g_object_unref (action_group);
	window->priv->close_action_group = action_group;

	action_group = gtk_action_group_new ("PlumaWindowPanesActions");
	gtk_action_group_set_translation_domain (action_group, NULL);
	gtk_action_group_add_toggle_actions (action_group,
					     pluma_panes_toggle_menu_entries,
					     G_N_ELEMENTS (pluma_panes_toggle_menu_entries),
					     window);

	gtk_ui_manager_insert_action_group (manager, action_group, 0);
	g_object_unref (action_group);
	window->priv->panes_action_group = action_group;

	/* now load the UI definition */
	ui_file = pluma_dirs_get_ui_file (PLUMA_UIFILE);
	gtk_ui_manager_add_ui_from_file (manager, ui_file, &error);
	if (error != NULL)
	{
		g_warning ("Could not merge %s: %s", ui_file, error->message);
		g_error_free (error);
	}
	g_free (ui_file);

	/* show tooltips in the statusbar */
	g_signal_connect (manager,
			  "connect_proxy",
			  G_CALLBACK (connect_proxy_cb),
			  window);
	g_signal_connect (manager,
			  "disconnect_proxy",
			  G_CALLBACK (disconnect_proxy_cb),
			  window);

	/* recent files menu */
	action_group = gtk_action_group_new ("RecentFilesActions");
	gtk_action_group_set_translation_domain (action_group, NULL);
	window->priv->recents_action_group = action_group;
	gtk_ui_manager_insert_action_group (manager, action_group, 0);
	g_object_unref (action_group);

	recent_manager = gtk_recent_manager_get_default ();
	window->priv->recents_handler_id = g_signal_connect (recent_manager,
							     "changed",
							     G_CALLBACK (recent_manager_changed),
							     window);
	update_recent_files_menu (window);

	/* languages menu */
	action_group = gtk_action_group_new ("LanguagesActions");
	gtk_action_group_set_translation_domain (action_group, NULL);
	window->priv->languages_action_group = action_group;
	gtk_ui_manager_insert_action_group (manager, action_group, 0);
	g_object_unref (action_group);
	create_languages_menu (window);

	/* list of open documents menu */
	action_group = gtk_action_group_new ("DocumentsListActions");
	gtk_action_group_set_translation_domain (action_group, NULL);
	window->priv->documents_list_action_group = action_group;
	gtk_ui_manager_insert_action_group (manager, action_group, 0);
	g_object_unref (action_group);

	window->priv->menubar = gtk_ui_manager_get_widget (manager, "/MenuBar");
	gtk_box_pack_start (GTK_BOX (main_box), 
			    window->priv->menubar,
			    FALSE, 
			    FALSE, 
			    0);

	window->priv->toolbar = gtk_ui_manager_get_widget (manager, "/ToolBar");
#if GTK_CHECK_VERSION(3, 0, 0)
	gtk_style_context_add_class (gtk_widget_get_style_context (window->priv->toolbar),
		GTK_STYLE_CLASS_PRIMARY_TOOLBAR);
#endif
	gtk_box_pack_start (GTK_BOX (main_box),
			    window->priv->toolbar,
			    FALSE,
			    FALSE,
			    0);

	set_toolbar_style (window, NULL);
	
	window->priv->toolbar_recent_menu = setup_toolbar_open_button (window,
								       window->priv->toolbar);

	gtk_container_foreach (GTK_CONTAINER (window->priv->toolbar),
			       (GtkCallback)set_non_homogeneus,
			       NULL);

	g_signal_connect_after (G_OBJECT (window->priv->toolbar),
				"show",
				G_CALLBACK (toolbar_visibility_changed),
				window);
	g_signal_connect_after (G_OBJECT (window->priv->toolbar),
				"hide",
				G_CALLBACK (toolbar_visibility_changed),
				window);
}

static void
documents_list_menu_activate (GtkToggleAction *action,
			      PlumaWindow     *window)
{
	gint n;

	if (gtk_toggle_action_get_active (action) == FALSE)
		return;

	n = gtk_radio_action_get_current_value (GTK_RADIO_ACTION (action));
	gtk_notebook_set_current_page (GTK_NOTEBOOK (window->priv->notebook), n);
}

static gchar *
get_menu_tip_for_tab (PlumaTab *tab)
{
	PlumaDocument *doc;
	gchar *uri;
	gchar *ruri;
	gchar *tip;

	doc = pluma_tab_get_document (tab);

	uri = pluma_document_get_uri_for_display (doc);
	ruri = pluma_utils_replace_home_dir_with_tilde (uri);
	g_free (uri);

	/* Translators: %s is a URI */
	tip =  g_strdup_printf (_("Activate '%s'"), ruri);
	g_free (ruri);
	
	return tip;
}

static void
update_documents_list_menu (PlumaWindow *window)
{
	PlumaWindowPrivate *p = window->priv;
	GList *actions, *l;
	gint n, i;
	guint id;
	GSList *group = NULL;

	pluma_debug (DEBUG_WINDOW);

	g_return_if_fail (p->documents_list_action_group != NULL);

	if (p->documents_list_menu_ui_id != 0)
		gtk_ui_manager_remove_ui (p->manager,
					  p->documents_list_menu_ui_id);

	actions = gtk_action_group_list_actions (p->documents_list_action_group);
	for (l = actions; l != NULL; l = l->next)
	{
		g_signal_handlers_disconnect_by_func (GTK_ACTION (l->data),
						      G_CALLBACK (documents_list_menu_activate),
						      window);
 		gtk_action_group_remove_action (p->documents_list_action_group,
						GTK_ACTION (l->data));
	}
	g_list_free (actions);

	n = gtk_notebook_get_n_pages (GTK_NOTEBOOK (p->notebook));

	id = (n > 0) ? gtk_ui_manager_new_merge_id (p->manager) : 0;

	for (i = 0; i < n; i++)
	{
		GtkWidget *tab;
		GtkRadioAction *action;
		gchar *action_name;
		gchar *tab_name;
		gchar *name;
		gchar *tip;
		gchar *accel;

		tab = gtk_notebook_get_nth_page (GTK_NOTEBOOK (p->notebook), i);

		/* NOTE: the action is associated to the position of the tab in
		 * the notebook not to the tab itself! This is needed to work
		 * around the gtk+ bug #170727: gtk leaves around the accels
		 * of the action. Since the accel depends on the tab position
		 * the problem is worked around, action with the same name always
		 * get the same accel.
		 */
		action_name = g_strdup_printf ("Tab_%d", i);
		tab_name = _pluma_tab_get_name (PLUMA_TAB (tab));
		name = pluma_utils_escape_underscores (tab_name, -1);
		tip =  get_menu_tip_for_tab (PLUMA_TAB (tab));

		/* alt + 1, 2, 3... 0 to switch to the first ten tabs */
		accel = (i < 10) ? g_strdup_printf ("<alt>%d", (i + 1) % 10) : NULL;

		action = gtk_radio_action_new (action_name,
					       name,
					       tip,
					       NULL,
					       i);

		if (group != NULL)
			gtk_radio_action_set_group (action, group);

		/* note that group changes each time we add an action, so it must be updated */
		group = gtk_radio_action_get_group (action);

		gtk_action_group_add_action_with_accel (p->documents_list_action_group,
							GTK_ACTION (action),
							accel);

		g_signal_connect (action,
				  "activate",
				  G_CALLBACK (documents_list_menu_activate),
				  window);

		gtk_ui_manager_add_ui (p->manager,
				       id,
				       "/MenuBar/DocumentsMenu/DocumentsListPlaceholder",
				       action_name, action_name,
				       GTK_UI_MANAGER_MENUITEM,
				       FALSE);

		if (PLUMA_TAB (tab) == p->active_tab)
			gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action), TRUE);

		g_object_unref (action);

		g_free (action_name);
		g_free (tab_name);
		g_free (name);
		g_free (tip);
		g_free (accel);
	}

	p->documents_list_menu_ui_id = id;
}

/* Returns TRUE if status bar is visible */
static gboolean
set_statusbar_style (PlumaWindow *window,
		     PlumaWindow *origin)
{
	GtkAction *action;
	
	gboolean visible;

	if (origin == NULL)
		visible = pluma_prefs_manager_get_statusbar_visible ();
	else
		visible = gtk_widget_get_visible (origin->priv->statusbar);

	if (visible)
		gtk_widget_show (window->priv->statusbar);
	else
		gtk_widget_hide (window->priv->statusbar);

	action = gtk_action_group_get_action (window->priv->always_sensitive_action_group,
					      "ViewStatusbar");
					      
	if (gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action)) != visible)
		gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action), visible);
		
	return visible;
}

static void
statusbar_visibility_changed (GtkWidget   *statusbar,
			      PlumaWindow *window)
{
	gboolean visible;
	GtkAction *action;

	visible = gtk_widget_get_visible (statusbar);

	if (pluma_prefs_manager_statusbar_visible_can_set ())
		pluma_prefs_manager_set_statusbar_visible (visible);

	action = gtk_action_group_get_action (window->priv->always_sensitive_action_group,
					      "ViewStatusbar");

	if (gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action)) != visible)
		gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action), visible);
}

static void
tab_width_combo_changed (PlumaStatusComboBox *combo,
			 GtkMenuItem         *item,
			 PlumaWindow         *window)
{
	PlumaView *view;
	guint width_data = 0;
	
	view = pluma_window_get_active_view (window);
	
	if (!view)
		return;
	
	width_data = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (item), TAB_WIDTH_DATA));
	
	if (width_data == 0)
		return;
	
	g_signal_handler_block (view, window->priv->tab_width_id);
	gtk_source_view_set_tab_width (GTK_SOURCE_VIEW (view), width_data);
	g_signal_handler_unblock (view, window->priv->tab_width_id);
}

static void
use_spaces_toggled (GtkCheckMenuItem *item,
		    PlumaWindow      *window)
{
	PlumaView *view;
	
	view = pluma_window_get_active_view (window);
	
	g_signal_handler_block (view, window->priv->spaces_instead_of_tabs_id);
	gtk_source_view_set_insert_spaces_instead_of_tabs (
			GTK_SOURCE_VIEW (view),
			gtk_check_menu_item_get_active (item));
	g_signal_handler_unblock (view, window->priv->spaces_instead_of_tabs_id);
}

static void
language_combo_changed (PlumaStatusComboBox *combo,
			GtkMenuItem         *item,
			PlumaWindow         *window)
{
	PlumaDocument *doc;
	GtkSourceLanguage *language;
	
	doc = pluma_window_get_active_document (window);
	
	if (!doc)
		return;
	
	language = GTK_SOURCE_LANGUAGE (g_object_get_data (G_OBJECT (item), LANGUAGE_DATA));
	
	g_signal_handler_block (doc, window->priv->language_changed_id);
	pluma_document_set_language (doc, language);
	g_signal_handler_unblock (doc, window->priv->language_changed_id);
}

typedef struct
{
	const gchar *label;
	guint width;
} TabWidthDefinition;
	 
static void
fill_tab_width_combo (PlumaWindow *window)
{
	static TabWidthDefinition defs[] = {
		{"2", 2},
		{"4", 4},
		{"8", 8},
		{"", 0}, /* custom size */
		{NULL, 0}
	};
	
	PlumaStatusComboBox *combo = PLUMA_STATUS_COMBO_BOX (window->priv->tab_width_combo);
	guint i = 0;
	GtkWidget *item;
	
	while (defs[i].label != NULL)
	{
		item = gtk_menu_item_new_with_label (defs[i].label);
		g_object_set_data (G_OBJECT (item), TAB_WIDTH_DATA, GINT_TO_POINTER (defs[i].width));
		
		pluma_status_combo_box_add_item (combo,
						 GTK_MENU_ITEM (item),
						 defs[i].label);

		if (defs[i].width != 0)
			gtk_widget_show (item);

		++i;
	}
	
	item = gtk_separator_menu_item_new ();
	pluma_status_combo_box_add_item (combo, GTK_MENU_ITEM (item), NULL);
	gtk_widget_show (item);
	
	item = gtk_check_menu_item_new_with_label (_("Use Spaces"));
	pluma_status_combo_box_add_item (combo, GTK_MENU_ITEM (item), NULL);
	gtk_widget_show (item);
	
	g_signal_connect (item, 
			  "toggled", 
			  G_CALLBACK (use_spaces_toggled), 
			  window);
}

static void
fill_language_combo (PlumaWindow *window)
{
	GtkSourceLanguageManager *manager;
	GSList *languages;
	GSList *item;
	GtkWidget *menu_item;
	const gchar *name;
	
	manager = pluma_get_language_manager ();
	languages = pluma_language_manager_list_languages_sorted (manager, FALSE);

	name = _("Plain Text");
	menu_item = gtk_menu_item_new_with_label (name);
	gtk_widget_show (menu_item);
	
	g_object_set_data (G_OBJECT (menu_item), LANGUAGE_DATA, NULL);
	pluma_status_combo_box_add_item (PLUMA_STATUS_COMBO_BOX (window->priv->language_combo),
					 GTK_MENU_ITEM (menu_item),
					 name);

	for (item = languages; item; item = item->next)
	{
		GtkSourceLanguage *lang = GTK_SOURCE_LANGUAGE (item->data);
		
		name = gtk_source_language_get_name (lang);
		menu_item = gtk_menu_item_new_with_label (name);
		gtk_widget_show (menu_item);
		
		g_object_set_data_full (G_OBJECT (menu_item),
				        LANGUAGE_DATA,		
					g_object_ref (lang),
					(GDestroyNotify)g_object_unref);

		pluma_status_combo_box_add_item (PLUMA_STATUS_COMBO_BOX (window->priv->language_combo),
						 GTK_MENU_ITEM (menu_item),
						 name);
	}
	
	g_slist_free (languages);
}

static void
create_statusbar (PlumaWindow *window, 
		  GtkWidget   *main_box)
{
	pluma_debug (DEBUG_WINDOW);

	window->priv->statusbar = pluma_statusbar_new ();

	window->priv->generic_message_cid = gtk_statusbar_get_context_id
		(GTK_STATUSBAR (window->priv->statusbar), "generic_message");
	window->priv->tip_message_cid = gtk_statusbar_get_context_id
		(GTK_STATUSBAR (window->priv->statusbar), "tip_message");

	gtk_box_pack_end (GTK_BOX (main_box),
			  window->priv->statusbar,
			  FALSE, 
			  TRUE, 
			  0);

	window->priv->tab_width_combo = pluma_status_combo_box_new (_("Tab Width"));
	gtk_widget_show (window->priv->tab_width_combo);
	gtk_box_pack_end (GTK_BOX (window->priv->statusbar),
			  window->priv->tab_width_combo,
			  FALSE,
			  TRUE,
			  0);

	fill_tab_width_combo (window);

	g_signal_connect (G_OBJECT (window->priv->tab_width_combo),
			  "changed",
			  G_CALLBACK (tab_width_combo_changed),
			  window);
			  
	window->priv->language_combo = pluma_status_combo_box_new (NULL);
	gtk_widget_show (window->priv->language_combo);
	gtk_box_pack_end (GTK_BOX (window->priv->statusbar),
			  window->priv->language_combo,
			  FALSE,
			  TRUE,
			  0);

	fill_language_combo (window);

	g_signal_connect (G_OBJECT (window->priv->language_combo),
			  "changed",
			  G_CALLBACK (language_combo_changed),
			  window);

	g_signal_connect_after (G_OBJECT (window->priv->statusbar),
				"show",
				G_CALLBACK (statusbar_visibility_changed),
				window);
	g_signal_connect_after (G_OBJECT (window->priv->statusbar),
				"hide",
				G_CALLBACK (statusbar_visibility_changed),
				window);

	set_statusbar_style (window, NULL);
}

static PlumaWindow *
clone_window (PlumaWindow *origin)
{
	PlumaWindow *window;
	GdkScreen *screen;
	PlumaApp  *app;
	gint panel_page;

	pluma_debug (DEBUG_WINDOW);	

	app = pluma_app_get_default ();

	screen = gtk_window_get_screen (GTK_WINDOW (origin));
	window = pluma_app_create_window (app, screen);

	if ((origin->priv->window_state & GDK_WINDOW_STATE_MAXIMIZED) != 0)
	{
		gint w, h;

		pluma_prefs_manager_get_default_window_size (&w, &h);
		gtk_window_set_default_size (GTK_WINDOW (window), w, h);
		gtk_window_maximize (GTK_WINDOW (window));
	}
	else
	{
		gtk_window_set_default_size (GTK_WINDOW (window),
					     origin->priv->width,
					     origin->priv->height);

		gtk_window_unmaximize (GTK_WINDOW (window));
	}		

	if ((origin->priv->window_state & GDK_WINDOW_STATE_STICKY ) != 0)
		gtk_window_stick (GTK_WINDOW (window));
	else
		gtk_window_unstick (GTK_WINDOW (window));

	/* set the panes size, the paned position will be set when
	 * they are mapped */ 
	window->priv->side_panel_size = origin->priv->side_panel_size;
	window->priv->bottom_panel_size = origin->priv->bottom_panel_size;

	panel_page = _pluma_panel_get_active_item_id (PLUMA_PANEL (origin->priv->side_panel));
	_pluma_panel_set_active_item_by_id (PLUMA_PANEL (window->priv->side_panel),
					    panel_page);

	panel_page = _pluma_panel_get_active_item_id (PLUMA_PANEL (origin->priv->bottom_panel));
	_pluma_panel_set_active_item_by_id (PLUMA_PANEL (window->priv->bottom_panel),
					    panel_page);

	if (gtk_widget_get_visible (origin->priv->side_panel))
		gtk_widget_show (window->priv->side_panel);
	else
		gtk_widget_hide (window->priv->side_panel);

	if (gtk_widget_get_visible (origin->priv->bottom_panel))
		gtk_widget_show (window->priv->bottom_panel);
	else
		gtk_widget_hide (window->priv->bottom_panel);

	set_statusbar_style (window, origin);
	set_toolbar_style (window, origin);

	return window;
}

static void
update_cursor_position_statusbar (GtkTextBuffer *buffer, 
				  PlumaWindow   *window)
{
	gint row, col;
	GtkTextIter iter;
	GtkTextIter start;
	guint tab_size;
	PlumaView *view;

	pluma_debug (DEBUG_WINDOW);
  
 	if (buffer != GTK_TEXT_BUFFER (pluma_window_get_active_document (window)))
 		return;
 		
 	view = pluma_window_get_active_view (window);
 	
	gtk_text_buffer_get_iter_at_mark (buffer,
					  &iter,
					  gtk_text_buffer_get_insert (buffer));
	
	row = gtk_text_iter_get_line (&iter);
	
	start = iter;
	gtk_text_iter_set_line_offset (&start, 0);
	col = 0;

	tab_size = gtk_source_view_get_tab_width (GTK_SOURCE_VIEW (view));

	while (!gtk_text_iter_equal (&start, &iter))
	{
		/* FIXME: Are we Unicode compliant here? */
		if (gtk_text_iter_get_char (&start) == '\t')
					
			col += (tab_size - (col  % tab_size));
		else
			++col;

		gtk_text_iter_forward_char (&start);
	}
	
	pluma_statusbar_set_cursor_position (
				PLUMA_STATUSBAR (window->priv->statusbar),
				row + 1,
				col + 1);
}

static void
update_overwrite_mode_statusbar (GtkTextView *view, 
				 PlumaWindow *window)
{
	if (view != GTK_TEXT_VIEW (pluma_window_get_active_view (window)))
		return;
		
	/* Note that we have to use !gtk_text_view_get_overwrite since we
	   are in the in the signal handler of "toggle overwrite" that is
	   G_SIGNAL_RUN_LAST
	*/
	pluma_statusbar_set_overwrite (
			PLUMA_STATUSBAR (window->priv->statusbar),
			!gtk_text_view_get_overwrite (view));
}

#define MAX_TITLE_LENGTH 100

static void 
set_title (PlumaWindow *window)
{
	PlumaDocument *doc = NULL;
	gchar *name;
	gchar *dirname = NULL;
	gchar *title = NULL;
	gint len;

	if (window->priv->active_tab == NULL)
	{
		gtk_window_set_title (GTK_WINDOW (window), "Pluma");
		return;
	}

	doc = pluma_tab_get_document (window->priv->active_tab);
	g_return_if_fail (doc != NULL);

	name = pluma_document_get_short_name_for_display (doc);

	len = g_utf8_strlen (name, -1);

	/* if the name is awfully long, truncate it and be done with it,
	 * otherwise also show the directory (ellipsized if needed)
	 */
	if (len > MAX_TITLE_LENGTH)
	{
		gchar *tmp;

		tmp = pluma_utils_str_middle_truncate (name,
						       MAX_TITLE_LENGTH);
		g_free (name);
		name = tmp;
	}
	else
	{
		GFile *file;

		file = pluma_document_get_location (doc);
		if (file != NULL)
		{
			gchar *str;

			str = pluma_utils_location_get_dirname_for_display (file);
			g_object_unref (file);

			/* use the remaining space for the dir, but use a min of 20 chars
			 * so that we do not end up with a dirname like "(a...b)".
			 * This means that in the worst case when the filename is long 99
			 * we have a title long 99 + 20, but I think it's a rare enough
			 * case to be acceptable. It's justa darn title afterall :)
			 */
			dirname = pluma_utils_str_middle_truncate (str, 
								   MAX (20, MAX_TITLE_LENGTH - len));
			g_free (str);
		}
	}

	if (gtk_text_buffer_get_modified (GTK_TEXT_BUFFER (doc)))
	{
		gchar *tmp_name;
		
		tmp_name = g_strdup_printf ("*%s", name);
		g_free (name);
		
		name = tmp_name;
	}		

	if (pluma_document_get_readonly (doc)) 
	{
		if (dirname != NULL)
			title = g_strdup_printf ("%s [%s] (%s) - Pluma",
						 name, 
						 _("Read-Only"), 
						 dirname);
		else
			title = g_strdup_printf ("%s [%s] - Pluma",
						 name, 
						 _("Read-Only"));
	} 
	else 
	{
		if (dirname != NULL)
			title = g_strdup_printf ("%s (%s) - Pluma",
						 name, 
						 dirname);
		else
			title = g_strdup_printf ("%s - Pluma",
						 name);
	}

	gtk_window_set_title (GTK_WINDOW (window), title);

	g_free (dirname);
	g_free (name);
	g_free (title);
}

#undef MAX_TITLE_LENGTH

static void
set_tab_width_item_blocked (PlumaWindow *window,
			    GtkMenuItem *item)
{
	g_signal_handlers_block_by_func (window->priv->tab_width_combo, 
					 tab_width_combo_changed, 
					 window);
	
	pluma_status_combo_box_set_item (PLUMA_STATUS_COMBO_BOX (window->priv->tab_width_combo),
					 item);
	
	g_signal_handlers_unblock_by_func (window->priv->tab_width_combo, 
					   tab_width_combo_changed, 
					   window);
}

static void
spaces_instead_of_tabs_changed (GObject     *object,
		   		GParamSpec  *pspec,
		 		PlumaWindow *window)
{
	PlumaView *view = PLUMA_VIEW (object);
	gboolean active = gtk_source_view_get_insert_spaces_instead_of_tabs (
			GTK_SOURCE_VIEW (view));
	GList *children = pluma_status_combo_box_get_items (
			PLUMA_STATUS_COMBO_BOX (window->priv->tab_width_combo));
	GtkCheckMenuItem *item;
	
	item = GTK_CHECK_MENU_ITEM (g_list_last (children)->data);
	
	gtk_check_menu_item_set_active (item, active);
	
	g_list_free (children);	
}

static void
tab_width_changed (GObject     *object,
		   GParamSpec  *pspec,
		   PlumaWindow *window)
{
	GList *items;
	GList *item;
	PlumaStatusComboBox *combo = PLUMA_STATUS_COMBO_BOX (window->priv->tab_width_combo);
	guint new_tab_width;
	gboolean found = FALSE;

	items = pluma_status_combo_box_get_items (combo);

	new_tab_width = gtk_source_view_get_tab_width (GTK_SOURCE_VIEW (object));
	
	for (item = items; item; item = item->next)
	{
		guint tab_width = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (item->data), TAB_WIDTH_DATA));
		
		if (tab_width == new_tab_width)
		{
			set_tab_width_item_blocked (window, GTK_MENU_ITEM (item->data));
			found = TRUE;
		}
		
		if (GTK_IS_SEPARATOR_MENU_ITEM (item->next->data))
		{
			if (!found)
			{
				/* Set for the last item the custom thing */
				gchar *text;
			
				text = g_strdup_printf ("%u", new_tab_width);
				pluma_status_combo_box_set_item_text (combo, 
								      GTK_MENU_ITEM (item->data),
								      text);

				gtk_label_set_text (GTK_LABEL (gtk_bin_get_child (GTK_BIN (item->data))),
						    text);
			
				set_tab_width_item_blocked (window, GTK_MENU_ITEM (item->data));
				gtk_widget_show (GTK_WIDGET (item->data));
			}
			else
			{
				gtk_widget_hide (GTK_WIDGET (item->data));
			}
			
			break;
		}
	}
	
	g_list_free (items);
}

static void
language_changed (GObject     *object,
		  GParamSpec  *pspec,
		  PlumaWindow *window)
{
	GList *items;
	GList *item;
	PlumaStatusComboBox *combo = PLUMA_STATUS_COMBO_BOX (window->priv->language_combo);
	GtkSourceLanguage *new_language;
	const gchar *new_id;
	
	items = pluma_status_combo_box_get_items (combo);

	new_language = gtk_source_buffer_get_language (GTK_SOURCE_BUFFER (object));
	
	if (new_language)
		new_id = gtk_source_language_get_id (new_language);
	else
		new_id = NULL;
	
	for (item = items; item; item = item->next)
	{
		GtkSourceLanguage *lang = g_object_get_data (G_OBJECT (item->data), LANGUAGE_DATA);
		
		if ((new_id == NULL && lang == NULL) || 
		    (new_id != NULL && lang != NULL && strcmp (gtk_source_language_get_id (lang),
		    					       new_id) == 0))
		{
			g_signal_handlers_block_by_func (window->priv->language_combo, 
							 language_combo_changed, 
					 		 window);
			
			pluma_status_combo_box_set_item (PLUMA_STATUS_COMBO_BOX (window->priv->language_combo),
					 		 GTK_MENU_ITEM (item->data));

			g_signal_handlers_unblock_by_func (window->priv->language_combo, 
							   language_combo_changed, 
					 		   window);
		}
	}

	g_list_free (items);
}

static void 
notebook_switch_page (GtkNotebook     *book,
		      GtkWidget       *pg,
		      gint             page_num, 
		      PlumaWindow     *window)
{
	PlumaView *view;
	PlumaTab *tab;
	GtkAction *action;
	gchar *action_name;
	
	/* CHECK: I don't know why but it seems notebook_switch_page is called
	two times every time the user change the active tab */
	
	tab = PLUMA_TAB (gtk_notebook_get_nth_page (book, page_num));
	if (tab == window->priv->active_tab)
		return;
	
	if (window->priv->active_tab)
	{
		if (window->priv->tab_width_id)
		{
			g_signal_handler_disconnect (pluma_tab_get_view (window->priv->active_tab), 
						     window->priv->tab_width_id);
		
			window->priv->tab_width_id = 0;
		}
		
		if (window->priv->spaces_instead_of_tabs_id)
		{
			g_signal_handler_disconnect (pluma_tab_get_view (window->priv->active_tab), 
						     window->priv->spaces_instead_of_tabs_id);
		
			window->priv->spaces_instead_of_tabs_id = 0;
		}
	}
	
	/* set the active tab */		
	window->priv->active_tab = tab;

	set_title (window);
	set_sensitivity_according_to_tab (window, tab);

	/* activate the right item in the documents menu */
	action_name = g_strdup_printf ("Tab_%d", page_num);
	action = gtk_action_group_get_action (window->priv->documents_list_action_group,
					      action_name);

	/* sometimes the action doesn't exist yet, and the proper action
	 * is set active during the documents list menu creation
	 * CHECK: would it be nicer if active_tab was a property and we monitored the notify signal?
	 */
	if (action != NULL)
		gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action), TRUE);

	g_free (action_name);

	/* update the syntax menu */
	update_languages_menu (window);

	view = pluma_tab_get_view (tab);

	/* sync the statusbar */
	update_cursor_position_statusbar (GTK_TEXT_BUFFER (pluma_tab_get_document (tab)),
					  window);
	pluma_statusbar_set_overwrite (PLUMA_STATUSBAR (window->priv->statusbar),
				       gtk_text_view_get_overwrite (GTK_TEXT_VIEW (view)));

	gtk_widget_show (window->priv->tab_width_combo);
	gtk_widget_show (window->priv->language_combo);

	window->priv->tab_width_id = g_signal_connect (view, 
						       "notify::tab-width", 
						       G_CALLBACK (tab_width_changed),
						       window);
	window->priv->spaces_instead_of_tabs_id = g_signal_connect (view, 
								    "notify::insert-spaces-instead-of-tabs", 
								    G_CALLBACK (spaces_instead_of_tabs_changed),
								    window);

	window->priv->language_changed_id = g_signal_connect (pluma_tab_get_document (tab),
							      "notify::language",
							      G_CALLBACK (language_changed),
							      window);

	/* call it for the first time */
	tab_width_changed (G_OBJECT (view), NULL, window);
	spaces_instead_of_tabs_changed (G_OBJECT (view), NULL, window);
	language_changed (G_OBJECT (pluma_tab_get_document (tab)), NULL, window);

	g_signal_emit (G_OBJECT (window), 
		       signals[ACTIVE_TAB_CHANGED], 
		       0, 
		       window->priv->active_tab);				       
}

static void
set_sensitivity_according_to_window_state (PlumaWindow *window)
{
	GtkAction *action;
	PlumaLockdownMask lockdown;

	lockdown = pluma_app_get_lockdown (pluma_app_get_default ());

	/* We disable File->Quit/SaveAll/CloseAll while printing to avoid to have two
	   operations (save and print/print preview) that uses the message area at
	   the same time (may be we can remove this limitation in the future) */
	/* We disable File->Quit/CloseAll if state is saving since saving cannot be
	   cancelled (may be we can remove this limitation in the future) */
	gtk_action_group_set_sensitive (window->priv->quit_action_group,
				  !(window->priv->state & PLUMA_WINDOW_STATE_SAVING) &&
				  !(window->priv->state & PLUMA_WINDOW_STATE_PRINTING));

	action = gtk_action_group_get_action (window->priv->action_group,
				              "FileCloseAll");
	gtk_action_set_sensitive (action, 
				  !(window->priv->state & PLUMA_WINDOW_STATE_SAVING) &&
				  !(window->priv->state & PLUMA_WINDOW_STATE_PRINTING));

	action = gtk_action_group_get_action (window->priv->action_group,
				              "FileSaveAll");
	gtk_action_set_sensitive (action, 
				  !(window->priv->state & PLUMA_WINDOW_STATE_PRINTING) &&
				  !(lockdown & PLUMA_LOCKDOWN_SAVE_TO_DISK));
			
	action = gtk_action_group_get_action (window->priv->always_sensitive_action_group,
					      "FileNew");
	gtk_action_set_sensitive (action, 
				  !(window->priv->state & PLUMA_WINDOW_STATE_SAVING_SESSION));
				  
	action = gtk_action_group_get_action (window->priv->always_sensitive_action_group,
					      "FileOpen");
	gtk_action_set_sensitive (action, 
				  !(window->priv->state & PLUMA_WINDOW_STATE_SAVING_SESSION));

	gtk_action_group_set_sensitive (window->priv->recents_action_group,
					!(window->priv->state & PLUMA_WINDOW_STATE_SAVING_SESSION));

	pluma_notebook_set_close_buttons_sensitive (PLUMA_NOTEBOOK (window->priv->notebook),
						    !(window->priv->state & PLUMA_WINDOW_STATE_SAVING_SESSION));
						    
	pluma_notebook_set_tab_drag_and_drop_enabled (PLUMA_NOTEBOOK (window->priv->notebook),
						      !(window->priv->state & PLUMA_WINDOW_STATE_SAVING_SESSION));

	if ((window->priv->state & PLUMA_WINDOW_STATE_SAVING_SESSION) != 0)
	{
		/* TODO: If we really care, Find could be active
		 * when in SAVING_SESSION state */

		if (gtk_action_group_get_sensitive (window->priv->action_group))
			gtk_action_group_set_sensitive (window->priv->action_group,
							FALSE);
		if (gtk_action_group_get_sensitive (window->priv->quit_action_group))
			gtk_action_group_set_sensitive (window->priv->quit_action_group,
							FALSE);
		if (gtk_action_group_get_sensitive (window->priv->close_action_group))
			gtk_action_group_set_sensitive (window->priv->close_action_group,
							FALSE);
	}
	else
	{
		if (!gtk_action_group_get_sensitive (window->priv->action_group))
			gtk_action_group_set_sensitive (window->priv->action_group,
							window->priv->num_tabs > 0);
		if (!gtk_action_group_get_sensitive (window->priv->quit_action_group))
			gtk_action_group_set_sensitive (window->priv->quit_action_group,
							window->priv->num_tabs > 0);
		if (!gtk_action_group_get_sensitive (window->priv->close_action_group))
		{
			gtk_action_group_set_sensitive (window->priv->close_action_group,
							window->priv->num_tabs > 0);
		}
	}
}

static void
update_tab_autosave (GtkWidget *widget,
		     gpointer   data)
{
	PlumaTab *tab = PLUMA_TAB (widget);
	gboolean *enabled = (gboolean *) data;

	pluma_tab_set_auto_save_enabled (tab, *enabled);
}

void
_pluma_window_set_lockdown (PlumaWindow       *window,
			    PlumaLockdownMask  lockdown)
{
	PlumaTab *tab;
	GtkAction *action;
	gboolean autosave;

	/* start/stop autosave in each existing tab */
	autosave = pluma_prefs_manager_get_auto_save ();
	gtk_container_foreach (GTK_CONTAINER (window->priv->notebook),
			       update_tab_autosave,
			       &autosave);

	/* update menues wrt the current active tab */	
	tab = pluma_window_get_active_tab (window);

	set_sensitivity_according_to_tab (window, tab);

	action = gtk_action_group_get_action (window->priv->action_group,
				              "FileSaveAll");
	gtk_action_set_sensitive (action, 
				  !(window->priv->state & PLUMA_WINDOW_STATE_PRINTING) &&
				  !(lockdown & PLUMA_LOCKDOWN_SAVE_TO_DISK));

}

static void
analyze_tab_state (PlumaTab    *tab, 
		   PlumaWindow *window)
{
	PlumaTabState ts;
	
	ts = pluma_tab_get_state (tab);
	
	switch (ts)
	{
		case PLUMA_TAB_STATE_LOADING:
		case PLUMA_TAB_STATE_REVERTING:
			window->priv->state |= PLUMA_WINDOW_STATE_LOADING;
			break;
		
		case PLUMA_TAB_STATE_SAVING:
			window->priv->state |= PLUMA_WINDOW_STATE_SAVING;
			break;
			
		case PLUMA_TAB_STATE_PRINTING:
		case PLUMA_TAB_STATE_PRINT_PREVIEWING:
			window->priv->state |= PLUMA_WINDOW_STATE_PRINTING;
			break;
	
		case PLUMA_TAB_STATE_LOADING_ERROR:
		case PLUMA_TAB_STATE_REVERTING_ERROR:
		case PLUMA_TAB_STATE_SAVING_ERROR:
		case PLUMA_TAB_STATE_GENERIC_ERROR:
			window->priv->state |= PLUMA_WINDOW_STATE_ERROR;
			++window->priv->num_tabs_with_error;
		default:
			/* NOP */
			break;		
	}
}

static void
update_window_state (PlumaWindow *window)
{
	PlumaWindowState old_ws;
	gint old_num_of_errors;
	
	pluma_debug_message (DEBUG_WINDOW, "Old state: %x", window->priv->state);
	
	old_ws = window->priv->state;
	old_num_of_errors = window->priv->num_tabs_with_error;
	
	window->priv->state = old_ws & PLUMA_WINDOW_STATE_SAVING_SESSION;
	
	window->priv->num_tabs_with_error = 0;

	gtk_container_foreach (GTK_CONTAINER (window->priv->notebook),
	       		       (GtkCallback)analyze_tab_state,
	       		       window);
		
	pluma_debug_message (DEBUG_WINDOW, "New state: %x", window->priv->state);		
		
	if (old_ws != window->priv->state)
	{
		set_sensitivity_according_to_window_state (window);

		pluma_statusbar_set_window_state (PLUMA_STATUSBAR (window->priv->statusbar),
						  window->priv->state,
						  window->priv->num_tabs_with_error);
						  
		g_object_notify (G_OBJECT (window), "state");
	}
	else if (old_num_of_errors != window->priv->num_tabs_with_error)
	{
		pluma_statusbar_set_window_state (PLUMA_STATUSBAR (window->priv->statusbar),
						  window->priv->state,
						  window->priv->num_tabs_with_error);	
	}
}

static void
sync_state (PlumaTab    *tab,
	    GParamSpec  *pspec,
	    PlumaWindow *window)
{
	pluma_debug (DEBUG_WINDOW);
	
	update_window_state (window);
	
	if (tab != window->priv->active_tab)
		return;

	set_sensitivity_according_to_tab (window, tab);

	g_signal_emit (G_OBJECT (window), signals[ACTIVE_TAB_STATE_CHANGED], 0);		
}

static void
sync_name (PlumaTab    *tab,
	   GParamSpec  *pspec,
	   PlumaWindow *window)
{
	GtkAction *action;
	gchar *action_name;
	gchar *tab_name;
	gchar *escaped_name;
	gchar *tip;
	gint n;
	PlumaDocument *doc;

	if (tab == window->priv->active_tab)
	{
		set_title (window);

		doc = pluma_tab_get_document (tab);
		action = gtk_action_group_get_action (window->priv->action_group,
						      "FileRevert");
		gtk_action_set_sensitive (action,
					  !pluma_document_is_untitled (doc));
	}

	/* sync the item in the documents list menu */
	n = gtk_notebook_page_num (GTK_NOTEBOOK (window->priv->notebook),
				   GTK_WIDGET (tab));
	action_name = g_strdup_printf ("Tab_%d", n);
	action = gtk_action_group_get_action (window->priv->documents_list_action_group,
					      action_name);
	g_free (action_name);
	g_return_if_fail (action != NULL);

	tab_name = _pluma_tab_get_name (tab);
	escaped_name = pluma_utils_escape_underscores (tab_name, -1);
	tip =  get_menu_tip_for_tab (tab);

	g_object_set (action, "label", escaped_name, NULL);
	g_object_set (action, "tooltip", tip, NULL);

	g_free (tab_name);
	g_free (escaped_name);
	g_free (tip);

	pluma_plugins_engine_update_plugins_ui (pluma_plugins_engine_get_default (),
						 window);
}

static PlumaWindow *
get_drop_window (GtkWidget *widget)
{
	GtkWidget *target_window;

	target_window = gtk_widget_get_toplevel (widget);
	g_return_val_if_fail (PLUMA_IS_WINDOW (target_window), NULL);

	if ((PLUMA_WINDOW(target_window)->priv->state & PLUMA_WINDOW_STATE_SAVING_SESSION) != 0)
		return NULL;
	
	return PLUMA_WINDOW (target_window);
}

static void
load_uris_from_drop (PlumaWindow  *window,
		     gchar       **uri_list)
{
	GSList *uris = NULL;
	gint i;
	
	if (uri_list == NULL)
		return;
	
	for (i = 0; uri_list[i] != NULL; ++i)
	{
		uris = g_slist_prepend (uris, uri_list[i]);
	}

	uris = g_slist_reverse (uris);
	pluma_commands_load_uris (window,
				  uris,
				  NULL,
				  0);

	g_slist_free (uris);
}

/* Handle drops on the PlumaWindow */
static void
drag_data_received_cb (GtkWidget        *widget,
		       GdkDragContext   *context,
		       gint              x,
		       gint              y,
		       GtkSelectionData *selection_data,
		       guint             info,
		       guint             timestamp,
		       gpointer          data)
{
	PlumaWindow *window;
	gchar **uri_list;

	window = get_drop_window (widget);
	
	if (window == NULL)
		return;

	if (info == TARGET_URI_LIST)
	{
		uri_list = pluma_utils_drop_get_uris(selection_data);
		load_uris_from_drop (window, uri_list);
		g_strfreev (uri_list);
	}
}

/* Handle drops on the PlumaView */
static void
drop_uris_cb (GtkWidget    *widget,
	      gchar       **uri_list)
{
	PlumaWindow *window;

	window = get_drop_window (widget);
	
	if (window == NULL)
		return;

	load_uris_from_drop (window, uri_list);
}

static void
fullscreen_controls_show (PlumaWindow *window)
{
	GdkScreen *screen;
	GdkRectangle fs_rect;
	gint w, h;

	screen = gtk_window_get_screen (GTK_WINDOW (window));
	gdk_screen_get_monitor_geometry (screen,
					 gdk_screen_get_monitor_at_window (screen,
									   gtk_widget_get_window (GTK_WIDGET (window))),
					 &fs_rect);

	gtk_window_get_size (GTK_WINDOW (window->priv->fullscreen_controls), &w, &h);

	gtk_window_resize (GTK_WINDOW (window->priv->fullscreen_controls),
			   fs_rect.width, h);

	gtk_window_move (GTK_WINDOW (window->priv->fullscreen_controls),
			 fs_rect.x, fs_rect.y - h + 1);

	gtk_widget_show_all (window->priv->fullscreen_controls);
}

static gboolean
run_fullscreen_animation (gpointer data)
{
	PlumaWindow *window = PLUMA_WINDOW (data);
	GdkScreen *screen;
	GdkRectangle fs_rect;
	gint x, y;
	
	screen = gtk_window_get_screen (GTK_WINDOW (window));
	gdk_screen_get_monitor_geometry (screen,
					 gdk_screen_get_monitor_at_window (screen,
									   gtk_widget_get_window (GTK_WIDGET (window))),
					 &fs_rect);
					 
	gtk_window_get_position (GTK_WINDOW (window->priv->fullscreen_controls),
				 &x, &y);
	
	if (window->priv->fullscreen_animation_enter)
	{
		if (y == fs_rect.y)
		{
			window->priv->fullscreen_animation_timeout_id = 0;
			return FALSE;
		}
		else
		{
			gtk_window_move (GTK_WINDOW (window->priv->fullscreen_controls),
					 x, y + 1);
			return TRUE;
		}
	}
	else
	{
		gint w, h;
	
		gtk_window_get_size (GTK_WINDOW (window->priv->fullscreen_controls),
				     &w, &h);
	
		if (y == fs_rect.y - h + 1)
		{
			window->priv->fullscreen_animation_timeout_id = 0;
			return FALSE;
		}
		else
		{
			gtk_window_move (GTK_WINDOW (window->priv->fullscreen_controls),
					 x, y - 1);
			return TRUE;
		}
	}
}

static void
show_hide_fullscreen_toolbar (PlumaWindow *window,
			      gboolean     show,
			      gint         height)
{
	GtkSettings *settings;
	gboolean enable_animations;

	settings = gtk_widget_get_settings (GTK_WIDGET (window));
	g_object_get (G_OBJECT (settings),
		      "gtk-enable-animations",
		      &enable_animations,
		      NULL);

	if (enable_animations)
	{
		window->priv->fullscreen_animation_enter = show;

		if (window->priv->fullscreen_animation_timeout_id == 0)
		{
			window->priv->fullscreen_animation_timeout_id =
				g_timeout_add (FULLSCREEN_ANIMATION_SPEED,
					       (GSourceFunc) run_fullscreen_animation,
					       window);
		}
	}
	else
	{
		GdkRectangle fs_rect;
		GdkScreen *screen;

		screen = gtk_window_get_screen (GTK_WINDOW (window));
		gdk_screen_get_monitor_geometry (screen,
						 gdk_screen_get_monitor_at_window (screen,
										   gtk_widget_get_window (GTK_WIDGET (window))),
						 &fs_rect);

		if (show)
			gtk_window_move (GTK_WINDOW (window->priv->fullscreen_controls),
				 fs_rect.x, fs_rect.y);
		else
			gtk_window_move (GTK_WINDOW (window->priv->fullscreen_controls),
					 fs_rect.x, fs_rect.y - height + 1);
	}

}

static gboolean
on_fullscreen_controls_enter_notify_event (GtkWidget        *widget,
					   GdkEventCrossing *event,
					   PlumaWindow      *window)
{
	show_hide_fullscreen_toolbar (window, TRUE, 0);

	return FALSE;
}

static gboolean
on_fullscreen_controls_leave_notify_event (GtkWidget        *widget,
					   GdkEventCrossing *event,
					   PlumaWindow      *window)
{
	GdkDisplay *display;
	GdkScreen *screen;
	gint w, h;
	gint x, y;

	display = gdk_display_get_default ();
	screen = gtk_window_get_screen (GTK_WINDOW (window));

	gtk_window_get_size (GTK_WINDOW (window->priv->fullscreen_controls), &w, &h);
	gdk_display_get_pointer (display, &screen, &x, &y, NULL);
	
	/* gtk seems to emit leave notify when clicking on tool items,
	 * work around it by checking the coordinates
	 */
	if (y >= h)
	{
		show_hide_fullscreen_toolbar (window, FALSE, h);
	}

	return FALSE;
}

static void
fullscreen_controls_build (PlumaWindow *window)
{
	PlumaWindowPrivate *priv = window->priv;
	GtkWidget *toolbar;
	GtkWidget *toolbar_recent_menu;
	GtkAction *action;

	if (priv->fullscreen_controls != NULL)
		return;
	
	priv->fullscreen_controls = gtk_window_new (GTK_WINDOW_POPUP);

	gtk_window_set_transient_for (GTK_WINDOW (priv->fullscreen_controls),
				      &window->window);
	
	/* popup toolbar */
	toolbar = gtk_ui_manager_get_widget (priv->manager, "/FullscreenToolBar");
	gtk_container_add (GTK_CONTAINER (priv->fullscreen_controls),
			   toolbar);
	
	action = gtk_action_group_get_action (priv->always_sensitive_action_group,
					      "LeaveFullscreen");
	g_object_set (action, "is-important", TRUE, NULL);
	
	toolbar_recent_menu = setup_toolbar_open_button (window, toolbar);

	gtk_container_foreach (GTK_CONTAINER (toolbar),
			       (GtkCallback)set_non_homogeneus,
			       NULL);

	/* Set the toolbar style */
	gtk_toolbar_set_style (GTK_TOOLBAR (toolbar),
			       GTK_TOOLBAR_BOTH_HORIZ);

	g_signal_connect (priv->fullscreen_controls, "enter-notify-event",
			  G_CALLBACK (on_fullscreen_controls_enter_notify_event),
			  window);
	g_signal_connect (priv->fullscreen_controls, "leave-notify-event",
			  G_CALLBACK (on_fullscreen_controls_leave_notify_event),
			  window);
}

static void
can_search_again (PlumaDocument *doc,
		  GParamSpec    *pspec,
		  PlumaWindow   *window)
{
	gboolean sensitive;
	GtkAction *action;

	if (doc != pluma_window_get_active_document (window))
		return;

	sensitive = pluma_document_get_can_search_again (doc);

	action = gtk_action_group_get_action (window->priv->action_group,
					      "SearchFindNext");
	gtk_action_set_sensitive (action, sensitive);

	action = gtk_action_group_get_action (window->priv->action_group,
					      "SearchFindPrevious");
	gtk_action_set_sensitive (action, sensitive);

	action = gtk_action_group_get_action (window->priv->action_group,
					      "SearchClearHighlight");
	gtk_action_set_sensitive (action, sensitive);
}

static void
can_undo (PlumaDocument *doc,
	  GParamSpec    *pspec,
	  PlumaWindow   *window)
{
	GtkAction *action;
	gboolean sensitive;

	sensitive = gtk_source_buffer_can_undo (GTK_SOURCE_BUFFER (doc));

	if (doc != pluma_window_get_active_document (window))
		return;

	action = gtk_action_group_get_action (window->priv->action_group,
					     "EditUndo");
	gtk_action_set_sensitive (action, sensitive);
}

static void
can_redo (PlumaDocument *doc,
	  GParamSpec    *pspec,
	  PlumaWindow   *window)
{
	GtkAction *action;
	gboolean sensitive;

	sensitive = gtk_source_buffer_can_redo (GTK_SOURCE_BUFFER (doc));

	if (doc != pluma_window_get_active_document (window))
		return;

	action = gtk_action_group_get_action (window->priv->action_group,
					     "EditRedo");
	gtk_action_set_sensitive (action, sensitive);
}

static void
selection_changed (PlumaDocument *doc,
		   GParamSpec    *pspec,
		   PlumaWindow   *window)
{
	PlumaTab *tab;
	PlumaView *view;
	GtkAction *action;
	PlumaTabState state;
	gboolean state_normal;
	gboolean editable;

	pluma_debug (DEBUG_WINDOW);

	if (doc != pluma_window_get_active_document (window))
		return;

	tab = pluma_tab_get_from_document (doc);
	state = pluma_tab_get_state (tab);
	state_normal = (state == PLUMA_TAB_STATE_NORMAL);

	view = pluma_tab_get_view (tab);
	editable = gtk_text_view_get_editable (GTK_TEXT_VIEW (view));

	action = gtk_action_group_get_action (window->priv->action_group,
					      "EditCut");
	gtk_action_set_sensitive (action,
				  state_normal &&
				  editable &&
				  gtk_text_buffer_get_has_selection (GTK_TEXT_BUFFER (doc)));

	action = gtk_action_group_get_action (window->priv->action_group,
					      "EditCopy");
	gtk_action_set_sensitive (action,
				  (state_normal ||
				   state == PLUMA_TAB_STATE_EXTERNALLY_MODIFIED_NOTIFICATION) &&
				  gtk_text_buffer_get_has_selection (GTK_TEXT_BUFFER (doc)));

	action = gtk_action_group_get_action (window->priv->action_group,
					      "EditDelete");
	gtk_action_set_sensitive (action,
				  state_normal &&
				  editable &&
				  gtk_text_buffer_get_has_selection (GTK_TEXT_BUFFER (doc)));

	pluma_plugins_engine_update_plugins_ui (pluma_plugins_engine_get_default (),
						 window);
}

static void
sync_languages_menu (PlumaDocument *doc,
		     GParamSpec    *pspec,
		     PlumaWindow   *window)
{
	update_languages_menu (window);
	pluma_plugins_engine_update_plugins_ui (pluma_plugins_engine_get_default (),
						 window);
}

static void
readonly_changed (PlumaDocument *doc,
		  GParamSpec    *pspec,
		  PlumaWindow   *window)
{
	set_sensitivity_according_to_tab (window, window->priv->active_tab);

	sync_name (window->priv->active_tab, NULL, window);

	pluma_plugins_engine_update_plugins_ui (pluma_plugins_engine_get_default (),
						 window);
}

static void
editable_changed (PlumaView  *view,
                  GParamSpec  *arg1,
                  PlumaWindow *window)
{
	pluma_plugins_engine_update_plugins_ui (pluma_plugins_engine_get_default (),
						 window);
}

static void
update_sensitivity_according_to_open_tabs (PlumaWindow *window)
{
	GtkAction *action;

	/* Set sensitivity */
	gtk_action_group_set_sensitive (window->priv->action_group,
					window->priv->num_tabs != 0);

	action = gtk_action_group_get_action (window->priv->action_group,
					     "DocumentsMoveToNewWindow");
	gtk_action_set_sensitive (action,
				  window->priv->num_tabs > 1);

	gtk_action_group_set_sensitive (window->priv->close_action_group,
	                                window->priv->num_tabs != 0);
}

static void
notebook_tab_added (PlumaNotebook *notebook,
		    PlumaTab      *tab,
		    PlumaWindow   *window)
{
	PlumaView *view;
	PlumaDocument *doc;

	pluma_debug (DEBUG_WINDOW);

	g_return_if_fail ((window->priv->state & PLUMA_WINDOW_STATE_SAVING_SESSION) == 0);
	
	++window->priv->num_tabs;

	update_sensitivity_according_to_open_tabs (window);

	view = pluma_tab_get_view (tab);
	doc = pluma_tab_get_document (tab);

	/* IMPORTANT: remember to disconnect the signal in notebook_tab_removed
	 * if a new signal is connected here */

	g_signal_connect (tab, 
			 "notify::name",
			  G_CALLBACK (sync_name), 
			  window);
	g_signal_connect (tab, 
			 "notify::state",
			  G_CALLBACK (sync_state), 
			  window);

	g_signal_connect (doc,
			  "cursor-moved",
			  G_CALLBACK (update_cursor_position_statusbar),
			  window);
	g_signal_connect (doc,
			  "notify::can-search-again",
			  G_CALLBACK (can_search_again),
			  window);
	g_signal_connect (doc,
			  "notify::can-undo",
			  G_CALLBACK (can_undo),
			  window);
	g_signal_connect (doc,
			  "notify::can-redo",
			  G_CALLBACK (can_redo),
			  window);
	g_signal_connect (doc,
			  "notify::has-selection",
			  G_CALLBACK (selection_changed),
			  window);
	g_signal_connect (doc,
			  "notify::language",
			  G_CALLBACK (sync_languages_menu),
			  window);
	g_signal_connect (doc,
			  "notify::read-only",
			  G_CALLBACK (readonly_changed),
			  window);
	g_signal_connect (view,
			  "toggle_overwrite",
			  G_CALLBACK (update_overwrite_mode_statusbar),
			  window);
	g_signal_connect (view,
			  "notify::editable",
			  G_CALLBACK (editable_changed),
			  window);

	update_documents_list_menu (window);
	
	g_signal_connect (view,
			  "drop_uris",
			  G_CALLBACK (drop_uris_cb), 
			  NULL);

	update_window_state (window);

	g_signal_emit (G_OBJECT (window), signals[TAB_ADDED], 0, tab);
}

static void
notebook_tab_removed (PlumaNotebook *notebook,
		      PlumaTab      *tab,
		      PlumaWindow   *window)
{
	PlumaView     *view;
	PlumaDocument *doc;

	pluma_debug (DEBUG_WINDOW);

	g_return_if_fail ((window->priv->state & PLUMA_WINDOW_STATE_SAVING_SESSION) == 0);

	--window->priv->num_tabs;

	view = pluma_tab_get_view (tab);
	doc = pluma_tab_get_document (tab);

	g_signal_handlers_disconnect_by_func (tab,
					      G_CALLBACK (sync_name), 
					      window);
	g_signal_handlers_disconnect_by_func (tab,
					      G_CALLBACK (sync_state), 
					      window);
	g_signal_handlers_disconnect_by_func (doc,
					      G_CALLBACK (update_cursor_position_statusbar), 
					      window);
	g_signal_handlers_disconnect_by_func (doc, 
					      G_CALLBACK (can_search_again),
					      window);
	g_signal_handlers_disconnect_by_func (doc, 
					      G_CALLBACK (can_undo),
					      window);
	g_signal_handlers_disconnect_by_func (doc, 
					      G_CALLBACK (can_redo),
					      window);
	g_signal_handlers_disconnect_by_func (doc,
					      G_CALLBACK (selection_changed),
					      window);
	g_signal_handlers_disconnect_by_func (doc,
					      G_CALLBACK (sync_languages_menu),
					      window);
	g_signal_handlers_disconnect_by_func (doc,
					      G_CALLBACK (readonly_changed),
					      window);
	g_signal_handlers_disconnect_by_func (view, 
					      G_CALLBACK (update_overwrite_mode_statusbar),
					      window);
	g_signal_handlers_disconnect_by_func (view, 
					      G_CALLBACK (editable_changed),
					      window);
	g_signal_handlers_disconnect_by_func (view, 
					      G_CALLBACK (drop_uris_cb),
					      NULL);

	if (window->priv->tab_width_id && tab == pluma_window_get_active_tab (window))
	{
		g_signal_handler_disconnect (view, window->priv->tab_width_id);
		window->priv->tab_width_id = 0;
	}
	
	if (window->priv->spaces_instead_of_tabs_id && tab == pluma_window_get_active_tab (window))
	{
		g_signal_handler_disconnect (view, window->priv->spaces_instead_of_tabs_id);
		window->priv->spaces_instead_of_tabs_id = 0;
	}
	
	if (window->priv->language_changed_id && tab == pluma_window_get_active_tab (window))
	{
		g_signal_handler_disconnect (doc, window->priv->language_changed_id);
		window->priv->language_changed_id = 0;
	}

	g_return_if_fail (window->priv->num_tabs >= 0);
	if (window->priv->num_tabs == 0)
	{
		window->priv->active_tab = NULL;
			       
		set_title (window);
			
		/* Remove line and col info */
		pluma_statusbar_set_cursor_position (
				PLUMA_STATUSBAR (window->priv->statusbar),
				-1,
				-1);
				
		pluma_statusbar_clear_overwrite (
				PLUMA_STATUSBAR (window->priv->statusbar));

		/* hide the combos */
		gtk_widget_hide (window->priv->tab_width_combo);
		gtk_widget_hide (window->priv->language_combo);
	}

	if (!window->priv->removing_tabs)
	{
		update_documents_list_menu (window);
		update_next_prev_doc_sensitivity_per_window (window);
	}
	else
	{
		if (window->priv->num_tabs == 0)
		{
			update_documents_list_menu (window);
			update_next_prev_doc_sensitivity_per_window (window);
		}
	}

	update_sensitivity_according_to_open_tabs (window);

	if (window->priv->num_tabs == 0)
	{
		pluma_plugins_engine_update_plugins_ui (pluma_plugins_engine_get_default (),
							 window);
	}

	update_window_state (window);

	g_signal_emit (G_OBJECT (window), signals[TAB_REMOVED], 0, tab);	
}

static void
notebook_tabs_reordered (PlumaNotebook *notebook,
			 PlumaWindow   *window)
{
	update_documents_list_menu (window);
	update_next_prev_doc_sensitivity_per_window (window);
	
	g_signal_emit (G_OBJECT (window), signals[TABS_REORDERED], 0);
}

static void
notebook_tab_detached (PlumaNotebook *notebook,
		       PlumaTab      *tab,
		       PlumaWindow   *window)
{
	PlumaWindow *new_window;
	
	new_window = clone_window (window);
		
	pluma_notebook_move_tab (notebook,
				 PLUMA_NOTEBOOK (_pluma_window_get_notebook (new_window)),
				 tab, 0);
				 
	gtk_window_set_position (GTK_WINDOW (new_window), 
				 GTK_WIN_POS_MOUSE);
					 
	gtk_widget_show (GTK_WIDGET (new_window));
}		      

static void 
notebook_tab_close_request (PlumaNotebook *notebook,
			    PlumaTab      *tab,
			    GtkWindow     *window)
{
	/* Note: we are destroying the tab before the default handler
	 * seems to be ok, but we need to keep an eye on this. */
	_pluma_cmd_file_close_tab (tab, PLUMA_WINDOW (window));
}

static gboolean
show_notebook_popup_menu (GtkNotebook    *notebook,
			  PlumaWindow    *window,
			  GdkEventButton *event)
{
	GtkWidget *menu;
//	GtkAction *action;

	menu = gtk_ui_manager_get_widget (window->priv->manager, "/NotebookPopup");
	g_return_val_if_fail (menu != NULL, FALSE);

// CHECK do we need this?
#if 0
	/* allow extensions to sync when showing the popup */
	action = gtk_action_group_get_action (window->priv->action_group,
					      "NotebookPopupAction");
	g_return_val_if_fail (action != NULL, FALSE);
	gtk_action_activate (action);
#endif
	if (event != NULL)
	{
		gtk_menu_popup (GTK_MENU (menu), NULL, NULL,
				NULL, NULL,
				event->button, event->time);
	}
	else
	{
		GtkWidget *tab;
		GtkWidget *tab_label;

		tab = GTK_WIDGET (pluma_window_get_active_tab (window));
		g_return_val_if_fail (tab != NULL, FALSE);

		tab_label = gtk_notebook_get_tab_label (notebook, tab);

		gtk_menu_popup (GTK_MENU (menu), NULL, NULL,
				pluma_utils_menu_position_under_widget, tab_label,
				0, gtk_get_current_event_time ());

		gtk_menu_shell_select_first (GTK_MENU_SHELL (menu), FALSE);
	}

	return TRUE;
}

static gboolean
notebook_button_press_event (GtkNotebook    *notebook,
			     GdkEventButton *event,
			     PlumaWindow    *window)
{
	if (GDK_BUTTON_PRESS == event->type && 3 == event->button)
	{
		return show_notebook_popup_menu (notebook, window, event);
	}
	else if (GDK_BUTTON_PRESS == event->type && 2 == event->button)
	{
		PlumaTab *tab;
		tab = pluma_window_get_active_tab (window);
		notebook_tab_close_request (PLUMA_NOTEBOOK (notebook), tab, GTK_WINDOW (window));
		return FALSE;
	}

	return FALSE;
}

static gboolean
notebook_popup_menu (GtkNotebook *notebook,
		     PlumaWindow *window)
{
	/* Only respond if the notebook is the actual focus */
	if (PLUMA_IS_NOTEBOOK (gtk_window_get_focus (GTK_WINDOW (window))))
	{
		return show_notebook_popup_menu (notebook, window, NULL);
	}

	return FALSE;
}

static void
side_panel_size_allocate (GtkWidget     *widget,
			  GtkAllocation *allocation,
			  PlumaWindow   *window)
{
	window->priv->side_panel_size = allocation->width;
}

static void
bottom_panel_size_allocate (GtkWidget     *widget,
			    GtkAllocation *allocation,
			    PlumaWindow   *window)
{
	window->priv->bottom_panel_size = allocation->height;
}

static void
hpaned_restore_position (GtkWidget   *widget,
			 PlumaWindow *window)
{
	gint pos;

	pluma_debug_message (DEBUG_WINDOW,
			     "Restoring hpaned position: side panel size %d",
			     window->priv->side_panel_size);

	pos = MAX (100, window->priv->side_panel_size);
	gtk_paned_set_position (GTK_PANED (window->priv->hpaned), pos);

	/* start monitoring the size */
	g_signal_connect (window->priv->side_panel,
			  "size-allocate",
			  G_CALLBACK (side_panel_size_allocate),
			  window);

	/* run this only once */
	g_signal_handlers_disconnect_by_func (widget, hpaned_restore_position, window);
}

static void
vpaned_restore_position (GtkWidget   *widget,
			 PlumaWindow *window)
{
	GtkAllocation allocation;
	gint pos;

	gtk_widget_get_allocation (widget, &allocation);

	pluma_debug_message (DEBUG_WINDOW,
			     "Restoring vpaned position: bottom panel size %d",
			     window->priv->bottom_panel_size);

	pos = allocation.height -
	      MAX (50, window->priv->bottom_panel_size);
	gtk_paned_set_position (GTK_PANED (window->priv->vpaned), pos);

	/* start monitoring the size */
	g_signal_connect (window->priv->bottom_panel,
			  "size-allocate",
			  G_CALLBACK (bottom_panel_size_allocate),
			  window);

	/* run this only once */
	g_signal_handlers_disconnect_by_func (widget, vpaned_restore_position, window);
}

static void
side_panel_visibility_changed (GtkWidget   *side_panel,
			       PlumaWindow *window)
{
	gboolean visible;
	GtkAction *action;

	visible = gtk_widget_get_visible (side_panel);

	if (pluma_prefs_manager_side_pane_visible_can_set ())
		pluma_prefs_manager_set_side_pane_visible (visible);

	action = gtk_action_group_get_action (window->priv->panes_action_group,
	                                      "ViewSidePane");

	if (gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action)) != visible)
		gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action), visible);

	/* focus the document */
	if (!visible && window->priv->active_tab != NULL)
		gtk_widget_grab_focus (GTK_WIDGET (
				pluma_tab_get_view (PLUMA_TAB (window->priv->active_tab))));
}

static void
create_side_panel (PlumaWindow *window)
{
	GtkWidget *documents_panel;

	pluma_debug (DEBUG_WINDOW);

	window->priv->side_panel = pluma_panel_new (GTK_ORIENTATION_VERTICAL);

	gtk_paned_pack1 (GTK_PANED (window->priv->hpaned), 
			 window->priv->side_panel, 
			 FALSE, 
			 FALSE);

	g_signal_connect_after (window->priv->side_panel,
				"show",
				G_CALLBACK (side_panel_visibility_changed),
				window);
	g_signal_connect_after (window->priv->side_panel,
				"hide",
				G_CALLBACK (side_panel_visibility_changed),
				window);

	documents_panel = pluma_documents_panel_new (window);
	pluma_panel_add_item_with_stock_icon (PLUMA_PANEL (window->priv->side_panel),
					      documents_panel,
					      _("Documents"),
					      GTK_STOCK_FILE);
}

static void
bottom_panel_visibility_changed (PlumaPanel  *bottom_panel,
				 PlumaWindow *window)
{
	gboolean visible;
	GtkAction *action;

	visible = gtk_widget_get_visible (GTK_WIDGET (bottom_panel));

	if (pluma_prefs_manager_bottom_panel_visible_can_set ())
		pluma_prefs_manager_set_bottom_panel_visible (visible);

	action = gtk_action_group_get_action (window->priv->panes_action_group,
					      "ViewBottomPane");

	if (gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action)) != visible)
		gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action), visible);

	/* focus the document */
	if (!visible && window->priv->active_tab != NULL)
		gtk_widget_grab_focus (GTK_WIDGET (
				pluma_tab_get_view (PLUMA_TAB (window->priv->active_tab))));
}

static void
bottom_panel_item_removed (PlumaPanel  *panel,
			   GtkWidget   *item,
			   PlumaWindow *window)
{
	if (pluma_panel_get_n_items (panel) == 0)
	{
		GtkAction *action;

		gtk_widget_hide (GTK_WIDGET (panel));

		action = gtk_action_group_get_action (window->priv->panes_action_group,
						      "ViewBottomPane");
		gtk_action_set_sensitive (action, FALSE);
	}
}

static void
bottom_panel_item_added (PlumaPanel  *panel,
			 GtkWidget   *item,
			 PlumaWindow *window)
{
	/* if it's the first item added, set the menu item
	 * sensitive and if needed show the panel */
	if (pluma_panel_get_n_items (panel) == 1)
	{
		GtkAction *action;
		gboolean show;

		action = gtk_action_group_get_action (window->priv->panes_action_group,
						      "ViewBottomPane");
		gtk_action_set_sensitive (action, TRUE);

		show = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
		if (show)
			gtk_widget_show (GTK_WIDGET (panel));
	}
}

static void
create_bottom_panel (PlumaWindow *window) 
{
	pluma_debug (DEBUG_WINDOW);

	window->priv->bottom_panel = pluma_panel_new (GTK_ORIENTATION_HORIZONTAL);

	gtk_paned_pack2 (GTK_PANED (window->priv->vpaned), 
			 window->priv->bottom_panel, 
			 FALSE,
			 FALSE);

	g_signal_connect_after (window->priv->bottom_panel,
				"show",
				G_CALLBACK (bottom_panel_visibility_changed),
				window);
	g_signal_connect_after (window->priv->bottom_panel,
				"hide",
				G_CALLBACK (bottom_panel_visibility_changed),
				window);
}

static void
init_panels_visibility (PlumaWindow *window)
{
	gint active_page;

	pluma_debug (DEBUG_WINDOW);

	/* side pane */
	active_page = pluma_prefs_manager_get_side_panel_active_page ();
	_pluma_panel_set_active_item_by_id (PLUMA_PANEL (window->priv->side_panel),
					    active_page);

	if (pluma_prefs_manager_get_side_pane_visible ())
	{
		gtk_widget_show (window->priv->side_panel);
	}

	/* bottom pane, it can be empty */
	if (pluma_panel_get_n_items (PLUMA_PANEL (window->priv->bottom_panel)) > 0)
	{
		active_page = pluma_prefs_manager_get_bottom_panel_active_page ();
		_pluma_panel_set_active_item_by_id (PLUMA_PANEL (window->priv->bottom_panel),
						    active_page);

		if (pluma_prefs_manager_get_bottom_panel_visible ())
		{
			gtk_widget_show (window->priv->bottom_panel);
		}
	}
	else
	{
		GtkAction *action;
		action = gtk_action_group_get_action (window->priv->panes_action_group,
						      "ViewBottomPane");
		gtk_action_set_sensitive (action, FALSE);
	}

	/* start track sensitivity after the initial state is set */
	window->priv->bottom_panel_item_removed_handler_id =
		g_signal_connect (window->priv->bottom_panel,
				  "item_removed",
				  G_CALLBACK (bottom_panel_item_removed),
				  window);

	g_signal_connect (window->priv->bottom_panel,
			  "item_added",
			  G_CALLBACK (bottom_panel_item_added),
			  window);
}

static void
clipboard_owner_change (GtkClipboard        *clipboard,
			GdkEventOwnerChange *event,
			PlumaWindow         *window)
{
	set_paste_sensitivity_according_to_clipboard (window,
						      clipboard);
}

static void
window_realized (GtkWidget *window,
		 gpointer  *data)
{
	GtkClipboard *clipboard;

	clipboard = gtk_widget_get_clipboard (window,
					      GDK_SELECTION_CLIPBOARD);

	g_signal_connect (clipboard,
			  "owner_change",
			  G_CALLBACK (clipboard_owner_change),
			  window);
}

static void
window_unrealized (GtkWidget *window,
		   gpointer  *data)
{
	GtkClipboard *clipboard;

	clipboard = gtk_widget_get_clipboard (window,
					      GDK_SELECTION_CLIPBOARD);

	g_signal_handlers_disconnect_by_func (clipboard,
					      G_CALLBACK (clipboard_owner_change),
					      window);
}

static void
check_window_is_active (PlumaWindow *window,
			GParamSpec *property,
			gpointer useless)
{
	if (window->priv->window_state & GDK_WINDOW_STATE_FULLSCREEN)
	{
		if (gtk_window_is_active (GTK_WINDOW (window)))
		{
			gtk_widget_show (window->priv->fullscreen_controls);
		}
		else
		{
			gtk_widget_hide (window->priv->fullscreen_controls);
		}
	}
}

static void
connect_notebook_signals (PlumaWindow *window,
			  GtkWidget   *notebook)
{
	g_signal_connect (notebook,
			  "switch-page",
			  G_CALLBACK (notebook_switch_page),
			  window);
	g_signal_connect (notebook,
			  "tab-added",
			  G_CALLBACK (notebook_tab_added),
			  window);
	g_signal_connect (notebook,
			  "tab-removed",
			  G_CALLBACK (notebook_tab_removed),
			  window);
	g_signal_connect (notebook,
			  "tabs-reordered",
			  G_CALLBACK (notebook_tabs_reordered),
			  window);
	g_signal_connect (notebook,
			  "tab-detached",
			  G_CALLBACK (notebook_tab_detached),
			  window);
	g_signal_connect (notebook,
			  "tab-close-request",
			  G_CALLBACK (notebook_tab_close_request),
			  window);
	g_signal_connect (notebook,
			  "button-press-event",
			  G_CALLBACK (notebook_button_press_event),
			  window);
	g_signal_connect (notebook,
			  "popup-menu",
			  G_CALLBACK (notebook_popup_menu),
			  window);
}

static void
add_notebook (PlumaWindow *window,
	      GtkWidget   *notebook)
{
	gtk_paned_pack1 (GTK_PANED (window->priv->vpaned),
	                 notebook,
	                 TRUE,
	                 TRUE);

	gtk_widget_show (notebook);

	connect_notebook_signals (window, notebook);
}

static void
pluma_window_init (PlumaWindow *window)
{
	GtkWidget *main_box;
	GtkTargetList *tl;

	pluma_debug (DEBUG_WINDOW);

	window->priv = PLUMA_WINDOW_GET_PRIVATE (window);
	window->priv->active_tab = NULL;
	window->priv->num_tabs = 0;
	window->priv->removing_tabs = FALSE;
	window->priv->state = PLUMA_WINDOW_STATE_NORMAL;
	window->priv->dispose_has_run = FALSE;
	window->priv->fullscreen_controls = NULL;
	window->priv->fullscreen_animation_timeout_id = 0;

	window->priv->message_bus = pluma_message_bus_new ();

	window->priv->window_group = gtk_window_group_new ();
	gtk_window_group_add_window (window->priv->window_group, GTK_WINDOW (window));

#if GTK_CHECK_VERSION(3, 0, 0)
    GtkStyleContext *context;

    context = gtk_widget_get_style_context (GTK_WIDGET (window));
    gtk_style_context_add_class (context, "pluma-window");
#endif

	main_box = gtk_vbox_new (FALSE, 0);
	gtk_container_add (GTK_CONTAINER (window), main_box);
	gtk_widget_show (main_box);

	/* Add menu bar and toolbar bar */
	create_menu_bar_and_toolbar (window, main_box);

	/* Add status bar */
	create_statusbar (window, main_box);

	/* Add the main area */
	pluma_debug_message (DEBUG_WINDOW, "Add main area");		
	window->priv->hpaned = gtk_hpaned_new ();
  	gtk_box_pack_start (GTK_BOX (main_box), 
  			    window->priv->hpaned, 
  			    TRUE, 
  			    TRUE, 
  			    0);

	window->priv->vpaned = gtk_vpaned_new ();
  	gtk_paned_pack2 (GTK_PANED (window->priv->hpaned), 
  			 window->priv->vpaned, 
  			 TRUE, 
  			 FALSE);
  	
	pluma_debug_message (DEBUG_WINDOW, "Create pluma notebook");
	window->priv->notebook = pluma_notebook_new ();
	add_notebook (window, window->priv->notebook);

	/* side and bottom panels */
  	create_side_panel (window);
	create_bottom_panel (window);

	/* panes' state must be restored after panels have been mapped,
	 * since the bottom pane position depends on the size of the vpaned. */
	window->priv->side_panel_size = pluma_prefs_manager_get_side_panel_size ();
	window->priv->bottom_panel_size = pluma_prefs_manager_get_bottom_panel_size ();

	g_signal_connect_after (window->priv->hpaned,
				"map",
				G_CALLBACK (hpaned_restore_position),
				window);
	g_signal_connect_after (window->priv->vpaned,
				"map",
				G_CALLBACK (vpaned_restore_position),
				window);

	gtk_widget_show (window->priv->hpaned);
	gtk_widget_show (window->priv->vpaned);

	/* Drag and drop support, set targets to NULL because we add the
	   default uri_targets below */
	gtk_drag_dest_set (GTK_WIDGET (window),
			   GTK_DEST_DEFAULT_MOTION |
			   GTK_DEST_DEFAULT_HIGHLIGHT |
			   GTK_DEST_DEFAULT_DROP,
			   NULL,
			   0,
			   GDK_ACTION_COPY);

	/* Add uri targets */
	tl = gtk_drag_dest_get_target_list (GTK_WIDGET (window));
	
	if (tl == NULL)
	{
		tl = gtk_target_list_new (NULL, 0);
		gtk_drag_dest_set_target_list (GTK_WIDGET (window), tl);
		gtk_target_list_unref (tl);
	}
	
	gtk_target_list_add_uri_targets (tl, TARGET_URI_LIST);

	/* connect instead of override, so that we can
	 * share the cb code with the view */
	g_signal_connect (window,
			  "drag_data_received",
	                  G_CALLBACK (drag_data_received_cb), 
	                  NULL);

	/* we can get the clipboard only after the widget
	 * is realized */
	g_signal_connect (window,
			  "realize",
			  G_CALLBACK (window_realized),
			  NULL);
	g_signal_connect (window,
			  "unrealize",
			  G_CALLBACK (window_unrealized),
			  NULL);

	/* Check if the window is active for fullscreen */
	g_signal_connect (window,
			  "notify::is-active",
			  G_CALLBACK (check_window_is_active),
			  NULL);

	pluma_debug_message (DEBUG_WINDOW, "Update plugins ui");
	
	pluma_plugins_engine_activate_plugins (pluma_plugins_engine_get_default (),
					        window);

	/* set visibility of panes.
	 * This needs to be done after plugins activatation */
	init_panels_visibility (window);

	update_sensitivity_according_to_open_tabs (window);

	pluma_debug_message (DEBUG_WINDOW, "END");
}

/**
 * pluma_window_get_active_view:
 * @window: a #PlumaWindow
 *
 * Gets the active #PlumaView.
 *
 * Returns: the active #PlumaView
 */
PlumaView *
pluma_window_get_active_view (PlumaWindow *window)
{
	PlumaView *view;

	g_return_val_if_fail (PLUMA_IS_WINDOW (window), NULL);

	if (window->priv->active_tab == NULL)
		return NULL;

	view = pluma_tab_get_view (PLUMA_TAB (window->priv->active_tab));

	return view;
}

/**
 * pluma_window_get_active_document:
 * @window: a #PlumaWindow
 *
 * Gets the active #PlumaDocument.
 * 
 * Returns: the active #PlumaDocument
 */
PlumaDocument *
pluma_window_get_active_document (PlumaWindow *window)
{
	PlumaView *view;

	g_return_val_if_fail (PLUMA_IS_WINDOW (window), NULL);

	view = pluma_window_get_active_view (window);
	if (view == NULL)
		return NULL;

	return PLUMA_DOCUMENT (gtk_text_view_get_buffer (GTK_TEXT_VIEW (view)));
}

GtkWidget *
_pluma_window_get_notebook (PlumaWindow *window)
{
	g_return_val_if_fail (PLUMA_IS_WINDOW (window), NULL);

	return window->priv->notebook;
}

/**
 * pluma_window_create_tab:
 * @window: a #PlumaWindow
 * @jump_to: %TRUE to set the new #PlumaTab as active
 *
 * Creates a new #PlumaTab and adds the new tab to the #PlumaNotebook.
 * In case @jump_to is %TRUE the #PlumaNotebook switches to that new #PlumaTab.
 *
 * Returns: a new #PlumaTab
 */
PlumaTab *
pluma_window_create_tab (PlumaWindow *window,
			 gboolean     jump_to)
{
	PlumaTab *tab;

	g_return_val_if_fail (PLUMA_IS_WINDOW (window), NULL);

	tab = PLUMA_TAB (_pluma_tab_new ());	
	gtk_widget_show (GTK_WIDGET (tab));	

	pluma_notebook_add_tab (PLUMA_NOTEBOOK (window->priv->notebook),
				tab,
				-1,
				jump_to);

	if (!gtk_widget_get_visible (GTK_WIDGET (window)))
	{
		gtk_window_present (GTK_WINDOW (window));
	}

	return tab;
}

/**
 * pluma_window_create_tab_from_uri:
 * @window: a #PlumaWindow
 * @uri: the uri of the document
 * @encoding: a #PlumaEncoding
 * @line_pos: the line position to visualize
 * @create: %TRUE to create a new document in case @uri does exist
 * @jump_to: %TRUE to set the new #PlumaTab as active
 *
 * Creates a new #PlumaTab loading the document specified by @uri.
 * In case @jump_to is %TRUE the #PlumaNotebook swithes to that new #PlumaTab.
 * Whether @create is %TRUE, creates a new empty document if location does 
 * not refer to an existing file
 *
 * Returns: a new #PlumaTab
 */
PlumaTab *
pluma_window_create_tab_from_uri (PlumaWindow         *window,
				  const gchar         *uri,
				  const PlumaEncoding *encoding,
				  gint                 line_pos,
				  gboolean             create,
				  gboolean             jump_to)
{
	GtkWidget *tab;

	g_return_val_if_fail (PLUMA_IS_WINDOW (window), NULL);
	g_return_val_if_fail (uri != NULL, NULL);

	tab = _pluma_tab_new_from_uri (uri,
				       encoding,
				       line_pos,
				       create);	
	if (tab == NULL)
		return NULL;

	gtk_widget_show (tab);	
	
	pluma_notebook_add_tab (PLUMA_NOTEBOOK (window->priv->notebook),
				PLUMA_TAB (tab),
				-1,
				jump_to);


	if (!gtk_widget_get_visible (GTK_WIDGET (window)))
	{
		gtk_window_present (GTK_WINDOW (window));
	}

	return PLUMA_TAB (tab);
}				  

/**
 * pluma_window_get_active_tab:
 * @window: a PlumaWindow
 *
 * Gets the active #PlumaTab in the @window.
 *
 * Returns: the active #PlumaTab in the @window.
 */
PlumaTab *
pluma_window_get_active_tab (PlumaWindow *window)
{
	g_return_val_if_fail (PLUMA_IS_WINDOW (window), NULL);
	
	return (window->priv->active_tab == NULL) ? 
				NULL : PLUMA_TAB (window->priv->active_tab);
}

static void
add_document (PlumaTab *tab, GList **res)
{
	PlumaDocument *doc;
	
	doc = pluma_tab_get_document (tab);
	
	*res = g_list_prepend (*res, doc);
}

/**
 * pluma_window_get_documents:
 * @window: a #PlumaWindow
 *
 * Gets a newly allocated list with all the documents in the window.
 * This list must be freed.
 *
 * Returns: (element-type Pluma.Document) (transfer container): a newly
 * allocated list with all the documents in the window
 */
GList *
pluma_window_get_documents (PlumaWindow *window)
{
	GList *res = NULL;

	g_return_val_if_fail (PLUMA_IS_WINDOW (window), NULL);
	
	gtk_container_foreach (GTK_CONTAINER (window->priv->notebook),
			       (GtkCallback)add_document,
			       &res);
			       
	res = g_list_reverse (res);
	
	return res;
}

static void
add_view (PlumaTab *tab, GList **res)
{
	PlumaView *view;
	
	view = pluma_tab_get_view (tab);
	
	*res = g_list_prepend (*res, view);
}

/**
 * pluma_window_get_views:
 * @window: a #PlumaWindow
 *
 * Gets a list with all the views in the window. This list must be freed.
 *
 * Returns: (element-type Pluma.View) (transfer container): a newly allocated
 * list with all the views in the window
 */
GList *
pluma_window_get_views (PlumaWindow *window)
{
	GList *res = NULL;

	g_return_val_if_fail (PLUMA_IS_WINDOW (window), NULL);
	
	gtk_container_foreach (GTK_CONTAINER (window->priv->notebook),
			       (GtkCallback)add_view,
			       &res);
			       
	res = g_list_reverse (res);
	
	return res;
}

/**
 * pluma_window_close_tab:
 * @window: a #PlumaWindow
 * @tab: the #PlumaTab to close
 *
 * Closes the @tab.
 */
void
pluma_window_close_tab (PlumaWindow *window,
			PlumaTab    *tab)
{
	g_return_if_fail (PLUMA_IS_WINDOW (window));
	g_return_if_fail (PLUMA_IS_TAB (tab));
	g_return_if_fail ((pluma_tab_get_state (tab) != PLUMA_TAB_STATE_SAVING) &&
			  (pluma_tab_get_state (tab) != PLUMA_TAB_STATE_SHOWING_PRINT_PREVIEW));
	
	pluma_notebook_remove_tab (PLUMA_NOTEBOOK (window->priv->notebook),
				   tab);
}

/**
 * pluma_window_close_all_tabs:
 * @window: a #PlumaWindow
 *
 * Closes all opened tabs.
 */
void
pluma_window_close_all_tabs (PlumaWindow *window)
{
	g_return_if_fail (PLUMA_IS_WINDOW (window));
	g_return_if_fail (!(window->priv->state & PLUMA_WINDOW_STATE_SAVING) &&
			  !(window->priv->state & PLUMA_WINDOW_STATE_SAVING_SESSION));

	window->priv->removing_tabs = TRUE;

	pluma_notebook_remove_all_tabs (PLUMA_NOTEBOOK (window->priv->notebook));

	window->priv->removing_tabs = FALSE;
}

/**
 * pluma_window_close_tabs:
 * @window: a #PlumaWindow
 * @tabs: (element-type Pluma.Tab): a list of #PlumaTab
 *
 * Closes all tabs specified by @tabs.
 */
void
pluma_window_close_tabs (PlumaWindow *window,
			 const GList *tabs)
{
	g_return_if_fail (PLUMA_IS_WINDOW (window));
	g_return_if_fail (!(window->priv->state & PLUMA_WINDOW_STATE_SAVING) &&
			  !(window->priv->state & PLUMA_WINDOW_STATE_SAVING_SESSION));

	if (tabs == NULL)
		return;

	window->priv->removing_tabs = TRUE;

	while (tabs != NULL)
	{
		if (tabs->next == NULL)
			window->priv->removing_tabs = FALSE;

		pluma_notebook_remove_tab (PLUMA_NOTEBOOK (window->priv->notebook),
				   	   PLUMA_TAB (tabs->data));

		tabs = g_list_next (tabs);
	}

	g_return_if_fail (window->priv->removing_tabs == FALSE);
}

PlumaWindow *
_pluma_window_move_tab_to_new_window (PlumaWindow *window,
				      PlumaTab    *tab)
{
	PlumaWindow *new_window;

	g_return_val_if_fail (PLUMA_IS_WINDOW (window), NULL);
	g_return_val_if_fail (PLUMA_IS_TAB (tab), NULL);
	g_return_val_if_fail (gtk_notebook_get_n_pages (
				GTK_NOTEBOOK (window->priv->notebook)) > 1, 
			      NULL);
			      
	new_window = clone_window (window);

	pluma_notebook_move_tab (PLUMA_NOTEBOOK (window->priv->notebook),
				 PLUMA_NOTEBOOK (new_window->priv->notebook),
				 tab,
				 -1);
				 
	gtk_widget_show (GTK_WIDGET (new_window));
	
	return new_window;
}				      

/**
 * pluma_window_set_active_tab:
 * @window: a #PlumaWindow
 * @tab: a #PlumaTab
 *
 * Switches to the tab that matches with @tab.
 */
void
pluma_window_set_active_tab (PlumaWindow *window,
			     PlumaTab    *tab)
{
	gint page_num;
	
	g_return_if_fail (PLUMA_IS_WINDOW (window));
	g_return_if_fail (PLUMA_IS_TAB (tab));
	
	page_num = gtk_notebook_page_num (GTK_NOTEBOOK (window->priv->notebook),
					  GTK_WIDGET (tab));
	g_return_if_fail (page_num != -1);
	
	gtk_notebook_set_current_page (GTK_NOTEBOOK (window->priv->notebook),
				       page_num);
}

/**
 * pluma_window_get_group:
 * @window: a #PlumaWindow
 *
 * Gets the #GtkWindowGroup in which @window resides.
 *
 * Returns: the #GtkWindowGroup
 */
GtkWindowGroup *
pluma_window_get_group (PlumaWindow *window)
{
	g_return_val_if_fail (PLUMA_IS_WINDOW (window), NULL);
	
	return window->priv->window_group;
}

gboolean
_pluma_window_is_removing_tabs (PlumaWindow *window)
{
	g_return_val_if_fail (PLUMA_IS_WINDOW (window), FALSE);
	
	return window->priv->removing_tabs;
}

/**
 * pluma_window_get_ui_manager:
 * @window: a #PlumaWindow
 *
 * Gets the #GtkUIManager associated with the @window.
 *
 * Returns: the #GtkUIManager of the @window.
 */
GtkUIManager *
pluma_window_get_ui_manager (PlumaWindow *window)
{
	g_return_val_if_fail (PLUMA_IS_WINDOW (window), NULL);

	return window->priv->manager;
}

/**
 * pluma_window_get_side_panel:
 * @window: a #PlumaWindow
 *
 * Gets the side #PlumaPanel of the @window.
 *
 * Returns: the side #PlumaPanel.
 */
PlumaPanel *
pluma_window_get_side_panel (PlumaWindow *window)
{
	g_return_val_if_fail (PLUMA_IS_WINDOW (window), NULL);

	return PLUMA_PANEL (window->priv->side_panel);
}

/**
 * pluma_window_get_bottom_panel:
 * @window: a #PlumaWindow
 *
 * Gets the bottom #PlumaPanel of the @window.
 *
 * Returns: the bottom #PlumaPanel.
 */
PlumaPanel *
pluma_window_get_bottom_panel (PlumaWindow *window)
{
	g_return_val_if_fail (PLUMA_IS_WINDOW (window), NULL);

	return PLUMA_PANEL (window->priv->bottom_panel);
}

/**
 * pluma_window_get_statusbar:
 * @window: a #PlumaWindow
 *
 * Gets the #PlumaStatusbar of the @window.
 *
 * Returns: the #PlumaStatusbar of the @window.
 */
GtkWidget *
pluma_window_get_statusbar (PlumaWindow *window)
{
	g_return_val_if_fail (PLUMA_IS_WINDOW (window), 0);

	return window->priv->statusbar;
}

/**
 * pluma_window_get_state:
 * @window: a #PlumaWindow
 *
 * Retrieves the state of the @window.
 *
 * Returns: the current #PlumaWindowState of the @window.
 */
PlumaWindowState
pluma_window_get_state (PlumaWindow *window)
{
	g_return_val_if_fail (PLUMA_IS_WINDOW (window), PLUMA_WINDOW_STATE_NORMAL);

	return window->priv->state;
}

GFile *
_pluma_window_get_default_location (PlumaWindow *window)
{
	g_return_val_if_fail (PLUMA_IS_WINDOW (window), NULL);

	return window->priv->default_location != NULL ?
		g_object_ref (window->priv->default_location) : NULL;
}

void
_pluma_window_set_default_location (PlumaWindow *window,
				    GFile       *location)
{
	GFile *dir;

	g_return_if_fail (PLUMA_IS_WINDOW (window));
	g_return_if_fail (G_IS_FILE (location));

	dir = g_file_get_parent (location);
	g_return_if_fail (dir != NULL);

	if (window->priv->default_location != NULL)
		g_object_unref (window->priv->default_location);

	window->priv->default_location = dir;
}

/**
 * pluma_window_get_unsaved_documents:
 * @window: a #PlumaWindow
 *
 * Gets the list of documents that need to be saved before closing the window.
 *
 * Returns: (element-type Pluma.Document) (transfer container): a list of
 * #PlumaDocument that need to be saved before closing the window
 */
GList *
pluma_window_get_unsaved_documents (PlumaWindow *window)
{
	GList *unsaved_docs = NULL;
	GList *tabs;
	GList *l;

	g_return_val_if_fail (PLUMA_IS_WINDOW (window), NULL);
	
	tabs = gtk_container_get_children (GTK_CONTAINER (window->priv->notebook));
	
	l = tabs;
	while (l != NULL)
	{
		PlumaTab *tab;

		tab = PLUMA_TAB (l->data);
		
		if (!_pluma_tab_can_close (tab))
		{
			PlumaDocument *doc;
			
			doc = pluma_tab_get_document (tab);
			unsaved_docs = g_list_prepend (unsaved_docs, doc);
		}	
		
		l = g_list_next (l);
	}
	
	g_list_free (tabs);

	return g_list_reverse (unsaved_docs);
}

void 
_pluma_window_set_saving_session_state (PlumaWindow *window,
					gboolean     saving_session)
{
	PlumaWindowState old_state;

	g_return_if_fail (PLUMA_IS_WINDOW (window));
	
	old_state = window->priv->state;

	if (saving_session)
		window->priv->state |= PLUMA_WINDOW_STATE_SAVING_SESSION;
	else
		window->priv->state &= ~PLUMA_WINDOW_STATE_SAVING_SESSION;

	if (old_state != window->priv->state)
	{
		set_sensitivity_according_to_window_state (window);

		g_object_notify (G_OBJECT (window), "state");
	}
}

static void
hide_notebook_tabs_on_fullscreen (GtkNotebook	*notebook, 
				  GParamSpec	*pspec,
				  PlumaWindow	*window)
{
	gtk_notebook_set_show_tabs (notebook, FALSE);
}

void
_pluma_window_fullscreen (PlumaWindow *window)
{
	g_return_if_fail (PLUMA_IS_WINDOW (window));

	if (_pluma_window_is_fullscreen (window))
		return;

	/* Go to fullscreen mode and hide bars */
	gtk_window_fullscreen (&window->window);
	gtk_notebook_set_show_tabs (GTK_NOTEBOOK (window->priv->notebook), FALSE);
	g_signal_connect (window->priv->notebook, "notify::show-tabs",
			  G_CALLBACK (hide_notebook_tabs_on_fullscreen), window);
	
	gtk_widget_hide (window->priv->menubar);
	
	g_signal_handlers_block_by_func (window->priv->toolbar,
					 toolbar_visibility_changed,
					 window);
	gtk_widget_hide (window->priv->toolbar);
	
	g_signal_handlers_block_by_func (window->priv->statusbar,
					 statusbar_visibility_changed,
					 window);
	gtk_widget_hide (window->priv->statusbar);

	fullscreen_controls_build (window);
	fullscreen_controls_show (window);
}

void
_pluma_window_unfullscreen (PlumaWindow *window)
{
	gboolean visible;
	GtkAction *action;

	g_return_if_fail (PLUMA_IS_WINDOW (window));

	if (!_pluma_window_is_fullscreen (window))
		return;

	/* Unfullscreen and show bars */
	gtk_window_unfullscreen (&window->window);
	g_signal_handlers_disconnect_by_func (window->priv->notebook,
					      hide_notebook_tabs_on_fullscreen,
					      window);
	gtk_notebook_set_show_tabs (GTK_NOTEBOOK (window->priv->notebook), TRUE);
	gtk_widget_show (window->priv->menubar);
	
	action = gtk_action_group_get_action (window->priv->always_sensitive_action_group,
					      "ViewToolbar");
	visible = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
	if (visible)
		gtk_widget_show (window->priv->toolbar);
	g_signal_handlers_unblock_by_func (window->priv->toolbar,
					   toolbar_visibility_changed,
					   window);
	
	action = gtk_action_group_get_action (window->priv->always_sensitive_action_group,
					      "ViewStatusbar");
	visible = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
	if (visible)
		gtk_widget_show (window->priv->statusbar);
	g_signal_handlers_unblock_by_func (window->priv->statusbar,
					   statusbar_visibility_changed,
					   window);

	gtk_widget_hide (window->priv->fullscreen_controls);
}

gboolean
_pluma_window_is_fullscreen (PlumaWindow *window)
{
	g_return_val_if_fail (PLUMA_IS_WINDOW (window), FALSE);

	return window->priv->window_state & GDK_WINDOW_STATE_FULLSCREEN;
}

/**
 * pluma_window_get_tab_from_location:
 * @window: a #PlumaWindow
 * @location: a #GFile
 *
 * Gets the #PlumaTab that matches with the given @location.
 *
 * Returns: the #PlumaTab that matches with the given @location.
 */
PlumaTab *
pluma_window_get_tab_from_location (PlumaWindow *window,
				    GFile       *location)
{
	GList *tabs;
	GList *l;
	PlumaTab *ret = NULL;

	g_return_val_if_fail (PLUMA_IS_WINDOW (window), NULL);
	g_return_val_if_fail (G_IS_FILE (location), NULL);

	tabs = gtk_container_get_children (GTK_CONTAINER (window->priv->notebook));
	
	for (l = tabs; l != NULL; l = g_list_next (l))
	{
		PlumaDocument *d;
		PlumaTab *t;
		GFile *f;

		t = PLUMA_TAB (l->data);
		d = pluma_tab_get_document (t);

		f = pluma_document_get_location (d);

		if ((f != NULL))
		{
			gboolean found = g_file_equal (location, f);

			g_object_unref (f);

			if (found)
			{
				ret = t;
				break;
			}
		}
	}
	
	g_list_free (tabs);
	
	return ret;
}

/**
 * pluma_window_get_message_bus:
 * @window: a #PlumaWindow
 *
 * Gets the #PlumaMessageBus associated with @window. The returned reference
 * is owned by the window and should not be unreffed.
 *
 * Return value: (transfer none): the #PlumaMessageBus associated with @window
 */
PlumaMessageBus	*
pluma_window_get_message_bus (PlumaWindow *window)
{
	g_return_val_if_fail (PLUMA_IS_WINDOW (window), NULL);
	
	return window->priv->message_bus;
}

/**
 * pluma_window_get_tab_from_uri:
 * @window: a #PlumaWindow
 * @uri: the uri to get the #PlumaTab
 *
 * Gets the #PlumaTab that matches @uri.
 *
 * Returns: the #PlumaTab associated with @uri.
 *
 * Deprecated: 2.24: Use pluma_window_get_tab_from_location() instead.
 */
PlumaTab *
pluma_window_get_tab_from_uri (PlumaWindow *window,
			       const gchar *uri)
{
	GFile *f;
	PlumaTab *tab;

	g_return_val_if_fail (PLUMA_IS_WINDOW (window), NULL);
	g_return_val_if_fail (uri != NULL, NULL);

	f = g_file_new_for_uri (uri);
	tab = pluma_window_get_tab_from_location (window, f);
	g_object_unref (f);

	return tab;
}
