- Changes for GObjectified YelpURI - Using new transformation code

* src/Makefile.am:
* src/yelp-cache.c:
* src/yelp-cache.h:
* src/yelp-html-gtkhtml2.c:
* src/yelp-info.c:
* src/yelp-main.c:
* src/yelp-main.c:
* src/yelp-scrollkeeper.c:
* src/yelp-section.c:
* src/yelp-window.c:
- Changes for GObjectified YelpURI
- Using new transformation code

* src/yelp-db-pager.c:
* src/yelp-pager.c:
* src/yelp-pager.h:
- Dethreadifying

* src/yelp-uri.c:
* src/yelp-uri.h:
- Work on relative URI resolver

16 files changed, 829 insertions, 622 deletions

diff --git a/ChangeLog b/ChangeLog
index cf68290b..e5f8218c 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,27 @@
+2003-11-15  Shaun McCance  <shaunm@gnome.org>
+
+	* src/Makefile.am:
+	* src/yelp-cache.c:
+	* src/yelp-cache.h:
+	* src/yelp-html-gtkhtml2.c:
+	* src/yelp-info.c:
+	* src/yelp-main.c:
+	* src/yelp-main.c:
+	* src/yelp-scrollkeeper.c:
+	* src/yelp-section.c:
+	* src/yelp-window.c:
+	- Changes for GObjectified YelpURI
+	- Using new transformation code
+
+	* src/yelp-db-pager.c:
+	* src/yelp-pager.c:
+	* src/yelp-pager.h:
+	- Dethreadifying
+
+	* src/yelp-uri.c:
+	* src/yelp-uri.h:
+	- Work on relative URI resolver
+
 2003-11-11  Shaun McCance  <shaunm@gnome.org>
 
 	* src/Makefile.am:
diff --git a/src/Makefile.am b/src/Makefile.am
index c73a81ae..06c282eb 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -86,18 +86,15 @@ yelp_SOURCES =								\
 	yelp-error.c		yelp-error.h				\
 	yelp-history.c		yelp-history.h				\
 	yelp-html-gtkhtml2.c	yelp-html.h				\
-	yelp-index-model.c	yelp-index-model.h			\
 	yelp-info.c		yelp-info.h				\
-	yelp-main.c							\
 	yelp-man.c		yelp-man.h				\
-	yelp-marshal-main.c						\
-	yelp-reader.c		yelp-reader.h				\
 	yelp-section.c		yelp-section.h				\
 	yelp-scrollkeeper.c	yelp-scrollkeeper.h			\
 	yelp-pager.c		yelp-pager.h				\
 	yelp-util.c		yelp-util.h				\
 	yelp-window.c 		yelp-window.h				\
-	yelp-uri.c	        yelp-uri.h
+	yelp-uri.c	        yelp-uri.h				\
+	yelp-marshal-main.c	yelp-main.c
 
 yelp_LDADD =								\
 	@YELP_LIBS@							\
diff --git a/src/yelp-cache.c b/src/yelp-cache.c
index bb7b0757..58a40bb7 100644
--- a/src/yelp-cache.c
+++ b/src/yelp-cache.c
@@ -1,6 +1,6 @@
-/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 4 -*- */
 /*
- * Copyright (C) 2002 Mikael Hallendal <micke@imendio.com>
+ * Copyright (C) 2003 Shaun McCance <shaunm@gnome.org>
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as
@@ -17,7 +17,7 @@
  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  * Boston, MA 02111-1307, USA.
  *
- * Author: Mikael Hallendal <micke@imendio.com>
+ * Author: Shaun McCance <shaunm@gnome.org>
  */
 
 #ifdef HAVE_CONFIG_H
@@ -33,30 +33,33 @@ GMutex     *cache_mutex;
 void
 yelp_cache_init (void)
 {
- 	cache_mutex = g_mutex_new ();
-        cache_table = g_hash_table_new (g_str_hash, g_str_equal);
+    cache_mutex = g_mutex_new ();
+    cache_table = g_hash_table_new_full (g_str_hash,
+					 g_str_equal,
+					 g_free,
+					 g_object_unref);
 }
 
-const gchar *
+GObject *
 yelp_cache_lookup (const gchar *path)
-{ 
-        const gchar *ret_val;
-        
-        g_mutex_lock (cache_mutex);
-        
-        ret_val = (const gchar *) g_hash_table_lookup (cache_table, path);
-        
-        g_mutex_unlock (cache_mutex);
-
-        return ret_val;
+{
+    GObject *object;
+
+    g_mutex_lock (cache_mutex);
+
+    object = (GObject *) g_hash_table_lookup (cache_table, path);
+
+    g_mutex_unlock (cache_mutex);
+
+    return object;
 }
 
 void
-yelp_cache_add (const gchar *path, const gchar *html)
+yelp_cache_add (const gchar *path, GObject *object)
 {
-        g_mutex_lock (cache_mutex);
-        
-        g_hash_table_insert (cache_table, (gchar *) path, g_strdup (html));
-        
-        g_mutex_unlock (cache_mutex);
+    g_mutex_lock (cache_mutex);
+
+    g_hash_table_insert (cache_table, (gchar *) path, object);
+
+    g_mutex_unlock (cache_mutex);
 }
diff --git a/src/yelp-cache.h b/src/yelp-cache.h
index bd6f74b0..f9cfea04 100644
--- a/src/yelp-cache.h
+++ b/src/yelp-cache.h
@@ -1,6 +1,6 @@
-/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 4 -*- */
 /*
- * Copyright (C) 2002 Mikael Hallendal <micke@imendio.com>
+ * Copyright (C) 2003 Shaun McCance <shaunm@gnome.org>
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as
@@ -17,7 +17,7 @@
  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  * Boston, MA 02111-1307, USA.
  *
- * Author: Mikael Hallendal <micke@imendio.com>
+ * Author: Shaun McCance <shaunm@gnome.org>
  */
 
 #ifndef __YELP_CACHE_H__
@@ -29,8 +29,8 @@
 
 void           yelp_cache_init          (void);
 
-const gchar *  yelp_cache_lookup        (const gchar *path);
+GObject *      yelp_cache_lookup        (const gchar *path);
 
 void           yelp_cache_add           (const gchar *path,
-                                         const gchar *html);
+					 GObject     *object);
 #endif /* __YELP_CACHE_H__ */
diff --git a/src/yelp-db-pager.c b/src/yelp-db-pager.c
index da8a2642..b9f1b1f8 100644
--- a/src/yelp-db-pager.c
+++ b/src/yelp-db-pager.c
@@ -47,10 +47,8 @@
 #define d(x)
 
 struct _YelpDBPagerPriv {
-    GMutex         *sects_mutex;
     GtkTreeModel   *sects;
 
-    GMutex         *frags_mutex;
     GHashTable     *frags_hash;
 };
 
@@ -71,7 +69,7 @@ static void     db_pager_class_init   (YelpDBPagerClass *klass);
 static void     db_pager_init         (YelpDBPager      *pager);
 static void     db_pager_dispose      (GObject          *gobject);
 
-void                 db_pager_process      (YelpPager   *pager);
+gboolean             db_pager_process      (YelpPager   *pager);
 void                 db_pager_cancel       (YelpPager   *pager);
 const gchar *        db_pager_resolve_uri  (YelpPager   *pager,
 					    YelpURI     *uri);
@@ -143,10 +141,8 @@ db_pager_init (YelpDBPager *pager)
     priv = g_new0 (YelpDBPagerPriv, 1);
     pager->priv = priv;
 
-    pager->priv->sects_mutex = g_mutex_new ();
     pager->priv->sects = NULL;
 
-    pager->priv->frags_mutex = g_mutex_new ();
     pager->priv->frags_hash =
 	g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free);
 }
@@ -156,10 +152,8 @@ db_pager_dispose (GObject *object)
 {
     YelpDBPager *pager = YELP_DB_PAGER (object);
 
-    g_mutex_free (pager->priv->sects_mutex);
     g_object_unref (pager->priv->sects);
 
-    g_mutex_free (pager->priv->frags_mutex);
     g_hash_table_destroy (pager->priv->frags_hash);
 
     g_free (pager->priv);
@@ -169,12 +163,6 @@ db_pager_dispose (GObject *object)
 
 /******************************************************************************/
 
-/**
- * yelp_db_pager_new:
- * @uri: the URI of the DocBook document to process.
- *
- * Creates a new YelpDBPager.
- **/
 YelpPager *
 yelp_db_pager_new (YelpURI *uri)
 {
@@ -186,15 +174,13 @@ yelp_db_pager_new (YelpURI *uri)
 					  "uri", uri,
 					  NULL);
 
-    g_mutex_lock (pager->priv->sects_mutex);
     pager->priv->sects =
 	GTK_TREE_MODEL (gtk_tree_store_new (2, G_TYPE_STRING, G_TYPE_STRING));
-    g_mutex_unlock (pager->priv->sects_mutex);
 
     return (YelpPager *) pager;
 }
 
-void
+gboolean
 db_pager_process (YelpPager *pager)
 {
     const YelpURI *uri     = yelp_pager_get_uri (pager);
@@ -209,10 +195,10 @@ db_pager_process (YelpPager *pager)
     gchar        *uri_slash;
     gchar        *doc_name;
     gchar        *doc_path;
-    const gchar  *params[9];
+    const gchar  *params[13];
 
-    g_return_if_fail (pager != NULL);
-    g_return_if_fail (YELP_IS_DB_PAGER (pager));
+    g_return_val_if_fail (pager != NULL, FALSE);
+    g_return_val_if_fail (YELP_IS_DB_PAGER (pager), FALSE);
 
     g_object_ref (pager);
 
@@ -226,7 +212,7 @@ db_pager_process (YelpPager *pager)
 	error = NULL;
 	yelp_pager_error (pager, error);
 
-	return;
+	return FALSE;
     }
 
     walker = g_new0 (DBWalker, 1);
@@ -234,11 +220,15 @@ db_pager_process (YelpPager *pager)
     walker->doc   = ctxt->myDoc;
     walker->cur   = xmlDocGetRootElement (walker->doc);
 
+    while (gtk_events_pending ())
+	gtk_main_iteration ();
+
     walker_walk_xml (walker);
 
-    yelp_pager_lock_state (pager);
     g_signal_emit_by_name (pager, "sections");
-    yelp_pager_unlock_state (pager);
+
+    while (gtk_events_pending ())
+	gtk_main_iteration ();
 
     uri_slash = g_strrstr (uri_str, "/");
     doc_name  = g_strndup (uri_str, uri_slash - uri_str + 1);
@@ -252,7 +242,11 @@ db_pager_process (YelpPager *pager)
     params[5]  = g_strconcat("\"file://", DB_STYLESHEET_PATH, "/\"", NULL) ;
     params[6]  = "chunk_depth";
     params[7]  = "2";
-    params[8] = NULL;
+    params[8]  = "html_extension";
+    params[9]  = "\"\"";
+    params[10] = "resolve_xref_chunk";
+    params[11] = "0";
+    params[12] = NULL;
 
     stylesheet = xsltParseStylesheetFile (DB_STYLESHEET);
     tctxt      = xsltNewTransformContext (stylesheet,
@@ -266,6 +260,10 @@ db_pager_process (YelpPager *pager)
 			    "cache",
 			    YELP_NAMESPACE,
 			    (xsltTransformFunction) xslt_yelp_cache);
+
+    while (gtk_events_pending ())
+	gtk_main_iteration ();
+
     xsltApplyStylesheetUser (stylesheet,
 			     ctxt->myDoc,
 			     params,
@@ -278,12 +276,12 @@ db_pager_process (YelpPager *pager)
     g_free (doc_name);
     g_free (doc_path);
 
-    yelp_pager_lock_state (pager);
     yelp_pager_set_state (pager, YELP_PAGER_STATE_FINISH);
     g_signal_emit_by_name (pager, "finish");
-    yelp_pager_unlock_state (pager);
 
     g_object_unref (pager);
+
+    return FALSE;
 }
 
 void
@@ -305,11 +303,9 @@ db_pager_resolve_uri (YelpPager *pager, YelpURI *uri)
 
     frag_id = yelp_uri_get_fragment (uri);
 
-    g_mutex_lock (db_pager->priv->frags_mutex);
     chunk_id =
 	(const gchar *) g_hash_table_lookup (db_pager->priv->frags_hash,
 					     frag_id);
-    g_mutex_unlock (db_pager->priv->frags_mutex);
 
     g_free (frag_id);
     return chunk_id;
@@ -343,6 +339,9 @@ xslt_yelp_document (xsltTransformContextPtr ctxt,
     if (!ctxt || !node || !inst || !comp)
 	return;
 
+    while (gtk_events_pending ())
+	gtk_main_iteration ();
+
     pager = (YelpPager *) ctxt->_private;
 
     chunk_id = xsltEvalAttrValueTemplate (ctxt, inst,
@@ -387,12 +386,11 @@ xslt_yelp_document (xsltTransformContextPtr ctxt,
     ctxt->output     = old_doc;
     ctxt->insert     = old_insert;
 
-    yelp_pager_lock_state (pager);
-
     yelp_pager_add_chunk (pager, chunk_id, chunk_buf);
     g_signal_emit_by_name (pager, "chunk", chunk_id);
 
-    yelp_pager_unlock_state (pager);
+    while (gtk_events_pending ())
+	gtk_main_iteration ();
 
     xmlFreeDoc (new_doc);
 }
@@ -449,11 +447,9 @@ walker_walk_xml (DBWalker *walker)
     walker->depth++;
 
     if (id) {
-	g_mutex_lock (priv->frags_mutex);
 	g_hash_table_insert (priv->frags_hash,
 			     g_strdup (id),
 			     g_strdup (walker->chunk_id));
-	g_mutex_unlock (priv->frags_mutex);
     }
 
     cur = walker->cur->children;
diff --git a/src/yelp-html-gtkhtml2.c b/src/yelp-html-gtkhtml2.c
index b31e5086..da0508b5 100644
--- a/src/yelp-html-gtkhtml2.c
+++ b/src/yelp-html-gtkhtml2.c
@@ -1,4 +1,4 @@
-/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 4 -*- */
 /*
  * Copyright (C) 2001-2002 Mikael Hallendal <micke@imendio.com>
  *
@@ -45,17 +45,16 @@
 #define d(x)
 
 struct _YelpHtmlPriv {
-	HtmlView        *view;
+    HtmlView        *view;
 
-        HtmlDocument    *doc;
-	YelpURI         *base_uri;
+    HtmlDocument    *doc;
+    YelpURI         *base_uri;
 
-	DomNodeIterator *find_iter;
-	DomNode         *find_node;
-	gint             find_offset;
+    DomNodeIterator *find_iter;
+    DomNode         *find_node;
+    gint             find_offset;
 };
 
-
 static void      html_init               (YelpHtml           *html);
 static void      html_class_init         (YelpHtmlClass      *klass);
 
@@ -78,9 +77,9 @@ static void      html_clear_find_data    (YelpHtml           *html);
 #define BUFFER_SIZE 16384
 
 enum {
-	URI_SELECTED,
-	TITLE_CHANGED,
-	LAST_SIGNAL
+    URI_SELECTED,
+    TITLE_CHANGED,
+    LAST_SIGNAL
 };
 
 static gint        signals[LAST_SIGNAL] = { 0 };
@@ -88,79 +87,76 @@ static gint        signals[LAST_SIGNAL] = { 0 };
 GType
 yelp_html_get_type (void)
 {
-        static GType view_type = 0;
-
-        if (!view_type) {
-                static const GTypeInfo view_info =
-                        {
-                                sizeof (YelpHtmlClass),
-                                NULL,
-                                NULL,
-                                (GClassInitFunc) html_class_init,
-                                NULL,
-                                NULL,
-                                sizeof (YelpHtml),
-                                0,
-                                (GInstanceInitFunc) html_init,
-                        };
-                
-                view_type = g_type_register_static (G_TYPE_OBJECT,
-                                                    "YelpHtml", 
-                                                    &view_info, 0);
-        }
-        
-        return view_type;
+    static GType view_type = 0;
+
+    if (!view_type) {
+	static const GTypeInfo view_info = {
+	    sizeof (YelpHtmlClass),
+	    NULL,
+	    NULL,
+	    (GClassInitFunc) html_class_init,
+	    NULL,
+	    NULL,
+	    sizeof (YelpHtml),
+	    0,
+	    (GInstanceInitFunc) html_init,
+	};
+
+	view_type = g_type_register_static (G_TYPE_OBJECT,
+					    "YelpHtml", 
+					    &view_info, 0);
+    }
+
+    return view_type;
 }
 
 static void
 html_init (YelpHtml *html)
 {
-        YelpHtmlPriv *priv;
+    YelpHtmlPriv *priv;
 
-        priv = g_new0 (YelpHtmlPriv, 1);
+    priv = g_new0 (YelpHtmlPriv, 1);
 
-	priv->view        = HTML_VIEW (html_view_new ());
-        priv->doc         = html_document_new ();
-        priv->base_uri    = NULL;
+    priv->view        = HTML_VIEW (html_view_new ());
+    priv->doc         = html_document_new ();
+    priv->base_uri    = NULL;
 
-        html_view_set_document (HTML_VIEW (priv->view), priv->doc);
-        
-        g_signal_connect (G_OBJECT (priv->doc), "link_clicked",
-                          G_CALLBACK (html_link_clicked_cb), html);
-        
-        g_signal_connect (G_OBJECT (priv->doc), "request_url",
-                          G_CALLBACK (html_url_requested_cb), html);
+    html_view_set_document (HTML_VIEW (priv->view), priv->doc);
 
-        g_signal_connect (G_OBJECT (priv->doc), "title_changed",
-                          G_CALLBACK (html_title_changed_cb), html);
+    g_signal_connect (G_OBJECT (priv->doc), "link_clicked",
+		      G_CALLBACK (html_link_clicked_cb), html);
+    g_signal_connect (G_OBJECT (priv->doc), "request_url",
+		      G_CALLBACK (html_url_requested_cb), html);
+    g_signal_connect (G_OBJECT (priv->doc), "title_changed",
+		      G_CALLBACK (html_title_changed_cb), html);
 
-        html->priv = priv;
+    html->priv = priv;
 }
 
 static void
 html_class_init (YelpHtmlClass *klass)
 {
-	signals[URI_SELECTED] = 
-		g_signal_new ("uri_selected",
-			      G_TYPE_FROM_CLASS (klass),
-			      G_SIGNAL_RUN_LAST,
-			      G_STRUCT_OFFSET (YelpHtmlClass,
-					       uri_selected),
-			      NULL, NULL,
-			      yelp_marshal_VOID__POINTER_BOOLEAN,
-			      G_TYPE_NONE,
-			      2, G_TYPE_POINTER, G_TYPE_BOOLEAN);
-
-	signals[TITLE_CHANGED] = 
-		g_signal_new ("title_changed",
-			      G_TYPE_FROM_CLASS (klass),
-			      G_SIGNAL_RUN_LAST,
-			      G_STRUCT_OFFSET (YelpHtmlClass,
-					       title_changed),
-			      NULL, NULL,
-			      yelp_marshal_VOID__STRING,
-			      G_TYPE_NONE,
-			      1, G_TYPE_STRING);
+    signals[URI_SELECTED] = 
+	g_signal_new ("uri_selected",
+		      G_TYPE_FROM_CLASS (klass),
+		      G_SIGNAL_RUN_LAST,
+		      G_STRUCT_OFFSET (YelpHtmlClass,
+				       uri_selected),
+		      NULL, NULL,
+		      yelp_marshal_VOID__POINTER_BOOLEAN,
+		      G_TYPE_NONE,
+		      2, G_TYPE_POINTER, G_TYPE_BOOLEAN);
+
+    signals[TITLE_CHANGED] = 
+	g_signal_new ("title_changed",
+		      G_TYPE_FROM_CLASS (klass),
+		      G_SIGNAL_RUN_LAST,
+		      G_STRUCT_OFFSET (YelpHtmlClass,
+				       title_changed),
+		      NULL, NULL,
+		      yelp_marshal_VOID__STRING,
+		      G_TYPE_NONE,
+		      1, G_TYPE_STRING);
 }
 
 static void
@@ -169,43 +165,44 @@ html_url_requested_cb (HtmlDocument *doc,
 		       HtmlStream   *stream,
 		       gpointer      data)
 {
-	YelpHtmlPriv     *priv;
-        YelpHtml         *html;
-	GnomeVFSHandle   *handle;
-	GnomeVFSResult    result;
-	gchar             buffer[BUFFER_SIZE];
-	GnomeVFSFileSize  read_len;
-	gchar            *absolute_url;
-	
-        html = YELP_HTML (data);
-	priv = html->priv;
+    YelpHtmlPriv     *priv;
+    YelpHtml         *html;
+    GnomeVFSHandle   *handle;
+    GnomeVFSResult    result;
+    gchar             buffer[BUFFER_SIZE];
+    GnomeVFSFileSize  read_len;
+    gchar            *absolute_url;
 
-	/* Reset find data when we load a new page. */
-	html_clear_find_data (html);
-	
-	html_stream_set_cancel_func (stream, html_cancel_stream, html);
+    html = YELP_HTML (data);
+    priv = html->priv;
 
-	d(g_print ("URL REQUESTED: %s\n", url));
+    /* Reset find data when we load a new page. */
+    html_clear_find_data (html);
 
-	absolute_url = yelp_util_resolve_relative_url (yelp_uri_get_path (priv->base_uri), url);
-	
-	result = gnome_vfs_open (&handle, absolute_url, GNOME_VFS_OPEN_READ);
+    html_stream_set_cancel_func (stream, html_cancel_stream, html);
 
-	if (result != GNOME_VFS_OK) {
-		g_warning ("Failed to open: %s", absolute_url);
-		g_free (absolute_url);
+    d(g_print ("URL REQUESTED: %s\n", url));
 
-		return;
-	}
+    absolute_url = yelp_util_resolve_relative_url (yelp_uri_get_path (priv->base_uri),
+						   url);
 
+    result = gnome_vfs_open (&handle, absolute_url, GNOME_VFS_OPEN_READ);
+
+    if (result != GNOME_VFS_OK) {
+	g_warning ("Failed to open: %s", absolute_url);
 	g_free (absolute_url);
 
-	while (gnome_vfs_read (handle, buffer, BUFFER_SIZE, &read_len) ==
-	       GNOME_VFS_OK) {
-		html_stream_write (stream, buffer, read_len);
-	}
+	return;
+    }
+
+    g_free (absolute_url);
 
-	gnome_vfs_close (handle);
+    while (gnome_vfs_read (handle, buffer, BUFFER_SIZE, &read_len) ==
+	   GNOME_VFS_OK) {
+	html_stream_write (stream, buffer, read_len);
+    }
+
+    gnome_vfs_close (handle);
 }
 
 static void
@@ -213,48 +210,53 @@ html_cancel_stream (HtmlStream *stream,
 		    gpointer    user_data, 
 		    gpointer    cancel_data)
 {
-	d(g_print ("CANCEL!!\n"));
+    d(g_print ("CANCEL!!\n"));
 
-	/* Not sure what to do here */
+    /* Not sure what to do here */
 }
 
 static void
 html_link_clicked_cb (HtmlDocument *doc, const gchar *url, YelpHtml *html)
 {
-	YelpHtmlPriv *priv;
-	gboolean      handled;
-	YelpURI      *uri;
+    YelpHtmlPriv *priv;
+    gboolean      handled;
+    YelpURI      *uri;
+    gchar        *fragment;
 
-	g_return_if_fail (HTML_IS_DOCUMENT (doc));
-	g_return_if_fail (url != NULL);
-	g_return_if_fail (YELP_IS_HTML (html));
+    g_return_if_fail (HTML_IS_DOCUMENT (doc));
+    g_return_if_fail (url != NULL);
+    g_return_if_fail (YELP_IS_HTML (html));
 
-	priv    = html->priv;
-	handled = FALSE;
+    priv    = html->priv;
+    handled = FALSE;
 
-	d(g_print ("Link clicked: %s\n", url));
+    d(g_print ("Link clicked: %s\n", url));
 
-	uri = yelp_uri_get_relative (priv->base_uri, url);
+    uri = yelp_uri_new_relative (priv->base_uri, url);
 
-	d(g_print ("That would be: %s\n", yelp_uri_to_string (uri)));
+    d(g_print ("That would be: %s\n", yelp_uri_to_string (uri)));
 	
-	/* If this is a relative reference. Shortcut reload. */
-	if (yelp_uri_equal_path (uri, priv->base_uri) &&
-	    yelp_uri_get_section (uri)) {
-		if (yelp_uri_get_type (uri) == YELP_URI_TYPE_HTML ||
-		    yelp_uri_get_type (uri) == YELP_URI_TYPE_MAN) {
-			html_view_jump_to_anchor (HTML_VIEW (html->priv->view),
-						  yelp_uri_get_section (uri));
-			handled = TRUE;
-		}
+    /* If this is a relative reference. Shortcut reload. */
+    if (yelp_uri_equal_path (uri, priv->base_uri)) {
+	fragment = yelp_uri_get_fragment (uri);
+	if (fragment) {
+	    if (yelp_uri_get_resource_type (uri) == YELP_URI_TYPE_HTML ||
+		yelp_uri_get_resource_type (uri) == YELP_URI_TYPE_MAN) {
+
+		html_view_jump_to_anchor (HTML_VIEW (html->priv->view),
+					  fragment);
+		g_free (fragment);
+		handled = TRUE;
+	    }
 	}
+    }
 
-	/* Reset find data when we load a new page. */
-	html_clear_find_data (html);
+    /* Reset find data when we load a new page. */
+    html_clear_find_data (html);
 
-	g_signal_emit (html, signals[URI_SELECTED], 0, uri, handled);
+    g_signal_emit (html, signals[URI_SELECTED], 0, uri, handled);
 
-	yelp_uri_unref (uri);
+    g_object_unref (uri);
 }
 
 static void
@@ -262,138 +264,136 @@ html_title_changed_cb (HtmlDocument *doc,
 		       const gchar  *new_title,
 		       YelpHtml     *html)
 {
-	g_return_if_fail (HTML_IS_DOCUMENT (doc));
-	g_return_if_fail (new_title != NULL);
-	
-	g_signal_emit (html, signals[TITLE_CHANGED], 0, new_title);
+    g_return_if_fail (HTML_IS_DOCUMENT (doc));
+    g_return_if_fail (new_title != NULL);
+
+    g_signal_emit (html, signals[TITLE_CHANGED], 0, new_title);
 }
 
 YelpHtml *
 yelp_html_new (void)
 {
-        YelpHtml *html;
-	
-        d(puts(G_GNUC_FUNCTION));
+    YelpHtml *html;
 
-        html = g_object_new (YELP_TYPE_HTML, NULL);
-	
- 	yelp_html_clear (html);
-	
- 	{
- 		gchar *text = "<html><body></body></html>";
+    d(puts(G_GNUC_FUNCTION));
 
- 		yelp_html_write (html, text, -1);
- 	}
-	
- 	yelp_html_close (html);
+    html = g_object_new (YELP_TYPE_HTML, NULL);
+
+    yelp_html_clear (html);
+
+    {
+	gchar *text = "<html><body></body></html>";
+
+	yelp_html_write (html, text, -1);
+    }
+
+    yelp_html_close (html);
 
-        return html;
+    return html;
 }
 
 void
 yelp_html_set_base_uri (YelpHtml *html, YelpURI *uri)
 {
-	YelpHtmlPriv *priv;
-	
-	g_return_if_fail (YELP_IS_HTML (html));
+    YelpHtmlPriv *priv;
 
-	priv = html->priv;
+    g_return_if_fail (YELP_IS_HTML (html));
 
-	if (priv->base_uri) {
-		yelp_uri_unref (priv->base_uri);
-	}
+    priv = html->priv;
+
+    if (priv->base_uri)
+	g_object_unref (priv->base_uri);
 
-	priv->base_uri = yelp_uri_ref (uri);
+    g_object_ref (uri);
+    priv->base_uri = uri;
 }
 
 void
 yelp_html_clear (YelpHtml *html)
 {
-	YelpHtmlPriv *priv;
-	
-	g_return_if_fail (YELP_IS_HTML (html));
+    YelpHtmlPriv *priv;
+
+    g_return_if_fail (YELP_IS_HTML (html));
 
-	priv = html->priv;
+    priv = html->priv;
 
-	html_document_clear (priv->doc);
-	html_document_open_stream (priv->doc, "text/html");
-	html_stream_set_cancel_func (priv->doc->current_stream,
- 				     html_cancel_stream,
- 				     html);
+    html_document_clear (priv->doc);
+    html_document_open_stream (priv->doc, "text/html");
+    html_stream_set_cancel_func (priv->doc->current_stream,
+				 html_cancel_stream,
+				 html);
 }
 
 void
 yelp_html_write (YelpHtml *html, const gchar *data, gint len)
 {
-	YelpHtmlPriv *priv;
-	
-	g_return_if_fail (YELP_IS_HTML (html));
-	
-	priv = html->priv;
-	
-	if (len == -1) {
-		len = strlen (data);
-	}
-	
-	if (len <= 0) {
-		return;
-	}
-	
-	html_document_write_stream (priv->doc, data, len);
+    YelpHtmlPriv *priv;
+
+    g_return_if_fail (YELP_IS_HTML (html));
+
+    priv = html->priv;
+
+    if (len == -1)
+	len = strlen (data);
+
+    if (len <= 0)
+	return;
+
+    html_document_write_stream (priv->doc, data, len);
 }
 
 void
 yelp_html_printf (YelpHtml *html, char *format, ...)
 {
-	va_list  args;
-	gchar   *string;
-	
-	g_return_if_fail (format != NULL);
-	
-	va_start (args, format);
-	string = g_strdup_vprintf (format, args);
-	va_end (args);
-	
-	yelp_html_write (html, string, -1);
-	
-	g_free (string);
+    va_list  args;
+    gchar   *string;
+
+    g_return_if_fail (format != NULL);
+
+    va_start (args, format);
+    string = g_strdup_vprintf (format, args);
+    va_end (args);
+
+    yelp_html_write (html, string, -1);
+
+    g_free (string);
 }
 
 void
 yelp_html_close (YelpHtml *html)
 {
-	YelpHtmlPriv *priv;
-	
-	g_return_if_fail (YELP_IS_HTML (html));
-	
-	priv = html->priv;
-	
-	html_document_close_stream (priv->doc);
+    YelpHtmlPriv *priv;
+
+    g_return_if_fail (YELP_IS_HTML (html));
+
+    priv = html->priv;
 
-	gtk_adjustment_set_value (gtk_layout_get_vadjustment (GTK_LAYOUT (priv->view)),
-				  0);
+    html_document_close_stream (priv->doc);
+
+    gtk_adjustment_set_value (gtk_layout_get_vadjustment (GTK_LAYOUT (priv->view)),
+			      0);
 }
 
 GtkWidget *
 yelp_html_get_widget (YelpHtml *html)
 {
-	g_return_val_if_fail (YELP_IS_HTML (html), NULL);
-	
-	return GTK_WIDGET (html->priv->view);
+    g_return_val_if_fail (YELP_IS_HTML (html), NULL);
+
+    return GTK_WIDGET (html->priv->view);
 }
 
 static void
 html_clear_find_data (YelpHtml *html)
 {
-	YelpHtmlPriv *priv;
+    YelpHtmlPriv *priv;
 
-	priv = html->priv;
-	
-	/* Reset find data when we load a new page. */
-	if (priv->find_iter) {
-		g_object_unref (priv->find_iter);
-		priv->find_iter = NULL;
-	}
+    priv = html->priv;
+
+    /* Reset find data when we load a new page. */
+    if (priv->find_iter) {
+	g_object_unref (priv->find_iter);
+	priv->find_iter = NULL;
+    }
 }
 
 /* This code is really ugly, need to clean up. */
@@ -404,159 +404,159 @@ yelp_html_find (YelpHtml    *html,
 		gboolean     wrap,
 		gboolean     forward)
 {
-	YelpHtmlPriv    *priv;
-	DomNode         *root;
-	DomNode         *tmp_node;
-	DomNode         *node;
-	DomNodeIterator *iter;
-	gchar           *str;
-	gchar           *hit;
-	gchar           *haystack;
-
-	HtmlBox         *box;
-	gchar           *box_text;
-	gint             len;
- 
-	g_return_if_fail (YELP_IS_HTML (html));
-	g_return_if_fail (find_string != NULL);
-
-	priv = html->priv;
-
-	if (!priv->find_iter) {
-		iter = dom_DocumentTraversal_createNodeIterator (
-			DOM_DOCUMENT_TRAVERSAL (priv->doc->dom_document),
-			DOM_NODE (priv->doc->dom_document),
-			DOM_SHOW_ALL,
-			NULL,
-			FALSE,
-			NULL);
-
-		root = NULL;
-		while ((node = dom_NodeIterator_nextNode (iter, NULL))) {
-			if (!g_ascii_strcasecmp (dom_Node__get_nodeName (node), "body")) {
-				root = node;
-				break;
-			}
-		}
-		
-		g_object_unref (iter);
-		iter = NULL;
-	
-		if (!root) {
-			g_warning ("html_find(): Couldn't find html body.");
-			return;
-		}
-		
-		priv->find_iter = dom_DocumentTraversal_createNodeIterator (
-			DOM_DOCUMENT_TRAVERSAL (priv->doc->dom_document),
-			root,
-			DOM_SHOW_TEXT,
-			NULL,
-			FALSE,
-			NULL);
-
-		if (forward) {
-			priv->find_node = dom_NodeIterator_nextNode (priv->find_iter, NULL);
-			priv->find_offset = 0;
-		} else {
-			do {
-				tmp_node = priv->find_node;
-				priv->find_node = dom_NodeIterator_nextNode (priv->find_iter, NULL);
-			} while (priv->find_node);
-
-			priv->find_node = tmp_node;
-
-			if (priv->find_node) {
-				box = html_view_find_layout_box (priv->view, priv->find_node, FALSE);
-				box_text = html_box_text_get_text (HTML_BOX_TEXT (box), &len);
-				priv->find_offset = len;
-			}
-		}
+    YelpHtmlPriv    *priv;
+    DomNode         *root;
+    DomNode         *tmp_node;
+    DomNode         *node;
+    DomNodeIterator *iter;
+    gchar           *str;
+    gchar           *hit;
+    gchar           *haystack;
+
+    HtmlBox         *box;
+    gchar           *box_text;
+    gint             len;
+
+    g_return_if_fail (YELP_IS_HTML (html));
+    g_return_if_fail (find_string != NULL);
+
+    priv = html->priv;
+
+    if (!priv->find_iter) {
+	iter = dom_DocumentTraversal_createNodeIterator
+	    (DOM_DOCUMENT_TRAVERSAL (priv->doc->dom_document),
+	     DOM_NODE (priv->doc->dom_document),
+	     DOM_SHOW_ALL,
+	     NULL,
+	     FALSE,
+	     NULL);
+
+	root = NULL;
+	while ((node = dom_NodeIterator_nextNode (iter, NULL))) {
+	    if (!g_ascii_strcasecmp (dom_Node__get_nodeName (node), "body")) {
+		root = node;
+		break;
+	    }
 	}
-	
-	while (priv->find_node) {
-		box = html_view_find_layout_box (priv->view, priv->find_node, FALSE);
 
-		/* We get the text from the layout box instead from the DOM node
-		 * directly, since the text in the box is canonicalized
-		 * (whitespace stripped in places etc).
-		 */
+	g_object_unref (iter);
+	iter = NULL;
+
+	if (!root) {
+	    g_warning ("html_find(): Couldn't find html body.");
+	    return;
+	}
+
+	priv->find_iter = dom_DocumentTraversal_createNodeIterator
+	    (DOM_DOCUMENT_TRAVERSAL (priv->doc->dom_document),
+	     root,
+	     DOM_SHOW_TEXT,
+	     NULL,
+	     FALSE,
+	     NULL);
+
+	if (forward) {
+	    priv->find_node = dom_NodeIterator_nextNode (priv->find_iter, NULL);
+	    priv->find_offset = 0;
+	} else {
+	    do {
+		tmp_node = priv->find_node;
+		priv->find_node = dom_NodeIterator_nextNode (priv->find_iter, NULL);
+	    } while (priv->find_node);
+
+	    priv->find_node = tmp_node;
+
+	    if (priv->find_node) {
+		box = html_view_find_layout_box (priv->view, priv->find_node, FALSE);
 		box_text = html_box_text_get_text (HTML_BOX_TEXT (box), &len);
-		if (len) {
-			str = g_new (gchar, len + 1);
-			memcpy (str, box_text, sizeof (gchar) * len);
-			str[len] = 0;
-		} else {
-			str = g_strdup ("");
-		}
-
-		if (!match_case) {
-			if (forward) {
-				haystack = g_utf8_casefold (str + priv->find_offset, len - priv->find_offset);
-			} else {
-				haystack = g_utf8_casefold (str, priv->find_offset);
-			}
-		} else {
-			if (forward) {
-				haystack = g_strdup (str + priv->find_offset);
-			} else {
-				haystack = g_strndup (str, priv->find_offset);
-			}
-		}
-
-		if (forward) {
-			hit = strstr (haystack, find_string);
-		} else {
-			hit = g_strrstr_len (haystack,
-					     priv->find_offset,
-					     find_string);
-		}
-
-		if (hit) {
-			if (forward) {
-				html_selection_set (priv->view,
-						    priv->find_node,
-						    hit - haystack + priv->find_offset,
-						    strlen (find_string));
-				priv->find_offset += hit - haystack + strlen (find_string);
-			} else {
-				html_selection_set (priv->view,
-						    priv->find_node,
-						    hit - haystack,
-						    strlen (find_string));
-				priv->find_offset = hit - haystack;
-			}
-				
-			html_view_scroll_to_node (priv->view,
-						  priv->find_node,
-						  HTML_VIEW_SCROLL_TO_TOP);
-		}
-
-		g_free (str);
-		g_free (haystack);
-		
-		if (hit) {
-			break;
-		}
-		
-		if (forward) {
-			priv->find_node = dom_NodeIterator_nextNode (priv->find_iter, NULL);
-			priv->find_offset = 0;
-		} else {
-			priv->find_node = dom_NodeIterator_previousNode (priv->find_iter, NULL);
-			if (priv->find_node) {
-				box = html_view_find_layout_box (priv->view, priv->find_node, FALSE);
-				box_text = html_box_text_get_text (HTML_BOX_TEXT (box), &len);
-				priv->find_offset = len;
-			}
-		}			
+		priv->find_offset = len;
+	    }
+	}
+    }
+
+    while (priv->find_node) {
+	box = html_view_find_layout_box (priv->view, priv->find_node, FALSE);
+
+	/* We get the text from the layout box instead from the DOM node
+	 * directly, since the text in the box is canonicalized
+	 * (whitespace stripped in places etc).
+	 */
+	box_text = html_box_text_get_text (HTML_BOX_TEXT (box), &len);
+	if (len) {
+	    str = g_new (gchar, len + 1);
+	    memcpy (str, box_text, sizeof (gchar) * len);
+	    str[len] = 0;
+	} else {
+	    str = g_strdup ("");
+	}
+
+	if (!match_case) {
+	    if (forward)
+		haystack = g_utf8_casefold (str + priv->find_offset,
+					    len - priv->find_offset);
+	    else
+		haystack = g_utf8_casefold (str,
+					    priv->find_offset);
+	} else {
+	    if (forward)
+		haystack = g_strdup (str + priv->find_offset);
+	    else
+		haystack = g_strndup (str, priv->find_offset);
+	}
+
+	if (forward) {
+	    hit = strstr (haystack, find_string);
+	} else {
+	    hit = g_strrstr_len (haystack,
+				 priv->find_offset,
+				 find_string);
 	}
 
-	if (!priv->find_node) {
-		g_object_unref (priv->find_iter);
-		priv->find_iter = NULL;
-		priv->find_offset = 0;
-		html_selection_clear (priv->view);
+	if (hit) {
+	    if (forward) {
+		html_selection_set (priv->view,
+				    priv->find_node,
+				    hit - haystack + priv->find_offset,
+				    strlen (find_string));
+		priv->find_offset += hit - haystack + strlen (find_string);
+	    } else {
+		html_selection_set (priv->view,
+				    priv->find_node,
+				    hit - haystack,
+				    strlen (find_string));
+		priv->find_offset = hit - haystack;
+	    }
+
+	    html_view_scroll_to_node (priv->view,
+				      priv->find_node,
+				      HTML_VIEW_SCROLL_TO_TOP);
 	}
+
+	g_free (str);
+	g_free (haystack);
+
+	if (hit) {
+	    break;
+	}
+
+	if (forward) {
+	    priv->find_node = dom_NodeIterator_nextNode (priv->find_iter, NULL);
+	    priv->find_offset = 0;
+	} else {
+	    priv->find_node = dom_NodeIterator_previousNode (priv->find_iter, NULL);
+	    if (priv->find_node) {
+		box = html_view_find_layout_box (priv->view, priv->find_node, FALSE);
+		box_text = html_box_text_get_text (HTML_BOX_TEXT (box), &len);
+		priv->find_offset = len;
+	    }
+	}			
+    }
+
+    if (!priv->find_node) {
+	g_object_unref (priv->find_iter);
+	priv->find_iter = NULL;
+	priv->find_offset = 0;
+	html_selection_clear (priv->view);
+    }
 }
 
diff --git a/src/yelp-info.c b/src/yelp-info.c
index 9d80e54c..7b94bd1a 100644
--- a/src/yelp-info.c
+++ b/src/yelp-info.c
@@ -104,7 +104,7 @@ yelp_info_read_info_dir (const char *basedir, GSList **info_list)
 					    title, uri);
 		g_free (title);
 		
-		yelp_uri_unref (uri);
+		g_object_unref (uri);
 		
 		*info_list = g_slist_prepend (*info_list, section);
 	}
diff --git a/src/yelp-main.c b/src/yelp-main.c
index 13e0cc4f..86cb0c7e 100644
--- a/src/yelp-main.c
+++ b/src/yelp-main.c
@@ -314,8 +314,6 @@ main (int argc, char **argv)
 	bindtextdomain(GETTEXT_PACKAGE, GNOMELOCALEDIR);  
         bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
 	textdomain(GETTEXT_PACKAGE);
-	g_thread_init (NULL);
-
 
 	program = gnome_program_init (PACKAGE, VERSION,
 				      LIBGNOMEUI_MODULE,
@@ -326,8 +324,9 @@ main (int argc, char **argv)
 
 	/* Need to set this to the canonical DISPLAY value, since
 	   that's where we're registering per-display components */
-	bonobo_activation_set_activation_env_value ("DISPLAY",
-						    gdk_display_get_name (gdk_display_get_default ()));
+	bonobo_activation_set_activation_env_value
+		("DISPLAY",
+		 gdk_display_get_name (gdk_display_get_default ()) );
 
 	gnome_vfs_init ();
 	
diff --git a/src/yelp-man.c b/src/yelp-man.c
index 04bb6243..3725d003 100644
--- a/src/yelp-man.c
+++ b/src/yelp-man.c
@@ -183,7 +183,7 @@ yelp_man_populate_tree_for_subdir (GHashTable *section_hash,
 		uri = yelp_uri_new (uribuf);
 		yelp_section = yelp_section_new (YELP_SECTION_DOCUMENT,
 						 titlebuf, uri);
-		yelp_uri_unref (uri);
+		g_object_unref (uri);
 		
 		node->pages = g_list_prepend (node->pages, yelp_section);
 
diff --git a/src/yelp-pager.c b/src/yelp-pager.c
index c07fa689..ea8b63e1 100644
--- a/src/yelp-pager.c
+++ b/src/yelp-pager.c
@@ -36,13 +36,10 @@
 struct _YelpPagerPriv {
     YelpURI        *uri;
 
-    GMutex         *state_mutex;
     YelpPagerState  state;
 
-    GMutex         *error_mutex;
     GError         *error;
 
-    GMutex         *chunk_mutex;
     GHashTable     *chunk_hash;
 };
 
@@ -182,10 +179,6 @@ pager_init (YelpPager *pager)
     pager->priv->uri   = NULL;
     pager->priv->state = YELP_PAGER_STATE_NEW;
 
-    pager->priv->state_mutex = g_mutex_new ();
-    pager->priv->error_mutex = g_mutex_new ();
-    pager->priv->chunk_mutex = g_mutex_new ();
-
     pager->priv->error = NULL;
     pager->priv->chunk_hash =
 	g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free);
@@ -235,10 +228,6 @@ pager_dispose (GObject *object)
 
     g_object_unref (pager->priv->uri);
 
-    g_mutex_free (pager->priv->state_mutex);
-    g_mutex_free (pager->priv->error_mutex);
-    g_mutex_free (pager->priv->chunk_mutex);
-
     if (pager->priv->error)
 	g_error_free (pager->priv->error);
 
@@ -251,13 +240,6 @@ pager_dispose (GObject *object)
 
 /******************************************************************************/
 
-/**
- * yelp_pager_start:
- * @pager: a #YelpPager.
- *
- * Spawns a thread to process the document.  If the document has already
- * been processed, no thread will be spawned, and %FALSE will be returned.
- **/
 gboolean
 yelp_pager_start (YelpPager *pager)
 {
@@ -266,8 +248,6 @@ yelp_pager_start (YelpPager *pager)
     g_return_val_if_fail (pager != NULL, FALSE);
     g_return_val_if_fail (YELP_IS_PAGER (pager), FALSE);
 
-    yelp_pager_lock_state (pager);
-
     switch (yelp_pager_get_state (pager)) {
     case YELP_PAGER_STATE_NEW:
     case YELP_PAGER_STATE_CANCEL:
@@ -276,36 +256,18 @@ yelp_pager_start (YelpPager *pager)
 	g_object_ref (pager);
 	g_signal_emit (pager, signals[START], 0);
 
-	g_thread_create ((GThreadFunc) (YELP_PAGER_GET_CLASS (pager)->process),
-			 pager, FALSE, &error);
-
-	if (error) {
-	    yelp_pager_unlock_state (pager);
-	    yelp_pager_error (pager, error);
-	    g_object_unref (pager);
+	gtk_idle_add ((GtkFunction) (YELP_PAGER_GET_CLASS (pager)->process),
+		      pager);
 
-	    return FALSE;
-	}
-
-	yelp_pager_unlock_state (pager);
 	g_object_unref (pager);
 	return TRUE;
 
     default:
-	yelp_pager_unlock_state (pager);
 	g_object_unref (pager);
 	return FALSE;
     }
 }
 
-/**
- * yelp_pager_cancel:
- * @pager: a #YelpPager.
- *
- * Cancels the document processing.  The processing thread may continue
- * for a short while after this function returns before it recognizes
- * that it has been cancelled.
- **/
 void
 yelp_pager_cancel (YelpPager *pager)
 {
@@ -315,28 +277,15 @@ yelp_pager_cancel (YelpPager *pager)
     YELP_PAGER_GET_CLASS (pager)->cancel (pager);
 }
 
-/**
- * yelp_pager_get_uri:
- * @pager: a #YelpPager.
- *
- * Returns the URI of the documnt @pager is transforming.
- **/
-const YelpURI *
+YelpURI *
 yelp_pager_get_uri (YelpPager *pager)
 {
     g_return_val_if_fail (pager != NULL, FALSE);
     g_return_val_if_fail (YELP_IS_PAGER (pager), FALSE);
 
-    return (const YelpURI *) (pager->priv->uri);
+    return pager->priv->uri;
 }
 
-/**
- * yelp_pager_get_state:
- * @pager: a #YelpPager
- *
- * Returns the state of @pager.  This does not handle locking itself.  You
- * must call yelp_pager_lock_state before and yelp_pager_unlock_state after.
- **/
 YelpPagerState
 yelp_pager_get_state (YelpPager *pager)
 {
@@ -346,14 +295,6 @@ yelp_pager_get_state (YelpPager *pager)
     return pager->priv->state;
 }
 
-/**
- * yelp_pager_set_state:
- * @pager: a #YelpPager
- * @state: a #YelpPagerState
- *
- * Sets the state of @pager to @state.  This does not handle locking itself. You
- * must call yelp_pager_lock_state before and yelp_pager_unlock_state after.
- **/
 void
 yelp_pager_set_state (YelpPager *pager, YelpPagerState state)
 {
@@ -363,44 +304,6 @@ yelp_pager_set_state (YelpPager *pager, YelpPagerState state)
     pager->priv->state = state;
 }
 
-/**
- * yelp_pager_lock_state:
- * @pager: a #YelpPager.
- *
- * Locks the state @pager.  You should generally maintain a lock on the state
- * across most operations on @pager.
- **/
-void
-yelp_pager_lock_state (YelpPager *pager)
-{
-    g_return_if_fail (pager != NULL);
-    g_return_if_fail (YELP_IS_PAGER (pager));
-
-    g_mutex_lock (pager->priv->state_mutex);
-}
-
-/**
- * yelp_pager_unlock_state:
- * @pager: a #YelpPager.
- *
- * Releases a lock on the state of @pager.
- **/
-void
-yelp_pager_unlock_state (YelpPager *pager)
-{
-    g_return_if_fail (pager != NULL);
-    g_return_if_fail (YELP_IS_PAGER (pager));
-
-    g_mutex_unlock (pager->priv->state_mutex);
-}
-
-/**
- * yelp_pager_get_error:
- * @pager: a #YelpPager.
- *
- * Returns a #GError for the processing error.
- * The caller is responsible for freeing the #GError.
- **/
 GError *
 yelp_pager_get_error (YelpPager *pager)
 {
@@ -409,50 +312,26 @@ yelp_pager_get_error (YelpPager *pager)
     g_return_val_if_fail (pager != NULL, NULL);
     g_return_val_if_fail (YELP_IS_PAGER (pager), NULL);
 
-    g_mutex_lock (pager->priv->error_mutex);
-
     if (pager->priv->error)
 	error = g_error_copy (pager->priv->error);
     else
 	error = NULL;
 
-    g_mutex_unlock (pager->priv->error_mutex);
-
     return error;
 }
 
-/**
- * yelp_pager_error:
- * @pager: a #YelpPager
- * @error: a #GError
- *
- * Sets the error of @pager and emits the "error" signal.  You must
- * release locks on the state before calling this.
- **/
 void
 yelp_pager_error (YelpPager *pager, GError *error)
 {
-    yelp_pager_lock_state (pager);
-    g_mutex_lock (pager->priv->error_mutex);
-
     if (pager->priv->error)
 	g_error_free (pager->priv->error);
     pager->priv->error = error;
 
-    g_mutex_unlock (pager->priv->error_mutex);
-
     yelp_pager_set_state (pager, YELP_PAGER_STATE_ERROR);
 
     g_signal_emit_by_name (pager, "error");
-    yelp_pager_unlock_state (pager);
 }
 
-/**
- * yelp_pager_get_sections:
- * @pager: a #YelpPager
- *
- * Returns a reference to the #GtkTreeModel where the section outline is stored.
- **/
 const GtkTreeModel *
 yelp_pager_get_sections (YelpPager *pager)
 {
@@ -462,14 +341,6 @@ yelp_pager_get_sections (YelpPager *pager)
     return YELP_PAGER_GET_CLASS (pager)->get_sections (pager);
 }
 
-/**
- * yelp_pager_lookup_chunk:
- * @pager: a #YelpPager
- * @uri: a #YelpURI
- *
- * Look up and return the appropriate chunk for @uri, automatically resolving
- * which chunk to use based on the fragment identifier.
- **/
 const gchar *
 yelp_pager_lookup_chunk (YelpPager *pager, YelpURI *uri)
 {
@@ -493,13 +364,6 @@ yelp_pager_lookup_chunk (YelpPager *pager, YelpURI *uri)
     return (const gchar *) chunk;
 }
 
-/**
- * yelp_pager_get_chunk:
- * @pager: a #YelpPager
- * @id: the chunk id
- *
- * Return the chunk with id @id.
- **/
 const gchar *
 yelp_pager_get_chunk (YelpPager *pager, gchar *id)
 {
@@ -508,28 +372,16 @@ yelp_pager_get_chunk (YelpPager *pager, gchar *id)
     g_return_val_if_fail (pager != NULL, NULL);
     g_return_val_if_fail (YELP_IS_PAGER (pager), NULL);
 
-    g_mutex_lock (pager->priv->chunk_mutex);
     chunk = (gchar *) g_hash_table_lookup (pager->priv->chunk_hash, id);
-    g_mutex_unlock (pager->priv->chunk_mutex);
 
     return (const gchar *) chunk;
 }
 
-/**
- * yelp_pager_add_chunk:
- * @pager: a #YelpPager
- * @id: the id of the new chunk
- * @chunk: the contents of the new chunk
- *
- * Add the chunk @chunk with id @id.
- **/
 void 
 yelp_pager_add_chunk (YelpPager *pager, gchar *id, gchar *chunk)
 {
     g_return_if_fail (pager != NULL);
     g_return_if_fail (YELP_IS_PAGER (pager));
 
-    g_mutex_lock (pager->priv->chunk_mutex);
     g_hash_table_insert (pager->priv->chunk_hash, id, chunk);
-    g_mutex_unlock (pager->priv->chunk_mutex);
 }
diff --git a/src/yelp-pager.h b/src/yelp-pager.h
index ef8f5f98..0b647c3a 100644
--- a/src/yelp-pager.h
+++ b/src/yelp-pager.h
@@ -56,7 +56,7 @@ struct _YelpPagerClass {
     GObjectClass    parent_class;
 
     /* Virtual Functions */
-    void                 (*process)      (YelpPager    *pager);
+    gboolean             (*process)      (YelpPager    *pager);
     void                 (*cancel)       (YelpPager    *pager);
     const gchar *        (*resolve_uri)  (YelpPager    *pager,
 					  YelpURI      *uri);
@@ -69,13 +69,11 @@ GType                yelp_pager_get_type     (void);
 gboolean             yelp_pager_start        (YelpPager      *pager);
 void                 yelp_pager_cancel       (YelpPager      *pager);
 
-const YelpURI *      yelp_pager_get_uri      (YelpPager      *pager);
+YelpURI *            yelp_pager_get_uri      (YelpPager      *pager);
 
 YelpPagerState       yelp_pager_get_state    (YelpPager      *pager);
 void                 yelp_pager_set_state    (YelpPager      *pager,
 					      YelpPagerState  state);
-void                 yelp_pager_lock_state   (YelpPager      *pager);
-void                 yelp_pager_unlock_state (YelpPager      *pager);
 
 GError *             yelp_pager_get_error    (YelpPager      *pager);
 void                 yelp_pager_error        (YelpPager      *pager,
diff --git a/src/yelp-scrollkeeper.c b/src/yelp-scrollkeeper.c
index edcd7eb5..71e030ec 100644
--- a/src/yelp-scrollkeeper.c
+++ b/src/yelp-scrollkeeper.c
@@ -257,7 +257,7 @@ scrollkeeper_parse_doc (GNode *parent, xmlNode *xml_node, gchar *docid)
 	node = g_node_append_data (parent, 
                                    yelp_section_new (YELP_SECTION_DOCUMENT,
                                                      title, uri));
-	yelp_uri_unref (uri);
+	g_object_unref (uri);
 
 	if (docseriesid) {
 		g_hash_table_insert (seriesid_hash, docseriesid, node);
@@ -318,7 +318,7 @@ scrollkeeper_parse_toc_section (GNode       *parent,
         node = g_node_append_data (parent, 
                                    yelp_section_new (YELP_SECTION_DOCUMENT_SECTION,
                                                      name, uri));
-	yelp_uri_unref (uri);
+	g_object_unref (uri);
 	g_free (name);
 	
 	for (; next_child != NULL; next_child = next_child->next) {
@@ -511,14 +511,14 @@ scrollkeeper_parse_index_item (GList **index, YelpSection *section, xmlNode *nod
 		YelpURI     *uri;
 		YelpSection *index_section;
 		
-		uri = yelp_uri_get_relative (section->uri, link);
+		uri = yelp_uri_new_relative (section->uri, link);
 		
 		d(g_print ("%s\n", yelp_uri_to_string (uri)));
 		
 		index_section = yelp_section_new (YELP_SECTION_INDEX,
 						  title, uri);
 		
-		yelp_uri_unref (uri);
+		g_object_unref (uri);
 		
 		*index = g_list_prepend (*index, index_section);
 		
diff --git a/src/yelp-section.c b/src/yelp-section.c
index 520053fa..16b9cdd0 100644
--- a/src/yelp-section.c
+++ b/src/yelp-section.c
@@ -45,7 +45,8 @@ yelp_section_new (YelpSectionType  type,
 	}
 	
 	if (uri) {
-		section->uri = yelp_uri_ref (uri);
+		g_object_ref (uri);
+		section->uri = uri;
 	} else {
 		section->uri = NULL;
 	}
@@ -70,7 +71,7 @@ yelp_section_free (YelpSection *section)
 	}
 	
 	if (section->uri) {
-		yelp_uri_unref (section->uri);
+		g_object_unref (section->uri);
 	}
 }
 
diff --git a/src/yelp-uri.c b/src/yelp-uri.c
index 2994a9e3..6967226c 100644
--- a/src/yelp-uri.c
+++ b/src/yelp-uri.c
@@ -146,6 +146,69 @@ yelp_uri_new (const gchar *uri_str)
     return uri;
 }
 
+YelpURI *
+yelp_uri_new_relative (YelpURI *base, const gchar *uri_str)
+{
+    YelpURI    *uri;
+
+    uri = g_object_new (YELP_TYPE_URI, NULL);
+
+    uri_parse_uri (uri, uri_str);
+
+    if (yelp_uri_get_resource_type (uri) == YELP_URI_TYPE_RELATIVE) {
+	switch (yelp_uri_get_resource_type (base)) {
+	case YELP_URI_TYPE_FILE:
+	case YELP_URI_TYPE_DOCBOOK_XML:
+	case YELP_URI_TYPE_DOCBOOK_SGML:
+	case YELP_URI_TYPE_HTML:
+	    if (!uri->priv->path || uri->priv->path[0] == '\0') {
+		// This is just a fragment reference.
+		if (uri->priv->path)
+		    g_free (uri->priv->path);
+
+		uri->priv->path = g_strdup (base->priv->path);
+		uri->priv->type = base->priv->type;
+	    }
+	    else if (uri->priv->path[0] == '/') {
+		uri_resource_type (uri);
+	    }
+	    else {
+		gchar *base_path;
+		gchar *new_path;
+		gchar *slash;
+
+		slash = strrchr (base->priv->path, '/');
+		base_path = g_strndup (base->priv->path,
+				       slash - base->priv->path + 1);
+		new_path = g_strconcat (base_path, uri->priv->path, NULL);
+
+		g_free (base_path);
+		g_free (uri->priv->path);
+
+		uri->priv->path = new_path;
+		uri_resource_type (uri);
+	    }
+	case YELP_URI_TYPE_MAN:
+	case YELP_URI_TYPE_INFO:
+	case YELP_URI_TYPE_GHELP:
+	case YELP_URI_TYPE_GHELP_OTHER:
+	case YELP_URI_TYPE_UNKNOWN:
+	case YELP_URI_TYPE_RELATIVE:
+	case YELP_URI_TYPE_TOC:
+	case YELP_URI_TYPE_INDEX:
+	case YELP_URI_TYPE_PATH:
+	    // FIXME;
+	    break;
+	default:
+	    g_assert_not_reached ();
+	    break;
+	}
+    }
+
+    return uri;
+}
+
+
 gboolean
 yelp_uri_exists (YelpURI *uri)
 {
@@ -239,6 +302,9 @@ yelp_uri_to_string (YelpURI *uri)
     case YELP_URI_TYPE_PATH:
 	type = g_strdup ("path:");
 	break;
+    case YELP_URI_TYPE_RELATIVE:
+	type = g_strdup ("");
+	break;
     default:
 	g_assert_not_reached ();
 	break;
diff --git a/src/yelp-uri.h b/src/yelp-uri.h
index c83eeb31..6552973e 100644
--- a/src/yelp-uri.h
+++ b/src/yelp-uri.h
@@ -69,6 +69,8 @@ struct _YelpURIClass {
 GType           yelp_uri_get_type          (void);
 
 YelpURI *       yelp_uri_new               (const gchar   *uri_str);
+YelpURI *       yelp_uri_new_relative      (YelpURI       *base,
+					    const gchar   *uri_str);
 gboolean        yelp_uri_exists            (YelpURI       *uri);
 
 YelpURIType     yelp_uri_get_resource_type (YelpURI       *uri);
@@ -86,9 +88,6 @@ gboolean        yelp_uri_equal_fragment    (YelpURI       *uri1,
 
 /*
 YelpURI *       yelp_uri_copy             (YelpURI       *uri);
-YelpURI *       yelp_uri_get_relative     (YelpURI       *uri,
-					   const gchar   *link);
-
 YelpURI *       yelp_uri_to_index         (YelpURI       *uri);
 YelpURI *       yelp_uri_from_index       (YelpURI       *uri);
 gboolean        yelp_uri_no_path          (YelpURI       *uri);
diff --git a/src/yelp-window.c b/src/yelp-window.c
index ab4fe45a..c7a32422 100644
--- a/src/yelp-window.c
+++ b/src/yelp-window.c
@@ -37,11 +37,14 @@
 #include <libgnome/gnome-config.h>
 #include <glade/glade.h>
 #include <string.h>
+#include "yelp-cache.h"
+#include "yelp-db-pager.h"
 #include "yelp-error.h"
+#include "yelp-history.h"
 #include "yelp-html.h"
-#include "yelp-util.h"
+#include "yelp-pager.h"
 #include "yelp-section.h"
-#include "yelp-history.h"
+#include "yelp-util.h"
 #include "yelp-window.h"
 
 #define d(x)
@@ -62,11 +65,28 @@ typedef enum {
 static void        window_init		          (YelpWindow        *window);
 static void        window_class_init	          (YelpWindowClass   *klass);
 
+static void        window_error                   (YelpWindow        *window,
+						   GError            *error);
 static void        window_populate                (YelpWindow        *window);
 static GtkWidget * window_create_toolbar          (YelpWindow        *window);
 static GdkPixbuf * window_load_icon               (void);
+static void        window_set_sections            (YelpWindow        *window,
+						   GtkTreeModel      *sections);
 static gboolean    window_handle_uri              (YelpWindow        *window,
 						   YelpURI           *uri);
+static gboolean    window_handle_pager_uri        (YelpWindow        *window,
+						   YelpURI           *uri);
+
+static void        pager_chunk_cb                 (YelpPager         *pager,
+						   gchar             *chunk_id,
+						   gpointer           user_data);
+static void        pager_sections_cb              (YelpPager         *pager,
+						   gpointer           user_data);
+
+static void        html_uri_selected_cb           (YelpHtml          *html,
+						   YelpURI           *uri,
+						   gboolean           handled,
+						   gpointer           user_data);
 
 static void        window_new_window_cb           (gpointer           data,
 						   guint              section,
@@ -98,15 +118,9 @@ static void        window_toggle_history_forward  (YelpHistory       *history,
 static void        window_history_action          (YelpWindow        *window,
 						   YelpHistoryAction  action);
 
-/*
-static void        window_uri_selected_cb         (gpointer           view,
-						   YelpURI           *uri,
-						   gboolean           handled,
-						   YelpWindow        *window);
-static void        window_title_changed_cb        (gpointer           view,
-						   const gchar       *title,
-						   YelpWindow        *window);
 
+
+/*
 static void        window_index_button_clicked    (GtkWidget         *button,
 						   YelpWindow        *window);
 static void        window_find_cb                 (gpointer data,     guint section,
@@ -155,6 +169,10 @@ struct _YelpWindowPriv {
 
     YelpHistory    *history;
 
+    YelpPager      *pager;
+    gulong          chunk_handler;
+    gulong          sections_handler;
+
     GtkItemFactory *item_factory;
 
     GtkWidget      *forward_button;
@@ -320,6 +338,23 @@ yelp_window_get_current_uri (YelpWindow *window)
 /******************************************************************************/
 
 static void
+window_error (YelpWindow *window, GError *error)
+{
+    GtkWidget *dialog;
+
+    if (error) {
+	dialog = gtk_message_dialog_new
+	    (GTK_WINDOW (window),
+	     GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
+	     GTK_MESSAGE_ERROR,
+	     GTK_BUTTONS_OK,
+	     error->message);
+	gtk_dialog_run (GTK_DIALOG (dialog));
+	gtk_widget_destroy (dialog);
+    }
+}
+
+static void
 window_populate (YelpWindow *window)
 {
     YelpWindowPriv *priv;
@@ -350,16 +385,21 @@ window_populate (YelpWindow *window)
 				   menu_items,
 				   window);
 
-    menu_item = gtk_item_factory_get_item_by_action (priv->item_factory,
-						     YELP_WINDOW_ACTION_BACK);
-    gtk_widget_set_sensitive (menu_item, FALSE);
+    menu_item =
+	gtk_item_factory_get_item_by_action (priv->item_factory,
+					     YELP_WINDOW_ACTION_BACK);
+    if (menu_item)
+	gtk_widget_set_sensitive (menu_item, FALSE);
 
-    menu_item = gtk_item_factory_get_item_by_action (priv->item_factory,
-						     YELP_WINDOW_ACTION_FORWARD);
-    gtk_widget_set_sensitive (menu_item, FALSE);
+    menu_item =
+	gtk_item_factory_get_item_by_action (priv->item_factory,
+					     YELP_WINDOW_ACTION_FORWARD);
+    if (menu_item)
+	gtk_widget_set_sensitive (menu_item, FALSE);
 
     gtk_box_pack_start (GTK_BOX (main_box),
-			GTK_WIDGET (gtk_item_factory_get_widget (priv->item_factory, "<main>")),
+			GTK_WIDGET (gtk_item_factory_get_widget
+				    (priv->item_factory, "<main>")),
 			FALSE, FALSE, 0);
 
     toolbar = window_create_toolbar (window);
@@ -370,8 +410,21 @@ window_populate (YelpWindow *window)
 			
     priv->pane = gtk_hpaned_new ();
 
+    sw = gtk_scrolled_window_new (NULL, NULL);
+    gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
+				    GTK_POLICY_AUTOMATIC,
+				    GTK_POLICY_AUTOMATIC);
+
     priv->side_sects = gtk_tree_view_new ();
-    gtk_paned_add1 (GTK_PANED (priv->pane), priv->side_sects);
+    gtk_tree_view_insert_column_with_attributes
+	(GTK_TREE_VIEW (priv->side_sects), -1,
+	 _("Section"), gtk_cell_renderer_text_new (),
+	 "text", 0,
+	 NULL);
+    gtk_container_add (GTK_CONTAINER (sw),
+		       priv->side_sects);
+
+    gtk_paned_add1 (GTK_PANED (priv->pane), sw);
 
     sw = gtk_scrolled_window_new (NULL, NULL);
     gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
@@ -379,6 +432,11 @@ window_populate (YelpWindow *window)
 				    GTK_POLICY_AUTOMATIC);
 
     priv->html_view  = yelp_html_new ();
+    g_signal_connect (priv->html_view,
+		      "uri_selected",
+		      G_CALLBACK (html_uri_selected_cb),
+		      window);
+
     gtk_container_add (GTK_CONTAINER (sw),
 		       yelp_html_get_widget (priv->html_view));
 
@@ -466,6 +524,19 @@ window_load_icon (void)
     return pixbuf;
 }
 
+static void
+window_set_sections (YelpWindow   *window,
+		     GtkTreeModel *sections)
+{
+    YelpWindowPriv *priv;
+
+    g_return_if_fail (YELP_IS_WINDOW (window));
+
+    priv = window->priv;
+
+    gtk_tree_view_set_model (GTK_TREE_VIEW (priv->side_sects), sections);
+}
+
 static gboolean
 window_handle_uri (YelpWindow *window,
 		   YelpURI    *uri)
@@ -476,6 +547,9 @@ window_handle_uri (YelpWindow *window,
 
     priv = window->priv;
 
+    g_return_val_if_fail (YELP_IS_WINDOW (window), FALSE);
+    g_return_val_if_fail (YELP_IS_URI (uri), FALSE);
+
     if (!yelp_uri_exists (uri)) {
 	gchar *str_uri = yelp_uri_to_string (uri);
 		
@@ -484,30 +558,226 @@ window_handle_uri (YelpWindow *window,
 		     YELP_ERROR_URI_NOT_EXIST,
 		     _("The document '%s' does not exist"), str_uri);
 	g_free (str_uri);
-    } else {
-	//FIXME
+
+	window_error (window, error);
+
+	return FALSE;
+    }
+
+    switch (yelp_uri_get_resource_type (uri)) {
+    case YELP_URI_TYPE_DOCBOOK_XML:
+    case YELP_URI_TYPE_MAN:
+    case YELP_URI_TYPE_INFO:
+	handled = window_handle_pager_uri (window, uri);
+	break;
+    case YELP_URI_TYPE_DOCBOOK_SGML:
+	// FIXME: Error out
+	break;
+    case YELP_URI_TYPE_HTML:
+    case YELP_URI_TYPE_GHELP:
+    case YELP_URI_TYPE_GHELP_OTHER:
+    case YELP_URI_TYPE_TOC:
+    case YELP_URI_TYPE_INDEX:
+    case YELP_URI_TYPE_PATH:
+    case YELP_URI_TYPE_FILE:
+    case YELP_URI_TYPE_UNKNOWN:
+    case YELP_URI_TYPE_RELATIVE:
+    default:
+	break;
+    }
+
+    if (error)
+	window_error (window, error);
+
+    return handled;
+}
+
+static gboolean
+window_handle_pager_uri (YelpWindow *window,
+			 YelpURI    *uri)
+{
+    YelpWindowPriv *priv;
+    GError         *error = NULL;
+    gboolean    loadnow  = FALSE;
+    gboolean    startnow = TRUE;
+    gchar      *path;
+    gchar      *chunk = NULL;
+    YelpPager  *pager;
+
+    priv = window->priv;
+
+    // Disconnect signal handlers
+    if (priv->chunk_handler) {
+	g_signal_handler_disconnect (priv->pager,
+				     priv->chunk_handler);
+	priv->chunk_handler = 0;
+    }
+    if (priv->sections_handler) {
+	g_signal_handler_disconnect (priv->pager,
+				     priv->sections_handler);
+	priv->sections_handler = 0;
+    }
+
+    // Grab the appropriate pager from the cache
+    path  = yelp_uri_get_path (uri);
+    pager = (YelpPager *) yelp_cache_lookup (path);
+
+    // Create a new pager if one doesn't exist in the cache
+    if (!pager) {
 	switch (yelp_uri_get_resource_type (uri)) {
 	case YELP_URI_TYPE_DOCBOOK_XML:
-	case YELP_URI_TYPE_DOCBOOK_SGML:
-	case YELP_URI_TYPE_HTML:
-	case YELP_URI_TYPE_MAN:
+	    pager = yelp_db_pager_new (uri);
+	    break;
 	case YELP_URI_TYPE_INFO:
-	case YELP_URI_TYPE_GHELP:
-	case YELP_URI_TYPE_GHELP_OTHER:
-	case YELP_URI_TYPE_TOC:
-	case YELP_URI_TYPE_INDEX:
-	case YELP_URI_TYPE_PATH:
-	case YELP_URI_TYPE_FILE:
-	case YELP_URI_TYPE_UNKNOWN:
-	case YELP_URI_TYPE_RELATIVE:
+	    // FIXME
+	    break;
+	case YELP_URI_TYPE_MAN:
+	    // FIXME
+	    break;
 	default:
+	    // FIXME: Error
 	    break;
 	}
+
+	if (pager)
+	    yelp_cache_add (path, (GObject *) pager);
     }
 
-    return handled;
+    g_object_ref (pager);
+    if (priv->pager)
+	g_object_unref (priv->pager);
+    priv->pager = pager;
+
+    switch (yelp_pager_get_state (pager)) {
+    case YELP_PAGER_STATE_START:
+	chunk = (gchar *) yelp_pager_lookup_chunk (pager, uri);
+	loadnow  = (chunk ? TRUE : FALSE);
+	startnow = FALSE;
+	break;
+    case YELP_PAGER_STATE_NEW:
+    case YELP_PAGER_STATE_CANCEL:
+	loadnow  = FALSE;
+	startnow = TRUE;
+	break;
+    case YELP_PAGER_STATE_FINISH:
+	chunk = (gchar *) yelp_pager_lookup_chunk (pager, uri);
+	loadnow = TRUE;
+	break;
+    case YELP_PAGER_STATE_ERROR:
+	printf ("ERROR\n");
+	// FIXME: show error
+	return FALSE;
+    default:
+    	g_assert_not_reached ();
+	break;
+    }
+
+    if (!loadnow) {
+	priv->chunk_handler =
+	    g_signal_connect (pager,
+			      "chunk",
+			      G_CALLBACK (pager_chunk_cb),
+			      window);
+	priv->sections_handler =
+	    g_signal_connect (pager,
+			      "sections",
+			      G_CALLBACK (pager_sections_cb),
+			      window);
+
+	if (startnow)
+	    yelp_pager_start (pager);
+    } else {
+	if (!chunk) {
+	    gchar *str_uri = yelp_uri_to_string (uri);
+	    g_set_error (&error,
+			 YELP_ERROR,
+			 YELP_ERROR_FAILED_OPEN,
+			 _("The document '%s' could not be opened"), str_uri);
+	    g_free (str_uri);
+
+	    window_error (window, error);
+	    return FALSE;
+	}
+
+	window_set_sections (window,
+			     GTK_TREE_MODEL (yelp_pager_get_sections (pager)));
+
+	yelp_html_clear (window->priv->html_view);
+	yelp_html_set_base_uri (window->priv->html_view, uri);
+	yelp_html_write (window->priv->html_view,
+			 chunk, strlen (chunk));
+    }
+
+    return TRUE;
+}
+
+static void
+pager_chunk_cb (YelpPager *pager,
+		gchar     *chunk_id,
+		gpointer   user_data)
+{
+    YelpWindow *window = YELP_WINDOW (user_data);
+    YelpURI    *uri;
+    gchar      *frag;
+    gchar      *chunk;
+
+    uri  = yelp_window_get_current_uri (window);
+    frag = yelp_uri_get_fragment (uri);
+
+    if ( (yelp_uri_equal_path (uri, yelp_pager_get_uri (pager))) &&
+	 ( (frag == NULL && !strcmp (chunk_id, "index")) || 
+	   (!strcmp (frag, chunk_id)) )) {
+
+	if (window->priv->chunk_handler) {
+	    g_signal_handler_disconnect (window->priv->pager,
+					 window->priv->chunk_handler);
+	    window->priv->chunk_handler = 0;
+	}
+
+	chunk = (gchar *) yelp_pager_get_chunk (pager, chunk_id);
+	yelp_html_clear (window->priv->html_view);
+
+	yelp_html_set_base_uri (window->priv->html_view, uri);
+
+	yelp_html_write (window->priv->html_view,
+			 chunk, strlen (chunk));
+    }
+
+    g_free (frag);
 }
 
+static void
+pager_sections_cb (YelpPager *pager,
+		    gpointer   user_data)
+{
+    YelpWindow *window = YELP_WINDOW (user_data);
+    YelpURI    *uri;
+
+    uri  = yelp_window_get_current_uri (window);
+
+    if ( (yelp_uri_equal_path (uri, yelp_pager_get_uri (pager)))) {
+	if (window->priv->sections_handler) {
+	    g_signal_handler_disconnect (window->priv->pager,
+					 window->priv->sections_handler);
+	    window->priv->sections_handler = 0;
+	}
+
+	window_set_sections (window,
+			     GTK_TREE_MODEL (yelp_pager_get_sections (pager)));
+    }
+}
+
+static void
+html_uri_selected_cb (YelpHtml  *html,
+		      YelpURI   *uri,
+		      gboolean   handled,
+		      gpointer   user_data)
+{
+    YelpWindow *window = YELP_WINDOW (user_data);
+    yelp_window_open_uri (window, uri);
+}
+
+
 /******************************************************************************/
 
 static void
@@ -634,7 +904,8 @@ window_toggle_history_back (YelpHistory *history,
 
     menu_item = gtk_item_factory_get_item_by_action (priv->item_factory,
 						     YELP_WINDOW_ACTION_BACK);
-    gtk_widget_set_sensitive (menu_item, sensitive);
+    if (menu_item)
+	gtk_widget_set_sensitive (menu_item, sensitive);
 }
 
 static void
@@ -654,7 +925,8 @@ window_toggle_history_forward (YelpHistory *history,
 
     menu_item = gtk_item_factory_get_item_by_action (priv->item_factory,
 						     YELP_WINDOW_ACTION_FORWARD);
-    gtk_widget_set_sensitive (menu_item, sensitive);
+    if (menu_item)
+	gtk_widget_set_sensitive (menu_item, sensitive);
 }
 
 static void