initial

1 files changed, 2732 insertions, 0 deletions

diff --git a/gedit/gedit-document.c b/gedit/gedit-document.c
new file mode 100755
index 00000000..d9612263
--- /dev/null
+++ b/gedit/gedit-document.c
@@ -0,0 +1,2732 @@
+/*
+ * gedit-document.c
+ * This file is part of gedit
+ *
+ * Copyright (C) 1998, 1999 Alex Roberts, Evan Lawrence
+ * Copyright (C) 2000, 2001 Chema Celorio, Paolo Maggi 
+ * Copyright (C) 2002-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., 59 Temple Place, Suite 330, 
+ * Boston, MA 02111-1307, USA.
+ */
+ 
+/*
+ * Modified by the gedit Team, 1998-2005. See the AUTHORS file for a 
+ * list of people on the gedit Team.  
+ * See the ChangeLog files for a list of changes. 
+ *
+ * $Id$
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <string.h>
+#include <stdlib.h>
+
+#include <glib/gi18n.h>
+#include <gtksourceview/gtksourceiter.h>
+
+#include "gedit-prefs-manager-app.h"
+#include "gedit-document.h"
+#include "gedit-debug.h"
+#include "gedit-utils.h"
+#include "gedit-language-manager.h"
+#include "gedit-style-scheme-manager.h"
+#include "gedit-document-loader.h"
+#include "gedit-document-saver.h"
+#include "gedit-marshal.h"
+#include "gedit-enum-types.h"
+#include "gedittextregion.h"
+
+#ifndef ENABLE_GVFS_METADATA
+#include "gedit-metadata-manager.h"
+#else
+#define METADATA_QUERY "metadata::*"
+#endif
+
+#undef ENABLE_PROFILE 
+
+#ifdef ENABLE_PROFILE
+#define PROFILE(x) x
+#else
+#define PROFILE(x)
+#endif
+
+PROFILE (static GTimer *timer = NULL)
+
+#ifdef MAXPATHLEN
+#define GEDIT_MAX_PATH_LEN  MAXPATHLEN
+#elif defined (PATH_MAX)
+#define GEDIT_MAX_PATH_LEN  PATH_MAX
+#else
+#define GEDIT_MAX_PATH_LEN  2048
+#endif
+
+#define GEDIT_DOCUMENT_GET_PRIVATE(object)(G_TYPE_INSTANCE_GET_PRIVATE ((object), GEDIT_TYPE_DOCUMENT, GeditDocumentPrivate))
+
+static void	gedit_document_load_real	(GeditDocument          *doc,
+						 const gchar            *uri,
+						 const GeditEncoding    *encoding,
+						 gint                    line_pos,
+						 gboolean                create);
+static void	gedit_document_save_real	(GeditDocument          *doc,
+						 const gchar            *uri,
+						 const GeditEncoding    *encoding,
+						 GeditDocumentSaveFlags  flags);
+static void	to_search_region_range 		(GeditDocument *doc,
+						 GtkTextIter   *start, 
+						 GtkTextIter   *end);
+static void 	insert_text_cb		 	(GeditDocument *doc, 
+						 GtkTextIter   *pos,
+						 const gchar   *text, 
+						 gint           length);
+						 
+static void	delete_range_cb 		(GeditDocument *doc, 
+						 GtkTextIter   *start,
+						 GtkTextIter   *end);
+			     
+struct _GeditDocumentPrivate
+{
+	gchar	    *uri;
+	gint 	     untitled_number;
+	gchar       *short_name;
+
+	GFileInfo   *metadata_info;
+
+	const GeditEncoding *encoding;
+
+	gchar	    *content_type;
+
+	GTimeVal     mtime;
+	GTimeVal     time_of_last_save_or_load;
+
+	guint        search_flags;
+	gchar       *search_text;
+	gint	     num_of_lines_search_text;
+
+	GeditDocumentNewlineType newline_type;
+
+	/* Temp data while loading */
+	GeditDocumentLoader *loader;
+	gboolean             create; /* Create file if uri points 
+	                              * to a non existing file */
+	const GeditEncoding *requested_encoding;
+	gint                 requested_line_pos;
+
+	/* Saving stuff */
+	GeditDocumentSaver *saver;
+
+	/* Search highlighting support variables */
+	GeditTextRegion *to_search_region;
+	GtkTextTag      *found_tag;
+
+	/* Mount operation factory */
+	GeditMountOperationFactory  mount_operation_factory;
+	gpointer		    mount_operation_userdata;
+
+	gint readonly : 1;
+	gint last_save_was_manually : 1; 
+	gint language_set_by_user : 1;
+	gint stop_cursor_moved_emission : 1;
+	gint dispose_has_run : 1;
+};
+
+enum {
+	PROP_0,
+
+	PROP_URI,
+	PROP_SHORTNAME,
+	PROP_CONTENT_TYPE,
+	PROP_MIME_TYPE,
+	PROP_READ_ONLY,
+	PROP_ENCODING,
+	PROP_CAN_SEARCH_AGAIN,
+	PROP_ENABLE_SEARCH_HIGHLIGHTING,
+	PROP_NEWLINE_TYPE
+};
+
+enum {
+	CURSOR_MOVED,
+	LOAD,
+	LOADING,
+	LOADED,
+	SAVE,
+	SAVING,
+	SAVED,
+	SEARCH_HIGHLIGHT_UPDATED,
+	LAST_SIGNAL
+};
+
+static guint document_signals[LAST_SIGNAL] = { 0 };
+
+G_DEFINE_TYPE(GeditDocument, gedit_document, GTK_TYPE_SOURCE_BUFFER)
+
+GQuark
+gedit_document_error_quark (void)
+{
+	static GQuark quark = 0;
+
+	if (G_UNLIKELY (quark == 0))
+		quark = g_quark_from_static_string ("gedit_io_load_error");
+
+	return quark;
+}
+
+static GHashTable *allocated_untitled_numbers = NULL;
+
+static gint
+get_untitled_number (void)
+{
+	gint i = 1;
+
+	if (allocated_untitled_numbers == NULL)
+		allocated_untitled_numbers = g_hash_table_new (NULL, NULL);
+
+	g_return_val_if_fail (allocated_untitled_numbers != NULL, -1);
+
+	while (TRUE)
+	{
+		if (g_hash_table_lookup (allocated_untitled_numbers, GINT_TO_POINTER (i)) == NULL)
+		{
+			g_hash_table_insert (allocated_untitled_numbers, 
+					     GINT_TO_POINTER (i),
+					     GINT_TO_POINTER (i));
+
+			return i;
+		}
+
+		++i;
+	}
+}
+
+static void
+release_untitled_number (gint n)
+{
+	g_return_if_fail (allocated_untitled_numbers != NULL);
+
+	g_hash_table_remove (allocated_untitled_numbers, GINT_TO_POINTER (n));
+}
+
+static void
+gedit_document_dispose (GObject *object)
+{
+	GeditDocument *doc = GEDIT_DOCUMENT (object); 
+
+	gedit_debug (DEBUG_DOCUMENT);
+
+	/* Metadata must be saved here and not in finalize
+	 * because the language is gone by the time finalize runs.
+	 * beside if some plugin prevents proper finalization by
+	 * holding a ref to the doc, we still save the metadata */
+	if ((!doc->priv->dispose_has_run) && (doc->priv->uri != NULL))
+	{
+		GtkTextIter iter;
+		gchar *position;
+		const gchar *language = NULL;
+
+		if (doc->priv->language_set_by_user)
+		{
+			GtkSourceLanguage *lang;
+
+			lang = gedit_document_get_language (doc);
+
+			if (lang == NULL)
+				language = "_NORMAL_";
+			else
+				language = gtk_source_language_get_id (lang);
+		}
+
+		gtk_text_buffer_get_iter_at_mark (
+				GTK_TEXT_BUFFER (doc),
+				&iter,
+				gtk_text_buffer_get_insert (GTK_TEXT_BUFFER (doc)));
+
+		position = g_strdup_printf ("%d", 
+					    gtk_text_iter_get_offset (&iter));
+
+		if (language == NULL)
+			gedit_document_set_metadata (doc, GEDIT_METADATA_ATTRIBUTE_POSITION,
+						     position, NULL);
+		else
+			gedit_document_set_metadata (doc, GEDIT_METADATA_ATTRIBUTE_POSITION,
+						     position, GEDIT_METADATA_ATTRIBUTE_LANGUAGE,
+						     language, NULL);
+		g_free (position);
+	}
+
+	if (doc->priv->loader)
+	{
+		g_object_unref (doc->priv->loader);
+		doc->priv->loader = NULL;
+	}
+
+	if (doc->priv->metadata_info != NULL)
+	{
+		g_object_unref (doc->priv->metadata_info);
+		doc->priv->metadata_info = NULL;
+	}
+
+	doc->priv->dispose_has_run = TRUE;
+
+	G_OBJECT_CLASS (gedit_document_parent_class)->dispose (object);
+}
+
+static void
+gedit_document_finalize (GObject *object)
+{
+	GeditDocument *doc = GEDIT_DOCUMENT (object); 
+
+	gedit_debug (DEBUG_DOCUMENT);
+
+	if (doc->priv->untitled_number > 0)
+	{
+		g_return_if_fail (doc->priv->uri == NULL);
+		release_untitled_number (doc->priv->untitled_number);
+	}
+
+	g_free (doc->priv->uri);
+	g_free (doc->priv->content_type);
+	g_free (doc->priv->search_text);
+
+	if (doc->priv->to_search_region != NULL)
+	{
+		/* we can't delete marks if we're finalizing the buffer */
+		gedit_text_region_destroy (doc->priv->to_search_region, FALSE);
+	}
+
+	G_OBJECT_CLASS (gedit_document_parent_class)->finalize (object);
+}
+
+static void
+gedit_document_get_property (GObject    *object,
+			     guint       prop_id,
+			     GValue     *value,
+			     GParamSpec *pspec)
+{
+	GeditDocument *doc = GEDIT_DOCUMENT (object);
+
+	switch (prop_id)
+	{
+		case PROP_URI:
+			g_value_set_string (value, doc->priv->uri);
+			break;
+		case PROP_SHORTNAME:
+			g_value_take_string (value, gedit_document_get_short_name_for_display (doc));
+			break;
+		case PROP_CONTENT_TYPE:
+			g_value_take_string (value, gedit_document_get_content_type (doc));
+			break;
+		case PROP_MIME_TYPE:
+			g_value_take_string (value, gedit_document_get_mime_type (doc));
+			break;
+		case PROP_READ_ONLY:
+			g_value_set_boolean (value, doc->priv->readonly);
+			break;
+		case PROP_ENCODING:
+			g_value_set_boxed (value, doc->priv->encoding);
+			break;
+		case PROP_CAN_SEARCH_AGAIN:
+			g_value_set_boolean (value, gedit_document_get_can_search_again (doc));
+			break;
+		case PROP_ENABLE_SEARCH_HIGHLIGHTING:
+			g_value_set_boolean (value, gedit_document_get_enable_search_highlighting (doc));
+			break;
+		case PROP_NEWLINE_TYPE:
+			g_value_set_enum (value, doc->priv->newline_type);
+			break;
+		default:
+			G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+			break;
+	}
+}
+
+static void
+gedit_document_set_property (GObject      *object,
+			     guint         prop_id,
+			     const GValue *value,
+			     GParamSpec   *pspec)
+{
+	GeditDocument *doc = GEDIT_DOCUMENT (object);
+
+	switch (prop_id)
+	{
+		case PROP_ENABLE_SEARCH_HIGHLIGHTING:
+			gedit_document_set_enable_search_highlighting (doc,
+								       g_value_get_boolean (value));
+			break;
+		case PROP_NEWLINE_TYPE:
+			gedit_document_set_newline_type (doc,
+							 g_value_get_enum (value));
+			break;
+		case PROP_SHORTNAME:
+			gedit_document_set_short_name_for_display (doc,
+			                                           g_value_get_string (value));
+			break;
+		case PROP_CONTENT_TYPE:
+			gedit_document_set_content_type (doc,
+			                                 g_value_get_string (value));
+			break;
+		default:
+			G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+			break;
+	}
+}
+
+static void
+emit_cursor_moved (GeditDocument *doc)
+{
+	if (!doc->priv->stop_cursor_moved_emission)
+	{
+		g_signal_emit (doc,
+			       document_signals[CURSOR_MOVED],
+			       0);
+	}
+}
+
+static void
+gedit_document_mark_set (GtkTextBuffer     *buffer,
+                         const GtkTextIter *iter,
+                         GtkTextMark       *mark)
+{
+	GeditDocument *doc = GEDIT_DOCUMENT (buffer);
+
+	if (GTK_TEXT_BUFFER_CLASS (gedit_document_parent_class)->mark_set)
+		GTK_TEXT_BUFFER_CLASS (gedit_document_parent_class)->mark_set (buffer,
+									       iter,
+									       mark);
+
+	if (mark == gtk_text_buffer_get_insert (buffer))
+	{
+		emit_cursor_moved (doc);
+	}
+}
+
+static void
+gedit_document_changed (GtkTextBuffer *buffer)
+{
+	emit_cursor_moved (GEDIT_DOCUMENT (buffer));
+
+	GTK_TEXT_BUFFER_CLASS (gedit_document_parent_class)->changed (buffer);
+}
+
+static void 
+gedit_document_class_init (GeditDocumentClass *klass)
+{
+	GObjectClass *object_class = G_OBJECT_CLASS (klass);
+	GtkTextBufferClass *buf_class = GTK_TEXT_BUFFER_CLASS (klass);
+
+	object_class->dispose = gedit_document_dispose;
+	object_class->finalize = gedit_document_finalize;
+	object_class->get_property = gedit_document_get_property;
+	object_class->set_property = gedit_document_set_property;
+
+	buf_class->mark_set = gedit_document_mark_set;
+	buf_class->changed = gedit_document_changed;
+
+	klass->load = gedit_document_load_real;
+	klass->save = gedit_document_save_real;
+
+	g_object_class_install_property (object_class, PROP_URI,
+					 g_param_spec_string ("uri",
+							      "URI",
+							      "The document's URI",
+							      NULL,
+							      G_PARAM_READABLE |
+							      G_PARAM_STATIC_STRINGS));
+
+	g_object_class_install_property (object_class, PROP_SHORTNAME,
+					 g_param_spec_string ("shortname",
+							      "Short Name",
+							      "The document's short name",
+							      NULL,
+							      G_PARAM_READWRITE |
+							      G_PARAM_STATIC_STRINGS));
+
+	g_object_class_install_property (object_class, PROP_CONTENT_TYPE,
+					 g_param_spec_string ("content-type",
+							      "Content Type",
+							      "The document's Content Type",
+							      NULL,
+							      G_PARAM_READWRITE |
+							      G_PARAM_STATIC_STRINGS));
+
+	g_object_class_install_property (object_class, PROP_MIME_TYPE,
+					 g_param_spec_string ("mime-type",
+							      "MIME Type",
+							      "The document's MIME Type",
+							      "text/plain",
+							      G_PARAM_READABLE |
+							      G_PARAM_STATIC_STRINGS));
+
+	g_object_class_install_property (object_class, PROP_READ_ONLY,
+					 g_param_spec_boolean ("read-only",
+							       "Read Only",
+							       "Whether the document is read only or not",
+							       FALSE,
+							       G_PARAM_READABLE |
+							       G_PARAM_STATIC_STRINGS));
+
+	g_object_class_install_property (object_class, PROP_ENCODING,
+					 g_param_spec_boxed ("encoding",
+							     "Encoding",
+							     "The GeditEncoding used for the document",
+							     GEDIT_TYPE_ENCODING,
+							     G_PARAM_READABLE |
+							     G_PARAM_STATIC_STRINGS));
+
+	g_object_class_install_property (object_class, PROP_CAN_SEARCH_AGAIN,
+					 g_param_spec_boolean ("can-search-again",
+							       "Can search again",
+							       "Wheter it's possible to search again in the document",
+							       FALSE,
+							       G_PARAM_READABLE |
+							       G_PARAM_STATIC_STRINGS));
+
+	g_object_class_install_property (object_class, PROP_ENABLE_SEARCH_HIGHLIGHTING,
+					 g_param_spec_boolean ("enable-search-highlighting",
+							       "Enable Search Highlighting",
+							       "Whether all the occurences of the searched string must be highlighted",
+							       FALSE,
+							       G_PARAM_READWRITE |
+							       G_PARAM_STATIC_STRINGS));
+
+	/**
+	 * GeditDocument:newline-type:
+	 *
+	 * The :newline-type property determines what is considered
+	 * as a line ending when saving the document
+	 */
+	g_object_class_install_property (object_class, PROP_NEWLINE_TYPE,
+	                                 g_param_spec_enum ("newline-type",
+	                                                    "Newline type",
+	                                                    "The accepted types of line ending",
+	                                                    GEDIT_TYPE_DOCUMENT_NEWLINE_TYPE,
+	                                                    GEDIT_DOCUMENT_NEWLINE_TYPE_LF,
+	                                                    G_PARAM_READWRITE |
+	                                                    G_PARAM_STATIC_NAME |
+	                                                    G_PARAM_STATIC_BLURB));
+
+	/* This signal is used to update the cursor position is the statusbar,
+	 * it's emitted either when the insert mark is moved explicitely or
+	 * when the buffer changes (insert/delete).
+	 * We prevent the emission of the signal during replace_all to 
+	 * improve performance.
+	 */
+	document_signals[CURSOR_MOVED] =
+   		g_signal_new ("cursor-moved",
+			      G_OBJECT_CLASS_TYPE (object_class),
+			      G_SIGNAL_RUN_LAST,
+			      G_STRUCT_OFFSET (GeditDocumentClass, cursor_moved),
+			      NULL, NULL,
+			      g_cclosure_marshal_VOID__VOID,
+			      G_TYPE_NONE,
+			      0);
+
+	/**
+	 * GeditDocument::load:
+	 * @document: the #GeditDocument.
+	 * @uri: the uri where to load the document from.
+	 * @encoding: the #GeditEncoding to encode the document.
+	 * @line_pos: the line to show.
+	 * @create: whether the document should be created if it doesn't exist.
+	 *
+	 * The "load" signal is emitted when a document is loaded.
+	 *
+	 * Since: 2.22
+	 */
+	document_signals[LOAD] =
+		g_signal_new ("load",
+			      G_OBJECT_CLASS_TYPE (object_class),
+			      G_SIGNAL_RUN_LAST,
+			      G_STRUCT_OFFSET (GeditDocumentClass, load),
+			      NULL, NULL,
+			      gedit_marshal_VOID__STRING_BOXED_INT_BOOLEAN,
+			      G_TYPE_NONE,
+			      4,
+			      G_TYPE_STRING,
+			      /* we rely on the fact that the GeditEncoding pointer stays
+			       * the same forever */
+			      GEDIT_TYPE_ENCODING | G_SIGNAL_TYPE_STATIC_SCOPE,
+			      G_TYPE_INT,
+			      G_TYPE_BOOLEAN);
+
+
+	document_signals[LOADING] =
+		g_signal_new ("loading",
+			      G_OBJECT_CLASS_TYPE (object_class),
+			      G_SIGNAL_RUN_LAST,
+			      G_STRUCT_OFFSET (GeditDocumentClass, loading),
+			      NULL, NULL,
+			      gedit_marshal_VOID__UINT64_UINT64,
+			      G_TYPE_NONE,
+			      2,
+			      G_TYPE_UINT64,
+			      G_TYPE_UINT64);
+
+	document_signals[LOADED] =
+   		g_signal_new ("loaded",
+			      G_OBJECT_CLASS_TYPE (object_class),
+			      G_SIGNAL_RUN_LAST,
+			      G_STRUCT_OFFSET (GeditDocumentClass, loaded),
+			      NULL, NULL,
+			      g_cclosure_marshal_VOID__POINTER,
+			      G_TYPE_NONE,
+			      1,
+			      G_TYPE_POINTER);
+
+	/**
+	 * GeditDocument::save:
+	 * @document: the #GeditDocument.
+	 * @uri: the uri where the document is about to be saved.
+	 * @encoding: the #GeditEncoding used to save the document.
+	 * @flags: the #GeditDocumentSaveFlags for the save operation.
+	 *
+	 * The "save" signal is emitted when the document is saved.
+	 *
+	 * Since: 2.20
+	 */
+	document_signals[SAVE] =
+		g_signal_new ("save",
+			      G_OBJECT_CLASS_TYPE (object_class),
+			      G_SIGNAL_RUN_LAST,
+			      G_STRUCT_OFFSET (GeditDocumentClass, save),
+			      NULL, NULL,
+			      gedit_marshal_VOID__STRING_BOXED_FLAGS,
+			      G_TYPE_NONE,
+			      3,
+			      G_TYPE_STRING,
+			      /* we rely on the fact that the GeditEncoding pointer stays
+			       * the same forever */
+			      GEDIT_TYPE_ENCODING | G_SIGNAL_TYPE_STATIC_SCOPE,
+			      GEDIT_TYPE_DOCUMENT_SAVE_FLAGS);
+
+	document_signals[SAVING] =
+   		g_signal_new ("saving",
+			      G_OBJECT_CLASS_TYPE (object_class),
+			      G_SIGNAL_RUN_LAST,
+			      G_STRUCT_OFFSET (GeditDocumentClass, saving),
+			      NULL, NULL,
+			      gedit_marshal_VOID__UINT64_UINT64,
+			      G_TYPE_NONE,
+			      2,
+			      G_TYPE_UINT64,
+			      G_TYPE_UINT64);
+
+	document_signals[SAVED] =
+   		g_signal_new ("saved",
+			      G_OBJECT_CLASS_TYPE (object_class),
+			      G_SIGNAL_RUN_LAST,
+			      G_STRUCT_OFFSET (GeditDocumentClass, saved),
+			      NULL, NULL,
+			      g_cclosure_marshal_VOID__POINTER,
+			      G_TYPE_NONE,
+			      1,
+			      G_TYPE_POINTER);
+
+	document_signals[SEARCH_HIGHLIGHT_UPDATED] =
+	    	g_signal_new ("search_highlight_updated",
+			      G_OBJECT_CLASS_TYPE (object_class),
+			      G_SIGNAL_RUN_LAST,
+			      G_STRUCT_OFFSET (GeditDocumentClass, search_highlight_updated),
+			      NULL, NULL,
+			      gedit_marshal_VOID__BOXED_BOXED,
+			      G_TYPE_NONE, 
+			      2, 
+			      GTK_TYPE_TEXT_ITER | G_SIGNAL_TYPE_STATIC_SCOPE,
+			      GTK_TYPE_TEXT_ITER | G_SIGNAL_TYPE_STATIC_SCOPE);
+
+	g_type_class_add_private (object_class, sizeof(GeditDocumentPrivate));
+}
+
+static void
+set_language (GeditDocument     *doc, 
+              GtkSourceLanguage *lang,
+              gboolean           set_by_user)
+{
+	GtkSourceLanguage *old_lang;
+
+	gedit_debug (DEBUG_DOCUMENT);
+	
+	old_lang = gtk_source_buffer_get_language (GTK_SOURCE_BUFFER (doc));
+	
+	if (old_lang == lang)
+		return;
+
+	gtk_source_buffer_set_language (GTK_SOURCE_BUFFER (doc), lang);
+
+	if (lang != NULL)
+		gtk_source_buffer_set_highlight_syntax (GTK_SOURCE_BUFFER (doc),
+				 gedit_prefs_manager_get_enable_syntax_highlighting ());
+	else
+		gtk_source_buffer_set_highlight_syntax (GTK_SOURCE_BUFFER (doc), 
+				 FALSE);
+
+	if (set_by_user && (doc->priv->uri != NULL))
+	{
+		gedit_document_set_metadata (doc, GEDIT_METADATA_ATTRIBUTE_LANGUAGE,
+			(lang == NULL) ? "_NORMAL_" : gtk_source_language_get_id (lang),
+			NULL);
+	}
+
+	doc->priv->language_set_by_user = set_by_user;
+}
+
+static void
+set_encoding (GeditDocument       *doc, 
+	      const GeditEncoding *encoding,
+	      gboolean             set_by_user)
+{
+	g_return_if_fail (encoding != NULL);
+
+	gedit_debug (DEBUG_DOCUMENT);
+
+	if (doc->priv->encoding == encoding)
+		return;
+
+	doc->priv->encoding = encoding;
+
+	if (set_by_user)
+	{
+		const gchar *charset;
+
+		charset = gedit_encoding_get_charset (encoding);
+
+		gedit_document_set_metadata (doc, GEDIT_METADATA_ATTRIBUTE_ENCODING,
+					     charset, NULL);
+	}
+
+	g_object_notify (G_OBJECT (doc), "encoding");
+}
+
+static GtkSourceStyleScheme *
+get_default_style_scheme (void)
+{
+	gchar *scheme_id;
+	GtkSourceStyleScheme *def_style;
+	GtkSourceStyleSchemeManager *manager;
+
+	manager = gedit_get_style_scheme_manager ();
+	scheme_id = gedit_prefs_manager_get_source_style_scheme ();
+	def_style = gtk_source_style_scheme_manager_get_scheme (manager,
+								scheme_id);
+
+	if (def_style == NULL)
+	{
+		g_warning ("Default style scheme '%s' cannot be found, falling back to 'classic' style scheme ", scheme_id);
+
+		def_style = gtk_source_style_scheme_manager_get_scheme (manager, "classic");
+		if (def_style == NULL) 
+		{
+			g_warning ("Style scheme 'classic' cannot be found, check your GtkSourceView installation.");			
+		}
+	}
+
+	g_free (scheme_id);
+
+	return def_style;
+}
+
+static void
+on_uri_changed (GeditDocument *doc,
+		GParamSpec    *pspec,
+		gpointer       useless)
+{
+#ifdef ENABLE_GVFS_METADATA
+	GFile *location;
+
+	location = gedit_document_get_location (doc);
+
+	/* load metadata for this uri: we load sync since metadata is
+	 * always local so it should be fast and we need the information
+	 * right after the uri was set.
+	 */
+	if (location != NULL)
+	{
+		GError *error = NULL;
+
+		if (doc->priv->metadata_info != NULL)
+			g_object_unref (doc->priv->metadata_info);
+
+		doc->priv->metadata_info = g_file_query_info (location,
+							      METADATA_QUERY,
+							      G_FILE_QUERY_INFO_NONE,
+							      NULL,
+							      &error);
+
+		if (error != NULL)
+		{
+			if (error->code != G_FILE_ERROR_ISDIR &&
+			    error->code != G_FILE_ERROR_NOTDIR &&
+			    error->code != G_FILE_ERROR_NOENT)
+			{
+				g_warning ("%s", error->message);
+			}
+
+			g_error_free (error);
+		}
+
+		g_object_unref (location);
+	}
+#endif
+}
+
+static GtkSourceLanguage *
+guess_language (GeditDocument *doc,
+		const gchar   *content_type)
+{
+	gchar *data;
+	GtkSourceLanguage *language = NULL;
+
+	data = gedit_document_get_metadata (doc, GEDIT_METADATA_ATTRIBUTE_LANGUAGE);
+
+	if (data != NULL)
+	{
+		gedit_debug_message (DEBUG_DOCUMENT, "Language from metadata: %s", data);
+
+		if (strcmp (data, "_NORMAL_") != 0)
+		{
+			language = gtk_source_language_manager_get_language (
+						gedit_get_language_manager (),
+						data);
+		}
+
+		g_free (data);
+	}
+	else
+	{
+		GFile *file;
+		gchar *basename = NULL;
+
+		file = gedit_document_get_location (doc);
+		gedit_debug_message (DEBUG_DOCUMENT, "Sniffing Language");
+
+		if (file)
+		{
+			basename = g_file_get_basename (file);
+		}
+		else if (doc->priv->short_name != NULL)
+		{
+			basename = g_strdup (doc->priv->short_name);
+		}
+
+		language = gtk_source_language_manager_guess_language (
+					gedit_get_language_manager (),
+					basename,
+					content_type);
+
+		g_free (basename);
+
+		if (file != NULL)
+		{
+			g_object_unref (file);
+		}
+	}
+
+	return language;
+}
+
+static void
+on_content_type_changed (GeditDocument *doc,
+			 GParamSpec    *pspec,
+			 gpointer       useless)
+{
+	if (!doc->priv->language_set_by_user)
+	{
+		GtkSourceLanguage *language;
+
+		language = guess_language (doc, doc->priv->content_type);
+
+		gedit_debug_message (DEBUG_DOCUMENT, "Language: %s",
+				     language != NULL ? gtk_source_language_get_name (language) : "None");
+
+		set_language (doc, language, FALSE);
+	}
+}
+
+static gchar *
+get_default_content_type (void)
+{
+	return g_content_type_from_mime_type ("text/plain");
+}
+
+static void
+gedit_document_init (GeditDocument *doc)
+{
+	GtkSourceStyleScheme *style_scheme;
+
+	gedit_debug (DEBUG_DOCUMENT);
+
+	doc->priv = GEDIT_DOCUMENT_GET_PRIVATE (doc);
+
+	doc->priv->uri = NULL;
+	doc->priv->untitled_number = get_untitled_number ();
+
+	doc->priv->metadata_info = NULL;
+
+	doc->priv->content_type = get_default_content_type ();
+
+	doc->priv->readonly = FALSE;
+
+	doc->priv->stop_cursor_moved_emission = FALSE;
+
+	doc->priv->last_save_was_manually = TRUE;
+	doc->priv->language_set_by_user = FALSE;
+
+	doc->priv->dispose_has_run = FALSE;
+
+	doc->priv->mtime.tv_sec = 0;
+	doc->priv->mtime.tv_usec = 0;
+
+	g_get_current_time (&doc->priv->time_of_last_save_or_load);
+
+	doc->priv->encoding = gedit_encoding_get_utf8 ();
+
+	doc->priv->newline_type = GEDIT_DOCUMENT_NEWLINE_TYPE_DEFAULT;
+
+	gtk_source_buffer_set_max_undo_levels (GTK_SOURCE_BUFFER (doc), 
+					       gedit_prefs_manager_get_undo_actions_limit ());
+
+	gtk_source_buffer_set_highlight_matching_brackets (GTK_SOURCE_BUFFER (doc), 
+							   gedit_prefs_manager_get_bracket_matching ());
+
+	gedit_document_set_enable_search_highlighting (doc,
+						       gedit_prefs_manager_get_enable_search_highlighting ());
+
+	style_scheme = get_default_style_scheme ();
+	if (style_scheme != NULL)
+		gtk_source_buffer_set_style_scheme (GTK_SOURCE_BUFFER (doc),
+						    style_scheme);
+
+	g_signal_connect_after (doc, 
+			  	"insert-text",
+			  	G_CALLBACK (insert_text_cb),
+			  	NULL);
+
+	g_signal_connect_after (doc, 
+			  	"delete-range",
+			  	G_CALLBACK (delete_range_cb),
+			  	NULL);
+
+	g_signal_connect (doc,
+			  "notify::content-type",
+			  G_CALLBACK (on_content_type_changed),
+			  NULL);
+
+	g_signal_connect (doc,
+			  "notify::uri",
+			  G_CALLBACK (on_uri_changed),
+			  NULL);
+}
+
+GeditDocument *
+gedit_document_new (void)
+{
+	gedit_debug (DEBUG_DOCUMENT);
+
+	return GEDIT_DOCUMENT (g_object_new (GEDIT_TYPE_DOCUMENT, NULL));
+}
+
+static void
+set_content_type_no_guess (GeditDocument *doc,
+			   const gchar   *content_type)
+{
+	gedit_debug (DEBUG_DOCUMENT);
+
+	if (doc->priv->content_type != NULL && content_type != NULL &&
+	    (0 == strcmp (doc->priv->content_type, content_type)))
+		return;
+
+	g_free (doc->priv->content_type);
+
+	if (content_type == NULL || g_content_type_is_unknown (content_type))
+		doc->priv->content_type = get_default_content_type ();
+	else
+		doc->priv->content_type = g_strdup (content_type);
+
+	g_object_notify (G_OBJECT (doc), "content-type");
+}
+
+static void
+set_content_type (GeditDocument *doc,
+		  const gchar   *content_type)
+{
+	gedit_debug (DEBUG_DOCUMENT);
+
+	if (content_type == NULL)
+	{
+		GFile *file;
+		gchar *guessed_type = NULL;
+
+		/* If content type is null, we guess from the filename */
+		file = gedit_document_get_location (doc);
+		if (file != NULL)
+		{
+			gchar *basename;
+
+			basename = g_file_get_basename (file);
+			guessed_type = g_content_type_guess (basename, NULL, 0, NULL);
+
+			g_free (basename);
+			g_object_unref (file);
+		}
+
+		set_content_type_no_guess (doc, guessed_type);
+
+		g_free (guessed_type);
+	}
+	else
+	{
+		set_content_type_no_guess (doc, content_type);
+	}
+}
+
+void
+gedit_document_set_content_type (GeditDocument *doc,
+                                 const gchar   *content_type)
+{
+	g_return_if_fail (GEDIT_IS_DOCUMENT (doc));
+
+	set_content_type (doc, content_type);
+}
+
+static void
+set_uri (GeditDocument *doc,
+	 const gchar   *uri)
+{
+	gedit_debug (DEBUG_DOCUMENT);
+
+	g_return_if_fail ((uri == NULL) || gedit_utils_is_valid_uri (uri));
+
+	if (uri != NULL)
+	{
+		if (doc->priv->uri == uri)
+			return;
+
+		g_free (doc->priv->uri);
+		doc->priv->uri = g_strdup (uri);
+
+		if (doc->priv->untitled_number > 0)
+		{
+			release_untitled_number (doc->priv->untitled_number);
+			doc->priv->untitled_number = 0;
+		}
+	}
+
+	g_object_notify (G_OBJECT (doc), "uri");
+
+	if (doc->priv->short_name == NULL)
+	{
+		g_object_notify (G_OBJECT (doc), "shortname");
+	}
+}
+
+GFile *
+gedit_document_get_location (GeditDocument *doc)
+{
+	g_return_val_if_fail (GEDIT_IS_DOCUMENT (doc), NULL);
+
+	return doc->priv->uri == NULL ? NULL : g_file_new_for_uri (doc->priv->uri);
+}
+
+gchar *
+gedit_document_get_uri (GeditDocument *doc)
+{
+	g_return_val_if_fail (GEDIT_IS_DOCUMENT (doc), NULL);
+
+	return g_strdup (doc->priv->uri);
+}
+
+void
+gedit_document_set_uri (GeditDocument *doc,
+			const gchar   *uri)
+{
+	g_return_if_fail (GEDIT_IS_DOCUMENT (doc));
+	g_return_if_fail (uri != NULL);
+
+	set_uri (doc, uri);
+	set_content_type (doc, NULL);
+}
+
+/* Never returns NULL */
+gchar *
+gedit_document_get_uri_for_display (GeditDocument *doc)
+{
+	g_return_val_if_fail (GEDIT_IS_DOCUMENT (doc), g_strdup (""));
+
+	if (doc->priv->uri == NULL)
+		return g_strdup_printf (_("Unsaved Document %d"),
+					doc->priv->untitled_number);
+	else
+		return gedit_utils_uri_for_display (doc->priv->uri);
+}
+
+/* Never returns NULL */
+gchar *
+gedit_document_get_short_name_for_display (GeditDocument *doc)
+{
+	g_return_val_if_fail (GEDIT_IS_DOCUMENT (doc), g_strdup (""));
+
+	if (doc->priv->short_name != NULL)
+		return g_strdup (doc->priv->short_name);
+	else if (doc->priv->uri == NULL)
+		return g_strdup_printf (_("Unsaved Document %d"),
+					doc->priv->untitled_number);
+	else
+		return gedit_utils_basename_for_display (doc->priv->uri);
+}
+
+void
+gedit_document_set_short_name_for_display (GeditDocument *doc,
+                                           const gchar   *short_name)
+{
+	g_return_if_fail (GEDIT_IS_DOCUMENT (doc));
+
+	g_free (doc->priv->short_name);
+	doc->priv->short_name = g_strdup (short_name);
+
+	g_object_notify (G_OBJECT (doc), "shortname");
+}
+
+gchar *
+gedit_document_get_content_type (GeditDocument *doc)
+{
+	g_return_val_if_fail (GEDIT_IS_DOCUMENT (doc), NULL);
+
+ 	return g_strdup (doc->priv->content_type);
+}
+
+/* Never returns NULL */
+gchar *
+gedit_document_get_mime_type (GeditDocument *doc)
+{
+	gchar *mime_type = NULL;
+
+	g_return_val_if_fail (GEDIT_IS_DOCUMENT (doc), g_strdup ("text/plain"));
+
+	if ((doc->priv->content_type != NULL) &&
+	    (!g_content_type_is_unknown (doc->priv->content_type)))
+	{
+		mime_type = g_content_type_get_mime_type (doc->priv->content_type);
+	}
+
+ 	return mime_type != NULL ? mime_type : g_strdup ("text/plain");
+}
+
+/* Note: do not emit the notify::read-only signal */
+static gboolean
+set_readonly (GeditDocument *doc,
+	      gboolean       readonly)
+{
+	gedit_debug (DEBUG_DOCUMENT);
+
+	readonly = (readonly != FALSE);
+
+	if (doc->priv->readonly == readonly) 
+		return FALSE;
+
+	doc->priv->readonly = readonly;
+
+	return TRUE;
+}
+
+/**
+ * gedit_document_set_readonly:
+ * @doc: a #GeditDocument
+ * @readonly: %TRUE to se the document as read-only
+ *
+ * If @readonly is %TRUE sets @doc as read-only.
+ */
+void
+_gedit_document_set_readonly (GeditDocument *doc,
+			      gboolean       readonly)
+{
+	gedit_debug (DEBUG_DOCUMENT);
+
+	g_return_if_fail (GEDIT_IS_DOCUMENT (doc));
+
+	if (set_readonly (doc, readonly))
+	{
+		g_object_notify (G_OBJECT (doc), "read-only");
+	}
+}
+
+gboolean
+gedit_document_get_readonly (GeditDocument *doc)
+{
+	g_return_val_if_fail (GEDIT_IS_DOCUMENT (doc), TRUE);
+
+	return doc->priv->readonly;
+}
+
+gboolean
+_gedit_document_check_externally_modified (GeditDocument *doc)
+{
+	GFile *gfile;
+	GFileInfo *info;
+
+	g_return_val_if_fail (GEDIT_IS_DOCUMENT (doc), FALSE);
+
+	if (doc->priv->uri == NULL)
+	{
+		return FALSE;
+	}
+
+	gfile = g_file_new_for_uri (doc->priv->uri);
+	info = g_file_query_info (gfile,
+				  G_FILE_ATTRIBUTE_TIME_MODIFIED "," \
+				  G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE,
+				  G_FILE_QUERY_INFO_NONE,
+				  NULL, NULL);
+	g_object_unref (gfile);
+
+	if (info != NULL)
+	{
+		/* While at it also check if permissions changed */
+		if (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE))
+		{
+			gboolean read_only;
+
+			read_only = !g_file_info_get_attribute_boolean (info,
+									G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE);
+
+			_gedit_document_set_readonly (doc, read_only);
+		}
+
+		if (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_TIME_MODIFIED))
+		{
+			GTimeVal timeval;
+
+			g_file_info_get_modification_time (info, &timeval);
+			g_object_unref (info);
+	
+			return (timeval.tv_sec > doc->priv->mtime.tv_sec) ||
+			       (timeval.tv_sec == doc->priv->mtime.tv_sec && 
+			       timeval.tv_usec > doc->priv->mtime.tv_usec);
+		}
+	}
+
+	return FALSE;
+}
+
+static void
+reset_temp_loading_data (GeditDocument       *doc)
+{
+	/* the loader has been used, throw it away */
+	g_object_unref (doc->priv->loader);
+	doc->priv->loader = NULL;
+
+	doc->priv->requested_encoding = NULL;
+	doc->priv->requested_line_pos = 0;
+}
+
+static void
+document_loader_loaded (GeditDocumentLoader *loader,
+			const GError        *error,
+			GeditDocument       *doc)
+{
+	/* load was successful */
+	if (error == NULL ||
+	    (error->domain == GEDIT_DOCUMENT_ERROR &&
+	     error->code == GEDIT_DOCUMENT_ERROR_CONVERSION_FALLBACK))
+	{
+		GtkTextIter iter;
+		GFileInfo *info;
+		const gchar *content_type = NULL;
+		gboolean read_only = FALSE;
+		GTimeVal mtime = {0, 0};
+
+		info = gedit_document_loader_get_info (loader);
+
+		if (info)
+		{
+			if (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE))
+				content_type = g_file_info_get_attribute_string (info,
+										 G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE);
+
+			if (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_TIME_MODIFIED))
+				g_file_info_get_modification_time (info, &mtime);
+
+			if (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE))
+				read_only = !g_file_info_get_attribute_boolean (info,
+										G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE);
+		}
+
+		doc->priv->mtime = mtime;
+
+		set_readonly (doc, read_only);
+
+		g_get_current_time (&doc->priv->time_of_last_save_or_load);
+
+		set_encoding (doc, 
+			      gedit_document_loader_get_encoding (loader),
+			      (doc->priv->requested_encoding != NULL));
+
+		set_content_type (doc, content_type);
+
+		gedit_document_set_newline_type (doc,
+		                                 gedit_document_loader_get_newline_type (loader));
+
+		/* move the cursor at the requested line if any */
+		if (doc->priv->requested_line_pos > 0)
+		{
+			/* line_pos - 1 because get_iter_at_line counts from 0 */
+			gtk_text_buffer_get_iter_at_line (GTK_TEXT_BUFFER (doc),
+							  &iter,
+							  doc->priv->requested_line_pos - 1);
+		}
+		/* else, if enabled, to the position stored in the metadata */
+		else if (gedit_prefs_manager_get_restore_cursor_position ())
+		{
+			gchar *pos;
+			gint offset;
+
+			pos = gedit_document_get_metadata (doc, GEDIT_METADATA_ATTRIBUTE_POSITION);
+
+			offset = pos ? atoi (pos) : 0;
+			g_free (pos);
+
+			gtk_text_buffer_get_iter_at_offset (GTK_TEXT_BUFFER (doc),
+							    &iter,
+							    MAX (offset, 0));
+
+			/* make sure it's a valid position, if the file
+			 * changed we may have ended up in the middle of
+			 * a utf8 character cluster */
+			if (!gtk_text_iter_is_cursor_position (&iter))
+			{
+				gtk_text_buffer_get_start_iter (GTK_TEXT_BUFFER (doc),
+								&iter);
+			}
+		}
+		/* otherwise to the top */
+		else
+		{
+			gtk_text_buffer_get_start_iter (GTK_TEXT_BUFFER (doc),
+							&iter);
+		}
+
+		gtk_text_buffer_place_cursor (GTK_TEXT_BUFFER (doc), &iter);
+	}
+
+	/* special case creating a named new doc */
+	else if (doc->priv->create &&
+	         (error->domain == G_IO_ERROR && error->code == G_IO_ERROR_NOT_FOUND) &&
+	         (gedit_utils_uri_has_file_scheme (doc->priv->uri)))
+	{
+		reset_temp_loading_data (doc);
+
+		g_signal_emit (doc,
+			       document_signals[LOADED],
+			       0,
+			       NULL);
+
+		return;
+	}
+	
+	g_signal_emit (doc,
+		       document_signals[LOADED],
+		       0,
+		       error);
+
+	reset_temp_loading_data (doc);
+}
+
+static void
+document_loader_loading (GeditDocumentLoader *loader,
+			 gboolean             completed,
+			 const GError        *error,
+			 GeditDocument       *doc)
+{
+	if (completed)
+	{
+		document_loader_loaded (loader, error, doc);
+	}
+	else
+	{
+		goffset size = 0;
+		goffset read;
+		GFileInfo *info;
+
+		info = gedit_document_loader_get_info (loader);
+
+		if (info && g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_STANDARD_SIZE))
+			size = g_file_info_get_attribute_uint64 (info,
+								 G_FILE_ATTRIBUTE_STANDARD_SIZE);
+
+		read = gedit_document_loader_get_bytes_read (loader);
+
+		g_signal_emit (doc, 
+			       document_signals[LOADING],
+			       0,
+			       read,
+			       size);
+	}
+}
+
+static void
+gedit_document_load_real (GeditDocument       *doc,
+			  const gchar         *uri,
+			  const GeditEncoding *encoding,
+			  gint                 line_pos,
+			  gboolean             create)
+{
+	g_return_if_fail (doc->priv->loader == NULL);
+
+	gedit_debug_message (DEBUG_DOCUMENT, "load_real: uri = %s", uri);
+
+	/* create a loader. It will be destroyed when loading is completed */
+	doc->priv->loader = gedit_document_loader_new (doc, uri, encoding);
+
+	g_signal_connect (doc->priv->loader,
+			  "loading",
+			  G_CALLBACK (document_loader_loading),
+			  doc);
+
+	doc->priv->create = create;
+	doc->priv->requested_encoding = encoding;
+	doc->priv->requested_line_pos = line_pos;
+
+	set_uri (doc, uri);
+	set_content_type (doc, NULL);
+
+	gedit_document_loader_load (doc->priv->loader);
+}
+
+/**
+ * gedit_document_load:
+ * @doc: the #GeditDocument.
+ * @uri: the uri where to load the document from.
+ * @encoding: the #GeditEncoding to encode the document.
+ * @line_pos: the line to show.
+ * @create: whether the document should be created if it doesn't exist.
+ *
+ * Load a document. This results in the "load" signal to be emitted.
+ */
+void
+gedit_document_load (GeditDocument       *doc,
+		     const gchar         *uri,
+		     const GeditEncoding *encoding,
+		     gint                 line_pos,
+		     gboolean             create)
+{
+	g_return_if_fail (GEDIT_IS_DOCUMENT (doc));
+	g_return_if_fail (uri != NULL);
+	g_return_if_fail (gedit_utils_is_valid_uri (uri));
+
+	g_signal_emit (doc, document_signals[LOAD], 0, uri, encoding, line_pos, create);
+}
+
+/**
+ * gedit_document_load_cancel:
+ * @doc: the #GeditDocument.
+ *
+ * Cancel load of a document.
+ */
+gboolean
+gedit_document_load_cancel (GeditDocument *doc)
+{
+	g_return_val_if_fail (GEDIT_IS_DOCUMENT (doc), FALSE);
+
+	if (doc->priv->loader == NULL)
+		return FALSE;
+
+	return gedit_document_loader_cancel (doc->priv->loader);
+}
+
+static void
+document_saver_saving (GeditDocumentSaver *saver,
+		       gboolean            completed,
+		       const GError       *error,
+		       GeditDocument      *doc)
+{
+	gedit_debug (DEBUG_DOCUMENT);
+
+	if (completed)
+	{
+		/* save was successful */
+		if (error == NULL)
+		{
+			const gchar *uri;
+			const gchar *content_type = NULL;
+			GTimeVal mtime = {0, 0};
+			GFileInfo *info;
+
+			uri = gedit_document_saver_get_uri (saver);
+			set_uri (doc, uri);
+
+			info = gedit_document_saver_get_info (saver);
+
+			if (info != NULL)
+			{
+				if (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE))
+					content_type = g_file_info_get_attribute_string (info,
+											 G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE);
+
+				if (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_TIME_MODIFIED))
+					g_file_info_get_modification_time (info, &mtime);
+			}
+
+			set_content_type (doc, content_type);
+			doc->priv->mtime = mtime;
+
+			g_get_current_time (&doc->priv->time_of_last_save_or_load);
+
+			_gedit_document_set_readonly (doc, FALSE);
+
+			gtk_text_buffer_set_modified (GTK_TEXT_BUFFER (doc),
+						      FALSE);
+
+			set_encoding (doc, 
+				      doc->priv->requested_encoding, 
+				      TRUE);
+		}
+
+		g_signal_emit (doc,
+			       document_signals[SAVED],
+			       0,
+			       error);
+
+		/* the saver has been used, throw it away */
+		g_object_unref (doc->priv->saver);
+		doc->priv->saver = NULL;
+	}
+	else
+	{
+		goffset size = 0;
+		goffset written = 0;
+
+		size = gedit_document_saver_get_file_size (saver);
+		written = gedit_document_saver_get_bytes_written (saver);
+
+		gedit_debug_message (DEBUG_DOCUMENT, "save progress: %" G_GINT64_FORMAT " of %" G_GINT64_FORMAT, written, size);
+
+		g_signal_emit (doc,
+			       document_signals[SAVING],
+			       0,
+			       written,
+			       size);
+	}
+}
+
+static void
+gedit_document_save_real (GeditDocument          *doc,
+			  const gchar            *uri,
+			  const GeditEncoding    *encoding,
+			  GeditDocumentSaveFlags  flags)
+{
+	g_return_if_fail (doc->priv->saver == NULL);
+
+	/* create a saver, it will be destroyed once saving is complete */
+	doc->priv->saver = gedit_document_saver_new (doc, uri, encoding,
+						     doc->priv->newline_type,
+						     flags);
+
+	g_signal_connect (doc->priv->saver,
+			  "saving",
+			  G_CALLBACK (document_saver_saving),
+			  doc);
+
+	doc->priv->requested_encoding = encoding;
+
+	gedit_document_saver_save (doc->priv->saver,
+				   &doc->priv->mtime);
+}
+
+/**
+ * gedit_document_save:
+ * @doc: the #GeditDocument.
+ * @flags: optionnal #GeditDocumentSaveFlags.
+ *
+ * Save the document to its previous location. This results in the "save"
+ * signal to be emitted.
+ */
+void
+gedit_document_save (GeditDocument          *doc,
+		     GeditDocumentSaveFlags  flags)
+{
+	g_return_if_fail (GEDIT_IS_DOCUMENT (doc));
+	g_return_if_fail (doc->priv->uri != NULL);
+
+	g_signal_emit (doc,
+		       document_signals[SAVE],
+		       0,
+		       doc->priv->uri,
+		       doc->priv->encoding,
+		       flags);
+}
+
+/**
+ * gedit_document_save_as:
+ * @doc: the #GeditDocument.
+ * @uri: the uri where to save the document.
+ * @encoding: the #GeditEncoding to encode the document.
+ * @flags: optionnal #GeditDocumentSaveFlags.
+ *
+ * Save the document to a new location. This results in the "save" signal
+ * to be emitted.
+ */
+void
+gedit_document_save_as (GeditDocument          *doc,
+			const gchar            *uri,
+			const GeditEncoding    *encoding,
+			GeditDocumentSaveFlags  flags)
+{
+	g_return_if_fail (GEDIT_IS_DOCUMENT (doc));
+	g_return_if_fail (uri != NULL);
+	g_return_if_fail (encoding != NULL);
+
+	/* priv->mtime refers to the the old uri (if any). Thus, it should be
+	 * ignored when saving as. */
+	g_signal_emit (doc,
+		       document_signals[SAVE],
+		       0,
+		       uri,
+		       encoding,
+		       flags | GEDIT_DOCUMENT_SAVE_IGNORE_MTIME);
+}
+
+gboolean
+gedit_document_insert_file (GeditDocument       *doc,
+			    GtkTextIter         *iter,
+			    const gchar         *uri,
+			    const GeditEncoding *encoding)
+{
+	g_return_val_if_fail (GEDIT_IS_DOCUMENT (doc), FALSE);
+	g_return_val_if_fail (iter != NULL, FALSE);
+	g_return_val_if_fail (gtk_text_iter_get_buffer (iter) == 
+				GTK_TEXT_BUFFER (doc), FALSE);
+
+	/* TODO */
+
+	return FALSE;
+}
+
+gboolean	 
+gedit_document_is_untouched (GeditDocument *doc)
+{
+	g_return_val_if_fail (GEDIT_IS_DOCUMENT (doc), TRUE);
+
+	return (doc->priv->uri == NULL) && 
+		(!gtk_text_buffer_get_modified (GTK_TEXT_BUFFER (doc)));
+}
+
+gboolean 
+gedit_document_is_untitled (GeditDocument *doc)
+{
+	g_return_val_if_fail (GEDIT_IS_DOCUMENT (doc), TRUE);
+
+	return (doc->priv->uri == NULL);
+}
+
+gboolean
+gedit_document_is_local (GeditDocument *doc)
+{
+	g_return_val_if_fail (GEDIT_IS_DOCUMENT (doc), FALSE);
+
+	if (doc->priv->uri == NULL)
+	{
+		return FALSE;
+	}
+
+	return gedit_utils_uri_has_file_scheme (doc->priv->uri);
+}
+
+gboolean
+gedit_document_get_deleted (GeditDocument *doc)
+{
+	g_return_val_if_fail (GEDIT_IS_DOCUMENT (doc), FALSE);
+
+	return doc->priv->uri && !gedit_utils_uri_exists (doc->priv->uri);
+}
+
+/*
+ * If @line is bigger than the lines of the document, the cursor is moved
+ * to the last line and FALSE is returned.
+ */
+gboolean
+gedit_document_goto_line (GeditDocument *doc, 
+			  gint           line)
+{
+	gboolean ret = TRUE;
+	guint line_count;
+	GtkTextIter iter;
+
+	gedit_debug (DEBUG_DOCUMENT);
+
+	g_return_val_if_fail (GEDIT_IS_DOCUMENT (doc), FALSE);
+	g_return_val_if_fail (line >= -1, FALSE);
+
+	line_count = gtk_text_buffer_get_line_count (GTK_TEXT_BUFFER (doc));
+
+	if (line >= line_count)
+	{
+		ret = FALSE;
+		gtk_text_buffer_get_end_iter (GTK_TEXT_BUFFER (doc),
+					      &iter);
+	}
+	else
+	{
+		gtk_text_buffer_get_iter_at_line (GTK_TEXT_BUFFER (doc),
+						  &iter,
+						  line);
+	}
+
+	gtk_text_buffer_place_cursor (GTK_TEXT_BUFFER (doc), &iter);
+
+	return ret;
+}
+
+gboolean
+gedit_document_goto_line_offset (GeditDocument *doc,
+				 gint           line,
+				 gint           line_offset)
+{
+	gboolean ret = TRUE;
+	guint offset_count;
+	GtkTextIter iter;
+	
+	g_return_val_if_fail (GEDIT_IS_DOCUMENT (doc), FALSE);
+	g_return_val_if_fail (line >= -1, FALSE);
+	g_return_val_if_fail (line_offset >= -1, FALSE);
+	
+	gtk_text_buffer_get_iter_at_line (GTK_TEXT_BUFFER (doc),
+					  &iter,
+					  line);
+
+	offset_count = gtk_text_iter_get_chars_in_line (&iter);
+	if (line_offset > offset_count)
+	{
+		ret = FALSE;
+	}
+	else
+	{
+		gtk_text_iter_set_line_offset (&iter, line_offset);
+	}
+	
+	gtk_text_buffer_place_cursor (GTK_TEXT_BUFFER (doc), &iter);
+
+	return ret;
+}
+
+static gint
+compute_num_of_lines (const gchar *text)
+{
+	const gchar *p;
+	gint len;
+	gint n = 1;
+
+	g_return_val_if_fail (text != NULL, 0);
+
+	len = strlen (text);
+	p = text;
+
+	while (len > 0)
+	{
+		gint del, par;
+
+		pango_find_paragraph_boundary (p, len, &del, &par);
+
+		if (del == par) /* not found */
+			break;
+
+		p += par;
+		len -= par;
+		++n;
+	}
+
+	return n;
+}
+
+void
+gedit_document_set_search_text (GeditDocument *doc,
+				const gchar   *text,
+				guint          flags)
+{
+	gchar *converted_text;
+	gboolean notify = FALSE;
+	gboolean update_to_search_region = FALSE;
+	
+	g_return_if_fail (GEDIT_IS_DOCUMENT (doc));
+	g_return_if_fail ((text == NULL) || (doc->priv->search_text != text));
+	g_return_if_fail ((text == NULL) || g_utf8_validate (text, -1, NULL));
+
+	gedit_debug_message (DEBUG_DOCUMENT, "text = %s", text);
+
+	if (text != NULL)
+	{
+		if (*text != '\0')
+		{
+			converted_text = gedit_utils_unescape_search_text (text);
+			notify = !gedit_document_get_can_search_again (doc);
+		}
+		else
+		{
+			converted_text = g_strdup("");
+			notify = gedit_document_get_can_search_again (doc);
+		}
+		
+		g_free (doc->priv->search_text);
+	
+		doc->priv->search_text = converted_text;
+		doc->priv->num_of_lines_search_text = compute_num_of_lines (doc->priv->search_text);
+		update_to_search_region = TRUE;
+	}
+	
+	if (!GEDIT_SEARCH_IS_DONT_SET_FLAGS (flags))
+	{
+		if (doc->priv->search_flags != flags)
+			update_to_search_region = TRUE;
+			
+		doc->priv->search_flags = flags;
+
+	}
+
+	if (update_to_search_region)
+	{
+		GtkTextIter begin;
+		GtkTextIter end;
+		
+		gtk_text_buffer_get_bounds (GTK_TEXT_BUFFER (doc),
+					    &begin,
+					    &end);
+					    
+		to_search_region_range (doc,
+					&begin,
+					&end);
+	}
+	
+	if (notify)
+		g_object_notify (G_OBJECT (doc), "can-search-again");
+}
+
+gchar *
+gedit_document_get_search_text (GeditDocument *doc,
+				guint         *flags)
+{
+	g_return_val_if_fail (GEDIT_IS_DOCUMENT (doc), NULL);
+
+	if (flags != NULL)
+		*flags = doc->priv->search_flags;
+
+	return gedit_utils_escape_search_text (doc->priv->search_text);
+}
+
+gboolean
+gedit_document_get_can_search_again (GeditDocument *doc)
+{
+	g_return_val_if_fail (GEDIT_IS_DOCUMENT (doc), FALSE);
+
+	return ((doc->priv->search_text != NULL) && 
+	        (*doc->priv->search_text != '\0'));
+}
+
+gboolean
+gedit_document_search_forward (GeditDocument     *doc,
+			       const GtkTextIter *start,
+			       const GtkTextIter *end,
+			       GtkTextIter       *match_start,
+			       GtkTextIter       *match_end)
+{
+	GtkTextIter iter;
+	GtkSourceSearchFlags search_flags;
+	gboolean found = FALSE;
+	GtkTextIter m_start;
+	GtkTextIter m_end;
+	
+	g_return_val_if_fail (GEDIT_IS_DOCUMENT (doc), FALSE);
+	g_return_val_if_fail ((start == NULL) || 
+			      (gtk_text_iter_get_buffer (start) ==  GTK_TEXT_BUFFER (doc)), FALSE);
+	g_return_val_if_fail ((end == NULL) || 
+			      (gtk_text_iter_get_buffer (end) ==  GTK_TEXT_BUFFER (doc)), FALSE);
+	
+	if (doc->priv->search_text == NULL)
+	{
+		gedit_debug_message (DEBUG_DOCUMENT, "doc->priv->search_text == NULL\n");
+		return FALSE;
+	}
+	else
+		gedit_debug_message (DEBUG_DOCUMENT, "doc->priv->search_text == \"%s\"\n", doc->priv->search_text);
+				      
+	if (start == NULL)
+		gtk_text_buffer_get_start_iter (GTK_TEXT_BUFFER (doc), &iter);
+	else
+		iter = *start;
+		
+	search_flags = GTK_SOURCE_SEARCH_VISIBLE_ONLY | GTK_SOURCE_SEARCH_TEXT_ONLY;
+
+	if (!GEDIT_SEARCH_IS_CASE_SENSITIVE (doc->priv->search_flags))
+	{
+		search_flags = search_flags | GTK_SOURCE_SEARCH_CASE_INSENSITIVE;
+	}
+		
+	while (!found)
+	{
+		found = gtk_source_iter_forward_search (&iter,
+							doc->priv->search_text, 
+							search_flags,
+                        	                	&m_start, 
+                        	                	&m_end,
+                                	               	end);
+      	               	
+		if (found && GEDIT_SEARCH_IS_ENTIRE_WORD (doc->priv->search_flags))
+		{
+			found = gtk_text_iter_starts_word (&m_start) && 
+					gtk_text_iter_ends_word (&m_end);
+
+			if (!found) 
+				iter = m_end;
+		}
+		else
+			break;
+	}
+	
+	if (found && (match_start != NULL))
+		*match_start = m_start;
+	
+	if (found && (match_end != NULL))
+		*match_end = m_end;
+	
+	return found;			    
+}
+						 
+gboolean
+gedit_document_search_backward (GeditDocument     *doc,
+				const GtkTextIter *start,
+				const GtkTextIter *end,
+				GtkTextIter       *match_start,
+				GtkTextIter       *match_end)
+{
+	GtkTextIter iter;
+	GtkSourceSearchFlags search_flags;
+	gboolean found = FALSE;
+	GtkTextIter m_start;
+	GtkTextIter m_end;
+	
+	g_return_val_if_fail (GEDIT_IS_DOCUMENT (doc), FALSE);
+	g_return_val_if_fail ((start == NULL) || 
+			      (gtk_text_iter_get_buffer (start) ==  GTK_TEXT_BUFFER (doc)), FALSE);
+	g_return_val_if_fail ((end == NULL) || 
+			      (gtk_text_iter_get_buffer (end) ==  GTK_TEXT_BUFFER (doc)), FALSE);
+	
+	if (doc->priv->search_text == NULL)
+	{
+		gedit_debug_message (DEBUG_DOCUMENT, "doc->priv->search_text == NULL\n");
+		return FALSE;
+	}
+	else
+		gedit_debug_message (DEBUG_DOCUMENT, "doc->priv->search_text == \"%s\"\n", doc->priv->search_text);
+				      
+	if (end == NULL)
+		gtk_text_buffer_get_end_iter (GTK_TEXT_BUFFER (doc), &iter);
+	else
+		iter = *end;
+		
+	search_flags = GTK_SOURCE_SEARCH_VISIBLE_ONLY | GTK_SOURCE_SEARCH_TEXT_ONLY;
+
+	if (!GEDIT_SEARCH_IS_CASE_SENSITIVE (doc->priv->search_flags))
+	{
+		search_flags = search_flags | GTK_SOURCE_SEARCH_CASE_INSENSITIVE;
+	}
+
+	while (!found)
+	{
+		found = gtk_source_iter_backward_search (&iter,
+							 doc->priv->search_text, 
+							 search_flags,
+                        	                	 &m_start, 
+                        	                	 &m_end,
+                                	               	 start);
+      	               	
+		if (found && GEDIT_SEARCH_IS_ENTIRE_WORD (doc->priv->search_flags))
+		{
+			found = gtk_text_iter_starts_word (&m_start) && 
+					gtk_text_iter_ends_word (&m_end);
+
+			if (!found) 
+				iter = m_start;
+		}
+		else
+			break;
+	}
+	
+	if (found && (match_start != NULL))
+		*match_start = m_start;
+	
+	if (found && (match_end != NULL))
+		*match_end = m_end;
+	
+	return found;		      
+}
+
+gint 
+gedit_document_replace_all (GeditDocument       *doc,
+			    const gchar         *find, 
+			    const gchar         *replace, 
+			    guint                flags)
+{
+	GtkTextIter iter;
+	GtkTextIter m_start;
+	GtkTextIter m_end;
+	GtkSourceSearchFlags search_flags = 0;
+	gboolean found = TRUE;
+	gint cont = 0;
+	gchar *search_text;
+	gchar *replace_text;
+	gint replace_text_len;
+	GtkTextBuffer *buffer;
+	gboolean brackets_highlighting;
+	gboolean search_highliting;
+
+	g_return_val_if_fail (GEDIT_IS_DOCUMENT (doc), 0);
+	g_return_val_if_fail (replace != NULL, 0);
+	g_return_val_if_fail ((find != NULL) || (doc->priv->search_text != NULL), 0);
+
+	buffer = GTK_TEXT_BUFFER (doc);
+
+	if (find == NULL)
+		search_text = g_strdup (doc->priv->search_text);
+	else
+		search_text = gedit_utils_unescape_search_text (find);
+
+	replace_text = gedit_utils_unescape_search_text (replace);
+
+	gtk_text_buffer_get_start_iter (buffer, &iter);
+
+	search_flags = GTK_SOURCE_SEARCH_VISIBLE_ONLY | GTK_SOURCE_SEARCH_TEXT_ONLY;
+
+	if (!GEDIT_SEARCH_IS_CASE_SENSITIVE (flags))
+	{
+		search_flags = search_flags | GTK_SOURCE_SEARCH_CASE_INSENSITIVE;
+	}
+
+	replace_text_len = strlen (replace_text);
+
+	/* disable cursor_moved emission until the end of the
+	 * replace_all so that we don't spend all the time
+	 * updating the position in the statusbar
+	 */
+	doc->priv->stop_cursor_moved_emission = TRUE;
+
+	/* also avoid spending time matching brackets */
+	brackets_highlighting = gtk_source_buffer_get_highlight_matching_brackets (GTK_SOURCE_BUFFER (buffer));
+	gtk_source_buffer_set_highlight_matching_brackets (GTK_SOURCE_BUFFER (buffer), FALSE);
+
+	/* and do search highliting later */
+	search_highliting = gedit_document_get_enable_search_highlighting (doc);
+	gedit_document_set_enable_search_highlighting (doc, FALSE);
+
+	gtk_text_buffer_begin_user_action (buffer);
+
+	do
+	{
+		found = gtk_source_iter_forward_search (&iter,
+							search_text, 
+							search_flags,
+                        	                	&m_start, 
+                        	                	&m_end,
+                                	               	NULL);
+
+		if (found && GEDIT_SEARCH_IS_ENTIRE_WORD (flags))
+		{
+			gboolean word;
+
+			word = gtk_text_iter_starts_word (&m_start) && 
+			       gtk_text_iter_ends_word (&m_end);
+
+			if (!word)
+			{
+				iter = m_end;
+				continue;
+			}
+		}
+
+		if (found)
+		{
+			++cont;
+
+			gtk_text_buffer_delete (buffer, 
+						&m_start,
+						&m_end);
+			gtk_text_buffer_insert (buffer,
+						&m_start,
+						replace_text,
+						replace_text_len);
+
+			iter = m_start;
+		}		
+
+	} while (found);
+
+	gtk_text_buffer_end_user_action (buffer);
+
+	/* re-enable cursor_moved emission and notify
+	 * the current position 
+	 */
+	doc->priv->stop_cursor_moved_emission = FALSE;
+	emit_cursor_moved (doc);
+
+	gtk_source_buffer_set_highlight_matching_brackets (GTK_SOURCE_BUFFER (buffer),
+							   brackets_highlighting);
+	gedit_document_set_enable_search_highlighting (doc, search_highliting);
+
+	g_free (search_text);
+	g_free (replace_text);
+
+	return cont;
+}
+
+void
+gedit_document_set_language (GeditDocument     *doc, 
+			     GtkSourceLanguage *lang)
+{
+	g_return_if_fail (GEDIT_IS_DOCUMENT (doc));
+
+	set_language (doc, lang, TRUE);
+}
+
+GtkSourceLanguage *
+gedit_document_get_language (GeditDocument *doc)
+{
+	g_return_val_if_fail (GEDIT_IS_DOCUMENT (doc), NULL);
+
+	return gtk_source_buffer_get_language (GTK_SOURCE_BUFFER (doc));
+}
+
+const GeditEncoding *
+gedit_document_get_encoding (GeditDocument *doc)
+{
+	g_return_val_if_fail (GEDIT_IS_DOCUMENT (doc), NULL);
+
+	return doc->priv->encoding;
+}
+
+glong
+_gedit_document_get_seconds_since_last_save_or_load (GeditDocument *doc)
+{
+	GTimeVal current_time;
+
+	gedit_debug (DEBUG_DOCUMENT);
+	
+	g_return_val_if_fail (GEDIT_IS_DOCUMENT (doc), -1);
+
+	g_get_current_time (&current_time);
+
+	return (current_time.tv_sec - doc->priv->time_of_last_save_or_load.tv_sec);
+}
+
+static void
+get_search_match_colors (GeditDocument *doc,
+			 gboolean      *foreground_set,
+			 GdkColor      *foreground,
+			 gboolean      *background_set,
+			 GdkColor      *background)
+{
+	GtkSourceStyleScheme *style_scheme;
+	GtkSourceStyle *style;
+	gchar *bg;
+	gchar *fg;
+
+	style_scheme = gtk_source_buffer_get_style_scheme (GTK_SOURCE_BUFFER (doc));
+	if (style_scheme == NULL)
+		goto fallback;
+
+	style = gtk_source_style_scheme_get_style (style_scheme,
+						   "search-match");
+	if (style == NULL)
+		goto fallback;
+
+	g_object_get (style, 
+		      "foreground-set", foreground_set, 
+		      "foreground", &fg,
+		      "background-set", background_set, 
+		      "background", &bg,
+		      NULL);
+
+	if (*foreground_set)
+	{
+		if (fg == NULL ||
+		    !gdk_color_parse (fg, foreground))
+		{
+			*foreground_set = FALSE;
+		}
+	}
+
+	if (*background_set)
+	{
+		if (bg == NULL ||
+		    !gdk_color_parse (bg, background))
+		{
+			*background_set = FALSE;
+		}
+	}	
+
+	g_free (fg);
+	g_free (bg);
+
+	return;
+
+ fallback:
+	gedit_debug_message (DEBUG_DOCUMENT, 
+			     "Falling back to hard-coded colors "
+			     "for the \"found\" text tag.");
+
+	gdk_color_parse ("#FFFF78", background);
+	*background_set = TRUE;
+	*foreground_set = FALSE;
+
+	return;
+}
+
+static void
+sync_found_tag (GeditDocument *doc,
+		GParamSpec    *pspec,
+		gpointer       data)
+{
+	GdkColor fg;
+	GdkColor bg;
+	gboolean fg_set;
+	gboolean bg_set;
+
+	gedit_debug (DEBUG_DOCUMENT);
+
+	g_return_if_fail (GTK_TEXT_TAG (doc->priv->found_tag));
+
+	get_search_match_colors (doc,
+				 &fg_set, &fg,
+				 &bg_set, &bg);
+
+	g_object_set (doc->priv->found_tag,
+		      "foreground-gdk", fg_set ? &fg : NULL,
+		      NULL);
+	g_object_set (doc->priv->found_tag,
+		      "background-gdk", bg_set ? &bg : NULL,
+		      NULL);
+}
+
+static void
+text_tag_set_highest_priority (GtkTextTag    *tag,
+			       GtkTextBuffer *buffer)
+{
+	GtkTextTagTable *table;
+	gint n;
+
+	table = gtk_text_buffer_get_tag_table (buffer);
+	n = gtk_text_tag_table_get_size (table);
+	gtk_text_tag_set_priority (tag, n - 1);
+}
+
+static void
+search_region (GeditDocument *doc,
+	       GtkTextIter   *start,
+	       GtkTextIter   *end)
+{
+	GtkTextIter iter;
+	GtkTextIter m_start;
+	GtkTextIter m_end;	
+	GtkSourceSearchFlags search_flags = 0;
+	gboolean found = TRUE;
+
+	GtkTextBuffer *buffer;	
+
+	gedit_debug (DEBUG_DOCUMENT);
+	
+	buffer = GTK_TEXT_BUFFER (doc);
+	
+	if (doc->priv->found_tag == NULL)
+	{
+		doc->priv->found_tag = gtk_text_buffer_create_tag (GTK_TEXT_BUFFER (doc), 
+								   "found",
+								   NULL);
+
+		sync_found_tag (doc, NULL, NULL);
+
+		g_signal_connect (doc, 
+				  "notify::style-scheme",
+				  G_CALLBACK (sync_found_tag),
+				  NULL);
+	}
+
+	/* make sure the 'found' tag has the priority over
+	 * syntax highlighting tags */
+	text_tag_set_highest_priority (doc->priv->found_tag,
+				       GTK_TEXT_BUFFER (doc));
+				   
+
+	if (doc->priv->search_text == NULL)
+		return;
+
+	g_return_if_fail (doc->priv->num_of_lines_search_text > 0);
+
+	gtk_text_iter_backward_lines (start, doc->priv->num_of_lines_search_text);
+	gtk_text_iter_forward_lines (end, doc->priv->num_of_lines_search_text);
+
+	if (gtk_text_iter_has_tag (start, doc->priv->found_tag) &&
+	    !gtk_text_iter_begins_tag (start, doc->priv->found_tag))
+		gtk_text_iter_backward_to_tag_toggle (start, doc->priv->found_tag);
+
+	if (gtk_text_iter_has_tag (end, doc->priv->found_tag) &&
+	    !gtk_text_iter_ends_tag (end, doc->priv->found_tag))
+		gtk_text_iter_forward_to_tag_toggle (end, doc->priv->found_tag);
+
+	/*
+	g_print ("[%u (%u), %u (%u)]\n", gtk_text_iter_get_line (start), gtk_text_iter_get_offset (start),
+					   gtk_text_iter_get_line (end), gtk_text_iter_get_offset (end));
+	*/
+
+	gtk_text_buffer_remove_tag (buffer,
+				    doc->priv->found_tag,
+				    start,
+				    end);
+
+	if (*doc->priv->search_text == '\0')
+		return;
+
+	iter = *start;
+		
+	search_flags = GTK_SOURCE_SEARCH_VISIBLE_ONLY | GTK_SOURCE_SEARCH_TEXT_ONLY;
+
+	if (!GEDIT_SEARCH_IS_CASE_SENSITIVE (doc->priv->search_flags))
+	{
+		search_flags = search_flags | GTK_SOURCE_SEARCH_CASE_INSENSITIVE;
+	}
+	
+	do
+	{
+		if ((end != NULL) && gtk_text_iter_is_end (end))
+			end = NULL;
+			
+		found = gtk_source_iter_forward_search (&iter,
+							doc->priv->search_text, 
+							search_flags,
+                        	                	&m_start, 
+                        	                	&m_end,
+                                	               	end);
+				
+		iter = m_end;
+						      	               	
+		if (found && GEDIT_SEARCH_IS_ENTIRE_WORD (doc->priv->search_flags))
+		{
+			gboolean word;
+						
+			word = gtk_text_iter_starts_word (&m_start) && 
+			       gtk_text_iter_ends_word (&m_end);
+				
+			if (!word)
+				continue;
+		}
+
+		if (found)
+		{
+			gtk_text_buffer_apply_tag (buffer,
+						   doc->priv->found_tag,
+						   &m_start,
+						   &m_end);
+		}		
+
+	} while (found);
+}
+
+static void
+to_search_region_range (GeditDocument *doc,
+			GtkTextIter   *start, 
+			GtkTextIter   *end)
+{
+	gedit_debug (DEBUG_DOCUMENT);
+	
+	if (doc->priv->to_search_region == NULL)
+		return;
+		
+	gtk_text_iter_set_line_offset (start, 0);
+	gtk_text_iter_forward_to_line_end (end);
+	
+	/*
+	g_print ("+ [%u (%u), %u (%u)]\n", gtk_text_iter_get_line (start), gtk_text_iter_get_offset (start),
+					   gtk_text_iter_get_line (end), gtk_text_iter_get_offset (end));
+	*/
+
+	/* Add the region to the refresh region */
+	gedit_text_region_add (doc->priv->to_search_region, start, end);
+
+	/* Notify views of the updated highlight region */
+	gtk_text_iter_backward_lines (start, doc->priv->num_of_lines_search_text);
+	gtk_text_iter_forward_lines (end, doc->priv->num_of_lines_search_text);
+	
+	g_signal_emit (doc, document_signals [SEARCH_HIGHLIGHT_UPDATED], 0, start, end);
+}
+
+void
+_gedit_document_search_region (GeditDocument     *doc,
+			       const GtkTextIter *start,
+			       const GtkTextIter *end)
+{
+	GeditTextRegion *region;
+
+	gedit_debug (DEBUG_DOCUMENT);
+		
+	g_return_if_fail (GEDIT_IS_DOCUMENT (doc));
+	g_return_if_fail (start != NULL);
+	g_return_if_fail (end != NULL);
+	
+	if (doc->priv->to_search_region == NULL)
+		return;
+
+	/*
+	g_print ("U [%u (%u), %u (%u)]\n", gtk_text_iter_get_line (start), gtk_text_iter_get_offset (start),
+					   gtk_text_iter_get_line (end), gtk_text_iter_get_offset (end));
+	*/
+		
+	/* get the subregions not yet highlighted */
+	region = gedit_text_region_intersect (doc->priv->to_search_region, 
+					      start,
+					      end);
+	if (region) 
+	{
+		gint i;
+		GtkTextIter start_search;
+		GtkTextIter end_search;
+
+		i = gedit_text_region_subregions (region);
+		gedit_text_region_nth_subregion (region, 
+						 0,
+						 &start_search,
+						 NULL);
+
+		gedit_text_region_nth_subregion (region, 
+						 i - 1,
+						 NULL,
+						 &end_search);
+
+		gedit_text_region_destroy (region, TRUE);
+
+		gtk_text_iter_order (&start_search, &end_search);
+
+		search_region (doc, &start_search, &end_search);
+
+		/* remove the just highlighted region */
+		gedit_text_region_subtract (doc->priv->to_search_region,
+					    start, 
+					    end);
+	}
+}
+
+static void
+insert_text_cb (GeditDocument *doc, 
+		GtkTextIter   *pos,
+		const gchar   *text, 
+		gint           length)
+{
+	GtkTextIter start;
+	GtkTextIter end;
+
+	gedit_debug (DEBUG_DOCUMENT);
+		
+	start = end = *pos;
+
+	/*
+	 * pos is invalidated when
+	 * insertion occurs (because the buffer contents change), but the
+	 * default signal handler revalidates it to point to the end of the
+	 * inserted text 
+	 */
+	gtk_text_iter_backward_chars (&start,
+				      g_utf8_strlen (text, length));
+				     
+	to_search_region_range (doc, &start, &end);
+}
+						 
+static void	
+delete_range_cb (GeditDocument *doc, 
+		 GtkTextIter   *start,
+		 GtkTextIter   *end)
+{
+	GtkTextIter d_start;
+	GtkTextIter d_end;
+
+	gedit_debug (DEBUG_DOCUMENT);
+		
+	d_start = *start;
+	d_end = *end;
+	
+	to_search_region_range (doc, &d_start, &d_end);
+}
+
+void
+gedit_document_set_enable_search_highlighting (GeditDocument *doc,
+					       gboolean       enable)
+{
+	g_return_if_fail (GEDIT_IS_DOCUMENT (doc));
+	
+	enable = enable != FALSE;
+	
+	if ((doc->priv->to_search_region != NULL) == enable)
+		return;
+	
+	if (doc->priv->to_search_region != NULL)
+	{
+		/* Disable search highlighting */
+		if (doc->priv->found_tag != NULL)
+		{
+			/* If needed remove the found_tag */
+			GtkTextIter begin;
+			GtkTextIter end;
+		
+			gtk_text_buffer_get_bounds (GTK_TEXT_BUFFER (doc),
+						    &begin,
+						    &end);
+
+			gtk_text_buffer_remove_tag (GTK_TEXT_BUFFER (doc),
+				    		    doc->priv->found_tag,
+				    		    &begin,
+				    		    &end);
+		}
+		
+		gedit_text_region_destroy (doc->priv->to_search_region,
+					   TRUE);
+		doc->priv->to_search_region = NULL;
+	}
+	else
+	{
+		doc->priv->to_search_region = gedit_text_region_new (GTK_TEXT_BUFFER (doc));
+		if (gedit_document_get_can_search_again (doc))
+		{
+			/* If search_text is not empty, highligth all its occurrences */
+			GtkTextIter begin;
+			GtkTextIter end;
+		
+			gtk_text_buffer_get_bounds (GTK_TEXT_BUFFER (doc),
+						    &begin,
+						    &end);
+					    
+			to_search_region_range (doc,
+						&begin,
+						&end);
+		}
+	}
+}
+
+gboolean
+gedit_document_get_enable_search_highlighting (GeditDocument *doc)
+{
+	g_return_val_if_fail (GEDIT_IS_DOCUMENT (doc), FALSE);
+	
+	return (doc->priv->to_search_region != NULL);
+}
+
+void
+gedit_document_set_newline_type (GeditDocument           *doc,
+				 GeditDocumentNewlineType newline_type)
+{
+	g_return_if_fail (GEDIT_IS_DOCUMENT (doc));
+
+	if (doc->priv->newline_type != newline_type)
+	{
+		doc->priv->newline_type = newline_type;
+
+		g_object_notify (G_OBJECT (doc), "newline-type");
+	}
+}
+
+GeditDocumentNewlineType
+gedit_document_get_newline_type (GeditDocument *doc)
+{
+	g_return_val_if_fail (GEDIT_IS_DOCUMENT (doc), 0);
+
+	return doc->priv->newline_type;
+}
+
+void
+_gedit_document_set_mount_operation_factory (GeditDocument 	       *doc,
+					    GeditMountOperationFactory	callback,
+					    gpointer	                userdata)
+{
+	g_return_if_fail (GEDIT_IS_DOCUMENT (doc));
+	
+	doc->priv->mount_operation_factory = callback;
+	doc->priv->mount_operation_userdata = userdata;
+}
+
+GMountOperation *
+_gedit_document_create_mount_operation (GeditDocument *doc)
+{
+	g_return_val_if_fail (GEDIT_IS_DOCUMENT (doc), NULL);
+	
+	if (doc->priv->mount_operation_factory == NULL)
+		return g_mount_operation_new ();
+	else
+		return doc->priv->mount_operation_factory (doc, 
+						           doc->priv->mount_operation_userdata);
+}
+
+#ifndef ENABLE_GVFS_METADATA
+gchar *
+gedit_document_get_metadata (GeditDocument *doc,
+			     const gchar   *key)
+{
+	gchar *value = NULL;
+
+	g_return_val_if_fail (GEDIT_IS_DOCUMENT (doc), NULL);
+	g_return_val_if_fail (key != NULL, NULL);
+
+	if (!gedit_document_is_untitled (doc))
+	{
+		value = gedit_metadata_manager_get (doc->priv->uri, key);
+	}
+
+	return value;
+}
+
+void
+gedit_document_set_metadata (GeditDocument *doc,
+			     const gchar   *first_key,
+			     ...)
+{
+	const gchar *key;
+	const gchar *value;
+	va_list var_args;
+
+	g_return_if_fail (GEDIT_IS_DOCUMENT (doc));
+	g_return_if_fail (first_key != NULL);
+
+	if (gedit_document_is_untitled (doc))
+	{
+		/* Can't set metadata for untitled documents */
+		return;
+	}
+
+	va_start (var_args, first_key);
+
+	for (key = first_key; key; key = va_arg (var_args, const gchar *))
+	{
+		value = va_arg (var_args, const gchar *);
+		
+		gedit_metadata_manager_set (doc->priv->uri,
+					    key,
+					    value);
+	}
+
+	va_end (var_args);
+}
+
+#else
+
+/**
+ * gedit_document_get_metadata:
+ * @doc: a #GeditDocument
+ * @key: name of the key
+ *
+ * Gets the metadata assigned to @key.
+ *
+ * Returns: the value assigned to @key.
+ */
+gchar *
+gedit_document_get_metadata (GeditDocument *doc,
+			     const gchar   *key)
+{
+	gchar *value = NULL;
+
+	g_return_val_if_fail (GEDIT_IS_DOCUMENT (doc), NULL);
+	g_return_val_if_fail (key != NULL, NULL);
+
+	if (doc->priv->metadata_info && g_file_info_has_attribute (doc->priv->metadata_info,
+								   key))
+	{
+		value = g_strdup (g_file_info_get_attribute_string (doc->priv->metadata_info,
+								    key));
+	}
+
+	return value;
+}
+
+static void
+set_attributes_cb (GObject      *source,
+		   GAsyncResult *res,
+		   gpointer      useless)
+{
+	g_file_set_attributes_finish (G_FILE (source),
+				      res,
+				      NULL,
+				      NULL);
+}
+
+/**
+ * gedit_document_set_metadata:
+ * @doc: a #GeditDocument
+ * @first_key: name of the first key to set
+ * @...: value for the first key, followed optionally by more key/value pairs,
+ * followed by %NULL.
+ *
+ * Sets metadata on a document.
+ */
+void
+gedit_document_set_metadata (GeditDocument *doc,
+			     const gchar   *first_key,
+			     ...)
+{
+	const gchar *key;
+	const gchar *value;
+	va_list var_args;
+	GFileInfo *info;
+	GFile *location;
+
+	g_return_if_fail (GEDIT_IS_DOCUMENT (doc));
+	g_return_if_fail (first_key != NULL);
+
+	info = g_file_info_new ();
+
+	va_start (var_args, first_key);
+
+	for (key = first_key; key; key = va_arg (var_args, const gchar *))
+	{
+		value = va_arg (var_args, const gchar *);
+		
+		if (value != NULL)
+		{
+			g_file_info_set_attribute_string (info,
+							  key, value);
+		}
+		else
+		{
+			/* Unset the key */
+			g_file_info_set_attribute (info, key,
+						   G_FILE_ATTRIBUTE_TYPE_INVALID,
+						   NULL);
+		}
+	}
+
+	va_end (var_args);
+
+	if (doc->priv->metadata_info != NULL)
+		g_file_info_copy_into (info, doc->priv->metadata_info);
+
+	location = gedit_document_get_location (doc);
+
+	if (location != NULL)
+	{
+		g_file_set_attributes_async (location,
+					     info,
+					     G_FILE_QUERY_INFO_NONE,
+					     G_PRIORITY_DEFAULT,
+					     NULL,
+					     set_attributes_cb,
+					     NULL);
+
+		g_object_unref (location);
+	}
+	
+	g_object_unref (info);
+}
+#endif