Moved from Mate-Extra repository

22 files changed, 7788 insertions, 0 deletions

diff --git a/mate-dictionary/src/Makefile.am b/mate-dictionary/src/Makefile.am
new file mode 100644
index 00000000..ddde3d26
--- /dev/null
+++ b/mate-dictionary/src/Makefile.am
@@ -0,0 +1,82 @@
+NULL =
+
+INCLUDES = \
+	-DPREFIX=\""$(prefix)"\"			\
+	-DSYSCONFDIR=\""$(sysconfdir)"\"		\
+	-DLIBDIR=\""$(libdir)"\"			\
+	-DDATADIR=\""$(datadir)"\" 			\
+	-DUIDATADIR=\""$(datadir)/mate-2.0/ui"\" 	\
+	-DPKGDATADIR=\""$(datadir)/mate-dictionary"\" 	\
+	-DMATELOCALEDIR=\""$(prefix)/$(DATADIRNAME)/locale"\" \
+	$(NULL)
+
+bin_PROGRAMS = mate-dictionary
+
+if BUILD_GDICT_APPLET
+libexec_PROGRAMS = mate-dictionary-applet
+endif
+
+mate_dictionary_SOURCES = \
+	gdict-about.c		\
+	gdict-about.h		\
+	gdict-app.c		\
+	gdict-app.h		\
+	gdict-common.c 		\
+	gdict-common.h		\
+	gdict-pref-dialog.c	\
+	gdict-pref-dialog.h	\
+	gdict-print.c 		\
+	gdict-print.h 		\
+	gdict-sidebar.c		\
+	gdict-sidebar.h		\
+	gdict-source-dialog.c 	\
+	gdict-source-dialog.h 	\
+	gdict-window.c 		\
+	gdict-window.h 		\
+	main.c			\
+	$(NULL)
+mate_dictionary_CFLAGS = \
+	-I$(top_builddir)/mate-dictionary \
+	-I$(top_srcdir)/mate-dictionary \
+	$(MATE_UTILS_CFLAGS) \
+	$(NULL)
+mate_dictionary_LDADD = \
+	-lm			\
+	$(top_builddir)/mate-dictionary/libgdict/libmatedict.la \
+	$(MATE_UTILS_LIBS) \
+	$(NULL)
+
+if BUILD_GDICT_APPLET
+
+mate_dictionary_applet_SOURCES = \
+	gdict-about.c 		\
+	gdict-about.h		\
+	gdict-aligned-window.c	\
+	gdict-aligned-window.h	\
+	gdict-applet.c		\
+	gdict-applet.h		\
+	gdict-common.c		\
+	gdict-common.h		\
+	gdict-pref-dialog.c	\
+	gdict-pref-dialog.h	\
+	gdict-print.c 		\
+	gdict-print.h 		\
+	gdict-sidebar.c		\
+	gdict-sidebar.h		\
+	gdict-source-dialog.c 	\
+	gdict-source-dialog.h 	\
+	$(NULL)
+mate_dictionary_applet_CFLAGS = \
+	-I$(top_builddir)/mate-dictionary \
+	-I$(top_srcdir)/mate-dictionary \
+	$(MATE_UTILS_CFLAGS) \
+	$(APPLET_CFLAGS) \
+	$(NULL)
+mate_dictionary_applet_LDADD = \
+	-lm			\
+	$(top_builddir)/mate-dictionary/libgdict/libmatedict.la \
+	$(MATE_UTILS_LIBS) \
+	$(APPLET_LIBS) \
+	$(NULL)
+
+endif # BUILD_GDICT_APPLET
diff --git a/mate-dictionary/src/gdict-about.c b/mate-dictionary/src/gdict-about.c
new file mode 100644
index 00000000..dc74b560
--- /dev/null
+++ b/mate-dictionary/src/gdict-about.c
@@ -0,0 +1,90 @@
+/* gdict-about.c - GtkAboutDialog wrapper
+ *
+ * This file is part of MATE Dictionary
+ *
+ * Copyright (C) 2005 Emmanuele Bassi
+ *
+ * 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.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <glib/gi18n.h>
+#include <gdk-pixbuf/gdk-pixbuf.h>
+
+#include "gdict-about.h"
+
+void
+gdict_show_about_dialog (GtkWidget *parent)
+{
+  const gchar *authors[] = {
+    "Mike Hughes <[email protected]>",
+    "Spiros Papadimitriou <[email protected]>",
+    "Bradford Hovinen <[email protected]>",
+    "Vincent Noel <[email protected]>",
+    "Emmanuele Bassi <[email protected]>",
+    NULL
+  };
+
+  const gchar *documenters[] = {
+    "Sun MATE Documentation Team <[email protected]>",
+    "John Fleck <[email protected]>",
+    "Emmanuele Bassi <[email protected]>",
+    NULL
+  };
+
+  const gchar *translator_credits = _("translator-credits");
+  const gchar *copyright = "Copyright \xc2\xa9 2005-2006 Emmanuele Bassi";
+  const gchar *comments = _("Look up words in dictionaries");
+  
+  const gchar *license =
+    "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.\n"
+    "\n"
+    "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.\n"
+    "\n"
+    "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.\n";
+
+  g_return_if_fail (GTK_IS_WIDGET (parent));
+  
+  gtk_show_about_dialog (GTK_IS_WINDOW (parent) ? GTK_WINDOW (parent) : NULL,
+  			 "name", _("Dictionary"),
+  			 "version", VERSION,
+  			 "copyright", copyright,
+  			 "comments", comments,
+  			 "authors", authors,
+  			 "documenters", documenters,
+  			 "translator-credits", translator_credits,
+  			 "logo-icon-name", "accessories-dictionary",
+  			 "license", license,
+  			 "wrap-license", TRUE,
+			 "screen", gtk_widget_get_screen (parent),
+  			 NULL);
+}
diff --git a/mate-dictionary/src/gdict-about.h b/mate-dictionary/src/gdict-about.h
new file mode 100644
index 00000000..2e6467cf
--- /dev/null
+++ b/mate-dictionary/src/gdict-about.h
@@ -0,0 +1,30 @@
+/* gdict-about.h - GtkAboutDialog wrapper
+ *
+ * This file is part of MATE Dictionary
+ *
+ * Copyright (C) 2005 Emmanuele Bassi
+ *
+ * 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.
+ */
+
+#ifndef __GDICT_ABOUT_H__
+#define __GDICT_ABOUT_H__
+
+#include <gtk/gtk.h>
+
+void gdict_show_about_dialog (GtkWidget *parent);
+
+#endif /* __GDICT_ABOUT_H__ */
diff --git a/mate-dictionary/src/gdict-aligned-window.c b/mate-dictionary/src/gdict-aligned-window.c
new file mode 100644
index 00000000..c7ddf83e
--- /dev/null
+++ b/mate-dictionary/src/gdict-aligned-window.c
@@ -0,0 +1,348 @@
+/* gdict-aligned-window.c - Popup window aligned to a widget
+ *
+ * Copyright (c) 2005-2006  Emmanuele Bassi <[email protected]>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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 Library 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
+ *
+ * Ported from Seth Nickell's Python class:
+ *   Copyright (c) 2003 Seth Nickell
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <gtk/gtk.h>
+
+#include "gdict-aligned-window.h"
+
+#define GDICT_ALIGNED_WINDOW_GET_PRIVATE(obj)	(G_TYPE_INSTANCE_GET_PRIVATE ((obj), GDICT_TYPE_ALIGNED_WINDOW, GdictAlignedWindowPrivate))
+
+struct _GdictAlignedWindowPrivate
+{
+  GtkWidget *align_widget;
+  
+  guint motion_id;
+};
+
+enum
+{
+  PROP_0,
+  
+  PROP_ALIGN_WIDGET
+};
+
+static void gdict_aligned_window_finalize     (GObject      *object);
+static void gdict_aligned_window_get_property (GObject      *object,
+					       guint         prop_id,
+					       GValue       *value,
+					       GParamSpec   *pspec);
+static void gdict_aligned_window_set_property (GObject      *object,
+					       guint         prop_id,
+					       const GValue *value,
+					       GParamSpec   *pspec);
+
+static void     gdict_aligned_window_realize          (GtkWidget        *widget);
+static void     gdict_aligned_window_show             (GtkWidget        *widget);
+
+static gboolean gdict_aligned_window_motion_notify_cb (GtkWidget        *widget,
+						       GdkEventMotion   *event,
+						       GdictAlignedWindow *aligned_window);
+
+
+G_DEFINE_TYPE (GdictAlignedWindow, gdict_aligned_window, GTK_TYPE_WINDOW);
+
+
+
+static void
+gdict_aligned_window_class_init (GdictAlignedWindowClass *klass)
+{
+  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+  GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
+  
+  gobject_class->set_property = gdict_aligned_window_set_property;
+  gobject_class->get_property = gdict_aligned_window_get_property;
+  gobject_class->finalize = gdict_aligned_window_finalize;
+  
+  widget_class->realize = gdict_aligned_window_realize;
+  widget_class->show = gdict_aligned_window_show;
+  
+  g_object_class_install_property (gobject_class, PROP_ALIGN_WIDGET,
+  				   g_param_spec_object ("align-widget",
+  				   			"Align Widget",
+  				   			"The widget the window should align to",
+  				   			GTK_TYPE_WIDGET,
+  				   			G_PARAM_READWRITE));
+  
+  g_type_class_add_private (klass, sizeof (GdictAlignedWindowPrivate));
+}
+
+static void
+gdict_aligned_window_init (GdictAlignedWindow *aligned_window)
+{
+  GdictAlignedWindowPrivate *priv = GDICT_ALIGNED_WINDOW_GET_PRIVATE (aligned_window);
+  GtkWindow *window = GTK_WINDOW (aligned_window);
+  
+  aligned_window->priv = priv;
+  
+  priv->align_widget = NULL;
+  priv->motion_id = 0;
+  
+  /* set window properties */
+#if 0
+  gtk_window_set_modal (window, TRUE);
+#endif
+  gtk_window_set_decorated (window, FALSE);
+  gtk_window_set_type_hint (window, GDK_WINDOW_TYPE_HINT_DOCK);
+}
+
+static void
+gdict_aligned_window_get_property (GObject    *object,
+				   guint       prop_id,
+				   GValue     *value,
+				   GParamSpec *pspec)
+{
+  GdictAlignedWindow *aligned_window = GDICT_ALIGNED_WINDOW (object);
+  
+  switch (prop_id)
+    {
+    case PROP_ALIGN_WIDGET:
+      g_value_set_object (value, aligned_window->priv->align_widget);
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+    }
+}
+
+static void
+gdict_aligned_window_set_property (GObject      *object,
+				   guint         prop_id,
+				   const GValue *value,
+				   GParamSpec   *pspec)
+{
+  GdictAlignedWindow *aligned_window = GDICT_ALIGNED_WINDOW (object);
+  
+  switch (prop_id)
+    {
+    case PROP_ALIGN_WIDGET:
+      gdict_aligned_window_set_widget (aligned_window,
+      				       g_value_get_object (value));
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+    }
+}
+
+static void
+gdict_aligned_window_position (GdictAlignedWindow *window)
+{
+  GdictAlignedWindowPrivate *priv;
+  GtkWidget *align_widget;
+  gint our_width, our_height;
+  gint entry_x, entry_y, entry_width, entry_height;
+  gint x, y;
+  GdkGravity gravity = GDK_GRAVITY_NORTH_WEST;
+  GdkWindow *gdk_window;
+
+  g_assert (GDICT_IS_ALIGNED_WINDOW (window));
+  priv = window->priv;
+
+  if (!priv->align_widget)
+    return;
+
+  align_widget = priv->align_widget;
+  gdk_window = gtk_widget_get_window (align_widget);
+
+  gdk_flush ();
+  
+  gdk_window_get_geometry (gtk_widget_get_window (GTK_WIDGET (window)),
+  			   NULL,
+  			   NULL,
+  			   &our_width,
+  			   &our_height,
+  			   NULL);
+  
+  /* stick, skip taskbar and pager */
+  gtk_window_stick (GTK_WINDOW (window));
+  gtk_window_set_skip_taskbar_hint (GTK_WINDOW (window), TRUE);
+  gtk_window_set_skip_pager_hint (GTK_WINDOW (window), TRUE);
+
+  /* make sure the align_widget is realized before we do anything */
+  gtk_widget_realize (align_widget);
+  
+  /* get the positional and dimensional attributes of the align widget */
+  gdk_window_get_origin (gdk_window,
+  			 &entry_x,
+  			 &entry_y);
+  gdk_window_get_geometry (gdk_window,
+  			   NULL,
+  			   NULL,
+  			   &entry_width,
+  			   &entry_height,
+  			   NULL);
+  
+  if (entry_x + our_width < gdk_screen_width ())
+    x = entry_x + 1;
+  else
+    {
+      x = entry_x + entry_width - our_width - 1;
+      
+      gravity = GDK_GRAVITY_NORTH_EAST;
+    }
+  
+  if (entry_y + entry_height + our_height < gdk_screen_height ())
+    y = entry_y + entry_height - 1;
+  else
+    {
+      y = entry_y - our_height + 1;
+      
+      if (gravity == GDK_GRAVITY_NORTH_EAST)
+	gravity = GDK_GRAVITY_SOUTH_EAST;
+      else
+	gravity = GDK_GRAVITY_SOUTH_WEST;
+    }
+  
+  gtk_window_set_gravity (GTK_WINDOW (window), gravity);
+  gtk_window_move (GTK_WINDOW (window), x, y);
+}
+
+static void
+gdict_aligned_window_realize (GtkWidget *widget)
+{
+  GTK_WIDGET_CLASS (gdict_aligned_window_parent_class)->realize (widget);
+
+  gdict_aligned_window_position (GDICT_ALIGNED_WINDOW (widget));
+}
+
+static void
+gdict_aligned_window_show (GtkWidget *widget)
+{
+  gdict_aligned_window_position (GDICT_ALIGNED_WINDOW (widget));
+  
+  GTK_WIDGET_CLASS (gdict_aligned_window_parent_class)->show (widget);
+}
+
+static void
+gdict_aligned_window_finalize (GObject *object)
+{
+  G_OBJECT_CLASS (gdict_aligned_window_parent_class)->finalize (object);
+}
+
+static gboolean
+gdict_aligned_window_motion_notify_cb (GtkWidget        *widget,
+				       GdkEventMotion   *event,
+				       GdictAlignedWindow *aligned_window)
+{
+  GtkAllocation alloc;
+  GdkRectangle rect;
+
+  gtk_widget_get_allocation (GTK_WIDGET (aligned_window), &alloc);
+  
+  rect.x = 0;
+  rect.y = 0;
+  rect.width = alloc.width;
+  rect.height = alloc.height;
+
+  gdk_window_invalidate_rect (gtk_widget_get_window (GTK_WIDGET (aligned_window)),
+		  	      &rect,
+			      FALSE);
+  
+  return FALSE;
+}
+
+
+/**
+ * gdict_aligned_window_new:
+ * @align_widget: a #GtkWidget to which the window should align
+ *
+ * Creates a new window, aligned to a previously created widget.
+ *
+ * Return value: a new #GdictAlignedWindow
+ */
+GtkWidget *
+gdict_aligned_window_new (GtkWidget *align_widget)
+{
+  return g_object_new (GDICT_TYPE_ALIGNED_WINDOW,
+  		       "align-widget", align_widget,
+  		       NULL);
+}
+
+/**
+ * gdict_aligned_window_set_widget:
+ * @aligned_window: a #GdictAlignedWindow
+ * @align_widget: the #GtkWidget @aligned_window should align to
+ *
+ * Sets @align_widget as the #GtkWidget to which @aligned_window should
+ * align.
+ *
+ * Note that @align_widget must have a #GdkWindow in order to
+ * #GdictAlignedWindow to work.
+ */
+void
+gdict_aligned_window_set_widget (GdictAlignedWindow *aligned_window,
+			         GtkWidget          *align_widget)
+{
+  GdictAlignedWindowPrivate *priv;
+  
+  g_return_if_fail (GDICT_IS_ALIGNED_WINDOW (aligned_window));
+  g_return_if_fail (GTK_IS_WIDGET (align_widget));
+
+#if 0  
+  if (GTK_WIDGET_NO_WINDOW (align_widget))
+    {
+      g_warning ("Attempting to set a widget of class '%s' as the "
+                 "align widget, but widgets of this class does not "
+                 "have a GdkWindow.",
+                 g_type_name (G_OBJECT_TYPE (align_widget)));
+      
+      return;
+    }
+#endif
+
+  priv = GDICT_ALIGNED_WINDOW_GET_PRIVATE (aligned_window);
+  
+  if (priv->align_widget)
+    {
+      g_signal_handler_disconnect (priv->align_widget, priv->motion_id);
+      priv->align_widget = NULL;
+    }
+
+  priv->align_widget = align_widget;
+  priv->motion_id = g_signal_connect (priv->align_widget, "motion-notify-event",
+				      G_CALLBACK (gdict_aligned_window_motion_notify_cb),
+				      aligned_window);
+}
+
+/**
+ * gdict_aligned_window_get_widget:
+ * @aligned_window: a #GdictAlignedWindow
+ *
+ * Retrieves the #GtkWidget to which @aligned_window is aligned to.
+ *
+ * Return value: the align widget.
+ */
+GtkWidget *
+gdict_aligned_window_get_widget (GdictAlignedWindow *aligned_window)
+{
+  g_return_val_if_fail (GDICT_IS_ALIGNED_WINDOW (aligned_window), NULL);
+  
+  return aligned_window->priv->align_widget;
+}
diff --git a/mate-dictionary/src/gdict-aligned-window.h b/mate-dictionary/src/gdict-aligned-window.h
new file mode 100644
index 00000000..8647f272
--- /dev/null
+++ b/mate-dictionary/src/gdict-aligned-window.h
@@ -0,0 +1,69 @@
+/* gdict-aligned-widget.h - Popup window aligned to a widget
+ *
+ * Copyright (c) 2005  Emmanuele Bassi <[email protected]>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library 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 Library 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
+ *
+ * Ported from Seth Nickell's Python class:
+ *   Copyright (c) 2003 Seth Nickell
+ */
+
+#ifndef __GDICT_ALIGNED_WINDOW_H__
+#define __GDICT_ALIGNED_WINDOW_H__
+
+#include <gtk/gtk.h>
+
+G_BEGIN_DECLS
+
+#define GDICT_TYPE_ALIGNED_WINDOW		(gdict_aligned_window_get_type ())
+#define GDICT_ALIGNED_WINDOW(obj)		(G_TYPE_CHECK_INSTANCE_CAST ((obj), GDICT_TYPE_ALIGNED_WINDOW, GdictAlignedWindow))
+#define GDICT_IS_ALIGNED_WINDOW(obj)		(G_TYPE_CHECK_INSTANCE_TYPE ((obj), GDICT_TYPE_ALIGNED_WINDOW))
+#define GDICT_ALIGNED_WINDOW_CLASS(klass)	(G_TYPE_CHECK_CLASS_CAST ((klass), GDICT_TYPE_ALIGNED_WINDOW, GdictAlignedWindowClass))
+#define GDICT_IS_ALIGNED_WINDOW_CLASS(klass)	(G_TYPE_CHECK_CLASS_TYPE ((klass), GDICT_TYPE_ALIGNED_WINDOW))
+#define GDICT_ALIGNED_WINDOW_GET_CLASS(obj)	(G_TYPE_INSTANCE_GET_CLASS ((obj), GDICT_TYPE_ALIGNED_WINDOW, GdictAlignedWindowClass))
+
+typedef struct _GdictAlignedWindow        GdictAlignedWindow;
+typedef struct _GdictAlignedWindowClass	  GdictAlignedWindowClass;
+typedef struct _GdictAlignedWindowPrivate GdictAlignedWindowPrivate;
+
+struct _GdictAlignedWindow
+{
+  /*< private >*/
+  GtkWindow parent_instance;
+  
+  GdictAlignedWindowPrivate *priv;
+};
+
+struct _GdictAlignedWindowClass
+{
+  /*< private >*/
+  GtkWindowClass parent_class;
+  
+  void (*_gdict_reserved1) (void);
+  void (*_gdict_reserved2) (void);
+  void (*_gdict_reserved3) (void);
+  void (*_gdict_reserved4) (void);
+};
+
+GType      gdict_aligned_window_get_type   (void) G_GNUC_CONST;
+
+GtkWidget *gdict_aligned_window_new        (GtkWidget          *align_widget);
+void       gdict_aligned_window_set_widget (GdictAlignedWindow *aligned_window,
+					    GtkWidget          *align_widget);
+GtkWidget *gdict_aligned_window_get_widget (GdictAlignedWindow *aligned_window);
+
+G_END_DECLS
+
+#endif
diff --git a/mate-dictionary/src/gdict-app.c b/mate-dictionary/src/gdict-app.c
new file mode 100644
index 00000000..eab6bbd8
--- /dev/null
+++ b/mate-dictionary/src/gdict-app.c
@@ -0,0 +1,475 @@
+/* gdict-app.c - main application class
+ *
+ * This file is part of MATE Dictionary
+ *
+ * Copyright (C) 2005 Emmanuele Bassi
+ *
+ * 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.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+#include <sys/stat.h>
+
+#include <gtk/gtk.h>
+#include <glib.h>
+#include <glib/gi18n.h>
+
+#include "gdict-common.h"
+#include "gdict-pref-dialog.h"
+#include "gdict-app.h"
+
+static GdictApp *singleton = NULL;
+
+
+struct _GdictAppClass
+{
+  GObjectClass parent_class;
+};
+
+
+
+G_DEFINE_TYPE (GdictApp, gdict_app, G_TYPE_OBJECT);
+
+
+static void
+gdict_app_finalize (GObject *object)
+{
+  GdictApp *app = GDICT_APP (object);
+  
+  if (app->loader)
+    g_object_unref (app->loader);
+  
+  app->current_window = NULL;
+  
+  g_slist_foreach (app->windows,
+  		   (GFunc) gtk_widget_destroy,
+  		   NULL);
+  g_slist_free (app->windows);
+
+  g_slist_foreach (app->lookup_words, (GFunc) g_free, NULL);
+  g_slist_free (app->lookup_words);
+
+  g_slist_foreach (app->match_words, (GFunc) g_free, NULL);
+  g_slist_free (app->match_words);
+
+  g_free (app->database);
+  g_free (app->source_name);
+
+  G_OBJECT_CLASS (gdict_app_parent_class)->finalize (object);
+}
+
+static void
+gdict_app_class_init (GdictAppClass *klass)
+{
+  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+  
+  gobject_class->finalize = gdict_app_finalize;
+}
+
+static void
+gdict_app_init (GdictApp *app)
+{
+  app->windows = NULL;
+  app->current_window = NULL;
+}
+
+static void
+gdict_window_destroy_cb (GtkWidget *widget,
+		         gpointer   user_data)
+{
+  GdictWindow *window = GDICT_WINDOW (widget);
+  GdictApp *app = GDICT_APP (user_data);
+  
+  g_assert (GDICT_IS_APP (app));
+
+  app->windows = g_slist_remove (app->windows, window);
+  
+  if (window == app->current_window)
+    app->current_window = app->windows ? app->windows->data : NULL;
+  
+  if (app->windows == NULL)
+    gtk_main_quit ();  
+}
+
+static void
+gdict_window_created_cb (GdictWindow *parent,
+			 GdictWindow *new_window,
+			 gpointer     user_data)
+{
+  GdictApp *app = GDICT_APP (user_data);
+  
+  /* this might seem convoluted - but it's necessary, since I don't want
+   * GdictWindow to know about the GdictApp singleton.  every time a new
+   * window is created by a GdictWindow, it will register its "child window"
+   * here; the lifetime handlers will check every child window created and
+   * destroyed, and will add/remove it to the windows list accordingly
+   */
+  g_signal_connect (new_window, "created",
+  		    G_CALLBACK (gdict_window_created_cb), app);
+  g_signal_connect (new_window, "destroy",
+  		    G_CALLBACK (gdict_window_destroy_cb), app);
+
+  if (gtk_window_get_group (GTK_WINDOW (parent)))
+    gtk_window_group_add_window (gtk_window_get_group (GTK_WINDOW (parent)),
+		    		 GTK_WINDOW (new_window));
+  
+  app->windows = g_slist_prepend (app->windows, new_window);
+  app->current_window = new_window;
+}
+
+static void
+gdict_create_window (GdictApp *app)
+{
+  GSList *l;
+
+  if (!singleton->lookup_words && !singleton->match_words)
+    {
+      GtkWidget *window;
+
+      window = gdict_window_new (GDICT_WINDOW_ACTION_CLEAR,
+      				 singleton->loader,
+				 singleton->source_name,
+				 NULL);
+      g_signal_connect (window, "created",
+		        G_CALLBACK (gdict_window_created_cb), app);
+      g_signal_connect (window, "destroy",
+		        G_CALLBACK (gdict_window_destroy_cb), app);
+  
+      app->windows = g_slist_prepend (app->windows, window);
+      app->current_window = GDICT_WINDOW (window);
+  
+      gtk_widget_show (window);
+
+      return;
+    }
+      
+  for (l = singleton->lookup_words; l != NULL; l = l->next)
+    {
+      gchar *word = l->data;
+      GtkWidget *window;
+
+      window = gdict_window_new (GDICT_WINDOW_ACTION_LOOKUP,
+      				 singleton->loader,
+		      		 singleton->source_name,
+				 word);
+      
+      g_signal_connect (window, "created",
+		        G_CALLBACK (gdict_window_created_cb), app);
+      g_signal_connect (window, "destroy",
+		        G_CALLBACK (gdict_window_destroy_cb), app);
+  
+      app->windows = g_slist_prepend (app->windows, window);
+      app->current_window = GDICT_WINDOW (window);
+  
+      gtk_widget_show (window);
+    }
+
+  for (l = singleton->match_words; l != NULL; l = l->next)
+    {
+      gchar *word = l->data;
+      GtkWidget *window;
+
+      window = gdict_window_new (GDICT_WINDOW_ACTION_MATCH,
+      				 singleton->loader,
+				 singleton->source_name,
+				 word);
+      
+      g_signal_connect (window, "created",
+      			G_CALLBACK (gdict_window_created_cb), app);
+      g_signal_connect (window, "destroy",
+      			G_CALLBACK (gdict_window_destroy_cb), app);
+      
+      app->windows = g_slist_prepend (app->windows, window);
+      app->current_window = GDICT_WINDOW (window);
+
+      gtk_widget_show (window);
+    }
+}
+
+static void
+definition_found_cb (GdictContext    *context,
+		     GdictDefinition *definition,
+		     gpointer         user_data)
+{
+  /* Translators: the first is the word found, the second is the
+   * database name and the last is the definition's text; please
+   * keep the new lines. */
+  g_print (_("Definition for '%s'\n"
+	     "  From '%s':\n"
+	     "\n"
+	     "%s\n"),
+           gdict_definition_get_word (definition),
+	   gdict_definition_get_database (definition),
+	   gdict_definition_get_text (definition));
+}
+
+static void
+error_cb (GdictContext *context,
+          const GError *error,
+	  gpointer      user_data)
+{
+  g_print (_("Error: %s\n"), error->message);
+
+  gtk_main_quit ();
+}
+
+static void
+lookup_end_cb (GdictContext *context,
+	       gpointer      user_data)
+{
+  GdictApp *app = GDICT_APP (user_data);
+
+  app->remaining_words -= 1;
+
+  if (app->remaining_words == 0)
+    gtk_main_quit ();
+}
+
+static void
+gdict_look_up_word_and_quit (GdictApp *app)
+{
+  GdictSource *source;
+  GdictContext *context;
+  GSList *l;
+  
+  if ((!app->lookup_words) || (!app->match_words))
+    {
+      g_print (_("See mate-dictionary --help for usage\n"));
+
+      gdict_cleanup ();
+      exit (1);
+    }
+
+  if (app->source_name)
+    source = gdict_source_loader_get_source (app->loader, app->source_name);
+  else
+    source = gdict_source_loader_get_source (app->loader, GDICT_DEFAULT_SOURCE_NAME);
+
+  if (!source)
+    {
+      g_warning (_("Unable to find a suitable dictionary source"));
+
+      gdict_cleanup ();
+      exit (1);
+    }
+
+  /* we'll just use this one context, so we can destroy it along with
+   * the source that contains it
+   */
+  context = gdict_source_peek_context (source);
+  g_assert (GDICT_IS_CONTEXT (context));
+
+  g_signal_connect (context, "definition-found",
+		    G_CALLBACK (definition_found_cb), app);
+  g_signal_connect (context, "error",
+		    G_CALLBACK (error_cb), app);
+  g_signal_connect (context, "lookup-end",
+		    G_CALLBACK (lookup_end_cb), app);
+
+  app->remaining_words = 0;
+  for (l = app->lookup_words; l != NULL; l = l->next)
+    {
+      gchar *word = l->data;
+      GError *err = NULL;
+
+      app->remaining_words += 1;
+
+      gdict_context_define_word (context,
+		      		 app->database,
+				 word,
+				 &err);
+
+      if (err)
+	{
+          g_warning (_("Error while looking up the definition of \"%s\":\n%s"),
+		     word,
+		     err->message);
+
+	  g_error_free (err);
+	}
+    }
+
+  gtk_main ();
+
+  g_object_unref (source);
+
+  gdict_cleanup ();
+  exit (0);
+}
+
+void
+gdict_init (int *argc, char ***argv)
+{
+  GError *mateconf_error, *err = NULL;
+  GOptionContext *context;
+  gchar *loader_path;
+  gchar **lookup_words = NULL;
+  gchar **match_words = NULL;
+  gchar *database = NULL;
+  gchar *strategy = NULL;
+  gchar *source_name = NULL;
+  gboolean no_window = FALSE;
+  gboolean list_sources = FALSE;
+
+  const GOptionEntry gdict_app_goptions[] =
+  {
+    { "look-up", 0, 0, G_OPTION_ARG_STRING_ARRAY, &lookup_words,
+       N_("Words to look up"), N_("word") },
+    { "match", 0, 0, G_OPTION_ARG_STRING_ARRAY, &match_words,
+       N_("Words to match"), N_("word") },
+    { "source", 's', 0, G_OPTION_ARG_STRING, &source_name,
+       N_("Dictionary source to use"), N_("source") },
+    { "list-sources", 'l', 0, G_OPTION_ARG_NONE, &list_sources,
+       N_("Show available dictionary sources"), NULL },
+    { "no-window", 'n', 0, G_OPTION_ARG_NONE, &no_window,
+       N_("Print result to the console"), NULL },
+    { "database", 'D', 0, G_OPTION_ARG_STRING, &database,
+       N_("Database to use"), N_("db") },
+    { "strategy", 'S', 0, G_OPTION_ARG_STRING, &strategy,
+       N_("Strategy to use"), N_("strat") },
+    { G_OPTION_REMAINING, 0, 0, G_OPTION_ARG_STRING_ARRAY, &lookup_words,
+       N_("Words to look up"), N_("word") },
+    { NULL },
+  };
+  
+  /* we must have GLib's type system up and running in order to create the
+   * singleton object for mate-dictionary; thus, we can't rely on
+   * mate_program_init() calling g_type_init() for us.
+   */
+  g_type_init ();
+
+  g_assert (singleton == NULL);  
+  
+  singleton = GDICT_APP (g_object_new (GDICT_TYPE_APP, NULL));
+  g_assert (GDICT_IS_APP (singleton));
+  
+  /* create the new option context */
+  context = g_option_context_new (_(" - Look up words in dictionaries"));
+  
+  g_option_context_set_translation_domain (context, GETTEXT_PACKAGE);
+  g_option_context_add_main_entries (context, gdict_app_goptions, GETTEXT_PACKAGE);
+  g_option_context_add_group (context, gdict_get_option_group ());
+  g_option_context_add_group (context, gtk_get_option_group (TRUE));
+
+  g_option_context_parse (context, argc, argv, &err);
+  if (err)
+    {
+      g_critical ("Failed to parse argument: %s", err->message);
+      g_error_free (err);
+      g_option_context_free (context);
+      gdict_cleanup ();
+
+      exit (1);
+    }
+  
+  g_set_application_name (_("Dictionary"));
+  gtk_window_set_default_icon_name ("accessories-dictionary");
+  
+  if (!gdict_create_data_dir ())
+    {
+      gdict_cleanup ();
+
+      exit (1);
+    }
+  
+  mateconf_error = NULL;
+  singleton->mateconf_client = mateconf_client_get_default ();
+  mateconf_client_add_dir (singleton->mateconf_client,
+  			GDICT_MATECONF_DIR,
+  			MATECONF_CLIENT_PRELOAD_ONELEVEL,
+  			&mateconf_error);
+  if (mateconf_error)
+    {
+      g_warning ("Unable to access MateConf: %s\n", mateconf_error->message);
+      
+      g_error_free (mateconf_error);
+      g_object_unref (singleton->mateconf_client);
+    }
+
+  /* add user's path for fetching dictionary sources */  
+  singleton->loader = gdict_source_loader_new ();
+  loader_path = gdict_get_data_dir (); 
+  gdict_source_loader_add_search_path (singleton->loader, loader_path);
+  g_free (loader_path);
+
+  if (lookup_words)
+    {
+      gsize i;
+      gsize length = g_strv_length (lookup_words);
+
+      for (i = 0; i < length; i++)
+	singleton->lookup_words = g_slist_prepend (singleton->lookup_words,
+			                           g_strdup (lookup_words[i]));
+    }
+
+  if (match_words)
+    {
+      gsize i;
+      gsize length = g_strv_length (match_words);
+
+      for (i = 0; i < length; i++)
+        singleton->match_words = g_slist_prepend (singleton->match_words,
+			                          g_strdup (match_words[i]));
+    }
+
+  if (database)
+    singleton->database = g_strdup (database);
+  
+  if (source_name)
+    singleton->source_name = g_strdup (source_name);
+
+  if (no_window)
+    singleton->no_window = TRUE;
+
+  if (list_sources)
+    singleton->list_sources = TRUE;
+}
+
+void
+gdict_main (void)
+{
+  if (!singleton)
+    {
+      g_warning ("You must initialize GdictApp using gdict_init()\n");
+      return;
+    }
+  
+  if (!singleton->no_window)
+    gdict_create_window (singleton);
+  else
+    gdict_look_up_word_and_quit (singleton);
+  
+  gtk_main ();
+}
+
+void
+gdict_cleanup (void)
+{
+  if (!singleton)
+    {
+      g_warning ("You must initialize GdictApp using gdict_init()\n");
+      return;
+    }
+
+  g_object_unref (singleton);
+}
diff --git a/mate-dictionary/src/gdict-app.h b/mate-dictionary/src/gdict-app.h
new file mode 100644
index 00000000..c66f8958
--- /dev/null
+++ b/mate-dictionary/src/gdict-app.h
@@ -0,0 +1,72 @@
+/* gdict-app.h - main application class
+ *
+ * This file is part of MATE Dictionary
+ *
+ * Copyright (C) 2005 Emmanuele Bassi
+ *
+ * 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.
+ */
+
+#ifndef __GDICT_APP_H__
+#define __GDICT_APP_H__
+
+#include <gtk/gtk.h>
+#include <mateconf/mateconf-client.h>
+#include <libgdict/gdict.h>
+
+#include "gdict-window.h"
+
+G_BEGIN_DECLS
+
+#define GDICT_TYPE_APP		(gdict_app_get_type ())
+#define GDICT_APP(obj)		(G_TYPE_CHECK_INSTANCE_CAST ((obj), GDICT_TYPE_APP, GdictApp))
+#define GDICT_IS_APP(obj)	(G_TYPE_CHECK_INSTANCE_TYPE ((obj), GDICT_TYPE_APP))
+
+typedef struct _GdictApp         GdictApp;
+typedef struct _GdictAppClass    GdictAppClass;
+
+
+struct _GdictApp
+{
+  GObject parent_instance;
+
+  MateConfClient *mateconf_client;
+
+  GSList *lookup_words;
+  GSList *match_words;
+  gint remaining_words;
+  
+  gchar *database;
+  gchar *source_name;
+  gboolean no_window;
+  gboolean list_sources;
+  
+  GdictSourceLoader *loader;
+
+  GdictWindow *current_window;
+  GSList *windows;  
+};
+
+
+GType      gdict_app_get_type    (void) G_GNUC_CONST;
+
+void       gdict_init            (int *argc, char ***argv);
+void       gdict_main            (void);
+void       gdict_cleanup         (void);
+
+G_END_DECLS
+
+#endif /* __GDICT_APP_H__ */
diff --git a/mate-dictionary/src/gdict-applet.c b/mate-dictionary/src/gdict-applet.c
new file mode 100644
index 00000000..442381a6
--- /dev/null
+++ b/mate-dictionary/src/gdict-applet.c
@@ -0,0 +1,1333 @@
+/* gdict-applet.c - MATE Dictionary Applet
+ *
+ * Copyright (c) 2005  Emmanuele Bassi <[email protected]>
+ *
+ * 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
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <glib/gi18n.h>
+#include <gdk/gdkkeysyms.h>
+#include <gdk-pixbuf/gdk-pixbuf.h>
+#include <gtk/gtk.h>
+#include <mateconf/mateconf-client.h>
+
+#include "gdict-applet.h"
+#include "gdict-about.h"
+#include "gdict-pref-dialog.h"
+#include "gdict-print.h"
+#include "gdict-common.h"
+#include "gdict-aligned-window.h"
+
+#define GDICT_APPLET_CLASS(klass)	(G_TYPE_CHECK_CLASS_CAST ((klass), GDICT_TYPE_APPLET, GdictAppletClass))
+#define GDICT_APPLET_GET_CLASS(obj)	(G_TYPE_INSTANCE_GET_CLASS ((obj), GDICT_TYPE_APPLET, GdictAppletClass))
+
+struct _GdictAppletClass
+{
+  MatePanelAppletClass parent_class;
+};
+
+#define GDICT_APPLET_GET_PRIVATE(obj)	(G_TYPE_INSTANCE_GET_PRIVATE ((obj), GDICT_TYPE_APPLET, GdictAppletPrivate))
+
+struct _GdictAppletPrivate
+{
+  guint size;
+  GtkOrientation orient;
+  
+  MateConfClient *mateconf_client;
+  guint notify_id;
+  guint font_notify_id;
+
+  gchar *database;
+  gchar *strategy;
+  gchar *source_name;  
+  gchar *print_font;
+  gchar *defbox_font;
+
+  gchar *word;  
+  GdictContext *context;
+  guint lookup_start_id;
+  guint lookup_end_id;
+  guint error_id;
+
+  GdictSourceLoader *loader;
+
+  GtkWidget *box;
+  GtkWidget *toggle;
+  GtkWidget *image;
+  GtkWidget *entry;
+  GtkWidget *window;
+  GtkWidget *frame;
+  GtkWidget *defbox;
+
+  guint idle_draw_id;
+
+  GdkPixbuf *icon;
+
+  gint window_width;
+  gint window_height;
+
+  guint is_window_showing : 1;
+};
+
+#define WINDOW_MIN_WIDTH 	300
+#define WINDOW_MIN_HEIGHT 	200
+#define WINDOW_NUM_COLUMNS 	47
+#define WINDOW_NUM_ROWS  	20
+
+G_DEFINE_TYPE (GdictApplet, gdict_applet, PANEL_TYPE_APPLET);
+
+
+static const GtkTargetEntry drop_types[] =
+{
+  { "text/plain",    0, 0 },
+  { "TEXT",          0, 0 },
+  { "STRING",        0, 0 },
+  { "UTF8_STRING",   0, 0 },
+};
+static const guint n_drop_types = G_N_ELEMENTS (drop_types);
+
+
+static void
+set_atk_name_description (GtkWidget  *widget,
+			  const char *name,
+			  const char *description)
+{	
+  AtkObject *aobj;
+	
+  aobj = gtk_widget_get_accessible (widget);
+  if (!GTK_IS_ACCESSIBLE (aobj))
+    return;
+
+  atk_object_set_name (aobj, name);
+  atk_object_set_description (aobj, description);
+}
+
+static void
+set_window_default_size (GdictApplet *applet)
+{
+  GdictAppletPrivate *priv = applet->priv;
+  GtkWidget *widget, *defbox;
+  gint width, height;
+  gint font_size;
+  GdkScreen *screen;
+  gint monitor_num;
+  GtkRequisition req;
+  GdkRectangle monitor;
+
+  if (!priv->window)
+    return;
+  
+  widget = priv->window;
+  defbox = priv->defbox;
+
+  /* Size based on the font size */
+  font_size = pango_font_description_get_size (gtk_widget_get_style (defbox)->font_desc);
+  font_size = PANGO_PIXELS (font_size);
+
+  width = font_size * WINDOW_NUM_COLUMNS;
+  height = font_size * WINDOW_NUM_ROWS;
+
+  /* Use at least the requisition size of the window... */
+  gtk_widget_size_request (widget, &req);
+  width = MAX (width, req.width);
+  height = MAX (height, req.height);
+
+  /* ... but make it no larger than half the monitor size */
+  screen = gtk_widget_get_screen (widget);
+  monitor_num = gdk_screen_get_monitor_at_window (screen,
+                                                  gtk_widget_get_window (widget));
+
+  gdk_screen_get_monitor_geometry (screen, monitor_num, &monitor);
+
+  width = MIN (width, monitor.width / 2);
+  height = MIN (height, monitor.height / 2);
+
+  /* Set size */
+  gtk_widget_set_size_request (priv->frame, width, height);
+}
+
+static void
+clear_cb (GtkWidget   *widget,
+	  GdictApplet *applet)
+{
+  GdictAppletPrivate *priv = applet->priv;
+
+  gtk_entry_set_text (GTK_ENTRY (priv->entry), "");
+
+  if (!priv->defbox)
+    return;
+  
+  gdict_defbox_clear (GDICT_DEFBOX (priv->defbox));
+}
+
+static void
+print_cb (GtkWidget   *widget,
+	  GdictApplet *applet)
+{
+  GdictAppletPrivate *priv = applet->priv;
+
+  if (!priv->defbox)
+    return;
+  
+  gdict_show_print_dialog (GTK_WINDOW (priv->window),
+  			   GDICT_DEFBOX (priv->defbox));
+}
+
+static void
+save_cb (GtkWidget   *widget,
+         GdictApplet *applet)
+{
+  GdictAppletPrivate *priv = applet->priv;
+  GtkWidget *dialog;
+
+  if (!priv->defbox)
+    return;
+  
+  dialog = gtk_file_chooser_dialog_new (_("Save a Copy"),
+  					GTK_WINDOW (priv->window),
+  					GTK_FILE_CHOOSER_ACTION_SAVE,
+  					GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
+  					GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
+  					NULL);
+  gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dialog), TRUE);
+  
+  /* default to user's $HOME */
+  gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), g_get_home_dir ());
+  gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (dialog), _("Untitled document"));
+  
+  if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT)
+    {
+      gchar *filename;
+      gchar *text;
+      gsize len;
+      GError *write_error = NULL;
+      
+      filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
+      
+      text = gdict_defbox_get_text (GDICT_DEFBOX (priv->defbox), &len);
+      
+      g_file_set_contents (filename,
+      			   text,
+      			   len,
+      			   &write_error);
+      if (write_error)
+        {
+          gchar *message;
+          
+          message = g_strdup_printf (_("Error while writing to '%s'"), filename);
+          
+          gdict_show_error_dialog (GTK_WINDOW (priv->window),
+          			   message,
+          			   write_error->message);
+          
+          g_error_free (write_error);
+          g_free (message);
+        }
+      
+      g_free (text);
+      g_free (filename);
+    }
+
+  gtk_widget_destroy (dialog);
+}
+
+static void
+gdict_applet_set_menu_items_sensitive (GdictApplet *applet,
+				       gboolean     is_sensitive)
+{
+  MateComponentUIComponent *popup_component;
+  
+  popup_component = mate_panel_applet_get_popup_component (MATE_PANEL_APPLET (applet));
+  if (!MATECOMPONENT_IS_UI_COMPONENT (popup_component))
+    return;
+
+  matecomponent_ui_component_set_prop (popup_component,
+		  		"/commands/Clear",
+				"sensitive", (is_sensitive ? "1" : "0"),
+				NULL);
+  matecomponent_ui_component_set_prop (popup_component,
+		  		"/commands/Print",
+				"sensitive", (is_sensitive ? "1" : "0"),
+				NULL);
+  matecomponent_ui_component_set_prop (popup_component,
+		  		"/commands/Save",
+				"sensitive", (is_sensitive ? "1" : "0"),
+				NULL);
+}
+
+static gboolean
+window_key_press_event_cb (GtkWidget   *widget,
+			   GdkEventKey *event,
+			   gpointer     user_data)
+{
+  GdictApplet *applet = GDICT_APPLET (user_data);
+  
+  if (event->keyval == GDK_Escape)
+    {
+      gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (applet->priv->toggle), FALSE);
+      gtk_toggle_button_toggled (GTK_TOGGLE_BUTTON (applet->priv->toggle));
+
+      return TRUE;
+    }
+  else if ((event->keyval == GDK_l) &&
+	   (event->state & GDK_CONTROL_MASK))
+    {
+      gtk_widget_grab_focus (applet->priv->entry);
+
+      return TRUE;
+    }
+
+  return FALSE;
+}
+
+static void
+window_show_cb (GtkWidget   *window,
+		GdictApplet *applet)
+{
+  set_window_default_size (applet);
+}
+
+static void
+gdict_applet_build_window (GdictApplet *applet)
+{
+  GdictAppletPrivate *priv = applet->priv;
+  GtkWidget *window;
+  GtkWidget *frame;
+  GtkWidget *vbox;
+  GtkWidget *bbox;
+  GtkWidget *button;
+
+  if (!priv->entry)
+    {
+      g_warning ("No entry widget defined");
+
+      return;
+    }
+  
+  window = gdict_aligned_window_new (priv->toggle);
+  g_signal_connect (window, "key-press-event",
+		    G_CALLBACK (window_key_press_event_cb),
+		    applet);
+  g_signal_connect (window, "show",
+  		    G_CALLBACK (window_show_cb),
+		    applet);
+
+  frame = gtk_frame_new (NULL);
+  gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
+  gtk_container_add (GTK_CONTAINER (window), frame);
+  gtk_widget_show (frame);
+  priv->frame = frame;
+  
+  vbox = gtk_vbox_new (FALSE, 12);
+  gtk_container_set_border_width (GTK_CONTAINER (vbox), 6);
+  gtk_container_add (GTK_CONTAINER (frame), vbox);
+  gtk_widget_show (vbox);
+  
+  priv->defbox = gdict_defbox_new ();
+  if (priv->context)
+    gdict_defbox_set_context (GDICT_DEFBOX (priv->defbox), priv->context);
+  
+  gtk_box_pack_start (GTK_BOX (vbox), priv->defbox, TRUE, TRUE, 0);
+  gtk_widget_show (priv->defbox);
+  gtk_widget_set_can_focus (priv->defbox, TRUE);
+  gtk_widget_set_can_default (priv->defbox, TRUE);
+  
+  bbox = gtk_hbutton_box_new ();
+  gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), GTK_BUTTONBOX_END);
+  gtk_box_set_spacing (GTK_BOX (bbox), 6);
+  gtk_box_pack_end (GTK_BOX (vbox), bbox, FALSE, FALSE, 0);
+  gtk_widget_show (bbox);
+  
+  button = gtk_button_new_from_stock (GTK_STOCK_CLEAR);
+  gtk_widget_set_tooltip_text (button, _("Clear the definitions found"));
+  set_atk_name_description (button,
+		  	    _("Clear definition"),
+			    _("Clear the text of the definition"));
+  
+  g_signal_connect (button, "clicked", G_CALLBACK (clear_cb), applet);
+  gtk_box_pack_start (GTK_BOX (bbox), button, FALSE, FALSE, 0);
+  gtk_widget_show (button);
+
+  button = gtk_button_new_from_stock (GTK_STOCK_PRINT);
+  gtk_widget_set_tooltip_text (button, _("Print the definitions found"));
+  set_atk_name_description (button,
+		  	    _("Print definition"),
+			    _("Print the text of the definition"));
+  
+  g_signal_connect (button, "clicked", G_CALLBACK (print_cb), applet);
+  gtk_box_pack_start (GTK_BOX (bbox), button, FALSE, FALSE, 0);
+  gtk_widget_show (button);
+
+  button = gtk_button_new_from_stock (GTK_STOCK_SAVE);
+  gtk_widget_set_tooltip_text (button, _("Save the definitions found"));
+  set_atk_name_description (button,
+		  	    _("Save definition"),
+			    _("Save the text of the definition to a file"));
+  
+  g_signal_connect (button, "clicked", G_CALLBACK (save_cb), applet);
+  gtk_box_pack_start (GTK_BOX (bbox), button, FALSE, FALSE, 0);
+  gtk_widget_show (button);
+  
+  gtk_window_set_default (GTK_WINDOW (window), priv->defbox);
+  
+  priv->window = window;
+  priv->is_window_showing = FALSE;
+}
+
+static gboolean
+gdict_applet_icon_toggled_cb (GtkWidget   *widget,
+			      GdictApplet *applet)
+{
+  GdictAppletPrivate *priv = applet->priv;
+
+  if (!priv->window)
+    gdict_applet_build_window (applet);
+  
+  if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget)))
+    {
+      gtk_window_set_screen (GTK_WINDOW (priv->window),
+	                     gtk_widget_get_screen (GTK_WIDGET (applet)));
+      gtk_window_present (GTK_WINDOW (priv->window));
+      gtk_widget_grab_focus (priv->defbox);
+      
+      priv->is_window_showing = TRUE;
+    }
+  else
+    {
+      /* force hiding the find pane */
+      gdict_defbox_set_show_find (GDICT_DEFBOX (priv->defbox), FALSE);
+
+      gtk_widget_grab_focus (priv->entry);
+      gtk_widget_hide (priv->window);
+      
+      priv->is_window_showing = FALSE;
+    }
+
+  return FALSE;
+}
+
+static void
+gdict_applet_entry_activate_cb (GtkWidget   *widget,
+				GdictApplet *applet)
+{
+  GdictAppletPrivate *priv = applet->priv;
+  gchar *text;
+  
+  text = gtk_editable_get_chars (GTK_EDITABLE (widget), 0, -1);
+  if (!text)
+    return;
+  
+  g_free (priv->word);
+  priv->word = text;
+  
+  if (!priv->window)
+    gdict_applet_build_window (applet);
+
+  gdict_defbox_lookup (GDICT_DEFBOX (priv->defbox), priv->word);
+}
+
+static gboolean
+gdict_applet_entry_key_press_cb (GtkWidget   *widget,
+				 GdkEventKey *event,
+				 gpointer     user_data)
+{
+  GdictAppletPrivate *priv = GDICT_APPLET (user_data)->priv;
+  
+  if (event->keyval == GDK_Escape)
+    {
+      if (priv->is_window_showing)
+	{
+          gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->toggle), FALSE);
+	  gtk_toggle_button_toggled (GTK_TOGGLE_BUTTON (priv->toggle));
+	  
+	  return TRUE;
+	}
+    }
+  else if (event->keyval == GDK_Tab)
+    {
+      if (priv->is_window_showing)
+	gtk_widget_grab_focus (priv->defbox);
+    }
+
+  return FALSE;
+}
+
+static gboolean
+gdict_applet_icon_button_press_event_cb (GtkWidget      *widget,
+					 GdkEventButton *event,
+					 GdictApplet    *applet)
+{
+  GdictAppletPrivate *priv = applet->priv;
+  
+  /* we don't want to block the applet's popup menu unless the
+   * user is toggling the button
+   */
+  if (event->button != 1)
+    g_signal_stop_emission_by_name (priv->toggle, "button-press-event");
+
+  return FALSE;
+}
+
+static gboolean
+gdict_applet_entry_button_press_event_cb (GtkWidget      *widget,
+					  GdkEventButton *event,
+					  GdictApplet    *applet)
+{
+  mate_panel_applet_request_focus (MATE_PANEL_APPLET (applet), event->time);
+
+  return FALSE;
+}
+
+static gboolean
+gdict_applet_draw (GdictApplet *applet)
+{
+  GdictAppletPrivate *priv = applet->priv;
+  GtkWidget *box;
+  GtkWidget *hbox;
+  gchar *text = NULL;
+
+  if (priv->entry)
+    text = gtk_editable_get_chars (GTK_EDITABLE (priv->entry), 0, -1);
+  
+  if (priv->box)
+    gtk_widget_destroy (priv->box);
+
+  switch (priv->orient)
+    {
+    case GTK_ORIENTATION_VERTICAL:
+      box = gtk_vbox_new (FALSE, 0);
+      break;
+    case GTK_ORIENTATION_HORIZONTAL:
+      box = gtk_hbox_new (FALSE, 0);
+      break;
+    default:
+      g_assert_not_reached ();
+      break;
+    }
+  
+  gtk_container_add (GTK_CONTAINER (applet), box);
+  gtk_widget_show (box);
+
+  /* toggle button */
+  priv->toggle = gtk_toggle_button_new ();
+  gtk_widget_set_tooltip_text (priv->toggle, _("Click to view the dictionary window"));
+  set_atk_name_description (priv->toggle,
+			    _("Toggle dictionary window"),
+		  	    _("Show or hide the definition window"));
+  
+  gtk_button_set_relief (GTK_BUTTON (priv->toggle),
+		  	 GTK_RELIEF_NONE);
+  g_signal_connect (priv->toggle, "toggled",
+		    G_CALLBACK (gdict_applet_icon_toggled_cb),
+		    applet);
+  g_signal_connect (priv->toggle, "button-press-event",
+		    G_CALLBACK (gdict_applet_icon_button_press_event_cb),
+		    applet);
+  gtk_box_pack_start (GTK_BOX (box), priv->toggle, FALSE, FALSE, 0);
+  gtk_widget_show (priv->toggle);
+
+  hbox = gtk_hbox_new (FALSE, 0);
+  gtk_container_set_border_width (GTK_CONTAINER (hbox), 0);
+  gtk_container_add (GTK_CONTAINER (priv->toggle), hbox);
+  gtk_widget_show (hbox);
+
+  if (priv->icon)
+    {
+      GdkPixbuf *scaled;
+      
+      priv->image = gtk_image_new ();
+      gtk_image_set_pixel_size (GTK_IMAGE (priv->image), priv->size - 10);
+
+      scaled = gdk_pixbuf_scale_simple (priv->icon,
+		      			priv->size - 5,
+					priv->size - 5,
+					GDK_INTERP_BILINEAR);
+      
+      gtk_image_set_from_pixbuf (GTK_IMAGE (priv->image), scaled);
+      g_object_unref (scaled);
+      
+      gtk_box_pack_start (GTK_BOX (hbox), priv->image, FALSE, FALSE, 0);
+      
+      gtk_widget_show (priv->image);
+    }
+  else
+    {
+      priv->image = gtk_image_new ();
+
+      gtk_image_set_pixel_size (GTK_IMAGE (priv->image), priv->size - 10);
+      gtk_image_set_from_stock (GTK_IMAGE (priv->image),
+				GTK_STOCK_MISSING_IMAGE,
+				-1);
+      
+      gtk_box_pack_start (GTK_BOX (hbox), priv->image, FALSE, FALSE, 0);
+      gtk_widget_show (priv->image);
+    }
+
+  /* entry */
+  priv->entry = gtk_entry_new ();
+  gtk_widget_set_tooltip_text (priv->entry, _("Type the word you want to look up"));
+  set_atk_name_description (priv->entry,
+		  	    _("Dictionary entry"),
+			    _("Look up words in dictionaries"));
+  
+  gtk_editable_set_editable (GTK_EDITABLE (priv->entry), TRUE);
+  gtk_entry_set_width_chars (GTK_ENTRY (priv->entry), 12);
+  g_signal_connect (priv->entry, "activate",
+  		    G_CALLBACK (gdict_applet_entry_activate_cb),
+  		    applet);
+  g_signal_connect (priv->entry, "button-press-event",
+		    G_CALLBACK (gdict_applet_entry_button_press_event_cb),
+		    applet);
+  g_signal_connect (priv->entry, "key-press-event",
+		    G_CALLBACK (gdict_applet_entry_key_press_cb),
+		    applet);
+  gtk_box_pack_end (GTK_BOX (box), priv->entry, FALSE, FALSE, 0);
+  gtk_widget_show (priv->entry);
+
+  if (text)
+    {
+      gtk_entry_set_text (GTK_ENTRY (priv->entry), text);
+
+      g_free (text);
+    }
+  
+  priv->box = box;
+
+#if 0
+  gtk_widget_grab_focus (priv->entry);
+#endif
+  
+  gtk_widget_show_all (GTK_WIDGET (applet));
+
+  return FALSE;
+}
+
+static void
+gdict_applet_queue_draw (GdictApplet *applet)
+{
+  if (!applet->priv->idle_draw_id)
+    applet->priv->idle_draw_id = g_idle_add ((GSourceFunc) gdict_applet_draw,
+					     applet);
+}
+
+static void
+gdict_applet_lookup_start_cb (GdictContext *context,
+			      GdictApplet  *applet)
+{
+  GdictAppletPrivate *priv = applet->priv;
+
+  if (!priv->window)
+    gdict_applet_build_window (applet);
+
+  if (!priv->is_window_showing)
+    {
+      gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->toggle), TRUE);
+      
+      gtk_window_present (GTK_WINDOW (priv->window));
+      gtk_widget_grab_focus (priv->defbox);
+
+      priv->is_window_showing = TRUE;
+    }
+
+  gdict_applet_set_menu_items_sensitive (applet, FALSE);
+}
+
+static void
+gdict_applet_lookup_end_cb (GdictContext *context,
+			    GdictApplet  *applet)
+{
+  gdict_applet_set_menu_items_sensitive (applet, TRUE);
+
+  gtk_window_present (GTK_WINDOW (applet->priv->window));
+}
+
+static void
+gdict_applet_error_cb (GdictContext *context,
+		       const GError *error,
+		       GdictApplet  *applet)
+{
+  /* disable menu items */
+  gdict_applet_set_menu_items_sensitive (applet, FALSE);
+}
+
+static void
+gdict_applet_cmd_lookup (MateComponentUIComponent *component,
+			 GdictApplet       *applet,
+			 const gchar       *cname)
+{
+  GdictAppletPrivate *priv = applet->priv;
+  gchar *text = NULL;;
+  
+  text = gtk_editable_get_chars (GTK_EDITABLE (priv->entry), 0, -1);
+  if (!text)
+    return;
+  
+  g_free (priv->word);
+  priv->word = text;
+  
+  if (!priv->window)
+    gdict_applet_build_window (applet);
+  
+  gdict_defbox_lookup (GDICT_DEFBOX (priv->defbox), priv->word);
+}
+
+static void
+gdict_applet_cmd_clear (MateComponentUIComponent *component,
+			GdictApplet       *applet,
+			const gchar       *cname)
+{
+  clear_cb (NULL, applet);
+}
+
+static void
+gdict_applet_cmd_print (MateComponentUIComponent *component,
+			GdictApplet       *applet,
+			const gchar       *cname)
+{
+  print_cb (NULL, applet);
+}
+
+static void
+gdict_applet_cmd_preferences (MateComponentUIComponent *component,
+			      GdictApplet       *applet,
+			      const gchar       *cname)
+{
+  gdict_show_pref_dialog (GTK_WIDGET (applet),
+  			  _("Dictionary Preferences"),
+  			  applet->priv->loader);
+}
+
+static void
+gdict_applet_cmd_about (MateComponentUIComponent *component,
+			GdictApplet       *applet,
+			const gchar       *cname)
+{
+  gdict_show_about_dialog (GTK_WIDGET (applet));
+}
+
+static void
+gdict_applet_cmd_help (MateComponentUIComponent *component,
+		       GdictApplet       *applet,
+		       const gchar       *cname)
+{
+  GError *err = NULL;
+
+  gtk_show_uri (gtk_widget_get_screen (GTK_WIDGET (applet)),
+		"ghelp:mate-dictionary#mate-dictionary-applet",
+		gtk_get_current_event_time (), &err);
+  
+  if (err)
+    {
+      gdict_show_error_dialog (NULL,
+      			       _("There was an error while displaying help"),
+      			       err->message);
+      g_error_free (err);
+    }
+}
+
+static void
+gdict_applet_change_background (MatePanelApplet               *applet,
+				MatePanelAppletBackgroundType  type,
+				GdkColor                  *color,
+				GdkPixmap                 *pixmap)
+{
+  if (MATE_PANEL_APPLET_CLASS (gdict_applet_parent_class)->change_background)
+    MATE_PANEL_APPLET_CLASS (gdict_applet_parent_class)->change_background (applet,
+    								       type,
+    								       color,
+    								       pixmap);
+}
+
+static void
+gdict_applet_change_orient (MatePanelApplet       *applet,
+			    MatePanelAppletOrient  orient)
+{
+  GdictAppletPrivate *priv = GDICT_APPLET (applet)->priv;
+  guint new_size;
+  GtkAllocation allocation;
+  
+  gtk_widget_get_allocation (GTK_WIDGET (applet), &allocation);
+  switch (orient)
+    {
+    case MATE_PANEL_APPLET_ORIENT_LEFT:
+    case MATE_PANEL_APPLET_ORIENT_RIGHT:
+      priv->orient = GTK_ORIENTATION_VERTICAL;
+      new_size = allocation.width;
+      break;
+    case MATE_PANEL_APPLET_ORIENT_UP:
+    case MATE_PANEL_APPLET_ORIENT_DOWN:
+      priv->orient = GTK_ORIENTATION_HORIZONTAL;
+      new_size = allocation.height;
+      break;
+    }
+  
+  if (new_size != priv->size)
+    priv->size = new_size;
+  
+  gdict_applet_queue_draw (GDICT_APPLET (applet));
+  
+  if (MATE_PANEL_APPLET_CLASS (gdict_applet_parent_class)->change_orient)
+    MATE_PANEL_APPLET_CLASS (gdict_applet_parent_class)->change_orient (applet,
+    								   orient);
+}
+
+static void
+gdict_applet_size_allocate (GtkWidget    *widget,
+			    GdkRectangle *allocation)
+{
+  GdictApplet *applet = GDICT_APPLET (widget);
+  GdictAppletPrivate *priv = applet->priv;
+  guint new_size;
+ 
+  if (priv->orient == GTK_ORIENTATION_HORIZONTAL)
+    new_size = allocation->height;
+  else
+    new_size = allocation->width;
+  
+  if (priv->size != new_size)
+    {
+      priv->size = new_size;
+
+      gtk_image_set_pixel_size (GTK_IMAGE (priv->image), priv->size - 10);
+
+      /* re-scale the icon, if it was found */
+      if (priv->icon)
+        {
+          GdkPixbuf *scaled;
+
+	  scaled = gdk_pixbuf_scale_simple (priv->icon,
+			  		    priv->size - 5,
+					    priv->size - 5,
+					    GDK_INTERP_BILINEAR);
+	  
+	  gtk_image_set_from_pixbuf (GTK_IMAGE (priv->image), scaled);
+	  g_object_unref (scaled);
+	}
+     }
+
+  if (GTK_WIDGET_CLASS (gdict_applet_parent_class)->size_allocate)
+    GTK_WIDGET_CLASS (gdict_applet_parent_class)->size_allocate (widget,
+		    						 allocation);
+}
+
+static void
+gdict_applet_style_set (GtkWidget *widget,
+			GtkStyle  *old_style)
+{
+  if (GTK_WIDGET_CLASS (gdict_applet_parent_class)->style_set)
+    GTK_WIDGET_CLASS (gdict_applet_parent_class)->style_set (widget,
+		    					     old_style);
+#if 0
+  set_window_default_size (GDICT_APPLET (widget));
+#endif
+}
+
+static void
+gdict_applet_set_database (GdictApplet *applet,
+			   const gchar *database)
+{
+  GdictAppletPrivate *priv = applet->priv;
+  
+  g_free (priv->database);
+
+  if (database)
+    priv->database = g_strdup (database);
+  else
+    priv->database = gdict_mateconf_get_string_with_default (priv->mateconf_client,
+							  GDICT_MATECONF_DATABASE_KEY,
+							  GDICT_DEFAULT_DATABASE);
+  if (priv->defbox)
+    gdict_defbox_set_database (GDICT_DEFBOX (priv->defbox),
+			       priv->database);
+}
+
+static void
+gdict_applet_set_strategy (GdictApplet *applet,
+			   const gchar *strategy)
+{
+  GdictAppletPrivate *priv = applet->priv;
+  
+  g_free (priv->strategy);
+
+  if (strategy)
+    priv->strategy = g_strdup (strategy);
+  else
+    priv->strategy = gdict_mateconf_get_string_with_default (priv->mateconf_client,
+							  GDICT_MATECONF_STRATEGY_KEY,
+							  GDICT_DEFAULT_STRATEGY);
+}
+
+static GdictContext *
+get_context_from_loader (GdictApplet *applet)
+{
+  GdictAppletPrivate *priv = applet->priv;
+  GdictSource *source;
+  GdictContext *retval;
+
+  if (!priv->source_name)
+    priv->source_name = g_strdup (GDICT_DEFAULT_SOURCE_NAME);
+
+  source = gdict_source_loader_get_source (priv->loader,
+		  			   priv->source_name);
+  if (!source)
+    {
+      gchar *detail;
+      
+      detail = g_strdup_printf (_("No dictionary source available with name '%s'"),
+      				priv->source_name);
+
+      gdict_show_error_dialog (NULL,
+                               _("Unable to find dictionary source"),
+                               NULL);
+      
+      g_free (detail);
+
+      return NULL;
+    }
+  
+  gdict_applet_set_database (applet, gdict_source_get_database (source));
+  gdict_applet_set_strategy (applet, gdict_source_get_strategy (source));
+  
+  retval = gdict_source_get_context (source);
+  if (!retval)
+    {
+      gchar *detail;
+      
+      detail = g_strdup_printf (_("No context available for source '%s'"),
+      				gdict_source_get_description (source));
+      				
+      gdict_show_error_dialog (NULL,
+                               _("Unable to create a context"),
+                               detail);
+      
+      g_free (detail);
+      g_object_unref (source);
+      
+      return NULL;
+    }
+  
+  g_object_unref (source);
+  
+  return retval;
+}
+
+static void
+gdict_applet_set_print_font (GdictApplet *applet,
+			     const gchar *print_font)
+{
+  GdictAppletPrivate *priv = applet->priv;
+
+  g_free (priv->print_font);
+
+  if (print_font)
+    priv->print_font = g_strdup (print_font);
+  else
+    priv->print_font = gdict_mateconf_get_string_with_default (priv->mateconf_client,
+							    GDICT_MATECONF_PRINT_FONT_KEY,
+							    GDICT_DEFAULT_PRINT_FONT);
+}
+
+static void
+gdict_applet_set_defbox_font (GdictApplet *applet,
+			      const gchar *defbox_font)
+{
+  GdictAppletPrivate *priv = applet->priv;
+
+  g_free (priv->defbox_font);
+
+  if (defbox_font)
+    priv->defbox_font = g_strdup (defbox_font);
+  else
+    priv->defbox_font = gdict_mateconf_get_string_with_default (priv->mateconf_client,
+							     DOCUMENT_FONT_KEY,
+							     GDICT_DEFAULT_DEFBOX_FONT);
+
+  if (priv->defbox)
+    gdict_defbox_set_font_name (GDICT_DEFBOX (priv->defbox),
+				priv->defbox_font);
+}
+
+static void
+gdict_applet_set_context (GdictApplet  *applet,
+			  GdictContext *context)
+{
+  GdictAppletPrivate *priv = applet->priv;
+  
+  if (priv->context)
+    {
+      g_signal_handler_disconnect (priv->context, priv->lookup_start_id);
+      g_signal_handler_disconnect (priv->context, priv->lookup_end_id);
+      g_signal_handler_disconnect (priv->context, priv->error_id);
+      
+      priv->lookup_start_id = 0;
+      priv->lookup_end_id = 0;
+      priv->error_id = 0;
+      
+      g_object_unref (priv->context);
+      priv->context = NULL;
+    }
+
+  if (priv->defbox)
+    gdict_defbox_set_context (GDICT_DEFBOX (priv->defbox), context);
+
+  if (!context)
+    return;
+  
+  /* attach our callbacks */
+  priv->lookup_start_id = g_signal_connect (context, "lookup-start",
+					    G_CALLBACK (gdict_applet_lookup_start_cb),
+					    applet);
+  priv->lookup_end_id   = g_signal_connect (context, "lookup-end",
+					    G_CALLBACK (gdict_applet_lookup_end_cb),
+					    applet);
+  priv->error_id        = g_signal_connect (context, "error",
+		  			    G_CALLBACK (gdict_applet_error_cb),
+					    applet);
+  
+  priv->context = context;
+}
+
+static void
+gdict_applet_set_source_name (GdictApplet *applet,
+			      const gchar *source_name)
+{
+  GdictAppletPrivate *priv = applet->priv;
+  GdictContext *context;
+
+  g_free (priv->source_name);
+
+  if (source_name)
+    priv->source_name = g_strdup (source_name);
+  else
+    priv->source_name = gdict_mateconf_get_string_with_default (priv->mateconf_client,
+							     GDICT_MATECONF_SOURCE_KEY,
+							     GDICT_DEFAULT_SOURCE_NAME);
+  
+  context = get_context_from_loader (applet);
+  gdict_applet_set_context (applet, context);
+}
+
+static void
+gdict_applet_mateconf_notify_cb (MateConfClient *client,
+			      guint        cnxn_id,
+			      MateConfEntry  *entry,
+			      gpointer     user_data)
+{
+  GdictApplet *applet = GDICT_APPLET (user_data);
+
+  if (strcmp (entry->key, GDICT_MATECONF_PRINT_FONT_KEY) == 0)
+    {
+      if (entry->value && (entry->value->type == MATECONF_VALUE_STRING))
+        gdict_applet_set_print_font (applet, mateconf_value_get_string (entry->value));
+      else
+        gdict_applet_set_print_font (applet, GDICT_DEFAULT_PRINT_FONT);
+    }
+  else if (strcmp (entry->key, GDICT_MATECONF_SOURCE_KEY) == 0)
+    {
+      if (entry->value && (entry->value->type == MATECONF_VALUE_STRING))
+        gdict_applet_set_source_name (applet, mateconf_value_get_string (entry->value));
+      else
+        gdict_applet_set_source_name (applet, GDICT_DEFAULT_SOURCE_NAME);
+    }
+  else if (strcmp (entry->key, GDICT_MATECONF_DATABASE_KEY) == 0)
+    {
+      if (entry->value && (entry->value->type == MATECONF_VALUE_STRING))
+        gdict_applet_set_database (applet, mateconf_value_get_string (entry->value));
+      else
+        gdict_applet_set_database (applet, GDICT_DEFAULT_DATABASE);
+    }
+  else if (strcmp (entry->key, GDICT_MATECONF_STRATEGY_KEY) == 0)
+    {
+      if (entry->value && (entry->value->type == MATECONF_VALUE_STRING))
+        gdict_applet_set_strategy (applet, mateconf_value_get_string (entry->value));
+      else
+        gdict_applet_set_strategy (applet, GDICT_DEFAULT_STRATEGY);
+    }
+  else if (strcmp (entry->key, DOCUMENT_FONT_KEY) == 0)
+    {
+      if (entry->value && (entry->value->type == MATECONF_VALUE_STRING))
+        gdict_applet_set_defbox_font (applet, mateconf_value_get_string (entry->value));
+      else
+        gdict_applet_set_defbox_font (applet, GDICT_DEFAULT_DEFBOX_FONT);
+    }
+}
+
+static void
+gdict_applet_finalize (GObject *object)
+{
+  GdictApplet *applet = GDICT_APPLET (object);
+  GdictAppletPrivate *priv = applet->priv;
+
+  if (priv->idle_draw_id)
+    g_source_remove (priv->idle_draw_id);
+
+  if (priv->notify_id)
+    mateconf_client_notify_remove (priv->mateconf_client, priv->notify_id);
+
+  if (priv->font_notify_id)
+    mateconf_client_notify_remove (priv->mateconf_client, priv->font_notify_id);
+  
+  if (priv->mateconf_client)
+    g_object_unref (priv->mateconf_client);
+  
+  if (priv->context)
+    {
+      if (priv->lookup_start_id)
+        {
+          g_signal_handler_disconnect (priv->context, priv->lookup_start_id);
+	  g_signal_handler_disconnect (priv->context, priv->lookup_end_id);
+	  g_signal_handler_disconnect (priv->context, priv->error_id);
+	}
+
+      g_object_unref (priv->context);
+    }
+  
+  if (priv->loader)
+    g_object_unref (priv->loader);
+  
+  if (priv->icon)
+    g_object_unref (priv->icon);
+  
+  g_free (priv->source_name);
+  g_free (priv->print_font);
+  g_free (priv->defbox_font);
+  g_free (priv->word);
+  
+  G_OBJECT_CLASS (gdict_applet_parent_class)->finalize (object);
+}
+
+static void
+gdict_applet_class_init (GdictAppletClass *klass)
+{
+  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+  GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
+  MatePanelAppletClass *applet_class = MATE_PANEL_APPLET_CLASS (klass);
+  
+  gobject_class->finalize = gdict_applet_finalize;
+  
+  widget_class->size_allocate = gdict_applet_size_allocate;
+  widget_class->style_set = gdict_applet_style_set;
+  
+  applet_class->change_background = gdict_applet_change_background;
+  applet_class->change_orient = gdict_applet_change_orient;
+  
+  g_type_class_add_private (gobject_class, sizeof (GdictAppletPrivate));
+}
+
+static void
+gdict_applet_init (GdictApplet *applet)
+{
+  GdictAppletPrivate *priv;
+  gchar *data_dir;
+  GError *mateconf_error;
+
+  priv = GDICT_APPLET_GET_PRIVATE (applet);
+  applet->priv = priv;
+      
+  if (!priv->loader)
+    priv->loader = gdict_source_loader_new ();
+
+  /* add our data dir inside $HOME to the loader's search paths */
+  data_dir = gdict_get_data_dir ();
+  gdict_source_loader_add_search_path (priv->loader, data_dir);
+  g_free (data_dir);
+  
+  gtk_window_set_default_icon_name ("accessories-dictionary");
+  
+  mate_panel_applet_set_flags (MATE_PANEL_APPLET (applet),
+			  MATE_PANEL_APPLET_EXPAND_MINOR);
+  
+  /* get the default mateconf client */
+  if (!priv->mateconf_client)
+    priv->mateconf_client = mateconf_client_get_default ();
+  
+  mateconf_error = NULL;
+  mateconf_client_add_dir (priv->mateconf_client,
+  			GDICT_MATECONF_DIR,
+  			MATECONF_CLIENT_PRELOAD_ONELEVEL,
+  			&mateconf_error);
+  if (mateconf_error)
+    {
+      gdict_show_gerror_dialog (NULL,
+		                _("Unable to connect to MateConf"),
+		                mateconf_error);
+      mateconf_error = NULL;
+    }
+  
+  priv->notify_id = mateconf_client_notify_add (priv->mateconf_client,
+		  			     GDICT_MATECONF_DIR,
+					     gdict_applet_mateconf_notify_cb,
+					     applet, NULL,
+					     &mateconf_error);
+  if (mateconf_error)
+    {
+      gdict_show_gerror_dialog (NULL,
+		                _("Unable to get notification for preferences"),
+		                mateconf_error);
+
+      mateconf_error = NULL;
+    }
+  
+  priv->font_notify_id =  mateconf_client_notify_add (priv->mateconf_client,
+		  				   DOCUMENT_FONT_KEY,
+						   gdict_applet_mateconf_notify_cb,
+						   applet, NULL,
+						   &mateconf_error);
+  if (mateconf_error)
+    {
+      gdict_show_gerror_dialog (NULL,
+                               _("Unable to get notification for the document font"),
+                               mateconf_error);
+
+      mateconf_error = NULL;
+    }
+  
+#ifndef GDICT_APPLET_STAND_ALONE
+  mate_panel_applet_set_background_widget (MATE_PANEL_APPLET (applet),
+		  		      GTK_WIDGET (applet));
+
+  priv->size = mate_panel_applet_get_size (MATE_PANEL_APPLET (applet));
+
+  switch (mate_panel_applet_get_orient (MATE_PANEL_APPLET (applet)))
+    {
+    case MATE_PANEL_APPLET_ORIENT_LEFT:
+    case MATE_PANEL_APPLET_ORIENT_RIGHT:
+      priv->orient = GTK_ORIENTATION_VERTICAL;
+      break;
+    case MATE_PANEL_APPLET_ORIENT_UP:
+    case MATE_PANEL_APPLET_ORIENT_DOWN:
+      priv->orient = GTK_ORIENTATION_HORIZONTAL;
+      break;
+    }
+#else
+  priv->size = 24;
+  priv->orient = GTK_ORIENTATION_HORIZONTAL;
+  g_message ("(in %s) applet { size = %d, orient = %s }",
+  	     G_STRFUNC,
+  	     priv->size,
+  	     (priv->orient == GTK_ORIENTATION_HORIZONTAL ? "H" : "V"));
+#endif /* !GDICT_APPLET_STAND_ALONE */
+
+  priv->icon = gtk_icon_theme_load_icon (gtk_icon_theme_get_default (),
+		  			 "accessories-dictionary",
+					 48,
+					 0,
+					 NULL);
+  
+  /* force first draw */
+  gdict_applet_draw (applet);
+
+  /* force retrieval of the configuration from MateConf */
+  gdict_applet_set_source_name (applet, NULL);
+  gdict_applet_set_defbox_font (applet, NULL);
+  gdict_applet_set_print_font (applet, NULL);
+}
+
+#ifndef GDICT_APPLET_STAND_ALONE
+static const MateComponentUIVerb gdict_applet_menu_verbs[] =
+{
+  MATECOMPONENT_UI_UNSAFE_VERB ("LookUp", gdict_applet_cmd_lookup),
+  
+  MATECOMPONENT_UI_UNSAFE_VERB ("Clear", gdict_applet_cmd_clear),
+  MATECOMPONENT_UI_UNSAFE_VERB ("Print", gdict_applet_cmd_print),
+  
+  MATECOMPONENT_UI_UNSAFE_VERB ("Preferences", gdict_applet_cmd_preferences),
+  MATECOMPONENT_UI_UNSAFE_VERB ("Help", gdict_applet_cmd_help),
+  MATECOMPONENT_UI_UNSAFE_VERB ("About", gdict_applet_cmd_about),
+
+  MATECOMPONENT_UI_VERB_END
+};
+
+static gboolean
+gdict_applet_factory (MatePanelApplet *applet,
+                      const gchar *iid,
+		      gpointer     data)
+{
+  gboolean retval = FALSE;
+
+  if (((!strcmp (iid, "OAFIID:MATE_DictionaryApplet")) ||
+       (!strcmp (iid, "OAFIID:MATE_GDictApplet"))) &&
+      gdict_create_data_dir ())
+    {
+      /* Set up the menu */
+      mate_panel_applet_setup_menu_from_file (applet, UIDATADIR,
+					 "MATE_DictionaryApplet.xml",
+					 NULL,
+					 gdict_applet_menu_verbs,
+					 applet);
+
+      gtk_widget_show (GTK_WIDGET (applet));
+
+      /* set the menu items insensitive */
+      gdict_applet_set_menu_items_sensitive (GDICT_APPLET (applet), FALSE);
+      
+      retval = TRUE;
+    }
+
+  return retval;
+}
+
+/* this defines the main () for the applet */
+MATE_PANEL_APPLET_MATECOMPONENT_FACTORY ("OAFIID:MATE_DictionaryApplet_Factory",
+			     GDICT_TYPE_APPLET,
+			     "mate-dictionary-applet",
+			     VERSION,
+			     gdict_applet_factory,
+			     NULL);
+
+#else /* GDICT_APPLET_STAND_ALONE */
+
+int
+main (int argc, char *argv[])
+{
+  GtkWidget *window;
+  GtkWidget *applet;
+
+  /* gettext stuff */
+  bindtextdomain (GETTEXT_PACKAGE, MATELOCALEDIR);
+  bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
+  textdomain (GETTEXT_PACKAGE);
+
+  gtk_init (&argc, &argv);
+
+  window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+  g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL);
+
+  applet = GTK_WIDGET (g_object_new (GDICT_TYPE_APPLET, NULL));
+  g_message ("(in %s) typeof(applet) = '%s'",
+  	     G_STRFUNC,
+  	     g_type_name (G_OBJECT_TYPE (applet)));
+
+  gdict_applet_queue_draw (GDICT_APPLET (applet));
+  
+  gtk_container_set_border_width (GTK_CONTAINER (window), 12);
+  gtk_container_add (GTK_CONTAINER (window), applet);
+  
+  gtk_widget_show_all (window);
+  
+  gtk_main ();
+  
+  return 0;
+}
+
+#endif /* !GDICT_APPLET_STAND_ALONE */
diff --git a/mate-dictionary/src/gdict-applet.h b/mate-dictionary/src/gdict-applet.h
new file mode 100644
index 00000000..48f61c24
--- /dev/null
+++ b/mate-dictionary/src/gdict-applet.h
@@ -0,0 +1,48 @@
+/* gdict-applet.h - MATE Dictionary Applet
+ *
+ * Copyright (c) 2005  Emmanuele Bassi <[email protected]>
+ *
+ * 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
+ */
+
+#ifndef __GDICT_APPLET_H__
+#define __GDICT_APPLET_H__
+
+#include <gtk/gtk.h>
+#include <mate-panel-applet.h>
+#include <libgdict/gdict.h>
+
+G_BEGIN_DECLS
+
+#define GDICT_TYPE_APPLET		(gdict_applet_get_type ())
+#define GDICT_APPLET(obj)		(G_TYPE_CHECK_INSTANCE_CAST ((obj), GDICT_TYPE_APPLET, GdictApplet))
+#define GDICT_IS_APPLET(obj)		(G_TYPE_CHECK_INSTANCE_TYPE ((obj), GDICT_TYPE_APPLET))
+
+typedef struct _GdictApplet        GdictApplet;
+typedef struct _GdictAppletClass   GdictAppletClass;
+typedef struct _GdictAppletPrivate GdictAppletPrivate;
+
+struct _GdictApplet
+{
+  MatePanelApplet parent_instance;
+  
+  GdictAppletPrivate *priv;  
+};
+
+GType gdict_applet_get_type (void);
+
+G_END_DECLS
+
+#endif /* __GDICT_APPLET_H__ */
diff --git a/mate-dictionary/src/gdict-common.c b/mate-dictionary/src/gdict-common.c
new file mode 100644
index 00000000..8f106c18
--- /dev/null
+++ b/mate-dictionary/src/gdict-common.c
@@ -0,0 +1,201 @@
+/* gdict-common.h - shared code between application and applet
+ *
+ * This file is part of MATE Dictionary
+ *
+ * Copyright (C) 2005 Emmanuele Bassi
+ *
+ * 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.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <sys/types.h>
+#include <errno.h>
+
+#include <glib.h>
+#include <glib/gi18n.h>
+#include <glib/gstdio.h>
+
+#include <gtk/gtk.h>
+
+#include "gdict-common.h"
+
+gchar *
+gdict_get_data_dir (void)
+{
+  gchar *retval;
+
+  retval = g_build_filename (g_get_home_dir (),
+		  	     ".mate2",
+			     "mate-dictionary",
+			     NULL);
+  
+  return retval;
+}
+
+/* create the data directory inside $HOME, if it doesn't exist yet */
+gboolean
+gdict_create_data_dir (void)
+{
+  gchar *data_dir_name;
+  
+  data_dir_name = gdict_get_data_dir ();
+  if (g_mkdir (data_dir_name, 0700) == -1)
+    {
+      /* this is weird, but sometimes there's a "mate-dictionary" file
+       * inside $HOME/.mate2; see bug #329126.
+       */
+      if ((errno == EEXIST) &&
+          (g_file_test (data_dir_name, G_FILE_TEST_IS_REGULAR)))
+        {
+          gchar *backup = g_strdup_printf ("%s.pre-2-14", data_dir_name);
+	      
+	  if (g_rename (data_dir_name, backup) == -1)
+	    {
+              GtkWidget *error_dialog;
+
+	      error_dialog = gtk_message_dialog_new (NULL,
+                                                     GTK_DIALOG_MODAL,
+						     GTK_MESSAGE_ERROR,
+						     GTK_BUTTONS_CLOSE,
+						     _("Unable to rename file '%s' to '%s': %s"),
+						     data_dir_name,
+						     backup,
+						     g_strerror (errno));
+	      
+	      gtk_dialog_run (GTK_DIALOG (error_dialog));
+	      
+	      gtk_widget_destroy (error_dialog);
+	      g_free (backup);
+	      g_free (data_dir_name);
+
+	      return FALSE;
+            }
+
+	  g_free (backup);
+	  
+          if (g_mkdir (data_dir_name, 0700) == -1)
+            {
+              GtkWidget *error_dialog;
+	      
+	      error_dialog = gtk_message_dialog_new (NULL,
+						     GTK_DIALOG_MODAL,
+						     GTK_MESSAGE_ERROR,
+						     GTK_BUTTONS_CLOSE,
+						     _("Unable to create the data directory '%s': %s"),
+						     data_dir_name,
+						     g_strerror (errno));
+	      
+	      gtk_dialog_run (GTK_DIALOG (error_dialog));
+	      
+	      gtk_widget_destroy (error_dialog);
+              g_free (data_dir_name);
+
+	      return FALSE;
+            }
+
+	  goto success;
+	}
+      
+      if (errno != EEXIST)
+        {
+          GtkWidget *error_dialog;
+
+	  error_dialog = gtk_message_dialog_new (NULL,
+						 GTK_DIALOG_MODAL,
+						 GTK_MESSAGE_ERROR,
+						 GTK_BUTTONS_CLOSE,
+						 _("Unable to create the data directory '%s': %s"),
+						 data_dir_name,
+						 g_strerror (errno));
+	  
+	  gtk_dialog_run (GTK_DIALOG (error_dialog));
+	  
+	  gtk_widget_destroy (error_dialog);
+	  g_free (data_dir_name);
+
+	  return FALSE;
+	}
+    }
+
+success:
+  g_free (data_dir_name);
+
+  return TRUE;
+}
+
+/* shows an error dialog making it transient for @parent */
+void
+gdict_show_error_dialog (GtkWindow   *parent,
+			 const gchar *message,
+			 const gchar *detail)
+{
+  GtkWidget *dialog;
+  
+  g_return_if_fail ((parent == NULL) || (GTK_IS_WINDOW (parent)));
+  g_return_if_fail (message != NULL);
+  
+  dialog = gtk_message_dialog_new (parent,
+  				   GTK_DIALOG_DESTROY_WITH_PARENT,
+  				   GTK_MESSAGE_ERROR,
+  				   GTK_BUTTONS_OK,
+  				   "%s", message);
+  gtk_window_set_title (GTK_WINDOW (dialog), "");
+  
+  if (detail)
+    gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog),
+  					      "%s", detail);
+  
+  if (parent && gtk_window_get_group (parent))
+    gtk_window_group_add_window (gtk_window_get_group (parent), GTK_WINDOW (dialog));
+  
+  gtk_dialog_run (GTK_DIALOG (dialog));
+  
+  gtk_widget_destroy (dialog);
+}
+
+void
+gdict_show_gerror_dialog (GtkWindow   *parent,
+			  const gchar *message,
+			  GError      *error)
+{
+  g_return_if_fail ((parent == NULL) || (GTK_IS_WINDOW (parent)));
+  g_return_if_fail (message != NULL);
+  g_return_if_fail (error != NULL);
+  
+  gdict_show_error_dialog (parent, message, error->message);
+            
+  g_error_free (error);
+  error = NULL;
+}
+
+gchar *
+gdict_mateconf_get_string_with_default (MateConfClient *client,
+				     const gchar *key,
+				     const gchar *def)
+{
+  gchar *val;
+
+  val = mateconf_client_get_string (client, key, NULL);
+  return val ? val : g_strdup (def);
+}
+
diff --git a/mate-dictionary/src/gdict-common.h b/mate-dictionary/src/gdict-common.h
new file mode 100644
index 00000000..f8bc903d
--- /dev/null
+++ b/mate-dictionary/src/gdict-common.h
@@ -0,0 +1,48 @@
+/* gdict-common.h - shared code between application and applet
+ *
+ * This file is part of MATE Dictionary
+ *
+ * Copyright (C) 2005 Emmanuele Bassi
+ *
+ * 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.
+ */
+
+#ifndef __GDICT_COMMON_H__
+#define __GDICT_COMMON_H__
+
+#include <gtk/gtk.h>
+#include <mateconf/mateconf-client.h>
+
+G_BEGIN_DECLS
+
+gboolean gdict_create_data_dir (void);
+gchar *  gdict_get_data_dir    (void) G_GNUC_MALLOC;
+
+void     gdict_show_error_dialog  (GtkWindow   *parent,
+				   const gchar *message,
+				   const gchar *detail);
+void     gdict_show_gerror_dialog (GtkWindow   *parent,
+				   const gchar *message,
+				   GError      *error);
+
+gchar *  gdict_mateconf_get_string_with_default (MateConfClient *client,
+					      const gchar *key,
+					      const gchar *def);
+
+
+G_END_DECLS
+
+#endif /* __GDICT_COMMON_H__ */
diff --git a/mate-dictionary/src/gdict-pref-dialog.c b/mate-dictionary/src/gdict-pref-dialog.c
new file mode 100644
index 00000000..24b61980
--- /dev/null
+++ b/mate-dictionary/src/gdict-pref-dialog.c
@@ -0,0 +1,744 @@
+/* gdict-pref-dialog.c - preferences dialog
+ *
+ * This file is part of MATE Dictionary
+ *
+ * Copyright (C) 2005 Emmanuele Bassi
+ *
+ * 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.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <sys/types.h>
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+
+#include <glib/gi18n.h>
+#include <mateconf/mateconf-client.h>
+
+#include "gdict-source-dialog.h"
+#include "gdict-pref-dialog.h"
+#include "gdict-common.h"
+
+#define GDICT_PREFERENCES_UI 	PKGDATADIR "/mate-dictionary-preferences.ui"
+
+#define DEFAULT_MIN_WIDTH 	220
+#define DEFAULT_MIN_HEIGHT 	330
+
+/*******************
+ * GdictPrefDialog *
+ *******************/
+
+static GtkWidget *global_dialog = NULL;
+
+enum
+{
+  SOURCES_ACTIVE_COLUMN = 0,
+  SOURCES_NAME_COLUMN,
+  SOURCES_DESCRIPTION_COLUMN,
+  
+  SOURCES_N_COLUMNS
+};
+
+struct _GdictPrefDialog
+{
+  GtkDialog parent_instance;
+
+  GtkBuilder *builder;
+
+  MateConfClient *mateconf_client;
+  guint notify_id;
+  
+  gchar *active_source;
+  GdictSourceLoader *loader;
+  GtkListStore *sources_list;
+  
+  /* direct pointers to widgets */
+  GtkWidget *notebook;
+  
+  GtkWidget *sources_view;
+  GtkWidget *sources_add;
+  GtkWidget *sources_remove;
+  
+  gchar *print_font;
+  GtkWidget *font_button;
+  
+  GtkWidget *help_button;
+  GtkWidget *close_button;
+};
+
+struct _GdictPrefDialogClass
+{
+  GtkDialogClass parent_class;
+};
+
+enum
+{
+  PROP_0,
+
+  PROP_SOURCE_LOADER
+};
+
+
+G_DEFINE_TYPE (GdictPrefDialog, gdict_pref_dialog, GTK_TYPE_DIALOG);
+
+
+static gboolean
+select_active_source_name (GtkTreeModel *model,
+			   GtkTreePath  *path,
+			   GtkTreeIter  *iter,
+			   gpointer      data)
+{
+  GdictPrefDialog *dialog = GDICT_PREF_DIALOG (data);
+  gboolean is_active;
+  
+  gtk_tree_model_get (model, iter,
+      		      SOURCES_ACTIVE_COLUMN, &is_active,
+      		      -1);
+  if (is_active)
+    {
+      GtkTreeSelection *selection;
+      
+      selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (dialog->sources_view));
+      
+      gtk_tree_selection_select_iter (selection, iter);
+      
+      return TRUE;
+    }
+  
+  return FALSE;
+}
+
+static void
+update_sources_view (GdictPrefDialog *dialog)
+{
+  const GSList *sources, *l;
+  
+  gtk_tree_view_set_model (GTK_TREE_VIEW (dialog->sources_view), NULL);
+  
+  gtk_list_store_clear (dialog->sources_list);
+  
+  /* force update of the sources list */
+  gdict_source_loader_update (dialog->loader);
+  
+  sources = gdict_source_loader_get_sources (dialog->loader);
+  for (l = sources; l != NULL; l = l->next)
+    {
+      GdictSource *source = GDICT_SOURCE (l->data);
+      GtkTreeIter iter;
+      const gchar *name, *description;
+      gboolean is_active = FALSE;
+      
+      name = gdict_source_get_name (source);
+      description = gdict_source_get_description (source);
+      if (!description)
+	description = name;
+
+      if (strcmp (name, dialog->active_source) == 0)
+        is_active = TRUE;
+
+      gtk_list_store_append (dialog->sources_list, &iter);
+      gtk_list_store_set (dialog->sources_list, &iter,
+      			  SOURCES_ACTIVE_COLUMN, is_active,
+      			  SOURCES_NAME_COLUMN, name,
+      			  SOURCES_DESCRIPTION_COLUMN, description,
+      			  -1);
+    }
+
+  gtk_tree_view_set_model (GTK_TREE_VIEW (dialog->sources_view),
+  			   GTK_TREE_MODEL (dialog->sources_list));
+  
+  /* select the currently active source name */
+  gtk_tree_model_foreach (GTK_TREE_MODEL (dialog->sources_list),
+  			  select_active_source_name,
+  			  dialog);
+}
+
+static void
+source_renderer_toggled_cb (GtkCellRendererToggle *renderer,
+			    const gchar           *path,
+			    GdictPrefDialog       *dialog)
+{
+  GtkTreePath *treepath;
+  GtkTreeIter iter;
+  gboolean res;
+  gboolean is_active;
+  gchar *name;
+  
+  treepath = gtk_tree_path_new_from_string (path);
+  res = gtk_tree_model_get_iter (GTK_TREE_MODEL (dialog->sources_list),
+                                 &iter,
+                                 treepath);
+  if (!res)
+    {
+      gtk_tree_path_free (treepath);
+      
+      return;
+    }
+
+  gtk_tree_model_get (GTK_TREE_MODEL (dialog->sources_list), &iter,
+      		      SOURCES_NAME_COLUMN, &name,
+      		      SOURCES_ACTIVE_COLUMN, &is_active,
+      		      -1);
+  if (!is_active && name != NULL)
+    {
+      g_free (dialog->active_source);
+      dialog->active_source = g_strdup (name);
+      
+      mateconf_client_set_string (dialog->mateconf_client,
+      			       GDICT_MATECONF_SOURCE_KEY,
+      			       dialog->active_source,
+      			       NULL);
+      
+      update_sources_view (dialog);
+      
+      g_free (name);
+    }
+  
+  gtk_tree_path_free (treepath);
+}
+
+static void
+sources_view_row_activated_cb (GtkTreeView       *tree_view,
+			       GtkTreePath       *tree_path,
+			       GtkTreeViewColumn *tree_iter,
+			       GdictPrefDialog   *dialog)
+{
+  GtkWidget *edit_dialog;
+  gchar *source_name;
+  GtkTreeModel *model;
+  GtkTreeIter iter;
+
+  model = gtk_tree_view_get_model (tree_view);
+  if (!model)
+    return;
+  
+  if (!gtk_tree_model_get_iter (model, &iter, tree_path))
+    return;
+  
+  gtk_tree_model_get (model, &iter, SOURCES_NAME_COLUMN, &source_name, -1);
+  if (!source_name)
+    return;
+  
+  edit_dialog = gdict_source_dialog_new (GTK_WINDOW (dialog),
+  					 _("Edit Dictionary Source"),
+  					 GDICT_SOURCE_DIALOG_EDIT,
+  					 dialog->loader,
+  					 source_name);
+  gtk_dialog_run (GTK_DIALOG (edit_dialog));
+
+  gtk_widget_destroy (edit_dialog);
+  g_free (source_name);
+
+  update_sources_view (dialog);
+}
+
+static void
+build_sources_view (GdictPrefDialog *dialog)
+{
+  GtkTreeViewColumn *column;
+  GtkCellRenderer *renderer;
+  
+  if (dialog->sources_list)
+    return;
+    
+  dialog->sources_list = gtk_list_store_new (SOURCES_N_COLUMNS,
+  					     G_TYPE_BOOLEAN,  /* active */
+  					     G_TYPE_STRING,   /* name */
+  					     G_TYPE_STRING    /* description */);
+  gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (dialog->sources_list),
+  					SOURCES_DESCRIPTION_COLUMN,
+  					GTK_SORT_ASCENDING);
+  
+  renderer = gtk_cell_renderer_toggle_new ();
+  gtk_cell_renderer_toggle_set_radio (GTK_CELL_RENDERER_TOGGLE (renderer), TRUE);
+  g_signal_connect (renderer, "toggled",
+  		    G_CALLBACK (source_renderer_toggled_cb),
+  		    dialog);
+  
+  column = gtk_tree_view_column_new_with_attributes ("active",
+  						     renderer,
+  						     "active", SOURCES_ACTIVE_COLUMN,
+  						     NULL);
+  gtk_tree_view_append_column (GTK_TREE_VIEW (dialog->sources_view), column);
+
+  renderer = gtk_cell_renderer_text_new ();
+  column = gtk_tree_view_column_new_with_attributes ("description",
+  						     renderer,
+  						     "text", SOURCES_DESCRIPTION_COLUMN,
+  						     NULL);
+  gtk_tree_view_append_column (GTK_TREE_VIEW (dialog->sources_view), column);
+  
+  gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (dialog->sources_view), FALSE);
+  gtk_tree_view_set_model (GTK_TREE_VIEW (dialog->sources_view),
+  			   GTK_TREE_MODEL (dialog->sources_list));
+
+  g_signal_connect (dialog->sources_view, "row-activated",
+		    G_CALLBACK (sources_view_row_activated_cb),
+		    dialog);
+}
+
+static void
+source_add_clicked_cb (GtkWidget       *widget,
+		       GdictPrefDialog *dialog)
+{
+  GtkWidget *add_dialog;
+  
+  add_dialog = gdict_source_dialog_new (GTK_WINDOW (dialog),
+  					_("Add Dictionary Source"),
+  					GDICT_SOURCE_DIALOG_CREATE,
+  					dialog->loader,
+  					NULL);
+
+  gtk_dialog_run (GTK_DIALOG (add_dialog));
+
+  gtk_widget_destroy (add_dialog);
+
+  update_sources_view (dialog);
+}
+
+static void
+source_remove_clicked_cb (GtkWidget       *widget,
+			  GdictPrefDialog *dialog)
+{
+  GtkTreeSelection *selection;
+  GtkTreeModel *model;
+  GtkTreeIter iter;
+  gboolean is_selected;
+  gchar *name, *description;
+  
+  selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (dialog->sources_view));
+  if (!selection)
+    return;
+  
+  is_selected = gtk_tree_selection_get_selected (selection, &model, &iter);
+  if (!is_selected)
+    return;
+    
+  gtk_tree_model_get (model, &iter,
+  		      SOURCES_NAME_COLUMN, &name,
+  		      SOURCES_DESCRIPTION_COLUMN, &description,
+  		      -1);
+  if (!name) 
+    return;
+  else
+    {
+      GtkWidget *confirm_dialog;
+      gint response;
+      
+      confirm_dialog = gtk_message_dialog_new (GTK_WINDOW (dialog),
+      					       GTK_DIALOG_DESTROY_WITH_PARENT,
+      					       GTK_MESSAGE_WARNING,
+      					       GTK_BUTTONS_NONE,
+      					       _("Remove \"%s\"?"), description);
+      gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (confirm_dialog),
+      						_("This will permanently remove the "
+      						  "dictionary source from the list."));
+      
+      gtk_dialog_add_button (GTK_DIALOG (confirm_dialog),
+      			     GTK_STOCK_CANCEL,
+      			     GTK_RESPONSE_CANCEL);
+      gtk_dialog_add_button (GTK_DIALOG (confirm_dialog),
+      			     GTK_STOCK_REMOVE,
+      			     GTK_RESPONSE_OK);
+      
+      gtk_window_set_title (GTK_WINDOW (confirm_dialog), "");
+      
+      response = gtk_dialog_run (GTK_DIALOG (confirm_dialog));
+      if (response == GTK_RESPONSE_CANCEL)
+        {
+          gtk_widget_destroy (confirm_dialog);
+          
+          goto out;
+        }
+      
+      gtk_widget_destroy (confirm_dialog);
+    }
+  
+  if (gdict_source_loader_remove_source (dialog->loader, name))
+    gtk_list_store_remove (GTK_LIST_STORE (model), &iter);
+  else
+    {
+      GtkWidget *error_dialog;
+      gchar *message;
+      
+      message = g_strdup_printf (_("Unable to remove source '%s'"),
+      				 description);
+      
+      error_dialog = gtk_message_dialog_new (GTK_WINDOW (dialog),
+      					     GTK_DIALOG_DESTROY_WITH_PARENT,
+      					     GTK_MESSAGE_ERROR,
+      					     GTK_BUTTONS_OK,
+      					     "%s", message);
+      gtk_window_set_title (GTK_WINDOW (error_dialog), "");
+      
+      gtk_dialog_run (GTK_DIALOG (error_dialog));
+      
+      gtk_widget_destroy (error_dialog);
+    }
+
+out:
+  g_free (name);
+  g_free (description);
+  
+  update_sources_view (dialog);
+}
+
+static void
+set_source_loader (GdictPrefDialog   *dialog,
+		   GdictSourceLoader *loader)
+{
+  if (!dialog->sources_list)
+    return;
+  
+  if (dialog->loader)
+    g_object_unref (dialog->loader);
+  
+  dialog->loader = g_object_ref (loader);
+  
+  update_sources_view (dialog);
+}
+
+static void
+font_button_font_set_cb (GtkWidget       *font_button,
+			 GdictPrefDialog *dialog)
+{
+  const gchar *font;
+  
+  font = gtk_font_button_get_font_name (GTK_FONT_BUTTON (font_button));
+  if (!font || font[0] == '\0')
+    return;
+
+  if (dialog->print_font && (strcmp (dialog->print_font, font) == 0))
+    return;
+  
+  g_free (dialog->print_font);
+  dialog->print_font = g_strdup (font);
+      
+  mateconf_client_set_string (dialog->mateconf_client,
+  			   GDICT_MATECONF_PRINT_FONT_KEY,
+  			   dialog->print_font,
+  			   NULL);
+}
+
+static void
+gdict_pref_dialog_mateconf_notify_cb (MateConfClient *client,
+				   guint        cnxn_id,
+				   MateConfEntry  *entry,
+				   gpointer     user_data)
+{
+  GdictPrefDialog *dialog = GDICT_PREF_DIALOG (user_data);
+  
+  if (strcmp (entry->key, GDICT_MATECONF_SOURCE_KEY) == 0)
+    {
+      if (entry->value && entry->value->type == MATECONF_VALUE_STRING)
+        {
+          g_free (dialog->active_source);
+          dialog->active_source = g_strdup (mateconf_value_get_string (entry->value));
+        }
+      else
+        {
+          g_free (dialog->active_source);
+          dialog->active_source = g_strdup (GDICT_DEFAULT_SOURCE_NAME);
+        }
+      
+      update_sources_view (dialog);
+    }
+  else if (strcmp (entry->key, GDICT_MATECONF_PRINT_FONT_KEY) == 0)
+    {
+      if (entry->value && entry->value->type == MATECONF_VALUE_STRING)
+        {
+          g_free (dialog->print_font);
+          dialog->print_font = g_strdup (mateconf_value_get_string (entry->value));
+        }
+      else
+        {
+          g_free (dialog->print_font);
+          dialog->print_font = g_strdup (GDICT_DEFAULT_PRINT_FONT);
+        }
+
+      gtk_font_button_set_font_name (GTK_FONT_BUTTON (dialog->font_button),
+		      		     dialog->print_font);
+    }
+}
+
+static void
+response_cb (GtkDialog *dialog,
+	     gint       response_id,
+	     gpointer   user_data)
+{
+  GError *err = NULL;
+  
+  switch (response_id)
+    {
+    case GTK_RESPONSE_HELP:
+      gtk_show_uri (gtk_widget_get_screen (GTK_WIDGET (dialog)),
+                    "ghelp:mate-dictionary#mate-dictionary-preferences",
+                    gtk_get_current_event_time (), &err);
+      if (err)
+	{
+          GtkWidget *error_dialog;
+	  gchar *message;
+
+	  message = g_strdup_printf (_("There was an error while displaying help"));
+	  error_dialog = gtk_message_dialog_new (GTK_WINDOW (dialog),
+      					         GTK_DIALOG_DESTROY_WITH_PARENT,
+      					         GTK_MESSAGE_ERROR,
+						 GTK_BUTTONS_OK,
+						 "%s", message);
+	  gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (error_dialog),
+			  			    "%s", err->message);
+	  gtk_window_set_title (GTK_WINDOW (error_dialog), "");
+	  
+	  gtk_dialog_run (GTK_DIALOG (error_dialog));
+      
+          gtk_widget_destroy (error_dialog);
+	  g_error_free (err);
+        }
+      
+      /* we don't want the dialog to close itself */
+      g_signal_stop_emission_by_name (dialog, "response");
+      break;
+    case GTK_RESPONSE_ACCEPT:
+    default:
+      gtk_widget_hide (GTK_WIDGET (dialog));
+      break;
+    }
+}
+
+static void
+gdict_pref_dialog_finalize (GObject *object)
+{
+  GdictPrefDialog *dialog = GDICT_PREF_DIALOG (object);
+  
+  if (dialog->notify_id);
+    mateconf_client_notify_remove (dialog->mateconf_client, dialog->notify_id);
+  
+  if (dialog->mateconf_client)
+    g_object_unref (dialog->mateconf_client);
+  
+  if (dialog->builder)
+    g_object_unref (dialog->builder);
+
+  if (dialog->active_source)
+    g_free (dialog->active_source);
+  
+  if (dialog->loader)
+    g_object_unref (dialog->loader);
+  
+  G_OBJECT_CLASS (gdict_pref_dialog_parent_class)->finalize (object);
+}
+
+static void
+gdict_pref_dialog_set_property (GObject      *object,
+				guint         prop_id,
+				const GValue *value,
+				GParamSpec   *pspec)
+{
+  GdictPrefDialog *dialog = GDICT_PREF_DIALOG (object);
+  
+  switch (prop_id)
+    {
+    case PROP_SOURCE_LOADER:
+      set_source_loader (dialog, g_value_get_object (value));
+      break;
+    default:
+      break;
+    }
+}
+
+static void
+gdict_pref_dialog_get_property (GObject    *object,
+				guint       prop_id,
+				GValue     *value,
+				GParamSpec *pspec)
+{
+  GdictPrefDialog *dialog = GDICT_PREF_DIALOG (object);
+  
+  switch (prop_id)
+    {
+    case PROP_SOURCE_LOADER:
+      g_value_set_object (value, dialog->loader);
+      break;
+    default:
+      break;
+    }
+}
+
+static void
+gdict_pref_dialog_class_init (GdictPrefDialogClass *klass)
+{
+  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+  
+  gobject_class->set_property = gdict_pref_dialog_set_property;
+  gobject_class->get_property = gdict_pref_dialog_get_property;
+  gobject_class->finalize = gdict_pref_dialog_finalize;
+  
+  g_object_class_install_property (gobject_class,
+  				   PROP_SOURCE_LOADER,
+  				   g_param_spec_object ("source-loader",
+  				   			"Source Loader",
+  				   			"The GdictSourceLoader used by the application",
+  				   			GDICT_TYPE_SOURCE_LOADER,
+  				   			(G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY)));
+}
+
+static void
+gdict_pref_dialog_init (GdictPrefDialog *dialog)
+{
+  gchar *font;
+  GError *error = NULL;
+
+  gtk_window_set_default_size (GTK_WINDOW (dialog),
+  			       DEFAULT_MIN_WIDTH,
+  			       DEFAULT_MIN_HEIGHT);
+    
+  gtk_container_set_border_width (GTK_CONTAINER (dialog), 5);
+  gtk_box_set_spacing (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), 2);
+  gtk_dialog_set_has_separator (GTK_DIALOG (dialog), FALSE);
+  
+  /* add buttons */
+  gtk_dialog_add_button (GTK_DIALOG (dialog),
+  			 "gtk-help",
+  			 GTK_RESPONSE_HELP);
+  gtk_dialog_add_button (GTK_DIALOG (dialog),
+  			 "gtk-close",
+  			 GTK_RESPONSE_ACCEPT);
+
+  dialog->mateconf_client = mateconf_client_get_default ();
+  mateconf_client_add_dir (dialog->mateconf_client,
+  			GDICT_MATECONF_DIR,
+  			MATECONF_CLIENT_PRELOAD_ONELEVEL,
+  			NULL);
+  dialog->notify_id = mateconf_client_notify_add (dialog->mateconf_client,
+  					       GDICT_MATECONF_DIR,
+		  			       gdict_pref_dialog_mateconf_notify_cb,
+  					       dialog,
+  					       NULL,
+  					       NULL);
+
+  /* get the UI from the GtkBuilder file */
+  dialog->builder = gtk_builder_new ();
+  gtk_builder_add_from_file (dialog->builder, GDICT_PREFERENCES_UI, &error);
+
+  if (error) {
+    g_critical ("Unable to load the preferences user interface: %s", error->message);
+    g_error_free (error);
+    g_assert_not_reached ();
+  }
+
+  /* the main widget */
+  gtk_container_add (GTK_CONTAINER (gtk_dialog_get_content_area (GTK_DIALOG (dialog))),
+                     GTK_WIDGET (gtk_builder_get_object (dialog->builder, "preferences_root")));
+
+  /* keep all the interesting widgets around */  
+  dialog->notebook = GTK_WIDGET (gtk_builder_get_object (dialog->builder, "preferences_notebook"));
+  
+  dialog->sources_view = GTK_WIDGET (gtk_builder_get_object (dialog->builder, "sources_treeview"));
+  build_sources_view (dialog);
+
+  dialog->active_source = gdict_mateconf_get_string_with_default (dialog->mateconf_client,
+							       GDICT_MATECONF_SOURCE_KEY,
+							       GDICT_DEFAULT_SOURCE_NAME);
+
+  dialog->sources_add = GTK_WIDGET (gtk_builder_get_object (dialog->builder, "add_button"));
+  gtk_widget_set_tooltip_text (dialog->sources_add,
+                               _("Add a new dictionary source"));
+  g_signal_connect (dialog->sources_add, "clicked",
+  		    G_CALLBACK (source_add_clicked_cb), dialog);
+  		    
+  dialog->sources_remove = GTK_WIDGET (gtk_builder_get_object (dialog->builder, "remove_button"));
+  gtk_widget_set_tooltip_text (dialog->sources_remove,
+                               _("Remove the currently selected dictionary source"));
+  g_signal_connect (dialog->sources_remove, "clicked",
+  		    G_CALLBACK (source_remove_clicked_cb), dialog);
+  
+  font = mateconf_client_get_string (dialog->mateconf_client,
+  				  GDICT_MATECONF_PRINT_FONT_KEY,
+  				  NULL);
+  if (!font)
+    font = g_strdup (GDICT_DEFAULT_PRINT_FONT);
+  
+  dialog->font_button = GTK_WIDGET (gtk_builder_get_object (dialog->builder, "print_font_button"));
+  gtk_font_button_set_font_name (GTK_FONT_BUTTON (dialog->font_button), font);
+  gtk_widget_set_tooltip_text (dialog->font_button,
+                               _("Set the font used for printing the definitions"));
+  g_signal_connect (dialog->font_button, "font-set",
+  		    G_CALLBACK (font_button_font_set_cb), dialog);
+  g_free (font);
+  
+  gtk_widget_show_all (dialog->notebook);
+
+  /* we want to intercept the response signal before any other
+   * callbacks might be attached by the users of the
+   * GdictPrefDialog widget.
+   */
+  g_signal_connect (dialog, "response",
+		    G_CALLBACK (response_cb),
+		    NULL);
+}
+
+void
+gdict_show_pref_dialog (GtkWidget         *parent,
+			const gchar       *title,
+			GdictSourceLoader *loader)
+{
+  GtkWidget *dialog;
+  
+  g_return_if_fail (GTK_IS_WIDGET (parent));
+  g_return_if_fail (GDICT_IS_SOURCE_LOADER (loader));
+  
+  if (parent)
+    dialog = g_object_get_data (G_OBJECT (parent), "gdict-pref-dialog");
+  else
+    dialog = global_dialog;
+  
+  if (!dialog)
+    {
+      dialog = g_object_new (GDICT_TYPE_PREF_DIALOG,
+                             "source-loader", loader,
+                             "title", title,
+                             NULL);
+      
+      g_object_ref_sink (dialog);
+      
+      g_signal_connect (dialog, "delete-event",
+                        G_CALLBACK (gtk_widget_hide_on_delete),
+                        NULL);
+      
+      if (parent && GTK_IS_WINDOW (parent))
+        {
+          gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (parent));
+          gtk_window_set_destroy_with_parent (GTK_WINDOW (dialog), TRUE);
+          g_object_set_data_full (G_OBJECT (parent), "gdict-pref-dialog",
+                                  dialog,
+                                  g_object_unref);
+        }
+      else
+        global_dialog = dialog;
+    }
+
+  gtk_window_set_screen (GTK_WINDOW (dialog),
+ 			 gtk_widget_get_screen (parent));
+  gtk_window_present (GTK_WINDOW (dialog));  
+}
diff --git a/mate-dictionary/src/gdict-pref-dialog.h b/mate-dictionary/src/gdict-pref-dialog.h
new file mode 100644
index 00000000..7cae7e57
--- /dev/null
+++ b/mate-dictionary/src/gdict-pref-dialog.h
@@ -0,0 +1,65 @@
+/* gdict-pref-dialog.h - preferences dialog
+ *
+ * This file is part of MATE Dictionary
+ *
+ * Copyright (C) 2005 Emmanuele Bassi
+ *
+ * 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.
+ */
+
+#ifndef __GDICT_PREF_DIALOG_H__
+#define __GDICT_PREF_DIALOG_H__
+
+#include <gtk/gtk.h>
+#include <libgdict/gdict.h>
+
+G_BEGIN_DECLS
+
+#define GDICT_TYPE_PREF_DIALOG		(gdict_pref_dialog_get_type ())
+#define GDICT_PREF_DIALOG(obj)		(G_TYPE_CHECK_INSTANCE_CAST ((obj), GDICT_TYPE_PREF_DIALOG, GdictPrefDialog))
+#define GDICT_IS_PREF_DIALOG(obj)	(G_TYPE_CHECK_INSTANCE_TYPE ((obj), GDICT_TYPE_PREF_DIALOG))
+
+#define GDICT_DEFAULT_DEFBOX_FONT 	"Sans 10"
+#define GDICT_DEFAULT_PRINT_FONT 	"Serif 10"
+#define GDICT_DEFAULT_SOURCE_NAME 	"Default"
+
+#define GDICT_MATECONF_DIR				"/apps/mate-dictionary"
+#define GDICT_MATECONF_DATABASE_KEY 		GDICT_MATECONF_DIR "/database"
+#define GDICT_MATECONF_STRATEGY_KEY 		GDICT_MATECONF_DIR "/strategy"
+#define GDICT_MATECONF_PRINT_FONT_KEY 		GDICT_MATECONF_DIR "/print-font"
+#define GDICT_MATECONF_SOURCE_KEY 			GDICT_MATECONF_DIR "/source-name"
+#define GDICT_MATECONF_WINDOW_WIDTH_KEY 		GDICT_MATECONF_DIR "/default-window-width"
+#define GDICT_MATECONF_WINDOW_HEIGHT_KEY 		GDICT_MATECONF_DIR "/default-window-height"
+#define GDICT_MATECONF_WINDOW_IS_MAXIMIZED_KEY 	GDICT_MATECONF_DIR "/window-is-maximized"
+#define GDICT_MATECONF_SIDEBAR_VISIBLE_KEY		GDICT_MATECONF_DIR "/sidebar-visible"
+#define GDICT_MATECONF_SIDEBAR_PAGE_KEY            GDICT_MATECONF_DIR "/sidebar-page"
+#define GDICT_MATECONF_SIDEBAR_WIDTH_KEY           GDICT_MATECONF_DIR "/sidebar-width"
+#define GDICT_MATECONF_STATUSBAR_VISIBLE_KEY	GDICT_MATECONF_DIR "/statusbar-visible"
+
+#define DOCUMENT_FONT_KEY 			"/desktop/mate/interface/document_font_name"
+
+typedef struct _GdictPrefDialog        GdictPrefDialog;
+typedef struct _GdictPrefDialogClass   GdictPrefDialogClass;
+
+GType gdict_pref_dialog_get_type (void) G_GNUC_CONST;
+
+void gdict_show_pref_dialog (GtkWidget         *parent,
+			     const gchar       *title,
+			     GdictSourceLoader *loader);
+
+G_END_DECLS
+
+#endif /* __GDICT_PREF_DIALOG_H__ */
diff --git a/mate-dictionary/src/gdict-print.c b/mate-dictionary/src/gdict-print.c
new file mode 100644
index 00000000..855dbab6
--- /dev/null
+++ b/mate-dictionary/src/gdict-print.c
@@ -0,0 +1,322 @@
+/* gdict-print.c - print-related helper functions
+ *
+ * This file is part of MATE Dictionary
+ *
+ * Copyright (C) 2005 Emmanuele Bassi
+ *
+ * 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.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <stdio.h>
+#include <string.h>
+#include <math.h>
+
+#include <gtk/gtk.h>
+#include <glib/gi18n.h>
+
+#include <mateconf/mateconf-client.h>
+
+#include <libgdict/gdict.h>
+
+#include "gdict-pref-dialog.h"
+#include "gdict-print.h"
+
+#define HEADER_HEIGHT(lines)    ((lines) * 72 / 25.4)
+#define HEADER_GAP(lines)       ((lines) * 72 / 25.4)
+
+typedef struct _GdictPrintData
+{
+  GdictDefbox *defbox;
+  gchar *word;
+
+  PangoFontDescription *font_desc;
+  gdouble font_size;
+
+  gchar **lines;
+  
+  gint n_lines;
+  gint lines_per_page;
+  gint n_pages;
+} GdictPrintData;
+
+static void
+begin_print (GtkPrintOperation *operation,
+             GtkPrintContext   *context,
+             gpointer           user_data)
+{
+  GdictPrintData *data = user_data;
+  gchar *contents;
+  gdouble height;
+
+  height = gtk_print_context_get_height (context)
+           - HEADER_HEIGHT (10)
+           - HEADER_GAP (3);
+
+  contents = gdict_defbox_get_text (data->defbox, NULL);
+
+  data->lines = g_strsplit (contents, "\n", 0);
+  data->n_lines = g_strv_length (data->lines);
+  data->lines_per_page = floor (height / data->font_size);
+
+  data->n_pages = (data->n_lines - 1) / data->lines_per_page + 1;
+
+  gtk_print_operation_set_n_pages (operation, data->n_pages);
+
+  g_free (contents);
+}
+
+static void
+draw_page (GtkPrintOperation *operation,
+           GtkPrintContext   *context,
+           gint               page_number,
+           gpointer           user_data)
+{
+  GdictPrintData *data = user_data;
+  cairo_t *cr;
+  PangoLayout *layout;
+  gint text_width, text_height;
+  gdouble width;
+  gint line, i;
+  PangoFontDescription *desc;
+  gchar *page_str;
+
+  cr = gtk_print_context_get_cairo_context (context);
+  width = gtk_print_context_get_width (context);
+
+  cairo_rectangle (cr, 0, 0, width, HEADER_HEIGHT (10));
+  
+  cairo_set_source_rgb (cr, 0.8, 0.8, 0.8);
+  cairo_fill_preserve (cr);
+  
+  cairo_set_source_rgb (cr, 0, 0, 0);
+  cairo_set_line_width (cr, 1);
+  cairo_stroke (cr);
+
+  /* header */
+  layout = gtk_print_context_create_pango_layout (context);
+
+  desc = pango_font_description_from_string ("sans 14");
+  pango_layout_set_font_description (layout, desc);
+  pango_font_description_free (desc);
+
+  pango_layout_set_text (layout, data->word, -1);
+  pango_layout_get_pixel_size (layout, &text_width, &text_height);
+
+  if (text_width > width)
+    {
+      pango_layout_set_width (layout, width);
+      pango_layout_set_ellipsize (layout, PANGO_ELLIPSIZE_START);
+      pango_layout_get_pixel_size (layout, &text_width, &text_height);
+    }
+
+  cairo_move_to (cr, (width - text_width) / 2,
+                     (HEADER_HEIGHT (10) - text_height) / 2);
+  pango_cairo_show_layout (cr, layout);
+
+  page_str = g_strdup_printf ("%d/%d", page_number + 1, data->n_pages);
+  pango_layout_set_text (layout, page_str, -1);
+  g_free (page_str);
+
+  pango_layout_set_width (layout, -1);
+  pango_layout_get_pixel_size (layout, &text_width, &text_height);
+  cairo_move_to (cr, width - text_width - 4,
+                     (HEADER_HEIGHT (10) - text_height) / 2);
+  pango_cairo_show_layout (cr, layout);
+  
+  g_object_unref (layout);
+
+  /* text */
+  layout = gtk_print_context_create_pango_layout (context);
+  pango_font_description_set_size (data->font_desc,
+                                   data->font_size * PANGO_SCALE);
+  pango_layout_set_font_description (layout, data->font_desc);
+  
+  cairo_move_to (cr, 0, HEADER_HEIGHT (10) + HEADER_GAP (3));
+  line = page_number * data->lines_per_page;
+  for (i = 0; i < data->lines_per_page && line < data->n_lines; i++) 
+    {
+      pango_layout_set_text (layout, data->lines[line], -1);
+
+      pango_cairo_show_layout (cr, layout);
+      cairo_rel_move_to (cr, 0, data->font_size);
+      line++;
+    }
+
+  g_object_unref (layout);
+}
+
+static void
+end_print (GtkPrintOperation *operation,
+           GtkPrintContext   *context,
+           gpointer           user_data)
+{
+  GdictPrintData *data = user_data;
+
+  pango_font_description_free (data->font_desc);
+  g_free (data->word);
+  g_strfreev (data->lines);
+  g_free (data);
+}
+
+static gchar *
+get_print_font (void)
+{
+  MateConfClient *client;
+  gchar *print_font;
+  
+  client = mateconf_client_get_default ();
+  print_font = mateconf_client_get_string (client,
+  					GDICT_MATECONF_PRINT_FONT_KEY,
+  					NULL);
+  if (!print_font)
+    print_font = g_strdup (GDICT_DEFAULT_PRINT_FONT);
+  
+  g_object_unref (client);
+  
+  return print_font;
+}
+
+void
+gdict_show_print_preview (GtkWindow   *parent,
+                          GdictDefbox *defbox)
+{
+  GtkPrintOperation *operation;
+  GdictPrintData *data;
+  gchar *print_font;
+  gchar *word;
+  GError *error;
+  
+  g_return_if_fail (parent == NULL || GTK_IS_WINDOW (parent));
+  g_return_if_fail (GDICT_IS_DEFBOX (defbox));
+
+  g_object_get (defbox, "word", &word, NULL);
+  if (!word)
+    {
+      g_warning ("Preview should be disabled.");
+      return;
+    }
+
+  data = g_new0 (GdictPrintData, 1);
+  data->defbox = defbox;
+  data->word = word;
+
+  operation = gtk_print_operation_new ();
+  print_font = get_print_font ();
+  data->font_desc = pango_font_description_from_string (print_font);
+  data->font_size = pango_font_description_get_size (data->font_desc)
+                    / PANGO_SCALE;
+  g_free (print_font);
+
+  g_signal_connect (operation, "begin-print", 
+		    G_CALLBACK (begin_print), data);
+  g_signal_connect (operation, "draw-page", 
+		    G_CALLBACK (draw_page), data);
+  g_signal_connect (operation, "end-print", 
+		    G_CALLBACK (end_print), data);
+
+  error = NULL;
+  gtk_print_operation_run (operation,
+                           GTK_PRINT_OPERATION_ACTION_PREVIEW,
+                           parent,
+                           &error);
+  g_object_unref (operation);
+
+  if (error)
+    {
+      GtkWidget *dialog;
+
+      dialog = gtk_message_dialog_new (parent,
+                                       GTK_DIALOG_DESTROY_WITH_PARENT,
+                                       GTK_MESSAGE_ERROR,
+                                       GTK_BUTTONS_CLOSE,
+				       _("Unable to display the preview: %s"),
+                                       error->message);
+      g_error_free (error);
+
+      g_signal_connect (dialog, "response",
+			G_CALLBACK (gtk_widget_destroy), NULL);
+
+      gtk_widget_show (dialog);
+    }
+}
+
+void
+gdict_show_print_dialog (GtkWindow   *parent,
+			 GdictDefbox *defbox)
+{
+  GtkPrintOperation *operation;
+  GdictPrintData *data;
+  gchar *print_font;
+  gchar *word;
+  GError *error;
+  
+  g_return_if_fail (parent == NULL || GTK_IS_WINDOW (parent));
+  g_return_if_fail (GDICT_IS_DEFBOX (defbox));
+
+  g_object_get (defbox, "word", &word, NULL);
+  if (!word)
+    {
+      g_warning ("Print should be disabled.");
+      return;
+    }
+
+  data = g_new0 (GdictPrintData, 1);
+  data->defbox = defbox;
+  data->word = word;
+
+  operation = gtk_print_operation_new ();
+  print_font = get_print_font ();
+  data->font_desc = pango_font_description_from_string (print_font);
+  data->font_size = pango_font_description_get_size (data->font_desc)
+                    / PANGO_SCALE;
+  g_free (print_font);
+
+  g_signal_connect (operation, "begin-print", 
+		    G_CALLBACK (begin_print), data);
+  g_signal_connect (operation, "draw-page", 
+		    G_CALLBACK (draw_page), data);
+  g_signal_connect (operation, "end-print", 
+		    G_CALLBACK (end_print), data);
+
+  error = NULL;
+  gtk_print_operation_run (operation,
+                           GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG,
+                           parent,
+                           &error);
+  g_object_unref (operation);
+
+  if (error)
+    {
+      GtkWidget *dialog;
+
+      dialog = gtk_message_dialog_new (parent,
+                                       GTK_DIALOG_DESTROY_WITH_PARENT,
+                                       GTK_MESSAGE_ERROR,
+                                       GTK_BUTTONS_CLOSE,
+				       _("Unable to display the preview: %s"),
+                                       error->message);
+      g_error_free (error);
+
+      g_signal_connect (dialog, "response",
+			G_CALLBACK (gtk_widget_destroy), NULL);
+
+      gtk_widget_show (dialog);
+    }
+}
diff --git a/mate-dictionary/src/gdict-print.h b/mate-dictionary/src/gdict-print.h
new file mode 100644
index 00000000..5c0fe25f
--- /dev/null
+++ b/mate-dictionary/src/gdict-print.h
@@ -0,0 +1,38 @@
+/* gdict-print.h - print-related helper functions
+ *
+ * This file is part of MATE Dictionary
+ *
+ * Copyright (C) 2005 Emmanuele Bassi
+ *
+ * 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.
+ */
+
+#ifndef __GDICT_PRINT_H__
+#define __GDICT_PRINT_H__
+
+#include <gtk/gtk.h>
+#include <libgdict/gdict-defbox.h>
+
+G_BEGIN_DECLS
+
+void gdict_show_print_preview (GtkWindow   *parent,
+                               GdictDefbox *defbox);
+void gdict_show_print_dialog  (GtkWindow   *parent,
+			       GdictDefbox *defbox);
+
+G_END_DECLS
+
+#endif /* __GDICT_PRINT_H__ */
diff --git a/mate-dictionary/src/gdict-sidebar.c b/mate-dictionary/src/gdict-sidebar.c
new file mode 100644
index 00000000..c8f51be0
--- /dev/null
+++ b/mate-dictionary/src/gdict-sidebar.c
@@ -0,0 +1,568 @@
+/* gdict-sidebar.c - sidebar widget
+ *
+ * Copyright (C) 2006  Emmanuele Bassi <[email protected]>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this program; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ *
+ * Based on the equivalent widget from Evince
+ * 	by Jonathan Blandford,
+ * 	Copyright (C) 2004  Red Hat, Inc.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdarg.h>
+
+#include <gdk/gdkkeysyms.h>
+#include <gtk/gtk.h>
+#include <glib/gi18n.h>
+
+#include "gdict-sidebar.h"
+
+typedef struct
+{
+  guint index;
+
+  gchar *id;
+  gchar *name;
+
+  GtkWidget *child;
+  GtkWidget *menu_item;
+} SidebarPage;
+
+#define GDICT_SIDEBAR_GET_PRIVATE(obj)	(G_TYPE_INSTANCE_GET_PRIVATE ((obj), GDICT_TYPE_SIDEBAR, GdictSidebarPrivate))
+
+struct _GdictSidebarPrivate
+{
+  GHashTable *pages_by_id;
+  GSList *pages;
+
+  GtkWidget *hbox;
+  GtkWidget *notebook;
+  GtkWidget *menu;
+  GtkWidget *close_button;
+  GtkWidget *label;
+  GtkWidget *select_button;
+};
+
+enum
+{
+  PAGE_CHANGED,
+  CLOSED,
+
+  LAST_SIGNAL
+};
+
+static guint sidebar_signals[LAST_SIGNAL] = { 0 };
+static GQuark sidebar_page_id_quark = 0;
+
+G_DEFINE_TYPE (GdictSidebar, gdict_sidebar, GTK_TYPE_VBOX);
+
+SidebarPage *
+sidebar_page_new (const gchar *id,
+		  const gchar *name,
+		  GtkWidget   *widget)
+{
+  SidebarPage *page;
+
+  page = g_slice_new (SidebarPage);
+
+  page->id = g_strdup (id);
+  page->name = g_strdup (name);
+  page->child = widget;
+  page->index = -1;
+  page->menu_item = NULL;
+
+  return page;
+}
+
+void
+sidebar_page_free (SidebarPage *page)
+{
+  if (G_LIKELY (page))
+    {
+      g_free (page->name);
+      g_free (page->id);
+
+      g_slice_free (SidebarPage, page);
+    }
+}
+
+static void
+gdict_sidebar_finalize (GObject *object)
+{
+  GdictSidebar *sidebar = GDICT_SIDEBAR (object);
+  GdictSidebarPrivate *priv = sidebar->priv;
+
+  if (priv->pages_by_id)
+    g_hash_table_destroy (priv->pages_by_id);
+
+  if (priv->pages)
+    {
+      g_slist_foreach (priv->pages, (GFunc) sidebar_page_free, NULL);
+      g_slist_free (priv->pages);
+    }
+
+  G_OBJECT_CLASS (gdict_sidebar_parent_class)->finalize (object);
+}
+
+static void
+gdict_sidebar_dispose (GObject *object)
+{
+  GdictSidebar *sidebar = GDICT_SIDEBAR (object);
+
+  if (sidebar->priv->menu)
+    {
+      gtk_menu_detach (GTK_MENU (sidebar->priv->menu));
+      sidebar->priv->menu = NULL;
+    }
+
+  G_OBJECT_CLASS (gdict_sidebar_parent_class)->dispose (object);
+}
+
+static void
+gdict_sidebar_menu_position_function (GtkMenu  *menu,
+				      gint     *x,
+				      gint     *y,
+				      gboolean *push_in,
+				      gpointer  user_data)
+{
+  GtkWidget *widget;
+  GtkAllocation allocation;
+
+  g_assert (GTK_IS_BUTTON (user_data));
+
+  widget = GTK_WIDGET (user_data);
+
+  gdk_window_get_origin (gtk_widget_get_window (widget), x, y);
+
+  gtk_widget_get_allocation (widget, &allocation);
+  *x += allocation.x;
+  *y += allocation.y + allocation.height;
+
+  *push_in = FALSE;
+}
+
+static gboolean
+gdict_sidebar_select_button_press_cb (GtkWidget      *widget,
+				      GdkEventButton *event,
+				      gpointer        user_data)
+{
+  GdictSidebar *sidebar = GDICT_SIDEBAR (user_data);
+  GtkAllocation allocation;
+
+  if (event->button == 1)
+    {
+      GtkRequisition req;
+      gint width;
+
+      gtk_widget_get_allocation (widget, &allocation);
+      width = allocation.width;
+      gtk_widget_set_size_request (sidebar->priv->menu, -1, -1);
+      gtk_widget_size_request (sidebar->priv->menu, &req);
+      gtk_widget_set_size_request (sidebar->priv->menu,
+		      		   MAX (width, req.width), -1);
+      gtk_widget_grab_focus (widget);
+
+      gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), TRUE);
+      gtk_menu_popup (GTK_MENU (sidebar->priv->menu),
+		      NULL, NULL,
+		      gdict_sidebar_menu_position_function, widget,
+		      event->button, event->time);
+
+      return TRUE;
+    }
+
+  return FALSE;
+}
+
+static gboolean
+gdict_sidebar_select_key_press_cb (GtkWidget   *widget,
+				   GdkEventKey *event,
+				   gpointer     user_data)
+{
+  GdictSidebar *sidebar = GDICT_SIDEBAR (user_data);
+
+  if (event->keyval == GDK_space ||
+      event->keyval == GDK_KP_Space ||
+      event->keyval == GDK_Return ||
+      event->keyval == GDK_KP_Enter)
+    {
+      gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), TRUE);
+      gtk_menu_popup (GTK_MENU (sidebar->priv->menu),
+		      NULL, NULL,
+		      gdict_sidebar_menu_position_function, widget,
+		      1, event->time);
+
+      return TRUE;
+    }
+
+  return FALSE;
+}
+
+static void
+gdict_sidebar_close_clicked_cb (GtkWidget *widget,
+				gpointer   user_data)
+{
+  GdictSidebar *sidebar = GDICT_SIDEBAR (user_data);
+
+  g_signal_emit (sidebar, sidebar_signals[CLOSED], 0);
+}
+
+static void
+gdict_sidebar_menu_deactivate_cb (GtkWidget *widget,
+				  gpointer   user_data)
+{
+  GdictSidebar *sidebar = GDICT_SIDEBAR (user_data);
+  GdictSidebarPrivate *priv = sidebar->priv;
+  GtkToggleButton *select_button = GTK_TOGGLE_BUTTON (priv->select_button);
+
+  gtk_toggle_button_set_active (select_button, FALSE);
+}
+
+static void
+gdict_sidebar_menu_detach_cb (GtkWidget *widget,
+			      GtkMenu   *menu)
+{
+  GdictSidebar *sidebar = GDICT_SIDEBAR (widget);
+
+  sidebar->priv->menu = NULL;
+}
+
+static void
+gdict_sidebar_menu_item_activate (GtkWidget *widget,
+				  gpointer   user_data)
+{
+  GdictSidebar *sidebar = GDICT_SIDEBAR (user_data);
+  GdictSidebarPrivate *priv = sidebar->priv;
+  GtkWidget *menu_item;
+  const gchar *id;
+  SidebarPage *page;
+  gint current_index;
+
+  menu_item = gtk_menu_get_active (GTK_MENU (priv->menu));
+  id = g_object_get_qdata (G_OBJECT (menu_item), sidebar_page_id_quark);
+  g_assert (id != NULL);
+
+  page = g_hash_table_lookup (priv->pages_by_id, id);
+  g_assert (page != NULL);
+
+  current_index = gtk_notebook_get_current_page (GTK_NOTEBOOK (priv->notebook));
+  if (current_index == page->index)
+    return;
+
+  gtk_notebook_set_current_page (GTK_NOTEBOOK (priv->notebook),
+		  		 page->index);
+  gtk_label_set_text (GTK_LABEL (priv->label), page->name);
+
+  g_signal_emit (sidebar, sidebar_signals[PAGE_CHANGED], 0);
+}
+
+static void
+gdict_sidebar_class_init (GdictSidebarClass *klass)
+{
+  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+
+  g_type_class_add_private (gobject_class, sizeof (GdictSidebarPrivate));
+
+  sidebar_page_id_quark = g_quark_from_static_string ("gdict-sidebar-page-id");
+
+  gobject_class->finalize = gdict_sidebar_finalize;
+  gobject_class->dispose = gdict_sidebar_dispose;
+
+  sidebar_signals[PAGE_CHANGED] =
+    g_signal_new ("page-changed",
+		  G_TYPE_FROM_CLASS (gobject_class),
+		  G_SIGNAL_RUN_LAST,
+		  G_STRUCT_OFFSET (GdictSidebarClass, page_changed),
+		  NULL, NULL,
+		  g_cclosure_marshal_VOID__VOID,
+		  G_TYPE_NONE, 0);
+  sidebar_signals[CLOSED] =
+    g_signal_new ("closed",
+		  G_TYPE_FROM_CLASS (gobject_class),
+		  G_SIGNAL_RUN_LAST,
+		  G_STRUCT_OFFSET (GdictSidebarClass, closed),
+		  NULL, NULL,
+		  g_cclosure_marshal_VOID__VOID,
+		  G_TYPE_NONE, 0);
+}
+
+static void
+gdict_sidebar_init (GdictSidebar *sidebar)
+{
+  GdictSidebarPrivate *priv;
+  GtkWidget *hbox;
+  GtkWidget *select_hbox;
+  GtkWidget *select_button;
+  GtkWidget *close_button;
+  GtkWidget *arrow;
+
+  sidebar->priv = priv = GDICT_SIDEBAR_GET_PRIVATE (sidebar);
+
+  /* we store all the pages inside the list, but we keep
+   * a pointer inside the hash table for faster look up
+   * times; what's inside the table will be destroyed with
+   * the list, so there's no need to supply the destroy
+   * functions for keys and values.
+   */
+  priv->pages = NULL;
+  priv->pages_by_id = g_hash_table_new (g_str_hash, g_str_equal);
+
+  /* top option menu */
+  hbox = gtk_hbox_new (FALSE, 0);
+  gtk_box_pack_start (GTK_BOX (sidebar), hbox, FALSE, FALSE, 0);
+  gtk_widget_show (hbox);
+  priv->hbox = hbox;
+
+  select_button = gtk_toggle_button_new ();
+  gtk_button_set_relief (GTK_BUTTON (select_button), GTK_RELIEF_NONE);
+  g_signal_connect (select_button, "button-press-event",
+		    G_CALLBACK (gdict_sidebar_select_button_press_cb),
+		    sidebar);
+  g_signal_connect (select_button, "key-press-event",
+		    G_CALLBACK (gdict_sidebar_select_key_press_cb),
+		    sidebar);
+  priv->select_button = select_button;
+
+  select_hbox = gtk_hbox_new (FALSE, 0);
+
+  priv->label = gtk_label_new (NULL);
+  gtk_misc_set_alignment (GTK_MISC (priv->label), 0.0, 0.5);
+  gtk_box_pack_start (GTK_BOX (select_hbox), priv->label, FALSE, FALSE, 0);
+  gtk_widget_show (priv->label);
+
+  arrow = gtk_arrow_new (GTK_ARROW_DOWN, GTK_SHADOW_NONE);
+  gtk_box_pack_end (GTK_BOX (select_hbox), arrow, FALSE, FALSE, 0);
+  gtk_widget_show (arrow);
+
+  gtk_container_add (GTK_CONTAINER (select_button), select_hbox);
+  gtk_widget_show (select_hbox);
+
+  gtk_box_pack_start (GTK_BOX (hbox), select_button, TRUE, TRUE, 0);
+  gtk_widget_show (select_button);
+
+  close_button = gtk_button_new ();
+  gtk_button_set_relief (GTK_BUTTON (close_button), GTK_RELIEF_NONE);
+  gtk_button_set_image (GTK_BUTTON (close_button),
+		        gtk_image_new_from_stock (GTK_STOCK_CLOSE,
+						  GTK_ICON_SIZE_SMALL_TOOLBAR));
+  g_signal_connect (close_button, "clicked",
+		    G_CALLBACK (gdict_sidebar_close_clicked_cb),
+		    sidebar);
+  gtk_box_pack_end (GTK_BOX (hbox), close_button, FALSE, FALSE, 0);
+  gtk_widget_show (close_button);
+  priv->close_button = close_button;
+
+  sidebar->priv->menu = gtk_menu_new ();
+  g_signal_connect (sidebar->priv->menu, "deactivate",
+		    G_CALLBACK (gdict_sidebar_menu_deactivate_cb),
+		    sidebar);
+  gtk_menu_attach_to_widget (GTK_MENU (sidebar->priv->menu),
+		  	     GTK_WIDGET (sidebar),
+			     gdict_sidebar_menu_detach_cb);
+  gtk_widget_show (sidebar->priv->menu);
+
+  sidebar->priv->notebook = gtk_notebook_new ();
+  gtk_notebook_set_show_border (GTK_NOTEBOOK (sidebar->priv->notebook), FALSE);
+  gtk_notebook_set_show_tabs (GTK_NOTEBOOK (sidebar->priv->notebook), FALSE);
+  gtk_box_pack_start (GTK_BOX (sidebar), sidebar->priv->notebook, TRUE, TRUE, 6);
+  gtk_widget_show (sidebar->priv->notebook);
+}
+
+/*
+ * Public API
+ */
+
+GtkWidget *
+gdict_sidebar_new (void)
+{
+  return g_object_new (GDICT_TYPE_SIDEBAR, NULL);
+}
+
+void
+gdict_sidebar_add_page (GdictSidebar *sidebar,
+			const gchar  *page_id,
+			const gchar  *page_name,
+			GtkWidget    *page_widget)
+{
+  GdictSidebarPrivate *priv;
+  SidebarPage *page;
+  GtkWidget *menu_item;
+
+  g_return_if_fail (GDICT_IS_SIDEBAR (sidebar));
+  g_return_if_fail (page_id != NULL);
+  g_return_if_fail (page_name != NULL);
+  g_return_if_fail (GTK_IS_WIDGET (page_widget));
+
+  priv = sidebar->priv;
+
+  if (g_hash_table_lookup (priv->pages_by_id, page_id))
+    {
+      g_warning ("Attempting to add a page to the sidebar with "
+		 "id `%s', but there already is a page with the "
+		 "same id.  Aborting...",
+		 page_id);
+      return;
+    }
+
+  /* add the page inside the page list */
+  page = sidebar_page_new (page_id, page_name, page_widget);
+
+  priv->pages = g_slist_append (priv->pages, page);
+  g_hash_table_insert (priv->pages_by_id, page->id, page);
+
+  page->index = gtk_notebook_append_page (GTK_NOTEBOOK (priv->notebook),
+		  			  page_widget,
+					  NULL);
+
+  /* add the menu item for the page */
+  menu_item = gtk_image_menu_item_new_with_label (page_name);
+  g_object_set_qdata_full (G_OBJECT (menu_item),
+			   sidebar_page_id_quark,
+                           g_strdup (page_id),
+			   (GDestroyNotify) g_free);
+  g_signal_connect (menu_item, "activate",
+		    G_CALLBACK (gdict_sidebar_menu_item_activate),
+		    sidebar);
+  gtk_menu_shell_append (GTK_MENU_SHELL (priv->menu), menu_item);
+  gtk_widget_show (menu_item);
+  page->menu_item = menu_item;
+
+  gtk_menu_shell_select_item (GTK_MENU_SHELL (priv->menu), menu_item);
+  gtk_label_set_text (GTK_LABEL (priv->label), page_name);
+  gtk_notebook_set_current_page (GTK_NOTEBOOK (priv->notebook), page->index);
+}
+
+void
+gdict_sidebar_remove_page (GdictSidebar *sidebar,
+			   const gchar  *page_id)
+{
+  GdictSidebarPrivate *priv;
+  SidebarPage *page;
+  GList *children, *l;
+
+  g_return_if_fail (GDICT_IS_SIDEBAR (sidebar));
+  g_return_if_fail (page_id != NULL);
+
+  priv = sidebar->priv;
+
+  if ((page = g_hash_table_lookup (priv->pages_by_id, page_id)) == NULL)
+    {
+      g_warning ("Attempting to remove a page from the sidebar with "
+		 "id `%s', but there is no page with this id. Aborting...",
+		 page_id);
+      return;
+    }
+
+  children = gtk_container_get_children (GTK_CONTAINER (priv->menu));
+  for (l = children; l != NULL; l = l->next)
+    {
+      GtkWidget *menu_item = l->data;
+
+      if (menu_item == page->menu_item)
+        {
+          gtk_container_remove (GTK_CONTAINER (priv->menu), menu_item);
+	  break;
+	}
+    }
+  g_list_free (children);
+
+  gtk_notebook_remove_page (GTK_NOTEBOOK (priv->notebook), page->index);
+
+  g_hash_table_remove (priv->pages_by_id, page->id);
+  priv->pages = g_slist_remove (priv->pages, page);
+
+  sidebar_page_free (page);
+
+  /* select the first page, if present */
+  page = priv->pages->data;
+  if (page)
+    {
+      gtk_menu_shell_select_item (GTK_MENU_SHELL (priv->menu), page->menu_item);
+      gtk_label_set_text (GTK_LABEL (priv->label), page->name);
+      gtk_notebook_set_current_page (GTK_NOTEBOOK (priv->notebook), page->index);
+    }
+  else
+    gtk_widget_hide (GTK_WIDGET (sidebar));
+}
+
+void
+gdict_sidebar_view_page (GdictSidebar *sidebar,
+			 const gchar  *page_id)
+{
+  GdictSidebarPrivate *priv;
+  SidebarPage *page;
+
+  g_return_if_fail (GDICT_IS_SIDEBAR (sidebar));
+  g_return_if_fail (page_id != NULL);
+
+  priv = sidebar->priv;
+  page = g_hash_table_lookup (priv->pages_by_id, page_id);
+  if (!page)
+    return;
+
+  gtk_notebook_set_current_page (GTK_NOTEBOOK (priv->notebook), page->index);
+  gtk_label_set_text (GTK_LABEL (priv->label), page->name);
+  gtk_menu_shell_select_item (GTK_MENU_SHELL (priv->menu), page->menu_item);
+}
+
+const gchar *
+gdict_sidebar_current_page (GdictSidebar *sidebar)
+{
+  GdictSidebarPrivate *priv;
+  gint index;
+  SidebarPage *page;
+
+  g_return_val_if_fail (GDICT_IS_SIDEBAR (sidebar), NULL);
+
+  priv = sidebar->priv;
+
+  index = gtk_notebook_get_current_page (GTK_NOTEBOOK (priv->notebook));
+  page = g_slist_nth_data (priv->pages, index);
+  g_assert (page != NULL);
+
+  return page->id;
+}
+
+gchar **
+gdict_sidebar_list_pages (GdictSidebar *sidebar,
+                          gsize        *length)
+{
+  GdictSidebarPrivate *priv;
+  gchar **retval;
+  gint i;
+  GSList *l;
+
+  g_return_val_if_fail (GDICT_IS_SIDEBAR (sidebar), NULL);
+
+  priv = sidebar->priv;
+
+  retval = g_new (gchar*, g_slist_length (priv->pages) + 1);
+  for (l = priv->pages, i = 0; l; l = l->next, i++)
+    retval[i++] = g_strdup (l->data);
+
+  retval[i] = NULL;
+
+  if (length)
+    *length = i;
+
+  return retval;
+}
diff --git a/mate-dictionary/src/gdict-sidebar.h b/mate-dictionary/src/gdict-sidebar.h
new file mode 100644
index 00000000..82fa5c4c
--- /dev/null
+++ b/mate-dictionary/src/gdict-sidebar.h
@@ -0,0 +1,75 @@
+/* gdict-sidebar.h - sidebar widget
+ *
+ * Copyright (C) 2006  Emmanuele Bassi <[email protected]>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this program; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ *
+ * Based on the equivalent widget from Evince
+ * 	by Jonathan Blandford,
+ * 	Copyright (C) 2004  Red Hat, Inc.
+ */
+
+#ifndef __GDICT_SIDEBAR_H__
+#define __GDICT_SIDEBAR_H__
+
+#include <gtk/gtk.h>
+
+#define GDICT_TYPE_SIDEBAR		(gdict_sidebar_get_type ())
+#define GDICT_SIDEBAR(obj)		(G_TYPE_CHECK_INSTANCE_CAST ((obj), GDICT_TYPE_SIDEBAR, GdictSidebar))
+#define GDICT_IS_SIDEBAR(obj)		(G_TYPE_CHECK_INSTANCE_TYPE ((obj), GDICT_TYPE_SIDEBAR))
+#define GDICT_SIDEBAR_CLASS(klass)	(G_TYPE_CHECK_CLASS_CAST ((klass), GDICT_TYPE_SIDEBAR, GdictSidebarClass))
+#define GDICT_IS_SIDEBAR_CLASS(klass)	(G_TYPE_CHECK_CLASS_TYPE ((klass), GDICT_TYPE_SIDEBAR))
+#define GDICT_SIDEBAR_GET_CLASS(obj)	(G_TYPE_INSTANCE_GET_CLASS ((obj), GDICT_TYPE_SIDEBAR, GdictSidebarClass))
+
+typedef struct _GdictSidebar		GdictSidebar;
+typedef struct _GdictSidebarPrivate	GdictSidebarPrivate;
+typedef struct _GdictSidebarClass	GdictSidebarClass;
+
+struct _GdictSidebar
+{
+  GtkVBox parent_instance;
+
+  GdictSidebarPrivate *priv;
+};
+
+struct _GdictSidebarClass
+{
+  GtkVBoxClass parent_class;
+
+  void (*page_changed) (GdictSidebar *sidebar);
+  void (*closed)       (GdictSidebar *sidebar);
+
+  void (*_gdict_padding_1) (void);
+  void (*_gdict_padding_2) (void);
+  void (*_gdict_padding_3) (void);
+  void (*_gdict_padding_4) (void);
+};
+
+GType                 gdict_sidebar_get_type     (void) G_GNUC_CONST;
+
+GtkWidget *           gdict_sidebar_new          (void);
+void                  gdict_sidebar_add_page     (GdictSidebar *sidebar,
+						  const gchar  *page_id,
+						  const gchar  *page_name,
+						  GtkWidget    *page_widget);
+void                  gdict_sidebar_remove_page  (GdictSidebar *sidebar,
+						  const gchar  *page_id);
+void                  gdict_sidebar_view_page    (GdictSidebar *sidebar,
+						  const gchar  *page_id);
+const gchar *gdict_sidebar_current_page (GdictSidebar *sidebar);
+gchar **              gdict_sidebar_list_pages   (GdictSidebar *sidebar,
+                                                  gsize        *length) G_GNUC_MALLOC;
+
+#endif /* __GDICT_SIDEBAR_H__ */
diff --git a/mate-dictionary/src/gdict-source-dialog.c b/mate-dictionary/src/gdict-source-dialog.c
new file mode 100644
index 00000000..2a3014ab
--- /dev/null
+++ b/mate-dictionary/src/gdict-source-dialog.c
@@ -0,0 +1,759 @@
+/* gdict-source-dialog.c - source dialog
+ *
+ * This file is part of MATE Dictionary
+ *
+ * Copyright (C) 2005 Emmanuele Bassi
+ *
+ * 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.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <sys/types.h>
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+
+#include <glib/gi18n.h>
+#include <mateconf/mateconf-client.h>
+
+#include "gdict-source-dialog.h"
+#include "gdict-common.h"
+
+#define GDICT_SOURCE_UI 	PKGDATADIR "/mate-dictionary-source.ui"
+
+/*********************
+ * GdictSourceDialog *
+ *********************/
+
+struct _GdictSourceDialog
+{
+  GtkDialog parent_instance;
+
+  GtkBuilder *builder; 
+
+  MateConfClient *mateconf_client;
+  guint notify_id;
+  
+  GdictSourceLoader *loader;
+  GdictSource *source;
+  gchar *source_name;
+  GdictContext *context;
+  
+  GdictSourceDialogAction action;
+  
+  GdictSourceTransport transport;
+
+  GtkWidget *add_button;
+  GtkWidget *close_button;
+  GtkWidget *cancel_button;
+  GtkWidget *help_button;
+
+  GtkWidget *db_chooser;
+  GtkWidget *strat_chooser;
+  
+  GtkWidget *transport_combo;
+};
+
+struct _GdictSourceDialogClass
+{
+  GtkDialogClass parent_class;
+};
+
+enum
+{
+  PROP_0,
+  
+  PROP_SOURCE_LOADER,
+  PROP_SOURCE_NAME,
+  PROP_ACTION
+};
+
+G_DEFINE_TYPE (GdictSourceDialog, gdict_source_dialog, GTK_TYPE_DIALOG);
+
+static void
+set_source_loader (GdictSourceDialog *dialog,
+		   GdictSourceLoader *loader)
+{
+  if (dialog->loader)
+    g_object_unref (dialog->loader);
+  
+  dialog->loader = g_object_ref (loader);
+}
+
+static void
+transport_combo_changed_cb (GtkWidget *widget,
+			    gpointer   user_data)
+{
+  GdictSourceDialog *dialog = GDICT_SOURCE_DIALOG (user_data);
+  gint transport;
+
+  transport = gtk_combo_box_get_active (GTK_COMBO_BOX (widget));
+  if (transport == dialog->transport)
+    return;
+
+  if (transport == GDICT_SOURCE_TRANSPORT_DICTD)
+    {
+      gtk_widget_show (GTK_WIDGET (gtk_builder_get_object (dialog->builder, "hostname_label")));
+      gtk_widget_show (GTK_WIDGET (gtk_builder_get_object (dialog->builder, "hostname_entry")));
+      gtk_widget_show (GTK_WIDGET (gtk_builder_get_object (dialog->builder, "port_label")));
+      gtk_widget_show (GTK_WIDGET (gtk_builder_get_object (dialog->builder, "port_entry")));
+      
+      if (dialog->action == GDICT_SOURCE_DIALOG_CREATE)
+        {
+          gtk_widget_set_sensitive (dialog->add_button, TRUE);
+          
+          dialog->transport = GDICT_SOURCE_TRANSPORT_DICTD;
+        }
+    }
+  else
+    {
+      gtk_widget_hide (GTK_WIDGET (gtk_builder_get_object (dialog->builder, "hostname_label")));
+      gtk_widget_hide (GTK_WIDGET (gtk_builder_get_object (dialog->builder, "hostname_entry")));
+      gtk_widget_hide (GTK_WIDGET (gtk_builder_get_object (dialog->builder, "port_label")));
+      gtk_widget_hide (GTK_WIDGET (gtk_builder_get_object (dialog->builder, "port_entry")));
+
+      if (dialog->action == GDICT_SOURCE_DIALOG_CREATE)
+        {
+          gtk_widget_set_sensitive (dialog->add_button, FALSE);
+          
+          dialog->transport = GDICT_SOURCE_TRANSPORT_INVALID;
+        }
+    }
+}
+
+static gchar *
+get_text_from_entry (GdictSourceDialog *dialog,
+		     const gchar       *entry_name)
+{
+  GtkWidget *entry;
+  gchar *retval;
+
+  entry = GTK_WIDGET (gtk_builder_get_object (dialog->builder, entry_name));
+  if (!entry)
+    return NULL;
+  
+  retval = gtk_editable_get_chars (GTK_EDITABLE (entry), 0, -1);
+  
+  return retval;
+}
+
+static void
+set_text_to_entry (GdictSourceDialog *dialog,
+		   const gchar       *entry_name,
+		   const gchar       *text)
+{
+  GtkWidget *entry;
+
+  entry = GTK_WIDGET (gtk_builder_get_object (dialog->builder, entry_name));
+  if (!entry)
+    return;
+
+  gtk_entry_set_text (GTK_ENTRY (entry), text);
+}
+
+static void
+set_transport_settings (GdictSourceDialog *dialog)
+{
+  switch (dialog->transport)
+    {
+    case GDICT_SOURCE_TRANSPORT_DICTD:
+      {
+        GdictClientContext *context;
+        const gchar *hostname;
+        gchar *port_str;
+        guint port;
+
+        context = GDICT_CLIENT_CONTEXT (dialog->context);
+        hostname = gdict_client_context_get_hostname (context);
+        port = gdict_client_context_get_port (context);
+        port_str = g_strdup_printf ("%d", port);
+
+        set_text_to_entry (dialog, "hostname_entry", hostname);
+        set_text_to_entry (dialog, "port_entry", port_str);
+
+        gtk_widget_show (GTK_WIDGET (gtk_builder_get_object (dialog->builder, "hostname_label")));
+        gtk_widget_show (GTK_WIDGET (gtk_builder_get_object (dialog->builder, "hostname_entry")));
+        gtk_widget_show (GTK_WIDGET (gtk_builder_get_object (dialog->builder, "port_label")));
+        gtk_widget_show (GTK_WIDGET (gtk_builder_get_object (dialog->builder, "port_entry")));
+
+        g_free (port_str);
+      }
+      break;
+    case GDICT_SOURCE_TRANSPORT_INVALID:
+    default:
+      break;
+    }
+}
+
+static void
+update_dialog_ui (GdictSourceDialog *dialog)
+{
+  GdictSource *source;
+  
+  /* TODO - add code to update the contents of the dialog depending
+   * on the action; if we are in _CREATE, no action is needed
+   */
+  switch (dialog->action)
+    {
+    case GDICT_SOURCE_DIALOG_VIEW:
+    case GDICT_SOURCE_DIALOG_EDIT:
+      if (!dialog->source_name)
+	{
+          g_warning ("Attempting to retrieve source, but no "
+		     "source name has been defined.  Aborting...");
+	  return;
+	}
+      
+      source = gdict_source_loader_get_source (dialog->loader,
+		      			       dialog->source_name);
+      if (!source)
+	{
+          g_warning ("Attempting to retrieve source, but no "
+		     "source named `%s' was found.  Aborting...",
+		     dialog->source_name);
+	  return;
+	}
+      
+      g_object_ref (source);
+      
+      dialog->source = source;
+      set_text_to_entry (dialog, "description_entry",
+		         gdict_source_get_description (source));
+
+      dialog->transport = gdict_source_get_transport (source);
+      gtk_combo_box_set_active (GTK_COMBO_BOX (dialog->transport_combo),
+                                (gint) dialog->transport);
+
+      /* set the context for the database and strategy choosers */
+      dialog->context = gdict_source_get_context (source);
+      if (!dialog->context)
+        {
+          g_warning ("Attempting to retrieve the context, but "
+                     "none was found for source `%s'.",
+                     dialog->source_name);
+          return;
+        }
+      
+      set_transport_settings (dialog);
+
+      gdict_database_chooser_set_context (GDICT_DATABASE_CHOOSER (dialog->db_chooser),
+                                          dialog->context);
+      gdict_database_chooser_refresh (GDICT_DATABASE_CHOOSER (dialog->db_chooser));
+      gdict_strategy_chooser_set_context (GDICT_STRATEGY_CHOOSER (dialog->strat_chooser),
+                                          dialog->context);
+      gdict_strategy_chooser_refresh (GDICT_STRATEGY_CHOOSER (dialog->strat_chooser));
+      break;
+    case GDICT_SOURCE_DIALOG_CREATE:
+      /* DICTD transport is default */
+      gtk_combo_box_set_active (GTK_COMBO_BOX (dialog->transport_combo), 0);
+      g_signal_emit_by_name (dialog->transport_combo, "changed");
+      break;
+    default:
+      g_assert_not_reached ();
+      break;
+    }
+}
+
+static void
+build_new_source (GdictSourceDialog *dialog)
+{
+  GdictSource *source;
+  gchar *name, *text;
+  GdictSourceTransport transport;
+  gchar *host, *port;
+  gchar *data;
+  gsize length;
+  GError *error;
+  gchar *filename;
+  GdictDatabaseChooser *db_chooser;
+  GdictStrategyChooser *strat_chooser;
+  
+  source = gdict_source_new ();
+      
+  /* use the timestamp and the pid to get a unique name */
+  name = g_strdup_printf ("source-%lu-%u",
+                          (gulong) time (NULL),
+                          (guint) getpid ());
+  gdict_source_set_name (source, name);
+  g_free (name);
+      
+  text = get_text_from_entry (dialog, "description_entry");
+  gdict_source_set_description (source, text);
+  g_free (text);
+
+  db_chooser = GDICT_DATABASE_CHOOSER (dialog->db_chooser);
+  text = gdict_database_chooser_get_current_database (db_chooser);
+  gdict_source_set_database (source, text);
+  g_free (text);
+
+  strat_chooser = GDICT_STRATEGY_CHOOSER (dialog->strat_chooser);
+  text = gdict_strategy_chooser_get_current_strategy (strat_chooser);
+  gdict_source_set_strategy (source, text);
+  g_free (text);
+
+  /* get the selected transport id */
+  transport = dialog->transport;
+  switch (transport)
+    {
+    case GDICT_SOURCE_TRANSPORT_DICTD:
+      host = get_text_from_entry (dialog, "hostname_entry");
+      port = get_text_from_entry (dialog, "port_entry");
+       
+      gdict_source_set_transport (source, GDICT_SOURCE_TRANSPORT_DICTD,
+          			  "hostname", host,
+          			  "port", atoi (port),
+          			  NULL);
+          
+      g_free (host);
+      g_free (port);
+      break;
+    case GDICT_SOURCE_TRANSPORT_INVALID:
+    default:
+      g_warning ("Invalid transport");
+      return;
+    }
+      
+  error = NULL;
+  data = gdict_source_to_data (source, &length, &error);
+  if (error)
+    {
+      gdict_show_gerror_dialog (GTK_WINDOW (dialog),
+				_("Unable to create a source file"),
+				error);
+       
+      g_object_unref (source);
+      return;
+    }
+      
+  name = g_strdup_printf ("%s.desktop", gdict_source_get_name (source));
+  filename = g_build_filename (g_get_home_dir (),
+  			       ".mate2",
+      			       "mate-dictionary",
+      			       name,
+      			       NULL);
+  g_free (name);
+      
+  g_file_set_contents (filename, data, length, &error);
+  if (error)
+    gdict_show_gerror_dialog (GTK_WINDOW (dialog),
+       			      _("Unable to save source file"),
+       			      error);
+
+  g_free (filename);
+  g_free (data);
+  g_object_unref (source);
+}
+
+static void
+save_source (GdictSourceDialog *dialog)
+{
+  GdictSource *source;
+  GdictDatabaseChooser *db_chooser;
+  GdictStrategyChooser *strat_chooser;
+  gchar *name, *text;
+  GdictSourceTransport transport;
+  gchar *host, *port;
+  gchar *data;
+  gsize length;
+  GError *error;
+  gchar *filename;
+  
+  source = gdict_source_loader_get_source (dialog->loader,
+		  			   dialog->source_name);
+  if (!source)
+    {
+      g_warning ("Attempting to save source `%s', but no "
+		 "source for that name was found.",
+		 dialog->source_name);
+
+      return;
+    }
+      
+  text = get_text_from_entry (dialog, "description_entry");
+  gdict_source_set_description (source, text);
+  g_free (text);
+
+  db_chooser = GDICT_DATABASE_CHOOSER (dialog->db_chooser);
+  text = gdict_database_chooser_get_current_database (db_chooser);
+  gdict_source_set_database (source, text);
+  g_free (text);
+
+  strat_chooser = GDICT_STRATEGY_CHOOSER (dialog->strat_chooser);
+  text = gdict_strategy_chooser_get_current_strategy (strat_chooser);
+  gdict_source_set_strategy (source, text);
+  g_free (text);
+
+
+  /* get the selected transport id */
+  transport = dialog->transport;
+  switch (transport)
+    {
+    case GDICT_SOURCE_TRANSPORT_DICTD:
+      host = get_text_from_entry (dialog, "hostname_entry");
+      port = get_text_from_entry (dialog, "port_entry");
+       
+      gdict_source_set_transport (source, GDICT_SOURCE_TRANSPORT_DICTD,
+          			  "hostname", host,
+          			  "port", atoi (port),
+          			  NULL);
+          
+      g_free (host);
+      g_free (port);
+      break;
+    case GDICT_SOURCE_TRANSPORT_INVALID:
+    default:
+      g_warning ("Invalid transport");
+      return;
+    }
+      
+  error = NULL;
+  data = gdict_source_to_data (source, &length, &error);
+  if (error)
+    {
+      gdict_show_gerror_dialog (GTK_WINDOW (dialog),
+			 	_("Unable to create a source file"),
+			 	error);
+      
+      g_object_unref (source);
+      return;
+    }
+      
+  name = g_strdup_printf ("%s.desktop", gdict_source_get_name (source));
+  filename = g_build_filename (g_get_home_dir (),
+      			       ".mate2",
+			       "mate-dictionary",
+			       name,
+			       NULL);
+  g_free (name);
+      
+  g_file_set_contents (filename, data, length, &error);
+  if (error)
+    gdict_show_gerror_dialog (GTK_WINDOW (dialog),
+       			      _("Unable to save source file"),
+       			      error);
+
+  g_free (filename);
+  g_free (data);
+  g_object_unref (source);
+}
+
+static void
+gdict_source_dialog_response_cb (GtkDialog *dialog,
+				 gint       response_id,
+				 gpointer   user_data)
+{
+  GError *err = NULL;
+  
+  switch (response_id)
+    {
+    case GTK_RESPONSE_ACCEPT:
+      build_new_source (GDICT_SOURCE_DIALOG (dialog));
+      break;
+    case GTK_RESPONSE_HELP:
+      gtk_show_uri (gtk_widget_get_screen (GTK_WIDGET (dialog)),
+                    "ghelp:mate-dictionary#mate-dictionary-add-source",
+                    gtk_get_current_event_time (), &err);
+      if (err)
+        {
+          gdict_show_gerror_dialog (GTK_WINDOW (dialog),
+          			    _("There was an error while displaying help"),
+          		 	    err);
+          g_error_free (err);
+        }
+
+      /* we don't want the dialog to close itself */
+      g_signal_stop_emission_by_name (dialog, "response");
+      break;
+    case GTK_RESPONSE_CLOSE:
+      save_source (GDICT_SOURCE_DIALOG (dialog));
+      break;
+    case GTK_RESPONSE_CANCEL:
+      break;
+    default:
+      break;
+    }
+}
+
+static void
+gdict_source_dialog_finalize (GObject *object)
+{
+  GdictSourceDialog *dialog = GDICT_SOURCE_DIALOG (object);
+
+  if (dialog->mateconf_client)
+    g_object_unref (dialog->mateconf_client);
+  
+  if (dialog->builder)
+    g_object_unref (dialog->builder);
+
+  if (dialog->source_name)
+    g_free (dialog->source_name);
+
+  if (dialog->source)
+    g_object_unref (dialog->source);
+  
+  if (dialog->loader)
+    g_object_unref (dialog->loader);
+  
+  G_OBJECT_CLASS (gdict_source_dialog_parent_class)->finalize (object);
+}
+
+static void
+gdict_source_dialog_set_property (GObject      *object,
+				  guint         prop_id,
+				  const GValue *value,
+				  GParamSpec   *pspec)
+{
+  GdictSourceDialog *dialog = GDICT_SOURCE_DIALOG (object);
+  
+  switch (prop_id)
+    {
+    case PROP_SOURCE_LOADER:
+      set_source_loader (dialog, g_value_get_object (value));
+      break;
+    case PROP_SOURCE_NAME:
+      g_free (dialog->source_name);
+      dialog->source_name = g_strdup (g_value_get_string (value));
+      break;
+    case PROP_ACTION:
+      dialog->action = (GdictSourceDialogAction) g_value_get_int (value);
+      break;
+    default:
+      break;
+    }
+}
+
+static void
+gdict_source_dialog_get_property (GObject    *object,
+				  guint       prop_id,
+				  GValue     *value,
+				  GParamSpec *pspec)
+{
+  GdictSourceDialog *dialog = GDICT_SOURCE_DIALOG (object);
+  
+  switch (prop_id)
+    {
+    case PROP_SOURCE_LOADER:
+      g_value_set_object (value, dialog->loader);
+      break;
+    case PROP_SOURCE_NAME:
+      g_value_set_string (value, dialog->source_name);
+      break;
+    case PROP_ACTION:
+      g_value_set_int (value, dialog->action);
+      break;
+    default:
+      break;
+    }
+}
+
+static GObject *
+gdict_source_dialog_constructor (GType                  type,
+				 guint                  n_construct_properties,
+				 GObjectConstructParam *construct_params)
+{
+  GObject *object;
+  GdictSourceDialog *dialog;
+  GtkWidget *vbox;
+  GError *error = NULL;
+
+  object = G_OBJECT_CLASS (gdict_source_dialog_parent_class)->constructor (type,
+									   n_construct_properties,
+									   construct_params);
+  dialog = GDICT_SOURCE_DIALOG (object);
+
+  gtk_container_set_border_width (GTK_CONTAINER (dialog), 5);
+  gtk_box_set_spacing (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), 2);
+  
+  gtk_widget_push_composite_child ();
+
+  /* get the UI from the GtkBuilder file */
+  dialog->builder = gtk_builder_new ();
+  gtk_builder_add_from_file (dialog->builder, GDICT_SOURCE_UI, &error);
+
+  if (error) {
+    g_critical ("Unable to load the user interface definition file: %s",
+                error->message);
+    g_error_free (error);
+    g_assert_not_reached ();
+  }
+  
+  /* the main widget */
+  gtk_container_add (GTK_CONTAINER (gtk_dialog_get_content_area (GTK_DIALOG (dialog))),
+                     GTK_WIDGET (gtk_builder_get_object (dialog->builder, "source_root")));
+
+  /* the transport combo changes the UI by changing the visible widgets
+   * bound to the transport's own options.
+   */
+  dialog->transport_combo = GTK_WIDGET (gtk_builder_get_object (dialog->builder, "transport_combo"));
+  g_signal_connect (dialog->transport_combo, "changed",
+  		    G_CALLBACK (transport_combo_changed_cb),
+  		    dialog);
+
+  /* the help button is always visible */
+  dialog->help_button = gtk_dialog_add_button (GTK_DIALOG (dialog),
+  					       GTK_STOCK_HELP,
+					       GTK_RESPONSE_HELP);
+  
+  vbox = GTK_WIDGET (gtk_builder_get_object (dialog->builder, "db-vbox"));
+  dialog->db_chooser = gdict_database_chooser_new ();
+  gtk_box_pack_start (GTK_BOX (vbox), dialog->db_chooser, TRUE, TRUE, 0);
+  gtk_widget_show (dialog->db_chooser);
+
+  vbox = GTK_WIDGET (gtk_builder_get_object (dialog->builder, "strat-vbox"));
+  dialog->strat_chooser = gdict_strategy_chooser_new ();
+  gtk_box_pack_start (GTK_BOX (vbox), dialog->strat_chooser, TRUE, TRUE, 0);
+  gtk_widget_show (dialog->strat_chooser);
+
+  /* the UI changes depending on the action that the source dialog
+   * should perform
+   */
+  switch (dialog->action)
+    {
+    case GDICT_SOURCE_DIALOG_VIEW:
+      /* disable every editable widget */
+      gtk_editable_set_editable (GTK_EDITABLE (gtk_builder_get_object (dialog->builder, "name_entry")), FALSE);
+      gtk_editable_set_editable (GTK_EDITABLE (gtk_builder_get_object (dialog->builder, "description_entry")), FALSE);
+      gtk_editable_set_editable (GTK_EDITABLE (gtk_builder_get_object (dialog->builder, "hostname_entry")), FALSE);
+      gtk_editable_set_editable (GTK_EDITABLE (gtk_builder_get_object (dialog->builder, "port_entry")), FALSE);
+      
+      gtk_widget_set_sensitive (dialog->transport_combo, FALSE);
+
+      /* we just allow closing the dialog */
+      dialog->close_button  = gtk_dialog_add_button (GTK_DIALOG (dialog),
+      						     GTK_STOCK_CLOSE,
+      						     GTK_RESPONSE_CLOSE);
+      break;
+    case GDICT_SOURCE_DIALOG_CREATE:
+      dialog->cancel_button = gtk_dialog_add_button (GTK_DIALOG (dialog),
+      						     GTK_STOCK_CANCEL,
+      						     GTK_RESPONSE_CANCEL);
+      dialog->add_button    = gtk_dialog_add_button (GTK_DIALOG (dialog),
+      						     GTK_STOCK_ADD,
+      						     GTK_RESPONSE_ACCEPT);
+      /* the "add" button sensitivity is controlled by the transport_combo
+       * since it's the only setting that makes a source usable.
+       */
+      gtk_widget_set_sensitive (dialog->add_button, FALSE);
+      break;
+    case GDICT_SOURCE_DIALOG_EDIT:
+      dialog->cancel_button = gtk_dialog_add_button (GTK_DIALOG (dialog),
+      						     GTK_STOCK_CANCEL,
+      						     GTK_RESPONSE_CANCEL);
+      dialog->close_button  = gtk_dialog_add_button (GTK_DIALOG (dialog),
+		      	 			     GTK_STOCK_CLOSE,
+						     GTK_RESPONSE_CLOSE);
+      break;
+    default:
+      g_assert_not_reached ();
+      break;
+    }
+  
+  /* this will take care of updating the contents of the dialog
+   * based on the action
+   */
+  update_dialog_ui (dialog);
+  
+  gtk_widget_pop_composite_child ();
+  
+  return object;
+}
+
+static void
+gdict_source_dialog_class_init (GdictSourceDialogClass *klass)
+{
+  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+  
+  gobject_class->constructor = gdict_source_dialog_constructor;
+  gobject_class->set_property = gdict_source_dialog_set_property;
+  gobject_class->get_property = gdict_source_dialog_get_property;
+  gobject_class->finalize = gdict_source_dialog_finalize;
+  
+  g_object_class_install_property (gobject_class,
+  				   PROP_SOURCE_LOADER,
+  				   g_param_spec_object ("source-loader",
+  				   			"Source Loader",
+  				   			"The GdictSourceLoader used by the application",
+  				   			GDICT_TYPE_SOURCE_LOADER,
+  				   			(G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY)));
+  g_object_class_install_property (gobject_class,
+  				   PROP_SOURCE_NAME,
+  				   g_param_spec_string ("source-name",
+  				   			"Source Name",
+  				   			"The source name",
+  				   			NULL,
+  				   			(G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT)));
+  g_object_class_install_property (gobject_class,
+  				   PROP_ACTION,
+  				   g_param_spec_int ("action",
+  				   		     "Action",
+  				   		     "The action the source dialog should perform",
+  				   		     -1,
+  				   		     GDICT_SOURCE_DIALOG_EDIT,
+  				   		     GDICT_SOURCE_DIALOG_VIEW,
+  				   		     (G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY)));
+}
+
+static void
+gdict_source_dialog_init (GdictSourceDialog *dialog)
+{
+  gtk_widget_set_size_request (GTK_WIDGET (dialog), 400, 300);
+  gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE);
+  
+  gtk_dialog_set_has_separator (GTK_DIALOG (dialog), FALSE);
+
+  dialog->transport = GDICT_SOURCE_TRANSPORT_INVALID;
+
+  g_signal_connect (dialog, "response",
+  		    G_CALLBACK (gdict_source_dialog_response_cb),
+  		    NULL);
+}
+
+GtkWidget *
+gdict_source_dialog_new (GtkWindow               *parent,
+			 const gchar             *title,
+			 GdictSourceDialogAction  action,
+			 GdictSourceLoader       *loader,
+			 const gchar             *source_name)
+{
+  GtkWidget *retval;
+  
+  g_return_val_if_fail ((parent == NULL || GTK_IS_WINDOW (parent)), NULL);
+  g_return_val_if_fail (GDICT_IS_SOURCE_LOADER (loader), NULL);
+  
+  retval = g_object_new (GDICT_TYPE_SOURCE_DIALOG,
+  			 "source-loader", loader,
+  			 "source-name", source_name,
+  			 "action", action,
+  			 "title", title,
+  			 NULL);
+
+  if (parent)
+    {
+      gtk_window_set_transient_for (GTK_WINDOW (retval), parent);
+      gtk_window_set_destroy_with_parent (GTK_WINDOW (retval), TRUE);
+      gtk_window_set_screen (GTK_WINDOW (retval),
+                             gtk_widget_get_screen (GTK_WIDGET (parent)));
+    }
+  
+  return retval;
+}
diff --git a/mate-dictionary/src/gdict-source-dialog.h b/mate-dictionary/src/gdict-source-dialog.h
new file mode 100644
index 00000000..ecddd8ff
--- /dev/null
+++ b/mate-dictionary/src/gdict-source-dialog.h
@@ -0,0 +1,54 @@
+/* gdict-source-dialog.h - source dialog
+ *
+ * This file is part of MATE Dictionary
+ *
+ * Copyright (C) 2005 Emmanuele Bassi
+ *
+ * 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.
+ */
+
+#ifndef __GDICT_SOURCE_DIALOG_H__
+#define __GDICT_SOURCE_DIALOG_H__
+
+#include <gtk/gtk.h>
+#include <libgdict/gdict.h>
+
+G_BEGIN_DECLS
+
+#define GDICT_TYPE_SOURCE_DIALOG 	(gdict_source_dialog_get_type ())
+#define GDICT_SOURCE_DIALOG(obj) 	(G_TYPE_CHECK_INSTANCE_CAST ((obj), GDICT_TYPE_SOURCE_DIALOG, GdictSourceDialog))
+#define GDICT_IS_SOURCE_DIALOG(obj) 	(G_TYPE_CHECK_INSTANCE_TYPE ((obj), GDICT_TYPE_SOURCE_DIALOG))
+
+typedef enum
+{
+  GDICT_SOURCE_DIALOG_VIEW,
+  GDICT_SOURCE_DIALOG_CREATE,
+  GDICT_SOURCE_DIALOG_EDIT
+} GdictSourceDialogAction;
+
+typedef struct _GdictSourceDialog      GdictSourceDialog;
+typedef struct _GdictSourceDialogClass GdictSourceDialogClass;
+
+GType      gdict_source_dialog_get_type (void) G_GNUC_CONST;
+GtkWidget *gdict_source_dialog_new      (GtkWindow               *parent,
+					 const gchar             *title,
+					 GdictSourceDialogAction  action,
+					 GdictSourceLoader       *loader,
+					 const gchar             *source_name);
+
+G_END_DECLS
+
+#endif /* __GDICT_SOURCE_DIALOG_H__ */
diff --git a/mate-dictionary/src/gdict-window.c b/mate-dictionary/src/gdict-window.c
new file mode 100644
index 00000000..1be0256c
--- /dev/null
+++ b/mate-dictionary/src/gdict-window.c
@@ -0,0 +1,2214 @@
+/* gdict-window.c - main application window
+ *
+ * This file is part of MATE Dictionary
+ *
+ * Copyright (C) 2005 Emmanuele Bassi
+ *
+ * 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.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+
+#include <gtk/gtk.h>
+#include <glib.h>
+#include <glib/gi18n.h>
+
+#include <libgdict/gdict.h>
+
+#include "gdict-sidebar.h"
+#include "gdict-print.h"
+#include "gdict-pref-dialog.h"
+#include "gdict-about.h"
+#include "gdict-window.h"
+#include "gdict-common.h"
+
+#define GDICT_WINDOW_COLUMNS      56
+#define GDICT_WINDOW_ROWS         33
+
+#define GDICT_WINDOW_MIN_WIDTH	  400
+#define GDICT_WINDOW_MIN_HEIGHT	  330
+
+/* sidebar pages logical ids */
+#define GDICT_SIDEBAR_SPELLER_PAGE      "speller"
+#define GDICT_SIDEBAR_DATABASES_PAGE    "db-chooser"
+#define GDICT_SIDEBAR_STRATEGIES_PAGE   "strat-chooser"
+#define GDICT_SIDEBAR_SOURCES_PAGE      "source-chooser"
+
+enum
+{
+  COMPLETION_TEXT_COLUMN,
+
+  COMPLETION_N_COLUMNS
+};
+
+enum
+{
+  PROP_0,
+
+  PROP_ACTION,
+  PROP_SOURCE_LOADER,
+  PROP_SOURCE_NAME,
+  PROP_PRINT_FONT,
+  PROP_DEFBOX_FONT,
+  PROP_WORD,
+  PROP_WINDOW_ID
+};
+
+enum
+{
+  CREATED,
+  
+  LAST_SIGNAL
+};
+
+static guint gdict_window_signals[LAST_SIGNAL] = { 0 };
+
+static const GtkTargetEntry drop_types[] =
+{
+  { "text/plain",    0, 0 },
+  { "TEXT",          0, 0 },
+  { "STRING",        0, 0 },
+  { "UTF8_STRING",   0, 0 },
+};
+static const guint n_drop_types = G_N_ELEMENTS (drop_types);
+
+
+
+G_DEFINE_TYPE (GdictWindow, gdict_window, GTK_TYPE_WINDOW);
+
+
+static void
+gdict_window_finalize (GObject *gobject)
+{
+  GdictWindow *window = GDICT_WINDOW (gobject);
+
+  g_free (window->source_name);
+  g_free (window->print_font);
+  g_free (window->defbox_font);
+  g_free (window->word);
+  g_free (window->database);
+  g_free (window->strategy);
+  
+  G_OBJECT_CLASS (gdict_window_parent_class)->finalize (gobject);
+}
+
+static void
+gdict_window_dispose (GObject *gobject)
+{
+  GdictWindow *window = GDICT_WINDOW (gobject);
+
+  if (window->notify_id)
+    {
+      mateconf_client_notify_remove (window->mateconf_client, window->notify_id);
+      window->notify_id = 0;
+    }
+
+  if (window->font_notify_id)
+    {
+      mateconf_client_notify_remove (window->mateconf_client,
+                                  window->font_notify_id);
+      window->font_notify_id = 0;
+    }
+  
+  if (window->mateconf_client)
+    {
+      g_object_unref (window->mateconf_client);
+      window->mateconf_client = NULL;
+    }
+  
+  if (window->context)
+    {
+      if (window->lookup_start_id)
+        {
+          g_signal_handler_disconnect (window->context,
+                                       window->lookup_start_id);
+          g_signal_handler_disconnect (window->context,
+                                       window->definition_id);
+          g_signal_handler_disconnect (window->context,
+                                       window->lookup_end_id);
+          g_signal_handler_disconnect (window->context,
+                                       window->error_id);
+
+          window->lookup_start_id = 0;
+          window->definition_id = 0;
+          window->lookup_end_id = 0;
+          window->error_id = 0;
+        }
+
+      g_object_unref (window->context);
+      window->context = NULL;
+    }
+  
+  if (window->loader)
+    {
+      g_object_unref (window->loader);
+      window->loader = NULL;
+    }
+  
+  if (window->ui_manager)
+    {
+      g_object_unref (window->ui_manager);
+      window->ui_manager = NULL;
+    }
+  
+  if (window->action_group)
+    {
+      g_object_unref (window->action_group);
+      window->action_group = NULL;
+    }
+
+  if (window->completion)
+    {
+      g_object_unref (window->completion);
+      window->completion = NULL;
+    }
+
+  if (window->completion_model)
+    {
+      g_object_unref (window->completion_model);
+      window->completion_model = NULL;
+    }
+
+  if (window->busy_cursor)
+    {
+      gdk_cursor_unref (window->busy_cursor);
+      window->busy_cursor = NULL;
+    }
+
+  G_OBJECT_CLASS (gdict_window_parent_class)->dispose (gobject);
+}
+
+static const gchar *toggle_state[] = {
+  "/MainMenu/FileMenu/SaveAsMenu",
+  "/MainMenu/FileMenu/FilePreviewMenu",
+  "/MainMenu/FileMenu/FilePrintMenu",
+  "/MainMenu/GoMenu",
+};
+
+static gint n_toggle_state = G_N_ELEMENTS (toggle_state);
+
+static void
+gdict_window_ensure_menu_state (GdictWindow *window)
+{
+  gint i;
+  gboolean is_sensitive;
+
+  g_assert (GDICT_IS_WINDOW (window));
+
+  if (!window->ui_manager)
+    return;
+
+  is_sensitive = !!(window->word != NULL);
+  for (i = 0; i < n_toggle_state; i++)
+    {
+      GtkWidget *item;
+
+      item = gtk_ui_manager_get_widget (window->ui_manager, toggle_state[i]);
+      if (!item)
+        continue;
+
+      gtk_widget_set_sensitive (item, is_sensitive);
+    }
+}
+
+static void
+gdict_window_set_sidebar_visible (GdictWindow *window,
+				  gboolean     is_visible)
+{
+  g_assert (GDICT_IS_WINDOW (window));
+  
+  if (is_visible != window->sidebar_visible)
+    {
+      GtkAction *action;
+
+      if (is_visible)
+	gtk_widget_show (window->sidebar_frame);
+      else
+	gtk_widget_hide (window->sidebar_frame);
+
+      action = gtk_action_group_get_action (window->action_group,
+                                            "ViewSidebar");
+      gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action), is_visible);
+
+      window->sidebar_visible = is_visible;
+    }
+}
+
+static void
+gdict_window_set_statusbar_visible (GdictWindow *window,
+				    gboolean     is_visible)
+{
+  g_assert (GDICT_IS_WINDOW (window));
+
+  if (is_visible != window->statusbar_visible)
+    {
+      GtkAction *action;
+
+      if (is_visible)
+	gtk_widget_show (window->status);
+      else
+	gtk_widget_hide (window->status);
+
+      action = gtk_action_group_get_action (window->action_group,
+                                            "ViewStatusbar");
+      gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action), is_visible);
+
+      window->statusbar_visible = is_visible;
+    }
+}
+
+static void
+gdict_window_definition_cb (GdictContext    *context,
+			    GdictDefinition *definition,
+			    GdictWindow     *window)
+{
+  gint total, n;
+  gdouble fraction;
+
+  g_assert (GDICT_IS_WINDOW (window));
+
+  total = gdict_definition_get_total (definition);
+  n = window->current_definition + 1;
+
+  fraction = CLAMP (((gdouble) n / (gdouble) total), 0.0, 1.0);
+
+  gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (window->progress),
+		  		 fraction);
+  while (gtk_events_pending ())
+    gtk_main_iteration ();
+
+  window->current_definition = n;
+}
+
+static void
+gdict_window_lookup_start_cb (GdictContext *context,
+			      GdictWindow  *window)
+{
+  gchar *message;
+
+  if (!window->word)
+    return;
+
+  if (!window->busy_cursor)
+    window->busy_cursor = gdk_cursor_new (GDK_WATCH);
+
+  message = g_strdup_printf (_("Searching for '%s'..."), window->word);
+  
+  if (window->status && window->statusbar_visible)
+    gtk_statusbar_push (GTK_STATUSBAR (window->status), 0, message);
+
+  if (window->progress)
+    gtk_widget_show (window->progress);
+
+  window->max_definition = -1;
+  window->last_definition = 0;
+  window->current_definition = 0;
+
+  gdk_window_set_cursor (gtk_widget_get_window (GTK_WIDGET (window)), window->busy_cursor);
+
+  g_free (message);
+}
+
+static void
+gdict_window_lookup_end_cb (GdictContext *context,
+			    GdictWindow  *window)
+{
+  gchar *message;
+  gint count;
+  GtkTreeIter iter;
+  GdictSource *source;
+  GdictContext *speller_context;
+  
+  count = window->current_definition;
+
+  window->max_definition = count - 1;
+
+  if (count == 0)
+    message = g_strdup (_("No definitions found"));
+  else 
+    message = g_strdup_printf (ngettext("A definition found",
+					"%d definitions found",
+					count),
+		    	       count);
+
+  if (window->status && window->statusbar_visible)
+    gtk_statusbar_push (GTK_STATUSBAR (window->status), 0, message);
+
+  if (window->progress)
+    gtk_widget_hide (window->progress);
+
+  /* we clone the context, so that the signals that it
+   * fires do not get caught by the signal handlers we
+   * use for getting the definitions.
+   */
+  source = gdict_source_loader_get_source (window->loader, window->source_name);
+  speller_context = gdict_source_get_context (source);
+  gdict_speller_set_context (GDICT_SPELLER (window->speller), speller_context);
+  g_object_unref (speller_context);
+  g_object_unref (source);
+
+  /* search for similar words; if we have a no-match we already started
+   * looking in the error signal handler
+   */
+  if (count != 0 && window->word)
+    {
+      gdict_speller_set_strategy (GDICT_SPELLER (window->speller), window->strategy);
+      gdict_speller_match (GDICT_SPELLER (window->speller), window->word);
+      gtk_list_store_append (window->completion_model, &iter);
+      gtk_list_store_set (window->completion_model, &iter,
+                          COMPLETION_TEXT_COLUMN, window->word,
+                          -1);
+    }
+
+  gdk_window_set_cursor (gtk_widget_get_window (GTK_WIDGET (window)), NULL);
+  g_free (message);
+
+  if (count == 0)
+    {
+      g_free (window->word);
+      window->word = NULL;
+    }
+
+  gdict_window_ensure_menu_state (window);
+}
+
+static void
+gdict_window_error_cb (GdictContext *context,
+		       const GError *error,
+		       GdictWindow  *window)
+{
+  gdk_window_set_cursor (gtk_widget_get_window (GTK_WIDGET (window)), NULL);
+  
+  if (window->status && window->statusbar_visible)
+    gtk_statusbar_push (GTK_STATUSBAR (window->status), 0,
+                        _("No definitions found"));
+
+  gtk_widget_hide (window->progress);
+
+  /* launch the speller only on NO_MATCH */
+  if (error->code == GDICT_CONTEXT_ERROR_NO_MATCH)
+    {
+      GdictSource *source;
+      GdictContext *context;
+
+      gdict_window_set_sidebar_visible (window, TRUE);
+      gdict_sidebar_view_page (GDICT_SIDEBAR (window->sidebar),
+                               GDICT_SIDEBAR_SPELLER_PAGE);
+
+      /* we clone the context, so that the signals that it
+       * fires do not get caught by the signal handlers we
+       * use for getting the definitions.
+       */
+      source = gdict_source_loader_get_source (window->loader,
+		      			       window->source_name);
+      context = gdict_source_get_context (source);
+
+      gdict_speller_set_context (GDICT_SPELLER (window->speller),
+		      		 context);
+      g_object_unref (context);
+      g_object_unref (source);
+      
+      gdict_speller_set_strategy (GDICT_SPELLER (window->speller),
+			          window->strategy);
+      
+      gdict_speller_match (GDICT_SPELLER (window->speller),
+		           window->word);
+    }
+
+  /* unset the word and update the UI */
+  g_free (window->word);
+  window->word = NULL;
+
+  gdict_window_ensure_menu_state (window);
+}
+
+static void
+gdict_window_set_database (GdictWindow *window,
+			   const gchar *database)
+{
+  g_free (window->database);
+
+  if (database)
+    window->database = g_strdup (database);
+  else
+    window->database = gdict_mateconf_get_string_with_default (window->mateconf_client,
+							    GDICT_MATECONF_DATABASE_KEY,
+							    GDICT_DEFAULT_DATABASE);
+
+  if (window->defbox)
+    gdict_defbox_set_database (GDICT_DEFBOX (window->defbox),
+			       window->database);
+
+  if (window->db_chooser)
+    gdict_database_chooser_set_current_database (GDICT_DATABASE_CHOOSER (window->db_chooser),
+                                                 window->database);
+}
+
+static void
+gdict_window_set_strategy (GdictWindow *window,
+			   const gchar *strategy)
+{
+  g_free (window->strategy);
+
+  if (strategy && strategy[0] != '\0')
+    window->strategy = g_strdup (strategy);
+  else
+    window->strategy = gdict_mateconf_get_string_with_default (window->mateconf_client,
+							    GDICT_MATECONF_STRATEGY_KEY,
+							    GDICT_DEFAULT_STRATEGY);
+
+  if (window->speller)
+    gdict_speller_set_strategy (GDICT_SPELLER (window->speller),
+                                window->strategy);
+
+  if (window->strat_chooser)
+    gdict_strategy_chooser_set_current_strategy (GDICT_STRATEGY_CHOOSER (window->strat_chooser),
+                                                 window->strategy);
+}
+
+static GdictContext *
+get_context_from_loader (GdictWindow *window)
+{
+  GdictSource *source;
+  GdictContext *retval;
+
+  if (!window->source_name)
+    window->source_name = g_strdup (GDICT_DEFAULT_SOURCE_NAME);
+
+  source = gdict_source_loader_get_source (window->loader,
+		  			   window->source_name);
+  if (!source &&
+      strcmp (window->source_name, GDICT_DEFAULT_SOURCE_NAME) != 0)
+    {
+      g_free (window->source_name);
+      window->source_name = g_strdup (GDICT_DEFAULT_SOURCE_NAME);
+
+      source = gdict_source_loader_get_source (window->loader,
+                                               window->source_name);
+    }
+  
+  if (!source)
+    {
+      gchar *detail;
+      
+      detail = g_strdup_printf (_("No dictionary source available with name '%s'"),
+      				window->source_name);
+
+      gdict_show_error_dialog (GTK_WINDOW (window),
+                               _("Unable to find dictionary source"),
+                               detail);
+      
+      g_free (detail);
+
+      return NULL;
+    }
+  
+  gdict_window_set_database (window, gdict_source_get_database (source));
+  gdict_window_set_strategy (window, gdict_source_get_strategy (source));
+  
+  retval = gdict_source_get_context (source);
+  if (!retval)
+    {
+      gchar *detail;
+      
+      detail = g_strdup_printf (_("No context available for source '%s'"),
+      				gdict_source_get_description (source));
+      				
+      gdict_show_error_dialog (GTK_WINDOW (window),
+                               _("Unable to create a context"),
+                               detail);
+      
+      g_free (detail);
+      g_object_unref (source);
+      
+      return NULL;
+    }
+  
+  g_object_unref (source);
+  
+  return retval;
+}
+
+static void
+gdict_window_set_defbox_font (GdictWindow *window,
+			      const gchar *defbox_font)
+{
+  g_free (window->defbox_font);
+
+  if (defbox_font)
+    window->defbox_font = g_strdup (defbox_font);
+  else
+    window->defbox_font = gdict_mateconf_get_string_with_default (window->mateconf_client,
+							       DOCUMENT_FONT_KEY,
+							       GDICT_DEFAULT_DEFBOX_FONT);
+
+  if (window->defbox)
+    gdict_defbox_set_font_name (GDICT_DEFBOX (window->defbox),
+				window->defbox_font);
+}
+
+static void
+gdict_window_set_print_font (GdictWindow *window,
+			     const gchar *print_font)
+{
+  g_free (window->print_font);
+
+  if (print_font)
+    window->print_font = g_strdup (print_font);
+  else
+    window->print_font = gdict_mateconf_get_string_with_default (window->mateconf_client,
+							      GDICT_MATECONF_PRINT_FONT_KEY,
+							      GDICT_DEFAULT_PRINT_FONT);
+}
+
+static void
+gdict_window_set_word (GdictWindow *window,
+		       const gchar *word,
+		       const gchar *database)
+{
+  gchar *title;
+  
+  g_free (window->word);
+  window->word = NULL;
+
+  if (word && word[0] != '\0')
+    window->word = g_strdup (word);
+  else
+    return;
+
+  if (!database || database[0] == '\0')
+    database = window->database;
+
+  if (window->word)
+    title = g_strdup_printf (_("%s - Dictionary"), window->word);
+  else
+    title = g_strdup (_("Dictionary"));
+  
+  gtk_window_set_title (GTK_WINDOW (window), title);
+  g_free (title);
+
+  if (window->defbox)
+    {
+      gdict_defbox_set_database (GDICT_DEFBOX (window->defbox), database);
+      gdict_defbox_lookup (GDICT_DEFBOX (window->defbox), word);
+    }
+}
+
+static void
+gdict_window_set_context (GdictWindow  *window,
+			  GdictContext *context)
+{
+  if (window->context)
+    {
+      g_signal_handler_disconnect (window->context, window->definition_id);
+      g_signal_handler_disconnect (window->context, window->lookup_start_id);
+      g_signal_handler_disconnect (window->context, window->lookup_end_id);
+      g_signal_handler_disconnect (window->context, window->error_id);
+      
+      window->definition_id = 0;
+      window->lookup_start_id = 0;
+      window->lookup_end_id = 0;
+      window->error_id = 0;
+      
+      g_object_unref (window->context);
+      window->context = NULL;
+    }
+
+  if (window->defbox)
+    gdict_defbox_set_context (GDICT_DEFBOX (window->defbox), context);
+
+  if (window->db_chooser)
+    gdict_database_chooser_set_context (GDICT_DATABASE_CHOOSER (window->db_chooser), context);
+
+  if (window->strat_chooser)
+    gdict_strategy_chooser_set_context (GDICT_STRATEGY_CHOOSER (window->strat_chooser), context);
+
+  if (!context)
+    return;
+  
+  /* attach our callbacks */
+  window->definition_id   = g_signal_connect (context, "definition-found",
+		  			      G_CALLBACK (gdict_window_definition_cb),
+					      window);
+  window->lookup_start_id = g_signal_connect (context, "lookup-start",
+		  			      G_CALLBACK (gdict_window_lookup_start_cb),
+					      window);
+  window->lookup_end_id   = g_signal_connect (context, "lookup-end",
+		  			      G_CALLBACK (gdict_window_lookup_end_cb),
+					      window);
+  window->error_id        = g_signal_connect (context, "error",
+		  			      G_CALLBACK (gdict_window_error_cb),
+					      window);
+  
+  window->context = context;
+}
+
+static void
+gdict_window_set_source_name (GdictWindow *window,
+			      const gchar *source_name)
+{
+  GdictContext *context;
+
+  if (window->source_name && source_name &&
+      strcmp (window->source_name, source_name) == 0)
+    return;
+
+  g_free (window->source_name);
+
+  if (source_name)
+    window->source_name = g_strdup (source_name);
+  else
+    window->source_name = gdict_mateconf_get_string_with_default (window->mateconf_client,
+							       GDICT_MATECONF_SOURCE_KEY,
+							       GDICT_DEFAULT_SOURCE_NAME);
+
+  context = get_context_from_loader (window);
+  gdict_window_set_context (window, context);
+
+  if (window->source_chooser)
+    gdict_source_chooser_set_current_source (GDICT_SOURCE_CHOOSER (window->source_chooser),
+                                             window->source_name);
+
+  g_object_notify (G_OBJECT (window), "source-name");
+}
+
+static void
+gdict_window_set_property (GObject      *object,
+			   guint         prop_id,
+			   const GValue *value,
+			   GParamSpec   *pspec)
+{
+  GdictWindow *window = GDICT_WINDOW (object);
+  
+  switch (prop_id)
+    {
+    case PROP_ACTION:
+      window->action = g_value_get_enum (value);
+      break;
+    case PROP_SOURCE_LOADER:
+      if (window->loader)
+        g_object_unref (window->loader);
+      window->loader = g_value_get_object (value);
+      g_object_ref (window->loader);
+      break;
+    case PROP_SOURCE_NAME:
+      gdict_window_set_source_name (window, g_value_get_string (value));
+      break;
+    case PROP_WORD:
+      gdict_window_set_word (window, g_value_get_string (value), NULL);
+      break;
+    case PROP_PRINT_FONT:
+      gdict_window_set_print_font (window, g_value_get_string (value));
+      break;
+    case PROP_DEFBOX_FONT:
+      gdict_window_set_defbox_font (window, g_value_get_string (value));
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+    }
+}
+
+static void
+gdict_window_get_property (GObject    *object,
+			   guint       prop_id,
+			   GValue     *value,
+			   GParamSpec *pspec)
+{
+  GdictWindow *window = GDICT_WINDOW (object);
+  
+  switch (prop_id)
+    {
+    case PROP_ACTION:
+      g_value_set_enum (value, window->action);
+      break;
+    case PROP_SOURCE_LOADER:
+      g_value_set_object (value, window->loader);
+      break;
+    case PROP_SOURCE_NAME:
+      g_value_set_string (value, window->source_name);
+      break;
+    case PROP_WORD:
+      g_value_set_string (value, window->word);
+      break;
+    case PROP_PRINT_FONT:
+      g_value_set_string (value, window->print_font);
+      break;
+    case PROP_DEFBOX_FONT:
+      g_value_set_string (value, window->defbox_font);
+      break;
+    case PROP_WINDOW_ID:
+      g_value_set_uint (value, window->window_id);
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+    }
+}
+
+static void
+gdict_window_cmd_file_new (GtkAction   *action,
+			   GdictWindow *window)
+{
+  GtkWidget *new_window;
+  gchar *word = NULL;
+  
+  /* store the default size of the window and its state, so that
+   * it's picked up by the newly created window
+   */
+  mateconf_client_set_int (window->mateconf_client,
+		        GDICT_MATECONF_WINDOW_WIDTH_KEY,
+		  	window->default_width,
+			NULL);
+  mateconf_client_set_int (window->mateconf_client,
+		  	GDICT_MATECONF_WINDOW_HEIGHT_KEY,
+			window->default_height,
+			NULL);
+  mateconf_client_set_bool (window->mateconf_client,
+		  	 GDICT_MATECONF_WINDOW_IS_MAXIMIZED_KEY,
+			 window->is_maximized,
+			 NULL);
+  mateconf_client_set_bool (window->mateconf_client,
+		  	 GDICT_MATECONF_SIDEBAR_VISIBLE_KEY,
+			 window->sidebar_visible,
+			 NULL);
+  mateconf_client_set_int (window->mateconf_client,
+		  	GDICT_MATECONF_SIDEBAR_WIDTH_KEY,
+			window->sidebar_width,
+			NULL);
+  mateconf_client_set_string (window->mateconf_client,
+		  	   GDICT_MATECONF_SIDEBAR_PAGE_KEY,
+			   gdict_sidebar_current_page (GDICT_SIDEBAR (window->sidebar)),
+			   NULL);
+  mateconf_client_set_bool (window->mateconf_client,
+		  	 GDICT_MATECONF_STATUSBAR_VISIBLE_KEY,
+			 window->statusbar_visible,
+			 NULL);
+
+  word = gdict_defbox_get_selected_word (GDICT_DEFBOX (window->defbox));
+  if (word)
+    {
+      new_window = gdict_window_new (GDICT_WINDOW_ACTION_LOOKUP,
+                                     window->loader,
+                                     NULL, word);
+      g_free (word);
+    }
+  else
+    new_window = gdict_window_new (GDICT_WINDOW_ACTION_CLEAR,
+                                   window->loader,
+                                   NULL, NULL);
+
+  gtk_widget_show (new_window);
+  
+  g_signal_emit (window, gdict_window_signals[CREATED], 0, new_window);
+}
+
+static void
+gdict_window_cmd_save_as (GtkAction   *action,
+			  GdictWindow *window)
+{
+  GtkWidget *dialog;
+  
+  g_assert (GDICT_IS_WINDOW (window));
+  
+  dialog = gtk_file_chooser_dialog_new (_("Save a Copy"),
+  					GTK_WINDOW (window),
+  					GTK_FILE_CHOOSER_ACTION_SAVE,
+  					GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
+  					GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
+  					NULL);
+  gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dialog), TRUE);
+  
+  /* default to user's home */
+  gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), g_get_home_dir ());
+  gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (dialog), _("Untitled document"));
+  
+  if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT)
+    {
+      gchar *filename;
+      gchar *text;
+      gsize len;
+      GError *write_error = NULL;
+      
+      filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
+      
+      text = gdict_defbox_get_text (GDICT_DEFBOX (window->defbox), &len);
+      
+      g_file_set_contents (filename,
+      			   text,
+      			   len,
+      			   &write_error);
+      if (write_error)
+        {
+          gchar *message;
+          
+          message = g_strdup_printf (_("Error while writing to '%s'"), filename);
+          
+          gdict_show_gerror_dialog (GTK_WINDOW (window),
+                                    message,
+                                    write_error);
+
+          g_free (message);
+        }
+      
+      g_free (text);
+      g_free (filename);
+    }
+
+  gtk_widget_destroy (dialog);
+}
+
+static void
+gdict_window_cmd_file_preview (GtkAction   *action,
+                               GdictWindow *window)
+{
+  g_assert (GDICT_IS_WINDOW (window));
+
+  gdict_show_print_preview (GTK_WINDOW (window),
+                            GDICT_DEFBOX (window->defbox));
+}
+
+static void
+gdict_window_cmd_file_print (GtkAction   *action,
+			     GdictWindow *window)
+{
+  g_assert (GDICT_IS_WINDOW (window));
+  
+  gdict_show_print_dialog (GTK_WINDOW (window),
+  			   GDICT_DEFBOX (window->defbox));
+}
+
+static void
+gdict_window_cmd_file_close_window (GtkAction   *action,
+				    GdictWindow *window)
+{
+  g_assert (GDICT_IS_WINDOW (window));
+
+  /* store the default size of the window and its state */
+  mateconf_client_set_int (window->mateconf_client,
+		        GDICT_MATECONF_WINDOW_WIDTH_KEY,
+		  	window->default_width,
+			NULL);
+  mateconf_client_set_int (window->mateconf_client,
+		  	GDICT_MATECONF_WINDOW_HEIGHT_KEY,
+			window->default_height,
+			NULL);
+  mateconf_client_set_bool (window->mateconf_client,
+		  	 GDICT_MATECONF_WINDOW_IS_MAXIMIZED_KEY,
+			 window->is_maximized,
+			 NULL);
+  mateconf_client_set_bool (window->mateconf_client,
+		         GDICT_MATECONF_SIDEBAR_VISIBLE_KEY,
+			 window->sidebar_visible,
+			 NULL);
+  mateconf_client_set_int  (window->mateconf_client,
+		  	 GDICT_MATECONF_SIDEBAR_WIDTH_KEY,
+			 window->sidebar_width,
+			 NULL);
+  mateconf_client_set_string (window->mateconf_client,
+		           GDICT_MATECONF_SIDEBAR_PAGE_KEY,
+			   gdict_sidebar_current_page (GDICT_SIDEBAR (window->sidebar)),
+			   NULL);
+  mateconf_client_set_bool (window->mateconf_client,
+		  	 GDICT_MATECONF_STATUSBAR_VISIBLE_KEY,
+			 window->statusbar_visible,
+			 NULL);
+  
+  /* if this was called from the uimanager, destroy the widget;
+   * otherwise, if it was called from the delete_event, the widget
+   * will destroy itself.
+   */
+  if (action)
+    gtk_widget_destroy (GTK_WIDGET (window));
+}
+
+static void
+gdict_window_cmd_edit_copy (GtkAction   *action,
+			    GdictWindow *window)
+{
+  g_assert (GDICT_IS_WINDOW (window));
+
+  gdict_defbox_copy_to_clipboard (GDICT_DEFBOX (window->defbox),
+		  		  gtk_clipboard_get (GDK_SELECTION_CLIPBOARD));
+}
+
+static void
+gdict_window_cmd_edit_select_all (GtkAction   *action,
+				  GdictWindow *window)
+{
+  g_assert (GDICT_IS_WINDOW (window));
+
+  gdict_defbox_select_all (GDICT_DEFBOX (window->defbox));
+}
+
+static void
+gdict_window_cmd_edit_find (GtkAction   *action,
+			    GdictWindow *window)
+{
+  g_assert (GDICT_IS_WINDOW (window));
+  
+  gdict_defbox_set_show_find (GDICT_DEFBOX (window->defbox), TRUE);
+}
+
+static void
+gdict_window_cmd_edit_find_next (GtkAction   *action,
+				 GdictWindow *window)
+{
+  g_assert (GDICT_IS_WINDOW (window));
+
+  gdict_defbox_find_next (GDICT_DEFBOX (window->defbox));
+}
+
+static void
+gdict_window_cmd_edit_find_previous (GtkAction   *action,
+				     GdictWindow *window)
+{
+  g_assert (GDICT_IS_WINDOW (window));
+
+  gdict_defbox_find_previous (GDICT_DEFBOX (window->defbox));
+}
+
+static void
+gdict_window_cmd_edit_preferences (GtkAction   *action,
+				   GdictWindow *window)
+{
+  g_assert (GDICT_IS_WINDOW (window));
+  
+  gdict_show_pref_dialog (GTK_WIDGET (window),
+  			  _("Dictionary Preferences"),
+  			  window->loader);
+}
+
+static void
+gdict_window_cmd_view_sidebar (GtkAction   *action,
+			       GdictWindow *window)
+{
+  g_assert (GDICT_IS_WINDOW (window));
+
+  if (window->sidebar_visible)
+    gdict_window_set_sidebar_visible (window, FALSE);
+  else
+    gdict_window_set_sidebar_visible (window, TRUE);
+}
+
+static void
+gdict_window_cmd_view_statusbar (GtkAction   *action,
+				 GdictWindow *window)
+{
+  g_assert (GDICT_IS_WINDOW (window));
+
+  if (window->statusbar_visible)
+    gdict_window_set_statusbar_visible (window, FALSE);
+  else
+    gdict_window_set_statusbar_visible (window, TRUE);
+}
+
+static void
+gdict_window_cmd_view_speller (GtkAction   *action,
+			       GdictWindow *window)
+{
+  g_assert (GDICT_IS_WINDOW (window));
+
+  gdict_sidebar_view_page (GDICT_SIDEBAR (window->sidebar),
+                           GDICT_SIDEBAR_SPELLER_PAGE);
+  gdict_window_set_sidebar_visible (window, TRUE);
+}
+
+static void
+gdict_window_cmd_view_databases (GtkAction   *action,
+				 GdictWindow *window)
+{
+  g_assert (GDICT_IS_WINDOW (window));
+
+  gdict_sidebar_view_page (GDICT_SIDEBAR (window->sidebar),
+                           GDICT_SIDEBAR_DATABASES_PAGE);
+  gdict_window_set_sidebar_visible (window, TRUE);
+}
+
+static void
+gdict_window_cmd_view_strategies (GtkAction   *action,
+                                  GdictWindow *window)
+{
+  g_assert (GDICT_IS_WINDOW (window));
+
+  gdict_sidebar_view_page (GDICT_SIDEBAR (window->sidebar),
+                           GDICT_SIDEBAR_STRATEGIES_PAGE);
+  gdict_window_set_sidebar_visible (window, TRUE);
+}
+
+static void
+gdict_window_cmd_view_sources (GtkAction   *action,
+                               GdictWindow *window)
+{
+  g_assert (GDICT_IS_WINDOW (window));
+
+  gdict_sidebar_view_page (GDICT_SIDEBAR (window->sidebar),
+                           GDICT_SIDEBAR_SOURCES_PAGE);
+  gdict_window_set_sidebar_visible (window, TRUE);
+}
+
+static void
+gdict_window_cmd_go_first_def (GtkAction   *action,
+			       GdictWindow *window)
+{
+  g_assert (GDICT_IS_WINDOW (window));
+  
+  window->last_definition = 0;
+  gdict_defbox_jump_to_definition (GDICT_DEFBOX (window->defbox),
+                                   window->last_definition);
+}
+
+static void
+gdict_window_cmd_go_previous_def (GtkAction   *action,
+				  GdictWindow *window)
+{
+  g_assert (GDICT_IS_WINDOW (window));
+  
+  if (window->last_definition == 0)
+    return;
+  
+  window->last_definition -= 1;
+  gdict_defbox_jump_to_definition (GDICT_DEFBOX (window->defbox),
+                                   window->last_definition);
+}
+
+static void
+gdict_window_cmd_go_next_def (GtkAction   *action,
+			      GdictWindow *window)
+{
+  g_assert (GDICT_IS_WINDOW (window));
+  
+  if (window->max_definition == -1)
+    window->max_definition = gdict_defbox_count_definitions (GDICT_DEFBOX (window->defbox)) - 1;
+    
+  if (window->last_definition == window->max_definition)
+    return;
+  
+  window->last_definition += 1;
+  gdict_defbox_jump_to_definition (GDICT_DEFBOX (window->defbox),
+                                   window->last_definition);
+}
+
+static void
+gdict_window_cmd_go_last_def (GtkAction   *action,
+			      GdictWindow *window)
+{
+  g_assert (GDICT_IS_WINDOW (window));
+  
+  if (window->max_definition == -1)
+    window->last_definition = gdict_defbox_count_definitions (GDICT_DEFBOX (window->defbox)) - 1;
+  
+  window->last_definition = window->max_definition;
+  gdict_defbox_jump_to_definition (GDICT_DEFBOX (window->defbox),
+                                   window->last_definition);
+}
+
+static void
+gdict_window_cmd_help_contents (GtkAction   *action,
+				GdictWindow *window)
+{
+  GError *err = NULL;
+  
+  g_return_if_fail (GDICT_IS_WINDOW (window));
+ 
+  gtk_show_uri (gtk_widget_get_screen (GTK_WIDGET (window)),
+                "ghelp:mate-dictionary",
+                gtk_get_current_event_time (), &err); 
+  if (err)
+    {
+      gdict_show_gerror_dialog (GTK_WINDOW (window),
+      		                _("There was an error while displaying help"),
+      			        err);
+      g_error_free (err);
+    }
+}
+
+static void
+gdict_window_cmd_help_about (GtkAction   *action,
+			     GdictWindow *window)
+{
+  g_assert (GDICT_IS_WINDOW (window));
+  
+  gdict_show_about_dialog (GTK_WIDGET (window));
+}
+
+static void
+gdict_window_cmd_lookup (GtkAction   *action,
+			 GdictWindow *window)
+{
+  g_assert (GDICT_IS_WINDOW (window));
+
+  gtk_widget_grab_focus (window->entry);
+}
+
+static void
+gdict_window_cmd_escape (GtkAction   *action,
+			 GdictWindow *window)
+{
+  g_assert (GDICT_IS_WINDOW (window));
+  
+  gdict_defbox_set_show_find (GDICT_DEFBOX (window->defbox), FALSE);
+}
+
+static const GtkActionEntry entries[] =
+{
+  { "File", NULL, N_("_File") },
+  { "Edit", NULL, N_("_Edit") },
+  { "View", NULL, N_("_View") },
+  { "Go", NULL, N_("_Go") },
+  { "Help", NULL, N_("_Help") },
+
+  /* File menu */
+  { "FileNew", GTK_STOCK_NEW, N_("_New"), "<control>N",
+    N_("New look up"), G_CALLBACK (gdict_window_cmd_file_new) },
+  { "FileSaveAs", GTK_STOCK_SAVE_AS, N_("_Save a Copy..."), NULL, NULL,
+    G_CALLBACK (gdict_window_cmd_save_as) },
+  { "FilePreview", NULL, N_("P_review..."), "<control><shift>P",
+    N_("Preview this document"), G_CALLBACK (gdict_window_cmd_file_preview) },
+  { "FilePrint", GTK_STOCK_PRINT, N_("_Print..."), "<control>P",
+    N_("Print this document"), G_CALLBACK (gdict_window_cmd_file_print) },
+  { "FileCloseWindow", GTK_STOCK_CLOSE, NULL, "<control>W", NULL,
+    G_CALLBACK (gdict_window_cmd_file_close_window) },
+
+  /* Edit menu */
+  { "EditCopy", GTK_STOCK_COPY, NULL, "<control>C", NULL,
+    G_CALLBACK (gdict_window_cmd_edit_copy) },
+  { "EditSelectAll", NULL, N_("Select _All"), "<control>A", NULL,
+    G_CALLBACK (gdict_window_cmd_edit_select_all) },
+  { "EditFind", GTK_STOCK_FIND, NULL, "<control>F",
+    N_("Find a word or phrase in the document"),
+    G_CALLBACK (gdict_window_cmd_edit_find) },
+  { "EditFindNext", NULL, N_("Find Ne_xt"), "<control>G", NULL,
+    G_CALLBACK (gdict_window_cmd_edit_find_next) },
+  { "EditFindPrevious", NULL, N_("Find Pre_vious"), "<control><shift>G", NULL,
+    G_CALLBACK (gdict_window_cmd_edit_find_previous) },
+  { "EditPreferences", GTK_STOCK_PREFERENCES, N_("_Preferences"), NULL, NULL,
+    G_CALLBACK (gdict_window_cmd_edit_preferences) },
+
+  /* Go menu */
+  { "GoPreviousDef", GTK_STOCK_GO_BACK, N_("_Previous Definition"), "<control>Page_Up",
+    N_("Go to the previous definition"), G_CALLBACK (gdict_window_cmd_go_previous_def) },
+  { "GoNextDef", GTK_STOCK_GO_FORWARD, N_("_Next Definition"), "<control>Page_Down",
+    N_("Go to the next definition"), G_CALLBACK (gdict_window_cmd_go_next_def) },
+  { "GoFirstDef", GTK_STOCK_GOTO_FIRST, N_("_First Definition"), "<control>Home",
+    N_("Go to the first definition"), G_CALLBACK (gdict_window_cmd_go_first_def) },
+  { "GoLastDef", GTK_STOCK_GOTO_LAST, N_("_Last Definition"), "<control>End",
+    N_("Go to the last definition"), G_CALLBACK (gdict_window_cmd_go_last_def) },
+
+  /* View menu */
+  { "ViewSpeller", NULL, N_("Similar _Words"), "<control>T", NULL,
+    G_CALLBACK (gdict_window_cmd_view_speller), },
+  { "ViewSource", NULL, N_("Dictionary Sources"), "<control>D", NULL,
+    G_CALLBACK (gdict_window_cmd_view_sources), },
+  { "ViewDB", NULL, N_("Available _Databases"), "<control>B", NULL,
+    G_CALLBACK (gdict_window_cmd_view_databases), },
+  { "ViewStrat", NULL, N_("Available St_rategies"), "<control>R", NULL,
+    G_CALLBACK (gdict_window_cmd_view_strategies), },
+
+  /* Help menu */
+  { "HelpContents", GTK_STOCK_HELP, N_("_Contents"), "F1", NULL,
+    G_CALLBACK (gdict_window_cmd_help_contents) },
+  { "HelpAbout", GTK_STOCK_ABOUT, N_("_About"), NULL, NULL,
+    G_CALLBACK (gdict_window_cmd_help_about) },
+  
+  /* Accelerators */
+  { "Lookup", NULL, "", "<control>L", NULL, G_CALLBACK (gdict_window_cmd_lookup) },
+  { "Escape", NULL, "", "Escape", "", G_CALLBACK (gdict_window_cmd_escape) },
+  { "Slash", GTK_STOCK_FIND, NULL, "slash", NULL, G_CALLBACK (gdict_window_cmd_edit_find) },
+};
+
+static const GtkToggleActionEntry toggle_entries[] = {
+  /* View menu */
+  { "ViewSidebar", NULL, N_("_Sidebar"), "F9", NULL,
+    G_CALLBACK (gdict_window_cmd_view_sidebar), FALSE },
+  { "ViewStatusbar", NULL, N_("S_tatusbar"), NULL, NULL,
+    G_CALLBACK (gdict_window_cmd_view_statusbar), FALSE },
+};
+
+static gboolean
+gdict_window_delete_event_cb (GtkWidget *widget,
+			      GdkEvent  *event,
+			      gpointer   user_data)
+{
+  gdict_window_cmd_file_close_window (NULL, GDICT_WINDOW (widget));
+
+  return FALSE;
+}
+
+static gboolean
+gdict_window_state_event_cb (GtkWidget           *widget,
+			     GdkEventWindowState *event,
+			     gpointer             user_data)
+{
+  GdictWindow *window = GDICT_WINDOW (widget);
+  
+  if (event->new_window_state & GDK_WINDOW_STATE_MAXIMIZED)
+    window->is_maximized = TRUE;
+  else
+    window->is_maximized = FALSE;
+  
+  return FALSE;
+}
+
+static void
+gdict_window_mateconf_notify_cb (MateConfClient *client,
+			      guint        cnxn_id,
+			      MateConfEntry  *entry,
+			      gpointer     user_data)
+{
+  GdictWindow *window;
+
+  window = GDICT_WINDOW (user_data);
+
+  if (strcmp (entry->key, GDICT_MATECONF_PRINT_FONT_KEY) == 0)
+    {
+      if (entry->value && (entry->value->type == MATECONF_VALUE_STRING))
+        gdict_window_set_print_font (window, mateconf_value_get_string (entry->value));
+      else
+        gdict_window_set_print_font (window, GDICT_DEFAULT_PRINT_FONT);
+    }
+  else if (strcmp (entry->key, GDICT_MATECONF_SOURCE_KEY) == 0)
+    {
+      if (entry->value && (entry->value->type == MATECONF_VALUE_STRING))
+        gdict_window_set_source_name (window, mateconf_value_get_string (entry->value));
+      else
+        gdict_window_set_source_name (window, GDICT_DEFAULT_SOURCE_NAME);
+    }
+  else if (strcmp (entry->key, GDICT_MATECONF_DATABASE_KEY) == 0)
+    {
+      if (entry->value && (entry->value->type == MATECONF_VALUE_STRING))
+        gdict_window_set_database (window, mateconf_value_get_string (entry->value));
+      else
+        gdict_window_set_database (window, GDICT_DEFAULT_DATABASE);
+    }
+  else if (strcmp (entry->key, DOCUMENT_FONT_KEY) == 0)
+    {
+      if (entry->value && (entry->value->type == MATECONF_VALUE_STRING))
+        gdict_window_set_defbox_font (window, mateconf_value_get_string (entry->value));
+      else
+        gdict_window_set_defbox_font (window, GDICT_DEFAULT_DEFBOX_FONT);
+    }
+  else if (strcmp (entry->key, GDICT_MATECONF_SIDEBAR_VISIBLE_KEY) == 0)
+    {
+      if (entry->value && (entry->value->type == MATECONF_VALUE_BOOL))
+        gdict_window_set_sidebar_visible (window,
+					  mateconf_value_get_bool (entry->value));
+      else
+        gdict_window_set_sidebar_visible (window, FALSE);
+    }
+  else if (strcmp (entry->key, GDICT_MATECONF_STATUSBAR_VISIBLE_KEY) == 0)
+    {
+      if (entry->value && (entry->value->type == MATECONF_VALUE_BOOL))
+	gdict_window_set_statusbar_visible (window,
+					    mateconf_value_get_bool (entry->value));
+      else
+	gdict_window_set_statusbar_visible (window, FALSE);
+    }
+}
+
+static void
+lookup_word (GdictWindow *window,
+             gpointer     dummy)
+{
+  const gchar *entry_text;
+  gchar *word;
+  
+  g_assert (GDICT_IS_WINDOW (window));
+  
+  if (!window->context)
+    return;
+  
+  entry_text = gtk_entry_get_text (GTK_ENTRY (window->entry));
+  if (!entry_text || *entry_text == '\0')
+    return;
+
+  word = g_strdup (entry_text);
+  gdict_window_set_word (window, g_strstrip (word), NULL);
+
+  g_free (word);
+}
+
+static void
+source_activated_cb (GdictSourceChooser *chooser,
+                     const gchar        *source_name,
+                     GdictSource        *source,
+                     GdictWindow        *window)
+{
+  g_signal_handlers_block_by_func (chooser, source_activated_cb, window);
+  gdict_window_set_source_name (window, source_name);
+  g_signal_handlers_unblock_by_func (chooser, source_activated_cb, window);
+
+  if (window->status && window->statusbar_visible)
+    {
+      gchar *message;
+
+      message = g_strdup_printf (_("Dictionary source `%s' selected"),
+                                 gdict_source_get_description (source));
+      gtk_statusbar_push (GTK_STATUSBAR (window->status), 0, message);
+      g_free (message);
+    }
+}
+
+static void
+strategy_activated_cb (GdictStrategyChooser *chooser,
+                       const gchar          *strat_name,
+                       const gchar          *strat_desc,
+                       GdictWindow          *window)
+{
+  g_signal_handlers_block_by_func (chooser, strategy_activated_cb, window);
+  gdict_window_set_strategy (window, strat_name);
+  g_signal_handlers_unblock_by_func (chooser, strategy_activated_cb, window);
+
+  if (window->status && window->statusbar_visible)
+    {
+      gchar *message;
+
+      message = g_strdup_printf (_("Strategy `%s' selected"), strat_desc);
+      gtk_statusbar_push (GTK_STATUSBAR (window->status), 0, message);
+      g_free (message);
+    }
+}
+
+static void
+database_activated_cb (GdictDatabaseChooser *chooser,
+		       const gchar          *db_name,
+		       const gchar          *db_desc,
+		       GdictWindow          *window)
+{
+  g_signal_handlers_block_by_func (chooser, database_activated_cb, window);
+  gdict_window_set_database (window, db_name);
+  g_signal_handlers_unblock_by_func (chooser, database_activated_cb, window);
+
+  if (window->status && window->statusbar_visible)
+    {
+      gchar *message;
+
+      message = g_strdup_printf (_("Database `%s' selected"), db_desc);
+      gtk_statusbar_push (GTK_STATUSBAR (window->status), 0, message);
+      g_free (message);
+    }
+}
+
+static void
+speller_word_activated_cb (GdictSpeller *speller,
+			   const gchar  *word,
+			   const gchar  *db_name,
+			   GdictWindow  *window)
+{
+  gtk_entry_set_text (GTK_ENTRY (window->entry), word);
+  
+  gdict_window_set_word (window, word, db_name);
+
+  if (window->status && window->statusbar_visible)
+    {
+      gchar *message;
+
+      message = g_strdup_printf (_("Word `%s' selected"), word);
+      gtk_statusbar_push (GTK_STATUSBAR (window->status), 0, message);
+      g_free (message);
+    }
+}
+
+static void
+sidebar_page_changed_cb (GdictSidebar *sidebar,
+			 GdictWindow  *window)
+{
+  const gchar *page_id;
+  const gchar *message;
+
+  page_id = gdict_sidebar_current_page (sidebar);
+
+  switch (page_id[0])
+    {
+    case 's':
+      {
+      switch (page_id[1])
+        {
+        case 'p': /* speller */
+          message = _("Double-click on the word to look up");
+          if (window->word)
+            gdict_speller_match (GDICT_SPELLER (window->speller),
+                                 window->word);
+          break;
+        case 't': /* strat-chooser */
+          message = _("Double-click on the matching strategy to use");
+          
+          gdict_strategy_chooser_refresh (GDICT_STRATEGY_CHOOSER (window->strat_chooser));
+          break;
+        case 'o': /* source-chooser */
+          message = _("Double-click on the source to use");
+          gdict_source_chooser_refresh (GDICT_SOURCE_CHOOSER (window->source_chooser));
+          break;
+        default:
+          message = NULL;
+        }
+      }
+      break;
+    case 'd': /* db-chooser */
+      message = _("Double-click on the database to use");
+      
+      gdict_database_chooser_refresh (GDICT_DATABASE_CHOOSER (window->db_chooser));
+      break;
+    default:
+      message = NULL;
+      break;
+    }
+
+  if (message && window->status && window->statusbar_visible)
+    gtk_statusbar_push (GTK_STATUSBAR (window->status), 0, message);
+}
+
+static void
+sidebar_closed_cb (GdictSidebar *sidebar,
+		   GdictWindow  *window)
+{
+  gdict_window_set_sidebar_visible (window, FALSE); 
+}
+
+static void
+gdict_window_link_clicked (GdictDefbox *defbox,
+                           const gchar *link_text,
+                           GdictWindow *window)
+{
+  GtkWidget *new_window;
+  
+  /* store the default size of the window and its state, so that
+   * it's picked up by the newly created window
+   */
+  mateconf_client_set_int (window->mateconf_client,
+		        GDICT_MATECONF_WINDOW_WIDTH_KEY,
+		  	window->default_width,
+			NULL);
+  mateconf_client_set_int (window->mateconf_client,
+		  	GDICT_MATECONF_WINDOW_HEIGHT_KEY,
+			window->default_height,
+			NULL);
+  mateconf_client_set_bool (window->mateconf_client,
+		  	 GDICT_MATECONF_WINDOW_IS_MAXIMIZED_KEY,
+			 window->is_maximized,
+			 NULL);
+  mateconf_client_set_bool (window->mateconf_client,
+		  	 GDICT_MATECONF_SIDEBAR_VISIBLE_KEY,
+			 window->sidebar_visible,
+			 NULL);
+  mateconf_client_set_int (window->mateconf_client,
+		  	GDICT_MATECONF_SIDEBAR_WIDTH_KEY,
+			window->sidebar_width,
+			NULL);
+  mateconf_client_set_string (window->mateconf_client,
+		  	   GDICT_MATECONF_SIDEBAR_PAGE_KEY,
+			   gdict_sidebar_current_page (GDICT_SIDEBAR (window->sidebar)),
+			   NULL);
+  mateconf_client_set_bool (window->mateconf_client,
+		  	 GDICT_MATECONF_STATUSBAR_VISIBLE_KEY,
+			 window->statusbar_visible,
+			 NULL);
+
+  new_window = gdict_window_new (GDICT_WINDOW_ACTION_LOOKUP,
+                                 window->loader,
+                                 NULL, link_text);
+  gtk_widget_show (new_window);
+  
+  g_signal_emit (window, gdict_window_signals[CREATED], 0, new_window);
+}
+
+static void
+gdict_window_drag_data_received_cb (GtkWidget        *widget,
+				    GdkDragContext   *context,
+				    gint              x,
+				    gint              y,
+				    GtkSelectionData *data,
+				    guint             info,
+				    guint             time_,
+				    gpointer          user_data)
+{
+  GdictWindow *window = GDICT_WINDOW (user_data);
+  gchar *text;
+  
+  text = (gchar *) gtk_selection_data_get_text (data);
+  if (text)
+    {
+      gtk_entry_set_text (GTK_ENTRY (window->entry), text);
+
+      gdict_window_set_word (window, text, NULL);
+      g_free (text);
+      
+      gtk_drag_finish (context, TRUE, FALSE, time_);
+    }
+  else
+    gtk_drag_finish (context, FALSE, FALSE, time_);
+}
+
+static void
+gdict_window_size_allocate (GtkWidget     *widget,
+			    GtkAllocation *allocation)
+{
+  GdictWindow *window = GDICT_WINDOW (widget);
+
+  if (!window->is_maximized)
+    {
+      window->default_width = allocation->width;
+      window->default_height = allocation->height;
+    }
+
+  if (GTK_WIDGET_CLASS (gdict_window_parent_class)->size_allocate)
+    GTK_WIDGET_CLASS (gdict_window_parent_class)->size_allocate (widget,
+		    						 allocation);
+}
+
+static void
+set_window_default_size (GdictWindow *window)
+{
+  GtkWidget *widget;
+  gboolean is_maximized;
+  gint width, height;
+  gint font_size;
+  GdkScreen *screen;
+  gint monitor_num;
+  GtkRequisition req;
+  GdkRectangle monitor;
+
+  g_assert (GDICT_IS_WINDOW (window));
+
+  widget = GTK_WIDGET (window);
+
+  /* make sure that the widget is realized */
+  gtk_widget_realize (widget);
+  
+  /* recover the state from MateConf */
+  width = mateconf_client_get_int (window->mateconf_client,
+		  		GDICT_MATECONF_WINDOW_WIDTH_KEY,
+				NULL);
+  height = mateconf_client_get_int (window->mateconf_client,
+		  		 GDICT_MATECONF_WINDOW_HEIGHT_KEY,
+				 NULL);
+  is_maximized = mateconf_client_get_bool (window->mateconf_client,
+		  			GDICT_MATECONF_WINDOW_IS_MAXIMIZED_KEY,
+					NULL);
+  
+  /* XXX - the user wants mate-dictionary to resize itself, so
+   * we compute the minimum safe geometry needed for displaying
+   * the text returned by a dictionary server, which is based
+   * on the font size and the ANSI terminal.  this is dumb,
+   * I know, but dictionary servers return pre-formatted text
+   * and we can't reformat it ourselves.
+   */
+  if (width == -1 || height == -1)
+    {
+      /* Size based on the font size */
+      GtkWidget *defbox = window->defbox;
+      
+      font_size = pango_font_description_get_size (gtk_widget_get_style (defbox)->font_desc);
+      font_size = PANGO_PIXELS (font_size);
+
+      width = font_size * GDICT_WINDOW_COLUMNS;
+      height = font_size * GDICT_WINDOW_ROWS;
+
+      /* Use at least the requisition size of the window... */
+      gtk_widget_size_request (widget, &req);
+      width = MAX (width, req.width);
+      height = MAX (height, req.height);
+
+      /* ... but make it no larger than the monitor */
+      screen = gtk_widget_get_screen (widget);
+      monitor_num = gdk_screen_get_monitor_at_window (screen, gtk_widget_get_window (widget));
+
+      gdk_screen_get_monitor_geometry (screen, monitor_num, &monitor);
+      width = MIN (width, monitor.width * 3 / 4);
+      height = MIN (height, monitor.height * 3 / 4);
+    }
+
+  /* Set default size */
+  gtk_window_set_default_size (GTK_WINDOW (widget),
+  			       width,
+  			       height);
+
+  if (is_maximized)
+    gtk_window_maximize (GTK_WINDOW (widget));
+}
+
+static void
+gdict_window_style_set (GtkWidget *widget,
+			GtkStyle  *old_style)
+{
+
+  if (GTK_WIDGET_CLASS (gdict_window_parent_class)->style_set)
+    GTK_WIDGET_CLASS (gdict_window_parent_class)->style_set (widget, old_style);
+
+  set_window_default_size (GDICT_WINDOW (widget));
+}
+
+static void
+gdict_window_handle_notify_position_cb (GtkWidget  *widget,
+					GParamSpec *pspec,
+					gpointer    user_data)
+{
+  GdictWindow *window = GDICT_WINDOW (user_data);
+  gint window_width, pos;
+  GtkAllocation allocation;
+
+  pos = gtk_paned_get_position (GTK_PANED (widget));
+  gtk_widget_get_allocation (GTK_WIDGET (window), &allocation);
+  window_width = allocation.width;
+
+  window->sidebar_width = window_width - pos;
+}
+
+static GObject *
+gdict_window_constructor (GType                  type,
+			  guint                  n_construct_properties,
+			  GObjectConstructParam *construct_params)
+{
+  GObject *object;
+  GdictWindow *window;
+  gint width, height, sidebar_width;
+  gboolean is_maximized;
+  GtkWidget *hbox;
+  GtkWidget *handle;
+  GtkWidget *frame1, *frame2;
+  GtkWidget *vbox;
+  GtkWidget *button;
+  GtkActionGroup *action_group;
+  GtkAccelGroup *accel_group;
+  PangoFontDescription *font_desc;
+  gchar *font_name, *sidebar_page;
+  GError *error;
+  gboolean sidebar_visible;
+  gboolean statusbar_visible;
+  GtkAllocation allocation;
+  
+  object = G_OBJECT_CLASS (gdict_window_parent_class)->constructor (type,
+  						   n_construct_properties,
+  						   construct_params);
+  window = GDICT_WINDOW (object);
+  
+  gtk_widget_push_composite_child ();
+ 
+  window->main_box = gtk_vbox_new (FALSE, 0);
+  gtk_container_add (GTK_CONTAINER (window), window->main_box);
+  gtk_widget_show (window->main_box);
+  
+  /* build menus */
+  action_group = gtk_action_group_new ("MenuActions");
+  window->action_group = action_group;
+  gtk_action_group_set_translation_domain (action_group, NULL);
+  gtk_action_group_add_actions (action_group, entries,
+  				G_N_ELEMENTS (entries),
+  				window);
+  gtk_action_group_add_toggle_actions (action_group, toggle_entries,
+                                       G_N_ELEMENTS (toggle_entries),
+                                       window);
+  
+  window->ui_manager = gtk_ui_manager_new ();
+  gtk_ui_manager_insert_action_group (window->ui_manager, action_group, 0);
+  
+  accel_group = gtk_ui_manager_get_accel_group (window->ui_manager);
+  gtk_window_add_accel_group (GTK_WINDOW (window), accel_group);
+  
+  error = NULL;
+  if (!gtk_ui_manager_add_ui_from_file (window->ui_manager,
+  					PKGDATADIR "/mate-dictionary-ui.xml",
+  					&error))
+    {
+      g_warning ("Building menus failed: %s", error->message);
+      g_error_free (error);
+    }
+  else
+    {
+      window->menubar = gtk_ui_manager_get_widget (window->ui_manager, "/MainMenu");
+      
+      gtk_box_pack_start (GTK_BOX (window->main_box), window->menubar, FALSE, FALSE, 0);
+      gtk_widget_show (window->menubar);
+
+      gdict_window_ensure_menu_state (window);
+    }
+  
+  vbox = gtk_vbox_new (FALSE, 6);
+  gtk_container_set_border_width (GTK_CONTAINER (vbox), 6);
+  gtk_container_add (GTK_CONTAINER (window->main_box), vbox);
+  gtk_widget_show (vbox);
+  
+  hbox = gtk_hbox_new (FALSE, 12);
+  gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
+  gtk_widget_show (hbox);
+  
+  button = gtk_button_new_with_mnemonic (_("Look _up:"));
+  g_signal_connect_swapped (button, "clicked",
+                            G_CALLBACK (lookup_word),
+                            window);
+  gtk_button_set_relief (GTK_BUTTON (button), GTK_RELIEF_NONE);
+  gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
+  gtk_widget_show (button);
+
+  window->completion_model = gtk_list_store_new (COMPLETION_N_COLUMNS,
+		  				 G_TYPE_STRING);
+  
+  window->completion = gtk_entry_completion_new ();
+  gtk_entry_completion_set_popup_completion (window->completion, TRUE);
+  gtk_entry_completion_set_model (window->completion,
+		  		  GTK_TREE_MODEL (window->completion_model));
+  gtk_entry_completion_set_text_column (window->completion,
+		  			COMPLETION_TEXT_COLUMN);
+  
+  window->entry = gtk_entry_new ();
+  if (window->word)
+    gtk_entry_set_text (GTK_ENTRY (window->entry), window->word);
+  
+  gtk_entry_set_completion (GTK_ENTRY (window->entry),
+		  	    window->completion);
+  g_signal_connect_swapped (window->entry, "activate",
+                            G_CALLBACK (lookup_word),
+                            window);
+  gtk_box_pack_start (GTK_BOX (hbox), window->entry, TRUE, TRUE, 0);
+  gtk_widget_show (window->entry);
+
+  handle = gtk_hpaned_new ();
+  gtk_box_pack_start (GTK_BOX (vbox), handle, TRUE, TRUE, 0);
+  gtk_widget_show (handle);
+
+  frame1 = gtk_vbox_new (FALSE, 0);
+  frame2 = gtk_vbox_new (FALSE, 0);
+  
+  window->defbox = gdict_defbox_new ();
+  if (window->context)
+    gdict_defbox_set_context (GDICT_DEFBOX (window->defbox), window->context);
+
+  g_signal_connect (window->defbox, "link-clicked",
+                    G_CALLBACK (gdict_window_link_clicked),
+                    window);
+
+  gtk_drag_dest_set (window->defbox,
+  		     GTK_DEST_DEFAULT_ALL,
+  		     drop_types, n_drop_types,
+  		     GDK_ACTION_COPY);
+  g_signal_connect (window->defbox, "drag-data-received",
+  		    G_CALLBACK (gdict_window_drag_data_received_cb),
+  		    window);
+  gtk_container_add (GTK_CONTAINER (frame1), window->defbox);
+  gtk_widget_show (window->defbox);
+
+  /* Sidebar */
+  window->sidebar = gdict_sidebar_new ();
+  g_signal_connect (window->sidebar, "page-changed",
+		    G_CALLBACK (sidebar_page_changed_cb),
+		    window);
+  g_signal_connect (window->sidebar, "closed",
+		    G_CALLBACK (sidebar_closed_cb),
+		    window);
+  
+  /* Speller */
+  window->speller = gdict_speller_new ();
+  if (window->context)
+    gdict_speller_set_context (GDICT_SPELLER (window->speller),
+		    	       window->context);
+  g_signal_connect (window->speller, "word-activated",
+		    G_CALLBACK (speller_word_activated_cb),
+		    window);
+  gdict_sidebar_add_page (GDICT_SIDEBAR (window->sidebar),
+		          GDICT_SIDEBAR_SPELLER_PAGE,
+			  _("Similar words"),
+			  window->speller);
+  gtk_widget_show (window->speller);
+
+  /* Database chooser */
+  if (window->context)
+    gdict_database_chooser_set_context (GDICT_DATABASE_CHOOSER (window->db_chooser),
+			    		window->context);
+  g_signal_connect (window->db_chooser, "database-activated",
+	  	    G_CALLBACK (database_activated_cb),
+		    window);
+  gdict_sidebar_add_page (GDICT_SIDEBAR (window->sidebar),
+	  		  GDICT_SIDEBAR_DATABASES_PAGE,
+			  _("Available dictionaries"),
+			  window->db_chooser);
+  gtk_widget_show (window->db_chooser);
+
+  /* Strategy chooser */
+  if (window->context)
+    gdict_strategy_chooser_set_context (GDICT_STRATEGY_CHOOSER (window->strat_chooser),
+                                        window->context);
+  g_signal_connect (window->strat_chooser, "strategy-activated",
+                    G_CALLBACK (strategy_activated_cb),
+                    window);
+  gdict_sidebar_add_page (GDICT_SIDEBAR (window->sidebar),
+                          GDICT_SIDEBAR_STRATEGIES_PAGE,
+                          _("Available strategies"),
+                          window->strat_chooser);
+  gtk_widget_show (window->strat_chooser);
+
+  /* Source chooser */
+  window->source_chooser = gdict_source_chooser_new_with_loader (window->loader);
+  g_signal_connect (window->source_chooser, "source-activated",
+                    G_CALLBACK (source_activated_cb),
+                    window);
+  gdict_sidebar_add_page (GDICT_SIDEBAR (window->sidebar),
+                          GDICT_SIDEBAR_SOURCES_PAGE,
+                          _("Dictionary sources"),
+                          window->source_chooser);
+  gtk_widget_show (window->source_chooser);
+
+  gtk_container_add (GTK_CONTAINER (frame2), window->sidebar);
+  gtk_widget_show (window->sidebar);
+
+  gtk_paned_pack1 (GTK_PANED (handle), frame1, TRUE, FALSE);
+  gtk_paned_pack2 (GTK_PANED (handle), frame2, FALSE, TRUE);
+
+  window->defbox_frame = frame1;
+  window->sidebar_frame = frame2;
+
+  gtk_widget_show (window->defbox_frame);
+
+  window->status = gtk_statusbar_new ();
+  gtk_statusbar_set_has_resize_grip (GTK_STATUSBAR (window->status), TRUE);
+  gtk_box_pack_end (GTK_BOX (window->main_box), window->status, FALSE, FALSE, 0);
+  statusbar_visible = mateconf_client_get_bool (window->mateconf_client,
+		  			     GDICT_MATECONF_STATUSBAR_VISIBLE_KEY,
+					     NULL);
+  gdict_window_set_statusbar_visible (window, statusbar_visible);
+
+  window->progress = gtk_progress_bar_new ();
+  gtk_box_pack_end (GTK_BOX (window->status), window->progress, FALSE, FALSE, 0);
+
+  /* retrieve the font size from mateconf */
+  font_name = gdict_mateconf_get_string_with_default (window->mateconf_client,
+						   DOCUMENT_FONT_KEY,
+						   GDICT_DEFAULT_DEFBOX_FONT);
+
+  gdict_window_set_defbox_font (window, font_name);
+  font_desc = pango_font_description_from_string (font_name);
+  g_free (font_name);
+
+  sidebar_visible = mateconf_client_get_bool (window->mateconf_client,
+		  			   GDICT_MATECONF_SIDEBAR_VISIBLE_KEY,
+					   NULL);
+  gdict_window_set_sidebar_visible (window, sidebar_visible);
+
+  /* retrieve the window state from mateconf */
+  is_maximized = mateconf_client_get_bool (window->mateconf_client,
+		  			GDICT_MATECONF_WINDOW_IS_MAXIMIZED_KEY,
+					NULL);
+
+  width = mateconf_client_get_int (window->mateconf_client,
+		  		GDICT_MATECONF_WINDOW_WIDTH_KEY,
+				NULL);
+  height = mateconf_client_get_int (window->mateconf_client,
+		  		 GDICT_MATECONF_WINDOW_HEIGHT_KEY,
+				 NULL);
+  sidebar_width = mateconf_client_get_int (window->mateconf_client,
+		  			GDICT_MATECONF_SIDEBAR_WIDTH_KEY,
+					NULL);
+  sidebar_page = mateconf_client_get_string (window->mateconf_client,
+		  			  GDICT_MATECONF_SIDEBAR_PAGE_KEY,
+					  NULL);
+
+  /* if the (width, height) tuple is not defined, use the font to
+   * calculate the right window geometry
+   */
+  if (width == -1 || height == -1)
+    {
+      gint font_size;
+  
+      font_size = pango_font_description_get_size (font_desc);
+      font_size = PANGO_PIXELS (font_size);
+
+      width = MAX (GDICT_WINDOW_COLUMNS * font_size, GDICT_WINDOW_MIN_WIDTH);
+      height = MAX (GDICT_WINDOW_ROWS * font_size, GDICT_WINDOW_MIN_HEIGHT);
+    }
+  else
+    {
+      window->default_width = width;
+      window->default_height = height;
+    }
+
+  pango_font_description_free (font_desc);
+  
+  window->is_maximized = is_maximized;
+  
+  gtk_window_set_title (GTK_WINDOW (window), _("Dictionary"));
+  gtk_window_set_default_size (GTK_WINDOW (window),
+  			       width,
+  			       height);
+  if (is_maximized)
+    gtk_window_maximize (GTK_WINDOW (window));
+
+  gtk_widget_get_allocation (GTK_WIDGET (window), &allocation);
+  gtk_paned_set_position (GTK_PANED (handle), allocation.width - sidebar_width);
+  if (sidebar_page)
+    {
+      gdict_sidebar_view_page (GDICT_SIDEBAR (window->sidebar), sidebar_page);
+      g_free (sidebar_page);
+    }
+
+  g_signal_connect (window, "delete-event",
+		    G_CALLBACK (gdict_window_delete_event_cb),
+		    NULL);
+  g_signal_connect (window, "window-state-event",
+		    G_CALLBACK (gdict_window_state_event_cb),
+		    NULL);
+  g_signal_connect (handle, "notify::position",
+		    G_CALLBACK (gdict_window_handle_notify_position_cb),
+		    window);
+
+  gtk_widget_grab_focus (window->entry);
+
+  gtk_widget_pop_composite_child ();
+  
+  return object;
+}
+
+static void
+gdict_window_class_init (GdictWindowClass *klass)
+{
+  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+  GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
+
+  gobject_class->finalize = gdict_window_finalize;
+  gobject_class->dispose = gdict_window_dispose;
+  gobject_class->set_property = gdict_window_set_property;
+  gobject_class->get_property = gdict_window_get_property;
+  gobject_class->constructor = gdict_window_constructor;
+
+  widget_class->style_set = gdict_window_style_set;
+  widget_class->size_allocate = gdict_window_size_allocate;
+  
+  g_object_class_install_property (gobject_class,
+  				   PROP_ACTION,
+				   g_param_spec_enum ("action",
+				   		      "Action",
+						      "The default action performed by the window",
+						      GDICT_TYPE_WINDOW_ACTION,
+						      GDICT_WINDOW_ACTION_CLEAR,
+						      (G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY)));
+  g_object_class_install_property (gobject_class,
+  				   PROP_SOURCE_LOADER,
+  				   g_param_spec_object ("source-loader",
+  							"Source Loader",
+  							"The GdictSourceLoader to be used to load dictionary sources",
+  							GDICT_TYPE_SOURCE_LOADER,
+  							(G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY)));
+  g_object_class_install_property (gobject_class,
+		  		   PROP_SOURCE_NAME,
+				   g_param_spec_string ("source-name",
+					   		"Source Name",
+							"The name of the GdictSource to be used",
+							GDICT_DEFAULT_SOURCE_NAME,
+							(G_PARAM_READABLE | G_PARAM_WRITABLE)));
+  g_object_class_install_property (gobject_class,
+  				   PROP_PRINT_FONT,
+  				   g_param_spec_string ("print-font",
+  				   			"Print Font",
+  				   			"The font name to be used when printing",
+  				   			GDICT_DEFAULT_PRINT_FONT,
+  				   			(G_PARAM_READABLE | G_PARAM_WRITABLE)));
+  g_object_class_install_property (gobject_class,
+		  		   PROP_DEFBOX_FONT,
+				   g_param_spec_string ("defbox-font",
+					   		"Defbox Font",
+							"The font name to be used by the defbox widget",
+							GDICT_DEFAULT_DEFBOX_FONT,
+							(G_PARAM_READABLE | G_PARAM_WRITABLE)));
+  g_object_class_install_property (gobject_class,
+		  		   PROP_WORD,
+				   g_param_spec_string ("word",
+					   		"Word",
+							"The word to search",
+							NULL,
+							(G_PARAM_READABLE | G_PARAM_WRITABLE)));
+  g_object_class_install_property (gobject_class,
+  				   PROP_WINDOW_ID,
+  				   g_param_spec_uint ("window-id",
+  				   		      "Window ID",
+  				   		      "The unique identifier for this window",
+  				   		      0,
+  				   		      G_MAXUINT,
+  				   		      0,
+  				   		      G_PARAM_READABLE));
+
+  gdict_window_signals[CREATED] =
+    g_signal_new ("created",
+                  G_OBJECT_CLASS_TYPE (gobject_class),
+                  G_SIGNAL_RUN_LAST,
+                  G_STRUCT_OFFSET (GdictWindowClass, created),
+                  NULL, NULL,
+                  g_cclosure_marshal_VOID__OBJECT,
+                  G_TYPE_NONE, 1,
+                  GDICT_TYPE_WINDOW);
+}
+
+static void
+gdict_window_init (GdictWindow *window)
+{
+  GError *mateconf_error;
+
+  window->action = GDICT_WINDOW_ACTION_CLEAR;
+  
+  window->loader = NULL;
+  window->context = NULL;
+
+  window->mateconf_client = mateconf_client_get_default ();
+
+  mateconf_error = NULL;
+  mateconf_client_add_dir (window->mateconf_client,
+  			GDICT_MATECONF_DIR,
+  			MATECONF_CLIENT_PRELOAD_NONE,
+  			&mateconf_error);
+  if (mateconf_error)
+    {
+      gdict_show_gerror_dialog (NULL,
+		                _("Unable to connect to MateConf"),
+		                mateconf_error);
+    }
+
+  window->notify_id = mateconf_client_notify_add (window->mateconf_client,
+  					       GDICT_MATECONF_DIR,
+  					       gdict_window_mateconf_notify_cb,
+  					       window,
+  					       NULL,
+  					       &mateconf_error);
+  if (mateconf_error)
+    {
+      gdict_show_gerror_dialog (NULL,
+		                _("Unable to get notification for preferences"),
+		                mateconf_error);
+    }
+
+  window->font_notify_id = mateconf_client_notify_add (window->mateconf_client,
+		  				    DOCUMENT_FONT_KEY,
+						    gdict_window_mateconf_notify_cb,
+						    window,
+						    NULL,
+						    &mateconf_error);
+  if (mateconf_error)
+    {
+      gdict_show_gerror_dialog (NULL,
+		                _("Unable to get notification for the document font"),
+		                mateconf_error);
+    }
+  
+  window->word = NULL;
+  window->source_name = NULL;
+  window->print_font = NULL;
+  window->defbox_font = NULL;
+
+  window->database = NULL;
+  window->strategy = NULL;
+
+  window->default_width = -1;
+  window->default_height = -1;
+  window->is_maximized = FALSE;
+  
+  window->window_id = (gulong) time (NULL);
+
+  /* we need to create the chooser widgets for the sidebar before
+   * we set the construction properties
+   */
+  window->db_chooser = gdict_database_chooser_new ();
+  window->strat_chooser = gdict_strategy_chooser_new ();
+}
+
+GtkWidget *
+gdict_window_new (GdictWindowAction  action,
+		  GdictSourceLoader *loader,
+		  const gchar       *source_name,
+		  const gchar       *word)
+{
+  GtkWidget *retval;
+  GdictWindow *window;
+  
+  g_return_val_if_fail (GDICT_IS_SOURCE_LOADER (loader), NULL);
+  
+  retval = g_object_new (GDICT_TYPE_WINDOW,
+  			 "action", action,
+                         "source-loader", loader,
+			 "source-name", source_name,
+			 NULL);
+
+  window = GDICT_WINDOW (retval);
+
+  if (word && word[0] != '\0')
+    {
+      switch (action)
+        {
+	case GDICT_WINDOW_ACTION_LOOKUP:
+	  gtk_entry_set_text (GTK_ENTRY (window->entry), word);
+	  gdict_window_set_word (window, word, NULL);
+	  break;
+	case GDICT_WINDOW_ACTION_MATCH:
+          {
+          GdictSource *source;
+          GdictContext *context;
+
+	  gtk_entry_set_text (GTK_ENTRY (window->entry), word);
+          
+          gdict_window_set_sidebar_visible (window, TRUE);
+          gdict_sidebar_view_page (GDICT_SIDEBAR (window->sidebar),
+                                   GDICT_SIDEBAR_SPELLER_PAGE);
+
+          /* we clone the context, so that the signals that it
+           * fires do not get caught by the signal handlers we
+           * use for getting the definitions.
+           */
+          source = gdict_source_loader_get_source (window->loader,
+                                                   window->source_name);
+          context = gdict_source_get_context (source);
+
+          gdict_speller_set_context (GDICT_SPELLER (window->speller), context);
+          
+          g_object_unref (context);
+          g_object_unref (source);
+      
+          gdict_speller_set_strategy (GDICT_SPELLER (window->speller),
+                                      window->strategy);
+      
+          gdict_speller_match (GDICT_SPELLER (window->speller), word);
+          }
+	case GDICT_WINDOW_ACTION_CLEAR:
+          gdict_defbox_clear (GDICT_DEFBOX (window->defbox));
+	  break;
+	default:
+	  g_assert_not_reached ();
+	  break;
+	}
+    }
+
+  return retval;
+}
+
+/* GdictWindowAction */
+static const GEnumValue _gdict_window_action_values[] = {
+  { GDICT_WINDOW_ACTION_LOOKUP, "GDICT_WINDOW_ACTION_LOOKUP", "lookup" },
+  { GDICT_WINDOW_ACTION_MATCH, "GDICT_WINDOW_ACTION_MATCH", "match" },
+  { GDICT_WINDOW_ACTION_CLEAR, "GDICT_WINDOW_ACTION_CLEAR", "clear" },
+  { 0, NULL, NULL }
+};
+
+GType
+gdict_window_action_get_type (void)
+{
+  static GType our_type = 0;
+
+  if (!our_type)
+    our_type = g_enum_register_static ("GdictWindowAction", _gdict_window_action_values);
+
+  return our_type;
+}
diff --git a/mate-dictionary/src/gdict-window.h b/mate-dictionary/src/gdict-window.h
new file mode 100644
index 00000000..36455cba
--- /dev/null
+++ b/mate-dictionary/src/gdict-window.h
@@ -0,0 +1,129 @@
+/* gdict-window.h - main application window
+ *
+ * This file is part of MATE Dictionary
+ *
+ * Copyright (C) 2005 Emmanuele Bassi
+ *
+ * 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.
+ */
+
+#ifndef __GDICT_WINDOW_H__
+#define __GDICT_WINDOW_H__
+
+#include <gdk-pixbuf/gdk-pixbuf.h>
+#include <gtk/gtk.h>
+#include <mateconf/mateconf-client.h>
+#include <libgdict/gdict.h>
+
+G_BEGIN_DECLS
+
+#define GDICT_TYPE_WINDOW	(gdict_window_get_type ())
+#define GDICT_WINDOW(obj)	(G_TYPE_CHECK_INSTANCE_CAST ((obj), GDICT_TYPE_WINDOW, GdictWindow))
+#define GDICT_IS_WINDOW(obj)	(G_TYPE_CHECK_INSTANCE_TYPE ((obj), GDICT_TYPE_WINDOW))
+
+typedef enum {
+  GDICT_WINDOW_ACTION_LOOKUP,
+  GDICT_WINDOW_ACTION_MATCH,
+  GDICT_WINDOW_ACTION_CLEAR
+} GdictWindowAction;
+
+#define GDICT_TYPE_WINDOW_ACTION	(gdict_window_action_get_type ())
+GType gdict_window_action_get_type (void) G_GNUC_CONST;
+
+typedef struct _GdictWindow      GdictWindow;
+typedef struct _GdictWindowClass GdictWindowClass;
+
+struct _GdictWindow
+{
+  GtkWindow parent_instance;
+  
+  GtkWidget *main_box;
+  GtkWidget *menubar;
+  GtkWidget *entry;
+  
+  /* sidebar widgets */
+  GtkWidget *speller;
+  GtkWidget *db_chooser;
+  GtkWidget *strat_chooser;
+  GtkWidget *source_chooser;
+
+  GtkWidget *sidebar;
+  GtkWidget *sidebar_frame;
+  
+  GtkWidget *defbox;
+  GtkWidget *defbox_frame;
+
+  GtkWidget *status;
+  GtkWidget *progress;
+  
+  GtkUIManager *ui_manager;
+  GtkActionGroup *action_group;
+ 
+  GtkEntryCompletion *completion;
+  GtkListStore *completion_model;
+  
+  GdictWindowAction action;
+  
+  gchar *word;
+  gint max_definition;
+  gint last_definition;
+  gint current_definition;
+ 
+  gchar *source_name;
+  GdictSourceLoader *loader;
+  GdictContext *context;
+  guint definition_id;
+  guint lookup_start_id;
+  guint lookup_end_id;
+  guint error_id;
+  
+  gchar *database;
+  gchar *strategy;
+  gchar *print_font;
+  gchar *defbox_font;
+  
+  MateConfClient *mateconf_client;
+  guint notify_id;
+  guint font_notify_id;
+
+  GdkCursor *busy_cursor;
+
+  gint default_width;
+  gint default_height;
+  gint sidebar_width;
+  
+  guint is_maximized      : 1;
+  guint sidebar_visible   : 1;
+  guint statusbar_visible : 1;
+  
+  gulong window_id;
+};
+
+struct _GdictWindowClass
+{
+  GtkWindowClass parent_class;
+  
+  void (*created) (GdictWindow *parent_window,
+  		   GdictWindow *new_window);
+};
+
+GType      gdict_window_get_type (void) G_GNUC_CONST;
+GtkWidget *gdict_window_new      (GdictWindowAction  action,
+				  GdictSourceLoader *loader,
+				  const gchar       *source_name,
+				  const gchar       *word);
+
+#endif /* __GDICT_WINDOW_H__ */
diff --git a/mate-dictionary/src/main.c b/mate-dictionary/src/main.c
new file mode 100644
index 00000000..f6dcc94d
--- /dev/null
+++ b/mate-dictionary/src/main.c
@@ -0,0 +1,24 @@
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <libintl.h>
+
+#include "gdict-app.h"
+
+int main (int argc, char *argv[])
+{
+        bindtextdomain (GETTEXT_PACKAGE, MATELOCALEDIR);
+        bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
+        textdomain (GETTEXT_PACKAGE);
+
+	gdict_init (&argc, &argv);
+	
+	gdict_main ();
+
+	gdict_cleanup ();
+	
+	return EXIT_SUCCESS;
+}