Moved from Mate-Extra repository

author: Stefano Karapetsas <[email protected]> 2011-12-14 10:13:54 +0100
committer: Stefano Karapetsas <[email protected]> 2011-12-14 10:13:54 +0100
commit: ef0467789bfc8406b57ba553e4d59f4d6c3f9be8 (patch)
tree: 09d541636a16cb38448fe6183289ebdc3080c1bf /mate-dictionary/libgdict
download: mate-utils-ef0467789bfc8406b57ba553e4d59f4d6c3f9be8.tar.bz2
mate-utils-ef0467789bfc8406b57ba553e4d59f4d6c3f9be8.tar.xz
30 files changed, 13681 insertions, 0 deletions
diff --git a/mate-dictionary/libgdict/Makefile.am b/mate-dictionary/libgdict/Makefile.am
new file mode 100644
index 00000000..006b42f4
--- /dev/null
+++ b/mate-dictionary/libgdict/Makefile.am
@@ -0,0 +1,134 @@
+NULL =
+
+INCLUDES = -DG_LOG_DOMAIN=\"Gdict\" \
+ -DDATADIR=\""$(datadir)"\" \
+ -DLIBDIR=\""$(libdir)"\" \
+ -DSYSCONFDIR=\""$(sysconfdir)"\" \
+ -DPREFIX=\""$(prefix)"\" \
+ -DMATELOCALEDIR=\""$(mateutilslocaledir)"\" \
+ -DGDICTSOURCESDIR=\""$(datadir)/mate-dict/sources"\" \
+ -DGDICT_ENABLE_INTERNALS=1 \
+ -DG_DISABLE_DEPRECATED \
+ -DGDK_DISABLE_DEPRECATED \
+ -DGTK_DISABLE_DEPRECATED \
+ -DPANGO_DISABLE_DEPRECATED \
+ -DG_DISABLE_SINGLE_INCLUDES \
+ -DGTK_DISABLE_SINGLE_INCLUDES \
+ $(NULL)
+
+sources_h = \
+ $(srcdir)/gdict-context.h \
+ $(srcdir)/gdict-client-context.h \
+ $(srcdir)/gdict-database-chooser.h \
+ $(srcdir)/gdict-defbox.h \
+ $(srcdir)/gdict-source-chooser.h \
+ $(srcdir)/gdict-source-loader.h \
+ $(srcdir)/gdict-source.h \
+ $(srcdir)/gdict-speller.h \
+ $(srcdir)/gdict-strategy-chooser.h \
+ $(srcdir)/gdict-utils.h \
+ $(NULL)
+
+sources_h_priv = \
+ $(srcdir)/gdict-context-private.h \
+ $(srcdir)/gdict-debug.h \
+ $(srcdir)/gdict-private.h \
+ $(NULL)
+
+sources_c = \
+ $(srcdir)/gdict-context.c \
+ $(srcdir)/gdict-client-context.c \
+ $(srcdir)/gdict-database-chooser.c \
+ $(srcdir)/gdict-defbox.c \
+ gdict-enum-types.c \
+ gdict-marshal.c \
+ $(srcdir)/gdict-source-chooser.c \
+ $(srcdir)/gdict-source-loader.c \
+ $(srcdir)/gdict-source.c \
+ $(srcdir)/gdict-speller.c \
+ $(srcdir)/gdict-strategy-chooser.c \
+ $(srcdir)/gdict-utils.c \
+ $(NULL)
+
+lib_LTLIBRARIES = libmatedict.la
+
+# MATE Dictionary shared library
+libmatedict_la_SOURCES = $(sources_h) $(sources_h_priv) $(sources_c)
+libmatedict_la_CPPFLAGS = $(LIBGDICT_CFLAGS) $(GDICT_DEBUG_CFLAGS) $(MAINTAINER_CFLAGS)
+libmatedict_la_LIBADD = $(LIBGDICT_LIBS)
+libmatedict_la_LDFLAGS = \
+ -version-info $(LIBGDICT_LT_VERSION) \
+ -export-dynamic \
+ -no-undefined
+
+libgdict_includedir = $(includedir)/mate-dict/gdict
+libgdict_include_HEADERS = \
+ $(sources_h) \
+ gdict-enum-types.h \
+ gdict-version.h \
+ $(srcdir)/gdict.h \
+ $(NULL)
+
+gdict_built_files = \
+ gdict-enum-types.h \
+ gdict-enum-types.c \
+ gdict-marshal.h \
+ gdict-marshal.c
+
+stamp_files = stamp-gdict-enum-types.h stamp-gdict-marshal.h
+
+CLEANFILES = $(stamp_files) $(gdict_built_files)
+DISTCLEANFILES = gdict-version.h
+MAINTAINERCLEANFILES = $(stamp_files) $(gdict_built_files) gdict-version.h
+
+EXTRA_DIST = \
+ gdict-version.h.in \
+ gdict-enum-types.h.in \
+ gdict-enum-types.c.in \
+ gdict-marshal.list \
+ mate-dict.pc.in \
+ $(NULL)
+
+BUILT_SOURCES = $(gdict_built_files)
+
+gdict-marshal.h: stamp-gdict-marshal.h
+ @true
+stamp-gdict-marshal.h: gdict-marshal.list $(GLIB_GENMARSHAL) Makefile
+ $(AM_V_GEN)$(GLIB_GENMARSHAL) $< --header --prefix=gdict_marshal > xgen-gmh \
+ && ( cmp -s xgen-gmh gdict-marshal.h || cp xgen-gmh gdict-marshal.h ) \
+ && rm -f xgen-gmh \
+ && echo timestamp > $(@F)
+
+gdict-marshal.c: gdict-marshal.list $(GLIB_GENMARSHAL) Makefile
+ $(AM_V_GEN)( echo "#include \"gdict-marshal.h\""; echo; \
+ $(GLIB_GENMARSHAL) $< --body --prefix=gdict_marshal ) > xgen-gmc \
+ && cp xgen-gmc gdict-marshal.c \
+ && rm -f xgen-gmc
+
+gdict-enum-types.h: stamp-gdict-enum-types.h
+ @true
+stamp-gdict-enum-types.h: $(sources_h) gdict-enum-types.h.in Makefile
+ $(AM_V_GEN)( cd $(srcdir) && \
+ $(GLIB_MKENUMS) \
+ --template $(srcdir)/gdict-enum-types.h.in \
+ $(sources_h) ) > xgen-ceth \
+ && ( cmp -s xgen-ceth gdict-enum-types.h || cp xgen-ceth gdict-enum-types.h ) \
+ && rm -f xgen-ceth \
+ && echo timestamp > $(@F)
+
+gdict-enum-types.c: gdict-enum-types.h gdict-enum-types.c.in Makefile
+ $(AM_V_GEN)( cd $(srcdir) && \
+ $(GLIB_MKENUMS) \
+ --template $(srcdir)/gdict-enum-types.c.in \
+ $(sources_h) ) > xgen-cetc \
+ && cp xgen-cetc gdict-enum-types.c \
+ && rm -f xgen-cetc
+
+pkgconfigdir = $(libdir)/pkgconfig
+pkgconfig_DATA = mate-dict.pc
+
+distclean-local:
+ if test $(srcdir) != .; then \
+ rm -f $(MAINTAINERCLEANFILES); \
+ fi
+
diff --git a/mate-dictionary/libgdict/gdict-client-context.c b/mate-dictionary/libgdict/gdict-client-context.c
new file mode 100644
index 00000000..5e370f0a
--- /dev/null
+++ b/mate-dictionary/libgdict/gdict-client-context.c
@@ -0,0 +1,2162 @@
+/* gdict-client-context.c -
+ *
+ * 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 library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ */
+
+/**
+ * SECTION:gdict-client-context
+ * @short_description: DICT client transport
+ *
+ * #GdictClientContext is an implementation of the #GdictContext interface.
+ * It implements the Dictionary Protocol as defined by the RFC 2229 in order
+ * to connect to a dictionary server.
+ *
+ * You should rarely instantiate this object directely: use an appropriate
+ * #GdictSource instead.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <netdb.h>
+#include <fcntl.h>
+#include <errno.h>
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+
+#include <glib.h>
+#include <glib/gi18n-lib.h>
+
+#include "gdict-context-private.h"
+#include "gdict-context.h"
+#include "gdict-client-context.h"
+#include "gdict-enum-types.h"
+#include "gdict-marshal.h"
+#include "gdict-debug.h"
+#include "gdict-utils.h"
+#include "gdict-private.h"
+
+typedef enum {
+ CMD_CLIENT,
+ CMD_SHOW_DB,
+ CMD_SHOW_STRAT,
+ CMD_SHOW_INFO, /* not implemented */
+ CMD_SHOW_SERVER, /* not implemented */
+ CMD_MATCH,
+ CMD_DEFINE,
+ CMD_STATUS, /* not implemented */
+ CMD_OPTION_MIME, /* not implemented */
+ CMD_AUTH, /* not implemented */
+ CMD_HELP, /* not implemented */
+ CMD_QUIT,
+
+ CMD_INVALID
+} GdictCommandType;
+#define IS_VALID_CMD(cmd) (((cmd) >= CMD_CLIENT) || ((cmd) < CMD_INVALID))
+
+/* command strings: keep synced with the enum above! */
+static const gchar *dict_command_strings[] = {
+ "CLIENT",
+ "SHOW DB",
+ "SHOW STRAT",
+ "SHOW INFO",
+ "SHOW SERVER",
+ "MATCH",
+ "DEFINE",
+ "STATUS",
+ "OPTION MIME",
+ "AUTH",
+ "HELP",
+ "QUIT",
+
+ NULL
+};
+
+/* command stata */
+enum
+{
+ S_START,
+
+ S_STATUS,
+ S_DATA,
+
+ S_FINISH
+};
+
+typedef struct
+{
+ GdictCommandType cmd_type;
+
+ gchar *cmd_string;
+ guint state;
+
+ /* optional parameters passed to the command */
+ gchar *database;
+ gchar *strategy;
+ gchar *word;
+
+ /* buffer used to hold the reply from the server */
+ GString *buffer;
+
+ gpointer data;
+ GDestroyNotify data_destroy;
+} GdictCommand;
+
+/* The default string to be passed to the CLIENT command */
+#define GDICT_DEFAULT_CLIENT "MATE Dictionary (" VERSION ")"
+
+/* Default server:port couple */
+#define GDICT_DEFAULT_HOSTNAME "dict.org"
+#define GDICT_DEFAULT_PORT 2628
+
+/* make the hostname lookup expire every five minutes */
+#define HOSTNAME_LOOKUP_EXPIRE 300
+
+/* wait 30 seconds between connection and receiving data on the line */
+#define CONNECTION_TIMEOUT 30
+
+enum
+{
+ PROP_0,
+
+ PROP_HOSTNAME,
+ PROP_PORT,
+ PROP_STATUS,
+ PROP_CLIENT_NAME
+};
+
+enum
+{
+ CONNECTED,
+ DISCONNECTED,
+
+ LAST_SIGNAL
+};
+
+static guint gdict_client_context_signals[LAST_SIGNAL] = { 0 };
+
+#define GDICT_CLIENT_CONTEXT_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GDICT_TYPE_CLIENT_CONTEXT, GdictClientContextPrivate))
+struct _GdictClientContextPrivate
+{
+#ifdef ENABLE_IPV6
+ struct sockaddr_storage sockaddr;
+ struct addrinfo *host6info;
+#else
+ struct sockaddr_in sockaddr;
+#endif
+ struct hostent *hostinfo;
+
+ time_t last_lookup;
+
+ gchar *hostname;
+ gint port;
+
+ GIOChannel *channel;
+ guint source_id;
+ guint timeout_id;
+
+ GdictCommand *command;
+ GQueue *commands_queue;
+
+ gchar *client_name;
+
+ GdictStatusCode status_code;
+
+ guint local_only : 1;
+ guint is_connecting : 1;
+};
+
+static void gdict_client_context_iface_init (GdictContextIface *iface);
+
+G_DEFINE_TYPE_WITH_CODE (GdictClientContext,
+ gdict_client_context,
+ G_TYPE_OBJECT,
+ G_IMPLEMENT_INTERFACE (GDICT_TYPE_CONTEXT,
+ gdict_client_context_iface_init));
+
+/* GObject methods */
+static void gdict_client_context_set_property (GObject *object,
+ guint prop_id,
+ const GValue *value,
+ GParamSpec *pspec);
+static void gdict_client_context_get_property (GObject *object,
+ guint prop_id,
+ GValue *value,
+ GParamSpec *pspec);
+static void gdict_client_context_finalize (GObject *object);
+
+/* GdictContext methods */
+static gboolean gdict_client_context_get_databases (GdictContext *context,
+ GError **error);
+static gboolean gdict_client_context_get_strategies (GdictContext *context,
+ GError **error);
+static gboolean gdict_client_context_define_word (GdictContext *context,
+ const gchar *database,
+ const gchar *word,
+ GError **error);
+static gboolean gdict_client_context_match_word (GdictContext *context,
+ const gchar *database,
+ const gchar *strategy,
+ const gchar *word,
+ GError **error);
+
+static void gdict_client_context_clear_hostinfo (GdictClientContext *context);
+static gboolean gdict_client_context_lookup_server (GdictClientContext *context,
+ GError **error);
+static gboolean gdict_client_context_io_watch_cb (GIOChannel *source,
+ GIOCondition condition,
+ GdictClientContext *context);
+static gboolean gdict_client_context_parse_line (GdictClientContext *context,
+ const gchar *buffer);
+static void gdict_client_context_disconnect (GdictClientContext *context);
+static void gdict_client_context_force_disconnect (GdictClientContext *context);
+static void gdict_client_context_real_connected (GdictClientContext *context);
+static void gdict_client_context_real_disconnected (GdictClientContext *context);
+
+static GdictCommand *gdict_command_new (GdictCommandType cmd_type);
+static void gdict_command_free (GdictCommand *cmd);
+
+
+
+GQuark
+gdict_client_context_error_quark (void)
+{
+ return g_quark_from_static_string ("gdict-client-context-error-quark");
+}
+
+static void
+gdict_client_context_iface_init (GdictContextIface *iface)
+{
+ iface->get_databases = gdict_client_context_get_databases;
+ iface->get_strategies = gdict_client_context_get_strategies;
+ iface->match_word = gdict_client_context_match_word;
+ iface->define_word = gdict_client_context_define_word;
+}
+
+static void
+gdict_client_context_class_init (GdictClientContextClass *klass)
+{
+ GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+
+ gobject_class->set_property = gdict_client_context_set_property;
+ gobject_class->get_property = gdict_client_context_get_property;
+ gobject_class->finalize = gdict_client_context_finalize;
+
+ g_object_class_override_property (gobject_class,
+ GDICT_CONTEXT_PROP_LOCAL_ONLY,
+ "local-only");
+
+ /**
+ * GdictClientContext:client-name
+ *
+ * The name of the client using this context; it will be advertised when
+ * connecting to the dictionary server.
+ *
+ * Since: 1.0
+ */
+ g_object_class_install_property (gobject_class,
+ PROP_CLIENT_NAME,
+ g_param_spec_string ("client-name",
+ _("Client Name"),
+ _("The name of the client of the context object"),
+ NULL,
+ (G_PARAM_READABLE | G_PARAM_WRITABLE)));
+ /**
+ * GdictClientContext:hostname
+ *
+ * The hostname of the dictionary server to connect to.
+ *
+ * Since: 1.0
+ */
+ g_object_class_install_property (gobject_class,
+ PROP_HOSTNAME,
+ g_param_spec_string ("hostname",
+ _("Hostname"),
+ _("The hostname of the dictionary server to connect to"),
+ NULL,
+ (G_PARAM_READABLE | G_PARAM_WRITABLE)));
+ /**
+ * GdictClientContext:port
+ *
+ * The port of the dictionary server to connect to.
+ *
+ * Since: 1.0
+ */
+ g_object_class_install_property (gobject_class,
+ PROP_PORT,
+ g_param_spec_uint ("port",
+ _("Port"),
+ _("The port of the dictionary server to connect to"),
+ 0,
+ 65535,
+ GDICT_DEFAULT_PORT,
+ (G_PARAM_READABLE | G_PARAM_WRITABLE)));
+ /**
+ * GdictClientContext:status
+ *
+ * The status code as returned by the dictionary server.
+ *
+ * Since: 1.0
+ */
+ g_object_class_install_property (gobject_class,
+ PROP_STATUS,
+ g_param_spec_enum ("status",
+ _("Status"),
+ _("The status code as returned by the dictionary server"),
+ GDICT_TYPE_STATUS_CODE,
+ GDICT_STATUS_INVALID,
+ G_PARAM_READABLE));
+
+ /**
+ * GdictClientContext::connected
+ * @client: the object which received the signal
+ *
+ * Emitted when a #GdictClientContext has successfully established a
+ * connection with a dictionary server.
+ *
+ * Since: 1.0
+ */
+ gdict_client_context_signals[CONNECTED] =
+ g_signal_new ("connected",
+ G_OBJECT_CLASS_TYPE (gobject_class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (GdictClientContextClass, connected),
+ NULL, NULL,
+ gdict_marshal_VOID__VOID,
+ G_TYPE_NONE, 0);
+ /**
+ * GdictClientContext::disconnected
+ * @client: the object which received the signal
+ *
+ * Emitted when a #GdictClientContext has disconnected from a dictionary
+ * server.
+ *
+ * Since: 1.0
+ */
+ gdict_client_context_signals[DISCONNECTED] =
+ g_signal_new ("disconnected",
+ G_OBJECT_CLASS_TYPE (gobject_class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (GdictClientContextClass, disconnected),
+ NULL, NULL,
+ gdict_marshal_VOID__VOID,
+ G_TYPE_NONE, 0);
+
+ klass->connected = gdict_client_context_real_connected;
+ klass->disconnected = gdict_client_context_real_disconnected;
+
+ g_type_class_add_private (gobject_class, sizeof (GdictClientContextPrivate));
+}
+
+static void
+gdict_client_context_init (GdictClientContext *context)
+{
+ GdictClientContextPrivate *priv;
+
+ priv = GDICT_CLIENT_CONTEXT_GET_PRIVATE (context);
+ context->priv = priv;
+
+ priv->hostname = NULL;
+ priv->port = 0;
+
+ priv->hostinfo = NULL;
+#ifdef ENABLE_IPV6
+ priv->host6info = NULL;
+#endif
+
+ priv->last_lookup = (time_t) -1;
+
+ priv->is_connecting = FALSE;
+ priv->local_only = FALSE;
+
+ priv->status_code = GDICT_STATUS_INVALID;
+
+ priv->client_name = NULL;
+
+ priv->command = NULL;
+ priv->commands_queue = g_queue_new ();
+}
+
+static void
+gdict_client_context_set_property (GObject *object,
+ guint prop_id,
+ const GValue *value,
+ GParamSpec *pspec)
+{
+ GdictClientContextPrivate *priv = GDICT_CLIENT_CONTEXT_GET_PRIVATE (object);
+
+ switch (prop_id)
+ {
+ case PROP_HOSTNAME:
+ if (priv->hostname)
+ g_free (priv->hostname);
+ priv->hostname = g_strdup (g_value_get_string (value));
+ gdict_client_context_clear_hostinfo (GDICT_CLIENT_CONTEXT (object));
+ break;
+ case PROP_PORT:
+ priv->port = g_value_get_uint (value);
+ break;
+ case PROP_CLIENT_NAME:
+ if (priv->client_name)
+ g_free (priv->client_name);
+ priv->client_name = g_strdup (g_value_get_string (value));
+ break;
+ case GDICT_CONTEXT_PROP_LOCAL_ONLY:
+ priv->local_only = g_value_get_boolean (value);
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ break;
+ }
+}
+
+static void
+gdict_client_context_get_property (GObject *object,
+ guint prop_id,
+ GValue *value,
+ GParamSpec *pspec)
+{
+ GdictClientContextPrivate *priv = GDICT_CLIENT_CONTEXT_GET_PRIVATE (object);
+
+ switch (prop_id)
+ {
+ case PROP_STATUS:
+ g_value_set_enum (value, priv->status_code);
+ break;
+ case PROP_HOSTNAME:
+ g_value_set_string (value, priv->hostname);
+ break;
+ case PROP_PORT:
+ g_value_set_uint (value, priv->port);
+ break;
+ case PROP_CLIENT_NAME:
+ g_value_set_string (value, priv->client_name);
+ break;
+ case GDICT_CONTEXT_PROP_LOCAL_ONLY:
+ g_value_set_boolean (value, priv->local_only);
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ break;
+ }
+}
+
+static void
+gdict_client_context_finalize (GObject *object)
+{
+ GdictClientContext *context = GDICT_CLIENT_CONTEXT (object);
+ GdictClientContextPrivate *priv = context->priv;
+
+ /* force disconnection */
+ gdict_client_context_force_disconnect (context);
+
+ if (priv->command)
+ gdict_command_free (priv->command);
+
+ if (priv->commands_queue)
+ {
+ g_queue_foreach (priv->commands_queue,
+ (GFunc) gdict_command_free,
+ NULL);
+ g_queue_free (priv->commands_queue);
+
+ priv->commands_queue = NULL;
+ }
+
+ if (priv->client_name)
+ g_free (priv->client_name);
+
+ if (priv->hostname)
+ g_free (priv->hostname);
+
+#ifdef ENABLE_IPV6
+ if (priv->host6info)
+ freeaddrinfo (priv->host6info);
+#endif
+
+ /* chain up parent's finalize method */
+ G_OBJECT_CLASS (gdict_client_context_parent_class)->finalize (object);
+}
+
+/**
+ * gdict_client_context_new:
+ * @hostname: the hostname of a dictionary server, or %NULL for the
+ * default server
+ * @port: port to be used when connecting to the dictionary server,
+ * or -1 for the default port
+ *
+ * Creates a new #GdictClientContext object for @hostname. Use this
+ * object to connect and query the dictionary server using the Dictionary
+ * Protocol as defined by RFC 2229.
+ *
+ * Return value: the newly created #GdictClientContext object. You should
+ * free it using g_object_unref().
+ */
+GdictContext *
+gdict_client_context_new (const gchar *hostname,
+ gint port)
+{
+ return g_object_new (GDICT_TYPE_CLIENT_CONTEXT,
+ "hostname", (hostname != NULL ? hostname : GDICT_DEFAULT_HOSTNAME),
+ "port", (port != -1 ? port : GDICT_DEFAULT_PORT),
+ "client-name", GDICT_DEFAULT_CLIENT,
+ NULL);
+}
+
+/**
+ * gdict_client_context_set_hostname:
+ * @context: a #GdictClientContext
+ * @hostname: the hostname of a Dictionary server, or %NULL
+ *
+ * Sets @hostname as the hostname of the dictionary server to be used.
+ * If @hostname is %NULL, the default dictionary server will be used.
+ */
+void
+gdict_client_context_set_hostname (GdictClientContext *context,
+ const gchar *hostname)
+{
+ g_return_if_fail (GDICT_IS_CLIENT_CONTEXT (context));
+
+ g_object_set (G_OBJECT (context),
+ "hostname", (hostname != NULL ? hostname : GDICT_DEFAULT_HOSTNAME),
+ NULL);
+}
+
+/**
+ * gdict_client_context_get_hostname:
+ * @context: a #GdictClientContext
+ *
+ * Gets the hostname of the dictionary server used by @context.
+ *
+ * Return value: the hostname of a dictionary server. The returned string is
+ * owned by the #GdictClientContext object and should never be modified or
+ * freed.
+ */
+const gchar *
+gdict_client_context_get_hostname (GdictClientContext *context)
+{
+ gchar *hostname;
+
+ g_return_val_if_fail (GDICT_IS_CLIENT_CONTEXT (context), NULL);
+
+ g_object_get (G_OBJECT (context), "hostname", &hostname, NULL);
+
+ return hostname;
+}
+
+/**
+ * gdict_client_context_set_port:
+ * @context: a #GdictClientContext
+ * @port: port of the dictionary server to be used, or -1
+ *
+ * Sets the port of the dictionary server to be used when connecting.
+ *
+ * If @port is -1, the default port will be used.
+ */
+void
+gdict_client_context_set_port (GdictClientContext *context,
+ gint port)
+{
+ g_return_if_fail (GDICT_IS_CLIENT_CONTEXT (context));
+
+ g_object_set (G_OBJECT (context),
+ "port", (port != -1 ? port : GDICT_DEFAULT_PORT),
+ NULL);
+}
+
+/**
+ * gdict_client_context_get_port:
+ * @context: a #GdictClientContext
+ *
+ * Gets the port of the dictionary server used by @context.
+ *
+ * Return value: the number of the port.
+ */
+guint
+gdict_client_context_get_port (GdictClientContext *context)
+{
+ guint port;
+
+ g_return_val_if_fail (GDICT_IS_CLIENT_CONTEXT (context), -1);
+
+ g_object_get (G_OBJECT (context), "port", &port, NULL);
+
+ return port;
+}
+
+/**
+ * gdict_client_context_set_client:
+ * @context: a #GdictClientContext
+ * @client: the client name to use, or %NULL
+ *
+ * Sets @client as the client name to be used when advertising ourselves when
+ * a connection the the dictionary server has been established.
+ * If @client is %NULL, the default client name will be used.
+ */
+void
+gdict_client_context_set_client (GdictClientContext *context,
+ const gchar *client)
+{
+ g_return_if_fail (GDICT_IS_CLIENT_CONTEXT (context));
+
+ g_object_set (G_OBJECT (context),
+ "client-name", (client != NULL ? client : GDICT_DEFAULT_CLIENT),
+ NULL);
+}
+
+/**
+ * gdict_client_context_get_client:
+ * @context: a #GdictClientContext
+ *
+ * Gets the client name used by @context. See gdict_client_context_set_client().
+ *
+ * Return value: the client name. The returned string is owned by the
+ * #GdictClientContext object and should never be modified or freed.
+ */
+const gchar *
+gdict_client_context_get_client (GdictClientContext *context)
+{
+ gchar *client_name;
+
+ g_return_val_if_fail (GDICT_IS_CLIENT_CONTEXT (context), NULL);
+
+ g_object_get (G_OBJECT (context), "client-name", &client_name, NULL);
+
+ return client_name;
+}
+
+/* creates a new command to be sent to the dictionary server */
+static GdictCommand *
+gdict_command_new (GdictCommandType cmd_type)
+{
+ GdictCommand *retval;
+
+ g_assert (IS_VALID_CMD (cmd_type));
+
+ retval = g_slice_new0 (GdictCommand);
+
+ retval->cmd_type = cmd_type;
+ retval->state = S_START;
+
+ return retval;
+}
+
+static void
+gdict_command_free (GdictCommand *cmd)
+{
+ if (!cmd)
+ return;
+
+ g_free (cmd->cmd_string);
+
+ switch (cmd->cmd_type)
+ {
+ case CMD_CLIENT:
+ case CMD_QUIT:
+ break;
+ case CMD_SHOW_DB:
+ case CMD_SHOW_STRAT:
+ break;
+ case CMD_MATCH:
+ g_free (cmd->database);
+ g_free (cmd->strategy);
+ g_free (cmd->word);
+ break;
+ case CMD_DEFINE:
+ g_free (cmd->database);
+ g_free (cmd->word);
+ break;
+ default:
+ break;
+ }
+
+ if (cmd->buffer)
+ g_string_free (cmd->buffer, TRUE);
+
+ if (cmd->data_destroy)
+ cmd->data_destroy (cmd->data);
+
+ g_slice_free (GdictCommand, cmd);
+}
+
+/* push @command into the head of the commands queue; the command queue is
+ * a FIFO-like pipe: commands go into the head and are retrieved from the
+ * tail.
+ */
+static gboolean
+gdict_client_context_push_command (GdictClientContext *context,
+ GdictCommand *command)
+{
+ GdictClientContextPrivate *priv;
+
+ g_assert (GDICT_IS_CLIENT_CONTEXT (context));
+ g_assert (command != NULL);
+
+ priv = context->priv;
+
+ /* avoid pushing a command twice */
+ if (g_queue_find (priv->commands_queue, command))
+ {
+ g_warning ("gdict_client_context_push_command() called on a command already in queue\n");
+ return FALSE;
+ }
+
+ GDICT_NOTE (DICT, "Pushing command ('%s') into the queue...",
+ dict_command_strings[command->cmd_type]);
+
+ g_queue_push_head (priv->commands_queue, command);
+
+ return TRUE;
+}
+
+static GdictCommand *
+gdict_client_context_pop_command (GdictClientContext *context)
+{
+ GdictClientContextPrivate *priv;
+ GdictCommand *retval;
+
+ g_assert (GDICT_IS_CLIENT_CONTEXT (context));
+
+ priv = context->priv;
+
+ retval = (GdictCommand *) g_queue_pop_tail (priv->commands_queue);
+ if (!retval)
+ return NULL;
+
+ GDICT_NOTE (DICT, "Getting command ('%s') from the queue...",
+ dict_command_strings[retval->cmd_type]);
+
+ return retval;
+}
+
+/* send @command on the wire */
+static gboolean
+gdict_client_context_send_command (GdictClientContext *context,
+ GdictCommand *command,
+ GError **error)
+{
+ GdictClientContextPrivate *priv;
+ GError *write_error;
+ gsize written_bytes;
+ GIOStatus res;
+
+ g_assert (GDICT_IS_CLIENT_CONTEXT (context));
+ g_assert (command != NULL && command->cmd_string != NULL);
+
+ priv = context->priv;
+
+ if (!priv->channel)
+ {
+ GDICT_NOTE (DICT, "No connection established");
+
+ g_set_error (error, GDICT_CLIENT_CONTEXT_ERROR,
+ GDICT_CLIENT_CONTEXT_ERROR_NO_CONNECTION,
+ _("No connection to the dictionary server at '%s:%d'"),
+ priv->hostname,
+ priv->port);
+
+ return FALSE;
+ }
+
+ write_error = NULL;
+ res = g_io_channel_write_chars (priv->channel,
+ command->cmd_string,
+ -1,
+ &written_bytes,
+ &write_error);
+ if (res != G_IO_STATUS_NORMAL)
+ {
+ g_propagate_error (error, write_error);
+
+ return FALSE;
+ }
+
+ /* force flushing of the write buffer */
+ g_io_channel_flush (priv->channel, NULL);
+
+ GDICT_NOTE (DICT, "Wrote %"G_GSIZE_FORMAT" bytes to the channel", written_bytes);
+
+ return TRUE;
+}
+
+/* gdict_client_context_run_command: runs @command inside @context; this
+ * function builds the command string and then passes it to the dictionary
+ * server.
+ */
+static gboolean
+gdict_client_context_run_command (GdictClientContext *context,
+ GdictCommand *command,
+ GError **error)
+{
+ GdictClientContextPrivate *priv;
+ gchar *payload;
+ GError *send_error;
+ gboolean res;
+
+ g_assert (GDICT_IS_CLIENT_CONTEXT (context));
+ g_assert (command != NULL);
+ g_assert (IS_VALID_CMD (command->cmd_type));
+
+ GDICT_NOTE (DICT, "GdictCommand command =\n"
+ "{\n"
+ " .cmd_type = '%02d' ('%s');\n"
+ " .database = '%s';\n"
+ " .strategy = '%s';\n"
+ " .word = '%s';\n"
+ "}\n",
+ command->cmd_type, dict_command_strings[command->cmd_type],
+ command->database ? command->database : "<none>",
+ command->strategy ? command->strategy : "<none>",
+ command->word ? command->word : "<none>");
+
+ priv = context->priv;
+
+ g_assert (priv->command == NULL);
+
+ priv->command = command;
+
+ /* build the command string to be sent to the server */
+ switch (command->cmd_type)
+ {
+ case CMD_CLIENT:
+ payload = g_shell_quote (priv->client_name);
+ command->cmd_string = g_strdup_printf ("%s %s\r\n",
+ dict_command_strings[CMD_CLIENT],
+ payload);
+ g_free (payload);
+ break;
+ case CMD_QUIT:
+ command->cmd_string = g_strdup_printf ("%s\r\n",
+ dict_command_strings[CMD_QUIT]);
+ break;
+ case CMD_SHOW_DB:
+ command->cmd_string = g_strdup_printf ("%s\r\n",
+ dict_command_strings[CMD_SHOW_DB]);
+ break;
+ case CMD_SHOW_STRAT:
+ command->cmd_string = g_strdup_printf ("%s\r\n",
+ dict_command_strings[CMD_SHOW_STRAT]);
+ break;
+ case CMD_MATCH:
+ g_assert (command->word);
+ payload = g_shell_quote (command->word);
+ command->cmd_string = g_strdup_printf ("%s %s %s %s\r\n",
+ dict_command_strings[CMD_MATCH],
+ (command->database != NULL ? command->database : "!"),
+ (command->strategy != NULL ? command->strategy : "*"),
+ payload);
+ g_free (payload);
+ break;
+ case CMD_DEFINE:
+ g_assert (command->word);
+ payload = g_shell_quote (command->word);
+ command->cmd_string = g_strdup_printf ("%s %s %s\r\n",
+ dict_command_strings[CMD_DEFINE],
+ (command->database != NULL ? command->database : "!"),
+ payload);
+ g_free (payload);
+ break;
+ default:
+ g_assert_not_reached ();
+ break;
+ }
+
+ g_assert (command->cmd_string);
+
+ GDICT_NOTE (DICT, "Sending command ('%s') to the server",
+ dict_command_strings[command->cmd_type]);
+
+ send_error = NULL;
+ res = gdict_client_context_send_command (context, command, &send_error);
+ if (!res)
+ {
+ g_propagate_error (error, send_error);
+
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+/* we use this signal to advertise ourselves to the dictionary server */
+static void
+gdict_client_context_real_connected (GdictClientContext *context)
+{
+ GdictCommand *cmd;
+
+ cmd = gdict_command_new (CMD_CLIENT);
+ cmd->state = S_FINISH;
+
+ /* the CLIENT command should be the first one in our queue, so we place
+ * it above all other commands the user might have issued between the
+ * first and the emission of the "connected" signal, by calling it
+ * directely.
+ */
+ gdict_client_context_run_command (context, cmd, NULL);
+}
+
+static void
+clear_command_queue (GdictClientContext *context)
+{
+ GdictClientContextPrivate *priv = context->priv;
+
+ if (priv->commands_queue)
+ {
+ g_queue_foreach (priv->commands_queue,
+ (GFunc) gdict_command_free,
+ NULL);
+
+ g_queue_free (priv->commands_queue);
+ }
+
+ /* renew */
+ priv->commands_queue = g_queue_new ();
+}
+
+/* force a disconnection from the server */
+static void
+gdict_client_context_force_disconnect (GdictClientContext *context)
+{
+ GdictClientContextPrivate *priv = context->priv;
+
+ if (priv->timeout_id)
+ {
+ g_source_remove (priv->timeout_id);
+ priv->timeout_id = 0;
+ }
+
+ if (priv->source_id)
+ {
+ g_source_remove (priv->source_id);
+ priv->source_id = 0;
+ }
+
+ if (priv->channel)
+ {
+ g_io_channel_shutdown (priv->channel, TRUE, NULL);
+ g_io_channel_unref (priv->channel);
+
+ priv->channel = NULL;
+ }
+
+ if (priv->command)
+ {
+ gdict_command_free (priv->command);
+ priv->command = NULL;
+ }
+
+ clear_command_queue (context);
+}
+
+static void
+gdict_client_context_real_disconnected (GdictClientContext *context)
+{
+ gdict_client_context_force_disconnect (context);
+}
+
+/* clear the lookup data */
+static void
+gdict_client_context_clear_hostinfo (GdictClientContext *context)
+{
+ GdictClientContextPrivate *priv;
+
+ g_assert (GDICT_IS_CLIENT_CONTEXT (context));
+
+ priv = context->priv;
+
+#ifdef ENABLE_IPV6
+ if (!priv->host6info)
+ return;
+#endif
+
+ if (!priv->hostinfo)
+ return;
+
+#ifdef ENABLE_IPV6
+ freeaddrinfo (priv->host6info);
+#endif
+ priv->hostinfo = NULL;
+}
+
+/* gdict_client_context_lookup_server: perform an hostname lookup in order to
+ * connect to the dictionary server
+ */
+static gboolean
+gdict_client_context_lookup_server (GdictClientContext *context,
+ GError **error)
+{
+ GdictClientContextPrivate *priv;
+ gboolean is_expired = FALSE;
+ time_t now;
+
+ g_assert (GDICT_IS_CLIENT_CONTEXT (context));
+
+ priv = context->priv;
+
+ /* we need the hostname, at this point */
+ g_assert (priv->hostname != NULL);
+
+ time (&now);
+ if (now >= (priv->last_lookup + HOSTNAME_LOOKUP_EXPIRE))
+ is_expired = TRUE;
+
+ /* we already have resolved the hostname */
+#ifdef ENABLE_IPV6
+ if (priv->host6info && !is_expired)
+ return TRUE;
+#endif
+
+ if (priv->hostinfo && !is_expired)
+ return TRUE;
+
+ /* clear any previously acquired lookup data */
+ gdict_client_context_clear_hostinfo (context);
+
+ GDICT_NOTE (DICT, "Looking up hostname '%s'", priv->hostname);
+
+#ifdef ENABLE_IPV6
+ if (_gdict_has_ipv6 ())
+ {
+ struct addrinfo hints, *res;
+
+ GDICT_NOTE (DICT, "Hostname '%s' look-up (using IPv6)", priv->hostname);
+
+ memset (&hints, 0, sizeof (hints));
+ hints.ai_socktype = SOCK_STREAM;
+
+ if (getaddrinfo (priv->hostname, NULL, &hints, &(priv->host6info)) == 0)
+ {
+ for (res = priv->host6info; res; res = res->ai_next)
+ if (res->ai_family == AF_INET6 || res->ai_family == AF_INET)
+ break;
+
+ if (!res)
+ {
+ g_set_error (error, GDICT_CLIENT_CONTEXT_ERROR,
+ GDICT_CLIENT_CONTEXT_ERROR_LOOKUP,
+ _("Lookup failed for hostname '%s': no suitable resources found"),
+ priv->hostname);
+
+ return FALSE;
+ }
+ else
+ {
+ if (res->ai_family == AF_INET6)
+ memcpy (&((struct sockaddr_in6 *) &priv->sockaddr)->sin6_addr,
+ &((struct sockaddr_in6 *) res->ai_addr)->sin6_addr,
+ sizeof (struct in6_addr));
+
+ if (res->ai_family == AF_INET)
+ memcpy (&((struct sockaddr_in *) &priv->sockaddr)->sin_addr,
+ &((struct sockaddr_in *) res->ai_addr)->sin_addr,
+ sizeof (struct in_addr));
+
+ priv->sockaddr.ss_family = res->ai_family;
+
+ GDICT_NOTE (DICT, "Hostname '%s' found (using IPv6)",
+ priv->hostname);
+
+ priv->last_lookup = time (NULL);
+
+ return TRUE;
+ }
+ }
+ else
+ {
+ g_set_error (error, GDICT_CLIENT_CONTEXT_ERROR,
+ GDICT_CLIENT_CONTEXT_ERROR_LOOKUP,
+ _("Lookup failed for host '%s': %s"),
+ priv->hostname,
+ gai_strerror (errno));
+
+ return FALSE;
+ }
+ }
+ else
+ {
+#endif /* ENABLE_IPV6 */
+ /* if we don't support IPv6, fallback to usual IPv4 lookup */
+
+ GDICT_NOTE (DICT, "Hostname '%s' look-up (using IPv4)", priv->hostname);
+
+ ((struct sockaddr_in *) &priv->sockaddr)->sin_family = AF_INET;
+
+ priv->hostinfo = gethostbyname (priv->hostname);
+ if (priv->hostinfo)
+ {
+ memcpy (&((struct sockaddr_in *) &(priv->sockaddr))->sin_addr,
+ priv->hostinfo->h_addr,
+ priv->hostinfo->h_length);
+
+ GDICT_NOTE (DICT, "Hostname '%s' found (using IPv4)",
+ priv->hostname);
+
+ priv->last_lookup = time (NULL);
+
+ return TRUE;
+ }
+ else
+ {
+ g_set_error (error, GDICT_CLIENT_CONTEXT_ERROR,
+ GDICT_CLIENT_CONTEXT_ERROR_LOOKUP,
+ _("Lookup failed for host '%s': host not found"),
+ priv->hostname);
+
+ return FALSE;
+ }
+#ifdef ENABLE_IPV6
+ }
+#endif
+
+ g_assert_not_reached ();
+
+ return FALSE;
+}
+
+/* gdict_client_context_parse_line: parses a line from the dictionary server
+ * this is the core of the RFC2229 protocol implementation, here's where
+ * the magic happens.
+ */
+static gboolean
+gdict_client_context_parse_line (GdictClientContext *context,
+ const gchar *buffer)
+{
+ GdictClientContextPrivate *priv;
+ GError *server_error = NULL;
+
+ g_assert (GDICT_IS_CLIENT_CONTEXT (context));
+ g_assert (buffer != NULL);
+
+ priv = context->priv;
+
+ GDICT_NOTE (DICT, "parse buffer: '%s'", buffer);
+
+ /* connection is a special case: we don't have a command, so we just
+ * make sure that the server replied with the correct code. WARNING:
+ * the server might be shutting down or not available, so we must
+ * take into account those responses too!
+ */
+ if (!priv->command)
+ {
+ if (priv->status_code == GDICT_STATUS_CONNECT)
+ {
+ /* the server accepts our connection */
+ g_signal_emit (context, gdict_client_context_signals[CONNECTED], 0);
+
+ return TRUE;
+ }
+ else if ((priv->status_code == GDICT_STATUS_SERVER_DOWN) ||
+ (priv->status_code == GDICT_STATUS_SHUTDOWN))
+ {
+ /* the server is shutting down or is not available */
+ g_set_error (&server_error, GDICT_CLIENT_CONTEXT_ERROR,
+ GDICT_CLIENT_CONTEXT_ERROR_SERVER_DOWN,
+ _("Unable to connect to the dictionary server "
+ "at '%s:%d'. The server replied with "
+ "code %d (server down)"),
+ priv->hostname,
+ priv->port,
+ priv->status_code);
+
+ g_signal_emit_by_name (context, "error", server_error);
+
+ g_error_free (server_error);
+
+ return TRUE;
+ }
+ else
+ {
+ GError *parse_error = NULL;
+
+ g_set_error (&parse_error, GDICT_CONTEXT_ERROR,
+ GDICT_CONTEXT_ERROR_PARSE,
+ _("Unable to parse the dictionary server reply\n: '%s'"),
+ buffer);
+
+ g_signal_emit_by_name (context, "error", parse_error);
+
+ g_error_free (parse_error);
+
+ return FALSE;
+ }
+ }
+
+ /* disconnection is another special case: the server replies with code
+ * 221, and closes the connection; we emit the "disconnected" signal
+ * and close the connection on our side.
+ */
+ if (priv->status_code == GDICT_STATUS_QUIT)
+ {
+ g_signal_emit (context, gdict_client_context_signals[DISCONNECTED], 0);
+
+ return TRUE;
+ }
+
+ /* here we catch all the errors codes that the server might give us */
+ server_error = NULL;
+ switch (priv->status_code)
+ {
+ case GDICT_STATUS_NO_MATCH:
+ g_set_error (&server_error, GDICT_CONTEXT_ERROR,
+ GDICT_CONTEXT_ERROR_NO_MATCH,
+ _("No definitions found for '%s'"),
+ priv->command->word);
+
+ GDICT_NOTE (DICT, "No match: %s", server_error->message);
+
+ g_signal_emit_by_name (context, "error", server_error);
+
+ g_error_free (server_error);
+ server_error = NULL;
+
+ priv->command->state = S_FINISH;
+ break;
+ case GDICT_STATUS_BAD_DATABASE:
+ g_set_error (&server_error, GDICT_CONTEXT_ERROR,
+ GDICT_CONTEXT_ERROR_INVALID_DATABASE,
+ _("Invalid database '%s'"),
+ priv->command->database);
+
+ GDICT_NOTE (DICT, "Bad DB: %s", server_error->message);
+
+ g_signal_emit_by_name (context, "error", server_error);
+
+ g_error_free (server_error);
+ server_error = NULL;
+
+ priv->command->state = S_FINISH;
+ break;
+ case GDICT_STATUS_BAD_STRATEGY:
+ g_set_error (&server_error, GDICT_CONTEXT_ERROR,
+ GDICT_CONTEXT_ERROR_INVALID_STRATEGY,
+ _("Invalid strategy '%s'"),
+ priv->command->strategy);
+
+ GDICT_NOTE (DICT, "Bad strategy: %s", server_error->message);
+
+ g_signal_emit_by_name (context, "error", server_error);
+
+ g_error_free (server_error);
+ server_error = NULL;
+
+ priv->command->state = S_FINISH;
+ break;
+ case GDICT_STATUS_BAD_COMMAND:
+ g_set_error (&server_error, GDICT_CONTEXT_ERROR,
+ GDICT_CONTEXT_ERROR_INVALID_COMMAND,
+ _("Bad command '%s'"),
+ dict_command_strings[priv->command->cmd_type]);
+
+ GDICT_NOTE (DICT, "Bad command: %s", server_error->message);
+
+ g_signal_emit_by_name (context, "error", server_error);
+
+ g_error_free (server_error);
+ server_error = NULL;
+
+ priv->command->state = S_FINISH;
+ break;
+ case GDICT_STATUS_BAD_PARAMETERS:
+ g_set_error (&server_error, GDICT_CONTEXT_ERROR,
+ GDICT_CONTEXT_ERROR_INVALID_COMMAND,
+ _("Bad parameters for command '%s'"),
+ dict_command_strings[priv->command->cmd_type]);
+
+ GDICT_NOTE (DICT, "Bad params: %s", server_error->message);
+
+ g_signal_emit_by_name (context, "error", server_error);
+
+ g_error_free (server_error);
+ server_error = NULL;
+
+ priv->command->state = S_FINISH;
+ break;
+ case GDICT_STATUS_NO_DATABASES_PRESENT:
+ g_set_error (&server_error, GDICT_CONTEXT_ERROR,
+ GDICT_CONTEXT_ERROR_NO_DATABASES,
+ _("No databases found on dictionary server at '%s'"),
+ priv->hostname);
+
+ GDICT_NOTE (DICT, "No DB: %s", server_error->message);
+
+ g_signal_emit_by_name (context, "error", server_error);
+
+ g_error_free (server_error);
+ server_error = NULL;
+
+ priv->command->state = S_FINISH;
+ break;
+ case GDICT_STATUS_NO_STRATEGIES_PRESENT:
+ g_set_error (&server_error, GDICT_CONTEXT_ERROR,
+ GDICT_CONTEXT_ERROR_NO_STRATEGIES,
+ _("No strategies found on dictionary server at '%s'"),
+ priv->hostname);
+
+ GDICT_NOTE (DICT, "No strategies: %s", server_error->message);
+
+ g_signal_emit_by_name (context, "error", server_error);
+
+ g_error_free (server_error);
+ server_error = NULL;
+
+ priv->command->state = S_FINISH;
+ break;
+ default:
+ GDICT_NOTE (DICT, "non-error code: %d", priv->status_code);
+ break;
+ }
+
+ /* server replied with 'ok' or the command has reached its FINISH state,
+ * so now we are clear for destroying the current command and check if
+ * there are other commands on the queue, and run them.
+ */
+ if ((priv->status_code == GDICT_STATUS_OK) ||
+ (priv->command->state == S_FINISH))
+ {
+ GdictCommand *new_command;
+ GError *run_error;
+ GdictCommandType last_cmd;
+
+ last_cmd = priv->command->cmd_type;
+
+ gdict_command_free (priv->command);
+ priv->command = NULL;
+
+ /* notify the end of a command - ignore CLIENT and QUIT commands, as
+ * we issue them ourselves
+ */
+ if ((last_cmd != CMD_CLIENT) && (last_cmd != CMD_QUIT))
+ g_signal_emit_by_name (context, "lookup-end");
+
+ /* pop the next command from the queue */
+ new_command = gdict_client_context_pop_command (context);
+ if (!new_command)
+ {
+ /* if the queue is empty, quit */
+ gdict_client_context_disconnect (context);
+ new_command = gdict_client_context_pop_command (context);
+ }
+
+ run_error = NULL;
+ gdict_client_context_run_command (context, new_command, &run_error);
+ if (run_error)
+ {
+ g_signal_emit_by_name (context, "error", run_error);
+
+ g_error_free (run_error);
+ }
+
+ return TRUE;
+ }
+
+ GDICT_NOTE (DICT, "check command %d ('%s')[state:%d]",
+ priv->command->cmd_type,
+ dict_command_strings[priv->command->cmd_type],
+ priv->command->state);
+
+ /* check command type */
+ switch (priv->command->cmd_type)
+ {
+ case CMD_CLIENT:
+ case CMD_QUIT:
+ break;
+ case CMD_SHOW_DB:
+ if (priv->status_code == GDICT_STATUS_N_DATABASES_PRESENT)
+ {
+ gchar *p;
+
+ priv->command->state = S_DATA;
+
+ p = g_utf8_strchr (buffer, -1, ' ');
+ if (p)
+ p = g_utf8_next_char (p);
+
+ GDICT_NOTE (DICT, "server replied: %d databases found", atoi (p));
+
+ g_signal_emit_by_name (context, "lookup-start");
+ }
+ else if (0 == strcmp (buffer, "."))
+ priv->command->state = S_FINISH;
+ else
+ {
+ GdictDatabase *db;
+ gchar *name, *full, *p;
+
+ g_assert (priv->command->state == S_DATA);
+
+ /* first token: database name;
+ * second token: database description;
+ */
+ name = (gchar *) buffer;
+ if (!name)
+ break;
+
+ p = g_utf8_strchr (name, -1, ' ');
+ if (p)
+ *p = '\0';
+
+ full = g_utf8_next_char (p);
+
+ if (full[0] == '\"')
+ full = g_utf8_next_char (full);
+
+ p = g_utf8_strchr (full, -1, '\"');
+ if (p)
+ *p = '\0';
+
+ db = _gdict_database_new (name);
+ db->full_name = g_strdup (full);
+
+ g_signal_emit_by_name (context, "database-found", db);
+
+ gdict_database_unref (db);
+ }
+ break;
+ case CMD_SHOW_STRAT:
+ if (priv->status_code == GDICT_STATUS_N_STRATEGIES_PRESENT)
+ {
+ gchar *p;
+
+ priv->command->state = S_DATA;
+
+ p = g_utf8_strchr (buffer, -1, ' ');
+ if (p)
+ p = g_utf8_next_char (p);
+
+ GDICT_NOTE (DICT, "server replied: %d strategies found", atoi (p));
+
+ g_signal_emit_by_name (context, "lookup-start");
+ }
+ else if (0 == strcmp (buffer, "."))
+ priv->command->state = S_FINISH;
+ else
+ {
+ GdictStrategy *strat;
+ gchar *name, *desc, *p;
+
+ g_assert (priv->command->state == S_DATA);
+
+ name = (gchar *) buffer;
+ if (!name)
+ break;
+
+ p = g_utf8_strchr (name, -1, ' ');
+ if (p)
+ *p = '\0';
+
+ desc = g_utf8_next_char (p);
+
+ if (desc[0] == '\"')
+ desc = g_utf8_next_char (desc);
+
+ p = g_utf8_strchr (desc, -1, '\"');
+ if (p)
+ *p = '\0';
+
+ strat = _gdict_strategy_new (name);
+ strat->description = g_strdup (desc);
+
+ g_signal_emit_by_name (context, "strategy-found", strat);
+
+ gdict_strategy_unref (strat);
+ }
+ break;
+ case CMD_DEFINE:
+ if (priv->status_code == GDICT_STATUS_N_DEFINITIONS_RETRIEVED)
+ {
+ GdictDefinition *def;
+ gchar *p;
+
+ priv->command->state = S_STATUS;
+
+ p = g_utf8_strchr (buffer, -1, ' ');
+ if (p)
+ p = g_utf8_next_char (p);
+
+ GDICT_NOTE (DICT, "server replied: %d definitions found", atoi (p));
+
+ def = _gdict_definition_new (atoi (p));
+
+ priv->command->data = def;
+ priv->command->data_destroy = (GDestroyNotify) gdict_definition_unref;
+
+ g_signal_emit_by_name (context, "lookup-start");
+ }
+ else if (priv->status_code == GDICT_STATUS_WORD_DB_NAME)
+ {
+ GdictDefinition *def;
+ gchar *word, *db_name, *db_full, *p;
+
+ word = (gchar *) buffer;
+
+ /* skip the status code */
+ word = g_utf8_strchr (word, -1, ' ');
+ word = g_utf8_next_char (word);
+
+ if (word[0] == '\"')
+ word = g_utf8_next_char (word);
+
+ p = g_utf8_strchr (word, -1, '\"');
+ if (p)
+ *p = '\0';
+
+ p = g_utf8_next_char (p);
+
+ /* the database name is not protected by "" */
+ db_name = g_utf8_next_char (p);
+ if (!db_name)
+ break;
+
+ p = g_utf8_strchr (db_name, -1, ' ');
+ if (p)
+ *p = '\0';
+
+ p = g_utf8_next_char (p);
+
+ db_full = g_utf8_next_char (p);
+ if (!db_full)
+ break;
+
+ if (db_full[0] == '\"')
+ db_full = g_utf8_next_char (db_full);
+
+ p = g_utf8_strchr (db_full, -1, '\"');
+ if (p)
+ *p = '\0';
+
+ def = (GdictDefinition *) priv->command->data;
+
+ GDICT_NOTE (DICT, "{ word = '%s', db_name = '%s', db_full = '%s' }",
+ word,
+ db_name,
+ db_full);
+
+ def->word = g_strdup (word);
+ def->database_name = g_strdup (db_name);
+ def->database_full = g_strdup (db_full);
+ def->definition = NULL;
+
+ priv->command->state = S_DATA;
+ }
+ else if (strcmp (buffer, ".") == 0)
+ {
+ GdictDefinition *def;
+ gint num;
+
+ g_assert (priv->command->state == S_DATA);
+
+ def = (GdictDefinition *) priv->command->data;
+ if (!def)
+ break;
+
+ def->definition = g_string_free (priv->command->buffer, FALSE);
+
+ /* store the numer of definitions */
+ num = def->total;
+
+ g_signal_emit_by_name (context, "definition-found", def);
+
+ gdict_definition_unref (def);
+
+ priv->command->buffer = NULL;
+ priv->command->data = _gdict_definition_new (num);
+
+ priv->command->state = S_STATUS;
+ }
+ else
+ {
+ g_assert (priv->command->state == S_DATA);
+
+ if (!priv->command->buffer)
+ priv->command->buffer = g_string_new (NULL);
+
+ GDICT_NOTE (DICT, "appending to buffer:\n %s", buffer);
+
+ /* TODO - collapse '..' to '.' */
+ g_string_append_printf (priv->command->buffer, "%s\n", buffer);
+ }
+ break;
+ case CMD_MATCH:
+ if (priv->status_code == GDICT_STATUS_N_MATCHES_FOUND)
+ {
+ gchar *p;
+
+ priv->command->state = S_DATA;
+
+ p = g_utf8_strchr (buffer, -1, ' ');
+ if (p)
+ p = g_utf8_next_char (p);
+
+ GDICT_NOTE (DICT, "server replied: %d matches found", atoi (p));
+
+ g_signal_emit_by_name (context, "lookup-start");
+ }
+ else if (0 == strcmp (buffer, "."))
+ priv->command->state = S_FINISH;
+ else
+ {
+ GdictMatch *match;
+ gchar *word, *db_name, *p;
+
+ g_assert (priv->command->state == S_DATA);
+
+ db_name = (gchar *) buffer;
+ if (!db_name)
+ break;
+
+ p = g_utf8_strchr (db_name, -1, ' ');
+ if (p)
+ *p = '\0';
+
+ word = g_utf8_next_char (p);
+
+ if (word[0] == '\"')
+ word = g_utf8_next_char (word);
+
+ p = g_utf8_strchr (word, -1, '\"');
+ if (p)
+ *p = '\0';
+
+ match = _gdict_match_new (word);
+ match->database = g_strdup (db_name);
+
+ g_signal_emit_by_name (context, "match-found", match);
+
+ gdict_match_unref (match);
+ }
+ break;
+ default:
+ g_assert_not_reached ();
+ break;
+ }
+
+ return TRUE;
+}
+
+/* retrieve the status code from the server response line */
+static gint
+get_status_code (const gchar *line,
+ gint old_status)
+{
+ gchar *status;
+ gint possible_status, retval;
+
+ if (strlen (line) < 3)
+ return 0;
+
+ if (!g_unichar_isdigit (line[0]) ||
+ !g_unichar_isdigit (line[1]) ||
+ !g_unichar_isdigit (line[2]))
+ return 0;
+
+ if (!g_unichar_isspace (line[3]))
+ return 0;
+
+ status = g_strndup (line, 3);
+ possible_status = atoi (status);
+ g_free (status);
+
+ /* status whitelisting: sometimes, a database *cough* moby-thes *cough*
+ * might return a number as first word; we do a small check here for
+ * invalid status codes based on the previously set status; we don't check
+ * the whole line, as we need only to be sure that the status code is
+ * consistent with what we expect.
+ */
+ switch (old_status)
+ {
+ case GDICT_STATUS_WORD_DB_NAME:
+ case GDICT_STATUS_N_MATCHES_FOUND:
+ if (possible_status == GDICT_STATUS_OK)
+ retval = possible_status;
+ else
+ retval = 0;
+ break;
+ case GDICT_STATUS_N_DEFINITIONS_RETRIEVED:
+ if (possible_status == GDICT_STATUS_WORD_DB_NAME)
+ retval = possible_status;
+ else
+ retval = 0;
+ break;
+ default:
+ retval = possible_status;
+ break;
+ }
+
+ return retval;
+}
+
+static gboolean
+gdict_client_context_io_watch_cb (GIOChannel *channel,
+ GIOCondition condition,
+ GdictClientContext *context)
+{
+ GdictClientContextPrivate *priv;
+
+ g_assert (GDICT_IS_CLIENT_CONTEXT (context));
+ priv = context->priv;
+
+ /* since this is an asynchronous channel, we might end up here
+ * even though the channel has been shut down.
+ */
+ if (!priv->channel)
+ {
+ g_warning ("No channel available\n");
+
+ return FALSE;
+ }
+
+ if (priv->is_connecting)
+ {
+ priv->is_connecting = FALSE;
+
+ if (priv->timeout_id)
+ {
+ g_source_remove (priv->timeout_id);
+ priv->timeout_id = 0;
+ }
+ }
+
+ if (condition & G_IO_ERR)
+ {
+ GError *err = NULL;
+
+ g_set_error (&err, GDICT_CLIENT_CONTEXT_ERROR,
+ GDICT_CLIENT_CONTEXT_ERROR_SOCKET,
+ _("Connection failed to the dictionary server at %s:%d"),
+ priv->hostname,
+ priv->port);
+
+ g_signal_emit_by_name (context, "error", err);
+
+ g_error_free (err);
+
+ return FALSE;
+ }
+
+ while (1)
+ {
+ GIOStatus res;
+ guint status_code;
+ GError *read_err;
+ gsize len, term;
+ gchar *line;
+ gboolean parse_res;
+
+ /* we might sever the connection while still inside the read loop,
+ * so we must check the state of the channel before actually doing
+ * the line reading, otherwise we'll end up with death, destruction
+ * and chaos on all earth. oh, and an assertion failed inside
+ * g_io_channel_read_line().
+ */
+ if (!priv->channel)
+ break;
+
+ read_err = NULL;
+ res = g_io_channel_read_line (priv->channel, &line, &len, &term, &read_err);
+ if (res == G_IO_STATUS_ERROR)
+ {
+ if (read_err)
+ {
+ GError *err = NULL;
+
+ g_set_error (&err, GDICT_CLIENT_CONTEXT_ERROR,
+ GDICT_CLIENT_CONTEXT_ERROR_SOCKET,
+ _("Error while reading reply from server:\n%s"),
+ read_err->message);
+
+ g_signal_emit_by_name (context, "error", err);
+
+ g_error_free (err);
+ g_error_free (read_err);
+ }
+
+ gdict_client_context_force_disconnect (context);
+
+ return FALSE;
+ }
+
+ if (len == 0)
+ break;
+
+ /* truncate the line terminator before parsing */
+ line[term] = '\0';
+
+ status_code = get_status_code (line, priv->status_code);
+ if ((status_code == 0) || (GDICT_IS_VALID_STATUS_CODE (status_code)))
+ {
+ priv->status_code = status_code;
+
+ GDICT_NOTE (DICT, "new status = '%d'", priv->status_code);
+ }
+ else
+ priv->status_code = GDICT_STATUS_INVALID;
+
+ /* notify changes only for valid status codes */
+ if (priv->status_code != GDICT_STATUS_INVALID)
+ g_object_notify (G_OBJECT (context), "status");
+
+ parse_res = gdict_client_context_parse_line (context, line);
+ if (!parse_res)
+ {
+ g_free (line);
+
+ g_warning ("Parsing failed");
+
+ gdict_client_context_force_disconnect (context);
+
+ return FALSE;
+ }
+
+ g_free (line);
+ }
+
+ return TRUE;
+}
+
+static gboolean
+check_for_connection (gpointer data)
+{
+ GdictClientContext *context = data;
+
+#if 0
+ g_debug (G_STRLOC ": checking for connection (is connecting:%s)",
+ context->priv->is_connecting ? "true" : "false");
+#endif
+
+ if (context == NULL)
+ return FALSE;
+
+ if (context->priv->is_connecting)
+ {
+ GError *err = NULL;
+
+ GDICT_NOTE (DICT, "Forcing a disconnection due to timeout");
+
+ g_set_error (&err, GDICT_CLIENT_CONTEXT_ERROR,
+ GDICT_CLIENT_CONTEXT_ERROR_SOCKET,
+ _("Connection timeout for the dictionary server at '%s:%d'"),
+ context->priv->hostname,
+ context->priv->port);
+
+ g_signal_emit_by_name (context, "error", err);
+
+ g_error_free (err);
+
+ gdict_client_context_force_disconnect (context);
+ }
+
+ /* this is a one-off operation */
+ return FALSE;
+}
+
+static gboolean
+gdict_client_context_connect (GdictClientContext *context,
+ GError **error)
+{
+ GdictClientContextPrivate *priv;
+ GError *lookup_error, *flags_error;
+ gboolean res;
+ gint sock_fd, sock_res;
+ gsize addrlen;
+ GIOFlags flags;
+
+ g_return_val_if_fail (GDICT_IS_CLIENT_CONTEXT (context), FALSE);
+
+ priv = context->priv;
+
+ if (!priv->hostname)
+ {
+ g_set_error (error, GDICT_CLIENT_CONTEXT_ERROR,
+ GDICT_CLIENT_CONTEXT_ERROR_LOOKUP,
+ _("No hostname defined for the dictionary server"));
+
+ return FALSE;
+ }
+
+ /* forgive the absence of a port */
+ if (!priv->port)
+ priv->port = GDICT_DEFAULT_PORT;
+
+ priv->is_connecting = TRUE;
+
+ lookup_error = NULL;
+ res = gdict_client_context_lookup_server (context, &lookup_error);
+ if (!res)
+ {
+ g_propagate_error (error, lookup_error);
+
+ return FALSE;
+ }
+
+#ifdef ENABLE_IPV6
+ if (priv->sockaddr.ss_family == AF_INET6)
+ ((struct sockaddr_in6 *) &priv->sockaddr)->sin6_port = g_htons (priv->port);
+ else
+#endif
+ ((struct sockaddr_in *) &priv->sockaddr)->sin_port = g_htons (priv->port);
+
+
+#ifdef ENABLE_IPV6
+ if (priv->sockaddr.ss_family == AF_INET6)
+ {
+ sock_fd = socket (AF_INET6, SOCK_STREAM, 0);
+ if (sock_fd < 0)
+ {
+ g_set_error (error, GDICT_CLIENT_CONTEXT_ERROR,
+ GDICT_CLIENT_CONTEXT_ERROR_SOCKET,
+ _("Unable to create socket"));
+
+ return FALSE;
+ }
+
+ addrlen = sizeof (struct sockaddr_in6);
+ }
+ else
+ {
+#endif /* ENABLE_IPV6 */
+ sock_fd = socket (AF_INET, SOCK_STREAM, 0);
+ if (sock_fd < 0)
+ {
+ g_set_error (error, GDICT_CLIENT_CONTEXT_ERROR,
+ GDICT_CLIENT_CONTEXT_ERROR_SOCKET,
+ _("Unable to create socket"));
+
+ return FALSE;
+ }
+
+ addrlen = sizeof (struct sockaddr_in);
+#ifdef ENABLE_IPV6
+ }
+#endif
+
+ priv->channel = g_io_channel_unix_new (sock_fd);
+
+ /* RFC2229 mandates the usage of UTF-8, so we force this encoding */
+ g_io_channel_set_encoding (priv->channel, "UTF-8", NULL);
+
+ g_io_channel_set_line_term (priv->channel, "\r\n", 2);
+
+ /* make sure that the channel is non-blocking */
+ flags = g_io_channel_get_flags (priv->channel);
+ flags |= G_IO_FLAG_NONBLOCK;
+ flags_error = NULL;
+ g_io_channel_set_flags (priv->channel, flags, &flags_error);
+ if (flags_error)
+ {
+ g_set_error (error, GDICT_CLIENT_CONTEXT_ERROR,
+ GDICT_CLIENT_CONTEXT_ERROR_SOCKET,
+ _("Unable to set the channel as non-blocking: %s"),
+ flags_error->message);
+
+ g_error_free (flags_error);
+ g_io_channel_unref (priv->channel);
+
+ return FALSE;
+ }
+
+ /* let the magic begin */
+ sock_res = connect (sock_fd, (struct sockaddr *) &priv->sockaddr, addrlen);
+ if ((sock_res != 0) && (errno != EINPROGRESS))
+ {
+ g_set_error (error, GDICT_CLIENT_CONTEXT_ERROR,
+ GDICT_CLIENT_CONTEXT_ERROR_SOCKET,
+ _("Unable to connect to the dictionary server at '%s:%d'"),
+ priv->hostname,
+ priv->port);
+
+ return FALSE;
+ }
+
+ priv->timeout_id = g_timeout_add (CONNECTION_TIMEOUT * 1000,
+ check_for_connection,
+ context);
+
+ /* XXX - remember that g_io_add_watch() increases the reference count
+ * of the GIOChannel we are using.
+ */
+ priv->source_id = g_io_add_watch (priv->channel,
+ (G_IO_IN | G_IO_ERR),
+ (GIOFunc) gdict_client_context_io_watch_cb,
+ context);
+
+ return TRUE;
+}
+
+static void
+gdict_client_context_disconnect (GdictClientContext *context)
+{
+ GdictCommand *cmd;
+
+ g_return_if_fail (GDICT_IS_CLIENT_CONTEXT (context));
+
+ /* instead of just breaking the connection to the server, we push
+ * a QUIT command on the queue, and wait for every other scheduled
+ * command to perform; this allows the creation of a batch of
+ * commands.
+ */
+ cmd = gdict_command_new (CMD_QUIT);
+ cmd->state = S_FINISH;
+
+ gdict_client_context_push_command (context, cmd);
+}
+
+static gboolean
+gdict_client_context_is_connected (GdictClientContext *context)
+{
+ g_assert (GDICT_IS_CLIENT_CONTEXT (context));
+
+ /* we are in the middle of a connection attempt */
+ if (context->priv->is_connecting)
+ return TRUE;
+
+ return (context->priv->channel != NULL && context->priv->source_id != 0);
+}
+
+static gboolean
+gdict_client_context_get_databases (GdictContext *context,
+ GError **error)
+{
+ GdictClientContext *client_ctx;
+ GdictCommand *cmd;
+
+ g_return_val_if_fail (GDICT_IS_CLIENT_CONTEXT (context), FALSE);
+
+ client_ctx = GDICT_CLIENT_CONTEXT (context);
+
+ if (!gdict_client_context_is_connected (client_ctx))
+ {
+ GError *connect_error = NULL;
+
+ gdict_client_context_connect (client_ctx, &connect_error);
+ if (connect_error)
+ {
+ g_propagate_error (error, connect_error);
+
+ return FALSE;
+ }
+ }
+
+ cmd = gdict_command_new (CMD_SHOW_DB);
+
+ return gdict_client_context_push_command (client_ctx, cmd);
+}
+
+static gboolean
+gdict_client_context_get_strategies (GdictContext *context,
+ GError **error)
+{
+ GdictClientContext *client_ctx;
+ GdictCommand *cmd;
+
+ g_return_val_if_fail (GDICT_IS_CLIENT_CONTEXT (context), FALSE);
+
+ client_ctx = GDICT_CLIENT_CONTEXT (context);
+
+ if (!gdict_client_context_is_connected (client_ctx))
+ {
+ GError *connect_error = NULL;
+
+ gdict_client_context_connect (client_ctx, &connect_error);
+ if (connect_error)
+ {
+ g_propagate_error (error, connect_error);
+
+ return FALSE;
+ }
+ }
+
+ cmd = gdict_command_new (CMD_SHOW_STRAT);
+
+ return gdict_client_context_push_command (client_ctx, cmd);
+}
+
+static gboolean
+gdict_client_context_define_word (GdictContext *context,
+ const gchar *database,
+ const gchar *word,
+ GError **error)
+{
+ GdictClientContext *client_ctx;
+ GdictCommand *cmd;
+
+ g_return_val_if_fail (GDICT_IS_CLIENT_CONTEXT (context), FALSE);
+
+ client_ctx = GDICT_CLIENT_CONTEXT (context);
+
+ if (!gdict_client_context_is_connected (client_ctx))
+ {
+ GError *connect_error = NULL;
+
+ gdict_client_context_connect (client_ctx, &connect_error);
+ if (connect_error)
+ {
+ g_propagate_error (error, connect_error);
+
+ return FALSE;
+ }
+ }
+
+ cmd = gdict_command_new (CMD_DEFINE);
+ cmd->database = g_strdup ((database != NULL ? database : GDICT_DEFAULT_DATABASE));
+ cmd->word = g_utf8_normalize (word, -1, G_NORMALIZE_NFC);
+
+ return gdict_client_context_push_command (client_ctx, cmd);
+}
+
+static gboolean
+gdict_client_context_match_word (GdictContext *context,
+ const gchar *database,
+ const gchar *strategy,
+ const gchar *word,
+ GError **error)
+{
+ GdictClientContext *client_ctx;
+ GdictCommand *cmd;
+
+ g_return_val_if_fail (GDICT_IS_CLIENT_CONTEXT (context), FALSE);
+
+ client_ctx = GDICT_CLIENT_CONTEXT (context);
+
+ if (!gdict_client_context_is_connected (client_ctx))
+ {
+ GError *connect_error = NULL;
+
+ gdict_client_context_connect (client_ctx, &connect_error);
+ if (connect_error)
+ {
+ g_propagate_error (error, connect_error);
+
+ return FALSE;
+ }
+ }
+
+ cmd = gdict_command_new (CMD_MATCH);
+ cmd->database = g_strdup ((database != NULL ? database : GDICT_DEFAULT_DATABASE));
+ cmd->strategy = g_strdup ((strategy != NULL ? strategy : GDICT_DEFAULT_STRATEGY));
+ cmd->word = g_utf8_normalize (word, -1, G_NORMALIZE_NFC);
+
+ return gdict_client_context_push_command (client_ctx, cmd);
+}
diff --git a/mate-dictionary/libgdict/gdict-client-context.h b/mate-dictionary/libgdict/gdict-client-context.h
new file mode 100644
index 00000000..5dbe6ed2
--- /dev/null
+++ b/mate-dictionary/libgdict/gdict-client-context.h
@@ -0,0 +1,98 @@
+/* gdict-server-context.h - Implementation of a dictionary protocol client context
+ *
+ * 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 library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ */
+
+#ifndef __GDICT_CLIENT_CONTEXT_H__
+#define __GDICT_CLIENT_CONTEXT_H__
+
+#include <glib-object.h>
+
+#define GDICT_TYPE_CLIENT_CONTEXT (gdict_client_context_get_type ())
+#define GDICT_CLIENT_CONTEXT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GDICT_TYPE_CLIENT_CONTEXT, GdictClientContext))
+#define GDICT_IS_CLIENT_CONTEXT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GDICT_TYPE_CLIENT_CONTEXT))
+#define GDICT_CLIENT_CONTEXT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GDICT_TYPE_CLIENT_CONTEXT, GdictClientContextClass))
+#define GDICT_CLIENT_CONTEXT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GDICT_TYPE_CLIENT_CONTEXT, GdictClientContextClass))
+
+typedef struct _GdictClientContext GdictClientContext;
+typedef struct _GdictClientContextClass GdictClientContextClass;
+typedef struct _GdictClientContextPrivate GdictClientContextPrivate;
+
+#define GDICT_CLIENT_CONTEXT_ERROR (gdict_client_context_error_quark ())
+
+/**
+ * GdictClientContextError:
+ * @GDICT_CLIENT_CONTEXT_ERROR_SOCKET:
+ * @GDICT_CLIENT_CONTEXT_ERROR_LOOKUP:
+ * @GDICT_CLIENT_CONTEXT_ERROR_NO_CONNECTION:
+ * @GDICT_CLIENT_CONTEXT_ERROR_SERVER_DOWN:
+ *
+ * #GdictClientContext error enumeration
+ */
+typedef enum {
+ GDICT_CLIENT_CONTEXT_ERROR_SOCKET,
+ GDICT_CLIENT_CONTEXT_ERROR_LOOKUP,
+ GDICT_CLIENT_CONTEXT_ERROR_NO_CONNECTION,
+ GDICT_CLIENT_CONTEXT_ERROR_SERVER_DOWN
+} GdictClientContextError;
+
+GQuark gdict_client_context_error_quark (void);
+
+struct _GdictClientContext
+{
+ /*< private >*/
+ GObject parent_instance;
+
+ GdictClientContextPrivate *priv;
+};
+
+struct _GdictClientContextClass
+{
+ /*< private >*/
+ GObjectClass parent_class;
+
+ /*< public >*/
+ /* signals monitoring the lifetime of the connection with
+ * the dictionary server
+ */
+ void (*connected) (GdictClientContext *context);
+ void (*disconnected) (GdictClientContext *context);
+
+ /*< private >*/
+ /* padding for future expansion */
+ void (*_gdict_client_1) (void);
+ void (*_gdict_client_2) (void);
+ void (*_gdict_client_3) (void);
+ void (*_gdict_client_4) (void);
+};
+
+GType gdict_client_context_get_type (void) G_GNUC_CONST;
+
+GdictContext * gdict_client_context_new (const gchar *hostname,
+ gint port);
+
+void gdict_client_context_set_hostname (GdictClientContext *context,
+ const gchar *hostname);
+const gchar *gdict_client_context_get_hostname (GdictClientContext *context);
+void gdict_client_context_set_port (GdictClientContext *context,
+ gint port);
+guint gdict_client_context_get_port (GdictClientContext *context);
+void gdict_client_context_set_client (GdictClientContext *context,
+ const gchar *client);
+const gchar *gdict_client_context_get_client (GdictClientContext *context);
+
+#endif /* __GDICT_CLIENT_CONTEXT_H__ */
diff --git a/mate-dictionary/libgdict/gdict-context-private.h b/mate-dictionary/libgdict/gdict-context-private.h
new file mode 100644
index 00000000..24ea463a
--- /dev/null
+++ b/mate-dictionary/libgdict/gdict-context-private.h
@@ -0,0 +1,107 @@
+/* gdict-private.h - Private definitions for Gdict
+ *
+ * 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 library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ */
+
+#ifndef __GDICT_PRIVATE_H__
+#define __GDICT_PRIVATE_H__
+
+#ifndef GDICT_ENABLE_INTERNALS
+#error "You are trying to access Gdict's internals outside Gdict. The API of these internal functions is not fixed."
+#endif
+
+#include <glib-object.h>
+
+#include "gdict-context.h"
+
+G_BEGIN_DECLS
+
+/* boilerplate code, similar to G_DEFINE_TYPE in spirit, used to define
+ * our boxed types and their ref/unref functions; you still have to
+ * implement your own ref/unref functions!
+ */
+#define GDICT_DEFINE_BOXED_TYPE(TypeName,type_name) \
+\
+static gpointer type_name##_intern_ref (gpointer self) \
+{ \
+ return type_name##_ref ((TypeName *) self); \
+} \
+static void type_name##_intern_unref (gpointer self) \
+{ \
+ type_name##_unref ((TypeName *) self); \
+} \
+\
+GType \
+type_name##_get_type (void) \
+{ \
+ static GType gdict_define_boxed_type = 0; \
+ if (G_UNLIKELY (gdict_define_boxed_type == 0)) \
+ gdict_define_boxed_type = g_boxed_type_register_static (#TypeName, (GBoxedCopyFunc) type_name##_intern_ref, (GBoxedFreeFunc) type_name##_intern_unref); \
+ return gdict_define_boxed_type; \
+}
+
+/* Never, _ever_ access the members of these structures, unless you
+ * know what you are doing.
+ */
+
+struct _GdictDatabase
+{
+ gchar *name;
+ gchar *full_name;
+ 
+ guint ref_count;
+};
+
+struct _GdictStrategy
+{
+ gchar *name;
+ gchar *description;
+ 
+ guint ref_count;
+};
+
+struct _GdictMatch
+{
+ gchar *database;
+ gchar *word;
+ 
+ guint ref_count;
+};
+
+struct _GdictDefinition
+{
+ gint total;
+ 
+ gchar *word;
+ gchar *database_name;
+ gchar *database_full;
+ gchar *definition;
+ 
+ guint ref_count;
+};
+
+/* constructors for these objects are private, as the world outside do
+ * not know what they hold, and accessor functions are getters only
+ */
+GdictDatabase * _gdict_database_new (const gchar *name);
+GdictStrategy * _gdict_strategy_new (const gchar *name);
+GdictMatch * _gdict_match_new (const gchar *word);
+GdictDefinition * _gdict_definition_new (gint total);
+
+G_END_DECLS
+
+#endif /* __GDICT_PRIVATE_H__ */
diff --git a/mate-dictionary/libgdict/gdict-context.c b/mate-dictionary/libgdict/gdict-context.c
new file mode 100644
index 00000000..4566bc1a
--- /dev/null
+++ b/mate-dictionary/libgdict/gdict-context.c
@@ -0,0 +1,892 @@
+/* gdict-context.c - Abstract class for dictionary contexts
+ *
+ * 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 library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ */
+
+/**
+ * SECTION:gdict-context
+ * @short_description: Interface for dictionary transports
+ *
+ * #GdictContext is an interface used to uniformly access dictionary
+ * transport objects. Each implementation of #GdictContext must provide
+ * functions for accessing the list of databases available on a dictionary
+ * source and the available matching strategies; a function for retrieving
+ * all words matching a given string, inside one (or more) of those databases
+ * and using one of those strategies; a function for querying one (or more)
+ * of those databases for a definition of a word.
+ *
+ * Implementations of the #GdictContext interface should query their
+ * dictionary sources asynchronously; methods of the #GdictContext interface
+ * should return immediately, and each time a new database, strategy, match
+ * or definition has been found, a signal should be fired by those
+ * implementations.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <glib/gi18n-lib.h>
+
+#include "gdict-context.h"
+#include "gdict-enum-types.h"
+#include "gdict-utils.h"
+#include "gdict-marshal.h"
+#include "gdict-context-private.h"
+#include "gdict-private.h"
+
+
+static void gdict_context_class_init (gpointer g_iface);
+
+
+GType
+gdict_context_get_type (void)
+{
+ static GType context_type = 0;
+
+ if (G_UNLIKELY (context_type == 0))
+ {
+ static GTypeInfo context_info =
+ {
+ sizeof (GdictContextIface),
+ NULL, /* base_init */
+ NULL, /* base_finalize */
+ (GClassInitFunc) gdict_context_class_init,
+ };
+
+ context_type = g_type_register_static (G_TYPE_INTERFACE,
+ "GdictContext",
+ &context_info, 0);
+ g_type_interface_add_prerequisite (context_type, G_TYPE_OBJECT);
+ }
+
+ return context_type;
+}
+
+
+static void
+gdict_context_class_init (gpointer g_iface)
+{
+ GType iface_type = G_TYPE_FROM_INTERFACE (g_iface);
+
+ /**
+ * GdictContext::lookup-start
+ * @context: the object which received the signal
+ *
+ * This signal is emitted when a look up operation has been issued using
+ * a #GdictContext. Since every operation using a context is
+ * asynchronous, you can use this signal to know if the request has been
+ * issued or not.
+ *
+ * Since: 1.0
+ */
+ g_signal_new ("lookup-start",
+ iface_type,
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (GdictContextIface, lookup_start),
+ NULL, NULL,
+ gdict_marshal_VOID__VOID,
+ G_TYPE_NONE, 0);
+ /**
+ * GdictContext::lookup-end
+ * @context: the object which received the signal
+ *
+ * This signal is emitted when a look up operation that has been issued
+ * using a #GdictContext has been completed. Since every operation using a
+ * context is asynchronous, you can use this signal to know if the request
+ * has been completed or not.
+ *
+ * Since: 1.0
+ */
+ g_signal_new ("lookup-end",
+ iface_type,
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (GdictContextIface, lookup_end),
+ NULL, NULL,
+ gdict_marshal_VOID__VOID,
+ G_TYPE_NONE, 0);
+ /**
+ * GdictContext::error
+ * @context: the object which received the signal
+ * @error: a #GError
+ *
+ * This signal is emitted when an error happened during an asynchronous
+ * request.
+ *
+ * Since: 1.0
+ */
+ g_signal_new ("error",
+ iface_type,
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (GdictContextIface, error),
+ NULL, NULL,
+ gdict_marshal_VOID__POINTER,
+ G_TYPE_NONE, 1,
+ G_TYPE_POINTER);
+ /**
+ * GdictContext::database-found
+ * @context: the object which received the signal
+ * @database: a #GdictDatabase
+ *
+ * This signal is emitted when a database request has found a database.
+ *
+ * Since: 1.0
+ */
+ g_signal_new ("database-found",
+ iface_type,
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (GdictContextIface, database_found),
+ NULL, NULL,
+ gdict_marshal_VOID__BOXED,
+ G_TYPE_NONE, 1,
+ GDICT_TYPE_DATABASE);
+ /**
+ * GdictContext::strategy-found
+ * @context: the object which received the signal
+ * @strategy: a #GdictStrategy
+ *
+ * This signal is emitted when a strategy request has found a strategy.
+ *
+ * Since: 1.0
+ */
+ g_signal_new ("strategy-found",
+ iface_type,
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (GdictContextIface, strategy_found),
+ NULL, NULL,
+ gdict_marshal_VOID__BOXED,
+ G_TYPE_NONE, 1,
+ GDICT_TYPE_STRATEGY);
+ /**
+ * GdictContext::match-found
+ * @context: the object which received the signal
+ * @match: a #GdictMatch
+ *
+ * This signal is emitted when a match request has found a match.
+ *
+ * Since: 1.0
+ */
+ g_signal_new ("match-found",
+ iface_type,
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (GdictContextIface, match_found),
+ NULL, NULL,
+ gdict_marshal_VOID__BOXED,
+ G_TYPE_NONE, 1,
+ GDICT_TYPE_MATCH);
+ /**
+ * GdictContext::definition-found
+ * @context: the object which received the signal
+ * @definition: a #GdictDefinition
+ *
+ * This signal is emitted when a definition request has found a definition.
+ *
+ * Since: 1.0
+ */
+ g_signal_new ("definition-found",
+ iface_type,
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (GdictContextIface, definition_found),
+ NULL, NULL,
+ gdict_marshal_VOID__BOXED,
+ G_TYPE_NONE, 1,
+ GDICT_TYPE_DEFINITION);
+
+ /**
+ * GdictContext:local-only
+ *
+ * Whether the context uses only local dictionaries or not.
+ *
+ * Since: 1.0
+ */
+ g_object_interface_install_property (g_iface,
+ g_param_spec_boolean ("local-only",
+ _("Local Only"),
+ _("Whether the context uses only local dictionaries or not"),
+ FALSE,
+ (G_PARAM_READABLE | G_PARAM_WRITABLE)));
+}
+
+GQuark
+gdict_context_error_quark (void)
+{
+ return g_quark_from_static_string ("gdict-context-error-quark");
+}
+
+/**
+ * gdict_context_set_local_only:
+ * @context: a #GdictContext
+ * @local_only: %TRUE if only local resources will be used
+ *
+ * Sets whether only local resources will be used when querying for databases,
+ * strategies, matches or definitions.
+ *
+ * Since: 1.0
+ */
+void
+gdict_context_set_local_only (GdictContext *context,
+ gboolean local_only)
+{
+ g_return_if_fail (GDICT_IS_CONTEXT (context));
+
+ g_object_set (context, "local-only", &local_only, NULL);
+}
+
+/**
+ * gdict_context_get_local_only:
+ * @context: a #GdictContext
+ *
+ * Gets whether only local resources will be used when querying.
+ *
+ * Return value: %TRUE if only local resources will be used.
+ *
+ * Since: 1.0
+ */
+gboolean
+gdict_context_get_local_only (GdictContext *context)
+{
+ gboolean local_only;
+
+ g_return_val_if_fail (GDICT_IS_CONTEXT (context), FALSE);
+
+ g_object_get (context, "local-only", &local_only, NULL);
+
+ return local_only;
+}
+
+/**
+ * gdict_context_lookup_databases:
+ * @context: a #GdictContext
+ * @error: return location for a #GError, or %NULL
+ *
+ * Query @context for the list of databases available. Each time a
+ * database is found, the "database-found" signal is fired.
+ *
+ * Return value: %TRUE if the query was successfully started.
+ *
+ * Since: 1.0
+ */
+gboolean
+gdict_context_lookup_databases (GdictContext *context,
+ GError **error)
+{
+ g_return_val_if_fail (GDICT_IS_CONTEXT (context), FALSE);
+
+ if (!GDICT_CONTEXT_GET_IFACE (context)->get_databases)
+ {
+ g_warning ("Object `%s' does not implement the get_databases "
+ "virtual function.",
+ g_type_name (G_OBJECT_TYPE (context)));
+
+ return FALSE;
+ }
+
+ return GDICT_CONTEXT_GET_IFACE (context)->get_databases (context, error);
+}
+
+/**
+ * gdict_context_lookup_strategies:
+ * @context: a #GdictContext
+ * @error: return location for a #GError, or %NULL
+ *
+ * Query @context for the list of matching strategies available. Each
+ * time a new strategy is found, the "strategy-found" signal is fired.
+ *
+ * Return value: %TRUE if the query was successfully started.
+ *
+ * Since: 1.0
+ */
+gboolean
+gdict_context_lookup_strategies (GdictContext *context,
+ GError **error)
+{
+ g_return_val_if_fail (GDICT_IS_CONTEXT (context), FALSE);
+
+ if (!GDICT_CONTEXT_GET_IFACE (context)->get_strategies)
+ {
+ g_warning ("Object `%s' does not implement the get_strategies "
+ "virtual function.",
+ g_type_name (G_OBJECT_TYPE (context)));
+
+ return FALSE;
+ }
+
+ return GDICT_CONTEXT_GET_IFACE (context)->get_strategies (context, error);
+}
+
+/**
+ * gdict_context_match_word:
+ * @context: a #GdictContext
+ * @database: a database name to search into, or %NULL for the
+ * default database
+ * @strategy: a strategy name to use for matching, or %NULL for
+ * the default strategy
+ * @word: the word to match
+ * @error: return location for a #GError, or %NULL
+ *
+ * Query @context for a list of word matching @word inside @database,
+ * using @strategy as a matching strategy. Each time a matching word
+ * is found, the "match-found" signal is fired.
+ *
+ * Return value: %TRUE if the query was successfully started.
+ *
+ * Since: 1.0
+ */
+gboolean
+gdict_context_match_word (GdictContext *context,
+ const gchar *database,
+ const gchar *strategy,
+ const gchar *word,
+ GError **error)
+{
+ g_return_val_if_fail (GDICT_IS_CONTEXT (context), FALSE);
+ g_return_val_if_fail (word != NULL, FALSE);
+
+ if (!GDICT_CONTEXT_GET_IFACE (context)->match_word)
+ {
+ g_warning ("Object `%s' does not implement the match_word "
+ "virtual function.",
+ g_type_name (G_OBJECT_TYPE (context)));
+
+ return FALSE;
+ }
+
+ return GDICT_CONTEXT_GET_IFACE (context)->match_word (context,
+ database,
+ strategy,
+ word,
+ error);
+}
+
+/**
+ * gdict_context_define_word:
+ * @context: a #GdictContext
+ * @database: a database name to search into, or %NULL for the
+ * default database
+ * @word: the word to search
+ * @error: return location for a #GError, or %NULL
+ *
+ * Query @context for a list of definitions of @word inside @database. Each
+ * time a new definition is found, the "definition-found" signal is fired.
+ *
+ * Return value: %TRUE if the query was successfully sent.
+ *
+ * Since: 1.0
+ */
+gboolean
+gdict_context_define_word (GdictContext *context,
+ const gchar *database,
+ const gchar *word,
+ GError **error)
+{
+ g_return_val_if_fail (GDICT_IS_CONTEXT (context), FALSE);
+ g_return_val_if_fail (word != NULL, FALSE);
+
+ if (!GDICT_CONTEXT_GET_IFACE (context)->define_word)
+ {
+ g_warning ("Object `%s' does not implement the define_word "
+ "virtual function.",
+ g_type_name (G_OBJECT_TYPE (context)));
+
+ return FALSE;
+ }
+
+ return GDICT_CONTEXT_GET_IFACE (context)->define_word (context,
+ database,
+ word,
+ error);
+}
+
+
+
+/*****************
+ * GdictDatabase *
+ *****************/
+
+GDICT_DEFINE_BOXED_TYPE (GdictDatabase, gdict_database);
+
+GdictDatabase *
+_gdict_database_new (const gchar *name)
+{
+ GdictDatabase *retval;
+
+ g_return_val_if_fail (name != NULL, NULL);
+
+ retval = g_slice_new (GdictDatabase);
+ retval->name = g_strdup (name);
+ retval->full_name = NULL;
+ retval->ref_count = 1;
+
+ return retval;
+}
+
+/**
+ * gdict_database_ref:
+ * @db: a #GdictDatabase
+ *
+ * Increases the reference count of @db by one.
+ *
+ * Return value: @db with its reference count increased
+ *
+ * Since: 1.0
+ */
+GdictDatabase *
+gdict_database_ref (GdictDatabase *db)
+{
+ g_return_val_if_fail (db != NULL, NULL);
+
+ g_assert (db->ref_count != 0);
+
+ db->ref_count += 1;
+
+ return db;
+}
+
+/**
+ * gdict_database_unref:
+ * @db: a #GdictDatabase
+ *
+ * Decreases the reference count of @db by one. If the reference count reaches
+ * zero, @db is destroyed.
+ *
+ * Since: 1.0
+ */
+void
+gdict_database_unref (GdictDatabase *db)
+{
+ g_return_if_fail (db != NULL);
+
+ g_assert (db->ref_count != 0);
+
+ db->ref_count -= 1;
+ if (db->ref_count == 0)
+ {
+ g_free (db->name);
+ g_free (db->full_name);
+
+ g_slice_free (GdictDatabase, db);
+ }
+}
+
+/**
+ * gdict_database_get_name:
+ * @db: a #GdictDatabase
+ *
+ * Gets the short name of the database, to be used with functions like
+ * gdict_context_match_word() or gdict_context_define_word().
+ *
+ * Return value: the short name of the database. The string is owned by
+ * the #GdictDatabase object, and should never be modified or freed.
+ *
+ * Since: 1.0
+ */
+const gchar *
+gdict_database_get_name (GdictDatabase *db)
+{
+ g_return_val_if_fail (db != NULL, NULL);
+
+ return db->name;
+}
+
+/**
+ * gdict_database_get_full_name:
+ * @db: a #GdictDatabase
+ *
+ * Gets the full name of the database, suitable for display.
+ *
+ * Return value: the full name of the database. The string is owned by
+ * the #GdictDatabase object, and should never be modified or freed.
+ *
+ * Since: 1.0
+ */
+const gchar *
+gdict_database_get_full_name (GdictDatabase *db)
+{
+ g_return_val_if_fail (db != NULL, NULL);
+
+ return db->full_name;
+}
+
+
+
+/*****************
+ * GdictStrategy *
+ *****************/
+
+GDICT_DEFINE_BOXED_TYPE (GdictStrategy, gdict_strategy);
+
+GdictStrategy *
+_gdict_strategy_new (const gchar *name)
+{
+ GdictStrategy *strat;
+
+ g_return_val_if_fail (name != NULL, NULL);
+
+ strat = g_slice_new (GdictStrategy);
+ strat->name = g_strdup (name);
+ strat->description = NULL;
+ strat->ref_count = 1;
+
+ return strat;
+}
+
+/**
+ * gdict_strategy_ref:
+ * @strat: a #GdictStrategy
+ *
+ * Increases the reference count of @strat by one.
+ *
+ * Return value: the #GdictStrategy object with its reference count
+ * increased
+ *
+ * Since: 1.0
+ */
+GdictStrategy *
+gdict_strategy_ref (GdictStrategy *strat)
+{
+ g_return_val_if_fail (strat != NULL, NULL);
+
+ g_assert (strat->ref_count != 0);
+
+ strat->ref_count += 1;
+
+ return strat;
+}
+
+/**
+ * gdict_strategy_unref:
+ * @strat: a #GdictStrategy
+ *
+ * Decreases the reference count of @strat by one. If the reference count
+ * reaches zero, the #GdictStrategy object is freed.
+ *
+ * Since: 1.0
+ */
+void
+gdict_strategy_unref (GdictStrategy *strat)
+{
+ g_return_if_fail (strat != NULL);
+
+ g_assert (strat->ref_count != 0);
+
+ strat->ref_count -= 1;
+ if (strat->ref_count == 0)
+ {
+ g_free (strat->name);
+ g_free (strat->description);
+
+ g_slice_free (GdictStrategy, strat);
+ }
+}
+
+/**
+ * gdict_strategy_get_name:
+ * @strat: a #GdictStrategy
+ *
+ * FIXME
+ *
+ * Return value: FIXME
+ *
+ * Since: 1.0
+ */
+const gchar *
+gdict_strategy_get_name (GdictStrategy *strat)
+{
+ g_return_val_if_fail (strat != NULL, NULL);
+
+ return strat->name;
+}
+
+/**
+ * gdict_strategy_get_description:
+ * @strat: a #GdictStrategy
+ *
+ * FIXME
+ *
+ * Return value: FIXME
+ *
+ * Since: 1.0
+ */
+const gchar *
+gdict_strategy_get_description (GdictStrategy *strat)
+{
+ g_return_val_if_fail (strat != NULL, NULL);
+
+ return strat->description;
+}
+
+
+
+/**************
+ * GdictMatch *
+ **************/
+
+GDICT_DEFINE_BOXED_TYPE (GdictMatch, gdict_match);
+
+GdictMatch *
+_gdict_match_new (const gchar *word)
+{
+ GdictMatch *match;
+
+ g_return_val_if_fail (word != NULL, NULL);
+
+ match = g_slice_new (GdictMatch);
+ match->word = g_strdup (word);
+ match->database = NULL;
+ match->ref_count = 1;
+
+ return match;
+}
+
+/**
+ * gdict_match_ref:
+ * @match: a #GdictMatch
+ *
+ * FIXME
+ *
+ * Return value: FIXME
+ *
+ * Since: 1.0
+ */
+GdictMatch *
+gdict_match_ref (GdictMatch *match)
+{
+ g_return_val_if_fail (match != NULL, NULL);
+
+ g_assert (match->ref_count != 0);
+
+ match->ref_count += 1;
+
+ return match;
+}
+
+/**
+ * gdict_match_unref:
+ * @match: a #GdictMatch
+ *
+ * FIXME
+ *
+ * Since: 1.0
+ */
+void
+gdict_match_unref (GdictMatch *match)
+{
+ g_return_if_fail (match != NULL);
+
+ g_assert (match->ref_count != 0);
+
+ match->ref_count -= 1;
+
+ if (match->ref_count == 0)
+ {
+ g_free (match->word);
+ g_free (match->database);
+
+ g_slice_free (GdictMatch, match);
+ }
+}
+
+/**
+ * gdict_match_get_word:
+ * @match: a #GdictMatch
+ *
+ * FIXME
+ *
+ * Return value: FIXME
+ *
+ * Since: 1.0
+ */
+const gchar *
+gdict_match_get_word (GdictMatch *match)
+{
+ g_return_val_if_fail (match != NULL, NULL);
+
+ return match->word;
+}
+
+/**
+ * gdict_match_get_database:
+ * @match: a #GdictMatch
+ *
+ * FIXME
+ *
+ * Return value: FIXME
+ *
+ * Since: 1.0
+ */
+const gchar *
+gdict_match_get_database (GdictMatch *match)
+{
+ g_return_val_if_fail (match != NULL, NULL);
+
+ return match->database;
+}
+
+
+
+/*******************
+ * GdictDefinition *
+ *******************/
+
+GDICT_DEFINE_BOXED_TYPE (GdictDefinition, gdict_definition);
+
+/* GdictDefinition constructor */
+GdictDefinition *
+_gdict_definition_new (gint total)
+{
+ GdictDefinition *def;
+
+ def = g_slice_new (GdictDefinition);
+
+ def->total = total;
+ def->word = NULL;
+ def->database_name = NULL;
+ def->database_full = NULL;
+ def->ref_count = 1;
+
+ return def;
+}
+
+/**
+ * gdict_definition_ref:
+ * @def: a #GdictDefinition
+ *
+ * Increases the reference count of @def by one.
+ *
+ * Return value: the #GdictDefinition object with its reference count
+ * increased.
+ *
+ * Since: 1.0
+ */
+GdictDefinition *
+gdict_definition_ref (GdictDefinition *def)
+{
+ g_return_val_if_fail (def != NULL, NULL);
+
+ g_assert (def->ref_count != 0);
+
+ def->ref_count += 1;
+
+ return def;
+}
+
+/**
+ * gdict_definition_unref:
+ * @def: a #GdictDefinition
+ *
+ * Decreases the reference count of @def by one. If the reference count
+ * reaches zero, the #GdictDefinition object is freed.
+ *
+ * Since: 1.0
+ */
+void
+gdict_definition_unref (GdictDefinition *def)
+{
+ g_return_if_fail (def != NULL);
+
+ g_assert (def->ref_count != 0);
+
+ def->ref_count -= 1;
+ if (def->ref_count == 0)
+ {
+ g_free (def->word);
+ g_free (def->database_name);
+ g_free (def->database_full);
+
+ g_slice_free (GdictDefinition, def);
+ }
+}
+
+/**
+ * gdict_definition_get_total:
+ * @def: a #GdictDefinition
+ *
+ * Retrieves the total number of definitions that were found on a
+ * dictionary.
+ *
+ * Return value: the number of definitions.
+ *
+ * Since: 1.0
+ */
+gint
+gdict_definition_get_total (GdictDefinition *def)
+{
+ g_return_val_if_fail (def != NULL, -1);
+
+ return def->total;
+}
+
+/**
+ * gdict_definition_get_word:
+ * @def: a #GdictDefinition
+ *
+ * Retrieves the word used by the dictionary database to store
+ * the definition.
+ *
+ * Return value: a word. The returned string is owned by the
+ * #GdictDefinition object and should not be modified or freed.
+ *
+ * Since: 1.0
+ */
+const gchar *
+gdict_definition_get_word (GdictDefinition *def)
+{
+ g_return_val_if_fail (def != NULL, NULL);
+
+ return def->word;
+}
+
+/**
+ * gdict_definition_get_database:
+ * @def: a #GdictDefinition
+ *
+ * Retrieves the full name of the dictionary database where the
+ * definition is stored.
+ *
+ * Return value: the full name of a database. The returned string
+ * is owned by the #GdictDefinition object and should not be
+ * modified or freed.
+ *
+ * Since: 1.0
+ */
+const gchar *
+gdict_definition_get_database (GdictDefinition *def)
+{
+ g_return_val_if_fail (def != NULL, NULL);
+
+ return def->database_full;
+}
+
+/**
+ * gdict_definition_get_text:
+ * @def: a #GdictDefinition
+ *
+ * Retrieves the text of the definition.
+ *
+ * Return value: the text of the definition. The returned string
+ * is owned by the #GdictDefinition object, and should not be
+ * modified or freed.
+ *
+ * Since: 1.0
+ */
+const gchar *
+gdict_definition_get_text (GdictDefinition *def)
+{
+ g_return_val_if_fail (def != NULL, NULL);
+
+ return def->definition;
+}
diff --git a/mate-dictionary/libgdict/gdict-context.h b/mate-dictionary/libgdict/gdict-context.h
new file mode 100644
index 00000000..974a820b
--- /dev/null
+++ b/mate-dictionary/libgdict/gdict-context.h
@@ -0,0 +1,204 @@
+/* gdict-context.h - Abstract class for dictionary contexts
+ *
+ * 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 library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ */
+
+#ifndef __GDICT_CONTEXT_H__
+#define __GDICT_CONTEXT_H__
+
+#include <glib-object.h>
+
+G_BEGIN_DECLS
+
+#define GDICT_TYPE_DATABASE (gdict_database_get_type ())
+#define GDICT_TYPE_STRATEGY (gdict_strategy_get_type ())
+#define GDICT_TYPE_MATCH (gdict_match_get_type ())
+#define GDICT_TYPE_DEFINITION (gdict_definition_get_type ())
+
+#define GDICT_TYPE_CONTEXT (gdict_context_get_type ())
+#define GDICT_CONTEXT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GDICT_TYPE_CONTEXT, GdictContext))
+#define GDICT_IS_CONTEXT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GDICT_TYPE_CONTEXT))
+#define GDICT_CONTEXT_GET_IFACE(inst) (G_TYPE_INSTANCE_GET_INTERFACE ((inst), GDICT_TYPE_CONTEXT, GdictContextIface))
+
+/* These are the boxed containers for action results. */
+typedef struct _GdictDatabase GdictDatabase;
+typedef struct _GdictStrategy GdictStrategy;
+typedef struct _GdictMatch GdictMatch;
+typedef struct _GdictDefinition GdictDefinition;
+
+typedef struct _GdictContext GdictContext; /* dummy typedef */
+typedef struct _GdictContextIface GdictContextIface;
+
+#define GDICT_CONTEXT_ERROR (gdict_context_error_quark ())
+
+/**
+ * GdictContextError:
+ * @GDICT_CONTEXT_ERROR_PARSE:
+ * @GDICT_CONTEXT_ERROR_NOT_IMPLEMENTED:
+ * @GDICT_CONTEXT_ERROR_INVALID_DATABASE:
+ * @GDICT_CONTEXT_ERROR_INVALID_STRATEGY:
+ * @GDICT_CONTEXT_ERROR_INVALID_COMMAND:
+ * @GDICT_CONTEXT_ERROR_NO_MATCH:
+ * @GDICT_CONTEXT_ERROR_NO_DATABASES:
+ * @GDICT_CONTEXT_ERROR_NO_STRATEGIES:
+ *
+ * #GdictContext error enumeration.
+ */
+typedef enum {
+ GDICT_CONTEXT_ERROR_PARSE,
+ GDICT_CONTEXT_ERROR_NOT_IMPLEMENTED,
+ GDICT_CONTEXT_ERROR_INVALID_DATABASE,
+ GDICT_CONTEXT_ERROR_INVALID_STRATEGY,
+ GDICT_CONTEXT_ERROR_INVALID_COMMAND,
+ GDICT_CONTEXT_ERROR_NO_MATCH,
+ GDICT_CONTEXT_ERROR_NO_DATABASES,
+ GDICT_CONTEXT_ERROR_NO_STRATEGIES
+} GdictContextError;
+
+GQuark gdict_context_error_quark (void);
+
+/**
+ * GdictDatabase:
+ *
+ * A #GdictDatabase represents a database inside a dictionary source.
+ *
+ * The #GdictDatabase structure is private and should only be accessed
+ * using the available functions.
+ */
+GType gdict_database_get_type (void) G_GNUC_CONST;
+GdictDatabase * gdict_database_ref (GdictDatabase *db);
+void gdict_database_unref (GdictDatabase *db);
+const gchar *gdict_database_get_name (GdictDatabase *db);
+const gchar *gdict_database_get_full_name (GdictDatabase *db);
+
+/**
+ * GdictStrategy:
+ *
+ * A #GdictStrategy represents a matching strategy implemented by
+ * a dictionary source.
+ *
+ * The #GdictStrategy structure is private and should only be accessed
+ * using the available functions.
+ */
+GType gdict_strategy_get_type (void) G_GNUC_CONST;
+GdictStrategy * gdict_strategy_ref (GdictStrategy *strat);
+void gdict_strategy_unref (GdictStrategy *strat);
+const gchar *gdict_strategy_get_name (GdictStrategy *strat);
+const gchar *gdict_strategy_get_description (GdictStrategy *strat);
+
+/**
+ * GdictMatch:
+ *
+ * A #GdictMatch represents a single match for the searched word.
+ *
+ * The #GdictMatch structure is private and should only be accessed
+ * using the available functions.
+ */
+GType gdict_match_get_type (void) G_GNUC_CONST;
+GdictMatch * gdict_match_ref (GdictMatch *match);
+void gdict_match_unref (GdictMatch *match);
+const gchar *gdict_match_get_word (GdictMatch *match);
+const gchar *gdict_match_get_database (GdictMatch *match);
+
+/**
+ * GdictDefinition:
+ *
+ * A #GdictDefinition represents a single definition for the searched
+ * word.
+ *
+ * The #GdictDefinition structure is private and should only be
+ * accessed using the available functions.
+ */
+GType gdict_definition_get_type (void) G_GNUC_CONST;
+GdictDefinition * gdict_definition_ref (GdictDefinition *def);
+void gdict_definition_unref (GdictDefinition *def);
+gint gdict_definition_get_total (GdictDefinition *def);
+const gchar *gdict_definition_get_word (GdictDefinition *def);
+const gchar *gdict_definition_get_database (GdictDefinition *def);
+const gchar *gdict_definition_get_text (GdictDefinition *def);
+
+/**
+ * GdictContextIface:
+ *
+ * Interface defintion
+ */
+struct _GdictContextIface
+{
+ /*< private >*/
+ GTypeInterface base_iface;
+
+ /*< public >*/
+ /* methods, not signals */
+ gboolean (*get_databases) (GdictContext *context,
+ GError **error);
+ gboolean (*get_strategies) (GdictContext *context,
+ GError **error);
+ gboolean (*match_word) (GdictContext *context,
+ const gchar *database,
+ const gchar *strategy,
+ const gchar *word,
+ GError **error);
+ gboolean (*define_word) (GdictContext *context,
+ const gchar *database,
+ const gchar *word,
+ GError **error);
+
+ /* signals */
+ void (*lookup_start) (GdictContext *context);
+ void (*lookup_end) (GdictContext *context);
+
+ void (*database_found) (GdictContext *context,
+ GdictDatabase *database);
+ void (*strategy_found) (GdictContext *context,
+ GdictStrategy *strategy);
+ void (*match_found) (GdictContext *context,
+ GdictMatch *match);
+ void (*definition_found) (GdictContext *context,
+ GdictDefinition *definition);
+
+ /* fired each time there's an error; the GError is owned
+ * by the context, and should never be modified or freed
+ */
+ void (*error) (GdictContext *context,
+ const GError *error);
+};
+
+GType gdict_context_get_type (void) G_GNUC_CONST;
+
+/* Configuration */
+void gdict_context_set_local_only (GdictContext *context,
+ gboolean local_only);
+gboolean gdict_context_get_local_only (GdictContext *context);
+
+/* Actions */
+gboolean gdict_context_lookup_databases (GdictContext *context,
+ GError **error);
+gboolean gdict_context_lookup_strategies (GdictContext *context,
+ GError **error);
+gboolean gdict_context_match_word (GdictContext *context,
+ const gchar *database,
+ const gchar *strategy,
+ const gchar *word,
+ GError **error);
+gboolean gdict_context_define_word (GdictContext *context,
+ const gchar *database,
+ const gchar *word,
+ GError **error);
+
+G_END_DECLS
+
+#endif /* __GDICT_CONTEXT_H__ */
diff --git a/mate-dictionary/libgdict/gdict-database-chooser.c b/mate-dictionary/libgdict/gdict-database-chooser.c
new file mode 100644
index 00000000..475b150b
--- /dev/null
+++ b/mate-dictionary/libgdict/gdict-database-chooser.c
@@ -0,0 +1,1142 @@
+/* gdict-database-chooser.c - display widget for database names
+ *
+ * Copyright (C) 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 library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ */
+
+/**
+ * SECTION:gdict-database-chooser
+ * @short_description: Display the list of available databases
+ *
+ * Each #GdictContext has a list of databases, that is dictionaries that
+ * can be queried. #GdictDatabaseChooser is a widget that queries a given
+ * #GdictContext and displays the list of available databases.
+ *
+ * #GdictDatabaseChooser is available since Gdict 0.10
+ */
+
+#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-lib.h>
+
+#include "gdict-database-chooser.h"
+#include "gdict-utils.h"
+#include "gdict-debug.h"
+#include "gdict-private.h"
+#include "gdict-enum-types.h"
+#include "gdict-marshal.h"
+
+#define GDICT_DATABASE_CHOOSER_GET_PRIVATE(obj) \
+(G_TYPE_INSTANCE_GET_PRIVATE ((obj), GDICT_TYPE_DATABASE_CHOOSER, GdictDatabaseChooserPrivate))
+
+struct _GdictDatabaseChooserPrivate
+{
+ GtkListStore *store;
+
+ GtkWidget *treeview;
+ GtkWidget *clear_button;
+ GtkWidget *refresh_button;
+ GtkWidget *buttons_box;
+ 
+ GdictContext *context;
+ gint results;
+
+ guint start_id;
+ guint match_id;
+ guint end_id;
+ guint error_id;
+
+ GdkCursor *busy_cursor;
+
+ gchar *current_db;
+
+ guint is_searching : 1;
+};
+
+enum
+{
+ DATABASE_NAME,
+ DATABASE_ERROR
+} DBType;
+
+enum
+{
+ DB_COLUMN_TYPE,
+ DB_COLUMN_NAME,
+ DB_COLUMN_DESCRIPTION,
+ DB_COLUMN_CURRENT,
+
+ DB_N_COLUMNS
+};
+
+enum
+{
+ PROP_0,
+ 
+ PROP_CONTEXT,
+ PROP_COUNT
+};
+
+enum
+{
+ DATABASE_ACTIVATED,
+ SELECTION_CHANGED,
+
+ LAST_SIGNAL
+};
+
+static guint db_chooser_signals[LAST_SIGNAL] = { 0 };
+
+G_DEFINE_TYPE (GdictDatabaseChooser,
+ gdict_database_chooser,
+ GTK_TYPE_VBOX);
+
+
+static void
+set_gdict_context (GdictDatabaseChooser *chooser,
+ GdictContext *context)
+{
+ GdictDatabaseChooserPrivate *priv;
+ 
+ g_assert (GDICT_IS_DATABASE_CHOOSER (chooser));
+ priv = chooser->priv;
+ 
+ if (priv->context)
+ {
+ if (priv->start_id)
+ {
+ GDICT_NOTE (CHOOSER, "Removing old context handlers");
+ 
+ g_signal_handler_disconnect (priv->context, priv->start_id);
+ g_signal_handler_disconnect (priv->context, priv->match_id);
+ g_signal_handler_disconnect (priv->context, priv->end_id);
+ 
+ priv->start_id = 0;
+ priv->end_id = 0;
+ priv->match_id = 0;
+ }
+ 
+ if (priv->error_id)
+ {
+ g_signal_handler_disconnect (priv->context, priv->error_id);
+
+ priv->error_id = 0;
+ }
+
+ GDICT_NOTE (CHOOSER, "Removing old context");
+ 
+ g_object_unref (G_OBJECT (priv->context));
+
+ priv->context = NULL;
+ priv->results = -1;
+ }
+
+ if (!context)
+ return;
+
+ if (!GDICT_IS_CONTEXT (context))
+ {
+ g_warning ("Object of type '%s' instead of a GdictContext\n",
+ g_type_name (G_OBJECT_TYPE (context)));
+ return;
+ }
+
+ GDICT_NOTE (CHOOSER, "Setting new context");
+ 
+ priv->context = g_object_ref (context);
+ priv->results = 0;
+}
+
+static void
+gdict_database_chooser_finalize (GObject *gobject)
+{
+ GdictDatabaseChooser *chooser = GDICT_DATABASE_CHOOSER (gobject);
+ GdictDatabaseChooserPrivate *priv = chooser->priv;
+
+ g_free (priv->current_db);
+ 
+ G_OBJECT_CLASS (gdict_database_chooser_parent_class)->finalize (gobject);
+}
+
+static void
+gdict_database_chooser_dispose (GObject *gobject)
+{
+ GdictDatabaseChooser *chooser = GDICT_DATABASE_CHOOSER (gobject);
+ GdictDatabaseChooserPrivate *priv = chooser->priv;
+
+ set_gdict_context (chooser, NULL);
+
+ if (priv->busy_cursor)
+ {
+ gdk_cursor_unref (priv->busy_cursor);
+ priv->busy_cursor = NULL;
+ }
+
+ if (priv->store)
+ {
+ g_object_unref (priv->store);
+ priv->store = NULL;
+ }
+
+ G_OBJECT_CLASS (gdict_database_chooser_parent_class)->dispose (gobject);
+}
+
+static void
+gdict_database_chooser_set_property (GObject *gobject,
+ guint prop_id,
+ const GValue *value,
+ GParamSpec *pspec)
+{
+ GdictDatabaseChooser *chooser = GDICT_DATABASE_CHOOSER (gobject);
+ 
+ switch (prop_id)
+ {
+ case PROP_CONTEXT:
+ set_gdict_context (chooser, g_value_get_object (value));
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
+ break;
+ }
+}
+
+static void
+gdict_database_chooser_get_property (GObject *gobject,
+ guint prop_id,
+ GValue *value,
+ GParamSpec *pspec)
+{
+ GdictDatabaseChooser *chooser = GDICT_DATABASE_CHOOSER (gobject);
+ 
+ switch (prop_id)
+ {
+ case PROP_CONTEXT:
+ g_value_set_object (value, chooser->priv->context);
+ break;
+ case PROP_COUNT:
+ g_value_set_int (value, chooser->priv->results);
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
+ break;
+ }
+}
+
+static void
+row_activated_cb (GtkTreeView *treeview,
+ GtkTreePath *path,
+ GtkTreeViewColumn *column,
+ gpointer user_data)
+{
+ GdictDatabaseChooser *chooser = GDICT_DATABASE_CHOOSER (user_data);
+ GdictDatabaseChooserPrivate *priv = chooser->priv;
+ GtkTreeIter iter;
+ gchar *db_name, *db_desc;
+ gboolean valid;
+
+ valid = gtk_tree_model_get_iter (GTK_TREE_MODEL (priv->store),
+ &iter,
+ path);
+ if (!valid)
+ {
+ g_warning ("Invalid iterator found");
+ return;
+ }
+
+ gtk_tree_model_get (GTK_TREE_MODEL (priv->store), &iter,
+ DB_COLUMN_NAME, &db_name,
+ DB_COLUMN_DESCRIPTION, &db_desc,
+ -1);
+ if (db_name && db_desc)
+ {
+ g_free (priv->current_db);
+ priv->current_db = g_strdup (db_name);
+
+ g_signal_emit (chooser, db_chooser_signals[DATABASE_ACTIVATED], 0,
+ db_name, db_desc);
+ }
+ else
+ {
+ gchar *row = gtk_tree_path_to_string (path);
+
+ g_warning ("Row %s activated, but no database attached", row);
+ g_free (row);
+ }
+
+ g_free (db_name);
+ g_free (db_desc);
+}
+
+static void
+refresh_button_clicked_cb (GtkWidget *widget,
+ gpointer user_data)
+{
+ GdictDatabaseChooser *chooser = GDICT_DATABASE_CHOOSER (user_data);
+
+ gdict_database_chooser_refresh (chooser);
+}
+
+static void
+clear_button_clicked_cb (GtkWidget *widget,
+ gpointer user_data)
+{
+ GdictDatabaseChooser *chooser = GDICT_DATABASE_CHOOSER (user_data);
+
+ gdict_database_chooser_clear (chooser);
+}
+
+static void
+selection_changed_cb (GtkTreeSelection *selection,
+ gpointer user_data)
+{
+ g_signal_emit (user_data, db_chooser_signals[SELECTION_CHANGED], 0);
+}
+
+static GObject *
+gdict_database_chooser_constructor (GType type,
+ guint n_params,
+ GObjectConstructParam *params)
+{
+ GObjectClass *parent_class;
+ GObject *object;
+ GdictDatabaseChooser *chooser;
+ GdictDatabaseChooserPrivate *priv;
+ GtkWidget *sw;
+ GtkCellRenderer *renderer;
+ GtkTreeViewColumn *column;
+ GtkWidget *hbox;
+
+ parent_class = G_OBJECT_CLASS (gdict_database_chooser_parent_class);
+ object = parent_class->constructor (type, n_params, params);
+
+ chooser = GDICT_DATABASE_CHOOSER (object);
+ priv = chooser->priv;
+
+ gtk_widget_push_composite_child ();
+
+ sw = gtk_scrolled_window_new (NULL, NULL);
+ gtk_widget_set_composite_name (sw, "gdict-database-chooser-scrolled-window");
+ gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
+ GTK_POLICY_AUTOMATIC,
+ GTK_POLICY_AUTOMATIC);
+ gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw),
+ GTK_SHADOW_IN);
+ gtk_box_pack_start (GTK_BOX (chooser), sw, TRUE, TRUE, 0);
+ gtk_widget_show (sw);
+
+ renderer = gtk_cell_renderer_text_new ();
+ column = gtk_tree_view_column_new_with_attributes ("databases",
+ renderer,
+ "text", DB_COLUMN_DESCRIPTION,
+ "weight", DB_COLUMN_CURRENT,
+ NULL);
+ priv->treeview = gtk_tree_view_new ();
+ gtk_widget_set_composite_name (priv->treeview, "gdict-database-chooser-treeview");
+ gtk_tree_view_set_model (GTK_TREE_VIEW (priv->treeview),
+ GTK_TREE_MODEL (priv->store));
+ gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (priv->treeview), FALSE);
+ gtk_tree_view_append_column (GTK_TREE_VIEW (priv->treeview), column);
+ g_signal_connect (gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->treeview)),
+ "changed", G_CALLBACK (selection_changed_cb),
+ chooser);
+ g_signal_connect (priv->treeview, "row-activated",
+ G_CALLBACK (row_activated_cb), chooser);
+ gtk_container_add (GTK_CONTAINER (sw), priv->treeview);
+ gtk_widget_show (priv->treeview);
+
+ hbox = gtk_hbox_new (FALSE, 0);
+ priv->buttons_box = hbox;
+
+ priv->refresh_button = gtk_button_new ();
+ gtk_button_set_image (GTK_BUTTON (priv->refresh_button),
+ gtk_image_new_from_stock (GTK_STOCK_REFRESH,
+ GTK_ICON_SIZE_SMALL_TOOLBAR));
+ g_signal_connect (priv->refresh_button, "clicked",
+ G_CALLBACK (refresh_button_clicked_cb),
+ chooser);
+ gtk_box_pack_start (GTK_BOX (hbox), priv->refresh_button, FALSE, FALSE, 0);
+ gtk_widget_show (priv->refresh_button);
+ gtk_widget_set_tooltip_text (priv->refresh_button,
+ _("Reload the list of available databases"));
+
+ priv->clear_button = gtk_button_new ();
+ gtk_button_set_image (GTK_BUTTON (priv->clear_button),
+ gtk_image_new_from_stock (GTK_STOCK_CLEAR,
+ GTK_ICON_SIZE_SMALL_TOOLBAR));
+ g_signal_connect (priv->clear_button, "clicked",
+ G_CALLBACK (clear_button_clicked_cb),
+ chooser);
+ gtk_box_pack_start (GTK_BOX (hbox), priv->clear_button, FALSE, FALSE, 0);
+ gtk_widget_show (priv->clear_button);
+ gtk_widget_set_tooltip_text (priv->clear_button,
+ _("Clear the list of available databases"));
+
+ gtk_box_pack_end (GTK_BOX (chooser), hbox, FALSE, FALSE, 0);
+ gtk_widget_show (hbox);
+ 
+ gtk_widget_pop_composite_child ();
+
+ return object;
+}
+
+static void
+gdict_database_chooser_class_init (GdictDatabaseChooserClass *klass)
+{
+ GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+ 
+ gobject_class->finalize = gdict_database_chooser_finalize;
+ gobject_class->dispose = gdict_database_chooser_dispose;
+ gobject_class->set_property = gdict_database_chooser_set_property;
+ gobject_class->get_property = gdict_database_chooser_get_property;
+ gobject_class->constructor = gdict_database_chooser_constructor;
+
+ /**
+ * GdictDatabaseChooser:context:
+ *
+ * The #GdictContext used to retrieve the list of available databases.
+ *
+ * Since: 0.10
+ */
+ g_object_class_install_property (gobject_class,
+ PROP_CONTEXT,
+ g_param_spec_object ("context",
+ "Context",
+ "The GdictContext object used to get the list of databases",
+ GDICT_TYPE_CONTEXT,
+ (G_PARAM_READWRITE | G_PARAM_CONSTRUCT)));
+ /**
+ * GdictDatabaseChooser:count:
+ *
+ * The number of displayed databases or, if no #GdictContext is set, -1.
+ *
+ * Since: 0.12
+ */
+ g_object_class_install_property (gobject_class,
+ PROP_COUNT,
+ g_param_spec_int ("count",
+ "Count",
+ "The number of available databases",
+ -1, G_MAXINT, -1,
+ G_PARAM_READABLE));
+
+ /**
+ * GdictDatabaseChooser::database-activated:
+ * @chooser: the database chooser that received the signal
+ * @name: the name of the activated database
+ * @description: the description of the activated database
+ *
+ * The ::database-activated signal is emitted each time the user
+ * activated a row in the database chooser widget, either by double
+ * clicking on it or by a keyboard event.
+ *
+ * Since: 0.10
+ */
+ db_chooser_signals[DATABASE_ACTIVATED] =
+ g_signal_new ("database-activated",
+ G_OBJECT_CLASS_TYPE (gobject_class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (GdictDatabaseChooserClass, database_activated),
+ NULL, NULL,
+ gdict_marshal_VOID__STRING_STRING,
+ G_TYPE_NONE, 2,
+ G_TYPE_STRING,
+ G_TYPE_STRING);
+ /**
+ * GdictDatabaseChooser::selection-changed:
+ * @chooser: the database chooser that received the signal
+ *
+ * The ::selection-changed signal is emitted each time the selection
+ * inside the database chooser has been changed.
+ *
+ * Since: 0.12
+ */
+ db_chooser_signals[SELECTION_CHANGED] =
+ g_signal_new ("selection-changed",
+ G_OBJECT_CLASS_TYPE (gobject_class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (GdictDatabaseChooserClass, selection_changed),
+ NULL, NULL,
+ gdict_marshal_VOID__VOID,
+ G_TYPE_NONE, 0);
+
+ g_type_class_add_private (gobject_class, sizeof (GdictDatabaseChooserPrivate));
+}
+
+static void
+gdict_database_chooser_init (GdictDatabaseChooser *chooser)
+{
+ GdictDatabaseChooserPrivate *priv;
+
+ chooser->priv = priv = GDICT_DATABASE_CHOOSER_GET_PRIVATE (chooser);
+
+ priv->results = -1;
+ priv->context = NULL;
+
+ priv->store = gtk_list_store_new (DB_N_COLUMNS,
+ G_TYPE_INT, /* db_type */
+ G_TYPE_STRING, /* db_name */
+ G_TYPE_STRING, /* db_desc */
+ G_TYPE_INT /* db_current */);
+
+ priv->start_id = 0;
+ priv->end_id = 0;
+ priv->match_id = 0;
+ priv->error_id = 0;
+}
+
+/**
+ * gdict_database_chooser_new:
+ *
+ * Creates a new #GdictDatabaseChooser widget. A Database chooser widget
+ * can be used to display the list of available databases on a dictionary
+ * source using the #GdictContext representing it. After creation, the
+ * #GdictContext can be set using gdict_database_chooser_set_context().
+ *
+ * Return value: the newly created #GdictDatabaseChooser widget.
+ *
+ * Since: 0.10
+ */
+GtkWidget *
+gdict_database_chooser_new (void)
+{
+ return g_object_new (GDICT_TYPE_DATABASE_CHOOSER, NULL);
+}
+
+/**
+ * gdict_database_chooser_new_with_context:
+ * @context: a #GdictContext
+ *
+ * Creates a new #GdictDatabaseChooser, using @context as the representation
+ * of the dictionary source to query for the list of available databases.
+ *
+ * Return value: the newly created #GdictDatabaseChooser widget.
+ *
+ * Since: 0.10
+ */
+GtkWidget *
+gdict_database_chooser_new_with_context (GdictContext *context)
+{
+ g_return_val_if_fail (GDICT_IS_CONTEXT (context), NULL);
+ 
+ return g_object_new (GDICT_TYPE_DATABASE_CHOOSER,
+ "context", context,
+ NULL);
+}
+
+/**
+ * gdict_database_chooser_get_context:
+ * @chooser: a #GdictDatabaseChooser
+ *
+ * Retrieves the #GdictContext used by @chooser.
+ *
+ * Return value: a #GdictContext or %NULL
+ *
+ * Since: 0.10
+ */
+GdictContext *
+gdict_database_chooser_get_context (GdictDatabaseChooser *chooser)
+{
+ g_return_val_if_fail (GDICT_IS_DATABASE_CHOOSER (chooser), NULL);
+ 
+ return chooser->priv->context;
+}
+
+/**
+ * gdict_database_chooser_set_context:
+ * @chooser: a #GdictDatabaseChooser
+ * @context: a #GdictContext
+ *
+ * Sets the #GdictContext to be used to query a dictionary source
+ * for the list of available databases.
+ *
+ * Since: 0.10
+ */
+void
+gdict_database_chooser_set_context (GdictDatabaseChooser *chooser,
+ GdictContext *context)
+{
+ g_return_if_fail (GDICT_IS_DATABASE_CHOOSER (chooser));
+ g_return_if_fail (context == NULL || GDICT_IS_CONTEXT (context));
+
+ set_gdict_context (chooser, context);
+
+ g_object_notify (G_OBJECT (chooser), "context");
+}
+
+/**
+ * gdict_database_chooser_get_databases:
+ * @chooser: a #GdictDatabaseChooser
+ * @length: return location for the length of the returned vector
+ *
+ * Gets the list of available database names.
+ *
+ * Return value: a newly allocated, %NULL terminated string vector
+ * containing database names. Use g_strfreev() to deallocate it.
+ *
+ * Since: 0.10
+ */
+gchar **
+gdict_database_chooser_get_databases (GdictDatabaseChooser *chooser,
+ gsize *length)
+{
+ GdictDatabaseChooserPrivate *priv;
+ GtkTreeIter iter;
+ gchar **retval;
+ gsize i;
+
+ g_return_val_if_fail (GDICT_IS_DATABASE_CHOOSER (chooser), NULL);
+
+ priv = chooser->priv;
+
+ if (!gtk_tree_model_get_iter_first (GTK_TREE_MODEL (priv->store), &iter))
+ return NULL;
+
+ i = 0;
+ retval = g_new (gchar*, priv->results);
+
+ do
+ {
+ gchar *db_name;
+
+ gtk_tree_model_get (GTK_TREE_MODEL (priv->store), &iter,
+ DB_COLUMN_NAME, &db_name,
+ -1);
+
+ retval[i++] = db_name;
+ }
+ while (gtk_tree_model_iter_next (GTK_TREE_MODEL (priv->store), &iter));
+
+ retval[i] = NULL;
+
+ if (length)
+ *length = i;
+
+ return retval;
+}
+
+/**
+ * gdict_database_chooser_has_database:
+ * @chooser: a #GdictDatabaseChooser
+ * @database: the name of a database
+ *
+ * Checks whether the @chooser displays @database
+ *
+ * Return value: %TRUE if the search database name is present
+ *
+ * Since: 0.10
+ */
+gboolean
+gdict_database_chooser_has_database (GdictDatabaseChooser *chooser,
+ const gchar *database)
+{
+ GdictDatabaseChooserPrivate *priv;
+ GtkTreeIter iter;
+ gboolean retval;
+
+ g_return_val_if_fail (GDICT_IS_DATABASE_CHOOSER (chooser), FALSE);
+ g_return_val_if_fail (database != NULL, FALSE);
+
+ priv = chooser->priv;
+
+ if (!gtk_tree_model_get_iter_first (GTK_TREE_MODEL (priv->store), &iter))
+ return FALSE;
+
+ retval = FALSE;
+
+ do
+ {
+ gchar *db_name;
+
+ gtk_tree_model_get (GTK_TREE_MODEL (priv->store), &iter,
+ DB_COLUMN_NAME, &db_name,
+ -1);
+ 
+ if (strcmp (db_name, database) == 0)
+ {
+ g_free (db_name);
+ retval = TRUE;
+ break;
+ }
+ 
+ g_free (db_name);
+ }
+ while (gtk_tree_model_iter_next (GTK_TREE_MODEL (priv->store), &iter));
+
+ return retval;
+}
+
+/**
+ * gdict_database_chooser_count_databases:
+ * @chooser: a #GdictDatabaseChooser
+ *
+ * Returns the number of databases found.
+ *
+ * Return value: the number of databases or -1 if no context is set
+ *
+ * Since: 0.10
+ */
+gint
+gdict_database_chooser_count_databases (GdictDatabaseChooser *chooser)
+{
+ g_return_val_if_fail (GDICT_IS_DATABASE_CHOOSER (chooser), -1);
+
+ return chooser->priv->results;
+}
+
+static void
+lookup_start_cb (GdictContext *context,
+ gpointer user_data)
+{
+ GdictDatabaseChooser *chooser = GDICT_DATABASE_CHOOSER (user_data);
+ GdictDatabaseChooserPrivate *priv = chooser->priv;
+
+ if (!priv->busy_cursor)
+ priv->busy_cursor = gdk_cursor_new (GDK_WATCH);
+
+ if (gtk_widget_get_window (GTK_WIDGET (chooser)))
+ gdk_window_set_cursor (gtk_widget_get_window (GTK_WIDGET (chooser)), priv->busy_cursor);
+
+ priv->is_searching = TRUE;
+}
+
+static void
+lookup_end_cb (GdictContext *context,
+ gpointer user_data)
+{
+ GdictDatabaseChooser *chooser = GDICT_DATABASE_CHOOSER (user_data);
+ GdictDatabaseChooserPrivate *priv = chooser->priv;
+
+ if (gtk_widget_get_window (GTK_WIDGET (chooser)))
+ gdk_window_set_cursor (gtk_widget_get_window (GTK_WIDGET (chooser)), NULL);
+
+ priv->is_searching = FALSE;
+}
+
+static void
+database_found_cb (GdictContext *context,
+ GdictDatabase *database,
+ gpointer user_data)
+{
+ GdictDatabaseChooser *chooser = GDICT_DATABASE_CHOOSER (user_data);
+ GdictDatabaseChooserPrivate *priv = chooser->priv;
+ GtkTreeIter iter;
+ const gchar *name, *full_name;
+ gint weight = PANGO_WEIGHT_NORMAL;
+
+ name = gdict_database_get_name (database);
+ full_name = gdict_database_get_full_name (database);
+
+ if (priv->current_db && !strcmp (priv->current_db, name))
+ weight = PANGO_WEIGHT_BOLD;
+
+ GDICT_NOTE (CHOOSER, "DATABASE: `%s' (`%s')",
+ name,
+ full_name);
+ 
+ gtk_list_store_append (priv->store, &iter);
+ gtk_list_store_set (priv->store, &iter,
+ DB_COLUMN_TYPE, DATABASE_NAME,
+ DB_COLUMN_NAME, name,
+ DB_COLUMN_DESCRIPTION, full_name,
+ DB_COLUMN_CURRENT, weight,
+ -1);
+
+ priv->results += 1;
+}
+
+static void
+error_cb (GdictContext *context,
+ const GError *error,
+ gpointer user_data)
+{
+ GdictDatabaseChooser *chooser = GDICT_DATABASE_CHOOSER (user_data);
+
+ if (gtk_widget_get_window (GTK_WIDGET (chooser)))
+ gdk_window_set_cursor (gtk_widget_get_window (GTK_WIDGET (chooser)), NULL);
+
+ chooser->priv->is_searching = FALSE;
+ chooser->priv->results = 0;
+}
+
+/**
+ * gdict_database_chooser_refresh:
+ * @chooser: a #GdictDatabaseChooser
+ *
+ * Reloads the list of available databases.
+ *
+ * Since: 0.10
+ */
+void
+gdict_database_chooser_refresh (GdictDatabaseChooser *chooser)
+{
+ GdictDatabaseChooserPrivate *priv;
+ GError *db_error;
+ 
+ g_return_if_fail (GDICT_IS_DATABASE_CHOOSER (chooser));
+
+ priv = chooser->priv;
+
+ if (!priv->context)
+ {
+ g_warning ("Attempting to retrieve the available databases, but "
+ "no GdictContext has been set. Use gdict_database_chooser_set_context() "
+ "before invoking gdict_database_chooser_refresh().");
+ return;
+ }
+
+ if (priv->is_searching)
+ return;
+
+ gdict_database_chooser_clear (chooser);
+
+ if (!priv->start_id)
+ {
+ priv->start_id = g_signal_connect (priv->context, "lookup-start",
+ G_CALLBACK (lookup_start_cb),
+ chooser);
+ priv->match_id = g_signal_connect (priv->context, "database-found",
+ G_CALLBACK (database_found_cb),
+ chooser);
+ priv->end_id = g_signal_connect (priv->context, "lookup-end",
+ G_CALLBACK (lookup_end_cb),
+ chooser);
+ }
+
+ if (!priv->error_id)
+ priv->error_id = g_signal_connect (priv->context, "error",
+ G_CALLBACK (error_cb),
+ chooser);
+
+ db_error = NULL;
+ gdict_context_lookup_databases (priv->context, &db_error);
+ if (db_error)
+ {
+ GtkTreeIter iter;
+
+ gtk_list_store_append (priv->store, &iter);
+ gtk_list_store_set (priv->store, &iter,
+ DB_COLUMN_TYPE, DATABASE_ERROR,
+ DB_COLUMN_NAME, _("Error while matching"),
+ DB_COLUMN_DESCRIPTION, NULL,
+ -1);
+
+ g_warning ("Error while looking for databases: %s",
+ db_error->message);
+
+ g_error_free (db_error);
+ }
+}
+
+/**
+ * gdict_database_chooser_clear:
+ * @chooser: a #GdictDatabaseChooser
+ *
+ * Clears @chooser.
+ *
+ * Since: 0.10
+ */
+void
+gdict_database_chooser_clear (GdictDatabaseChooser *chooser)
+{
+ GdictDatabaseChooserPrivate *priv;
+
+ g_return_if_fail (GDICT_IS_DATABASE_CHOOSER (chooser));
+
+ priv = chooser->priv;
+
+ gtk_tree_view_set_model (GTK_TREE_VIEW (priv->treeview), NULL);
+
+ gtk_list_store_clear (priv->store);
+ priv->results = 0;
+
+ gtk_tree_view_set_model (GTK_TREE_VIEW (priv->treeview),
+ GTK_TREE_MODEL (priv->store));
+}
+
+typedef struct
+{
+ gchar *db_name;
+ GdictDatabaseChooser *chooser;
+ 
+ guint found : 1;
+ guint do_select : 1;
+ guint do_activate : 1;
+} SelectData;
+
+static gboolean
+scan_for_db_name (GtkTreeModel *model,
+ GtkTreePath *path,
+ GtkTreeIter *iter,
+ gpointer user_data)
+{
+ SelectData *select_data = user_data;
+ gchar *db_name = NULL;
+
+ if (!select_data)
+ return TRUE;
+
+ gtk_tree_model_get (model, iter, DB_COLUMN_NAME, &db_name, -1);
+ if (!db_name)
+ return FALSE;
+
+ if (strcmp (db_name, select_data->db_name) == 0)
+ {
+ GtkTreeView *tree_view;
+ GtkTreeSelection *selection;
+
+ select_data->found = TRUE;
+
+ tree_view = GTK_TREE_VIEW (select_data->chooser->priv->treeview);
+ if (select_data->do_activate)
+ {
+ GtkTreeViewColumn *column;
+
+ gtk_list_store_set (GTK_LIST_STORE (model), iter,
+ DB_COLUMN_CURRENT, PANGO_WEIGHT_BOLD,
+ -1);
+
+ column = gtk_tree_view_get_column (tree_view, 0);
+ gtk_tree_view_row_activated (tree_view, path, column);
+ }
+
+ selection = gtk_tree_view_get_selection (tree_view);
+ if (select_data->do_select)
+ gtk_tree_selection_select_path (selection, path);
+ else
+ gtk_tree_selection_unselect_path (selection, path);
+ }
+ else
+ {
+ gtk_list_store_set (GTK_LIST_STORE (model), iter,
+ DB_COLUMN_CURRENT, PANGO_WEIGHT_NORMAL,
+ -1);
+ }
+
+ g_free (db_name);
+
+ return FALSE;
+}
+
+/**
+ * gdict_database_chooser_select_database:
+ * @chooser: a #GdictDatabaseChooser
+ * @db_name: name of the database to select
+ *
+ * Selects the database with @db_name inside the @chooser widget.
+ *
+ * Return value: %TRUE if the database was found and selected
+ *
+ * Since: 0.10
+ */
+gboolean
+gdict_database_chooser_select_database (GdictDatabaseChooser *chooser,
+ const gchar *db_name)
+{
+ GdictDatabaseChooserPrivate *priv;
+ SelectData data;
+ gboolean retval;
+
+ g_return_val_if_fail (GDICT_IS_DATABASE_CHOOSER (chooser), FALSE);
+ g_return_val_if_fail (db_name != NULL, FALSE);
+
+ priv = chooser->priv;
+
+ data.db_name = g_strdup (db_name);
+ data.chooser = chooser;
+ data.found = FALSE;
+ data.do_select = TRUE;
+ data.do_activate = FALSE;
+
+ gtk_tree_model_foreach (GTK_TREE_MODEL (priv->store),
+ scan_for_db_name,
+ &data);
+
+ retval = data.found;
+
+ g_free (data.db_name);
+
+ return retval;
+}
+
+/**
+ * gdict_database_chooser_unselect_database:
+ * @chooser: a #GdictDatabaseChooser
+ * @db_name: name of the database to unselect
+ *
+ * Unselects the database @db_name inside the @chooser widget
+ *
+ * Return value: %TRUE if the database was found and unselected
+ *
+ * Since: 0.10
+ */
+gboolean
+gdict_database_chooser_unselect_database (GdictDatabaseChooser *chooser,
+ const gchar *db_name)
+{
+ GdictDatabaseChooserPrivate *priv;
+ SelectData data;
+ gboolean retval;
+
+ g_return_val_if_fail (GDICT_IS_DATABASE_CHOOSER (chooser), FALSE);
+ g_return_val_if_fail (db_name != NULL, FALSE);
+
+ priv = chooser->priv;
+
+ data.db_name = g_strdup (db_name);
+ data.chooser = chooser;
+ data.found = FALSE;
+ data.do_select = FALSE;
+ data.do_activate = FALSE;
+
+ gtk_tree_model_foreach (GTK_TREE_MODEL (priv->store),
+ scan_for_db_name,
+ &data);
+
+ retval = data.found;
+
+ g_free (data.db_name);
+
+ return retval;
+}
+
+/**
+ * gdict_database_chooser_set_current_database:
+ * @chooser: a #GdictDatabaseChooser
+ * @db_name: the name of the database
+ *
+ * Sets @db_name as the current database. This function will select
+ * and activate the corresponding row, if the database is found.
+ *
+ * Return value: %TRUE if the database was found and set
+ *
+ * Since: 0.10
+ */
+gboolean
+gdict_database_chooser_set_current_database (GdictDatabaseChooser *chooser,
+ const gchar *db_name)
+{
+ GdictDatabaseChooserPrivate *priv;
+ SelectData data;
+ gboolean retval;
+
+ g_return_val_if_fail (GDICT_IS_DATABASE_CHOOSER (chooser), FALSE);
+ g_return_val_if_fail (db_name != NULL, FALSE);
+
+ priv = chooser->priv;
+
+ data.db_name = g_strdup (db_name);
+ data.chooser = chooser;
+ data.found = FALSE;
+ data.do_select = TRUE;
+ data.do_activate = TRUE;
+
+ gtk_tree_model_foreach (GTK_TREE_MODEL (priv->store),
+ scan_for_db_name,
+ &data);
+
+ retval = data.found;
+
+ if (data.found)
+ {
+ g_free (priv->current_db);
+ priv->current_db = data.db_name;
+ }
+ else
+ g_free (data.db_name);
+
+ return retval;
+}
+
+/**
+ * gdict_database_chooser_get_current_database:
+ * @chooser: a #GdictDatabaseChooser
+ *
+ * Retrieves the name of the currently selected database inside @chooser
+ *
+ * Return value: the name of the selected database. Use g_free() on the
+ * returned string when done using it
+ *
+ * Since: 0.10
+ */
+gchar *
+gdict_database_chooser_get_current_database (GdictDatabaseChooser *chooser)
+{
+ GdictDatabaseChooserPrivate *priv;
+ GtkTreeSelection *selection;
+ GtkTreeModel *model;
+ GtkTreeIter iter;
+ gchar *retval = NULL;
+
+ g_return_val_if_fail (GDICT_IS_DATABASE_CHOOSER (chooser), NULL);
+ 
+ priv = chooser->priv;
+
+ selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->treeview));
+ if (!gtk_tree_selection_get_selected (selection, &model, &iter))
+ return NULL;
+
+ gtk_tree_model_get (model, &iter, DB_COLUMN_NAME, &retval, -1);
+ 
+ g_free (priv->current_db);
+ priv->current_db = g_strdup (retval);
+
+ return retval;
+}
+
+/**
+ * gdict_database_chooser_add_button:
+ * @chooser: a #GdictDatabase
+ * @button_text: text of the button
+ *
+ * Adds a #GtkButton with @button_text to the button area on
+ * the bottom of @chooser. The @button_text can also be a
+ * stock ID.
+ *
+ * Return value: the newly packed button.
+ *
+ * Since: 0.10
+ */
+GtkWidget *
+gdict_database_chooser_add_button (GdictDatabaseChooser *chooser,
+ const gchar *button_text)
+{
+ GdictDatabaseChooserPrivate *priv;
+ GtkWidget *button;
+
+ g_return_val_if_fail (GDICT_IS_DATABASE_CHOOSER (chooser), NULL);
+ g_return_val_if_fail (button_text != NULL, NULL);
+
+ priv = chooser->priv;
+
+ button = gtk_button_new_from_stock (button_text);
+
+ gtk_widget_set_can_default (button, TRUE);
+
+ gtk_widget_show (button);
+
+ gtk_box_pack_end (GTK_BOX (priv->buttons_box), button, FALSE, TRUE, 0);
+
+ return button;
+}
diff --git a/mate-dictionary/libgdict/gdict-database-chooser.h b/mate-dictionary/libgdict/gdict-database-chooser.h
new file mode 100644
index 00000000..c95a23ab
--- /dev/null
+++ b/mate-dictionary/libgdict/gdict-database-chooser.h
@@ -0,0 +1,99 @@
+/* gdict-database-chooser.h - display widget for database names
+ *
+ * Copyright (C) 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 library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ */
+
+#ifndef __GDICT_DATABASE_CHOOSER_H__
+#define __GDICT_DATABASE_CHOOSER_H__
+
+#include <gtk/gtk.h>
+#include "gdict-context.h"
+
+G_BEGIN_DECLS
+
+#define GDICT_TYPE_DATABASE_CHOOSER (gdict_database_chooser_get_type ())
+#define GDICT_DATABASE_CHOOSER(obj) \
+(G_TYPE_CHECK_INSTANCE_CAST ((obj), GDICT_TYPE_DATABASE_CHOOSER, GdictDatabaseChooser))
+#define GDICT_IS_DATABASE_CHOOSER(obj) \
+(G_TYPE_CHECK_INSTANCE_TYPE ((obj), GDICT_TYPE_DATABASE_CHOOSER))
+#define GDICT_DATABASE_CHOOSER_CLASS(klass) \
+(G_TYPE_CHECK_CLASS_CAST ((klass), GDICT_TYPE_DATABASE_CHOOSER, GdictDatabaseChooserClass))
+#define GDICT_IS_DATABASE_CHOOSER_CLASS(klass) \
+(G_TYPE_CHECK_CLASS_TYPE ((klass), GDICT_TYPE_DATABASE_CHOOSER))
+#define GDICT_DATABASE_CHOOSER_GET_CLASS(obj) \
+(G_TYPE_INSTANCE_GET_CLASS ((obj), GDICT_TYPE_DATABASE_CHOOSER, GdictDatabaseChooserClass))
+
+typedef struct _GdictDatabaseChooser GdictDatabaseChooser;
+typedef struct _GdictDatabaseChooserPrivate GdictDatabaseChooserPrivate;
+typedef struct _GdictDatabaseChooserClass GdictDatabaseChooserClass;
+
+struct _GdictDatabaseChooser
+{
+ /*< private >*/
+ GtkVBox parent_instance;
+ 
+ GdictDatabaseChooserPrivate *priv;
+};
+
+struct _GdictDatabaseChooserClass
+{
+ /*< private >*/
+ GtkVBoxClass parent_class;
+
+ /*< public >*/
+ void (*database_activated) (GdictDatabaseChooser *chooser,
+ const gchar *name,
+ const gchar *description);
+ void (*selection_changed) (GdictDatabaseChooser *chooser);
+
+ /*< private >*/
+ /* padding for future expansion */
+ void (*_gdict_padding2) (void);
+ void (*_gdict_padding3) (void);
+ void (*_gdict_padding4) (void);
+ void (*_gdict_padding5) (void);
+ void (*_gdict_padding6) (void);
+};
+
+GType gdict_database_chooser_get_type (void) G_GNUC_CONST;
+
+GtkWidget * gdict_database_chooser_new (void);
+GtkWidget * gdict_database_chooser_new_with_context (GdictContext *context);
+
+GdictContext *gdict_database_chooser_get_context (GdictDatabaseChooser *chooser);
+void gdict_database_chooser_set_context (GdictDatabaseChooser *chooser,
+ GdictContext *context);
+gboolean gdict_database_chooser_select_database (GdictDatabaseChooser *chooser,
+ const gchar *db_name);
+gboolean gdict_database_chooser_unselect_database (GdictDatabaseChooser *chooser,
+ const gchar *db_name);
+gboolean gdict_database_chooser_set_current_database (GdictDatabaseChooser *chooser,
+ const gchar *db_name);
+gchar * gdict_database_chooser_get_current_database (GdictDatabaseChooser *chooser) G_GNUC_MALLOC;
+gchar ** gdict_database_chooser_get_databases (GdictDatabaseChooser *chooser,
+ gsize *length) G_GNUC_MALLOC;
+gint gdict_database_chooser_count_databases (GdictDatabaseChooser *chooser);
+gboolean gdict_database_chooser_has_database (GdictDatabaseChooser *chooser,
+ const gchar *database);
+void gdict_database_chooser_refresh (GdictDatabaseChooser *chooser);
+void gdict_database_chooser_clear (GdictDatabaseChooser *chooser);
+GtkWidget * gdict_database_chooser_add_button (GdictDatabaseChooser *chooser,
+ const gchar *button_text);
+
+G_END_DECLS
+
+#endif /* __GDICT_DATABASE_CHOOSER_H__ */
diff --git a/mate-dictionary/libgdict/gdict-debug.h b/mate-dictionary/libgdict/gdict-debug.h
new file mode 100644
index 00000000..af234b1f
--- /dev/null
+++ b/mate-dictionary/libgdict/gdict-debug.h
@@ -0,0 +1,55 @@
+/* gdict-debug.h - Debug facilities for Gdict
+ *
+ * Copyright (C) 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 library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ */
+
+#ifndef __GDICT_DEBUG_H__
+#define __GDICT_DEBUG_H__
+
+#include <glib.h>
+
+G_BEGIN_DECLS
+
+typedef enum {
+ GDICT_DEBUG_MISC = 1 << 0,
+ GDICT_DEBUG_CONTEXT = 1 << 1,
+ GDICT_DEBUG_DICT = 1 << 2,
+ GDICT_DEBUG_SOURCE = 1 << 3,
+ GDICT_DEBUG_LOADER = 1 << 4,
+ GDICT_DEBUG_CHOOSER = 1 << 5,
+ GDICT_DEBUG_DEFBOX = 1 << 6,
+ GDICT_DEBUG_SPELLER = 1 << 7
+} GdictDebugFlags;
+
+#ifdef GDICT_ENABLE_DEBUG
+
+#define GDICT_NOTE(type,x,a...) G_STMT_START { \
+ if (gdict_debug_flags & GDICT_DEBUG_##type) { \
+ g_message ("[" #type "]: " G_STRLOC ": " x, ##a); \
+ } } G_STMT_END
+
+#else
+
+#define GDICT_NOTE(type,x,a...)
+
+#endif /* !GDICT_ENABLE_DEBUG */
+
+extern guint gdict_debug_flags;
+
+G_END_DECLS
+
+#endif /* __GDICT_DEBUG_H__ */
diff --git a/mate-dictionary/libgdict/gdict-defbox.c b/mate-dictionary/libgdict/gdict-defbox.c
new file mode 100644
index 00000000..0b739475
--- /dev/null
+++ b/mate-dictionary/libgdict/gdict-defbox.c
@@ -0,0 +1,2927 @@
+/* gdict-defbox.c - display widget for dictionary definitions
+ *
+ * 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 library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ */
+
+/**
+ * SECTION:gdict-defbox
+ * @short_description: Display the list of definitions for a word
+ *
+ * The #GdictDefbox widget is a composite widget showing the list of
+ * definitions for a word. It queries the passed #GdictContext and displays
+ * the list of #GdictDefinition<!-- -->s obtained.
+ *
+ * It provides syntax highlighting, clickable links and an embedded find
+ * bar.
+ */
+
+#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-lib.h>
+
+#include "gdict-defbox.h"
+#include "gdict-utils.h"
+#include "gdict-debug.h"
+#include "gdict-private.h"
+#include "gdict-enum-types.h"
+#include "gdict-marshal.h"
+
+/**
+ * G_UNICODE_COMBINING_MARK was deprecated on glib 2.30
+ * use G_UNICODE_SPACING_MARK
+ */
+
+#if !GLIB_CHECK_VERSION(2, 29, 14)
+ #define G_UNICODE_SPACING_MARK G_UNICODE_COMBINING_MARK
+#endif
+
+#define QUERY_MARGIN 48
+#define ERROR_MARGIN 24
+
+typedef struct
+{
+ GdictDefinition *definition;
+
+ gint begin;
+} Definition;
+
+#define GDICT_DEFBOX_GET_PRIVATE(obj) \
+(G_TYPE_INSTANCE_GET_PRIVATE ((obj), GDICT_TYPE_DEFBOX, GdictDefboxPrivate))
+
+struct _GdictDefboxPrivate
+{
+ GtkWidget *text_view;
+
+ /* the "find" pane */
+ GtkWidget *find_pane;
+ GtkWidget *find_entry;
+ GtkWidget *find_next;
+ GtkWidget *find_prev;
+ GtkWidget *find_label;
+
+ GtkWidget *progress_dialog;
+
+ GtkTextBuffer *buffer;
+
+ GdictContext *context;
+ GSList *definitions;
+
+ gchar *word;
+ gchar *database;
+ gchar *font_name;
+
+ guint show_find : 1;
+ guint is_searching : 1;
+ guint is_hovering : 1;
+
+ GdkCursor *busy_cursor;
+ GdkCursor *hand_cursor;
+ GdkCursor *regular_cursor;
+
+ guint start_id;
+ guint end_id;
+ guint define_id;
+ guint error_id;
+ guint hide_timeout;
+
+ GtkTextTag *link_tag;
+ GtkTextTag *visited_link_tag;
+};
+
+enum
+{
+ PROP_0,
+
+ PROP_CONTEXT,
+ PROP_WORD,
+ PROP_DATABASE,
+ PROP_FONT_NAME,
+ PROP_COUNT
+};
+
+enum
+{
+ SHOW_FIND,
+ HIDE_FIND,
+ FIND_NEXT,
+ FIND_PREVIOUS,
+ LINK_CLICKED,
+
+ LAST_SIGNAL
+};
+
+static guint gdict_defbox_signals[LAST_SIGNAL] = { 0 };
+static GdkColor default_link_color = { 0, 0, 0, 0xeeee };
+static GdkColor default_visited_link_color = { 0, 0x5555, 0x1a1a, 0x8b8b };
+
+
+G_DEFINE_TYPE (GdictDefbox, gdict_defbox, GTK_TYPE_VBOX);
+
+
+static Definition *
+definition_new (void)
+{
+ Definition *def;
+
+ def = g_slice_new (Definition);
+ def->definition = NULL;
+ def->begin = -1;
+
+ return def;
+}
+
+static void
+definition_free (Definition *def)
+{
+ if (!def)
+ return;
+
+ gdict_definition_unref (def->definition);
+ g_slice_free (Definition, def);
+}
+
+static void
+gdict_defbox_dispose (GObject *gobject)
+{
+ GdictDefbox *defbox = GDICT_DEFBOX (gobject);
+ GdictDefboxPrivate *priv = defbox->priv;
+
+ if (priv->start_id)
+ {
+ g_signal_handler_disconnect (priv->context, priv->start_id);
+ g_signal_handler_disconnect (priv->context, priv->end_id);
+ g_signal_handler_disconnect (priv->context, priv->define_id);
+
+ priv->start_id = 0;
+ priv->end_id = 0;
+ priv->define_id = 0;
+ }
+
+ if (priv->error_id)
+ {
+ g_signal_handler_disconnect (priv->context, priv->error_id);
+ priv->error_id = 0;
+ }
+
+ if (priv->context)
+ {
+ g_object_unref (priv->context);
+ priv->context = NULL;
+ }
+
+ if (priv->buffer)
+ {
+ g_object_unref (priv->buffer);
+ priv->buffer = NULL;
+ }
+
+ if (priv->busy_cursor)
+ {
+ gdk_cursor_unref (priv->busy_cursor);
+ priv->busy_cursor = NULL;
+ }
+
+ if (priv->hand_cursor)
+ {
+ gdk_cursor_unref (priv->hand_cursor);
+ priv->hand_cursor = NULL;
+ }
+
+ if (priv->regular_cursor)
+ {
+ gdk_cursor_unref (priv->regular_cursor);
+ priv->regular_cursor = NULL;
+ }
+
+ G_OBJECT_CLASS (gdict_defbox_parent_class)->dispose (gobject);
+}
+
+static void
+gdict_defbox_finalize (GObject *object)
+{
+ GdictDefbox *defbox = GDICT_DEFBOX (object);
+ GdictDefboxPrivate *priv = defbox->priv;
+
+ g_free (priv->database);
+ g_free (priv->word);
+ g_free (priv->font_name);
+
+ if (priv->definitions)
+ {
+ g_slist_foreach (priv->definitions, (GFunc) definition_free, NULL);
+ g_slist_free (priv->definitions);
+
+ priv->definitions = NULL;
+ }
+
+ G_OBJECT_CLASS (gdict_defbox_parent_class)->finalize (object);
+}
+
+static void
+set_gdict_context (GdictDefbox *defbox,
+ GdictContext *context)
+{
+ GdictDefboxPrivate *priv;
+
+ g_assert (GDICT_IS_DEFBOX (defbox));
+
+ priv = defbox->priv;
+ if (priv->context)
+ {
+ if (priv->start_id)
+ {
+ GDICT_NOTE (DEFBOX, "Removing old context handlers");
+
+ g_signal_handler_disconnect (priv->context, priv->start_id);
+ g_signal_handler_disconnect (priv->context, priv->define_id);
+ g_signal_handler_disconnect (priv->context, priv->end_id);
+
+ priv->start_id = 0;
+ priv->end_id = 0;
+ priv->define_id = 0;
+ }
+
+ if (priv->error_id)
+ {
+ g_signal_handler_disconnect (priv->context, priv->error_id);
+
+ priv->error_id = 0;
+ }
+
+ GDICT_NOTE (DEFBOX, "Removing old context");
+
+ g_object_unref (G_OBJECT (priv->context));
+ }
+
+ if (!context)
+ return;
+
+ if (!GDICT_IS_CONTEXT (context))
+ {
+ g_warning ("Object of type '%s' instead of a GdictContext\n",
+ g_type_name (G_OBJECT_TYPE (context)));
+ return;
+ }
+
+ GDICT_NOTE (DEFBOX, "Setting new context");
+
+ priv->context = context;
+ g_object_ref (G_OBJECT (priv->context));
+}
+
+static void
+gdict_defbox_set_property (GObject *object,
+ guint prop_id,
+ const GValue *value,
+ GParamSpec *pspec)
+{
+ GdictDefbox *defbox = GDICT_DEFBOX (object);
+ GdictDefboxPrivate *priv = defbox->priv;
+
+ switch (prop_id)
+ {
+ case PROP_WORD:
+ gdict_defbox_lookup (defbox, g_value_get_string (value));
+ break;
+ case PROP_CONTEXT:
+ set_gdict_context (defbox, g_value_get_object (value));
+ break;
+ case PROP_DATABASE:
+ g_free (priv->database);
+ priv->database = g_strdup (g_value_get_string (value));
+ break;
+ case PROP_FONT_NAME:
+ gdict_defbox_set_font_name (defbox, g_value_get_string (value));
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ break;
+ }
+}
+
+static void
+gdict_defbox_get_property (GObject *object,
+ guint prop_id,
+ GValue *value,
+ GParamSpec *pspec)
+{
+ GdictDefbox *defbox = GDICT_DEFBOX (object);
+ GdictDefboxPrivate *priv = defbox->priv;
+
+ switch (prop_id)
+ {
+ case PROP_WORD:
+ g_value_set_string (value, priv->word);
+ break;
+ case PROP_CONTEXT:
+ g_value_set_object (value, priv->context);
+ break;
+ case PROP_DATABASE:
+ g_value_set_string (value, priv->database);
+ break;
+ case PROP_FONT_NAME:
+ g_value_set_string (value, priv->font_name);
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ break;
+ }
+}
+
+/*
+ * this code has been copied from gtksourceview; it's the implementation
+ * for case-insensitive search in a GtkTextBuffer. this is non-trivial, as
+ * searches on a utf-8 text stream involve a norm(casefold(norm(utf8)))
+ * operation which can be costly on large buffers. luckily for us, it's
+ * not the case on a set of definitions.
+ */
+
+#define GTK_TEXT_UNKNOWN_CHAR 0xFFFC
+
+/* this function acts like g_utf8_offset_to_pointer() except that if it finds a
+ * decomposable character it consumes the decomposition length from the given
+ * offset. So it's useful when the offset was calculated for the normalized
+ * version of str, but we need a pointer to str itself. */
+static const gchar *
+pointer_from_offset_skipping_decomp (const gchar *str, gint offset)
+{
+ gchar *casefold, *normal;
+ const gchar *p, *q;
+
+ p = str;
+ while (offset > 0)
+ {
+ q = g_utf8_next_char (p);
+ casefold = g_utf8_casefold (p, q - p);
+ normal = g_utf8_normalize (casefold, -1, G_NORMALIZE_NFD);
+ offset -= g_utf8_strlen (normal, -1);
+ g_free (casefold);
+ g_free (normal);
+ p = q;
+ }
+ return p;
+}
+
+static gboolean
+exact_prefix_cmp (const gchar *string,
+ const gchar *prefix,
+ guint prefix_len)
+{
+ GUnicodeType type;
+
+ if (strncmp (string, prefix, prefix_len) != 0)
+ return FALSE;
+ if (string[prefix_len] == '\0')
+ return TRUE;
+
+ type = g_unichar_type (g_utf8_get_char (string + prefix_len));
+
+ /* If string contains prefix, check that prefix is not followed
+ * by a unicode mark symbol, e.g. that trailing 'a' in prefix
+ * is not part of two-char a-with-hat symbol in string. */
+ return type != G_UNICODE_SPACING_MARK &&
+ type != G_UNICODE_ENCLOSING_MARK &&
+ type != G_UNICODE_NON_SPACING_MARK;
+}
+
+static const gchar *
+utf8_strcasestr (const gchar *haystack, const gchar *needle)
+{
+ gsize needle_len;
+ gsize haystack_len;
+ const gchar *ret = NULL;
+ gchar *p;
+ gchar *casefold;
+ gchar *caseless_haystack;
+ gint i;
+
+ g_return_val_if_fail (haystack != NULL, NULL);
+ g_return_val_if_fail (needle != NULL, NULL);
+
+ casefold = g_utf8_casefold (haystack, -1);
+ caseless_haystack = g_utf8_normalize (casefold, -1, G_NORMALIZE_NFD);
+ g_free (casefold);
+
+ needle_len = g_utf8_strlen (needle, -1);
+ haystack_len = g_utf8_strlen (caseless_haystack, -1);
+
+ if (needle_len == 0)
+ {
+ ret = (gchar *)haystack;
+ goto finally_1;
+ }
+
+ if (haystack_len < needle_len)
+ {
+ ret = NULL;
+ goto finally_1;
+ }
+
+ p = (gchar*)caseless_haystack;
+ needle_len = strlen (needle);
+ i = 0;
+
+ while (*p)
+ {
+ if (exact_prefix_cmp (p, needle, needle_len))
+ {
+ ret = pointer_from_offset_skipping_decomp (haystack, i);
+ goto finally_1;
+ }
+
+ p = g_utf8_next_char (p);
+ i++;
+ }
+
+finally_1:
+ g_free (caseless_haystack);
+
+ return ret;
+}
+
+static const gchar *
+utf8_strrcasestr (const gchar *haystack, const gchar *needle)
+{
+ gsize needle_len;
+ gsize haystack_len;
+ const gchar *ret = NULL;
+ gchar *p;
+ gchar *casefold;
+ gchar *caseless_haystack;
+ gint i;
+
+ g_return_val_if_fail (haystack != NULL, NULL);
+ g_return_val_if_fail (needle != NULL, NULL);
+
+ casefold = g_utf8_casefold (haystack, -1);
+ caseless_haystack = g_utf8_normalize (casefold, -1, G_NORMALIZE_NFD);
+ g_free (casefold);
+
+ needle_len = g_utf8_strlen (needle, -1);
+ haystack_len = g_utf8_strlen (caseless_haystack, -1);
+
+ if (needle_len == 0)
+ {
+ ret = (gchar *)haystack;
+ goto finally_1;
+ }
+
+ if (haystack_len < needle_len)
+ {
+ ret = NULL;
+ goto finally_1;
+ }
+
+ i = haystack_len - needle_len;
+ p = g_utf8_offset_to_pointer (caseless_haystack, i);
+ needle_len = strlen (needle);
+
+ while (p >= caseless_haystack)
+ {
+ if (exact_prefix_cmp (p, needle, needle_len))
+ {
+ ret = pointer_from_offset_skipping_decomp (haystack, i);
+ goto finally_1;
+ }
+
+ p = g_utf8_prev_char (p);
+ i--;
+ }
+
+finally_1:
+ g_free (caseless_haystack);
+
+ return ret;
+}
+
+static gboolean
+utf8_caselessnmatch (const char *s1, const char *s2,
+ gssize n1, gssize n2)
+{
+ gchar *casefold;
+ gchar *normalized_s1;
+ gchar *normalized_s2;
+ gint len_s1;
+ gint len_s2;
+ gboolean ret = FALSE;
+
+ g_return_val_if_fail (s1 != NULL, FALSE);
+ g_return_val_if_fail (s2 != NULL, FALSE);
+ g_return_val_if_fail (n1 > 0, FALSE);
+ g_return_val_if_fail (n2 > 0, FALSE);
+
+ casefold = g_utf8_casefold (s1, n1);
+ normalized_s1 = g_utf8_normalize (casefold, -1, G_NORMALIZE_NFD);
+ g_free (casefold);
+
+ casefold = g_utf8_casefold (s2, n2);
+ normalized_s2 = g_utf8_normalize (casefold, -1, G_NORMALIZE_NFD);
+ g_free (casefold);
+
+ len_s1 = strlen (normalized_s1);
+ len_s2 = strlen (normalized_s2);
+
+ if (len_s1 < len_s2)
+ goto finally_2;
+
+ ret = (strncmp (normalized_s1, normalized_s2, len_s2) == 0);
+
+finally_2:
+ g_free (normalized_s1);
+ g_free (normalized_s2);
+
+ return ret;
+}
+
+/* FIXME: total horror */
+static gboolean
+char_is_invisible (const GtkTextIter *iter)
+{
+ GSList *tags;
+ gboolean invisible = FALSE;
+ tags = gtk_text_iter_get_tags (iter);
+ while (tags)
+ {
+ gboolean this_invisible, invisible_set;
+ g_object_get (tags->data, "invisible", &this_invisible,
+ "invisible-set", &invisible_set, NULL);
+ if (invisible_set)
+ invisible = this_invisible;
+ tags = g_slist_delete_link (tags, tags);
+ }
+ return invisible;
+}
+
+static void
+forward_chars_with_skipping (GtkTextIter *iter,
+ gint count,
+ gboolean skip_invisible,
+ gboolean skip_nontext,
+ gboolean skip_decomp)
+{
+ gint i;
+
+ g_return_if_fail (count >= 0);
+
+ i = count;
+
+ while (i > 0)
+ {
+ gboolean ignored = FALSE;
+
+ /* minimal workaround to avoid the infinite loop of bug #168247.
+ * It doesn't fix the problemjust the symptom...
+ */
+ if (gtk_text_iter_is_end (iter))
+ return;
+
+ if (skip_nontext && gtk_text_iter_get_char (iter) == GTK_TEXT_UNKNOWN_CHAR)
+ ignored = TRUE;
+
+ /* FIXME: char_is_invisible() gets list of tags for each char there,
+ and checks every tag. It doesn't sound like a good idea. */
+ if (!ignored && skip_invisible && char_is_invisible (iter))
+ ignored = TRUE;
+
+ if (!ignored && skip_decomp)
+ {
+ /* being UTF8 correct sucks; this accounts for extra
+ offsets coming from canonical decompositions of
+ UTF8 characters (e.g. accented characters) which
+ g_utf8_normalize() performs */
+ gchar *normal;
+ gchar buffer[6];
+ gint buffer_len;
+
+ buffer_len = g_unichar_to_utf8 (gtk_text_iter_get_char (iter), buffer);
+ normal = g_utf8_normalize (buffer, buffer_len, G_NORMALIZE_NFD);
+ i -= (g_utf8_strlen (normal, -1) - 1);
+ g_free (normal);
+ }
+
+ gtk_text_iter_forward_char (iter);
+
+ if (!ignored)
+ --i;
+ }
+}
+
+static gboolean
+lines_match (const GtkTextIter *start,
+ const gchar **lines,
+ gboolean visible_only,
+ gboolean slice,
+ GtkTextIter *match_start,
+ GtkTextIter *match_end)
+{
+ GtkTextIter next;
+ gchar *line_text;
+ const gchar *found;
+ gint offset;
+
+ if (*lines == NULL || **lines == '\0')
+ {
+ if (match_start)
+ *match_start = *start;
+ if (match_end)
+ *match_end = *start;
+ return TRUE;
+ }
+
+ next = *start;
+ gtk_text_iter_forward_line (&next);
+
+ /* No more text in buffer, but *lines is nonempty */
+ if (gtk_text_iter_equal (start, &next))
+ return FALSE;
+
+ if (slice)
+ {
+ if (visible_only)
+ line_text = gtk_text_iter_get_visible_slice (start, &next);
+ else
+ line_text = gtk_text_iter_get_slice (start, &next);
+ }
+ else
+ {
+ if (visible_only)
+ line_text = gtk_text_iter_get_visible_text (start, &next);
+ else
+ line_text = gtk_text_iter_get_text (start, &next);
+ }
+
+ if (match_start) /* if this is the first line we're matching */
+ {
+ found = utf8_strcasestr (line_text, *lines);
+ }
+ else
+ {
+ /* If it's not the first line, we have to match from the
+ * start of the line.
+ */
+ if (utf8_caselessnmatch (line_text, *lines, strlen (line_text),
+ strlen (*lines)))
+ found = line_text;
+ else
+ found = NULL;
+ }
+
+ if (found == NULL)
+ {
+ g_free (line_text);
+ return FALSE;
+ }
+
+ /* Get offset to start of search string */
+ offset = g_utf8_strlen (line_text, found - line_text);
+
+ next = *start;
+
+ /* If match start needs to be returned, set it to the
+ * start of the search string.
+ */
+ forward_chars_with_skipping (&next, offset, visible_only, !slice, FALSE);
+ if (match_start)
+ {
+ *match_start = next;
+ }
+
+ /* Go to end of search string */
+ forward_chars_with_skipping (&next, g_utf8_strlen (*lines, -1), visible_only, !slice, TRUE);
+
+ g_free (line_text);
+
+ ++lines;
+
+ if (match_end)
+ *match_end = next;
+
+ /* pass NULL for match_start, since we don't need to find the
+ * start again.
+ */
+ return lines_match (&next, lines, visible_only, slice, NULL, match_end);
+}
+
+static gboolean
+backward_lines_match (const GtkTextIter *start,
+ const gchar **lines,
+ gboolean visible_only,
+ gboolean slice,
+ GtkTextIter *match_start,
+ GtkTextIter *match_end)
+{
+ GtkTextIter line, next;
+ gchar *line_text;
+ const gchar *found;
+ gint offset;
+
+ if (*lines == NULL || **lines == '\0')
+ {
+ if (match_start)
+ *match_start = *start;
+ if (match_end)
+ *match_end = *start;
+ return TRUE;
+ }
+
+ line = next = *start;
+ if (gtk_text_iter_get_line_offset (&next) == 0)
+ {
+ if (!gtk_text_iter_backward_line (&next))
+ return FALSE;
+ }
+ else
+ gtk_text_iter_set_line_offset (&next, 0);
+
+ if (slice)
+ {
+ if (visible_only)
+ line_text = gtk_text_iter_get_visible_slice (&next, &line);
+ else
+ line_text = gtk_text_iter_get_slice (&next, &line);
+ }
+ else
+ {
+ if (visible_only)
+ line_text = gtk_text_iter_get_visible_text (&next, &line);
+ else
+ line_text = gtk_text_iter_get_text (&next, &line);
+ }
+
+ if (match_start) /* if this is the first line we're matching */
+ {
+ found = utf8_strrcasestr (line_text, *lines);
+ }
+ else
+ {
+ /* If it's not the first line, we have to match from the
+ * start of the line.
+ */
+ if (utf8_caselessnmatch (line_text, *lines, strlen (line_text),
+ strlen (*lines)))
+ found = line_text;
+ else
+ found = NULL;
+ }
+
+ if (found == NULL)
+ {
+ g_free (line_text);
+ return FALSE;
+ }
+
+ /* Get offset to start of search string */
+ offset = g_utf8_strlen (line_text, found - line_text);
+
+ forward_chars_with_skipping (&next, offset, visible_only, !slice, FALSE);
+
+ /* If match start needs to be returned, set it to the
+ * start of the search string.
+ */
+ if (match_start)
+ {
+ *match_start = next;
+ }
+
+ /* Go to end of search string */
+ forward_chars_with_skipping (&next, g_utf8_strlen (*lines, -1), visible_only, !slice, TRUE);
+
+ g_free (line_text);
+
+ ++lines;
+
+ if (match_end)
+ *match_end = next;
+
+ /* try to match the rest of the lines forward, passing NULL
+ * for match_start so lines_match will try to match the entire
+ * line */
+ return lines_match (&next, lines, visible_only,
+ slice, NULL, match_end);
+}
+
+/* strsplit () that retains the delimiter as part of the string. */
+static gchar **
+breakup_string (const char *string,
+ const char *delimiter,
+ gint max_tokens)
+{
+ GSList *string_list = NULL, *slist;
+ gchar **str_array, *s, *casefold, *new_string;
+ guint i, n = 1;
+
+ g_return_val_if_fail (string != NULL, NULL);
+ g_return_val_if_fail (delimiter != NULL, NULL);
+
+ if (max_tokens < 1)
+ max_tokens = G_MAXINT;
+
+ s = strstr (string, delimiter);
+ if (s)
+ {
+ guint delimiter_len = strlen (delimiter);
+
+ do
+ {
+ guint len;
+
+ len = s - string + delimiter_len;
+ new_string = g_new (gchar, len + 1);
+ strncpy (new_string, string, len);
+ new_string[len] = 0;
+ casefold = g_utf8_casefold (new_string, -1);
+ g_free (new_string);
+ new_string = g_utf8_normalize (casefold, -1, G_NORMALIZE_NFD);
+ g_free (casefold);
+ string_list = g_slist_prepend (string_list, new_string);
+ n++;
+ string = s + delimiter_len;
+ s = strstr (string, delimiter);
+ } while (--max_tokens && s);
+ }
+
+ if (*string)
+ {
+ n++;
+ casefold = g_utf8_casefold (string, -1);
+ new_string = g_utf8_normalize (casefold, -1, G_NORMALIZE_NFD);
+ g_free (casefold);
+ string_list = g_slist_prepend (string_list, new_string);
+ }
+
+ str_array = g_new (gchar*, n);
+
+ i = n - 1;
+
+ str_array[i--] = NULL;
+ for (slist = string_list; slist; slist = slist->next)
+ str_array[i--] = slist->data;
+
+ g_slist_free (string_list);
+
+ return str_array;
+}
+
+static gboolean
+gdict_defbox_iter_forward_search (const GtkTextIter *iter,
+ const gchar *str,
+ GtkTextIter *match_start,
+ GtkTextIter *match_end,
+ const GtkTextIter *limit)
+{
+ gchar **lines = NULL;
+ GtkTextIter match;
+ gboolean retval = FALSE;
+ GtkTextIter search;
+
+ g_return_val_if_fail (iter != NULL, FALSE);
+ g_return_val_if_fail (str != NULL, FALSE);
+
+ if (limit && gtk_text_iter_compare (iter, limit) >= 0)
+ return FALSE;
+
+ if (*str == '\0')
+ {
+ /* If we can move one char, return the empty string there */
+ match = *iter;
+
+ if (gtk_text_iter_forward_char (&match))
+ {
+ if (limit && gtk_text_iter_equal (&match, limit))
+ return FALSE;
+
+ if (match_start)
+ *match_start = match;
+
+ if (match_end)
+ *match_end = match;
+
+ return TRUE;
+ }
+ else
+ return FALSE;
+ }
+
+ /* locate all lines */
+ lines = breakup_string (str, "\n", -1);
+
+ search = *iter;
+
+ /* This loop has an inefficient worst-case, where
+ * gtk_text_iter_get_text () is called repeatedly on
+ * a single line.
+ */
+ do
+ {
+ GtkTextIter end;
+ gboolean res;
+
+ if (limit && gtk_text_iter_compare (&search, limit) >= 0)
+ break;
+
+ res = lines_match (&search, (const gchar**)lines,
+ TRUE, FALSE,
+ &match, &end);
+ if (res)
+ {
+ if (limit == NULL ||
+ (limit && gtk_text_iter_compare (&end, limit) <= 0))
+ {
+ retval = TRUE;
+
+ if (match_start)
+ *match_start = match;
+
+ if (match_end)
+ *match_end = end;
+ }
+
+ break;
+ }
+ } while (gtk_text_iter_forward_line (&search));
+
+ g_strfreev ((gchar**) lines);
+
+ return retval;
+}
+
+static gboolean
+gdict_defbox_iter_backward_search (const GtkTextIter *iter,
+ const gchar *str,
+ GtkTextIter *match_start,
+ GtkTextIter *match_end,
+ const GtkTextIter *limit)
+{
+ gchar **lines = NULL;
+ GtkTextIter match;
+ gboolean retval = FALSE;
+ GtkTextIter search;
+
+ g_return_val_if_fail (iter != NULL, FALSE);
+ g_return_val_if_fail (str != NULL, FALSE);
+
+ if (limit && gtk_text_iter_compare (iter, limit) <= 0)
+ return FALSE;
+
+ if (*str == '\0')
+ {
+ /* If we can move one char, return the empty string there */
+ match = *iter;
+
+ if (gtk_text_iter_backward_char (&match))
+ {
+ if (limit && gtk_text_iter_equal (&match, limit))
+ return FALSE;
+
+ if (match_start)
+ *match_start = match;
+
+ if (match_end)
+ *match_end = match;
+
+ return TRUE;
+ }
+ else
+ return FALSE;
+ }
+
+ /* locate all lines */
+ lines = breakup_string (str, "\n", -1);
+
+ search = *iter;
+
+ /* This loop has an inefficient worst-case, where
+ * gtk_text_iter_get_text () is called repeatedly on
+ * a single line.
+ */
+ while (TRUE)
+ {
+ GtkTextIter end;
+ gboolean res;
+
+ if (limit && gtk_text_iter_compare (&search, limit) <= 0)
+ break;
+
+ res = backward_lines_match (&search, (const gchar**)lines,
+ TRUE, FALSE,
+ &match, &end);
+ if (res)
+ {
+ if (limit == NULL ||
+ (limit && gtk_text_iter_compare (&end, limit) > 0))
+ {
+ retval = TRUE;
+
+ if (match_start)
+ *match_start = match;
+
+ if (match_end)
+ *match_end = end;
+
+ }
+
+ break;
+ }
+
+ if (gtk_text_iter_get_line_offset (&search) == 0)
+ {
+ if (!gtk_text_iter_backward_line (&search))
+ break;
+ }
+ else
+ gtk_text_iter_set_line_offset (&search, 0);
+ }
+
+ g_strfreev ((gchar**) lines);
+
+ return retval;
+}
+
+static gboolean
+gdict_defbox_find_backward (GdictDefbox *defbox,
+ const gchar *text)
+{
+ GdictDefboxPrivate *priv = defbox->priv;
+ GtkTextIter start_iter, end_iter;
+ GtkTextIter match_start, match_end;
+ GtkTextIter iter;
+ GtkTextMark *last_search;
+ gboolean res;
+
+ g_assert (GTK_IS_TEXT_BUFFER (priv->buffer));
+
+ gtk_text_buffer_get_bounds (priv->buffer, &start_iter, &end_iter);
+
+ /* if there already has been another result, begin from there */
+ last_search = gtk_text_buffer_get_mark (priv->buffer, "last-search-prev");
+ if (last_search)
+ gtk_text_buffer_get_iter_at_mark (priv->buffer, &iter, last_search);
+ else
+ iter = end_iter;
+
+ res = gdict_defbox_iter_backward_search (&iter, text,
+ &match_start, &match_end,
+ NULL);
+ if (res)
+ {
+ gtk_text_view_scroll_to_iter (GTK_TEXT_VIEW (priv->text_view),
+ &match_start,
+ 0.0,
+ TRUE,
+ 0.0, 0.0);
+ gtk_text_buffer_place_cursor (priv->buffer, &match_end);
+ gtk_text_buffer_move_mark (priv->buffer,
+ gtk_text_buffer_get_mark (priv->buffer, "selection_bound"),
+ &match_start);
+ gtk_text_buffer_create_mark (priv->buffer, "last-search-prev", &match_start, FALSE);
+ gtk_text_buffer_create_mark (priv->buffer, "last-search-next", &match_end, FALSE);
+
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+static gboolean
+hide_find_pane (gpointer user_data)
+{
+ GdictDefbox *defbox = user_data;
+
+ gtk_widget_hide (defbox->priv->find_pane);
+ defbox->priv->show_find = FALSE;
+
+ gtk_widget_grab_focus (defbox->priv->text_view);
+
+ defbox->priv->hide_timeout = 0;
+
+ return FALSE;
+}
+
+static void
+find_prev_clicked_cb (GtkWidget *widget,
+ gpointer user_data)
+{
+ GdictDefbox *defbox = GDICT_DEFBOX (user_data);
+ GdictDefboxPrivate *priv = defbox->priv;
+ const gchar *text;
+ gboolean found;
+
+ gtk_widget_hide (priv->find_label);
+
+ text = gtk_entry_get_text (GTK_ENTRY (priv->find_entry));
+ if (!text)
+ return;
+
+ found = gdict_defbox_find_backward (defbox, text);
+ if (!found)
+ {
+ gchar *str;
+
+ str = g_strconcat (" <i>", _("Not found"), "</i>", NULL);
+ gtk_label_set_markup (GTK_LABEL (priv->find_label), str);
+ gtk_widget_show (priv->find_label);
+
+ g_free (str);
+ }
+
+ if (priv->hide_timeout)
+ {
+ g_source_remove (priv->hide_timeout);
+ priv->hide_timeout = g_timeout_add (5000, hide_find_pane, defbox);
+ }
+}
+
+static gboolean
+gdict_defbox_find_forward (GdictDefbox *defbox,
+ const gchar *text,
+ gboolean is_typing)
+{
+ GdictDefboxPrivate *priv = defbox->priv;
+ GtkTextIter start_iter, end_iter;
+ GtkTextIter match_start, match_end;
+ GtkTextIter iter;
+ GtkTextMark *last_search;
+ gboolean res;
+
+ g_assert (GTK_IS_TEXT_BUFFER (priv->buffer));
+
+ gtk_text_buffer_get_bounds (priv->buffer, &start_iter, &end_iter);
+
+ if (!is_typing)
+ {
+ /* if there already has been another result, begin from there */
+ last_search = gtk_text_buffer_get_mark (priv->buffer, "last-search-next");
+
+ if (last_search)
+ gtk_text_buffer_get_iter_at_mark (priv->buffer, &iter, last_search);
+ else
+ iter = start_iter;
+ }
+ else
+ {
+ last_search = gtk_text_buffer_get_mark (priv->buffer, "last-search-prev");
+
+ if (last_search)
+ gtk_text_buffer_get_iter_at_mark (priv->buffer, &iter, last_search);
+ else
+ iter = start_iter;
+ }
+
+ res = gdict_defbox_iter_forward_search (&iter, text,
+ &match_start,
+ &match_end,
+ NULL);
+ if (res)
+ {
+ gtk_text_view_scroll_to_iter (GTK_TEXT_VIEW (priv->text_view),
+ &match_start,
+ 0.0,
+ TRUE,
+ 0.0, 0.0);
+ gtk_text_buffer_place_cursor (priv->buffer, &match_end);
+ gtk_text_buffer_move_mark (priv->buffer,
+ gtk_text_buffer_get_mark (priv->buffer, "selection_bound"),
+ &match_start);
+ gtk_text_buffer_create_mark (priv->buffer, "last-search-prev", &match_start, FALSE);
+ gtk_text_buffer_create_mark (priv->buffer, "last-search-next", &match_end, FALSE);
+
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+static void
+find_next_clicked_cb (GtkWidget *widget,
+ gpointer user_data)
+{
+ GdictDefbox *defbox = GDICT_DEFBOX (user_data);
+ GdictDefboxPrivate *priv = defbox->priv;
+ const gchar *text;
+ gboolean found;
+
+ gtk_widget_hide (priv->find_label);
+
+ text = gtk_entry_get_text (GTK_ENTRY (priv->find_entry));
+ if (!text)
+ return;
+
+ found = gdict_defbox_find_forward (defbox, text, FALSE);
+ if (!found)
+ {
+ gchar *str;
+
+ str = g_strconcat (" <i>", _("Not found"), "</i>", NULL);
+ gtk_label_set_markup (GTK_LABEL (priv->find_label), str);
+ gtk_widget_show (priv->find_label);
+
+ g_free (str);
+ }
+
+ if (priv->hide_timeout)
+ {
+ g_source_remove (priv->hide_timeout);
+ priv->hide_timeout = g_timeout_add (5000, hide_find_pane, defbox);
+ }
+}
+
+static void
+find_entry_changed_cb (GtkWidget *widget,
+ gpointer user_data)
+{
+ GdictDefbox *defbox = GDICT_DEFBOX (user_data);
+ GdictDefboxPrivate *priv = defbox->priv;
+ gchar *text;
+ gboolean found;
+
+ gtk_widget_hide (priv->find_label);
+
+ text = gtk_editable_get_chars (GTK_EDITABLE (widget), 0, -1);
+ if (!text)
+ return;
+
+ found = gdict_defbox_find_forward (defbox, text, TRUE);
+ if (!found)
+ {
+ gchar *str;
+
+ str = g_strconcat (" <i>", _("Not found"), "</i>", NULL);
+ gtk_label_set_markup (GTK_LABEL (priv->find_label), str);
+ gtk_widget_show (priv->find_label);
+
+ g_free (str);
+ }
+
+ g_free (text);
+
+ if (priv->hide_timeout)
+ {
+ g_source_remove (priv->hide_timeout);
+ priv->hide_timeout = g_timeout_add (5000, hide_find_pane, defbox);
+ }
+}
+
+static void
+close_button_clicked (GtkButton *button,
+ gpointer data)
+{
+ GdictDefboxPrivate *priv = GDICT_DEFBOX (data)->priv;
+
+ if (priv->hide_timeout)
+ g_source_remove (priv->hide_timeout);
+
+ (void) hide_find_pane (data);
+}
+
+static GtkWidget *
+create_find_pane (GdictDefbox *defbox)
+{
+ GdictDefboxPrivate *priv;
+ GtkWidget *find_pane;
+ GtkWidget *label;
+ GtkWidget *sep;
+ GtkWidget *hbox1, *hbox2;
+ GtkWidget *button;
+
+ priv = defbox->priv;
+
+ find_pane = gtk_hbox_new (FALSE, 0);
+ gtk_container_set_border_width (GTK_CONTAINER (find_pane), 0);
+
+ hbox1 = gtk_hbox_new (FALSE, 6);
+ gtk_box_pack_start (GTK_BOX (find_pane), hbox1, TRUE, TRUE, 0);
+ gtk_widget_show (hbox1);
+
+ button = gtk_button_new ();
+ gtk_button_set_relief (GTK_BUTTON (button), GTK_RELIEF_NONE);
+ gtk_button_set_image (GTK_BUTTON (button),
+ gtk_image_new_from_stock (GTK_STOCK_CLOSE,
+ GTK_ICON_SIZE_BUTTON));
+ g_signal_connect (button, "clicked",
+ G_CALLBACK (close_button_clicked), defbox);
+ gtk_box_pack_start (GTK_BOX (hbox1), button, FALSE, FALSE, 0);
+ gtk_widget_show (button);
+
+ hbox2 = gtk_hbox_new (FALSE, 12);
+ gtk_box_pack_start (GTK_BOX (hbox1), hbox2, TRUE, TRUE, 0);
+ gtk_widget_show (hbox2);
+
+ label = gtk_label_new_with_mnemonic (_("F_ind:"));
+ gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, FALSE, 0);
+
+ priv->find_entry = gtk_entry_new ();
+ g_signal_connect (priv->find_entry, "changed",
+ G_CALLBACK (find_entry_changed_cb), defbox);
+ gtk_box_pack_start (GTK_BOX (hbox2), priv->find_entry, TRUE, TRUE, 0);
+ gtk_label_set_mnemonic_widget (GTK_LABEL (label), priv->find_entry);
+
+ sep = gtk_vseparator_new ();
+ gtk_box_pack_start (GTK_BOX (hbox1), sep, FALSE, FALSE, 0);
+ gtk_widget_show (sep);
+
+ priv->find_prev = gtk_button_new_with_mnemonic (_("_Previous"));
+ gtk_button_set_image (GTK_BUTTON (priv->find_prev),
+ gtk_image_new_from_stock (GTK_STOCK_GO_BACK,
+ GTK_ICON_SIZE_MENU));
+ g_signal_connect (priv->find_prev, "clicked",
+ G_CALLBACK (find_prev_clicked_cb), defbox);
+ gtk_box_pack_start (GTK_BOX (hbox1), priv->find_prev, FALSE, FALSE, 0);
+
+ priv->find_next = gtk_button_new_with_mnemonic (_("_Next"));
+ gtk_button_set_image (GTK_BUTTON (priv->find_next),
+ gtk_image_new_from_stock (GTK_STOCK_GO_FORWARD,
+ GTK_ICON_SIZE_MENU));
+ g_signal_connect (priv->find_next, "clicked",
+ G_CALLBACK (find_next_clicked_cb), defbox);
+ gtk_box_pack_start (GTK_BOX (hbox1), priv->find_next, FALSE, FALSE, 0);
+
+ priv->find_label = gtk_label_new (NULL);
+ gtk_label_set_use_markup (GTK_LABEL (priv->find_label), TRUE);
+ gtk_box_pack_end (GTK_BOX (find_pane), priv->find_label, FALSE, FALSE, 0);
+ gtk_widget_hide (priv->find_label);
+
+ return find_pane;
+}
+
+static void
+gdict_defbox_init_tags (GdictDefbox *defbox)
+{
+ GdictDefboxPrivate *priv = defbox->priv;
+ GdkColor *link_color, *visited_link_color;
+
+ g_assert (GTK_IS_TEXT_BUFFER (priv->buffer));
+
+ gtk_text_buffer_create_tag (priv->buffer, "italic",
+ "style", PANGO_STYLE_ITALIC,
+ NULL);
+ gtk_text_buffer_create_tag (priv->buffer, "bold",
+ "weight", PANGO_WEIGHT_BOLD,
+ NULL);
+ gtk_text_buffer_create_tag (priv->buffer, "underline",
+ "underline", PANGO_UNDERLINE_SINGLE,
+ NULL);
+
+ gtk_text_buffer_create_tag (priv->buffer, "big",
+ "scale", 1.6,
+ NULL);
+ gtk_text_buffer_create_tag (priv->buffer, "small",
+ "scale", PANGO_SCALE_SMALL,
+ NULL);
+
+ link_color = visited_link_color = NULL;
+ gtk_widget_style_get (GTK_WIDGET (defbox),
+ "link-color", &link_color,
+ "visited-link-color", &visited_link_color,
+ NULL);
+ if (!link_color)
+ link_color = &default_link_color;
+
+ if (!visited_link_color)
+ visited_link_color = &default_visited_link_color;
+
+ priv->link_tag =
+ gtk_text_buffer_create_tag (priv->buffer, "link",
+ "underline", PANGO_UNDERLINE_SINGLE,
+ "foreground-gdk", link_color,
+ NULL);
+ priv->visited_link_tag =
+ gtk_text_buffer_create_tag (priv->buffer, "visited-link",
+ "underline", PANGO_UNDERLINE_SINGLE,
+ "foreground-gdk", visited_link_color,
+ NULL);
+
+ if (link_color != &default_link_color)
+ gdk_color_free (link_color);
+
+ if (visited_link_color != &default_visited_link_color)
+ gdk_color_free (visited_link_color);
+
+ gtk_text_buffer_create_tag (priv->buffer, "phonetic",
+ "foreground", "dark gray",
+ NULL);
+
+ gtk_text_buffer_create_tag (priv->buffer, "query-title",
+ "left-margin", QUERY_MARGIN,
+ "pixels-above-lines", 5,
+ "pixels-below-lines", 20,
+ NULL);
+ gtk_text_buffer_create_tag (priv->buffer, "query-from",
+ "foreground", "dark gray",
+ "scale", PANGO_SCALE_SMALL,
+ "left-margin", QUERY_MARGIN,
+ "pixels-above-lines", 5,
+ "pixels-below-lines", 10,
+ NULL);
+
+ gtk_text_buffer_create_tag (priv->buffer, "error-title",
+ "foreground", "dark red",
+ "left-margin", ERROR_MARGIN,
+ NULL);
+ gtk_text_buffer_create_tag (priv->buffer, "error-message",
+ "left-margin", ERROR_MARGIN,
+ NULL);
+}
+
+static void
+follow_if_is_link (GdictDefbox *defbox,
+ GtkTextView *text_view,
+ GtkTextIter *iter)
+{
+ GSList *tags, *l;
+
+ tags = gtk_text_iter_get_tags (iter);
+
+ for (l = tags; l != NULL; l = l->next)
+ {
+ GtkTextTag *tag = l->data;
+ gchar *name;
+
+ g_object_get (G_OBJECT (tag), "name", &name, NULL);
+ if (name &&
+ (strcmp (name, "link") == 0 ||
+ strcmp (name, "visited-link") == 0))
+ {
+ GtkTextBuffer *buffer = gtk_text_view_get_buffer (text_view);
+ GtkTextIter start, end;
+ gchar *link_str;
+
+ start = *iter;
+ end = *iter;
+
+ gtk_text_iter_backward_to_tag_toggle (&start, tag);
+ gtk_text_iter_forward_to_tag_toggle (&end, tag);
+
+ link_str = gtk_text_buffer_get_text (buffer, &start, &end, FALSE);
+
+ g_signal_emit (defbox, gdict_defbox_signals[LINK_CLICKED], 0, link_str);
+
+ g_free (link_str);
+ g_free (name);
+
+ break;
+ }
+
+ g_free (name);
+ }
+
+ g_slist_free (tags);
+}
+
+static gboolean
+defbox_event_after_cb (GtkWidget *text_view,
+ GdkEvent *event,
+ GdictDefbox *defbox)
+{
+ GtkTextIter iter;
+ GtkTextBuffer *buffer;
+ GdkEventButton *button_event;
+ gint bx, by;
+
+ if (event->type != GDK_BUTTON_RELEASE)
+ return FALSE;
+
+ button_event = (GdkEventButton *) event;
+
+ if (button_event->button != 1)
+ return FALSE;
+
+ buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (text_view));
+ if (gtk_text_buffer_get_has_selection (buffer))
+ return FALSE;
+
+ gtk_text_view_window_to_buffer_coords (GTK_TEXT_VIEW (text_view),
+ GTK_TEXT_WINDOW_WIDGET,
+ button_event->x, button_event->y,
+ &bx, &by);
+
+ gtk_text_view_get_iter_at_location (GTK_TEXT_VIEW (text_view),
+ &iter,
+ bx, by);
+
+ follow_if_is_link (defbox, GTK_TEXT_VIEW (text_view), &iter);
+
+ return FALSE;
+}
+
+static void
+set_cursor_if_appropriate (GdictDefbox *defbox,
+ GtkTextView *text_view,
+ gint x,
+ gint y)
+{
+ GdictDefboxPrivate *priv;
+ GSList *tags, *l;
+ GtkTextIter iter;
+ gboolean hovering = FALSE;
+
+ priv = defbox->priv;
+
+ if (!priv->hand_cursor)
+ priv->hand_cursor = gdk_cursor_new (GDK_HAND2);
+
+ if (!priv->regular_cursor)
+ priv->regular_cursor = gdk_cursor_new (GDK_XTERM);
+
+ gtk_text_view_get_iter_at_location (text_view, &iter, x, y);
+
+ tags = gtk_text_iter_get_tags (&iter);
+ for (l = tags; l != NULL; l = l->next)
+ {
+ GtkTextTag *tag = l->data;
+ gchar *name;
+
+ g_object_get (G_OBJECT (tag), "name", &name, NULL);
+ if (name &&
+ (strcmp (name, "link") == 0 ||
+ strcmp (name, "visited-link") == 0))
+ {
+ hovering = TRUE;
+ g_free (name);
+
+ break;
+ }
+
+ g_free (name);
+ }
+
+ if (hovering != defbox->priv->is_hovering)
+ {
+ defbox->priv->is_hovering = hovering;
+
+ if (defbox->priv->is_hovering)
+ gdk_window_set_cursor (gtk_text_view_get_window (text_view,
+ GTK_TEXT_WINDOW_TEXT),
+ defbox->priv->hand_cursor);
+ else
+ gdk_window_set_cursor (gtk_text_view_get_window (text_view,
+ GTK_TEXT_WINDOW_TEXT),
+ defbox->priv->regular_cursor);
+ }
+
+ if (tags)
+ g_slist_free (tags);
+}
+
+static gboolean
+defbox_motion_notify_cb (GtkWidget *text_view,
+ GdkEventMotion *event,
+ GdictDefbox *defbox)
+{
+ gint bx, by;
+
+ gtk_text_view_window_to_buffer_coords (GTK_TEXT_VIEW (text_view),
+ GTK_TEXT_WINDOW_WIDGET,
+ event->x, event->y,
+ &bx, &by);
+
+ set_cursor_if_appropriate (defbox, GTK_TEXT_VIEW (text_view), bx, by);
+
+ gdk_window_get_pointer (gtk_widget_get_window (text_view), NULL, NULL, NULL);
+
+ return FALSE;
+}
+
+static gboolean
+defbox_visibility_notify_cb (GtkWidget *text_view,
+ GdkEventVisibility *event,
+ GdictDefbox *defbox)
+{
+ gint wx, wy;
+ gint bx, by;
+
+ gdk_window_get_pointer (gtk_widget_get_window (text_view), &wx, &wy, NULL);
+
+ gtk_text_view_window_to_buffer_coords (GTK_TEXT_VIEW (text_view),
+ GTK_TEXT_WINDOW_WIDGET,
+ wx, wy,
+ &bx, &by);
+
+ set_cursor_if_appropriate (defbox, GTK_TEXT_VIEW (text_view), bx, by);
+
+ return FALSE;
+}
+
+static GObject *
+gdict_defbox_constructor (GType type,
+ guint n_construct_properties,
+ GObjectConstructParam *construct_params)
+{
+ GdictDefbox *defbox;
+ GdictDefboxPrivate *priv;
+ GObject *object;
+ GtkWidget *sw;
+
+ object = G_OBJECT_CLASS (gdict_defbox_parent_class)->constructor (type,
+ n_construct_properties,
+ construct_params);
+ defbox = GDICT_DEFBOX (object);
+ priv = defbox->priv;
+
+ gtk_widget_push_composite_child ();
+
+ sw = gtk_scrolled_window_new (NULL, NULL);
+ gtk_widget_set_composite_name (sw, "gdict-defbox-scrolled-window");
+ gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
+ GTK_POLICY_AUTOMATIC,
+ GTK_POLICY_AUTOMATIC);
+ gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw),
+ GTK_SHADOW_IN);
+ gtk_box_pack_start (GTK_BOX (defbox), sw, TRUE, TRUE, 0);
+ gtk_widget_show (sw);
+
+ priv->buffer = gtk_text_buffer_new (NULL);
+ gdict_defbox_init_tags (defbox);
+
+ priv->text_view = gtk_text_view_new_with_buffer (priv->buffer);
+ gtk_widget_set_composite_name (priv->text_view, "gdict-defbox-text-view");
+ gtk_text_view_set_editable (GTK_TEXT_VIEW (priv->text_view), FALSE);
+ gtk_text_view_set_left_margin (GTK_TEXT_VIEW (priv->text_view), 4);
+ gtk_container_add (GTK_CONTAINER (sw), priv->text_view);
+ gtk_widget_show (priv->text_view);
+
+ priv->find_pane = create_find_pane (defbox);
+ gtk_widget_set_composite_name (priv->find_pane, "gdict-defbox-find-pane");
+ gtk_box_pack_end (GTK_BOX (defbox), priv->find_pane, FALSE, FALSE, 0);
+
+ /* stuff to make the link machinery work */
+ g_signal_connect (priv->text_view, "event-after",
+ G_CALLBACK (defbox_event_after_cb),
+ defbox);
+ g_signal_connect (priv->text_view, "motion-notify-event",
+ G_CALLBACK (defbox_motion_notify_cb),
+ defbox);
+ g_signal_connect (priv->text_view, "visibility-notify-event",
+ G_CALLBACK (defbox_visibility_notify_cb),
+ defbox);
+
+ gtk_widget_pop_composite_child ();
+
+ return object;
+}
+
+static void
+gdict_defbox_style_set (GtkWidget *widget,
+ GtkStyle *old_style)
+{
+ GdictDefboxPrivate *priv = GDICT_DEFBOX (widget)->priv;
+ GdkColor *link_color, *visited_link_color;
+
+ if (GTK_WIDGET_CLASS (gdict_defbox_parent_class)->style_set)
+ GTK_WIDGET_CLASS (gdict_defbox_parent_class)->style_set (widget, old_style);
+
+ link_color = visited_link_color = NULL;
+ gtk_widget_style_get (widget,
+ "link-color", &link_color,
+ "visited-link-color", &visited_link_color,
+ NULL);
+ if (!link_color)
+ link_color = &default_link_color;
+
+ if (!visited_link_color)
+ visited_link_color = &default_visited_link_color;
+
+ g_object_set (G_OBJECT (priv->link_tag),
+ "foreground-gdk", link_color,
+ NULL);
+
+ g_object_set (G_OBJECT (priv->visited_link_tag),
+ "foreground-gdk", visited_link_color,
+ NULL);
+
+ if (link_color != &default_link_color)
+ gdk_color_free (link_color);
+
+ if (visited_link_color != &default_visited_link_color)
+ gdk_color_free (visited_link_color);
+}
+
+/* we override the GtkWidget::show_all method since we have widgets
+ * we don't want to show, such as the find pane
+ */
+static void
+gdict_defbox_show_all (GtkWidget *widget)
+{
+ GdictDefbox *defbox = GDICT_DEFBOX (widget);
+ GdictDefboxPrivate *priv = defbox->priv;
+
+ gtk_widget_show (widget);
+
+ if (priv->show_find)
+ gtk_widget_show_all (priv->find_pane);
+}
+
+static void
+gdict_defbox_real_show_find (GdictDefbox *defbox)
+{
+ gtk_widget_show_all (defbox->priv->find_pane);
+ defbox->priv->show_find = TRUE;
+
+ gtk_widget_grab_focus (defbox->priv->find_entry);
+
+ defbox->priv->hide_timeout = g_timeout_add (5000, hide_find_pane, defbox);
+}
+
+static void
+gdict_defbox_real_find_next (GdictDefbox *defbox)
+{
+ /* synthetize a "clicked" signal to the "next" button */
+ gtk_button_clicked (GTK_BUTTON (defbox->priv->find_next));
+}
+
+static void
+gdict_defbox_real_find_previous (GdictDefbox *defbox)
+{
+ /* synthetize a "clicked" signal to the "prev" button */
+ gtk_button_clicked (GTK_BUTTON (defbox->priv->find_prev));
+}
+
+static void
+gdict_defbox_real_hide_find (GdictDefbox *defbox)
+{
+ gtk_widget_hide (defbox->priv->find_pane);
+ defbox->priv->show_find = FALSE;
+
+ gtk_widget_grab_focus (defbox->priv->text_view);
+
+ if (defbox->priv->hide_timeout)
+ {
+ g_source_remove (defbox->priv->hide_timeout);
+ defbox->priv->hide_timeout = 0;
+ }
+}
+
+static void
+gdict_defbox_class_init (GdictDefboxClass *klass)
+{
+ GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+ GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
+ GtkBindingSet *binding_set;
+
+ gobject_class->constructor = gdict_defbox_constructor;
+ gobject_class->set_property = gdict_defbox_set_property;
+ gobject_class->get_property = gdict_defbox_get_property;
+ gobject_class->dispose = gdict_defbox_dispose;
+ gobject_class->finalize = gdict_defbox_finalize;
+
+ widget_class->show_all = gdict_defbox_show_all;
+ widget_class->style_set = gdict_defbox_style_set;
+
+ /**
+ * GdictDefbox:word:
+ *
+ * The word to look up.
+ *
+ * Since: 0.10
+ */
+ g_object_class_install_property (gobject_class,
+ PROP_WORD,
+ g_param_spec_string ("word",
+ "Word",
+ "The word to look up",
+ NULL,
+ G_PARAM_READWRITE));
+ /**
+ * GdictDefbox:context:
+ *
+ * The #GdictContext object used to get the word definition.
+ *
+ * Since: 0.1
+ */
+ g_object_class_install_property (gobject_class,
+ PROP_CONTEXT,
+ g_param_spec_object ("context",
+ "Context",
+ "The GdictContext object used to get the word definition",
+ GDICT_TYPE_CONTEXT,
+ (G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT)));
+ /**
+ * GdictDefbox:database
+ *
+ * The database used by the #GdictDefbox bound to this object to get the word
+ * definition.
+ *
+ * Since: 0.1
+ */
+ g_object_class_install_property (gobject_class,
+ PROP_DATABASE,
+ g_param_spec_string ("database",
+ "Database",
+ "The database used to query the GdictContext",
+ GDICT_DEFAULT_DATABASE,
+ (G_PARAM_READABLE | G_PARAM_WRITABLE)));
+ /**
+ * GdictDefbox:font-name
+ *
+ * The name of the font used by the #GdictDefbox to display the definitions.
+ * use the same string you use for pango_font_description_from_string().
+ *
+ * Since: 0.3
+ */
+ g_object_class_install_property (gobject_class,
+ PROP_FONT_NAME,
+ g_param_spec_string ("font-name",
+ "Font Name",
+ "The font to be used by the defbox",
+ GDICT_DEFAULT_FONT_NAME,
+ (G_PARAM_READABLE | G_PARAM_WRITABLE)));
+
+ gdict_defbox_signals[SHOW_FIND] =
+ g_signal_new ("show-find",
+ G_OBJECT_CLASS_TYPE (gobject_class),
+ G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
+ G_STRUCT_OFFSET (GdictDefboxClass, show_find),
+ NULL, NULL,
+ gdict_marshal_VOID__VOID,
+ G_TYPE_NONE, 0);
+ gdict_defbox_signals[FIND_PREVIOUS] =
+ g_signal_new ("find-previous",
+ G_OBJECT_CLASS_TYPE (gobject_class),
+ G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
+ G_STRUCT_OFFSET (GdictDefboxClass, find_previous),
+ NULL, NULL,
+ gdict_marshal_VOID__VOID,
+ G_TYPE_NONE, 0);
+ gdict_defbox_signals[FIND_NEXT] =
+ g_signal_new ("find-next",
+ G_OBJECT_CLASS_TYPE (gobject_class),
+ G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
+ G_STRUCT_OFFSET (GdictDefboxClass, find_next),
+ NULL, NULL,
+ gdict_marshal_VOID__VOID,
+ G_TYPE_NONE, 0);
+ gdict_defbox_signals[HIDE_FIND] =
+ g_signal_new ("hide-find",
+ G_OBJECT_CLASS_TYPE (gobject_class),
+ G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
+ G_STRUCT_OFFSET (GdictDefboxClass, hide_find),
+ NULL, NULL,
+ gdict_marshal_VOID__VOID,
+ G_TYPE_NONE, 0);
+ gdict_defbox_signals[LINK_CLICKED] =
+ g_signal_new ("link-clicked",
+ G_OBJECT_CLASS_TYPE (gobject_class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (GdictDefboxClass, link_clicked),
+ NULL, NULL,
+ gdict_marshal_VOID__STRING,
+ G_TYPE_NONE, 1,
+ G_TYPE_STRING);
+
+ klass->show_find = gdict_defbox_real_show_find;
+ klass->hide_find = gdict_defbox_real_hide_find;
+ klass->find_next = gdict_defbox_real_find_next;
+ klass->find_previous = gdict_defbox_real_find_previous;
+
+ binding_set = gtk_binding_set_by_class (klass);
+ gtk_binding_entry_add_signal (binding_set,
+ GDK_f, GDK_CONTROL_MASK,
+ "show-find",
+ 0);
+ gtk_binding_entry_add_signal (binding_set,
+ GDK_g, GDK_CONTROL_MASK,
+ "find-next",
+ 0);
+ gtk_binding_entry_add_signal (binding_set,
+ GDK_g, GDK_SHIFT_MASK | GDK_CONTROL_MASK,
+ "find-previous",
+ 0);
+ gtk_binding_entry_add_signal (binding_set,
+ GDK_Escape, 0,
+ "hide-find",
+ 0);
+
+ g_type_class_add_private (klass, sizeof (GdictDefboxPrivate));
+}
+
+static void
+gdict_defbox_init (GdictDefbox *defbox)
+{
+ GdictDefboxPrivate *priv;
+
+ gtk_box_set_spacing (GTK_BOX (defbox), 6);
+
+ priv = GDICT_DEFBOX_GET_PRIVATE (defbox);
+ defbox->priv = priv;
+
+ priv->context = NULL;
+ priv->database = g_strdup (GDICT_DEFAULT_DATABASE);
+ priv->font_name = g_strdup (GDICT_DEFAULT_FONT_NAME);
+ priv->word = NULL;
+
+ priv->definitions = NULL;
+
+ priv->busy_cursor = NULL;
+ priv->hand_cursor = NULL;
+ priv->regular_cursor = NULL;
+
+ priv->show_find = FALSE;
+ priv->is_searching = FALSE;
+ priv->is_hovering = FALSE;
+
+ priv->hide_timeout = 0;
+}
+
+/**
+ * gdict_defbox_new:
+ *
+ * Creates a new #GdictDefbox widget. Use this widget to search for
+ * a word using a #GdictContext, and to show the resulting definition(s).
+ * You must set a #GdictContext for this widget using
+ * gdict_defbox_set_context().
+ *
+ * Return value: a new #GdictDefbox widget.
+ *
+ * Since: 0.1
+ */
+GtkWidget *
+gdict_defbox_new (void)
+{
+ return g_object_new (GDICT_TYPE_DEFBOX, NULL);
+}
+
+/**
+ * gdict_defbox_new_with_context:
+ * @context: a #GdictContext
+ *
+ * Creates a new #GdictDefbox widget. Use this widget to search for
+ * a word using @context, and to show the resulting definition.
+ *
+ * Return value: a new #GdictDefbox widget.
+ *
+ * Since: 0.1
+ */
+GtkWidget *
+gdict_defbox_new_with_context (GdictContext *context)
+{
+ g_return_val_if_fail (GDICT_IS_CONTEXT (context), NULL);
+
+ return g_object_new (GDICT_TYPE_DEFBOX, "context", context, NULL);
+}
+
+/**
+ * gdict_defbox_set_context:
+ * @defbox: a #GdictDefbox
+ * @context: a #GdictContext
+ *
+ * Sets @context as the #GdictContext to be used by @defbox in order
+ * to retrieve the definitions of a word.
+ *
+ * Since: 0.1
+ */
+void
+gdict_defbox_set_context (GdictDefbox *defbox,
+ GdictContext *context)
+{
+ g_return_if_fail (GDICT_IS_DEFBOX (defbox));
+ g_return_if_fail (context == NULL || GDICT_IS_CONTEXT (context));
+
+ g_object_set (defbox, "context", context, NULL);
+}
+
+/**
+ * gdict_defbox_get_context:
+ * @defbox: a #GdictDefbox
+ *
+ * Gets the #GdictContext used by @defbox.
+ *
+ * Return value: a #GdictContext.
+ *
+ * Since: 0.1
+ */
+GdictContext *
+gdict_defbox_get_context (GdictDefbox *defbox)
+{
+ g_return_val_if_fail (GDICT_IS_DEFBOX (defbox), NULL);
+
+ return defbox->priv->context;
+}
+
+/**
+ * gdict_defbox_set_database:
+ * @defbox: a #GdictDefbox
+ * @database: a database
+ *
+ * Sets @database as the database used by the #GdictContext bound to @defbox
+ * to query for word definitions.
+ *
+ * Since: 0.1
+ */
+void
+gdict_defbox_set_database (GdictDefbox *defbox,
+ const gchar *database)
+{
+ GdictDefboxPrivate *priv;
+
+ g_return_if_fail (GDICT_IS_DEFBOX (defbox));
+
+ priv = defbox->priv;
+
+ g_free (priv->database);
+ priv->database = g_strdup (database);
+
+ g_object_notify (G_OBJECT (defbox), "database");
+}
+
+/**
+ * gdict_defbox_get_database:
+ * @defbox: a #GdictDefbox
+ *
+ * Gets the database used by @defbox. See gdict_defbox_set_database().
+ *
+ * Return value: the name of a database. The return string is owned by
+ * the #GdictDefbox widget and should not be modified or freed.
+ *
+ * Since: 0.1
+ */
+const gchar *
+gdict_defbox_get_database (GdictDefbox *defbox)
+{
+ g_return_val_if_fail (GDICT_IS_DEFBOX (defbox), NULL);
+
+ return defbox->priv->database;
+}
+
+/**
+ * gdict_defbox_get_word:
+ * @defbox: a #GdictDefbox
+ *
+ * Retrieves the word being looked up.
+ *
+ * Return value: the word looked up, or %NULL. The returned string is
+ * owned by the #GdictDefbox widget and should never be modified or
+ * freed.
+ *
+ * Since: 0.12
+ */
+const gchar *
+gdict_defbox_get_word (GdictDefbox *defbox)
+{
+ g_return_val_if_fail (GDICT_IS_DEFBOX (defbox), NULL);
+
+ return defbox->priv->word;
+}
+
+/**
+ * gdict_defbox_set_show_find:
+ * @defbox: a #GdictDefbox
+ * @show_find: %TRUE to show the find pane
+ *
+ * Whether @defbox should show the find pane.
+ *
+ * Since: 0.1
+ */
+void
+gdict_defbox_set_show_find (GdictDefbox *defbox,
+ gboolean show_find)
+{
+ GdictDefboxPrivate *priv;
+
+ g_return_if_fail (GDICT_IS_DEFBOX (defbox));
+
+ priv = defbox->priv;
+
+ if (priv->show_find == show_find)
+ return;
+
+ priv->show_find = show_find;
+ if (priv->show_find)
+ {
+ gtk_widget_show_all (priv->find_pane);
+ gtk_widget_grab_focus (priv->find_entry);
+
+ if (!priv->hide_timeout)
+ priv->hide_timeout = g_timeout_add (5000, hide_find_pane, defbox);
+ }
+ else
+ {
+ gtk_widget_hide (priv->find_pane);
+
+ if (priv->hide_timeout)
+ {
+ g_source_remove (priv->hide_timeout);
+ priv->hide_timeout = 0;
+ }
+ }
+}
+
+/**
+ * gdict_defbox_get_show_find:
+ * @defbox: a #GdictDefbox
+ *
+ * Gets whether the find pane should be visible or not.
+ *
+ * Return value: %TRUE if the find pane is visible.
+ *
+ * Since: 0.1
+ */
+gboolean
+gdict_defbox_get_show_find (GdictDefbox *defbox)
+{
+ g_return_val_if_fail (GDICT_IS_DEFBOX (defbox), FALSE);
+
+ return (defbox->priv->show_find == TRUE);
+}
+
+static void
+lookup_start_cb (GdictContext *context,
+ gpointer user_data)
+{
+ GdictDefbox *defbox = GDICT_DEFBOX (user_data);
+ GdictDefboxPrivate *priv = defbox->priv;
+ GdkWindow *window;
+
+ priv->is_searching = TRUE;
+
+ if (!priv->busy_cursor)
+ priv->busy_cursor = gdk_cursor_new (GDK_WATCH);
+
+ window = gtk_text_view_get_window (GTK_TEXT_VIEW (priv->text_view),
+ GTK_TEXT_WINDOW_WIDGET);
+
+ gdk_window_set_cursor (window, priv->busy_cursor);
+}
+
+static void
+lookup_end_cb (GdictContext *context,
+ gpointer user_data)
+{
+ GdictDefbox *defbox = GDICT_DEFBOX (user_data);
+ GdictDefboxPrivate *priv = defbox->priv;
+ GtkTextBuffer *buffer;
+ GtkTextIter start;
+ GdkWindow *window;
+
+ /* explicitely move the cursor to the beginning */
+ buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (priv->text_view));
+ gtk_text_buffer_get_start_iter (buffer, &start);
+ gtk_text_buffer_place_cursor (buffer, &start);
+
+ window = gtk_text_view_get_window (GTK_TEXT_VIEW (priv->text_view),
+ GTK_TEXT_WINDOW_WIDGET);
+
+ gdk_window_set_cursor (window, NULL);
+
+ priv->is_searching = FALSE;
+}
+
+static void
+gdict_defbox_insert_word (GdictDefbox *defbox,
+ GtkTextIter *iter,
+ const gchar *word)
+{
+ GdictDefboxPrivate *priv;
+ gchar *text;
+
+ if (!word)
+ return;
+
+ g_assert (GDICT_IS_DEFBOX (defbox));
+ priv = defbox->priv;
+
+ g_assert (GTK_IS_TEXT_BUFFER (priv->buffer));
+
+ text = g_strdup_printf ("%s\n", word);
+ gtk_text_buffer_insert_with_tags_by_name (priv->buffer,
+ iter,
+ text, strlen (text),
+ "big", "bold", "query-title",
+ NULL);
+ g_free (text);
+}
+
+/* escape a link string; links are expressed as "{...}".
+ * the link with the '{}' removed is stored inside link_str, while
+ * the returned value is a pointer to what follows the trailing '}'.
+ * link_str is allocated and should be freed.
+ */
+static const gchar *
+escape_link (const gchar *str,
+ gchar **link_str)
+{
+ gsize str_len;
+ GString *link_buf;
+ const gchar *p;
+
+ str_len = strlen (str);
+ link_buf = g_string_sized_new (str_len - 2);
+
+ for (p = str + 1; *p != '}'; p++)
+ {
+ link_buf = g_string_append_c (link_buf, *p);
+ }
+
+ if (link_str)
+ *link_str = g_string_free (link_buf, FALSE);
+
+ p++;
+
+ return p;
+}
+
+static const gchar *
+escape_phonethic (const gchar *str,
+ gchar **phon_str)
+{
+ gsize str_len;
+ GString *phon_buf;
+ const gchar *p;
+
+ str_len = strlen (str);
+ phon_buf = g_string_sized_new (str_len - 2);
+
+ for (p = str + 1; *p != '\\'; p++)
+ {
+ phon_buf = g_string_append_c (phon_buf, *p);
+ }
+
+ if (phon_str)
+ *phon_str = g_string_free (phon_buf, FALSE);
+
+ p++;
+
+ return p;
+}
+
+static void
+gdict_defbox_insert_body (GdictDefbox *defbox,
+ GtkTextIter *iter,
+ const gchar *body)
+{
+ GdictDefboxPrivate *priv;
+ gchar **words;
+ gint len, i;
+ GtkTextIter end_iter;
+
+ if (!body)
+ return;
+
+ g_assert (GDICT_IS_DEFBOX (defbox));
+ priv = defbox->priv;
+
+ g_assert (GTK_IS_TEXT_BUFFER (priv->buffer));
+
+ words = g_strsplit (body, " ", -1);
+ len = g_strv_length (words);
+ end_iter = *iter;
+
+ for (i = 0; i < len; i++)
+ {
+ gchar *w = words[i];
+ gint w_len = strlen (w);
+ gchar *begin, *end;
+
+ if (w_len == 0)
+ continue;
+
+ begin = g_utf8_offset_to_pointer (w, 0);
+
+ if (*begin == '{')
+ {
+ end = g_utf8_strrchr (w, -1, '}');
+
+ /* see this is a self contained link */
+ if (end && *end == '}')
+ {
+ const gchar *rest;
+ gchar *link_str;
+
+ rest = escape_link (w, &link_str);
+
+ gtk_text_buffer_insert_with_tags_by_name (priv->buffer,
+ &end_iter,
+ link_str, -1,
+ "link",
+ NULL);
+
+ gtk_text_buffer_insert (priv->buffer, &end_iter, rest, -1);
+
+ gtk_text_buffer_get_end_iter (priv->buffer, &end_iter);
+ gtk_text_buffer_insert (priv->buffer, &end_iter, " ", 1);
+
+ g_free (link_str);
+
+ continue;
+ }
+ else
+ {
+ /* uh-oh: the link ends in another word */
+ GString *buf;
+ gchar *next;
+ gint cur = i;
+
+ buf = g_string_new (NULL);
+ next = words[cur++];
+
+ while (next && (end = g_utf8_strrchr (next, -1, '}')) == NULL)
+ {
+ buf = g_string_append (buf, next);
+ buf = g_string_append_c (buf, ' ');
+
+ next = words[cur++];
+ }
+
+ buf = g_string_append (buf, next);
+
+ next = g_string_free (buf, FALSE);
+
+ if (end && *end == '}')
+ {
+ const gchar *rest;
+ gchar *link_str;
+
+ rest = escape_link (next, &link_str);
+
+ gtk_text_buffer_insert_with_tags_by_name (priv->buffer,
+ &end_iter,
+ link_str, -1,
+ "link",
+ NULL);
+
+ gtk_text_buffer_insert (priv->buffer, &end_iter, rest, -1);
+ gtk_text_buffer_insert (priv->buffer, &end_iter, " ", 1);
+
+ g_free (link_str);
+ }
+
+ g_free (next);
+ i = cur;
+
+ continue;
+ }
+ }
+ else if (*begin == '\\')
+ {
+ end = g_utf8_strrchr (w, -1, '\\');
+
+ if (end && *end == '\\')
+ {
+ const gchar *rest;
+ gchar *phon;
+
+ rest = escape_phonethic (w, &phon);
+
+ gtk_text_buffer_insert_with_tags_by_name (priv->buffer,
+ &end_iter,
+ phon, -1,
+ "italic", "phonetic",
+ NULL);
+
+ gtk_text_buffer_insert (priv->buffer, &end_iter, rest, -1);
+
+ gtk_text_buffer_get_end_iter (priv->buffer, &end_iter);
+ gtk_text_buffer_insert (priv->buffer, &end_iter, " ", -1);
+
+ g_free (phon);
+
+ continue;
+ }
+ }
+
+ gtk_text_buffer_insert (priv->buffer, &end_iter, w, w_len);
+
+ gtk_text_buffer_get_end_iter (priv->buffer, &end_iter);
+ gtk_text_buffer_insert (priv->buffer, &end_iter, " ", 1);
+ }
+
+ gtk_text_buffer_get_end_iter (priv->buffer, &end_iter);
+ gtk_text_buffer_insert (priv->buffer, &end_iter, "\n", 1);
+
+ *iter = end_iter;
+
+ g_strfreev (words);
+}
+
+static void
+gdict_defbox_insert_from (GdictDefbox *defbox,
+ GtkTextIter *iter,
+ const gchar *database)
+{
+ GdictDefboxPrivate *priv;
+ gchar *text;
+
+ if (!database)
+ return;
+
+ g_assert (GDICT_IS_DEFBOX (defbox));
+ priv = defbox->priv;
+
+ g_assert (GTK_IS_TEXT_BUFFER (priv->buffer));
+
+ text = g_strdup_printf ("\t-- From %s\n\n", database);
+ gtk_text_buffer_insert_with_tags_by_name (priv->buffer,
+ iter,
+ text, strlen (text),
+ "small", "query-from",
+ NULL);
+ g_free (text);
+}
+
+static void
+gdict_defbox_insert_error (GdictDefbox *defbox,
+ GtkTextIter *iter,
+ const gchar *title,
+ const gchar *message)
+{
+ GdictDefboxPrivate *priv;
+ GtkTextMark *mark;
+ GtkTextIter cur_iter;
+
+ if (!title)
+ return;
+
+ g_assert (GDICT_IS_DEFBOX (defbox));
+ priv = defbox->priv;
+
+ g_assert (GTK_IS_TEXT_BUFFER (priv->buffer));
+
+ mark = gtk_text_buffer_create_mark (priv->buffer, "block-cursor", iter, FALSE);
+ gtk_text_buffer_get_iter_at_mark (priv->buffer, &cur_iter, mark);
+
+ gtk_text_buffer_insert_with_tags_by_name (priv->buffer,
+ &cur_iter,
+ title, strlen (title),
+ "error-title", "big", "bold",
+ NULL);
+ gtk_text_buffer_get_iter_at_mark (priv->buffer, &cur_iter, mark);
+
+ gtk_text_buffer_insert (priv->buffer, &cur_iter, "\n\n", -1);
+ gtk_text_buffer_get_iter_at_mark (priv->buffer, &cur_iter, mark);
+
+ gtk_text_buffer_insert_with_tags_by_name (priv->buffer,
+ &cur_iter,
+ message, strlen (message),
+ "error-message",
+ NULL);
+}
+
+static void
+definition_found_cb (GdictContext *context,
+ GdictDefinition *definition,
+ gpointer user_data)
+{
+ GdictDefbox *defbox = GDICT_DEFBOX (user_data);
+ GdictDefboxPrivate *priv = defbox->priv;
+ GtkTextIter iter;
+ Definition *def;
+
+ /* insert the word if this is the first definition */
+ if (!priv->definitions)
+ {
+ gtk_text_buffer_get_start_iter (priv->buffer, &iter);
+ gdict_defbox_insert_word (defbox, &iter,
+ gdict_definition_get_word (definition));
+ }
+
+ def = definition_new ();
+
+ gtk_text_buffer_get_end_iter (priv->buffer, &iter);
+ def->begin = gtk_text_iter_get_offset (&iter);
+ gdict_defbox_insert_body (defbox, &iter, gdict_definition_get_text (definition));
+
+ gtk_text_buffer_get_end_iter (priv->buffer, &iter);
+ gdict_defbox_insert_from (defbox, &iter, gdict_definition_get_database (definition));
+
+ def->definition = gdict_definition_ref (definition);
+
+ priv->definitions = g_slist_append (priv->definitions, def);
+}
+
+static void
+error_cb (GdictContext *context,
+ const GError *error,
+ gpointer user_data)
+{
+ GdictDefbox *defbox = GDICT_DEFBOX (user_data);
+ GdictDefboxPrivate *priv = defbox->priv;
+ GtkTextIter iter;
+
+ if (!error)
+ return;
+
+ gdict_defbox_clear (defbox);
+
+ gtk_text_buffer_get_start_iter (priv->buffer, &iter);
+ gdict_defbox_insert_error (defbox, &iter,
+ _("Error while looking up definition"),
+ error->message);
+
+ g_free (priv->word);
+ priv->word = NULL;
+
+ defbox->priv->is_searching = FALSE;
+}
+
+/**
+ * gdict_defbox_lookup:
+ * @defbox: a #GdictDefbox
+ * @word: the word to look up
+ *
+ * Searches @word inside the dictionary sources using the #GdictContext
+ * provided when creating @defbox or set using gdict_defbox_set_context().
+ *
+ * Since: 0.1
+ */
+void
+gdict_defbox_lookup (GdictDefbox *defbox,
+ const gchar *word)
+{
+ GdictDefboxPrivate *priv;
+ GError *define_error;
+
+ g_return_if_fail (GDICT_IS_DEFBOX (defbox));
+
+ priv = defbox->priv;
+
+ if (!priv->context)
+ {
+ g_warning ("Attempting to look up `%s', but no GdictContext "
+ "has been set. Use gdict_defbox_set_context() "
+ "before invoking gdict_defbox_lookup().",
+ word);
+ return;
+ }
+
+ if (priv->is_searching)
+ {
+ _gdict_show_error_dialog (GTK_WIDGET (defbox),
+ _("Another search is in progress"),
+ _("Please wait until the current search ends."));
+
+ return;
+ }
+
+ gdict_defbox_clear (defbox);
+
+ if (!priv->start_id)
+ {
+ priv->start_id = g_signal_connect (priv->context, "lookup-start",
+ G_CALLBACK (lookup_start_cb),
+ defbox);
+ priv->define_id = g_signal_connect (priv->context, "definition-found",
+ G_CALLBACK (definition_found_cb),
+ defbox);
+ priv->end_id = g_signal_connect (priv->context, "lookup-end",
+ G_CALLBACK (lookup_end_cb),
+ defbox);
+ }
+
+ if (!priv->error_id)
+ priv->error_id = g_signal_connect (priv->context, "error",
+ G_CALLBACK (error_cb),
+ defbox);
+
+ priv->word = g_strdup (word);
+ g_object_notify (G_OBJECT (defbox), "word");
+
+ define_error = NULL;
+ gdict_context_define_word (priv->context,
+ priv->database,
+ word,
+ &define_error);
+ if (define_error)
+ {
+ GtkTextIter iter;
+
+ gtk_text_buffer_get_start_iter (priv->buffer, &iter);
+ gdict_defbox_insert_error (defbox, &iter,
+ _("Error while retrieving the definition"),
+ define_error->message);
+
+ g_error_free (define_error);
+ }
+}
+
+/**
+ * gdict_defbox_clear:
+ * @defbox: a @GdictDefbox
+ *
+ * Clears the buffer of @defbox
+ *
+ * Since: 0.1
+ */
+void
+gdict_defbox_clear (GdictDefbox *defbox)
+{
+ GdictDefboxPrivate *priv;
+ GtkTextIter start, end;
+
+ g_return_if_fail (GDICT_IS_DEFBOX (defbox));
+
+ priv = defbox->priv;
+
+ /* destroy previously found definitions */
+ if (priv->definitions)
+ {
+ g_slist_foreach (priv->definitions,
+ (GFunc) definition_free,
+ NULL);
+ g_slist_free (priv->definitions);
+
+ priv->definitions = NULL;
+ }
+
+ gtk_text_buffer_get_bounds (priv->buffer, &start, &end);
+ gtk_text_buffer_delete (priv->buffer, &start, &end);
+}
+
+/**
+ * gdict_defbox_find_next:
+ * @defbox: a #GdictDefbox
+ *
+ * Emits the "find-next" signal.
+ *
+ * Since: 0.1
+ */
+void
+gdict_defbox_find_next (GdictDefbox *defbox)
+{
+ g_return_if_fail (GDICT_IS_DEFBOX (defbox));
+
+ g_signal_emit (defbox, gdict_defbox_signals[FIND_NEXT], 0);
+}
+
+/**
+ * gdict_defbox_find_previous:
+ * @defbox: a #GdictDefbox
+ *
+ * Emits the "find-previous" signal.
+ *
+ * Since: 0.1
+ */
+void
+gdict_defbox_find_previous (GdictDefbox *defbox)
+{
+ g_return_if_fail (GDICT_IS_DEFBOX (defbox));
+
+ g_signal_emit (defbox, gdict_defbox_signals[FIND_PREVIOUS], 0);
+}
+
+/**
+ * gdict_defbox_select_all:
+ * @defbox: a #GdictDefbox
+ *
+ * Selects all the text displayed by @defbox
+ *
+ * Since: 0.1
+ */
+void
+gdict_defbox_select_all (GdictDefbox *defbox)
+{
+ GdictDefboxPrivate *priv;
+ GtkTextBuffer *buffer;
+ GtkTextIter start, end;
+
+ g_return_if_fail (GDICT_IS_DEFBOX (defbox));
+
+ priv = defbox->priv;
+ buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (priv->text_view));
+
+ gtk_text_buffer_get_bounds (buffer, &start, &end);
+ gtk_text_buffer_select_range (buffer, &start, &end);
+}
+
+/**
+ * gdict_defbox_copy_to_clipboard:
+ * @defbox: a #GdictDefbox
+ * @clipboard: a #GtkClipboard
+ *
+ * Copies the selected text inside @defbox into @clipboard.
+ *
+ * Since: 0.1
+ */
+void
+gdict_defbox_copy_to_clipboard (GdictDefbox *defbox,
+ GtkClipboard *clipboard)
+{
+ GdictDefboxPrivate *priv;
+ GtkTextBuffer *buffer;
+
+ g_return_if_fail (GDICT_IS_DEFBOX (defbox));
+ g_return_if_fail (GTK_IS_CLIPBOARD (clipboard));
+
+ priv = defbox->priv;
+ buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (priv->text_view));
+
+ gtk_text_buffer_copy_clipboard (buffer, clipboard);
+}
+
+/**
+ * gdict_defbox_count_definitions:
+ * @defbox: a #GdictDefbox
+ *
+ * Gets the number of definitions displayed by @defbox
+ *
+ * Return value: the number of definitions.
+ *
+ * Since: 0.1
+ */
+gint
+gdict_defbox_count_definitions (GdictDefbox *defbox)
+{
+ GdictDefboxPrivate *priv;
+
+ g_return_val_if_fail (GDICT_IS_DEFBOX (defbox), -1);
+
+ priv = defbox->priv;
+ if (!priv->definitions)
+ return -1;
+
+ return g_slist_length (priv->definitions);
+}
+
+/**
+ * gdict_defbox_jump_to_definition:
+ * @defbox: a #GdictDefbox
+ * @number: the definition to jump to
+ *
+ * Scrolls to the definition identified by @number. If @number is -1,
+ * jumps to the last definition.
+ *
+ * Since: 0.1
+ */
+void
+gdict_defbox_jump_to_definition (GdictDefbox *defbox,
+ gint number)
+{
+ GdictDefboxPrivate *priv;
+ gint count;
+ Definition *def;
+ GtkTextBuffer *buffer;
+ GtkTextIter def_start;
+
+ g_return_if_fail (GDICT_IS_DEFBOX (defbox));
+
+ count = gdict_defbox_count_definitions (defbox) - 1;
+ if (count == -1)
+ return;
+
+ if ((number == -1) || (number > count))
+ number = count;
+
+ priv = defbox->priv;
+ def = (Definition *) g_slist_nth_data (priv->definitions, number);
+ if (!def)
+ return;
+
+ buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (priv->text_view));
+ gtk_text_buffer_get_iter_at_offset (buffer, &def_start, def->begin);
+ gtk_text_view_scroll_to_iter (GTK_TEXT_VIEW (priv->text_view),
+ &def_start,
+ 0.0,
+ TRUE,
+ 0.0, 0.0);
+}
+
+/**
+ * gdict_defbox_get_text:
+ * @defbox: a #GdictDefbox
+ * @length: return location for the text length or %NULL
+ *
+ * Gets the full contents of @defbox.
+ *
+ * Return value: a newly allocated string containing the text displayed by
+ * @defbox.
+ *
+ * Since: 0.1
+ */
+gchar *
+gdict_defbox_get_text (GdictDefbox *defbox,
+ gsize *length)
+{
+ GdictDefboxPrivate *priv;
+ GtkTextBuffer *buffer;
+ GtkTextIter start, end;
+ gchar *retval;
+
+ g_return_val_if_fail (GDICT_IS_DEFBOX (defbox), NULL);
+
+ priv = defbox->priv;
+ buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (priv->text_view));
+
+ gtk_text_buffer_get_bounds (buffer, &start, &end);
+
+ retval = gtk_text_buffer_get_text (buffer, &start, &end, FALSE);
+
+ if (length)
+ *length = strlen (retval);
+
+ return retval;
+}
+
+/**
+ * gdict_defbox_set_font_name:
+ * @defbox: a #GdictDefbox
+ * @font_name: a font description, or %NULL
+ *
+ * Sets @font_name as the font for @defbox. It calls internally
+ * pango_font_description_from_string() and gtk_widget_modify_font().
+ *
+ * Passing %NULL for @font_name will reset any previously set font.
+ *
+ * Since: 0.3.0
+ */
+void
+gdict_defbox_set_font_name (GdictDefbox *defbox,
+ const gchar *font_name)
+{
+ GdictDefboxPrivate *priv;
+ PangoFontDescription *font_desc;
+
+ g_return_if_fail (GDICT_IS_DEFBOX (defbox));
+
+ priv = defbox->priv;
+
+ if (font_name)
+ {
+ font_desc = pango_font_description_from_string (font_name);
+ g_return_if_fail (font_desc != NULL);
+ }
+ else
+ font_desc = NULL;
+
+ gtk_widget_modify_font (priv->text_view, font_desc);
+
+ if (font_desc)
+ pango_font_description_free (font_desc);
+
+ g_free (priv->font_name);
+ priv->font_name = g_strdup (font_name);
+}
+
+/**
+ * gdict_defbox_get_font_name:
+ * @defbox: a #GdictDefbox
+ *
+ * Retrieves the font currently used by @defbox.
+ *
+ * Return value: a font name. The returned string is owned by @defbox and
+ * should not be modified or freed.
+ *
+ * Since: 0.3
+ */
+const gchar *
+gdict_defbox_get_font_name (GdictDefbox *defbox)
+{
+ g_return_val_if_fail (GDICT_IS_DEFBOX (defbox), NULL);
+
+ return defbox->priv->font_name;
+}
+
+/**
+ * gdict_defbox_get_selected_word:
+ * @defbox: a #GdictDefbox
+ *
+ * Retrieves the selected word from the defbox widget
+ *
+ * Return value: a newly allocated string containing the selected
+ * word. Use g_free() when done using it.
+ *
+ * Since: 0.12
+ */
+gchar *
+gdict_defbox_get_selected_word (GdictDefbox *defbox)
+{
+ GdictDefboxPrivate *priv;
+ GtkTextBuffer *buffer;
+
+ g_return_val_if_fail (GDICT_IS_DEFBOX (defbox), NULL);
+
+ priv = defbox->priv;
+ buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (priv->text_view));
+
+ if (!gtk_text_buffer_get_has_selection (buffer))
+ return NULL;
+ else
+ {
+ GtkTextIter start, end;
+ gchar *retval;
+
+ gtk_text_buffer_get_selection_bounds (buffer, &start, &end);
+ retval = gtk_text_buffer_get_text (buffer, &start, &end, FALSE);
+
+ return retval;
+ }
+}
diff --git a/mate-dictionary/libgdict/gdict-defbox.h b/mate-dictionary/libgdict/gdict-defbox.h
new file mode 100644
index 00000000..4c1278f6
--- /dev/null
+++ b/mate-dictionary/libgdict/gdict-defbox.h
@@ -0,0 +1,102 @@
+/* gdict-defbox.h - display widget for dictionary definitions
+ *
+ * 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 library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ */
+
+#ifndef __GDICT_DEFBOX_H__
+#define __GDICT_DEFBOX_H__
+
+#include <gtk/gtk.h>
+#include "gdict-context.h"
+
+G_BEGIN_DECLS
+
+#define GDICT_TYPE_DEFBOX (gdict_defbox_get_type ())
+#define GDICT_DEFBOX(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GDICT_TYPE_DEFBOX, GdictDefbox))
+#define GDICT_IS_DEFBOX(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GDICT_TYPE_DEFBOX))
+#define GDICT_DEFBOX_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GDICT_TYPE_DEFBOX, GdictDefboxClass))
+#define GDICT_IS_DEFBOX_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDICT_TYPE_DEFBOX))
+#define GDICT_DEFBOX_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GDICT_TYPE_DEFBOX, GdictDefboxClass))
+
+typedef struct _GdictDefbox GdictDefbox;
+typedef struct _GdictDefboxClass GdictDefboxClass;
+typedef struct _GdictDefboxPrivate GdictDefboxPrivate;
+
+struct _GdictDefbox
+{
+ /*< private >*/
+ GtkVBox parent_instance;
+
+ GdictDefboxPrivate *priv;
+};
+
+struct _GdictDefboxClass
+{
+ GtkVBoxClass parent_class;
+
+ /* these are all RUN_ACTION signals for key bindings */
+ void (*show_find) (GdictDefbox *defbox);
+ void (*hide_find) (GdictDefbox *defbox);
+ void (*find_previous) (GdictDefbox *defbox);
+ void (*find_next) (GdictDefbox *defbox);
+
+ /* signals */
+ void (*link_clicked) (GdictDefbox *defbox,
+ const gchar *link);
+
+ /* padding for future expansion */
+ void (*_gdict_defbox_1) (void);
+ void (*_gdict_defbox_2) (void);
+ void (*_gdict_defbox_3) (void);
+ void (*_gdict_defbox_4) (void);
+};
+
+GType gdict_defbox_get_type (void) G_GNUC_CONST;
+
+GtkWidget * gdict_defbox_new (void);
+GtkWidget * gdict_defbox_new_with_context (GdictContext *context);
+void gdict_defbox_set_context (GdictDefbox *defbox,
+ GdictContext *context);
+GdictContext * gdict_defbox_get_context (GdictDefbox *defbox);
+void gdict_defbox_set_database (GdictDefbox *defbox,
+ const gchar *database);
+const gchar *gdict_defbox_get_database (GdictDefbox *defbox);
+const gchar *gdict_defbox_get_word (GdictDefbox *defbox);
+gchar * gdict_defbox_get_text (GdictDefbox *defbox,
+ gsize *length) G_GNUC_MALLOC;
+void gdict_defbox_select_all (GdictDefbox *defbox);
+void gdict_defbox_copy_to_clipboard (GdictDefbox *defbox,
+ GtkClipboard *clipboard);
+void gdict_defbox_clear (GdictDefbox *defbox);
+void gdict_defbox_lookup (GdictDefbox *defbox,
+ const gchar *word);
+gint gdict_defbox_count_definitions (GdictDefbox *defbox);
+void gdict_defbox_jump_to_definition (GdictDefbox *defbox,
+ gint number);
+void gdict_defbox_set_show_find (GdictDefbox *defbox,
+ gboolean show_find);
+gboolean gdict_defbox_get_show_find (GdictDefbox *defbox);
+void gdict_defbox_find_next (GdictDefbox *defbox);
+void gdict_defbox_find_previous (GdictDefbox *defbox);
+void gdict_defbox_set_font_name (GdictDefbox *defbox,
+ const gchar *font_name);
+const gchar *gdict_defbox_get_font_name (GdictDefbox *defbox);
+gchar * gdict_defbox_get_selected_word (GdictDefbox *defbox) G_GNUC_MALLOC;
+
+G_END_DECLS
+
+#endif /* __GDICT_DEFBOX_H__ */
diff --git a/mate-dictionary/libgdict/gdict-enum-types.c.in b/mate-dictionary/libgdict/gdict-enum-types.c.in
new file mode 100644
index 00000000..0dbbdc66
--- /dev/null
+++ b/mate-dictionary/libgdict/gdict-enum-types.c.in
@@ -0,0 +1,33 @@
+/*** BEGIN file-header ***/
+#include "gdict-enum-types.h"
+/*** END file-header ***/
+
+/*** BEGIN file-production ***/
+/* enumerations from "@filename@" */
+#include "@filename@"
+/*** END file-production ***/
+
+/*** BEGIN value-header ***/
+GType
+@enum_name@_get_type (void)
+{
+ static GType g_enum_type_id = 0;
+ if (G_UNLIKELY (g_enum_type_id == 0))
+ {
+ static const G@Type@Value values[] = {
+/*** END value-header ***/
+
+/*** BEGIN value-production ***/
+ { @VALUENAME@, "@VALUENAME@", "@valuenick@" },
+/*** END value-production ***/
+
+/*** BEGIN value-tail ***/
+ { 0, NULL, NULL }
+ };
+ g_enum_type_id = g_@type@_register_static("@EnumName@", values);
+ }
+
+ return g_enum_type_id;
+}
+/*** END value-tail ***/
+
diff --git a/mate-dictionary/libgdict/gdict-enum-types.h.in b/mate-dictionary/libgdict/gdict-enum-types.h.in
new file mode 100644
index 00000000..bfaf3e29
--- /dev/null
+++ b/mate-dictionary/libgdict/gdict-enum-types.h.in
@@ -0,0 +1,26 @@
+/*** BEGIN file-header ***/
+#ifndef __GDICT_ENUM_TYPES_H__
+#define __GDICT_ENUM_TYPES_H__
+
+#include <glib-object.h>
+
+G_BEGIN_DECLS
+
+/*** END file-header ***/
+
+/*** BEGIN file-production ***/
+/* enumerations from "@filename@" */
+/*** END file-production ***/
+
+/*** BEGIN file-tail ***/
+G_END_DECLS
+
+#endif /* !__GDICT_ENUM_TYPES_H__ */
+/*** END file-tail ***/
+
+/*** BEGIN value-header ***/
+GType @enum_name@_get_type (void) G_GNUC_CONST;
+#define GDICT_TYPE_@ENUMSHORT@ (@enum_name@_get_type())
+
+/*** END value-header ***/
+
diff --git a/mate-dictionary/libgdict/gdict-marshal.list b/mate-dictionary/libgdict/gdict-marshal.list
new file mode 100644
index 00000000..39fa85e3
--- /dev/null
+++ b/mate-dictionary/libgdict/gdict-marshal.list
@@ -0,0 +1,7 @@
+VOID:VOID
+VOID:POINTER
+VOID:BOXED
+VOID:OBJECT
+VOID:STRING
+VOID:STRING,STRING
+VOID:STRING,OBJECT
diff --git a/mate-dictionary/libgdict/gdict-private.h b/mate-dictionary/libgdict/gdict-private.h
new file mode 100644
index 00000000..224ba776
--- /dev/null
+++ b/mate-dictionary/libgdict/gdict-private.h
@@ -0,0 +1,34 @@
+/* gdict-private.h - Private stuff for Gdict
+ *
+ * Copyright (C) 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 library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ */
+
+#include <gtk/gtk.h>
+#include "gdict-debug.h"
+
+G_BEGIN_DECLS
+
+gboolean _gdict_has_ipv6 (void);
+
+void _gdict_show_error_dialog (GtkWidget *widget,
+ const gchar *title,
+ const gchar *detail);
+void _gdict_show_gerror_dialog (GtkWidget *widget,
+ const gchar *title,
+ GError *error);
+
+G_END_DECLS
diff --git a/mate-dictionary/libgdict/gdict-source-chooser.c b/mate-dictionary/libgdict/gdict-source-chooser.c
new file mode 100644
index 00000000..ab640f85
--- /dev/null
+++ b/mate-dictionary/libgdict/gdict-source-chooser.c
@@ -0,0 +1,917 @@
+/* gdict-source-chooser.h - display widget for dictionary sources
+ *
+ * Copyright (C) 2007 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 library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ */
+
+/**
+ * SECTION:gdict-source-chooser
+ * @short_description: Display the list of available sources
+ *
+ * #GdictSourceChooser is a widget that shows the list of available
+ * dictionary sources using a #GdictSourceLoader instance as a model.
+ * It can be used to allow choosing the current dictionary source.
+ *
+ * #GdictSourceChooser is available since Gdict 0.12.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <stdlib.h>
+#include <string.h>
+
+#include <glib/gi18n-lib.h>
+
+#include <gdk/gdk.h>
+
+#include <gtk/gtk.h>
+
+#include "gdict-source-chooser.h"
+#include "gdict-utils.h"
+#include "gdict-private.h"
+#include "gdict-enum-types.h"
+#include "gdict-marshal.h"
+
+#define GDICT_SOURCE_CHOOSER_GET_PRIVATE(obj) \
+ (G_TYPE_INSTANCE_GET_PRIVATE ((obj), \
+ GDICT_TYPE_SOURCE_CHOOSER, \
+ GdictSourceChooserPrivate))
+
+struct _GdictSourceChooserPrivate
+{
+ GtkListStore *store;
+
+ GtkWidget *treeview;
+ GtkWidget *refresh_button;
+ GtkWidget *buttons_box;
+
+ GdictSourceLoader *loader;
+ gint n_sources;
+
+ GdkCursor *busy_cursor;
+ 
+ gchar *current_source;
+};
+
+enum
+{
+ SOURCE_TRANSPORT,
+ SOURCE_NAME,
+ SOURCE_DESCRIPTION,
+ SOURCE_CURRENT,
+
+ SOURCE_N_COLUMNS
+};
+
+enum
+{
+ PROP_0,
+
+ PROP_LOADER,
+ PROP_COUNT
+};
+
+enum
+{
+ SOURCE_ACTIVATED,
+ SELECTION_CHANGED,
+
+ LAST_SIGNAL
+};
+
+static guint source_chooser_signals[LAST_SIGNAL] = { 0, };
+
+G_DEFINE_TYPE (GdictSourceChooser, gdict_source_chooser, GTK_TYPE_VBOX);
+
+static void
+gdict_source_chooser_finalize (GObject *gobject)
+{
+ GdictSourceChooser *chooser = GDICT_SOURCE_CHOOSER (gobject);
+ GdictSourceChooserPrivate *priv = chooser->priv;
+
+ g_free (priv->current_source);
+
+ G_OBJECT_CLASS (gdict_source_chooser_parent_class)->finalize (gobject);
+}
+
+static void
+gdict_source_chooser_dispose (GObject *gobject)
+{
+ GdictSourceChooser *chooser = GDICT_SOURCE_CHOOSER (gobject);
+ GdictSourceChooserPrivate *priv = chooser->priv;
+
+ if (priv->store)
+ {
+ g_object_unref (priv->store);
+ priv->store = NULL;
+ }
+
+ if (priv->loader)
+ {
+ g_object_unref (priv->loader);
+ priv->loader = NULL;
+ }
+
+ if (priv->busy_cursor)
+ {
+ gdk_cursor_unref (priv->busy_cursor);
+ priv->busy_cursor = NULL;
+ }
+
+ G_OBJECT_CLASS (gdict_source_chooser_parent_class)->dispose (gobject);
+}
+
+static void
+gdict_source_chooser_set_property (GObject *gobject,
+ guint prop_id,
+ const GValue *value,
+ GParamSpec *pspec)
+{
+ switch (prop_id)
+ {
+ case PROP_LOADER:
+ gdict_source_chooser_set_loader (GDICT_SOURCE_CHOOSER (gobject),
+ g_value_get_object (value));
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
+ break;
+ }
+}
+
+static void
+gdict_source_chooser_get_property (GObject *gobject,
+ guint prop_id,
+ GValue *value,
+ GParamSpec *pspec)
+{
+ GdictSourceChooserPrivate *priv;
+
+ priv = GDICT_SOURCE_CHOOSER (gobject)->priv;
+
+ switch (prop_id)
+ {
+ case PROP_LOADER:
+ g_value_set_object (value, priv->loader);
+ break;
+ case PROP_COUNT:
+ g_value_set_int (value, priv->n_sources);
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
+ break;
+ }
+}
+
+static void
+row_activated_cb (GtkTreeView *treeview,
+ GtkTreePath *path,
+ GtkTreeViewColumn *column,
+ gpointer data)
+{
+ GdictSourceChooser *chooser = GDICT_SOURCE_CHOOSER (data);
+ GdictSourceChooserPrivate *priv = chooser->priv;
+ GtkTreeIter iter;
+ gchar *name;
+ GdictSource *source;
+
+ if (!priv->loader)
+ return;
+
+ if (!gtk_tree_model_get_iter (GTK_TREE_MODEL (priv->store), &iter, path))
+ return;
+
+ gtk_tree_model_get (GTK_TREE_MODEL (priv->store), &iter,
+ SOURCE_NAME, &name,
+ -1);
+ if (!name)
+ return;
+
+ source = gdict_source_loader_get_source (priv->loader, name);
+ if (!source)
+ {
+ g_free (name);
+ return;
+ }
+
+ g_signal_emit (chooser, source_chooser_signals[SOURCE_ACTIVATED], 0,
+ name, source);
+
+ g_free (name);
+ g_object_unref (source);
+}
+
+static void
+refresh_button_clicked_cb (GtkButton *button,
+ gpointer data)
+{
+ gdict_source_chooser_refresh (GDICT_SOURCE_CHOOSER (data));
+}
+
+static void
+selection_changed_cb (GtkTreeSelection *selection,
+ gpointer data)
+{
+ g_signal_emit (data, source_chooser_signals[SELECTION_CHANGED], 0);
+}
+
+static GObject *
+gdict_source_chooser_constructor (GType gtype,
+ guint n_params,
+ GObjectConstructParam *params)
+{
+ GdictSourceChooser *chooser;
+ GdictSourceChooserPrivate *priv;
+ GObjectClass *parent_class;
+ GObject *retval;
+ GtkWidget *sw;
+ GtkCellRenderer *renderer;
+ GtkTreeViewColumn *column;
+ GtkWidget *hbox;
+
+ parent_class = G_OBJECT_CLASS (gdict_source_chooser_parent_class);
+ retval = parent_class->constructor (gtype, n_params, params);
+
+ chooser = GDICT_SOURCE_CHOOSER (retval);
+ priv = chooser->priv;
+
+ gtk_widget_push_composite_child ();
+
+ sw = gtk_scrolled_window_new (NULL, NULL);
+ gtk_widget_set_composite_name (sw, "gdict-source-chooser-scrolled-window");
+ gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
+ GTK_POLICY_AUTOMATIC,
+ GTK_POLICY_AUTOMATIC);
+ gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw),
+ GTK_SHADOW_IN);
+ gtk_box_pack_start (GTK_BOX (chooser), sw, TRUE, TRUE, 0);
+ gtk_widget_show (sw);
+
+ renderer = gtk_cell_renderer_text_new ();
+ column = gtk_tree_view_column_new_with_attributes ("sources",
+ renderer,
+ "text", SOURCE_DESCRIPTION,
+ "weight", SOURCE_CURRENT,
+ NULL);
+ priv->treeview = gtk_tree_view_new ();
+ gtk_widget_set_composite_name (priv->treeview, "gdict-source-chooser-treeview");
+ gtk_tree_view_set_model (GTK_TREE_VIEW (priv->treeview),
+ GTK_TREE_MODEL (priv->store));
+ gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (priv->treeview), FALSE);
+ gtk_tree_view_append_column (GTK_TREE_VIEW (priv->treeview), column);
+ g_signal_connect (gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->treeview)),
+ "changed", G_CALLBACK (selection_changed_cb),
+ chooser);
+ g_signal_connect (priv->treeview,
+ "row-activated", G_CALLBACK (row_activated_cb),
+ chooser);
+ gtk_container_add (GTK_CONTAINER (sw), priv->treeview);
+ gtk_widget_show (priv->treeview);
+
+ hbox = gtk_hbox_new (FALSE, 6);
+ priv->buttons_box = hbox;
+
+ priv->refresh_button = gtk_button_new ();
+ gtk_button_set_image (GTK_BUTTON (priv->refresh_button),
+ gtk_image_new_from_stock (GTK_STOCK_REFRESH,
+ GTK_ICON_SIZE_BUTTON));
+ g_signal_connect (priv->refresh_button,
+ "clicked", G_CALLBACK (refresh_button_clicked_cb),
+ chooser);
+ gtk_box_pack_start (GTK_BOX (hbox), priv->refresh_button, FALSE, FALSE, 0);
+ gtk_widget_show (priv->refresh_button);
+ gtk_widget_set_tooltip_text (priv->refresh_button,
+ _("Reload the list of available sources"));
+
+ gtk_box_pack_end (GTK_BOX (chooser), hbox, FALSE, FALSE, 0);
+ gtk_widget_show (hbox);
+
+ gtk_widget_pop_composite_child ();
+
+ return retval;
+}
+
+static void
+gdict_source_chooser_class_init (GdictSourceChooserClass *klass)
+{
+ GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+
+ g_type_class_add_private (klass, sizeof (GdictSourceChooserPrivate));
+
+ gobject_class->finalize = gdict_source_chooser_finalize;
+ gobject_class->dispose = gdict_source_chooser_dispose;
+ gobject_class->set_property = gdict_source_chooser_set_property;
+ gobject_class->get_property = gdict_source_chooser_get_property;
+ gobject_class->constructor = gdict_source_chooser_constructor;
+
+ /**
+ * GdictSourceChooser:loader:
+ *
+ * The #GdictSourceLoader used to retrieve the list of available
+ * dictionary sources.
+ *
+ * Since: 0.12
+ */
+ g_object_class_install_property (gobject_class,
+ PROP_LOADER,
+ g_param_spec_object ("loader",
+ "Loader",
+ "The GdictSourceLoader used to get the list of sources",
+ GDICT_TYPE_SOURCE_LOADER,
+ G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
+ /**
+ * GdictSourceChooser:count:
+ *
+ * The number of available dictionary sources, or -1 if no
+ * #GdictSourceLoader is set.
+ *
+ * Since: 0.12
+ */
+ g_object_class_install_property (gobject_class,
+ PROP_COUNT,
+ g_param_spec_int ("count",
+ "Count",
+ "The number of available dictionary sources",
+ -1, G_MAXINT, -1,
+ G_PARAM_READABLE));
+
+ /**
+ * GdictSourceChooser::source-activated:
+ * @chooser: the #GdictSourceChooser that received the signal
+ * @source_name: the name of the activated source
+ * @source: the activated #GdictSource
+ *
+ * The ::source-activated signal is emitted each time the user
+ * activates a row in the source chooser widget, either by double
+ * clicking on it or by a keyboard event.
+ *
+ * Since: 0.12
+ */
+ source_chooser_signals[SOURCE_ACTIVATED] =
+ g_signal_new ("source-activated",
+ G_OBJECT_CLASS_TYPE (gobject_class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (GdictSourceChooserClass, source_activated),
+ NULL, NULL,
+ gdict_marshal_VOID__STRING_OBJECT,
+ G_TYPE_NONE, 2,
+ G_TYPE_STRING,
+ GDICT_TYPE_SOURCE);
+ /**
+ * GdictSourceChooser::selection-changed:
+ * @chooser: the #GdictSourceChooser that received the signal
+ *
+ * The ::selection-changed signal is emitted each time the
+ * selection inside the source chooser widget has been changed.
+ *
+ * Since: 0.12
+ */
+ source_chooser_signals[SELECTION_CHANGED] =
+ g_signal_new ("selection-changed",
+ G_OBJECT_CLASS_TYPE (gobject_class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (GdictSourceChooserClass, selection_changed),
+ NULL, NULL,
+ gdict_marshal_VOID__VOID,
+ G_TYPE_NONE, 0);
+}
+
+static void
+gdict_source_chooser_init (GdictSourceChooser *chooser)
+{
+ GdictSourceChooserPrivate *priv;
+
+ chooser->priv = priv = GDICT_SOURCE_CHOOSER_GET_PRIVATE (chooser);
+
+ priv->store = gtk_list_store_new (SOURCE_N_COLUMNS,
+ G_TYPE_INT, /* TRANSPORT */
+ G_TYPE_STRING, /* NAME */
+ G_TYPE_STRING, /* DESCRIPTION */
+ G_TYPE_INT /* CURRENT */);
+
+ priv->loader = NULL;
+ priv->n_sources = -1;
+
+ priv->busy_cursor = gdk_cursor_new (GDK_WATCH);
+}
+
+/**
+ * gdict_source_chooser_new:
+ *
+ * Creates a new #GdictSourceChooser widget. This widget can be used to
+ * display the list of available dictionary sources.
+ *
+ * Return value: the newly created #GdictSourceChooser widget.
+ *
+ * Since: 0.12
+ */
+GtkWidget *
+gdict_source_chooser_new (void)
+{
+ return g_object_new (GDICT_TYPE_SOURCE_CHOOSER, NULL);
+}
+
+/**
+ * gdict_source_chooser_new_with_loader:
+ * @loader: a #GdictSourceLoader
+ *
+ * Creates a new #GdictSourceChooser widget and sets @loader as the
+ * #GdictSourceLoader object to be used to retrieve the list of
+ * available dictionary sources.
+ *
+ * Return value: the newly created #GdictSourceChooser widget.
+ *
+ * Since: 0.12
+ */
+GtkWidget *
+gdict_source_chooser_new_with_loader (GdictSourceLoader *loader)
+{
+ g_return_val_if_fail (GDICT_IS_SOURCE_LOADER (loader), NULL);
+
+ return g_object_new (GDICT_TYPE_SOURCE_CHOOSER, "loader", loader, NULL);
+}
+
+/**
+ * gdict_source_chooser_set_loader:
+ * @chooser: a #GdictSourceChooser
+ * @loader: a #GdictSourceLoader or %NULL to unset it
+ *
+ * Sets the #GdictSourceLoader to be used by the source chooser
+ * widget.
+ *
+ * Since: 0.12
+ */
+void
+gdict_source_chooser_set_loader (GdictSourceChooser *chooser,
+ GdictSourceLoader *loader)
+{
+ GdictSourceChooserPrivate *priv;
+
+ g_return_if_fail (GDICT_IS_SOURCE_CHOOSER (chooser));
+ g_return_if_fail (loader == NULL || GDICT_IS_SOURCE_LOADER (loader));
+
+ priv = chooser->priv;
+
+ if (priv->loader != loader)
+ {
+ if (priv->loader)
+ g_object_unref (priv->loader);
+
+ if (loader)
+ {
+ priv->loader = g_object_ref (loader);
+ gdict_source_chooser_refresh (chooser);
+ }
+
+ g_object_notify (G_OBJECT (chooser), "loader");
+ }
+}
+
+/**
+ * gdict_source_chooser_get_loader:
+ * @chooser: a #GdictSourceChooser
+ * 
+ * Retrieves the #GdictSourceLoader used by @chooser.
+ *
+ * Return value: a #GdictSourceLoader or %NULL is none is set
+ *
+ * Since: 0.12
+ */
+GdictSourceLoader *
+gdict_source_chooser_get_loader (GdictSourceChooser *chooser)
+{
+ g_return_val_if_fail (GDICT_IS_SOURCE_CHOOSER (chooser), NULL);
+
+ return chooser->priv->loader;
+}
+
+typedef struct
+{
+ gchar *source_name;
+ GdictSourceChooser *chooser;
+ 
+ guint found : 1;
+ guint do_select : 1;
+ guint do_activate : 1;
+} SelectData;
+
+static gboolean
+scan_for_source_name (GtkTreeModel *model,
+ GtkTreePath *path,
+ GtkTreeIter *iter,
+ gpointer user_data)
+{
+ SelectData *select_data = user_data;
+ gchar *source_name = NULL;
+
+ if (!select_data)
+ return TRUE;
+
+ gtk_tree_model_get (model, iter, SOURCE_NAME, &source_name, -1);
+ if (!source_name)
+ return FALSE;
+
+ if (strcmp (source_name, select_data->source_name) == 0)
+ {
+ GtkTreeView *tree_view;
+ GtkTreeSelection *selection;
+
+ select_data->found = TRUE;
+
+ tree_view = GTK_TREE_VIEW (select_data->chooser->priv->treeview);
+
+ if (select_data->do_activate)
+ {
+ GtkTreeViewColumn *column;
+
+ column = gtk_tree_view_get_column (tree_view, 2);
+
+ gtk_list_store_set (GTK_LIST_STORE (model), iter,
+ SOURCE_CURRENT, PANGO_WEIGHT_BOLD,
+ -1);
+
+ gtk_tree_view_row_activated (tree_view, path, column);
+ }
+
+ selection = gtk_tree_view_get_selection (tree_view);
+ if (select_data->do_select)
+ gtk_tree_selection_select_path (selection, path);
+ else
+ gtk_tree_selection_unselect_path (selection, path);
+ }
+ else
+ {
+ gtk_list_store_set (GTK_LIST_STORE (model), iter,
+ SOURCE_CURRENT, PANGO_WEIGHT_NORMAL,
+ -1);
+ }
+
+ g_free (source_name);
+
+ return FALSE;
+}
+
+/**
+ * gdict_source_chooser_select_source:
+ * @chooser: a #GdictSourceChooser
+ * @source_name: the name of a dictionary source
+ *
+ * Selects the dictionary source named @source_name inside @chooser.
+ * The selection is moved but the row containing the dictionary source
+ * is not activated.
+ *
+ * Return value: %TRUE if the source was found and selected
+ *
+ * Since: 0.12
+ */
+gboolean
+gdict_source_chooser_select_source (GdictSourceChooser *chooser,
+ const gchar *source_name)
+{
+ GdictSourceChooserPrivate *priv;
+ SelectData data;
+ gboolean retval;
+
+ g_return_val_if_fail (GDICT_IS_SOURCE_CHOOSER (chooser), FALSE);
+ g_return_val_if_fail (source_name != NULL, FALSE);
+
+ priv = chooser->priv;
+
+ data.source_name = g_strdup (source_name);
+ data.chooser = chooser;
+ data.found = FALSE;
+ data.do_select = TRUE;
+ data.do_activate = FALSE;
+
+ gtk_tree_model_foreach (GTK_TREE_MODEL (priv->store),
+ scan_for_source_name,
+ &data);
+
+ retval = data.found;
+
+ g_free (data.source_name);
+
+ return retval;
+}
+
+/**
+ * gdict_source_chooser_unselect_source:
+ * @chooser: a #GdictSourceChooser
+ * @source_name: the name of a dictionary source
+ *
+ * Unselects @source_name inside @chooser.
+ *
+ * Return value: %TRUE if the source was found and unselected
+ *
+ * Since: 0.12
+ */
+gboolean
+gdict_source_chooser_unselect_source (GdictSourceChooser *chooser,
+ const gchar *source_name)
+{
+ GdictSourceChooserPrivate *priv;
+ SelectData data;
+ gboolean retval;
+
+ g_return_val_if_fail (GDICT_IS_SOURCE_CHOOSER (chooser), FALSE);
+ g_return_val_if_fail (source_name != NULL, FALSE);
+
+ priv = chooser->priv;
+
+ data.source_name = g_strdup (source_name);
+ data.chooser = chooser;
+ data.found = FALSE;
+ data.do_select = FALSE;
+ data.do_activate = FALSE;
+
+ gtk_tree_model_foreach (GTK_TREE_MODEL (priv->store),
+ scan_for_source_name,
+ &data);
+
+ retval = data.found;
+
+ g_free (data.source_name);
+
+ return retval;
+}
+
+/**
+ * gdict_source_chooser_set_current_source:
+ * @chooser: a #GdictSourceChooser
+ * @source_name: the name of a dictionary source
+ *
+ * Sets the current dictionary source named @source_name. The row
+ * of the source, if found, will be selected and activated.
+ *
+ * Return value: %TRUE if the source was found
+ *
+ * Since: 0.12
+ */
+gboolean
+gdict_source_chooser_set_current_source (GdictSourceChooser *chooser,
+ const gchar *source_name)
+{
+ GdictSourceChooserPrivate *priv;
+ SelectData data;
+ gboolean retval;
+
+ g_return_val_if_fail (GDICT_IS_SOURCE_CHOOSER (chooser), FALSE);
+ g_return_val_if_fail (source_name != NULL, FALSE);
+
+ priv = chooser->priv;
+
+ if (priv->current_source && !strcmp (priv->current_source, source_name))
+ return TRUE;
+
+ data.source_name = g_strdup (source_name);
+ data.chooser = chooser;
+ data.found = FALSE;
+ data.do_select = TRUE;
+ data.do_activate = TRUE;
+
+ gtk_tree_model_foreach (GTK_TREE_MODEL (priv->store),
+ scan_for_source_name,
+ &data);
+
+ retval = data.found;
+
+ GDICT_NOTE (CHOOSER, "%s current source: %s",
+ data.found ? "set" : "not set",
+ data.source_name);
+
+ if (data.found)
+ {
+ g_free (priv->current_source);
+ priv->current_source = data.source_name;
+ }
+ else
+ g_free (data.source_name);
+
+ return retval;
+}
+
+/**
+ * gdict_source_chooser_get_current_source:
+ * @chooser: a #GdictSourceChooser
+ *
+ * Retrieves the currently selected source.
+ *
+ * Return value: a newly allocated string containing the name of
+ * the currently selected source. Use g_free() when done using it
+ *
+ * Since: 0.12
+ */
+gchar *
+gdict_source_chooser_get_current_source (GdictSourceChooser *chooser)
+{
+ GdictSourceChooserPrivate *priv;
+ GtkTreeSelection *selection;
+ GtkTreeModel *model;
+ GtkTreeIter iter;
+ gchar *retval = NULL;
+
+ g_return_val_if_fail (GDICT_IS_SOURCE_CHOOSER (chooser), NULL);
+ 
+ priv = chooser->priv;
+
+ selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->treeview));
+ if (!gtk_tree_selection_get_selected (selection, &model, &iter))
+ return NULL;
+
+ gtk_tree_model_get (model, &iter, SOURCE_NAME, &retval, -1);
+ 
+ g_free (priv->current_source);
+ priv->current_source = g_strdup (retval);
+
+ return retval;
+}
+
+/**
+ * gdict_source_chooser_get_sources:
+ * @chooser: a #GdictSouceChooser
+ * @length: return location for the length of the returned vector
+ *
+ * Retrieves the names of the available dictionary sources.
+ *
+ * Return value: a newly allocated, %NULL terminated string vector
+ * containing the names of the available sources. Use g_strfreev()
+ * when done using it.
+ *
+ * Since: 0.12
+ */
+gchar **
+gdict_source_chooser_get_sources (GdictSourceChooser *chooser,
+ gsize *length)
+{
+ GdictSourceChooserPrivate *priv;
+ gchar **retval;
+ gsize retval_len;
+
+ g_return_val_if_fail (GDICT_IS_SOURCE_CHOOSER (chooser), NULL);
+
+ priv = chooser->priv;
+
+ if (!priv->loader)
+ return NULL;
+
+ retval = gdict_source_loader_get_names (priv->loader, &retval_len);
+ if (length)
+ *length = retval_len;
+
+ return retval;
+}
+
+/**
+ * gdict_source_chooser_count_sources:
+ * @chooser: a #GdictSourceChooser
+ *
+ * Retrieve the number of available dictionary sources.
+ *
+ * Return value: the number of available sources, or -1 if no
+ * #GdictSourceLoader has been set
+ *
+ * Since: 0.12
+ */
+gint
+gdict_source_chooser_count_sources (GdictSourceChooser *chooser)
+{
+ g_return_val_if_fail (GDICT_IS_SOURCE_CHOOSER (chooser), -1);
+
+ return chooser->priv->n_sources;
+}
+
+/**
+ * gdict_source_chooser_has_source:
+ * @chooser: a #GdictSourceChooser
+ * @source_name: the name of a dictionary source
+ *
+ * Checks whether @chooser has a dictionary source named @source_name.
+ *
+ * Return value: %TRUE if the dictionary source was found
+ *
+ * Since: 0.12
+ */
+gboolean
+gdict_source_chooser_has_source (GdictSourceChooser *chooser,
+ const gchar *source_name)
+{
+ GdictSourceChooserPrivate *priv;
+
+ g_return_val_if_fail (GDICT_IS_SOURCE_CHOOSER (chooser), FALSE);
+ g_return_val_if_fail (source_name != NULL, FALSE);
+
+ priv = chooser->priv;
+
+ if (!priv->loader)
+ return FALSE;
+
+ return gdict_source_loader_has_source (priv->loader, source_name);
+}
+
+/**
+ * gdict_source_chooser_refresh:
+ * @chooser: a #GdictSourceChooser
+ *
+ * Forces a refresh on the contents of the source chooser widget
+ *
+ * Since: 0.12
+ */
+void
+gdict_source_chooser_refresh (GdictSourceChooser *chooser)
+{
+ GdictSourceChooserPrivate *priv;
+
+ g_return_if_fail (GDICT_IS_SOURCE_CHOOSER (chooser));
+
+ priv = chooser->priv;
+
+ if (priv->loader)
+ {
+ const GSList *sources, *l;
+
+ if (priv->treeview)
+ gtk_tree_view_set_model (GTK_TREE_VIEW (priv->treeview), NULL);
+
+ gtk_list_store_clear (priv->store);
+
+ sources = gdict_source_loader_get_sources (priv->loader);
+ for (l = sources; l != NULL; l = l->next)
+ {
+ GdictSource *source = l->data;
+ const gchar *name, *description;
+ GdictSourceTransport transport;
+ gint weight;
+
+ transport = gdict_source_get_transport (source);
+ name = gdict_source_get_name (source);
+ description = gdict_source_get_description (source);
+ weight = PANGO_WEIGHT_NORMAL;
+
+ if (priv->current_source && !strcmp (priv->current_source, name))
+ weight = PANGO_WEIGHT_BOLD;
+
+ gtk_list_store_insert_with_values (priv->store, NULL, -1,
+ SOURCE_TRANSPORT, transport,
+ SOURCE_NAME, name,
+ SOURCE_DESCRIPTION, description,
+ SOURCE_CURRENT, weight,
+ -1);
+ }
+
+ if (priv->treeview)
+ gtk_tree_view_set_model (GTK_TREE_VIEW (priv->treeview),
+ GTK_TREE_MODEL (priv->store));
+ }
+}
+
+/**
+ * gdict_source_chooser_add_button:
+ * @chooser: a #GdictSourceChooser
+ * @button_text: text of the button
+ *
+ * Adds a #GtkButton with @button_text to the button area on
+ * the bottom of @chooser. The @button_text can also be a
+ * stock ID.
+ *
+ * Return value: the newly packed button.
+ *
+ * Since: 0.12
+ */
+GtkWidget *
+gdict_source_chooser_add_button (GdictSourceChooser *chooser,
+ const gchar *button_text)
+{
+ GdictSourceChooserPrivate *priv;
+ GtkWidget *button;
+
+ g_return_val_if_fail (GDICT_IS_SOURCE_CHOOSER (chooser), NULL);
+ g_return_val_if_fail (button_text != NULL, NULL);
+
+ priv = chooser->priv;
+
+ button = gtk_button_new_from_stock (button_text);
+
+ gtk_widget_set_can_default (button, TRUE);
+
+ gtk_widget_show (button);
+
+ gtk_box_pack_end (GTK_BOX (priv->buttons_box), button, FALSE, TRUE, 0);
+
+ return button;
+}
+
diff --git a/mate-dictionary/libgdict/gdict-source-chooser.h b/mate-dictionary/libgdict/gdict-source-chooser.h
new file mode 100644
index 00000000..ed9bf3fc
--- /dev/null
+++ b/mate-dictionary/libgdict/gdict-source-chooser.h
@@ -0,0 +1,93 @@
+/* gdict-source-chooser.h - display widget for dictionary sources
+ *
+ * Copyright (C) 2007 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 library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ */
+
+#ifndef __GDICT_SOURCE_CHOOSER_H__
+#define __GDICT_SOURCE_CHOOSER_H__
+
+#include <gtk/gtk.h>
+#include "gdict-source-loader.h"
+
+G_BEGIN_DECLS
+
+#define GDICT_TYPE_SOURCE_CHOOSER (gdict_source_chooser_get_type ())
+#define GDICT_SOURCE_CHOOSER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GDICT_TYPE_SOURCE_CHOOSER, GdictSourceChooser))
+#define GDICT_IS_SOURCE_CHOOSER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GDICT_TYPE_SOURCE_CHOOSER))
+#define GDICT_SOURCE_CHOOSER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GDICT_TYPE_SOURCE_CHOOSER, GdictSourceChooserClass))
+#define GDICT_IS_SOURCE_CHOOSER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDICT_TYPE_SOURCE_CHOOSER))
+#define GDICT_SOURCE_CHOOSER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GDICT_TYPE_SOURCE_CHOOSER, GdictSourceChooserClass))
+
+typedef struct _GdictSourceChooser GdictSourceChooser;
+typedef struct _GdictSourceChooserPrivate GdictSourceChooserPrivate;
+typedef struct _GdictSourceChooserClass GdictSourceChooserClass;
+
+struct _GdictSourceChooser
+{
+ /*< private >*/
+ GtkVBox parent_instance;
+
+ GdictSourceChooserPrivate *priv;
+};
+
+struct _GdictSourceChooserClass
+{
+ /*< private >*/
+ GtkVBoxClass parent_class;
+
+ /*< public >*/
+ void (*source_activated) (GdictSourceChooser *chooser,
+ const gchar *source_name,
+ GdictSource *source);
+ void (*selection_changed) (GdictSourceChooser *chooser);
+
+ /*< private >*/
+ /* padding for future expansion */
+ void (*_gdict_padding1) (void);
+ void (*_gdict_padding2) (void);
+ void (*_gdict_padding3) (void);
+ void (*_gdict_padding4) (void);
+ void (*_gdict_padding5) (void);
+ void (*_gdict_padding6) (void);
+};
+
+GType gdict_source_chooser_get_type (void) G_GNUC_CONST;
+
+GtkWidget * gdict_source_chooser_new (void);
+GtkWidget * gdict_source_chooser_new_with_loader (GdictSourceLoader *loader);
+void gdict_source_chooser_set_loader (GdictSourceChooser *chooser,
+ GdictSourceLoader *loader);
+GdictSourceLoader *gdict_source_chooser_get_loader (GdictSourceChooser *chooser);
+gboolean gdict_source_chooser_select_source (GdictSourceChooser *chooser,
+ const gchar *source_name);
+gboolean gdict_source_chooser_unselect_source (GdictSourceChooser *chooser,
+ const gchar *source_name);
+gboolean gdict_source_chooser_set_current_source (GdictSourceChooser *chooser,
+ const gchar *source_name);
+gchar * gdict_source_chooser_get_current_source (GdictSourceChooser *chooser) G_GNUC_MALLOC;
+gchar ** gdict_source_chooser_get_sources (GdictSourceChooser *chooser,
+ gsize *length) G_GNUC_MALLOC;
+gint gdict_source_chooser_count_sources (GdictSourceChooser *chooser);
+gboolean gdict_source_chooser_has_source (GdictSourceChooser *chooser,
+ const gchar *source_name);
+void gdict_source_chooser_refresh (GdictSourceChooser *chooser);
+GtkWidget * gdict_source_chooser_add_button (GdictSourceChooser *chooser,
+ const gchar *button_text);
+
+G_END_DECLS
+
+#endif /* __GDICT_SOURCE_CHOOSER_H__ */
diff --git a/mate-dictionary/libgdict/gdict-source-loader.c b/mate-dictionary/libgdict/gdict-source-loader.c
new file mode 100644
index 00000000..71d919af
--- /dev/null
+++ b/mate-dictionary/libgdict/gdict-source-loader.c
@@ -0,0 +1,600 @@
+/* gdict-source-loader.c - Source loader for Gdict
+ *
+ * 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 library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ */
+
+/**
+ * SECTION:gdict-source-loader
+ * @short_description: Loader object for a set of dictionary sources
+ *
+ * #GdictSourceLoader allows searching for dictionary source definition
+ * files inside a set of paths and return a #GdictSource using its name.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+
+#include <glib.h>
+#include <glib/gstdio.h>
+#include <glib/gi18n-lib.h>
+
+#include "gdict-source-loader.h"
+#include "gdict-utils.h"
+#include "gdict-enum-types.h"
+#include "gdict-marshal.h"
+#include "gdict-private.h"
+
+#define GDICT_SOURCE_FILE_SUFFIX ".desktop"
+
+#define GDICT_SOURCE_LOADER_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GDICT_TYPE_SOURCE_LOADER, GdictSourceLoaderPrivate))
+
+struct _GdictSourceLoaderPrivate
+{
+ GSList *paths;
+
+ GSList *sources;
+ GHashTable *sources_by_name;
+
+ guint paths_dirty : 1;
+};
+
+enum
+{
+ PROP_0,
+
+ PROP_PATHS,
+ PROP_SOURCES
+};
+
+enum
+{
+ SOURCE_LOADED,
+
+ LAST_SIGNAL
+};
+
+static guint loader_signals[LAST_SIGNAL] = { 0 };
+
+
+
+G_DEFINE_TYPE (GdictSourceLoader, gdict_source_loader, G_TYPE_OBJECT);
+
+
+static void
+gdict_source_loader_finalize (GObject *object)
+{
+ GdictSourceLoaderPrivate *priv = GDICT_SOURCE_LOADER_GET_PRIVATE (object);
+
+ if (priv->paths)
+ {
+ g_slist_foreach (priv->paths,
+ (GFunc) g_free,
+ NULL);
+ g_slist_free (priv->paths);
+
+ priv->paths = NULL;
+ }
+
+ if (priv->sources_by_name)
+ g_hash_table_destroy (priv->sources_by_name);
+
+ if (priv->sources)
+ {
+ g_slist_foreach (priv->sources,
+ (GFunc) g_object_unref,
+ NULL);
+ g_slist_free (priv->sources);
+
+ priv->sources = NULL;
+ }
+
+ G_OBJECT_CLASS (gdict_source_loader_parent_class)->finalize (object);
+}
+
+static void
+gdict_source_loader_set_property (GObject *object,
+ guint prop_id,
+ const GValue *value,
+ GParamSpec *pspec)
+{
+ switch (prop_id)
+ {
+ case PROP_PATHS:
+ break;
+ case PROP_SOURCES:
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ break;
+ }
+}
+
+static void
+gdict_source_loader_get_property (GObject *object,
+ guint prop_id,
+ GValue *value,
+ GParamSpec *pspec)
+{
+ switch (prop_id)
+ {
+ case PROP_PATHS:
+ break;
+ case PROP_SOURCES:
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ break;
+ }
+}
+
+static void
+gdict_source_loader_class_init (GdictSourceLoaderClass *klass)
+{
+ GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+
+ gobject_class->set_property = gdict_source_loader_set_property;
+ gobject_class->get_property = gdict_source_loader_get_property;
+ gobject_class->finalize = gdict_source_loader_finalize;
+
+ /**
+ * GdictSourceLoader:paths
+ *
+ * The search paths used by this object
+ *
+ * Since: 1.0
+ */
+ g_object_class_install_property (gobject_class,
+ PROP_PATHS,
+ g_param_spec_pointer ("paths",
+ _("Paths"),
+ _("Search paths used by this object"),
+ G_PARAM_READABLE));
+ /**
+ * GdictSourceLoader:sources
+ *
+ * The #GdictSource objects found by this object
+ *
+ * Since: 1.0
+ */
+ g_object_class_install_property (gobject_class,
+ PROP_SOURCES,
+ g_param_spec_pointer ("sources",
+ _("Sources"),
+ _("Dictionary sources found"),
+ G_PARAM_READABLE));
+
+ /**
+ * GdictSourceLoader::source-loaded
+ * @loader: the object which received the signal
+ * @source: the new #GdictSource object found
+ *
+ * This signal is emitted when a new dictionary source has been added
+ * to the list.
+ *
+ * Since: 1.0
+ */
+ loader_signals[SOURCE_LOADED] =
+ g_signal_new ("source-loaded",
+ G_OBJECT_CLASS_TYPE (gobject_class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (GdictSourceLoaderClass, source_loaded),
+ NULL, NULL,
+ gdict_marshal_VOID__OBJECT,
+ G_TYPE_NONE, 1,
+ GDICT_TYPE_SOURCE);
+
+ g_type_class_add_private (klass, sizeof (GdictSourceLoaderPrivate));
+}
+
+static void
+gdict_source_loader_init (GdictSourceLoader *loader)
+{
+ GdictSourceLoaderPrivate *priv;
+
+ priv = GDICT_SOURCE_LOADER_GET_PRIVATE (loader);
+ loader->priv = priv;
+
+ priv->paths = NULL;
+ /* add the default, system-wide path */
+ priv->paths = g_slist_prepend (priv->paths, g_strdup (GDICTSOURCESDIR));
+
+ priv->sources = NULL;
+ priv->sources_by_name = g_hash_table_new_full (g_str_hash, g_str_equal,
+ (GDestroyNotify) g_free,
+ NULL);
+
+ /* ensure that the sources list will be updated */
+ priv->paths_dirty = TRUE;
+}
+
+/**
+ * gdict_source_loader_new:
+ *
+ * Creates a new #GdictSourceLoader object. This object is used to search
+ * into a list of paths for dictionary source files. See #GdictSource for
+ * more informations about the format of dictionary source files.
+ *
+ * Return value: a new #GdictSourceLoader object
+ *
+ * Since: 1.0
+ */
+GdictSourceLoader *
+gdict_source_loader_new (void)
+{
+ return g_object_new (GDICT_TYPE_SOURCE_LOADER, NULL);
+}
+
+/**
+ * gdict_source_loader_update:
+ * @loader: a #GdictSourceLoader
+ *
+ * Queue an update of the sources inside @loader.
+ *
+ * Since: 1.0
+ */
+void
+gdict_source_loader_update (GdictSourceLoader *loader)
+{
+ g_return_if_fail (GDICT_IS_SOURCE_LOADER (loader));
+
+ loader->priv->paths_dirty = TRUE;
+}
+
+/**
+ * gdict_source_loader_add_search_path:
+ * @loader: a #GdictSourceLoader
+ * @path: a path to be added to the search path list
+ *
+ * Adds @path to the search paths list of @loader.
+ *
+ * Since: 1.0
+ */
+void
+gdict_source_loader_add_search_path (GdictSourceLoader *loader,
+ const gchar *path)
+{
+ GSList *l;
+
+ g_return_if_fail (GDICT_IS_SOURCE_LOADER (loader));
+ g_return_if_fail (path != NULL);
+
+ /* avoid duplications */
+ for (l = loader->priv->paths; l != NULL; l = l->next)
+ if (strcmp (path, (gchar *) l->data) == 0)
+ return;
+
+ loader->priv->paths = g_slist_append (loader->priv->paths, g_strdup (path));
+ loader->priv->paths_dirty = TRUE;
+}
+
+/**
+ * gdict_source_loader_get_paths:
+ * @loader: a #GdictSourceLoader
+ *
+ * Gets the list of paths used by @loader to search for dictionary source
+ * files.
+ *
+ * Return value: a list containing the paths. The returned list is owned
+ * by the #GdictSourceLoader object and should never be free or modified.
+ *
+ * Since: 1.0
+ */
+const GSList *
+gdict_source_loader_get_paths (GdictSourceLoader *loader)
+{
+ g_return_val_if_fail (GDICT_IS_SOURCE_LOADER (loader), NULL);
+
+ return loader->priv->paths;
+}
+
+/* create the list of dictionary source files, by scanning the search path
+ * directories for .desktop files; we disavow symlinks and sub-directories
+ * for the time being.
+ */
+static GSList *
+build_source_filenames (GdictSourceLoader *loader)
+{
+ GSList *retval, *d;
+
+ g_assert (GDICT_IS_SOURCE_LOADER (loader));
+
+ if (!loader->priv->paths)
+ return NULL;
+
+ retval = NULL;
+ for (d = loader->priv->paths; d != NULL; d = d->next)
+ {
+ gchar *path = (gchar *) d->data;
+ const gchar *filename;
+ GDir *dir;
+
+ dir = g_dir_open (path, 0, NULL);
+ if (!dir)
+ continue;
+
+ do
+ {
+ filename = g_dir_read_name (dir);
+ if (filename)
+ {
+ gchar *full_path;
+
+ if (!g_str_has_suffix (filename, GDICT_SOURCE_FILE_SUFFIX))
+ break;
+
+ full_path = g_build_filename (path, filename, NULL);
+ if (g_file_test (full_path, G_FILE_TEST_IS_REGULAR))
+ {
+ retval = g_slist_prepend (retval, full_path);
+ }
+ }
+ }
+ while (filename != NULL);
+
+ g_dir_close (dir);
+ }
+
+ return g_slist_reverse (retval);
+}
+
+static void
+gdict_source_loader_update_sources (GdictSourceLoader *loader)
+{
+ GSList *filenames, *f;
+
+ g_assert (GDICT_IS_SOURCE_LOADER (loader));
+
+ g_slist_foreach (loader->priv->sources,
+ (GFunc) g_object_unref,
+ NULL);
+ g_slist_free (loader->priv->sources);
+ loader->priv->sources = NULL;
+
+ filenames = build_source_filenames (loader);
+ for (f = filenames; f != NULL; f = f->next)
+ {
+ GdictSource *source;
+ GError *load_err;
+ gchar *path = (gchar *) f->data;
+
+ g_assert (path != NULL);
+
+ source = gdict_source_new ();
+
+ load_err = NULL;
+ gdict_source_load_from_file (source, path, &load_err);
+ if (load_err)
+ {
+ g_warning ("Unable to load dictionary source at '%s': %s\n",
+ path,
+ load_err->message);
+ g_error_free (load_err);
+
+ continue;
+ }
+
+ loader->priv->sources = g_slist_append (loader->priv->sources,
+ source);
+ g_hash_table_replace (loader->priv->sources_by_name,
+ g_strdup (gdict_source_get_name (source)),
+ source);
+
+ g_signal_emit (loader, loader_signals[SOURCE_LOADED], 0, source);
+ }
+
+ g_slist_foreach (filenames,
+ (GFunc) g_free,
+ NULL);
+ g_slist_free (filenames);
+
+ loader->priv->paths_dirty = FALSE;
+}
+
+/**
+ * gdict_source_loader_get_names:
+ * @loader: a #GdictSourceLoader
+ * @length: return location for the number of source names, or %NULL
+ *
+ * Retrieves the list of dictionary source names available into the
+ * search paths of @loader.
+ *
+ * Return value: a newly allocated, %NULL terminated array of strings. You
+ * should free the returned string array with g_strfreev()
+ *
+ * Since: 1.0
+ */
+gchar **
+gdict_source_loader_get_names (GdictSourceLoader *loader,
+ gsize *length)
+{
+ GSList *l;
+ gchar **names;
+ gsize i;
+
+ g_return_val_if_fail (GDICT_IS_SOURCE_LOADER (loader), NULL);
+
+ if (loader->priv->paths_dirty)
+ gdict_source_loader_update_sources (loader);
+
+ names = g_new0 (gchar *, g_slist_length (loader->priv->sources) + 1);
+
+ i = 0;
+ for (l = loader->priv->sources; l != NULL; l = l->next)
+ {
+ GdictSource *s = GDICT_SOURCE (l->data);
+
+ g_assert (s != NULL);
+
+ names[i++] = g_strdup (gdict_source_get_name (s));
+ }
+ names[i] = NULL;
+
+ if (length)
+ *length = i;
+
+ return names;
+}
+
+/**
+ * gdict_source_loader_get_sources:
+ * @loader: a #GdictSourceLoader
+ *
+ * Retrieves the list of dictionary sources available into the search
+ * paths of @loader, in form of #GdictSource objects.
+ *
+ * Return value: a list of #GdictSource objects. The returned list
+ * is owned by the #GdictSourceLoader object, and should never be
+ * freed or modified.
+ *
+ * Since: 1.0
+ */
+const GSList *
+gdict_source_loader_get_sources (GdictSourceLoader *loader)
+{
+ g_return_val_if_fail (GDICT_IS_SOURCE_LOADER (loader), NULL);
+
+ if (loader->priv->paths_dirty)
+ gdict_source_loader_update_sources (loader);
+
+ return loader->priv->sources;
+}
+
+/**
+ * gdict_source_loader_get_source:
+ * @loader: a #GdictSourceLoader
+ * @name: a name of a dictionary source
+ *
+ * Retrieves a dictionary source using @name. You can use the returned
+ * #GdictSource object to create the right #GdictContext for that
+ * dictionary source.
+ *
+ * Return value: a referenced #GdictSource object. You should de-reference
+ * it using g_object_unref() when you finished using it.
+ *
+ * Since: 1.0
+ */
+GdictSource *
+gdict_source_loader_get_source (GdictSourceLoader *loader,
+ const gchar *name)
+{
+ GdictSource *retval;
+
+ g_return_val_if_fail (GDICT_IS_SOURCE_LOADER (loader), NULL);
+ g_return_val_if_fail (name != NULL, NULL);
+
+ if (loader->priv->paths_dirty)
+ gdict_source_loader_update_sources (loader);
+
+ retval = g_hash_table_lookup (loader->priv->sources_by_name, name);
+ if (retval)
+ return g_object_ref (retval);
+
+ return NULL;
+}
+
+/**
+ * gdict_source_loader_remove_source:
+ * @loader: a #GdictSourceLoader
+ * @name: name of a dictionary source
+ *
+ * Removes the dictionary source @name from @loader. This function will
+ * also remove the dictionary source definition file bound to it.
+ *
+ * Return value: %TRUE if the dictionary source was successfully removed
+ *
+ * Since: 1.0
+ */
+gboolean
+gdict_source_loader_remove_source (GdictSourceLoader *loader,
+ const gchar *name)
+{
+ GdictSourceLoaderPrivate *priv;
+ GSList *l;
+
+ g_return_val_if_fail (GDICT_IS_SOURCE_LOADER (loader), FALSE);
+ g_return_val_if_fail (name != NULL, FALSE);
+
+ priv = loader->priv;
+
+ if (priv->paths_dirty)
+ gdict_source_loader_update_sources (loader);
+
+ for (l = priv->sources; l != NULL; l = l->next)
+ {
+ GdictSource *s = GDICT_SOURCE (l->data);
+
+ if (strcmp (gdict_source_get_name (s), name) == 0)
+ {
+ gchar *filename;
+
+ g_object_get (G_OBJECT (s), "filename", &filename, NULL);
+
+ if (g_unlink (filename) == -1)
+ {
+ g_warning ("Unable to remove filename '%s' for the "
+ "dictionary source '%s'\n",
+ filename,
+ name);
+
+ return FALSE;
+ }
+
+ g_hash_table_remove (priv->sources_by_name, name);
+
+ priv->sources = g_slist_remove_link (priv->sources, l);
+
+ g_object_unref (s);
+ g_slist_free (l);
+
+ return TRUE;
+ }
+ }
+
+ return FALSE;
+}
+
+/**
+ * gdict_source_loader_has_source:
+ * @loader: a #GdictSourceLoader
+ * @source_name: the name of a dictionary source
+ *
+ * Checks whether @loader has a dictionary source with name @source_name.
+ *
+ * Return value: %TRUE if the dictionary source is known
+ *
+ * Since: 0.12
+ */
+gboolean
+gdict_source_loader_has_source (GdictSourceLoader *loader,
+ const gchar *source_name)
+{
+ g_return_val_if_fail (GDICT_IS_SOURCE_LOADER (loader), FALSE);
+ g_return_val_if_fail (source_name != NULL, FALSE);
+
+ if (loader->priv->paths_dirty)
+ gdict_source_loader_update_sources (loader);
+
+ return (g_hash_table_lookup (loader->priv->sources_by_name, source_name) != NULL);
+}
diff --git a/mate-dictionary/libgdict/gdict-source-loader.h b/mate-dictionary/libgdict/gdict-source-loader.h
new file mode 100644
index 00000000..51f7bb78
--- /dev/null
+++ b/mate-dictionary/libgdict/gdict-source-loader.h
@@ -0,0 +1,81 @@
+/* gdict-source-loader.h - Source loader for Gdict
+ *
+ * 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 library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ */
+
+#ifndef __GDICT_SOURCE_LOADER_H__
+#define __GDICT_SOURCE_LOADER_H__
+
+#include <glib-object.h>
+#include "gdict-source.h"
+
+G_BEGIN_DECLS
+
+#define GDICT_TYPE_SOURCE_LOADER (gdict_source_loader_get_type ())
+#define GDICT_SOURCE_LOADER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GDICT_TYPE_SOURCE_LOADER, GdictSourceLoader))
+#define GDICT_IS_SOURCE_LOADER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GDICT_TYPE_SOURCE_LOADER))
+#define GDICT_SOURCE_LOADER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GDICT_TYPE_SOURCE_LOADER, GdictSourceLoaderClass))
+#define GDICT_IS_SOURCE_LOADER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDICT_TYPE_SOURCE_LOADER))
+#define GDICT_SOURCE_LOADER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GDICT_TYPE_SOURCE_LOADER, GdictSourceLoaderClass))
+
+typedef struct _GdictSourceLoader GdictSourceLoader;
+typedef struct _GdictSourceLoaderClass GdictSourceLoaderClass;
+typedef struct _GdictSourceLoaderPrivate GdictSourceLoaderPrivate;
+
+
+struct _GdictSourceLoader
+{
+ /*< private >*/
+ GObject parent_instance;
+
+ GdictSourceLoaderPrivate *priv;
+};
+
+struct _GdictSourceLoaderClass
+{
+ GObjectClass parent_class;
+
+ void (*source_loaded) (GdictSourceLoader *loader,
+ GdictSource *source);
+
+ /* padding for future expansion */
+ void (*_gdict_source_1) (void);
+ void (*_gdict_source_2) (void);
+ void (*_gdict_source_3) (void);
+ void (*_gdict_source_4) (void);
+};
+
+GType gdict_source_loader_get_type (void) G_GNUC_CONST;
+
+GdictSourceLoader * gdict_source_loader_new (void);
+void gdict_source_loader_update (GdictSourceLoader *loader);
+void gdict_source_loader_add_search_path (GdictSourceLoader *loader,
+ const gchar *path);
+const GSList *gdict_source_loader_get_paths (GdictSourceLoader *loader);
+gchar ** gdict_source_loader_get_names (GdictSourceLoader *loader,
+ gsize *length) G_GNUC_MALLOC;
+const GSList *gdict_source_loader_get_sources (GdictSourceLoader *loader);
+GdictSource * gdict_source_loader_get_source (GdictSourceLoader *loader,
+ const gchar *name);
+gboolean gdict_source_loader_has_source (GdictSourceLoader *loader,
+ const gchar *source_name);
+gboolean gdict_source_loader_remove_source (GdictSourceLoader *loader,
+ const gchar *name);
+
+G_END_DECLS
+
+#endif /* __GDICT_SOURCE_LOADER_H__ */
diff --git a/mate-dictionary/libgdict/gdict-source.c b/mate-dictionary/libgdict/gdict-source.c
new file mode 100644
index 00000000..aea506d2
--- /dev/null
+++ b/mate-dictionary/libgdict/gdict-source.c
@@ -0,0 +1,1195 @@
+/* gdict-source.c - Source configuration for Gdict
+ *
+ * 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 library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ */
+
+/**
+ * SECTION:gdict-source
+ * @short_description: A dictionary source definition
+ *
+ * #GdictSource is the representation of a #GdictContext. Each dictionary
+ * source provides a list of available dictionaries (databases) and a list
+ * of available matching strategies. Using a #GdictContext you can query
+ * the dictionary source for matching words and for definitions.
+ *
+ * By using a #GdictSource object you can retrieve the appropriate
+ * #GdictContext, already set up with the right parameters.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <glib/gi18n-lib.h>
+
+#include "gdict-source.h"
+#include "gdict-client-context.h"
+#include "gdict-utils.h"
+#include "gdict-enum-types.h"
+#include "gdict-private.h"
+
+/* Main group */
+#define SOURCE_GROUP "Dictionary Source"
+
+/* Common keys */
+#define SOURCE_KEY_NAME "Name"
+#define SOURCE_KEY_DESCRIPTION "Description"
+#define SOURCE_KEY_TRANSPORT "Transport"
+#define SOURCE_KEY_DATABASE "Database"
+#define SOURCE_KEY_STRATEGY "Strategy"
+
+/* dictd transport keys */
+#define SOURCE_KEY_HOSTNAME "Hostname"
+#define SOURCE_KEY_PORT "Port"
+
+
+#define GDICT_SOURCE_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GDICT_TYPE_SOURCE, GdictSourcePrivate))
+
+struct _GdictSourcePrivate
+{
+ gchar *filename;
+ GKeyFile *keyfile;
+
+ gchar *name;
+ gchar *description;
+
+ gchar *database;
+ gchar *strategy;
+
+ GdictSourceTransport transport;
+
+ GdictContext *context;
+};
+
+enum
+{
+ PROP_0,
+
+ PROP_FILENAME,
+ PROP_NAME,
+ PROP_DESCRIPTION,
+ PROP_DATABASE,
+ PROP_STRATEGY,
+ PROP_TRANSPORT,
+ PROP_CONTEXT
+};
+
+/* keep in sync with GdictSourceTransport */
+static const gchar *valid_transports[] =
+{
+ "dictd", /* GDICT_SOURCE_TRANSPORT_DICTD */
+
+ NULL /* GDICT_SOURCE_TRANSPORT_INVALID */
+};
+
+#define IS_VALID_TRANSPORT(t) (((t) >= GDICT_SOURCE_TRANSPORT_DICTD) && \
+ ((t) < GDICT_SOURCE_TRANSPORT_INVALID))
+
+GQuark
+gdict_source_error_quark (void)
+{
+ static GQuark quark = 0;
+
+ if (G_UNLIKELY (quark == 0))
+ quark = g_quark_from_static_string ("gdict-source-error-quark");
+
+ return quark;
+}
+
+
+G_DEFINE_TYPE (GdictSource, gdict_source, G_TYPE_OBJECT);
+
+
+
+static void
+gdict_source_set_property (GObject *object,
+ guint prop_id,
+ const GValue *value,
+ GParamSpec *pspec)
+{
+ GdictSource *source = GDICT_SOURCE (object);
+
+ switch (prop_id)
+ {
+ case PROP_NAME:
+ gdict_source_set_name (source, g_value_get_string (value));
+ break;
+ case PROP_DESCRIPTION:
+ gdict_source_set_description (source, g_value_get_string (value));
+ break;
+ case PROP_TRANSPORT:
+ gdict_source_set_transport (source, g_value_get_enum (value), NULL);
+ break;
+ case PROP_DATABASE:
+ gdict_source_set_database (source, g_value_get_string (value));
+ break;
+ case PROP_STRATEGY:
+ gdict_source_set_strategy (source, g_value_get_string (value));
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ break;
+ }
+}
+
+static void
+gdict_source_get_property (GObject *object,
+ guint prop_id,
+ GValue *value,
+ GParamSpec *pspec)
+{
+ GdictSource *source = GDICT_SOURCE (object);
+ GdictSourcePrivate *priv = source->priv;
+
+ switch (prop_id)
+ {
+ case PROP_FILENAME:
+ g_value_set_string (value, priv->filename);
+ break;
+ case PROP_NAME:
+ g_value_set_string (value, priv->name);
+ break;
+ case PROP_DESCRIPTION:
+ g_value_set_string (value, priv->description);
+ break;
+ case PROP_DATABASE:
+ g_value_set_string (value, priv->database);
+ break;
+ case PROP_STRATEGY:
+ g_value_set_string (value, priv->strategy);
+ break;
+ case PROP_TRANSPORT:
+ g_value_set_enum (value, priv->transport);
+ break;
+ case PROP_CONTEXT:
+ g_value_set_object (value, gdict_source_peek_context (source));
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+ break;
+ }
+}
+
+static void
+gdict_source_finalize (GObject *object)
+{
+ GdictSourcePrivate *priv = GDICT_SOURCE_GET_PRIVATE (object);
+
+ g_free (priv->filename);
+
+ if (priv->keyfile)
+ g_key_file_free (priv->keyfile);
+
+ g_free (priv->name);
+ g_free (priv->description);
+
+ g_free (priv->database);
+ g_free (priv->strategy);
+
+ if (priv->context)
+ g_object_unref (priv->context);
+
+ G_OBJECT_CLASS (gdict_source_parent_class)->finalize (object);
+}
+
+static void
+gdict_source_class_init (GdictSourceClass *klass)
+{
+ GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+
+ gobject_class->set_property = gdict_source_set_property;
+ gobject_class->get_property = gdict_source_get_property;
+ gobject_class->finalize = gdict_source_finalize;
+
+ /**
+ * GdictSource:filename
+ *
+ * The filename used by this dictionary source.
+ *
+ * Since: 1.0
+ */
+ g_object_class_install_property (gobject_class,
+ PROP_FILENAME,
+ g_param_spec_string ("filename",
+ _("Filename"),
+ _("The filename used by this dictionary source"),
+ NULL,
+ G_PARAM_READABLE));
+ /**
+ * GdictSource:name
+ *
+ * The display name of this dictionary source.
+ *
+ * Since: 1.0
+ */
+ g_object_class_install_property (gobject_class,
+ PROP_NAME,
+ g_param_spec_string ("name",
+ _("Name"),
+ _("The display name of this dictonary source"),
+ NULL,
+ (G_PARAM_READABLE | G_PARAM_WRITABLE)));
+ /**
+ * GdictSource:description
+ *
+ * The description of this dictionary source.
+ *
+ * Since: 1.0
+ */
+ g_object_class_install_property (gobject_class,
+ PROP_DESCRIPTION,
+ g_param_spec_string ("description",
+ _("Description"),
+ _("The description of this dictionary source"),
+ NULL,
+ (G_PARAM_READABLE | G_PARAM_WRITABLE)));
+ /**
+ * GdictSource:database
+ *
+ * The default database of this dictionary source.
+ *
+ * Since: 1.0
+ */
+ g_object_class_install_property (gobject_class,
+ PROP_DATABASE,
+ g_param_spec_string ("database",
+ _("Database"),
+ _("The default database of this dictonary source"),
+ NULL,
+ (G_PARAM_READABLE | G_PARAM_WRITABLE)));
+ /**
+ * GdictSource:strategy
+ *
+ * The default strategy of this dictionary source.
+ *
+ * Since: 1.0
+ */
+ g_object_class_install_property (gobject_class,
+ PROP_STRATEGY,
+ g_param_spec_string ("strategy",
+ _("Strategy"),
+ _("The default strategy of this dictonary source"),
+ NULL,
+ (G_PARAM_READABLE | G_PARAM_WRITABLE)));
+ /**
+ * GdictSource:transport
+ *
+ * The transport mechanism used by this source.
+ *
+ * Since: 1.0
+ */
+ g_object_class_install_property (gobject_class,
+ PROP_TRANSPORT,
+ g_param_spec_enum ("transport",
+ _("Transport"),
+ _("The transport mechanism used by this dictionary source"),
+ GDICT_TYPE_SOURCE_TRANSPORT,
+ GDICT_SOURCE_TRANSPORT_INVALID,
+ (G_PARAM_READABLE | G_PARAM_WRITABLE)));
+ /**
+ * GdictSource:context
+ *
+ * The #GdictContext bound to this source.
+ *
+ * Since: 1.0
+ */
+ g_object_class_install_property (gobject_class,
+ PROP_CONTEXT,
+ g_param_spec_object ("context",
+ _("Context"),
+ _("The GdictContext bound to this source"),
+ GDICT_TYPE_CONTEXT,
+ G_PARAM_READABLE));
+
+ g_type_class_add_private (klass, sizeof (GdictSourcePrivate));
+}
+
+static void
+gdict_source_init (GdictSource *source)
+{
+ GdictSourcePrivate *priv;
+
+ priv = GDICT_SOURCE_GET_PRIVATE (source);
+ source->priv = priv;
+
+ priv->filename = NULL;
+ priv->keyfile = g_key_file_new ();
+
+ priv->name = NULL;
+ priv->description = NULL;
+ priv->database = NULL;
+ priv->strategy = NULL;
+ priv->transport = GDICT_SOURCE_TRANSPORT_INVALID;
+
+ priv->context = NULL;
+}
+
+/**
+ * gdict_source_new:
+ *
+ * Creates an empty #GdictSource object. Use gdict_load_from_file() to
+ * read an existing dictionary source definition file.
+ *
+ * Return value: an empty #GdictSource
+ */
+GdictSource *
+gdict_source_new (void)
+{
+ return g_object_new (GDICT_TYPE_SOURCE, NULL);
+}
+
+static GdictSourceTransport
+gdict_source_resolve_transport (const gchar *transport)
+{
+ if (!transport)
+ return GDICT_SOURCE_TRANSPORT_INVALID;
+
+ if (strcmp (transport, "dictd") == 0)
+ return GDICT_SOURCE_TRANSPORT_DICTD;
+ else
+ return GDICT_SOURCE_TRANSPORT_INVALID;
+
+ g_assert_not_reached ();
+}
+
+static GdictContext *
+gdict_source_create_context (GdictSource *source,
+ GdictSourceTransport transport,
+ GError **error)
+{
+ GdictSourcePrivate *priv;
+ GdictContext *context;
+
+ g_assert (GDICT_IS_SOURCE (source));
+
+ priv = source->priv;
+
+ switch (transport)
+ {
+ case GDICT_SOURCE_TRANSPORT_DICTD:
+ {
+ gchar *hostname;
+ gint port;
+
+ hostname = g_key_file_get_string (priv->keyfile,
+ SOURCE_GROUP,
+ SOURCE_KEY_HOSTNAME,
+ NULL);
+
+ port = g_key_file_get_integer (priv->keyfile,
+ SOURCE_GROUP,
+ SOURCE_KEY_PORT,
+ NULL);
+ if (!port)
+ port = -1;
+
+ context = gdict_client_context_new (hostname, port);
+
+ if (hostname)
+ g_free (hostname);
+ }
+ break;
+ default:
+ g_set_error (error, GDICT_SOURCE_ERROR,
+ GDICT_SOURCE_ERROR_PARSE,
+ _("Invalid transport type '%d'"),
+ transport);
+ return NULL;
+ }
+
+ g_assert (context != NULL);
+
+ if (priv->transport != transport)
+ priv->transport = transport;
+
+ return context;
+}
+
+static gboolean
+gdict_source_parse (GdictSource *source,
+ GError **error)
+{
+ GdictSourcePrivate *priv;
+ GError *parse_error;
+ gchar *transport;
+ GdictSourceTransport t;
+
+ priv = source->priv;
+
+ if (!g_key_file_has_group (priv->keyfile, SOURCE_GROUP))
+ {
+ g_set_error (error, GDICT_SOURCE_ERROR,
+ GDICT_SOURCE_ERROR_PARSE,
+ _("No '%s' group found inside the dictionary source definition"),
+ SOURCE_GROUP);
+
+ return FALSE;
+ }
+
+ /* fetch the name for the dictionary source definition */
+ parse_error = NULL;
+ priv->name = g_key_file_get_string (priv->keyfile,
+ SOURCE_GROUP,
+ SOURCE_KEY_NAME,
+ &parse_error);
+ if (parse_error)
+ {
+ g_set_error (error, GDICT_SOURCE_ERROR,
+ GDICT_SOURCE_ERROR_PARSE,
+ _("Unable to get the '%s' key inside the dictionary "
+ "source definition: %s"),
+ SOURCE_KEY_NAME,
+ parse_error->message);
+ g_error_free (parse_error);
+
+ g_key_file_free (priv->keyfile);
+ priv->keyfile = NULL;
+
+ return FALSE;
+ }
+
+ /* if present, fetch the localized description */
+ if (g_key_file_has_key (priv->keyfile, SOURCE_GROUP, SOURCE_KEY_DESCRIPTION, NULL))
+ {
+ priv->description = g_key_file_get_locale_string (priv->keyfile,
+ SOURCE_GROUP,
+ SOURCE_KEY_DESCRIPTION,
+ NULL,
+ &parse_error);
+ if (parse_error)
+ {
+ g_set_error (error, GDICT_SOURCE_ERROR,
+ GDICT_SOURCE_ERROR_PARSE,
+ _("Unable to get the '%s' key inside the dictionary "
+ "source definition: %s"),
+ SOURCE_KEY_DESCRIPTION,
+ parse_error->message);
+
+ g_error_free (parse_error);
+ g_key_file_free (priv->keyfile);
+ priv->keyfile = NULL;
+ g_free (priv->name);
+
+ return FALSE;
+ }
+ }
+
+ if (g_key_file_has_key (priv->keyfile, SOURCE_GROUP, SOURCE_KEY_DATABASE, NULL))
+ {
+ priv->database = g_key_file_get_string (priv->keyfile,
+ SOURCE_GROUP,
+ SOURCE_KEY_DATABASE,
+ &parse_error);
+ if (parse_error)
+ {
+ g_set_error (error, GDICT_SOURCE_ERROR,
+ GDICT_SOURCE_ERROR_PARSE,
+ _("Unable to get the '%s' key inside the dictionary "
+ "source definition: %s"),
+ SOURCE_KEY_DATABASE,
+ parse_error->message);
+
+ g_error_free (parse_error);
+ g_key_file_free (priv->keyfile);
+ priv->keyfile = NULL;
+ g_free (priv->name);
+ g_free (priv->description);
+
+ return FALSE;
+ }
+ }
+
+ if (g_key_file_has_key (priv->keyfile, SOURCE_GROUP, SOURCE_KEY_STRATEGY, NULL))
+ {
+ priv->strategy = g_key_file_get_string (priv->keyfile,
+ SOURCE_GROUP,
+ SOURCE_KEY_STRATEGY,
+ &parse_error);
+ if (parse_error)
+ {
+ g_set_error (error, GDICT_SOURCE_ERROR,
+ GDICT_SOURCE_ERROR_PARSE,
+ _("Unable to get the '%s' key inside the dictionary "
+ "source definition: %s"),
+ SOURCE_KEY_STRATEGY,
+ parse_error->message);
+
+ g_error_free (parse_error);
+ g_key_file_free (priv->keyfile);
+ priv->keyfile = NULL;
+
+ g_free (priv->name);
+ g_free (priv->description);
+ g_free (priv->database);
+
+ return FALSE;
+ }
+ }
+
+ transport = g_key_file_get_string (priv->keyfile,
+ SOURCE_GROUP,
+ SOURCE_KEY_TRANSPORT,
+ &parse_error);
+ if (parse_error)
+ {
+ g_set_error (error, GDICT_SOURCE_ERROR,
+ GDICT_SOURCE_ERROR_PARSE,
+ _("Unable to get the '%s' key inside the dictionary "
+ "source definition file: %s"),
+ SOURCE_KEY_TRANSPORT,
+ parse_error->message);
+
+ g_error_free (parse_error);
+ g_key_file_free (priv->keyfile);
+ priv->keyfile = NULL;
+ g_free (priv->name);
+ g_free (priv->description);
+ g_free (priv->database);
+ g_free (priv->strategy);
+
+ return FALSE;
+ }
+
+ t = gdict_source_resolve_transport (transport);
+ g_free (transport);
+
+ priv->context = gdict_source_create_context (source, t, &parse_error);
+ if (parse_error)
+ {
+ g_propagate_error (error, parse_error);
+
+ g_key_file_free (priv->keyfile);
+ priv->keyfile = NULL;
+
+ g_free (priv->name);
+ g_free (priv->description);
+ g_free (priv->database);
+ g_free (priv->strategy);
+
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+/**
+ * gdict_source_load_from_file:
+ * @source: an empty #GdictSource
+ * @filename: path to a dictionary source file
+ * @error: return location for a #GError or %NULL
+ *
+ * Loads a dictionary source definition file into an empty #GdictSource
+ * object.
+ *
+ * Return value: %TRUE if @filename was loaded successfully.
+ *
+ * Since: 1.0
+ */
+gboolean
+gdict_source_load_from_file (GdictSource *source,
+ const gchar *filename,
+ GError **error)
+{
+ GdictSourcePrivate *priv;
+ GError *read_error;
+ GError *parse_error;
+
+ g_return_val_if_fail (GDICT_IS_SOURCE (source), FALSE);
+ g_return_val_if_fail (filename != NULL, FALSE);
+
+ priv = source->priv;
+
+ if (!priv->keyfile)
+ priv->keyfile = g_key_file_new ();
+
+ read_error = NULL;
+ g_key_file_load_from_file (priv->keyfile,
+ filename,
+ G_KEY_FILE_KEEP_TRANSLATIONS,
+ &read_error);
+ if (read_error)
+ {
+ g_propagate_error (error, read_error);
+
+ return FALSE;
+ }
+
+ parse_error = NULL;
+ gdict_source_parse (source, &parse_error);
+ if (parse_error)
+ {
+ g_propagate_error (error, parse_error);
+
+ return FALSE;
+ }
+
+ g_assert (priv->context != NULL);
+
+ priv->filename = g_strdup (filename);
+
+ return TRUE;
+}
+
+/**
+ * gdict_source_load_from_data:
+ * @source: a #GdictSource
+ * @data: string containing a dictionary source
+ * @length: length of @data
+ * @error: return location for a #GError or %NULL
+ *
+ * Loads a dictionary source definition from @data inside an empty
+ * #GdictSource object.
+ *
+ * Return value: %TRUE if @filename was loaded successfully.
+ *
+ * Since: 1.0
+ */
+gboolean
+gdict_source_load_from_data (GdictSource *source,
+ const gchar *data,
+ gsize length,
+ GError **error)
+{
+ GdictSourcePrivate *priv;
+ GError *read_error;
+ GError *parse_error;
+
+ g_return_val_if_fail (GDICT_IS_SOURCE (source), FALSE);
+ g_return_val_if_fail (data != NULL, FALSE);
+
+ priv = source->priv;
+
+ if (!priv->keyfile)
+ priv->keyfile = g_key_file_new ();
+
+ read_error = NULL;
+ g_key_file_load_from_data (priv->keyfile,
+ data,
+ length,
+ G_KEY_FILE_KEEP_TRANSLATIONS,
+ &read_error);
+ if (read_error)
+ {
+ g_propagate_error (error, read_error);
+
+ return FALSE;
+ }
+
+ parse_error = NULL;
+ gdict_source_parse (source, &parse_error);
+ if (parse_error)
+ {
+ g_propagate_error (error, parse_error);
+
+ return FALSE;
+ }
+
+ g_assert (priv->context != NULL);
+
+ g_free (priv->filename);
+ priv->filename = NULL;
+
+ return TRUE;
+}
+
+/**
+ * gdict_source_to_data:
+ * @source: a #GdictSource
+ * @length: return loaction for the length of the string, or %NULL
+ * @error: return location for a #GError or %NULL
+ *
+ * Outputs a dictionary source as a string.
+ *
+ * Return value: a newly allocated string holding the contents of @source.
+ *
+ * Since: 1.0
+ */
+gchar *
+gdict_source_to_data (GdictSource *source,
+ gsize *length,
+ GError **error)
+{
+ GdictSourcePrivate *priv;
+ gchar *retval = NULL;
+
+ g_return_val_if_fail (GDICT_IS_SOURCE (source), NULL);
+
+ priv = source->priv;
+
+ if (!priv->name)
+ {
+ g_set_error (error, GDICT_SOURCE_ERROR,
+ GDICT_SOURCE_ERROR_INVALID_NAME,
+ _("Dictionary source does not have name"));
+
+ return NULL;
+ }
+
+ if (!IS_VALID_TRANSPORT (priv->transport))
+ {
+ g_set_error (error, GDICT_SOURCE_ERROR,
+ GDICT_SOURCE_ERROR_INVALID_TRANSPORT,
+ _("Dictionary source '%s' has invalid transport '%s'"),
+ priv->name,
+ valid_transports[priv->transport]);
+
+ return NULL;
+ }
+
+ if (priv->keyfile)
+ {
+ GError *write_error = NULL;
+
+ retval = g_key_file_to_data (priv->keyfile,
+ length,
+ &write_error);
+ if (write_error)
+ g_propagate_error (error, write_error);
+ }
+
+ return retval;
+}
+
+/**
+ * gdict_source_set_name:
+ * @source: a #GdictSource
+ * @name: the UTF8-encoded name of the dictionary source
+ *
+ * Sets @name as the displayable name of the dictionary source.
+ *
+ * Since: 1.0
+ */
+void
+gdict_source_set_name (GdictSource *source,
+ const gchar *name)
+{
+ g_return_if_fail (GDICT_IS_SOURCE (source));
+ g_return_if_fail (name != NULL);
+
+ g_free (source->priv->name);
+ source->priv->name = g_strdup (name);
+
+ if (!source->priv->keyfile)
+ source->priv->keyfile = g_key_file_new ();
+
+ g_key_file_set_string (source->priv->keyfile,
+ SOURCE_GROUP,
+ SOURCE_KEY_NAME,
+ name);
+}
+
+/**
+ * gdict_source_get_name:
+ * @source: a #GdictSource
+ *
+ * Retrieves the name of @source.
+ *
+ * Return value: the name of a #GdictSource. The returned string is owned
+ * by the #GdictSource object, and should not be modified or freed.
+ *
+ * Since: 1.0
+ */
+const gchar *
+gdict_source_get_name (GdictSource *source)
+{
+ g_return_val_if_fail (GDICT_IS_SOURCE (source), NULL);
+
+ return source->priv->name;
+}
+
+/**
+ * gdict_source_set_description:
+ * @source: a #GdictSource
+ * @description: a UTF-8 encoded description or %NULL
+ *
+ * Sets the description of @source. If @description is %NULL, unsets the
+ * currently set description.
+ *
+ * Since: 1.0
+ */
+void
+gdict_source_set_description (GdictSource *source,
+ const gchar *description)
+{
+ g_return_if_fail (GDICT_IS_SOURCE (source));
+
+ g_free (source->priv->description);
+
+ if (!source->priv->keyfile)
+ source->priv->keyfile = g_key_file_new ();
+
+ if (description && description[0] != '\0')
+ {
+ source->priv->description = g_strdup (description);
+
+ g_key_file_set_string (source->priv->keyfile,
+ SOURCE_GROUP,
+ SOURCE_KEY_DESCRIPTION,
+ description);
+ }
+ else
+ {
+ if (g_key_file_has_key (source->priv->keyfile,
+ SOURCE_GROUP,
+ SOURCE_KEY_DESCRIPTION,
+ NULL))
+ g_key_file_remove_key (source->priv->keyfile,
+ SOURCE_GROUP,
+ SOURCE_KEY_DESCRIPTION,
+ NULL);
+ }
+}
+
+/**
+ * gdict_source_get_description:
+ * @source: a #GdictSource
+ *
+ * Retrieves the description of @source.
+ *
+ * Return value: the description of a #GdictSource. The returned string is
+ * owned by the #GdictSource object, and should not be modified or freed.
+ *
+ * Since: 1.0
+ */
+const gchar *
+gdict_source_get_description (GdictSource *source)
+{
+ g_return_val_if_fail (GDICT_IS_SOURCE (source), NULL);
+
+ return source->priv->description;
+}
+
+/**
+ * gdict_source_set_database:
+ * @source: a #GdictSource
+ * @database: a UTF-8 encoded database name or %NULL
+ *
+ * Sets the default database of @source. If @database is %NULL, unsets the
+ * currently set database.
+ *
+ * Since: 1.0
+ */
+void
+gdict_source_set_database (GdictSource *source,
+ const gchar *database)
+{
+ g_return_if_fail (GDICT_IS_SOURCE (source));
+
+ g_free (source->priv->database);
+
+ if (!source->priv->keyfile)
+ source->priv->keyfile = g_key_file_new ();
+
+ if (database && database[0] != '\0')
+ {
+ source->priv->database = g_strdup (database);
+
+ g_key_file_set_string (source->priv->keyfile,
+ SOURCE_GROUP,
+ SOURCE_KEY_DATABASE,
+ database);
+ }
+ else
+ {
+ if (g_key_file_has_key (source->priv->keyfile,
+ SOURCE_GROUP,
+ SOURCE_KEY_DATABASE,
+ NULL))
+ g_key_file_remove_key (source->priv->keyfile,
+ SOURCE_GROUP,
+ SOURCE_KEY_DATABASE,
+ NULL);
+ }
+}
+
+/**
+ * gdict_source_get_database:
+ * @source: a #GdictSource
+ *
+ * Retrieves the default database of @source.
+ *
+ * Return value: the default strategy of a #GdictSource. The returned string
+ * is owned by the #GdictSource object, and should not be modified or freed.
+ *
+ * Since: 1.0
+ */
+const gchar *
+gdict_source_get_database (GdictSource *source)
+{
+ g_return_val_if_fail (GDICT_IS_SOURCE (source), NULL);
+
+ return source->priv->database;
+}
+
+/**
+ * gdict_source_set_strategy:
+ * @source: a #GdictSource
+ * @strategy: a UTF-8 encoded strategy or %NULL
+ *
+ * Sets the description of @source. If @strategy is %NULL, unsets the
+ * currently set strategy.
+ *
+ * Since: 1.0
+ */
+void
+gdict_source_set_strategy (GdictSource *source,
+ const gchar *strategy)
+{
+ g_return_if_fail (GDICT_IS_SOURCE (source));
+
+ g_free (source->priv->strategy);
+
+ if (!source->priv->keyfile)
+ source->priv->keyfile = g_key_file_new ();
+
+ if (strategy && strategy[0] != '\0')
+ {
+ source->priv->strategy = g_strdup (strategy);
+
+ g_key_file_set_string (source->priv->keyfile,
+ SOURCE_GROUP,
+ SOURCE_KEY_STRATEGY,
+ strategy);
+ }
+ else
+ {
+ if (g_key_file_has_key (source->priv->keyfile,
+ SOURCE_GROUP,
+ SOURCE_KEY_STRATEGY,
+ NULL))
+ g_key_file_remove_key (source->priv->keyfile,
+ SOURCE_GROUP,
+ SOURCE_KEY_STRATEGY,
+ NULL);
+ }
+}
+
+/**
+ * gdict_source_get_strategy:
+ * @source: a #GdictSource
+ *
+ * Retrieves the default strategy of @source.
+ *
+ * Return value: the default strategy of a #GdictSource. The returned string
+ * is owned by the #GdictSource object, and should not be modified or freed.
+ *
+ * Since: 1.0
+ */
+const gchar *
+gdict_source_get_strategy (GdictSource *source)
+{
+ g_return_val_if_fail (GDICT_IS_SOURCE (source), NULL);
+
+ return source->priv->strategy;
+}
+
+/**
+ * gdict_source_set_transportv
+ * @source: a #GdictSource
+ * @transport: a #GdictSourceTransport
+ * @first_transport_property: FIXME
+ * @var_args: FIXME
+ *
+ * FIXME
+ *
+ * Since: 1.0
+ */
+void
+gdict_source_set_transportv (GdictSource *source,
+ GdictSourceTransport transport,
+ const gchar *first_transport_property,
+ va_list var_args)
+{
+ GdictSourcePrivate *priv;
+
+ g_return_if_fail (GDICT_IS_SOURCE (source));
+ g_return_if_fail (IS_VALID_TRANSPORT (transport));
+
+ priv = source->priv;
+
+ priv->transport = transport;
+
+ if (priv->context)
+ g_object_unref (priv->context);
+
+ switch (priv->transport)
+ {
+ case GDICT_SOURCE_TRANSPORT_DICTD:
+ priv->context = gdict_client_context_new (NULL, -1);
+ g_assert (GDICT_IS_CLIENT_CONTEXT (priv->context));
+
+ g_object_set_valist (G_OBJECT (priv->context),
+ first_transport_property,
+ var_args);
+
+ break;
+ case GDICT_SOURCE_TRANSPORT_INVALID:
+ default:
+ g_assert_not_reached ();
+ break;
+ }
+
+ /* update the keyfile */
+ if (!priv->keyfile)
+ priv->keyfile = g_key_file_new ();
+
+ g_key_file_set_string (priv->keyfile,
+ SOURCE_GROUP,
+ SOURCE_KEY_TRANSPORT,
+ valid_transports[transport]);
+
+ switch (priv->transport)
+ {
+ case GDICT_SOURCE_TRANSPORT_DICTD:
+ g_key_file_set_string (priv->keyfile,
+ SOURCE_GROUP,
+ SOURCE_KEY_HOSTNAME,
+ gdict_client_context_get_hostname (GDICT_CLIENT_CONTEXT (priv->context)));
+ g_key_file_set_integer (priv->keyfile,
+ SOURCE_GROUP,
+ SOURCE_KEY_PORT,
+ gdict_client_context_get_port (GDICT_CLIENT_CONTEXT (priv->context)));
+ break;
+ case GDICT_SOURCE_TRANSPORT_INVALID:
+ default:
+ g_assert_not_reached ();
+ break;
+ }
+}
+
+/**
+ * gdict_source_set_transport:
+ * @source: a #GdictSource
+ * @transport: a valid transport
+ * @first_transport_property: property for the context bound to
+ * the transport, or %NULL
+ * @Varargs: property value for first property name, then additionary
+ * properties, ending with %NULL
+ *
+ * Sets @transport as the choosen transport for @source. The @transport
+ * argument is a method of retrieving dictionary data from a source; it is
+ * used to create the right #GdictContext for this #GdictSource. After
+ * @transport, property name/value pairs should be listed, with a %NULL
+ * pointer ending the list. Properties are the same passed to a #GdictContext
+ * implementation instance using g_object_set().
+ *
+ * Here's a simple example:
+ *
+ * <informalexample><programlisting>
+ * #include &lt;gdict/gdict.h&gt;
+ * GdictSource *source = gdict_source_new ();
+ *
+ * gdict_source_set_name (source, "My Source");
+ * gdict_source_set_transport (source, GDICT_SOURCE_TRANSPORT_DICTD,
+ * "hostname", "dictionary-server.org",
+ * "port", 2628,
+ * NULL);
+ * </programlisting></informalexample>
+ *
+ * Since: 1.0
+ */
+void
+gdict_source_set_transport (GdictSource *source,
+ GdictSourceTransport transport,
+ const gchar *first_transport_property,
+ ...)
+{
+ va_list args;
+
+ g_return_if_fail (GDICT_IS_SOURCE (source));
+ g_return_if_fail (IS_VALID_TRANSPORT (transport));
+
+ va_start (args, first_transport_property);
+
+ gdict_source_set_transportv (source, transport,
+ first_transport_property,
+ args);
+
+ va_end (args);
+}
+
+/**
+ * gdict_source_get_transport:
+ * @source: a #GdictSource
+ *
+ * FIXME
+ *
+ * Return value: FIXME
+ *
+ * Since: 1.0
+ */
+GdictSourceTransport
+gdict_source_get_transport (GdictSource *source)
+{
+ g_return_val_if_fail (GDICT_IS_SOURCE (source), GDICT_SOURCE_TRANSPORT_INVALID);
+
+ return source->priv->transport;
+}
+
+/**
+ * gdict_source_get_context:
+ * @source: a #GdictSource
+ *
+ * Gets the #GdictContext bound to @source.
+ *
+ * Return value: a #GdictContext for @source. Use g_object_unref()
+ * when you don't need it anymore.
+ *
+ * Since: 1.0
+ */
+GdictContext *
+gdict_source_get_context (GdictSource *source)
+{
+ GdictContext *retval;
+
+ g_return_val_if_fail (GDICT_IS_SOURCE (source), NULL);
+
+ retval = gdict_source_create_context (source,
+ source->priv->transport,
+ NULL);
+
+ return retval;
+}
+
+/**
+ * gdict_source_peek_context:
+ * @source: a #GdictSource
+ *
+ * Gets the #GdictContext bound to @source. The returned object is a
+ * referenced copy of the context held by @source; if you want a different
+ * instance, use gdict_source_get_context().
+ *
+ * Return value: a referenced #GdictContext. Use g_object_unref() when
+ * finished using it.
+ *
+ * Since: 1.0
+ */
+GdictContext *
+gdict_source_peek_context (GdictSource *source)
+{
+ g_return_val_if_fail (GDICT_IS_SOURCE (source), NULL);
+
+ if (!source->priv->context)
+ source->priv->context = gdict_source_create_context (source,
+ source->priv->transport,
+ NULL);
+ return g_object_ref (source->priv->context);
+}
diff --git a/mate-dictionary/libgdict/gdict-source.h b/mate-dictionary/libgdict/gdict-source.h
new file mode 100644
index 00000000..b51ab97c
--- /dev/null
+++ b/mate-dictionary/libgdict/gdict-source.h
@@ -0,0 +1,115 @@
+/* gdict-source.h - Source configuration for Gdict
+ *
+ * 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 library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ */
+
+#ifndef __GDICT_SOURCE_H__
+#define __GDICT_SOURCE_H__
+
+#include <stdarg.h>
+#include <glib-object.h>
+#include "gdict-context.h"
+
+G_BEGIN_DECLS
+
+#define GDICT_TYPE_SOURCE (gdict_source_get_type ())
+#define GDICT_SOURCE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GDICT_TYPE_SOURCE, GdictSource))
+#define GDICT_IS_SOURCE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GDICT_TYPE_SOURCE))
+#define GDICT_SOURCE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GDICT_TYPE_SOURCE, GdictSourceClass))
+#define GDICT_IS_SOURCE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDICT_TYPE_SOURCE))
+#define GDICT_SOURCE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GDICT_TYPE_SOURCE, GdictSourceClass))
+
+
+typedef struct _GdictSource GdictSource;
+typedef struct _GdictSourceClass GdictSourceClass;
+typedef struct _GdictSourcePrivate GdictSourcePrivate;
+
+typedef enum
+{
+ GDICT_SOURCE_TRANSPORT_DICTD,
+
+ GDICT_SOURCE_TRANSPORT_INVALID /* only for debug */
+} GdictSourceTransport;
+
+#define GDICT_SOURCE_ERROR (gdict_source_error_quark ())
+
+typedef enum
+{
+ GDICT_SOURCE_ERROR_PARSE,
+ GDICT_SOURCE_ERROR_INVALID_NAME,
+ GDICT_SOURCE_ERROR_INVALID_TRANSPORT,
+ GDICT_SOURCE_ERROR_INVALID_BAD_PARAMETER
+} GdictSourceError;
+
+GQuark gdict_source_error_quark (void);
+
+struct _GdictSource
+{
+ /*< private >*/
+ GObject parent_instance;
+
+ GdictSourcePrivate *priv;
+};
+
+struct _GdictSourceClass
+{
+ /*< private >*/
+ GObjectClass parent_class;
+};
+
+GType gdict_source_get_type (void) G_GNUC_CONST;
+
+GdictSource * gdict_source_new (void);
+gboolean gdict_source_load_from_file (GdictSource *source,
+ const gchar *filename,
+ GError **error);
+gboolean gdict_source_load_from_data (GdictSource *source,
+ const gchar *data,
+ gsize length,
+ GError **error);
+gchar * gdict_source_to_data (GdictSource *source,
+ gsize *length,
+ GError **error) G_GNUC_MALLOC;
+
+void gdict_source_set_name (GdictSource *source,
+ const gchar *name);
+const gchar *gdict_source_get_name (GdictSource *source);
+void gdict_source_set_description (GdictSource *source,
+ const gchar *description);
+const gchar *gdict_source_get_description (GdictSource *source);
+void gdict_source_set_database (GdictSource *source,
+ const gchar *database);
+const gchar *gdict_source_get_database (GdictSource *source);
+void gdict_source_set_strategy (GdictSource *source,
+ const gchar *strategy);
+const gchar *gdict_source_get_strategy (GdictSource *source);
+void gdict_source_set_transport (GdictSource *source,
+ GdictSourceTransport transport,
+ const gchar *first_transport_property,
+ ...);
+void gdict_source_set_transportv (GdictSource *source,
+ GdictSourceTransport transport,
+ const gchar *first_transport_property,
+ va_list var_args);
+GdictSourceTransport gdict_source_get_transport (GdictSource *source);
+
+GdictContext * gdict_source_get_context (GdictSource *source);
+GdictContext * gdict_source_peek_context (GdictSource *source);
+
+G_END_DECLS
+
+#endif /* __GDICT_SOURCE_H__ */
diff --git a/mate-dictionary/libgdict/gdict-speller.c b/mate-dictionary/libgdict/gdict-speller.c
new file mode 100644
index 00000000..455883a1
--- /dev/null
+++ b/mate-dictionary/libgdict/gdict-speller.c
@@ -0,0 +1,827 @@
+/* gdict-speller.c - display widget for dictionary matches
+ *
+ * Copyright (C) 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 library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ */
+
+/**
+ * SECTION:gdict-speller
+ * @short_description: Display matching words
+ *
+ * #GdictSpeller is a widget showing a list of words returned by a
+ * #GdictContext query, using a specific database and a matching strategy.
+ */
+
+#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-lib.h>
+
+#include "gdict-speller.h"
+#include "gdict-utils.h"
+#include "gdict-enum-types.h"
+#include "gdict-marshal.h"
+#include "gdict-debug.h"
+#include "gdict-private.h"
+
+#define GDICT_SPELLER_GET_PRIVATE(obj) \
+(G_TYPE_INSTANCE_GET_PRIVATE ((obj), GDICT_TYPE_SPELLER, GdictSpellerPrivate))
+
+struct _GdictSpellerPrivate
+{
+ GdictContext *context;
+ gchar *database;
+ gchar *strategy;
+
+ gchar *word;
+
+ GtkWidget *treeview;
+ GtkWidget *clear_button;
+
+ GdkCursor *busy_cursor;
+
+ GtkListStore *store;
+ gint results;
+
+ guint start_id;
+ guint end_id;
+ guint match_id;
+ guint error_id;
+
+ guint is_searching : 1;
+};
+
+typedef enum
+{
+ MATCH_DB,
+ MATCH_WORD,
+ MATCH_ERROR
+} MatchType;
+
+enum
+{
+ MATCH_COLUMN_TYPE,
+ MATCH_COLUMN_DB_NAME,
+ MATCH_COLUMN_WORD,
+
+ MATCH_N_COLUMNS
+};
+
+enum
+{
+ PROP_0,
+
+ PROP_CONTEXT,
+ PROP_WORD,
+ PROP_DATABASE,
+ PROP_STRATEGY,
+ PROP_COUNT
+};
+
+enum
+{
+ WORD_ACTIVATED,
+
+ LAST_SIGNAL
+};
+
+static guint speller_signals[LAST_SIGNAL] = { 0 };
+
+G_DEFINE_TYPE (GdictSpeller, gdict_speller, GTK_TYPE_VBOX);
+
+
+static void
+set_gdict_context (GdictSpeller *speller,
+ GdictContext *context)
+{
+ GdictSpellerPrivate *priv;
+
+ g_assert (GDICT_IS_SPELLER (speller));
+
+ priv = speller->priv;
+ if (priv->context)
+ {
+ if (priv->start_id)
+ {
+ GDICT_NOTE (SPELLER, "Removing old context handlers");
+
+ g_signal_handler_disconnect (priv->context, priv->start_id);
+ g_signal_handler_disconnect (priv->context, priv->match_id);
+ g_signal_handler_disconnect (priv->context, priv->end_id);
+
+ priv->start_id = 0;
+ priv->end_id = 0;
+ priv->match_id = 0;
+ }
+
+ if (priv->error_id)
+ {
+ g_signal_handler_disconnect (priv->context, priv->error_id);
+
+ priv->error_id = 0;
+ }
+
+ GDICT_NOTE (SPELLER, "Removing old context");
+
+ g_object_unref (G_OBJECT (priv->context));
+ }
+
+ if (!context)
+ return;
+
+ if (!GDICT_IS_CONTEXT (context))
+ {
+ g_warning ("Object of type `%s' instead of a GdictContext\n",
+ g_type_name (G_OBJECT_TYPE (context)));
+ return;
+ }
+
+ GDICT_NOTE (SPELLER, "Setting new context\n");
+
+ priv->context = context;
+ g_object_ref (G_OBJECT (priv->context));
+}
+
+static void
+gdict_speller_finalize (GObject *gobject)
+{
+ GdictSpeller *speller = GDICT_SPELLER (gobject);
+ GdictSpellerPrivate *priv = speller->priv;
+
+ if (priv->context)
+ set_gdict_context (speller, NULL);
+
+ if (priv->busy_cursor)
+ gdk_cursor_unref (priv->busy_cursor);
+
+ g_free (priv->strategy);
+ g_free (priv->database);
+ g_free (priv->word);
+
+ if (priv->store)
+ g_object_unref (priv->store);
+
+ G_OBJECT_CLASS (gdict_speller_parent_class)->finalize (gobject);
+}
+
+
+static void
+gdict_speller_set_property (GObject *gobject,
+ guint prop_id,
+ const GValue *value,
+ GParamSpec *pspec)
+{
+ GdictSpeller *speller = GDICT_SPELLER (gobject);
+ GdictSpellerPrivate *priv = speller->priv;
+
+ switch (prop_id)
+ {
+ case PROP_CONTEXT:
+ set_gdict_context (speller, g_value_get_object (value));
+ break;
+ case PROP_DATABASE:
+ g_free (priv->database);
+ priv->database = g_strdup (g_value_get_string (value));
+ break;
+ case PROP_STRATEGY:
+ g_free (priv->strategy);
+ priv->strategy = g_strdup (g_value_get_string (value));
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
+ break;
+ }
+}
+
+static void
+gdict_speller_get_property (GObject *gobject,
+ guint prop_id,
+ GValue *value,
+ GParamSpec *pspec)
+{
+ GdictSpeller *speller = GDICT_SPELLER (gobject);
+
+ switch (prop_id)
+ {
+ case PROP_DATABASE:
+ g_value_set_string (value, speller->priv->database);
+ break;
+ case PROP_STRATEGY:
+ g_value_set_string (value, speller->priv->strategy);
+ break;
+ case PROP_CONTEXT:
+ g_value_set_object (value, speller->priv->context);
+ break;
+ case PROP_COUNT:
+ g_value_set_int (value, speller->priv->results);
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
+ break;
+ }
+}
+
+static void
+row_activated_cb (GtkTreeView *treeview,
+ GtkTreePath *path,
+ GtkTreeViewColumn *column,
+ gpointer user_data)
+{
+ GdictSpeller *speller = GDICT_SPELLER (user_data);
+ GdictSpellerPrivate *priv = speller->priv;
+ GtkTreeIter iter;
+ gchar *word, *db_name;
+ gboolean valid;
+
+ valid = gtk_tree_model_get_iter (GTK_TREE_MODEL (priv->store),
+ &iter,
+ path);
+ if (!valid)
+ {
+ g_warning ("Invalid iterator found");
+
+ return;
+ }
+
+ gtk_tree_model_get (GTK_TREE_MODEL (priv->store), &iter,
+ MATCH_COLUMN_WORD, &word,
+ MATCH_COLUMN_DB_NAME, &db_name,
+ -1);
+ if (word)
+ g_signal_emit (speller, speller_signals[WORD_ACTIVATED], 0,
+ word, db_name);
+ else
+ {
+ gchar *row = gtk_tree_path_to_string (path);
+
+ g_warning ("Row %s activated, but no word attached", row);
+ g_free (row);
+ }
+
+ g_free (word);
+ g_free (db_name);
+}
+
+static void
+clear_button_clicked_cb (GtkWidget *widget,
+ gpointer user_data)
+{
+ GdictSpeller *speller = GDICT_SPELLER (user_data);
+
+ gdict_speller_clear (speller);
+}
+
+static GObject *
+gdict_speller_constructor (GType type,
+ guint n_params,
+ GObjectConstructParam *params)
+{
+ GObject *object;
+ GdictSpeller *speller;
+ GdictSpellerPrivate *priv;
+ GtkWidget *sw;
+ GtkCellRenderer *renderer;
+ GtkTreeViewColumn *column;
+ GtkWidget *hbox;
+
+ object = G_OBJECT_CLASS (gdict_speller_parent_class)->constructor (type,
+ n_params,
+ params);
+ speller = GDICT_SPELLER (object);
+ priv = speller->priv;
+
+ gtk_widget_push_composite_child ();
+
+ sw = gtk_scrolled_window_new (NULL, NULL);
+ gtk_widget_set_composite_name (sw, "gdict-speller-scrolled-window");
+ gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
+ GTK_POLICY_AUTOMATIC,
+ GTK_POLICY_AUTOMATIC);
+ gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw),
+ GTK_SHADOW_IN);
+ gtk_box_pack_start (GTK_BOX (speller), sw, TRUE, TRUE, 0);
+ gtk_widget_show (sw);
+
+ renderer = gtk_cell_renderer_text_new ();
+ column = gtk_tree_view_column_new_with_attributes ("matches",
+ renderer,
+ "text", MATCH_COLUMN_WORD,
+ NULL);
+
+ priv->treeview = gtk_tree_view_new ();
+ gtk_widget_set_composite_name (priv->treeview, "gdict-speller-treeview");
+ gtk_tree_view_set_model (GTK_TREE_VIEW (priv->treeview),
+ GTK_TREE_MODEL (priv->store));
+ gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (priv->treeview), FALSE);
+ gtk_tree_view_append_column (GTK_TREE_VIEW (priv->treeview), column);
+ g_signal_connect (priv->treeview, "row-activated",
+ G_CALLBACK (row_activated_cb), speller);
+ gtk_container_add (GTK_CONTAINER (sw), priv->treeview);
+ gtk_widget_show (priv->treeview);
+
+ hbox = gtk_hbox_new (FALSE, 0);
+
+ priv->clear_button = gtk_button_new ();
+ gtk_button_set_image (GTK_BUTTON (priv->clear_button),
+ gtk_image_new_from_stock (GTK_STOCK_CLEAR,
+ GTK_ICON_SIZE_SMALL_TOOLBAR));
+ g_signal_connect (priv->clear_button, "clicked",
+ G_CALLBACK (clear_button_clicked_cb),
+ speller);
+ gtk_box_pack_start (GTK_BOX (hbox), priv->clear_button, FALSE, FALSE, 0);
+ gtk_widget_show (priv->clear_button);
+ gtk_widget_set_tooltip_text (priv->clear_button,
+ _("Clear the list of similar words"));
+
+ gtk_box_pack_end (GTK_BOX (speller), hbox, FALSE, FALSE, 0);
+ gtk_widget_show (hbox);
+
+ gtk_widget_pop_composite_child ();
+
+ return object;
+}
+
+static void
+gdict_speller_class_init (GdictSpellerClass *klass)
+{
+ GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+
+ gobject_class->finalize = gdict_speller_finalize;
+ gobject_class->set_property = gdict_speller_set_property;
+ gobject_class->get_property = gdict_speller_get_property;
+ gobject_class->constructor = gdict_speller_constructor;
+
+ g_object_class_install_property (gobject_class,
+ PROP_CONTEXT,
+ g_param_spec_object ("context",
+ _("Context"),
+ _("The GdictContext object used to get the word definition"),
+ GDICT_TYPE_CONTEXT,
+ (G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT)));
+ g_object_class_install_property (gobject_class,
+ PROP_DATABASE,
+ g_param_spec_string ("database",
+ _("Database"),
+ _("The database used to query the GdictContext"),
+ GDICT_DEFAULT_DATABASE,
+ (G_PARAM_READABLE | G_PARAM_WRITABLE)));
+ g_object_class_install_property (gobject_class,
+ PROP_DATABASE,
+ g_param_spec_string ("strategy",
+ _("Strategy"),
+ _("The strategy used to query the GdictContext"),
+ GDICT_DEFAULT_STRATEGY,
+ (G_PARAM_READABLE | G_PARAM_WRITABLE)));
+
+ speller_signals[WORD_ACTIVATED] =
+ g_signal_new ("word-activated",
+ G_OBJECT_CLASS_TYPE (gobject_class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (GdictSpellerClass, word_activated),
+ NULL, NULL,
+ gdict_marshal_VOID__STRING_STRING,
+ G_TYPE_NONE, 2,
+ G_TYPE_STRING,
+ G_TYPE_STRING);
+
+ g_type_class_add_private (gobject_class, sizeof (GdictSpellerPrivate));
+}
+
+static void
+gdict_speller_init (GdictSpeller *speller)
+{
+ GdictSpellerPrivate *priv;
+
+ speller->priv = priv = GDICT_SPELLER_GET_PRIVATE (speller);
+
+ priv->database = NULL;
+ priv->strategy = NULL;
+ priv->word = NULL;
+
+ priv->results = -1;
+ priv->context = NULL;
+
+ priv->store = gtk_list_store_new (MATCH_N_COLUMNS,
+ G_TYPE_INT, /* MatchType */
+ G_TYPE_STRING, /* db_name */
+ G_TYPE_STRING /* word */);
+
+ priv->start_id = 0;
+ priv->end_id = 0;
+ priv->match_id = 0;
+ priv->error_id = 0;
+}
+
+/**
+ * gdict_speller_new:
+ *
+ * FIXME
+ *
+ * Return value: FIXME
+ *
+ * Since:
+ */
+GtkWidget *
+gdict_speller_new (void)
+{
+ return g_object_new (GDICT_TYPE_SPELLER, NULL);
+}
+
+/**
+ * gdict_speller_new_with_context:
+ * @context: a #GdictContext
+ *
+ * FIXME
+ *
+ * Return value: FIXME
+ *
+ * Since:
+ */
+GtkWidget *
+gdict_speller_new_with_context (GdictContext *context)
+{
+ g_return_val_if_fail (GDICT_IS_CONTEXT (context), NULL);
+
+ return g_object_new (GDICT_TYPE_SPELLER,
+ "context", context,
+ NULL);
+}
+
+/**
+ * gdict_speller_set_context:
+ * @speller: a #GdictSpeller
+ * @context: a #GdictContext
+ *
+ * FIXME
+ *
+ * Since:
+ */
+void
+gdict_speller_set_context (GdictSpeller *speller,
+ GdictContext *context)
+{
+ g_return_if_fail (GDICT_IS_SPELLER (speller));
+ g_return_if_fail (context == NULL || GDICT_IS_CONTEXT (context));
+
+ set_gdict_context (speller, context);
+
+ g_object_notify (G_OBJECT (speller), "context");
+}
+
+/**
+ * gdict_speller_get_context:
+ * @speller: a #GdictSpeller
+ *
+ * FIXME
+ *
+ * Return value: a #GdictContext
+ *
+ * Since:
+ */
+GdictContext *
+gdict_speller_get_context (GdictSpeller *speller)
+{
+ g_return_val_if_fail (GDICT_IS_SPELLER (speller), NULL);
+
+ return speller->priv->context;
+}
+
+/**
+ * gdict_speller_set_database:
+ * @speller: a #GdictSpeller
+ * @database: FIXME
+ *
+ * FIXME
+ *
+ * Since:
+ */
+void
+gdict_speller_set_database (GdictSpeller *speller,
+ const gchar *database)
+{
+ GdictSpellerPrivate *priv;
+
+ g_return_if_fail (GDICT_IS_SPELLER (speller));
+
+ priv = speller->priv;
+
+ if (!database || database[0] == '\0')
+ database = GDICT_DEFAULT_DATABASE;
+
+ g_free (priv->database);
+ priv->database = g_strdup (database);
+
+ g_object_notify (G_OBJECT (speller), "database");
+}
+
+/**
+ * gdict_speller_get_database:
+ * @speller: a #GdictSpeller
+ *
+ * FIXME
+ *
+ * Return value: FIXME
+ *
+ * Since: FIXME
+ */
+const gchar *
+gdict_speller_get_database (GdictSpeller *speller)
+{
+ g_return_val_if_fail (GDICT_IS_SPELLER (speller), NULL);
+
+ return speller->priv->database;
+}
+
+/**
+ * gdict_speller_set_strategy:
+ * @speller: a #GdictSpeller
+ * @strategy: FIXME
+ *
+ * FIXME
+ *
+ * Since: FIXME
+ */
+void
+gdict_speller_set_strategy (GdictSpeller *speller,
+ const gchar *strategy)
+{
+ GdictSpellerPrivate *priv;
+
+ g_return_if_fail (GDICT_IS_SPELLER (speller));
+
+ priv = speller->priv;
+
+ if (!strategy || strategy[0] == '\0')
+ strategy = GDICT_DEFAULT_STRATEGY;
+
+ g_free (priv->strategy);
+ priv->strategy = g_strdup (strategy);
+
+ g_object_notify (G_OBJECT (speller), "strategy");
+}
+
+/**
+ * gdict_speller_get_strategy:
+ * @speller: a #GdictSpeller
+ *
+ * FIXME
+ *
+ * Return value: FIXME
+ *
+ * Since: FIXME
+ */
+const gchar *
+gdict_speller_get_strategy (GdictSpeller *speller)
+{
+ g_return_val_if_fail (GDICT_IS_SPELLER (speller), NULL);
+
+ return speller->priv->strategy;
+}
+
+/**
+ * gdict_speller_clear:
+ * @speller: a #GdictSpeller
+ *
+ * FIXME
+ *
+ * Since: FIXME
+ */
+void
+gdict_speller_clear (GdictSpeller *speller)
+{
+ GdictSpellerPrivate *priv;
+
+ g_return_if_fail (GDICT_IS_SPELLER (speller));
+ priv = speller->priv;
+
+ gtk_tree_view_set_model (GTK_TREE_VIEW (priv->treeview), NULL);
+
+ gtk_list_store_clear (priv->store);
+ priv->results = -1;
+
+ gtk_tree_view_set_model (GTK_TREE_VIEW (priv->treeview),
+ GTK_TREE_MODEL (priv->store));
+}
+
+static void
+lookup_start_cb (GdictContext *context,
+ gpointer user_data)
+{
+ GdictSpeller *speller = GDICT_SPELLER (user_data);
+ GdictSpellerPrivate *priv = speller->priv;
+
+ if (!priv->busy_cursor)
+ priv->busy_cursor = gdk_cursor_new (GDK_WATCH);
+
+ if (gtk_widget_get_window (GTK_WIDGET (speller)))
+ gdk_window_set_cursor (gtk_widget_get_window (GTK_WIDGET (speller)), priv->busy_cursor);
+
+ priv->is_searching = TRUE;
+}
+
+static void
+lookup_end_cb (GdictContext *context,
+ gpointer user_data)
+{
+ GdictSpeller *speller = GDICT_SPELLER (user_data);
+ GdictSpellerPrivate *priv = speller->priv;
+
+ if (gtk_widget_get_window (GTK_WIDGET (speller)))
+ gdk_window_set_cursor (gtk_widget_get_window (GTK_WIDGET (speller)), NULL);
+
+ g_free (priv->word);
+ priv->word = NULL;
+
+ priv->is_searching = FALSE;
+}
+
+static void
+match_found_cb (GdictContext *context,
+ GdictMatch *match,
+ gpointer user_data)
+{
+ GdictSpeller *speller = GDICT_SPELLER (user_data);
+ GdictSpellerPrivate *priv = speller->priv;
+ GtkTreeIter iter;
+
+ GDICT_NOTE (SPELLER, "MATCH: `%s' (from `%s')",
+ gdict_match_get_word (match),
+ gdict_match_get_database (match));
+
+ gtk_list_store_append (priv->store, &iter);
+ gtk_list_store_set (priv->store, &iter,
+ MATCH_COLUMN_TYPE, MATCH_WORD,
+ MATCH_COLUMN_DB_NAME, gdict_match_get_database (match),
+ MATCH_COLUMN_WORD, gdict_match_get_word (match),
+ -1);
+
+ if (priv->results == -1)
+ priv->results = 1;
+ else
+ priv->results += 1;
+}
+
+static void
+error_cb (GdictContext *context,
+ const GError *error,
+ gpointer user_data)
+{
+ GdictSpeller *speller = GDICT_SPELLER (user_data);
+ GdictSpellerPrivate *priv = speller->priv;
+
+ gdict_speller_clear (speller);
+
+ if (gtk_widget_get_window (GTK_WIDGET (speller)))
+ gdk_window_set_cursor (gtk_widget_get_window (GTK_WIDGET (speller)), NULL);
+
+ g_free (priv->word);
+ priv->word = NULL;
+
+ priv->is_searching = FALSE;
+}
+
+/**
+ * gdict_speller_match:
+ * @speller: a #GdictSpeller
+ * @word: FIXME
+ *
+ * FIXME
+ *
+ * Since: FIXME
+ */
+void
+gdict_speller_match (GdictSpeller *speller,
+ const gchar *word)
+{
+ GdictSpellerPrivate *priv;
+ GError *match_error;
+
+ g_return_if_fail (GDICT_IS_SPELLER (speller));
+ g_return_if_fail (word != NULL);
+
+ priv = speller->priv;
+
+ if (!priv->context)
+ {
+ g_warning ("Attempting to match `%s', but no GdictContext "
+ "has been set. Use gdict_speller_set_context() "
+ "before invoking gdict_speller_match().",
+ word);
+
+ return;
+ }
+
+ if (priv->is_searching)
+ {
+ _gdict_show_error_dialog (NULL,
+ _("Another search is in progress"),
+ _("Please wait until the current search ends."));
+
+ return;
+ }
+
+ gdict_speller_clear (speller);
+
+ if (!priv->start_id)
+ {
+ priv->start_id = g_signal_connect (priv->context, "lookup-start",
+ G_CALLBACK (lookup_start_cb),
+ speller);
+ priv->match_id = g_signal_connect (priv->context, "match-found",
+ G_CALLBACK (match_found_cb),
+ speller);
+ priv->end_id = g_signal_connect (priv->context, "lookup-end",
+ G_CALLBACK (lookup_end_cb),
+ speller);
+ }
+
+ if (!priv->error_id)
+ priv->error_id = g_signal_connect (priv->context, "error",
+ G_CALLBACK (error_cb),
+ speller);
+
+ g_free (priv->word);
+ priv->word = g_strdup (word);
+
+ match_error = NULL;
+ gdict_context_match_word (priv->context,
+ priv->database,
+ priv->strategy,
+ priv->word,
+ &match_error);
+ if (match_error)
+ {
+ GtkTreeIter iter;
+
+ gtk_list_store_append (priv->store, &iter);
+ gtk_list_store_set (priv->store, &iter,
+ MATCH_COLUMN_TYPE, MATCH_ERROR,
+ MATCH_COLUMN_DB_NAME, _("Error while matching"),
+ MATCH_COLUMN_WORD, NULL,
+ -1);
+
+ g_warning ("Error while matching `%s': %s",
+ priv->word,
+ match_error->message);
+
+ g_error_free (match_error);
+ }
+}
+
+/**
+ * gdict_speller_count_match:
+ * @speller: a #GdictSpeller
+ *
+ * FIXME
+ *
+ * Return value: FIXME
+ *
+ * Since: FIXME
+ */
+gint
+gdict_speller_count_matches (GdictSpeller *speller)
+{
+ g_return_val_if_fail (GDICT_IS_SPELLER (speller), -1);
+
+ return speller->priv->results;
+}
+
+/**
+ * gdict_speller_get_matches:
+ * @speller: a #GdictSpeller
+ * @length: FIXME
+ *
+ * FIXME
+ *
+ * Return value: FIXME
+ *
+ * Since: FIXME
+ */
+gchar **
+gdict_speller_get_matches (GdictSpeller *speller,
+ gsize length)
+{
+ g_return_val_if_fail (GDICT_IS_SPELLER (speller), NULL);
+
+ return NULL;
+}
diff --git a/mate-dictionary/libgdict/gdict-speller.h b/mate-dictionary/libgdict/gdict-speller.h
new file mode 100644
index 00000000..9d6e81ff
--- /dev/null
+++ b/mate-dictionary/libgdict/gdict-speller.h
@@ -0,0 +1,87 @@
+/* gdict-speller.h - display widget for dictionary matches
+ *
+ * Copyright (C) 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 library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ */
+
+#ifndef __GDICT_SPELLER_H__
+#define __GDICT_SPELLER_H__
+
+#include <gtk/gtk.h>
+#include "gdict-context.h"
+
+G_BEGIN_DECLS
+
+#define GDICT_TYPE_SPELLER (gdict_speller_get_type ())
+#define GDICT_SPELLER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GDICT_TYPE_SPELLER, GdictSpeller))
+#define GDICT_SPELLER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GDICT_TYPE_SPELLER, GdictSpellerClass))
+#define GDICT_IS_SPELLER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GDICT_TYPE_SPELLER))
+#define GDICT_IS_SPELLER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDICT_TYPE_SPELLER))
+#define GDICT_SPELLER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GDICT_TYPE_SPELLER, GdictSpellerClass))
+
+typedef struct _GdictSpeller GdictSpeller;
+typedef struct _GdictSpellerPrivate GdictSpellerPrivate;
+typedef struct _GdictSpellerClass GdictSpellerClass;
+
+struct _GdictSpeller
+{
+ GtkVBox parent_instance;
+
+ /*< private >*/
+ GdictSpellerPrivate *priv;
+};
+
+struct _GdictSpellerClass
+{
+ GtkVBoxClass parent_class;
+
+ void (*word_activated) (GdictSpeller *speller,
+ const gchar *word,
+ const gchar *database);
+
+ /* padding for future expansion */
+ void (*_gdict_speller_1) (void);
+ void (*_gdict_speller_2) (void);
+ void (*_gdict_speller_3) (void);
+ void (*_gdict_speller_4) (void);
+};
+
+GType gdict_speller_get_type (void) G_GNUC_CONST;
+
+GtkWidget * gdict_speller_new (void);
+GtkWidget * gdict_speller_new_with_context (GdictContext *context);
+
+void gdict_speller_set_context (GdictSpeller *speller,
+ GdictContext *context);
+GdictContext * gdict_speller_get_context (GdictSpeller *speller);
+void gdict_speller_set_database (GdictSpeller *speller,
+ const gchar *database);
+const gchar *gdict_speller_get_database (GdictSpeller *speller);
+void gdict_speller_set_strategy (GdictSpeller *speller,
+ const gchar *strategy);
+const gchar *gdict_speller_get_strategy (GdictSpeller *speller);
+
+void gdict_speller_clear (GdictSpeller *speller);
+void gdict_speller_match (GdictSpeller *speller,
+ const gchar *word);
+
+gint gdict_speller_count_matches (GdictSpeller *speller);
+gchar ** gdict_speller_get_matches (GdictSpeller *speller,
+ gsize length);
+
+G_END_DECLS
+
+#endif /* __GDICT_SPELLER_H__ */
diff --git a/mate-dictionary/libgdict/gdict-strategy-chooser.c b/mate-dictionary/libgdict/gdict-strategy-chooser.c
new file mode 100644
index 00000000..93df7073
--- /dev/null
+++ b/mate-dictionary/libgdict/gdict-strategy-chooser.c
@@ -0,0 +1,1092 @@
+/* gdict-strategy-chooser.c - display widget for strategy names
+ *
+ * Copyright (C) 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 library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ */
+
+/**
+ * SECTION:gdict-strategy-chooser
+ * @short_description: Display a list of matching strategies
+ *
+ * Each #GdictContext allows matching a word using a specific "matching
+ * strategy". The #GdictStrategyChooser widget queries a #GdictContext and
+ * displays the list of available matching strategies.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdarg.h>
+
+#include <gtk/gtk.h>
+#include <glib/gi18n-lib.h>
+
+#include "gdict-strategy-chooser.h"
+#include "gdict-utils.h"
+#include "gdict-debug.h"
+#include "gdict-private.h"
+#include "gdict-enum-types.h"
+#include "gdict-marshal.h"
+
+#define GDICT_STRATEGY_CHOOSER_GET_PRIVATE(obj) \
+(G_TYPE_INSTANCE_GET_PRIVATE ((obj), GDICT_TYPE_STRATEGY_CHOOSER, GdictStrategyChooserPrivate))
+
+struct _GdictStrategyChooserPrivate
+{
+ GtkListStore *store;
+
+ GtkWidget *treeview;
+ GtkWidget *clear_button;
+ GtkWidget *refresh_button;
+ GtkWidget *buttons_box;
+ 
+ GdictContext *context;
+ gint results;
+
+ guint start_id;
+ guint match_id;
+ guint end_id;
+ guint error_id;
+
+ GdkCursor *busy_cursor;
+
+ gchar *current_strat;
+
+ guint is_searching : 1;
+};
+
+enum
+{
+ STRATEGY_NAME,
+ STRATEGY_ERROR
+} StratType;
+
+enum
+{
+ STRAT_COLUMN_TYPE,
+ STRAT_COLUMN_NAME,
+ STRAT_COLUMN_DESCRIPTION,
+ STRAT_COLUMN_CURRENT,
+
+ STRAT_N_COLUMNS
+};
+
+enum
+{
+ PROP_0,
+ 
+ PROP_CONTEXT,
+ PROP_COUNT
+};
+
+enum
+{
+ STRATEGY_ACTIVATED,
+ CLOSED,
+
+ LAST_SIGNAL
+};
+
+static guint db_chooser_signals[LAST_SIGNAL] = { 0 };
+
+G_DEFINE_TYPE (GdictStrategyChooser,
+ gdict_strategy_chooser,
+ GTK_TYPE_VBOX);
+
+
+static void
+set_gdict_context (GdictStrategyChooser *chooser,
+ GdictContext *context)
+{
+ GdictStrategyChooserPrivate *priv;
+ 
+ g_assert (GDICT_IS_STRATEGY_CHOOSER (chooser));
+ priv = chooser->priv;
+ 
+ if (priv->context)
+ {
+ if (priv->start_id)
+ {
+ GDICT_NOTE (CHOOSER, "Removing old context handlers");
+ 
+ g_signal_handler_disconnect (priv->context, priv->start_id);
+ g_signal_handler_disconnect (priv->context, priv->match_id);
+ g_signal_handler_disconnect (priv->context, priv->end_id);
+ 
+ priv->start_id = 0;
+ priv->end_id = 0;
+ priv->match_id = 0;
+ }
+ 
+ if (priv->error_id)
+ {
+ g_signal_handler_disconnect (priv->context, priv->error_id);
+
+ priv->error_id = 0;
+ }
+
+ GDICT_NOTE (CHOOSER, "Removing old context");
+ 
+ g_object_unref (G_OBJECT (priv->context));
+ 
+ priv->context = NULL;
+ priv->results = -1;
+ }
+
+ if (!context)
+ return;
+
+ if (!GDICT_IS_CONTEXT (context))
+ {
+ g_warning ("Object of type '%s' instead of a GdictContext\n",
+ g_type_name (G_OBJECT_TYPE (context)));
+ return;
+ }
+
+ GDICT_NOTE (CHOOSER, "Setting new context");
+ 
+ priv->context = g_object_ref (context);
+ priv->results = 0;
+}
+
+static void
+gdict_strategy_chooser_dispose (GObject *gobject)
+{
+ GdictStrategyChooser *chooser = GDICT_STRATEGY_CHOOSER (gobject);
+ GdictStrategyChooserPrivate *priv = chooser->priv;
+
+ set_gdict_context (chooser, NULL);
+
+ if (priv->busy_cursor)
+ {
+ gdk_cursor_unref (priv->busy_cursor);
+ priv->busy_cursor = NULL;
+ }
+
+ if (priv->store)
+ {
+ g_object_unref (priv->store);
+ priv->store = NULL;
+ }
+
+ G_OBJECT_CLASS (gdict_strategy_chooser_parent_class)->dispose (gobject);
+}
+
+static void
+gdict_strategy_chooser_finalize (GObject *gobject)
+{
+ GdictStrategyChooser *chooser = GDICT_STRATEGY_CHOOSER (gobject);
+ GdictStrategyChooserPrivate *priv = chooser->priv;
+
+ g_free (priv->current_strat);
+
+ G_OBJECT_CLASS (gdict_strategy_chooser_parent_class)->finalize (gobject);
+}
+
+static void
+gdict_strategy_chooser_set_property (GObject *gobject,
+ guint prop_id,
+ const GValue *value,
+ GParamSpec *pspec)
+{
+ GdictStrategyChooser *chooser = GDICT_STRATEGY_CHOOSER (gobject);
+ 
+ switch (prop_id)
+ {
+ case PROP_CONTEXT:
+ set_gdict_context (chooser, g_value_get_object (value));
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
+ break;
+ }
+}
+
+static void
+gdict_strategy_chooser_get_property (GObject *gobject,
+ guint prop_id,
+ GValue *value,
+ GParamSpec *pspec)
+{
+ GdictStrategyChooser *chooser = GDICT_STRATEGY_CHOOSER (gobject);
+ 
+ switch (prop_id)
+ {
+ case PROP_CONTEXT:
+ g_value_set_object (value, chooser->priv->context);
+ break;
+ case PROP_COUNT:
+ g_value_set_int (value, chooser->priv->results);
+ break;
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
+ break;
+ }
+}
+
+static void
+row_activated_cb (GtkTreeView *treeview,
+ GtkTreePath *path,
+ GtkTreeViewColumn *column,
+ gpointer user_data)
+{
+ GdictStrategyChooser *chooser = GDICT_STRATEGY_CHOOSER (user_data);
+ GdictStrategyChooserPrivate *priv = chooser->priv;
+ GtkTreeIter iter;
+ gchar *db_name, *db_desc;
+ gboolean valid;
+
+ valid = gtk_tree_model_get_iter (GTK_TREE_MODEL (priv->store),
+ &iter,
+ path);
+ if (!valid)
+ {
+ g_warning ("Invalid iterator found");
+ return;
+ }
+
+ gtk_tree_model_get (GTK_TREE_MODEL (priv->store), &iter,
+ STRAT_COLUMN_NAME, &db_name,
+ STRAT_COLUMN_DESCRIPTION, &db_desc,
+ -1);
+ if (db_name && db_desc)
+ {
+ g_signal_emit (chooser, db_chooser_signals[STRATEGY_ACTIVATED], 0,
+ db_name, db_desc);
+ }
+ else
+ {
+ gchar *row = gtk_tree_path_to_string (path);
+
+ g_warning ("Row %s activated, but no strategy attached", row);
+ g_free (row);
+ }
+
+ g_free (db_name);
+ g_free (db_desc);
+}
+
+static void
+refresh_button_clicked_cb (GtkWidget *widget,
+ gpointer user_data)
+{
+ GdictStrategyChooser *chooser = GDICT_STRATEGY_CHOOSER (user_data);
+
+ gdict_strategy_chooser_refresh (chooser);
+}
+
+static void
+clear_button_clicked_cb (GtkWidget *widget,
+ gpointer user_data)
+{
+ GdictStrategyChooser *chooser = GDICT_STRATEGY_CHOOSER (user_data);
+
+ gdict_strategy_chooser_clear (chooser);
+}
+
+static GObject *
+gdict_strategy_chooser_constructor (GType type,
+ guint n_params,
+ GObjectConstructParam *params)
+{
+ GObject *object;
+ GdictStrategyChooser *chooser;
+ GdictStrategyChooserPrivate *priv;
+ GtkWidget *sw;
+ GtkCellRenderer *renderer;
+ GtkTreeViewColumn *column;
+ GtkWidget *hbox;
+
+ object = G_OBJECT_CLASS (gdict_strategy_chooser_parent_class)->constructor (type,
+ n_params,
+ params);
+
+ chooser = GDICT_STRATEGY_CHOOSER (object);
+ priv = chooser->priv;
+
+ gtk_widget_push_composite_child ();
+
+ sw = gtk_scrolled_window_new (NULL, NULL);
+ gtk_widget_set_composite_name (sw, "gdict-strategy-chooser-scrolled-window");
+ gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
+ GTK_POLICY_AUTOMATIC,
+ GTK_POLICY_AUTOMATIC);
+ gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw),
+ GTK_SHADOW_IN);
+ gtk_box_pack_start (GTK_BOX (chooser), sw, TRUE, TRUE, 0);
+ gtk_widget_show (sw);
+
+ renderer = gtk_cell_renderer_text_new ();
+ column = gtk_tree_view_column_new_with_attributes ("strategies",
+ renderer,
+ "text", STRAT_COLUMN_DESCRIPTION,
+ "weight", STRAT_COLUMN_CURRENT,
+ NULL);
+ priv->treeview = gtk_tree_view_new ();
+ gtk_widget_set_composite_name (priv->treeview, "gdict-strategy-chooser-treeview");
+ gtk_tree_view_set_model (GTK_TREE_VIEW (priv->treeview),
+ GTK_TREE_MODEL (priv->store));
+ gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (priv->treeview), FALSE);
+ gtk_tree_view_append_column (GTK_TREE_VIEW (priv->treeview), column);
+ g_signal_connect (priv->treeview, "row-activated",
+ G_CALLBACK (row_activated_cb), chooser);
+ gtk_container_add (GTK_CONTAINER (sw), priv->treeview);
+ gtk_widget_show (priv->treeview);
+
+ hbox = gtk_hbox_new (FALSE, 0);
+
+ priv->refresh_button = gtk_button_new ();
+ gtk_button_set_image (GTK_BUTTON (priv->refresh_button),
+ gtk_image_new_from_stock (GTK_STOCK_REFRESH,
+ GTK_ICON_SIZE_SMALL_TOOLBAR));
+ g_signal_connect (priv->refresh_button, "clicked",
+ G_CALLBACK (refresh_button_clicked_cb),
+ chooser);
+ gtk_box_pack_start (GTK_BOX (hbox), priv->refresh_button, FALSE, FALSE, 0);
+ gtk_widget_show (priv->refresh_button);
+ gtk_widget_set_tooltip_text (priv->refresh_button,
+ _("Reload the list of available strategies"));
+
+ priv->clear_button = gtk_button_new ();
+ gtk_button_set_image (GTK_BUTTON (priv->clear_button),
+ gtk_image_new_from_stock (GTK_STOCK_CLEAR,
+ GTK_ICON_SIZE_SMALL_TOOLBAR));
+ g_signal_connect (priv->clear_button, "clicked",
+ G_CALLBACK (clear_button_clicked_cb),
+ chooser);
+ gtk_box_pack_start (GTK_BOX (hbox), priv->clear_button, FALSE, FALSE, 0);
+ gtk_widget_show (priv->clear_button);
+ gtk_widget_set_tooltip_text (priv->clear_button,
+ _("Clear the list of available strategies"));
+
+ gtk_box_pack_end (GTK_BOX (chooser), hbox, FALSE, FALSE, 0);
+ gtk_widget_show (hbox);
+ 
+ gtk_widget_pop_composite_child ();
+
+ return object;
+}
+
+static void
+gdict_strategy_chooser_class_init (GdictStrategyChooserClass *klass)
+{
+ GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+ 
+ gobject_class->finalize = gdict_strategy_chooser_finalize;
+ gobject_class->dispose = gdict_strategy_chooser_dispose;
+ gobject_class->set_property = gdict_strategy_chooser_set_property;
+ gobject_class->get_property = gdict_strategy_chooser_get_property;
+ gobject_class->constructor = gdict_strategy_chooser_constructor;
+ 
+ /**
+ * GdictStrategyChooser:context:
+ *
+ * The #GdictContext object used to retrieve the list of strategies.
+ */
+ g_object_class_install_property (gobject_class,
+ PROP_CONTEXT,
+ g_param_spec_object ("context",
+ "Context",
+ "The GdictContext object used to get the list of strategies",
+ GDICT_TYPE_CONTEXT,
+ (G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT)));
+
+ /**
+ * GdictStrategyChooser::strategy-activated:
+ * @chooser: the widget that received the signal
+ * @name: the name of the activated strategy
+ * @description: the description of the activate strategy
+ *
+ * The ::strategy-activated signal is emitted each time the user
+ * activates a strategy in the @chooser, either by double click or
+ * using the keyboard.
+ */
+ db_chooser_signals[STRATEGY_ACTIVATED] =
+ g_signal_new ("strategy-activated",
+ G_OBJECT_CLASS_TYPE (gobject_class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (GdictStrategyChooserClass, strategy_activated),
+ NULL, NULL,
+ gdict_marshal_VOID__STRING_STRING,
+ G_TYPE_NONE, 2,
+ G_TYPE_STRING,
+ G_TYPE_STRING);
+ 
+ g_type_class_add_private (gobject_class, sizeof (GdictStrategyChooserPrivate));
+}
+
+static void
+gdict_strategy_chooser_init (GdictStrategyChooser *chooser)
+{
+ GdictStrategyChooserPrivate *priv;
+
+ chooser->priv = priv = GDICT_STRATEGY_CHOOSER_GET_PRIVATE (chooser);
+
+ priv->results = -1;
+ priv->context = NULL;
+
+ priv->store = gtk_list_store_new (STRAT_N_COLUMNS,
+ G_TYPE_INT, /* strat_type */
+ G_TYPE_STRING, /* strat_name */
+ G_TYPE_STRING, /* strat_desc */
+ G_TYPE_INT /* strat_current */);
+
+ priv->start_id = 0;
+ priv->end_id = 0;
+ priv->match_id = 0;
+ priv->error_id = 0;
+}
+
+/**
+ * gdict_strategy_chooser_new:
+ *
+ * Creates a new #GdictStrategyChooser. Use this widget to show a list
+ * of matching strategies available on a dictionary source represented
+ * by a #GdictContext, set with gdict_strategy_chooser_set_context().
+ *
+ * Return value: the newly created #GdictStrategyChooser widget
+ *
+ * Since: 0.9
+ */
+GtkWidget *
+gdict_strategy_chooser_new (void)
+{
+ return g_object_new (GDICT_TYPE_STRATEGY_CHOOSER, NULL);
+}
+
+/**
+ * gdict_strategy_chooser_new_with_context:
+ * @context: a #GdictContext
+ *
+ * Creates a new #GdictStrategyChooser widget, using @context as the
+ * representation of a dictionary source.
+ *
+ * Return value: the newly created #GdictStrategyChooser widget
+ *
+ * Since: 0.9
+ */
+GtkWidget *
+gdict_strategy_chooser_new_with_context (GdictContext *context)
+{
+ g_return_val_if_fail (GDICT_IS_CONTEXT (context), NULL);
+ 
+ return g_object_new (GDICT_TYPE_STRATEGY_CHOOSER,
+ "context", context,
+ NULL);
+}
+
+/**
+ * gdict_strategy_chooser_get_context:
+ * @chooser: a #GdictStrategyChooser
+ *
+ * Retrieves the #GdictContext used by @chooser.
+ *
+ * Return value: a #GdictContext
+ *
+ * Since:
+ */
+GdictContext *
+gdict_strategy_chooser_get_context (GdictStrategyChooser *chooser)
+{
+ g_return_val_if_fail (GDICT_IS_STRATEGY_CHOOSER (chooser), NULL);
+ 
+ return chooser->priv->context;
+}
+
+/**
+ * gdict_strategy_chooser_set_context:
+ * @chooser: a #GdictStrategyChooser
+ * @context: a #GdictContext, or %NULL to unset the context
+ *
+ * Sets the #GdictContext to be used by @chooser to retrieve the
+ * list of matching strategies.
+ *
+ * Since: 0.9
+ */
+void
+gdict_strategy_chooser_set_context (GdictStrategyChooser *chooser,
+ GdictContext *context)
+{
+ g_return_if_fail (GDICT_IS_STRATEGY_CHOOSER (chooser));
+ g_return_if_fail (context == NULL || GDICT_IS_CONTEXT (context));
+
+ set_gdict_context (chooser, context);
+
+ g_object_notify (G_OBJECT (chooser), "context");
+}
+
+/**
+ * gdict_strategy_chooser_get_strategies:
+ * @chooser: a #GdictStrategyChooser
+ * @length: return location for the length of the returned string list
+ *
+ * Retrieves the list of matching strategies available.
+ *
+ * Return value: a string vector containing the names of the matching
+ * strategies. Use g_strfreev() to deallocate the memory when done
+ *
+ * Since:0.9
+ */
+gchar **
+gdict_strategy_chooser_get_strategies (GdictStrategyChooser *chooser,
+ gsize *length)
+{
+ GdictStrategyChooserPrivate *priv;
+ GtkTreeIter iter;
+ gchar **retval;
+ gsize i;
+
+ g_return_val_if_fail (GDICT_IS_STRATEGY_CHOOSER (chooser), NULL);
+
+ priv = chooser->priv;
+
+ if (!gtk_tree_model_get_iter_first (GTK_TREE_MODEL (priv->store), &iter))
+ return NULL;
+
+ i = 0;
+ retval = g_new (gchar*, priv->results);
+
+ do
+ {
+ gchar *strat_name;
+
+ gtk_tree_model_get (GTK_TREE_MODEL (priv->store), &iter,
+ STRAT_COLUMN_NAME, &strat_name,
+ -1);
+
+ retval[i++] = strat_name;
+ }
+ while (gtk_tree_model_iter_next (GTK_TREE_MODEL (priv->store), &iter));
+
+ retval[i] = NULL;
+
+ if (length)
+ *length = i;
+
+ return retval;
+}
+
+/**
+ * gdict_strategy_chooser_has_strategy:
+ * @chooser: a #GdictStrategyChooser
+ * @strategy: a strategy name
+ *
+ * Checks whether @strategy is available in the list of matching
+ * strategies displayed by @chooser.
+ *
+ * Return value: %TRUE if the strategy was found, %FALSE otherwise
+ *
+ * Since: 0.9
+ */
+gboolean
+gdict_strategy_chooser_has_strategy (GdictStrategyChooser *chooser,
+ const gchar *strategy)
+{
+ GdictStrategyChooserPrivate *priv;
+ GtkTreeIter iter;
+ gboolean retval;
+
+ g_return_val_if_fail (GDICT_IS_STRATEGY_CHOOSER (chooser), FALSE);
+ g_return_val_if_fail (strategy != NULL, FALSE);
+
+ priv = chooser->priv;
+
+ if (!gtk_tree_model_get_iter_first (GTK_TREE_MODEL (priv->store), &iter))
+ return FALSE;
+
+ retval = FALSE;
+
+ do
+ {
+ gchar *strat_name;
+
+ gtk_tree_model_get (GTK_TREE_MODEL (priv->store), &iter,
+ STRAT_COLUMN_NAME, &strat_name,
+ -1);
+ 
+ if (strcmp (strat_name, strategy) == 0)
+ {
+ retval = TRUE;
+ g_free (strat_name);
+ break;
+ }
+
+ g_free (strat_name);
+ }
+ while (gtk_tree_model_iter_next (GTK_TREE_MODEL (priv->store), &iter));
+
+ return retval;
+}
+
+/**
+ * gdict_strategy_chooser_count_strategies:
+ * @chooser: a #GdictStrategyChooser
+ *
+ * Returns the number of strategies found.
+ *
+ * Return value: the number of strategies or -1 if case of error
+ *
+ * Since:
+ */
+gint
+gdict_strategy_chooser_count_strategies (GdictStrategyChooser *chooser)
+{
+ g_return_val_if_fail (GDICT_IS_STRATEGY_CHOOSER (chooser), -1);
+
+ return chooser->priv->results;
+}
+
+static void
+lookup_start_cb (GdictContext *context,
+ gpointer user_data)
+{
+ GdictStrategyChooser *chooser = GDICT_STRATEGY_CHOOSER (user_data);
+ GdictStrategyChooserPrivate *priv = chooser->priv;
+
+ if (!priv->busy_cursor)
+ priv->busy_cursor = gdk_cursor_new (GDK_WATCH);
+
+ if (gtk_widget_get_window (GTK_WIDGET (chooser)))
+ gdk_window_set_cursor (gtk_widget_get_window (GTK_WIDGET (chooser)), priv->busy_cursor);
+
+ priv->is_searching = TRUE;
+}
+
+static void
+lookup_end_cb (GdictContext *context,
+ gpointer user_data)
+{
+ GdictStrategyChooser *chooser = GDICT_STRATEGY_CHOOSER (user_data);
+ GdictStrategyChooserPrivate *priv = chooser->priv;
+
+ if (gtk_widget_get_window (GTK_WIDGET (chooser)))
+ gdk_window_set_cursor (gtk_widget_get_window (GTK_WIDGET (chooser)), NULL);
+
+ priv->is_searching = FALSE;
+}
+
+static void
+strategy_found_cb (GdictContext *context,
+ GdictStrategy *strategy,
+ gpointer user_data)
+{
+ GdictStrategyChooser *chooser = GDICT_STRATEGY_CHOOSER (user_data);
+ GdictStrategyChooserPrivate *priv = chooser->priv;
+ const gchar *name, *description;
+ GtkTreeIter iter;
+ gint weight = PANGO_WEIGHT_NORMAL;
+
+ name = gdict_strategy_get_name (strategy);
+ description = gdict_strategy_get_description (strategy);
+
+ GDICT_NOTE (CHOOSER, "STRATEGY: `%s' (`%s')",
+ name,
+ description);
+
+ if (priv->current_strat && !strcmp (priv->current_strat, name))
+ weight = PANGO_WEIGHT_BOLD;
+
+ gtk_list_store_append (priv->store, &iter);
+ gtk_list_store_set (priv->store, &iter,
+ STRAT_COLUMN_TYPE, STRATEGY_NAME,
+ STRAT_COLUMN_NAME, name,
+ STRAT_COLUMN_DESCRIPTION, description,
+ STRAT_COLUMN_CURRENT, weight,
+ -1);
+
+ priv->results += 1;
+}
+
+static void
+error_cb (GdictContext *context,
+ const GError *error,
+ gpointer user_data)
+{
+ GdictStrategyChooser *chooser = GDICT_STRATEGY_CHOOSER (user_data);
+
+ if (gtk_widget_get_window (GTK_WIDGET (chooser)))
+ gdk_window_set_cursor (gtk_widget_get_window (GTK_WIDGET (chooser)), NULL);
+
+ chooser->priv->is_searching = FALSE;
+ chooser->priv->results = 0;
+}
+
+/**
+ * gdict_strategy_chooser_refresh:
+ * @chooser: a #GdictStrategyChooser
+ *
+ * Reloads the list of available strategies.
+ *
+ * Since: 0.10
+ */
+void
+gdict_strategy_chooser_refresh (GdictStrategyChooser *chooser)
+{
+ GdictStrategyChooserPrivate *priv;
+ GError *db_error;
+ 
+ g_return_if_fail (GDICT_IS_STRATEGY_CHOOSER (chooser));
+
+ priv = chooser->priv;
+
+ if (!priv->context)
+ {
+ g_warning ("Attempting to retrieve the available strategies, but "
+ "no GdictContext has been set. Use gdict_strategy_chooser_set_context() "
+ "before invoking gdict_strategy_chooser_refresh().");
+ return;
+ }
+
+ if (priv->is_searching)
+ return;
+
+ gdict_strategy_chooser_clear (chooser);
+
+ if (!priv->start_id)
+ {
+ priv->start_id = g_signal_connect (priv->context, "lookup-start",
+ G_CALLBACK (lookup_start_cb),
+ chooser);
+ priv->match_id = g_signal_connect (priv->context, "strategy-found",
+ G_CALLBACK (strategy_found_cb),
+ chooser);
+ priv->end_id = g_signal_connect (priv->context, "lookup-end",
+ G_CALLBACK (lookup_end_cb),
+ chooser);
+ }
+
+ if (!priv->error_id)
+ priv->error_id = g_signal_connect (priv->context, "error",
+ G_CALLBACK (error_cb),
+ chooser);
+
+ db_error = NULL;
+ gdict_context_lookup_strategies (priv->context, &db_error);
+ if (db_error)
+ {
+ GtkTreeIter iter;
+
+ gtk_list_store_append (priv->store, &iter);
+ gtk_list_store_set (priv->store, &iter,
+ STRAT_COLUMN_TYPE, STRATEGY_ERROR,
+ STRAT_COLUMN_NAME, _("Error while matching"),
+ STRAT_COLUMN_DESCRIPTION, NULL,
+ -1);
+
+ g_warning ("Error while retrieving strategies: %s",
+ db_error->message);
+
+ g_error_free (db_error);
+ }
+}
+
+/**
+ * gdict_strategy_chooser_clear:
+ * @chooser: a #GdictStrategyChooser
+ *
+ * Clears @chooser.
+ *
+ * Since: 0.10
+ */
+void
+gdict_strategy_chooser_clear (GdictStrategyChooser *chooser)
+{
+ GdictStrategyChooserPrivate *priv;
+
+ g_return_if_fail (GDICT_IS_STRATEGY_CHOOSER (chooser));
+
+ priv = chooser->priv;
+
+ gtk_tree_view_set_model (GTK_TREE_VIEW (priv->treeview), NULL);
+
+ gtk_list_store_clear (priv->store);
+ priv->results = 0;
+
+ gtk_tree_view_set_model (GTK_TREE_VIEW (priv->treeview),
+ GTK_TREE_MODEL (priv->store));
+}
+
+typedef struct
+{
+ gchar *strat_name;
+ GdictStrategyChooser *chooser;
+ 
+ guint found : 1;
+ guint do_select : 1;
+ guint do_activate : 1;
+} SelectData;
+
+static gboolean
+scan_for_strat_name (GtkTreeModel *model,
+ GtkTreePath *path,
+ GtkTreeIter *iter,
+ gpointer user_data)
+{
+ SelectData *select_data = user_data;
+ gchar *strat_name = NULL;
+
+ if (!select_data)
+ return TRUE;
+
+ gtk_tree_model_get (model, iter, STRAT_COLUMN_NAME, &strat_name, -1);
+ if (!strat_name)
+ return FALSE;
+
+ if (strcmp (strat_name, select_data->strat_name) == 0)
+ {
+ GtkTreeView *tree_view;
+ GtkTreeSelection *selection;
+
+ select_data->found = TRUE;
+
+ tree_view = GTK_TREE_VIEW (select_data->chooser->priv->treeview);
+ if (select_data->do_activate)
+ {
+ GtkTreeViewColumn *column;
+
+ gtk_list_store_set (GTK_LIST_STORE (model), iter,
+ STRAT_COLUMN_CURRENT, PANGO_WEIGHT_BOLD,
+ -1);
+
+ column = gtk_tree_view_get_column (tree_view, 2);
+ gtk_tree_view_row_activated (tree_view, path, column);
+ }
+
+ selection = gtk_tree_view_get_selection (tree_view);
+ if (select_data->do_select)
+ gtk_tree_selection_select_path (selection, path);
+ else
+ gtk_tree_selection_unselect_path (selection, path);
+ }
+ else
+ {
+ gtk_list_store_set (GTK_LIST_STORE (model), iter,
+ STRAT_COLUMN_CURRENT, PANGO_WEIGHT_NORMAL,
+ -1);
+ }
+
+ g_free (strat_name);
+
+ return FALSE;
+}
+
+/**
+ * gdict_strategy_chooser_select_strategy:
+ * @chooser: a #GdictStrategyChooser
+ * @strat_name: the name of the strategy to select
+ *
+ * Selects @strat_name, if available.
+ *
+ * Return value: %TRUE if the matching strategy was found and selected
+ *
+ * Since: 0.10
+ */
+gboolean
+gdict_strategy_chooser_select_strategy (GdictStrategyChooser *chooser,
+ const gchar *strat_name)
+{
+ GdictStrategyChooserPrivate *priv;
+ SelectData data;
+ gboolean retval;
+
+ g_return_val_if_fail (GDICT_IS_STRATEGY_CHOOSER (chooser), FALSE);
+ g_return_val_if_fail (strat_name != NULL, FALSE);
+
+ priv = chooser->priv;
+
+ data.strat_name = g_strdup (strat_name);
+ data.chooser = chooser;
+ data.found = FALSE;
+ data.do_select = TRUE;
+ data.do_activate = FALSE;
+
+ gtk_tree_model_foreach (GTK_TREE_MODEL (priv->store),
+ scan_for_strat_name,
+ &data);
+
+ retval = data.found;
+
+ g_free (data.strat_name);
+
+ return retval;
+}
+
+/**
+ * gdict_strategy_chooser_unselect_strategy:
+ * @chooser: a #GdictStrategyChooser
+ * @strat_name: the name of the strategy to unselect
+ *
+ * Unselects @strat_name from the list.
+ *
+ * Return value: %TRUE if the matching strategy was found and successfully
+ * unselected
+ *
+ * Since: 0.10
+ */
+gboolean
+gdict_strategy_chooser_unselect_strategy (GdictStrategyChooser *chooser,
+ const gchar *strat_name)
+{
+ GdictStrategyChooserPrivate *priv;
+ SelectData data;
+ gboolean retval;
+
+ g_return_val_if_fail (GDICT_IS_STRATEGY_CHOOSER (chooser), FALSE);
+ g_return_val_if_fail (strat_name != NULL, FALSE);
+
+ priv = chooser->priv;
+
+ data.strat_name = g_strdup (strat_name);
+ data.chooser = chooser;
+ data.found = FALSE;
+ data.do_select = FALSE;
+ data.do_activate = FALSE;
+
+ gtk_tree_model_foreach (GTK_TREE_MODEL (priv->store),
+ scan_for_strat_name,
+ &data);
+
+ retval = data.found;
+
+ g_free (data.strat_name);
+
+ return retval;
+}
+
+/**
+ * gdict_strategy_chooser_set_current_strategy:
+ * @chooser: a #GdictStrategyChooser
+ * @strat_name: the name of the matching strategy
+ *
+ * Sets @strat_name as the current matching strategy.
+ *
+ * Return value: %TRUE if the matching strategy was found
+ *
+ * Since: 0.10
+ */
+gboolean
+gdict_strategy_chooser_set_current_strategy (GdictStrategyChooser *chooser,
+ const gchar *strat_name)
+{
+ GdictStrategyChooserPrivate *priv;
+ SelectData data;
+ gboolean retval;
+
+ g_return_val_if_fail (GDICT_IS_STRATEGY_CHOOSER (chooser), FALSE);
+ g_return_val_if_fail (strat_name != NULL, FALSE);
+
+ priv = chooser->priv;
+
+ if (priv->current_strat && !strcmp (priv->current_strat, strat_name))
+ return TRUE;
+
+ data.strat_name = g_strdup (strat_name);
+ data.chooser = chooser;
+ data.found = FALSE;
+ data.do_select = TRUE;
+ data.do_activate = TRUE;
+
+ gtk_tree_model_foreach (GTK_TREE_MODEL (priv->store),
+ scan_for_strat_name,
+ &data);
+
+ retval = data.found;
+
+ if (data.found)
+ {
+ g_free (priv->current_strat);
+ priv->current_strat = data.strat_name;
+ }
+ else
+ g_free (data.strat_name);
+
+ return retval;
+}
+
+/**
+ * gdict_strategy_chooser_get_current_strategy:
+ * @chooser: a #GdictStrategyChooser
+ *
+ * Retrieves the current matching strategy.
+ *
+ * Return value: a newly allocated string containing the name of
+ * the current matching strategy
+ *
+ * Since: 0.10
+ */
+gchar *
+gdict_strategy_chooser_get_current_strategy (GdictStrategyChooser *chooser)
+{
+ GdictStrategyChooserPrivate *priv;
+ GtkTreeSelection *selection;
+ GtkTreeModel *model;
+ GtkTreeIter iter;
+ gchar *retval = NULL;
+
+ g_return_val_if_fail (GDICT_IS_STRATEGY_CHOOSER (chooser), NULL);
+ 
+ priv = chooser->priv;
+
+ selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->treeview));
+ if (!gtk_tree_selection_get_selected (selection, &model, &iter))
+ return NULL;
+
+ gtk_tree_model_get (model, &iter, STRAT_COLUMN_NAME, &retval, -1);
+ 
+ g_free (priv->current_strat);
+ priv->current_strat = g_strdup (retval);
+
+ return retval;
+}
+
+/**
+ * gdict_strategy_chooser_add_button:
+ * @chooser: a #GdictStrategyChooser
+ * @button_text: text of the button (can be a stock id)
+ *
+ * Creates a new button and packs it into the #GdictStrategyChooser
+ * "action area".
+ *
+ * Return value: the packed #GtkButton
+ *
+ * Since: 0.10
+ */
+GtkWidget *
+gdict_strategy_chooser_add_button (GdictStrategyChooser *chooser,
+ const gchar *button_text)
+{
+ GdictStrategyChooserPrivate *priv;
+ GtkWidget *button;
+
+ g_return_val_if_fail (GDICT_IS_STRATEGY_CHOOSER (chooser), NULL);
+ g_return_val_if_fail (button_text != NULL, NULL);
+
+ priv = chooser->priv;
+
+ button = gtk_button_new_from_stock (button_text);
+
+ gtk_widget_set_can_default (button, TRUE);
+
+ gtk_widget_show (button);
+
+ gtk_box_pack_end (GTK_BOX (priv->buttons_box), button, FALSE, TRUE, 0);
+
+ return button;
+}
diff --git a/mate-dictionary/libgdict/gdict-strategy-chooser.h b/mate-dictionary/libgdict/gdict-strategy-chooser.h
new file mode 100644
index 00000000..efcf8e89
--- /dev/null
+++ b/mate-dictionary/libgdict/gdict-strategy-chooser.h
@@ -0,0 +1,94 @@
+/* gdict-strategy-chooser.h - display widget for strategy names
+ *
+ * Copyright (C) 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 library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ */
+
+#ifndef __GDICT_STRATEGY_CHOOSER_H__
+#define __GDICT_STRATEGY_CHOOSER_H__
+
+#include <gtk/gtk.h>
+#include "gdict-context.h"
+
+G_BEGIN_DECLS
+
+#define GDICT_TYPE_STRATEGY_CHOOSER (gdict_strategy_chooser_get_type ())
+#define GDICT_STRATEGY_CHOOSER(obj) \
+(G_TYPE_CHECK_INSTANCE_CAST ((obj), GDICT_TYPE_STRATEGY_CHOOSER, GdictStrategyChooser))
+#define GDICT_IS_STRATEGY_CHOOSER(obj) \
+(G_TYPE_CHECK_INSTANCE_TYPE ((obj), GDICT_TYPE_STRATEGY_CHOOSER))
+#define GDICT_STRATEGY_CHOOSER_CLASS(klass) \
+(G_TYPE_CHECK_CLASS_CAST ((klass), GDICT_TYPE_STRATEGY_CHOOSER, GdictStrategyChooserClass))
+#define GDICT_IS_STRATEGY_CHOOSER_CLASS(klass) \
+(G_TYPE_CHECK_CLASS_TYPE ((klass), GDICT_TYPE_STRATEGY_CHOOSER))
+#define GDICT_STRATEGY_CHOOSER_GET_CLASS(obj) \
+(G_TYPE_INSTANCE_GET_CLASS ((obj), GDICT_TYPE_STRATEGY_CHOOSER, GdictStrategyChooserClass))
+
+typedef struct _GdictStrategyChooser GdictStrategyChooser;
+typedef struct _GdictStrategyChooserPrivate GdictStrategyChooserPrivate;
+typedef struct _GdictStrategyChooserClass GdictStrategyChooserClass;
+
+struct _GdictStrategyChooser
+{
+ GtkVBox parent_instance;
+ 
+ GdictStrategyChooserPrivate *priv;
+};
+
+struct _GdictStrategyChooserClass
+{
+ GtkVBoxClass parent_class;
+
+ void (*strategy_activated) (GdictStrategyChooser *chooser,
+ const gchar *name,
+ const gchar *description);
+ 
+ void (*_gdict_padding1) (void);
+ void (*_gdict_padding2) (void);
+ void (*_gdict_padding3) (void);
+ void (*_gdict_padding4) (void);
+ void (*_gdict_padding5) (void);
+ void (*_gdict_padding6) (void);
+};
+
+GType gdict_strategy_chooser_get_type (void) G_GNUC_CONST;
+
+GtkWidget * gdict_strategy_chooser_new (void);
+GtkWidget * gdict_strategy_chooser_new_with_context (GdictContext *context);
+
+GdictContext *gdict_strategy_chooser_get_context (GdictStrategyChooser *chooser);
+void gdict_strategy_chooser_set_context (GdictStrategyChooser *chooser,
+ GdictContext *context);
+gboolean gdict_strategy_chooser_select_strategy (GdictStrategyChooser *chooser,
+ const gchar *strat_name);
+gboolean gdict_strategy_chooser_unselect_strategy (GdictStrategyChooser *chooser,
+ const gchar *strat_name);
+gboolean gdict_strategy_chooser_set_current_strategy (GdictStrategyChooser *chooser,
+ const gchar *strat_name);
+gchar * gdict_strategy_chooser_get_current_strategy (GdictStrategyChooser *chooser) G_GNUC_MALLOC;
+gchar ** gdict_strategy_chooser_get_strategies (GdictStrategyChooser *chooser,
+ gsize *length) G_GNUC_MALLOC;
+gint gdict_strategy_chooser_count_strategies (GdictStrategyChooser *chooser);
+gboolean gdict_strategy_chooser_has_strategy (GdictStrategyChooser *chooser,
+ const gchar *strategy);
+void gdict_strategy_chooser_refresh (GdictStrategyChooser *chooser);
+void gdict_strategy_chooser_clear (GdictStrategyChooser *chooser);
+GtkWidget * gdict_strategy_chooser_add_button (GdictStrategyChooser *chooser,
+ const gchar *button_text);
+
+G_END_DECLS
+
+#endif /* __GDICT_STRATEGY_CHOOSER_H__ */
diff --git a/mate-dictionary/libgdict/gdict-utils.c b/mate-dictionary/libgdict/gdict-utils.c
new file mode 100644
index 00000000..cdace3d3
--- /dev/null
+++ b/mate-dictionary/libgdict/gdict-utils.c
@@ -0,0 +1,333 @@
+/* gdict-utils.c - Utility functions for Gdict
+ *
+ * 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 library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <netdb.h>
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+
+#include <glib.h>
+#include <glib/gi18n-lib.h>
+#include <gtk/gtk.h>
+
+#include "gdict-context-private.h"
+#include "gdict-debug.h"
+#include "gdict-utils.h"
+#include "gdict-version.h"
+#include "gdict-private.h"
+
+guint gdict_major_version = GDICT_MAJOR_VERSION;
+guint gdict_minor_version = GDICT_MINOR_VERSION;
+guint gdict_micro_version = GDICT_MICRO_VERSION;
+
+guint gdict_debug_flags = 0; /* global gdict debug flag */
+
+#ifdef GDICT_ENABLE_DEBUG
+static const GDebugKey gdict_debug_keys[] = {
+ { "misc", GDICT_DEBUG_MISC },
+ { "context", GDICT_DEBUG_CONTEXT },
+ { "dict", GDICT_DEBUG_DICT },
+ { "source", GDICT_DEBUG_SOURCE },
+ { "loader", GDICT_DEBUG_LOADER },
+ { "chooser", GDICT_DEBUG_CHOOSER },
+ { "defbux", GDICT_DEBUG_DEFBOX },
+ { "speller", GDICT_DEBUG_SPELLER },
+};
+#endif /* GDICT_ENABLE_DEBUG */
+
+static gboolean gdict_is_initialized = FALSE;
+
+#ifdef GDICT_ENABLE_DEBUG
+static gboolean
+gdict_arg_debug_cb (const char *key,
+ const char *value,
+ gpointer user_data)
+{
+ gdict_debug_flags |=
+ g_parse_debug_string (value,
+ gdict_debug_keys,
+ G_N_ELEMENTS (gdict_debug_keys));
+ return TRUE;
+}
+
+static gboolean
+gdict_arg_no_debug_cb (const char *key,
+ const char *value,
+ gpointer user_data)
+{
+ gdict_debug_flags &=
+ ~g_parse_debug_string (value,
+ gdict_debug_keys,
+ G_N_ELEMENTS (gdict_debug_keys));
+ return TRUE;
+}
+#endif /* CLUTTER_ENABLE_DEBUG */
+
+static GOptionEntry gdict_args[] = {
+#ifdef GDICT_ENABLE_DEBUG
+ { "gdict-debug", 0, 0, G_OPTION_ARG_CALLBACK, gdict_arg_debug_cb,
+ N_("GDict debugging flags to set"), N_("FLAGS") },
+ { "gdict-no-debug", 0, 0, G_OPTION_ARG_CALLBACK, gdict_arg_no_debug_cb,
+ N_("GDict debugging flags to unset"), N_("FLAGS") },
+#endif /* GDICT_ENABLE_DEBUG */
+ { NULL, },
+};
+
+static gboolean
+pre_parse_hook (GOptionContext *context,
+ GOptionGroup *group,
+ gpointer data,
+ GError **error)
+{
+ const char *env_string;
+
+ if (gdict_is_initialized)
+ return TRUE;
+
+#ifdef GDICT_ENABLE_DEBUG
+ env_string = g_getenv ("GDICT_DEBUG");
+ if (env_string != NULL)
+ {
+ gdict_debug_flags =
+ g_parse_debug_string (env_string,
+ gdict_debug_keys,
+ G_N_ELEMENTS (gdict_debug_keys));
+ }
+#else
+ env_string = NULL;
+#endif /* GDICT_ENABLE_DEBUG */
+
+ return TRUE;
+}
+
+static gboolean
+post_parse_hook (GOptionContext *context,
+ GOptionGroup *group,
+ gpointer data,
+ GError **error)
+{
+ gdict_is_initialized = TRUE;
+
+ return TRUE;
+}
+
+/**
+ * gdict_get_option_group:
+ *
+ * FIXME
+ *
+ * Return value: FIXME
+ *
+ * Since: 0.12
+ */
+GOptionGroup *
+gdict_get_option_group (void)
+{
+ GOptionGroup *group;
+
+ group = g_option_group_new ("gdict",
+ _("GDict Options"),
+ _("Show GDict Options"),
+ NULL,
+ NULL);
+ 
+ g_option_group_set_parse_hooks (group, pre_parse_hook, post_parse_hook);
+ g_option_group_add_entries (group, gdict_args);
+ g_option_group_set_translation_domain (group, GETTEXT_PACKAGE);
+
+ return group;
+}
+
+/**
+ * gdict_debug_init:
+ * @argc: FIXME
+ * @argv: FIXME
+ *
+ * FIXME
+ *
+ * Since: 0.12
+ */
+void
+gdict_debug_init (gint *argc,
+ gchar ***argv)
+{
+ GOptionContext *option_context;
+ GOptionGroup *gdict_group;
+ GError *error = NULL;
+
+ if (gdict_is_initialized)
+ return;
+
+ option_context = g_option_context_new (NULL);
+ g_option_context_set_ignore_unknown_options (option_context, TRUE);
+ g_option_context_set_help_enabled (option_context, FALSE); 
+
+ gdict_group = gdict_get_option_group ();
+ g_option_context_set_main_group (option_context, gdict_group);
+
+ if (!g_option_context_parse (option_context, argc, argv, &error))
+ {
+ g_warning ("%s", error->message);
+ g_error_free (error);
+ }
+
+ g_option_context_free (option_context);
+}
+
+gboolean
+gdict_check_version (guint required_major,
+ guint required_minor,
+ guint required_micro)
+{
+ gint gdict_effective_micro = 100 * GDICT_MINOR_VERSION + GDICT_MICRO_VERSION;
+ gint required_effective_micro = 100 * required_minor + required_micro;
+
+ if (required_major > GDICT_MAJOR_VERSION)
+ return FALSE;
+
+ if (required_major < GDICT_MAJOR_VERSION)
+ return FALSE;
+
+ if (required_effective_micro < gdict_effective_micro)
+ return FALSE;
+
+ if (required_effective_micro > gdict_effective_micro)
+ return FALSE;
+
+ return TRUE;
+}
+/* gdict_has_ipv6: checks for the existence of the IPv6 extensions; if
+ * IPv6 support was not enabled, this function always return false
+ */
+gboolean
+_gdict_has_ipv6 (void)
+{
+#ifdef ENABLE_IPV6
+ int s;
+
+ s = socket (AF_INET6, SOCK_STREAM, 0);
+ if (s != -1)
+ {
+ close(s);
+ 
+ return TRUE;
+ }
+#endif
+
+ return FALSE;
+}
+
+/* shows an error dialog making it transient for @parent */
+static void
+show_error_dialog (GtkWindow *parent,
+ const gchar *message,
+ const gchar *detail)
+{
+ GtkWidget *dialog;
+ 
+ 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);
+}
+
+/* find the toplevel widget for @widget */
+static GtkWindow *
+get_toplevel_window (GtkWidget *widget)
+{
+ GtkWidget *toplevel;
+ 
+ toplevel = gtk_widget_get_toplevel (widget);
+ if (!gtk_widget_is_toplevel (toplevel))
+ return NULL;
+ else
+ return GTK_WINDOW (toplevel);
+}
+
+/**
+ * gdict_show_error_dialog:
+ * @widget: the widget that emits the error
+ * @title: the primary error message
+ * @message: the secondary error message or %NULL
+ *
+ * Creates and shows an error dialog bound to @widget.
+ *
+ * Since: 1.0
+ */
+void
+_gdict_show_error_dialog (GtkWidget *widget,
+ const gchar *title,
+ const gchar *detail)
+{
+ g_return_if_fail (GTK_IS_WIDGET (widget));
+ g_return_if_fail (title != NULL);
+ 
+ show_error_dialog (get_toplevel_window (widget), title, detail);
+}
+
+/**
+ * gdict_show_gerror_dialog:
+ * @widget: the widget that emits the error
+ * @title: the primary error message
+ * @error: a #GError
+ *
+ * Creates and shows an error dialog bound to @widget, using @error
+ * to fill the secondary text of the message dialog with the error
+ * message. Also takes care of freeing @error.
+ *
+ * Since: 1.0
+ */
+void
+_gdict_show_gerror_dialog (GtkWidget *widget,
+ const gchar *title,
+ GError *error)
+{
+ g_return_if_fail (GTK_IS_WIDGET (widget));
+ g_return_if_fail (title != NULL);
+ g_return_if_fail (error != NULL);
+ 
+ show_error_dialog (get_toplevel_window (widget), title, error->message);
+ 
+ g_error_free (error);
+}
diff --git a/mate-dictionary/libgdict/gdict-utils.h b/mate-dictionary/libgdict/gdict-utils.h
new file mode 100644
index 00000000..5f40eb5f
--- /dev/null
+++ b/mate-dictionary/libgdict/gdict-utils.h
@@ -0,0 +1,85 @@
+/* gdict-utils.h - Utility functions for Gdict
+ *
+ * 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 library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ */
+
+#ifndef __GDICT_UTILS_H__
+#define __GDICT_UTILS_H__
+
+#include <glib-object.h>
+#include <gtk/gtk.h>
+
+G_BEGIN_DECLS
+
+#define GDICT_DEFAULT_DATABASE "*"
+#define GDICT_DEFAULT_STRATEGY "."
+
+#define GDICT_DEFAULT_FONT_NAME "Sans 10"
+
+/* properties shared between GdictContext implementations */
+typedef enum {
+ GDICT_CONTEXT_PROP_FIRST = 0x1000,
+ GDICT_CONTEXT_PROP_LOCAL_ONLY = GDICT_CONTEXT_PROP_FIRST,
+ GDICT_CONTEXT_PROP_LAST
+} GdictContextProp;
+
+/* Status codes as defined by RFC 2229 */
+typedef enum {
+ GDICT_STATUS_INVALID = 0,
+ 
+ GDICT_STATUS_N_DATABASES_PRESENT = 110,
+ GDICT_STATUS_N_STRATEGIES_PRESENT = 111,
+ GDICT_STATUS_DATABASE_INFO = 112,
+ GDICT_STATUS_HELP_TEXT = 113,
+ GDICT_STATUS_SERVER_INFO = 114,
+ GDICT_STATUS_CHALLENGE = 130,
+ GDICT_STATUS_N_DEFINITIONS_RETRIEVED = 150,
+ GDICT_STATUS_WORD_DB_NAME = 151,
+ GDICT_STATUS_N_MATCHES_FOUND = 152,
+ GDICT_STATUS_CONNECT = 220,
+ GDICT_STATUS_QUIT = 221,
+ GDICT_STATUS_AUTH_OK = 230,
+ GDICT_STATUS_OK = 250,
+ GDICT_STATUS_SEND_RESPONSE = 330,
+ /* Connect response codes */
+ GDICT_STATUS_SERVER_DOWN = 420,
+ GDICT_STATUS_SHUTDOWN = 421,
+ /* Error codes */
+ GDICT_STATUS_BAD_COMMAND = 500,
+ GDICT_STATUS_BAD_PARAMETERS = 501,
+ GDICT_STATUS_COMMAND_NOT_IMPLEMENTED = 502,
+ GDICT_STATUS_PARAMETER_NOT_IMPLEMENTED = 503,
+ GDICT_STATUS_NO_ACCESS = 530,
+ GDICT_STATUS_USE_SHOW_INFO = 531,
+ GDICT_STATUS_UNKNOWN_MECHANISM = 532,
+ GDICT_STATUS_BAD_DATABASE = 550,
+ GDICT_STATUS_BAD_STRATEGY = 551,
+ GDICT_STATUS_NO_MATCH = 552,
+ GDICT_STATUS_NO_DATABASES_PRESENT = 554,
+ GDICT_STATUS_NO_STRATEGIES_PRESENT = 555
+} GdictStatusCode;
+
+#define GDICT_IS_VALID_STATUS_CODE(x) (((x) > GDICT_STATUS_INVALID) && \
+ ((x) <= GDICT_STATUS_NO_STRATEGIES_PRESENT))
+
+GOptionGroup *gdict_get_option_group (void);
+void gdict_debug_init (gint *argc,
+ gchar ***argv);
+
+G_END_DECLS
+
+#endif /* __GDICT_UTILS_H__ */
diff --git a/mate-dictionary/libgdict/gdict-version.h.in b/mate-dictionary/libgdict/gdict-version.h.in
new file mode 100644
index 00000000..b9491cb9
--- /dev/null
+++ b/mate-dictionary/libgdict/gdict-version.h.in
@@ -0,0 +1,92 @@
+/* gdict-version.h - convenience version header for libgdict
+ *
+ * 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 library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ */
+
+#ifndef __GDICT_VERSION_H__
+#define __GDICT_VERSION_H__
+
+#include <glib.h>
+
+G_BEGIN_DECLS
+
+/**
+ * GDICT_MAJOR_VERSION:
+ *
+ * FIXME
+ */
+#define GDICT_MAJOR_VERSION (@GDICT_MAJOR_VERSION@)
+
+/**
+ * GDICT_MINOR_VERSION:
+ *
+ * FIXME
+ */
+#define GDICT_MINOR_VERSION (@GDICT_MINOR_VERSION@)
+
+/**
+ * GDICT_MICRO_VERSION:
+ *
+ * FIXME
+ */
+#define GDICT_MICRO_VERSION (@GDICT_MICRO_VERSION@)
+
+/**
+ * GDICT_VERSION:
+ *
+ * FIXME
+ *
+ * Since: 0.11
+ */
+#define GDICT_VERSION (@GDICT_VERSION@)
+
+/**
+ * GDICT_VERSION_S:
+ *
+ * FIXME
+ * 
+ * Since: 0.11
+ */
+#define GDICT_VERSION_S "@GDICT_VERSION@"
+
+/**
+ * GDICT_VERSION_HEX:
+ *
+ * FIXME
+ *
+ * Since: 0.11
+ */
+#define GDICT_VERSION_HEX (GDICT_MAJOR_VERSION << 24 | \
+ GDICT_MINOR_VERSION << 16 | \
+ GDICT_MICRO_VERSION << 8)
+
+#define GDICT_CHECK_VERSION(major,minor,micro) \
+ (((major) >= GDICT_MAJOR_VERSION) || \
+ (((major) == GDICT_MAJOR_VERSION) && ((minor) >= GDICT_MINOR_VERSION)) || \
+ (((major) == GDICT_MAJOR_VERSION) && ((minor) == GDICT_MINOR_VERSION) && ((micro) >= GDICT_MICRO_VERSION)))
+
+extern guint gdict_major;
+extern guint gdict_minor;
+extern guint gdict_micro;
+
+gboolean gdict_check_version (guint required_major,
+ guint required_minor,
+ guint required_micro);
+
+G_END_DECLS
+
+#endif /* __GDICT_VERSION_H__ */
diff --git a/mate-dictionary/libgdict/gdict.h b/mate-dictionary/libgdict/gdict.h
new file mode 100644
index 00000000..f5a32af1
--- /dev/null
+++ b/mate-dictionary/libgdict/gdict.h
@@ -0,0 +1,36 @@
+/* gdict.h - convenience header for libgdict
+ *
+ * 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 library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ */
+
+#ifndef __GDICT_H__
+#define __GDICT_H__
+
+#include "gdict-context.h"
+#include "gdict-client-context.h"
+#include "gdict-source.h"
+#include "gdict-source-loader.h"
+#include "gdict-source-chooser.h"
+#include "gdict-database-chooser.h"
+#include "gdict-defbox.h"
+#include "gdict-speller.h"
+#include "gdict-strategy-chooser.h"
+#include "gdict-utils.h"
+#include "gdict-enum-types.h"
+#include "gdict-version.h"
+
+#endif /* __GDICT_H__ */
diff --git a/mate-dictionary/libgdict/mate-dict.pc.in b/mate-dictionary/libgdict/mate-dict.pc.in
new file mode 100644
index 00000000..9eff837e
--- /dev/null
+++ b/mate-dictionary/libgdict/mate-dict.pc.in
@@ -0,0 +1,12 @@
+prefix=@prefix@
+exec_prefix=@exec_prefix@
+libdir=@libdir@
+includedir=@includedir@
+
+Name: gdict-1.0
+Description: MATE Dictionary Protocol client library
+Requires: gtk+-2.0
+Version: @GDICT_VERSION@
+Libs: -L${libdir} -lmate-dict
+Cflags: -I${includedir}/mate-dict
+
author	Stefano Karapetsas <[email protected]>	2011-12-14 10:13:54 +0100
committer	Stefano Karapetsas <[email protected]>	2011-12-14 10:13:54 +0100
commit	ef0467789bfc8406b57ba553e4d59f4d6c3f9be8 (patch)
tree	09d541636a16cb38448fe6183289ebdc3080c1bf /mate-dictionary/libgdict
download	mate-utils-ef0467789bfc8406b57ba553e4d59f4d6c3f9be8.tar.bz2 mate-utils-ef0467789bfc8406b57ba553e4d59f4d6c3f9be8.tar.xz