diff options
Diffstat (limited to 'mate-dictionary/libgdict/gdict-defbox.c')
| -rw-r--r-- | mate-dictionary/libgdict/gdict-defbox.c | 2927 |
1 files changed, 2927 insertions, 0 deletions
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; + } +} |