./gdict-defbox.c

Bug Summary

File:	cafe-dictionary/libgdict/./gdict-defbox.c
Warning:	line 863, column 18 Out of bound memory access (access exceeds upper limit of memory block)
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name gdict-defbox.c -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -fhalf-no-semantic-interposition -mframe-pointer=all -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/rootdir/cafe-dictionary/libgdict -resource-dir /usr/lib/llvm-16/lib/clang/16 -D HAVE_CONFIG_H -I . -I ../.. -D G_LOG_DOMAIN="Gdict" -D DATADIR="/usr/share" -D LIBDIR="/usr/lib" -D SYSCONFDIR="/usr/etc" -D PREFIX="/usr" -D CAFELOCALEDIR="/usr/share/locale" -D GDICTSOURCESDIR="/usr/share/cafe-dict/sources" -D GDICT_ENABLE_INTERNALS -I /usr/include/glib-2.0 -I /usr/lib/x86_64-linux-gnu/glib-2.0/include -I /usr/include/ctk-3.0 -I /usr/include/pango-1.0 -I /usr/include/harfbuzz -I /usr/include/freetype2 -I /usr/include/libpng16 -I /usr/include/libmount -I /usr/include/blkid -I /usr/include/fribidi -I /usr/include/cairo -I /usr/include/pixman-1 -I /usr/include/gdk-pixbuf-2.0 -I /usr/include/x86_64-linux-gnu -I /usr/include/webp -I /usr/include/gio-unix-2.0 -I /usr/include/atk-1.0 -I /usr/include/at-spi2-atk/2.0 -I /usr/include/at-spi-2.0 -I /usr/include/dbus-1.0 -I /usr/lib/x86_64-linux-gnu/dbus-1.0/include -D G_DISABLE_ASSERT -D G_DISABLE_CHECKS -D G_DISABLE_CAST_CHECKS -D PIC -internal-isystem /usr/lib/llvm-16/lib/clang/16/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/13/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -fdebug-compilation-dir=/rootdir/cafe-dictionary/libgdict -ferror-limit 19 -fgnuc-version=4.2.1 -analyzer-checker deadcode.DeadStores -analyzer-checker alpha.deadcode.UnreachableCode -analyzer-checker alpha.core.CastSize -analyzer-checker alpha.core.CastToStruct -analyzer-checker alpha.core.IdenticalExpr -analyzer-checker alpha.core.SizeofPtr -analyzer-checker alpha.security.ArrayBoundV2 -analyzer-checker alpha.security.MallocOverflow -analyzer-checker alpha.security.ReturnPtrRange -analyzer-checker alpha.unix.SimpleStream -analyzer-checker alpha.unix.cstring.BufferOverlap -analyzer-checker alpha.unix.cstring.NotNullTerminated -analyzer-checker alpha.unix.cstring.OutOfBounds -analyzer-checker alpha.core.FixedAddr -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /rootdir/html-report/2024-02-07-165918-94955-1 -x c ./gdict-defbox.c
1/* gdict-defbox.c - display widget for dictionary definitions
*
* Copyright (C) 2005-2006  Emmanuele Bassi <ebassi@gmail.com>
*
* 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., 51 Franklin St, Fifth Floor,
*/

20/**
* 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.
*/

32#ifdef HAVE_CONFIG_H1
33#include "config.h"
34#endif

36#include <stdio.h>
37#include <stdlib.h>
38#include <string.h>
39#include <stdarg.h>

41#include <ctk/ctk.h>
42#include <cdk/cdkkeysyms.h>
43#include <glib/gi18n-lib.h>

45#include "gdict-defbox.h"
46#include "gdict-utils.h"
47#include "gdict-debug.h"
48#include "gdict-private.h"
49#include "gdict-enum-types.h"
50#include "gdict-marshal.h"

52#define QUERY_MARGIN48	48
53#define ERROR_MARGIN24	24

55typedef struct
56{
GdictDefinition *definition;

gint begin;
60} Definition;

62struct _GdictDefboxPrivate
63{
CtkWidget *text_view;

/* the "find" pane */
CtkWidget *find_pane;
CtkWidget *find_entry;
CtkWidget *find_next;
CtkWidget *find_prev;
CtkWidget *find_label;

CtkWidget *progress_dialog;

CtkTextBuffer *buffer;

GdictContext *context;
GSList *definitions;

gchar *word;
gchar *database;
gchar *font_name;

guint show_find : 1;
guint is_searching : 1;
guint is_hovering : 1;

CdkCursor *busy_cursor;
CdkCursor *hand_cursor;
CdkCursor *regular_cursor;

guint start_id;
guint end_id;
guint define_id;
guint error_id;
guint hide_timeout;

CtkTextTag *link_tag;
CtkTextTag *visited_link_tag;
100};

102enum
103{
PROP_0,

PROP_CONTEXT,
PROP_WORD,
PROP_DATABASE,
PROP_FONT_NAME,
PROP_COUNT
111};

113enum
114{
SHOW_FIND,
HIDE_FIND,
FIND_NEXT,
FIND_PREVIOUS,
LINK_CLICKED,

LAST_SIGNAL
122};

124static guint gdict_defbox_signals[LAST_SIGNAL] = { 0 };

126G_DEFINE_TYPE_WITH_PRIVATE (GdictDefbox, gdict_defbox, CTK_TYPE_BOX)static void gdict_defbox_init (GdictDefbox *self); static void
 gdict_defbox_class_init (GdictDefboxClass *klass); static GType
 gdict_defbox_get_type_once (void); static gpointer gdict_defbox_parent_class
 = ((void*)0); static gint GdictDefbox_private_offset; static
 void gdict_defbox_class_intern_init (gpointer klass) { gdict_defbox_parent_class
 = g_type_class_peek_parent (klass); if (GdictDefbox_private_offset
 != 0) g_type_class_adjust_private_offset (klass, &GdictDefbox_private_offset
); gdict_defbox_class_init ((GdictDefboxClass*) klass); } __attribute__
 ((__unused__)) static inline gpointer gdict_defbox_get_instance_private
 (GdictDefbox *self) { return (((gpointer) ((guint8*) (self) +
 (glong) (GdictDefbox_private_offset)))); } GType gdict_defbox_get_type
 (void) { static gsize static_g_define_type_id = 0; if ((__extension__
 ({ _Static_assert (sizeof *(&static_g_define_type_id) ==
 sizeof (gpointer), "Expression evaluates to false"); (void) (
? (gpointer) *(&static_g_define_type_id) : ((void*)0));
 (!(__extension__ ({ _Static_assert (sizeof *(&static_g_define_type_id
) == sizeof (gpointer), "Expression evaluates to false"); __typeof__
 (*(&static_g_define_type_id)) gapg_temp_newval; __typeof__
 ((&static_g_define_type_id)) gapg_temp_atomic = (&static_g_define_type_id
); __atomic_load (gapg_temp_atomic, &gapg_temp_newval, 5)
; gapg_temp_newval; })) && g_once_init_enter (&static_g_define_type_id
)); }))) { GType g_define_type_id = gdict_defbox_get_type_once
 (); (__extension__ ({ _Static_assert (sizeof *(&static_g_define_type_id
) == sizeof (gpointer), "Expression evaluates to false"); 0 ?
 (void) (*(&static_g_define_type_id) = (g_define_type_id)
) : (void) 0; g_once_init_leave ((&static_g_define_type_id
), (gsize) (g_define_type_id)); })); } return static_g_define_type_id
; } __attribute__ ((__noinline__)) static GType gdict_defbox_get_type_once
 (void) { GType g_define_type_id = g_type_register_static_simple
 ((ctk_box_get_type ()), g_intern_static_string ("GdictDefbox"
), sizeof (GdictDefboxClass), (GClassInitFunc)(void (*)(void)
) gdict_defbox_class_intern_init, sizeof (GdictDefbox), (GInstanceInitFunc
)(void (*)(void)) gdict_defbox_init, (GTypeFlags) 0); { {{ GdictDefbox_private_offset
 = g_type_add_instance_private (g_define_type_id, sizeof (GdictDefboxPrivate
)); };} } return g_define_type_id; }

128static Definition *
129definition_new (void)
130{
Definition *def;

def = g_slice_new (Definition)((Definition*) g_slice_alloc (sizeof (Definition)));
def->definition = NULL((void*)0);
def->begin = -1;

return def;
138}

140static void
141definition_free (Definition *def)
142{
if (!def)
  return;

gdict_definition_unref (def->definition);
g_slice_free (Definition, def)do { if (1) g_slice_free1 (sizeof (Definition), (def)); else (
void) ((Definition*) 0 == (def)); } while (0);
148}

150static void
151gdict_defbox_dispose (GObject *gobject)
152{
GdictDefbox *defbox = GDICT_DEFBOX (gobject)((((GdictDefbox*) (void *) ((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((void*)0);
  }

if (priv->buffer)
  {
    g_object_unref (priv->buffer);
    priv->buffer = NULL((void*)0);
  }

if (priv->busy_cursor)
  {
    g_object_unref (priv->busy_cursor);
    priv->busy_cursor = NULL((void*)0);
  }

if (priv->hand_cursor)
  {
    g_object_unref (priv->hand_cursor);
    priv->hand_cursor = NULL((void*)0);
  }

if (priv->regular_cursor)
  {
    g_object_unref (priv->regular_cursor);
    priv->regular_cursor = NULL((void*)0);
  }

G_OBJECT_CLASS (gdict_defbox_parent_class)((((GObjectClass*) (void *) ((gdict_defbox_parent_class)))))->dispose (gobject);
204}

206static void
207gdict_defbox_finalize (GObject *object)
208{
GdictDefbox *defbox = GDICT_DEFBOX (object)((((GdictDefbox*) (void *) ((object)))));
GdictDefboxPrivate *priv = defbox->priv;

g_free (priv->database);
g_free (priv->word);
g_free (priv->font_name);

if (priv->definitions)
  {
    g_slist_free_full (priv->definitions, (GDestroyNotify) definition_free);
    priv->definitions = NULL((void*)0);
  }

G_OBJECT_CLASS (gdict_defbox_parent_class)((((GObjectClass*) (void *) ((gdict_defbox_parent_class)))))->finalize (object);
223}

225static void
226set_gdict_context (GdictDefbox  *defbox,
   GdictContext *context)
228{
GdictDefboxPrivate *priv;

g_assert (GDICT_IS_DEFBOX (defbox))do { (void) 0; } while (0);

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)((((GObject*) (void *) ((priv->context))))));
  }

if (!context)
  return;

if (!GDICT_IS_CONTEXT (context)(((__extension__ ({ GTypeInstance *__inst = (GTypeInstance*) (
(context)); GType __t = ((gdict_context_get_type ())); gboolean
 __r; if (!__inst) __r = (0); else if (__inst->g_class &&
 __inst->g_class->g_type == __t) __r = (!(0)); else __r
 = g_type_check_instance_is_a (__inst, __t); __r; })))))
  {
    g_warning ("Object of type '%s' instead of a GdictContext\n",
    		 g_type_name (G_OBJECT_TYPE (context)(((((GTypeClass*) (((GTypeInstance*) (context))->g_class))
->g_type)))));
    return;
  }

GDICT_NOTE (DEFBOX, "Setting new context");

priv->context = context;
g_object_ref (G_OBJECT (priv->context))((__typeof__ (((((GObject*) (void *) ((priv->context))))))
) (g_object_ref) (((((GObject*) (void *) ((priv->context))
)))));
275}

277static void
278gdict_defbox_set_property (GObject      *object,
	   guint         prop_id,
	   const GValue *value,
	   GParamSpec   *pspec)
282{
GdictDefbox *defbox = GDICT_DEFBOX (object)((((GdictDefbox*) (void *) ((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))g_strdup_inline (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)do { GObject *_glib__object = (GObject*) ((object)); GParamSpec
 *_glib__pspec = (GParamSpec*) ((pspec)); guint _glib__property_id
 = ((prop_id)); g_warning ("%s:%d: invalid %s id %u for \"%s\" of type '%s' in '%s'"
, "./gdict-defbox.c", 302, ("property"), _glib__property_id, _glib__pspec
->name, g_type_name ((((((GTypeClass*) (((GTypeInstance*) (
_glib__pspec))->g_class))->g_type)))), (g_type_name (((
(((GTypeClass*) (((GTypeInstance*) (_glib__object))->g_class
))->g_type)))))); } while (0);
    break;
  }
305}

307static void
308gdict_defbox_get_property (GObject    *object,
	   guint       prop_id,
	   GValue     *value,
	   GParamSpec *pspec)
312{
GdictDefbox *defbox = GDICT_DEFBOX (object)((((GdictDefbox*) (void *) ((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)do { GObject *_glib__object = (GObject*) ((object)); GParamSpec
 *_glib__pspec = (GParamSpec*) ((pspec)); guint _glib__property_id
 = ((prop_id)); g_warning ("%s:%d: invalid %s id %u for \"%s\" of type '%s' in '%s'"
, "./gdict-defbox.c", 331, ("property"), _glib__property_id, _glib__pspec
->name, g_type_name ((((((GTypeClass*) (((GTypeInstance*) (
_glib__pspec))->g_class))->g_type)))), (g_type_name (((
(((GTypeClass*) (((GTypeInstance*) (_glib__object))->g_class
))->g_type)))))); } while (0);
    break;
  }
334}

336/*
* this code has been copied from ctksourceview; it's the implementation
* for case-insensitive search in a CtkTextBuffer. 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.
*/

344#define CTK_TEXT_UNKNOWN_CHAR0xFFFC 0xFFFC

346/* 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. */
350static const gchar *
351pointer_from_offset_skipping_decomp (const gchar *str, gint offset)
352{
gchar *casefold, *normal;
const gchar *p, *q;

p = str;
while (offset > 0)
{
q = g_utf8_next_char (p)(char *)((p) + g_utf8_skip[*(const guchar *)(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;
368}

370static gboolean
371exact_prefix_cmp (const gchar *string,
  const gchar *prefix,
  guint        prefix_len)
374{
GUnicodeType type;

if (strncmp (string, prefix, prefix_len) != 0)
return FALSE(0);
if (string[prefix_len] == '\0')
return TRUE(!(0));

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;
390}

392static const gchar *
393utf8_strcasestr (const gchar *haystack, const gchar *needle)
394{
gsize needle_len;
gsize haystack_len;
const gchar *ret = NULL((void*)0);
gchar *p;
gchar *casefold;
gchar *caseless_haystack;
gint i;

g_return_val_if_fail (haystack != NULL, NULL)do{ (void)0; }while (0);
g_return_val_if_fail (needle != NULL, NULL)do{ (void)0; }while (0);

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((void*)0);
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)(char *)((p) + g_utf8_skip[*(const guchar *)(p)]);
i++;
}

441finally_1:
g_free (caseless_haystack);

return ret;
445}

447static const gchar *
448utf8_strrcasestr (const gchar *haystack, const gchar *needle)
449{
gsize needle_len;
gsize haystack_len;
const gchar *ret = NULL((void*)0);
gchar *p;
gchar *casefold;
gchar *caseless_haystack;
gint i;

g_return_val_if_fail (haystack != NULL, NULL)do{ (void)0; }while (0);
g_return_val_if_fail (needle != NULL, NULL)do{ (void)0; }while (0);

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((void*)0);
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--;
}

496finally_1:
g_free (caseless_haystack);

return ret;
500}

502static gboolean
503utf8_caselessnmatch (const char *s1, const char *s2,
     gssize n1, gssize n2)
505{
gchar *casefold;
gchar *normalized_s1;
gchar *normalized_s2;
gint len_s1;
gint len_s2;
gboolean ret = FALSE(0);

g_return_val_if_fail (s1 != NULL, FALSE)do{ (void)0; }while (0);
g_return_val_if_fail (s2 != NULL, FALSE)do{ (void)0; }while (0);
g_return_val_if_fail (n1 > 0, FALSE)do{ (void)0; }while (0);
g_return_val_if_fail (n2 > 0, FALSE)do{ (void)0; }while (0);

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);

534finally_2:
g_free (normalized_s1);
g_free (normalized_s2);

return ret;
539}

541/* FIXME: total horror */
542static gboolean
543char_is_invisible (const CtkTextIter *iter)
544{
GSList *tags;
gboolean invisible = FALSE(0);
tags = ctk_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((void*)0));
if (invisible_set)
	invisible = this_invisible;
tags = g_slist_delete_link (tags, tags);
}
return invisible;
558}

560static void
561forward_chars_with_skipping (CtkTextIter *iter,
	     gint         count,
	     gboolean     skip_invisible,
	     gboolean     skip_nontext,
	     gboolean     skip_decomp)
566{
gint i;

g_return_if_fail (count >= 0)do{ (void)0; }while (0);

i = count;

while (i > 0)
{
gboolean ignored = FALSE(0);

/* minimal workaround to avoid the infinite loop of bug #168247.
 * It doesn't fix the problemjust the symptom...
 */
if (ctk_text_iter_is_end (iter))
	return;

if (skip_nontext && ctk_text_iter_get_char (iter) == CTK_TEXT_UNKNOWN_CHAR0xFFFC)
	ignored = TRUE(!(0));

/* 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(!(0));

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 (ctk_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);
}

ctk_text_iter_forward_char (iter);

if (!ignored)
	--i;
}
612}

614static gboolean
615lines_match (const CtkTextIter *start,
    const gchar      **lines,
    gboolean           visible_only,
    gboolean           slice,
    CtkTextIter       *match_start,
    CtkTextIter       *match_end)
621{
CtkTextIter next;
gchar *line_text;
const gchar *found;
gint offset;

if (*lines == NULL((void*)0) || **lines == '\0')
{
if (match_start)
	*match_start = *start;
if (match_end)
	*match_end = *start;
return TRUE(!(0));
}

next = *start;
ctk_text_iter_forward_line (&next);

/* No more text in buffer, but *lines is nonempty */
if (ctk_text_iter_equal (start, &next))
return FALSE(0);

if (slice)
{
if (visible_only)
	line_text = ctk_text_iter_get_visible_slice (start, &next);
else
	line_text = ctk_text_iter_get_slice (start, &next);
}
else
{
if (visible_only)
	line_text = ctk_text_iter_get_visible_text (start, &next);
else
	line_text = ctk_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((void*)0);
}

if (found == NULL((void*)0))
{
g_free (line_text);
return FALSE(0);
}

/* 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(0));
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(!(0)));

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((void*)0), match_end);
708}

710static gboolean
711backward_lines_match (const CtkTextIter *start,
      const gchar      **lines,
      gboolean           visible_only,
      gboolean           slice,
      CtkTextIter       *match_start,
      CtkTextIter       *match_end)
717{
CtkTextIter line, next;
gchar *line_text;
const gchar *found;
gint offset;

if (*lines == NULL((void*)0) || **lines == '\0')
{
if (match_start)
	*match_start = *start;
if (match_end)
	*match_end = *start;
return TRUE(!(0));
}

line = next = *start;
if (ctk_text_iter_get_line_offset (&next) == 0)
{
if (!ctk_text_iter_backward_line (&next))
	return FALSE(0);
}
else
ctk_text_iter_set_line_offset (&next, 0);

if (slice)
{
if (visible_only)
	line_text = ctk_text_iter_get_visible_slice (&next, &line);
else
	line_text = ctk_text_iter_get_slice (&next, &line);
}
else
{
if (visible_only)
	line_text = ctk_text_iter_get_visible_text (&next, &line);
else
	line_text = ctk_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((void*)0);
}

if (found == NULL((void*)0))
{
g_free (line_text);
return FALSE(0);
}

/* 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(0));

/* 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(!(0)));

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((void*)0), match_end);
806}

808/* strsplit () that retains the delimiter as part of the string. */
809static gchar **
810breakup_string (const char *string,
const char *delimiter,
gint        max_tokens)
813{
GSList *string_list = NULL((void*)0), *slist;
gchar **str_array, *s, *casefold, *new_string;
guint i, n = 1;

g_return_val_if_fail (string != NULL, NULL)do{ (void)0; }while (0);
13
←
Loop condition is false.  Exiting loop→
g_return_val_if_fail (delimiter != NULL, NULL)do{ (void)0; }while (0);
14
←
Loop condition is false.  Exiting loop→

if (max_tokens14.1
'max_tokens' is < 1
 < 1)
15
←
Taking true branch→
max_tokens = G_MAXINT2147483647;

s = strstr (string, delimiter);
if (s)
16
←
Assuming 's' is null→
17
←
Taking false branch→
{
guint delimiter_len = strlen (delimiter);

do
{
	guint len;

	len = s - string + delimiter_len;
	new_string = g_new (gchar, len + 1)((gchar *) g_malloc_n ((len + 1), sizeof (gchar)));
	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)
18
←
Taking true branch→
{
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)((gchar* *) g_malloc_n ((n), sizeof (gchar*)));

i = n - 1;

str_array[i--] = NULL((void*)0);
for (slist = string_list; slist; slist = slist->next)
19
←
Loop condition is true.  Entering loop body→
20
←
Loop condition is true.  Entering loop body→
str_array[i--] = slist->data;
21
←
Out of bound memory access (access exceeds upper limit of memory block)

g_slist_free (string_list);

return str_array;
868}

870static gboolean
871gdict_defbox_iter_forward_search (const CtkTextIter   *iter,
                                const gchar         *str,
                                CtkTextIter         *match_start,
                                CtkTextIter         *match_end,
                                const CtkTextIter   *limit)
876{
gchar **lines = NULL((void*)0);
CtkTextIter match;
gboolean retval = FALSE(0);
CtkTextIter search;

g_return_val_if_fail (iter != NULL, FALSE)do{ (void)0; }while (0);
9
←
Loop condition is false.  Exiting loop→
g_return_val_if_fail (str != NULL, FALSE)do{ (void)0; }while (0);

if (limit9.1
'limit' is null
 && ctk_text_iter_compare (iter, limit) >= 0)
  return FALSE(0);

if (*str == '\0')
10
←
Assuming the condition is false→
11
←
Taking false branch→
  {
    /* If we can move one char, return the empty string there */
    match = *iter;

    if (ctk_text_iter_forward_char (&match))
      {
        if (limit && ctk_text_iter_equal (&match, limit))
          return FALSE(0);

        if (match_start)
          *match_start = match;

        if (match_end)
          *match_end = match;

        return TRUE(!(0));
      }
    else
      return FALSE(0);
  }

/* locate all lines */
lines = breakup_string (str, "\n", -1);
12
←
Calling 'breakup_string'→

search = *iter;

/* This loop has an inefficient worst-case, where
 * ctk_text_iter_get_text () is called repeatedly on
 * a single line.
 */
do
  {
    CtkTextIter end;
    gboolean res;

    if (limit && ctk_text_iter_compare (&search, limit) >= 0)
      break;

    res = lines_match (&search, (const gchar**)lines,
                       TRUE(!(0)), FALSE(0),
                       &match, &end);
    if (res)
      {
        if (limit == NULL((void*)0) ||
            (limit && ctk_text_iter_compare (&end, limit) <= 0))
          {
            retval = TRUE(!(0));

            if (match_start)
              *match_start = match;

            if (match_end)
              *match_end = end;
          }

        break;
      }
  } while (ctk_text_iter_forward_line (&search));

g_strfreev ((gchar**) lines);

return retval;
951}

953static gboolean
954gdict_defbox_iter_backward_search (const CtkTextIter   *iter,
                                 const gchar         *str,
                                 CtkTextIter         *match_start,
                                 CtkTextIter         *match_end,
                                 const CtkTextIter   *limit)
959{
gchar **lines = NULL((void*)0);
CtkTextIter match;
gboolean retval = FALSE(0);
CtkTextIter search;

g_return_val_if_fail (iter != NULL, FALSE)do{ (void)0; }while (0);
g_return_val_if_fail (str != NULL, FALSE)do{ (void)0; }while (0);

if (limit && ctk_text_iter_compare (iter, limit) <= 0)
  return FALSE(0);

if (*str == '\0')
  {
    /* If we can move one char, return the empty string there */
    match = *iter;

    if (ctk_text_iter_backward_char (&match))
      {
        if (limit && ctk_text_iter_equal (&match, limit))
          return FALSE(0);

        if (match_start)
          *match_start = match;

        if (match_end)
          *match_end = match;

        return TRUE(!(0));
      }
    else
      return FALSE(0);
  }

/* locate all lines */
lines = breakup_string (str, "\n", -1);

search = *iter;

/* This loop has an inefficient worst-case, where
 * ctk_text_iter_get_text () is called repeatedly on
 * a single line.
 */
while (TRUE(!(0)))
  {
    CtkTextIter end;
    gboolean res;

    if (limit && ctk_text_iter_compare (&search, limit) <= 0)
      break;

    res = backward_lines_match (&search, (const gchar**)lines,
                                TRUE(!(0)), FALSE(0),
                                &match, &end);
    if (res)
      {
         if (limit == NULL((void*)0) ||
             (limit && ctk_text_iter_compare (&end, limit) > 0))
           {
             retval = TRUE(!(0));

             if (match_start)
               *match_start = match;

             if (match_end)
               *match_end = end;

           }

         break;
      }

    if (ctk_text_iter_get_line_offset (&search) == 0)
      {
        if (!ctk_text_iter_backward_line (&search))
          break;
      }
    else
      ctk_text_iter_set_line_offset (&search, 0);
  }

g_strfreev ((gchar**) lines);

return retval;
1043}

1045static gboolean
1046gdict_defbox_find_backward (GdictDefbox *defbox,
	    const gchar *text)
1048{
GdictDefboxPrivate *priv = defbox->priv;
CtkTextIter start_iter, end_iter;
CtkTextIter match_start, match_end;
CtkTextIter iter;
CtkTextMark *last_search;
gboolean res;

g_assert (CTK_IS_TEXT_BUFFER (priv->buffer))do { (void) 0; } while (0);

ctk_text_buffer_get_bounds (priv->buffer, &start_iter, &end_iter);

/* if there already has been another result, begin from there */
last_search = ctk_text_buffer_get_mark (priv->buffer, "last-search-prev");
if (last_search)
  ctk_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((void*)0));
if (res)
  {
    ctk_text_view_scroll_to_iter (CTK_TEXT_VIEW (priv->text_view)((((CtkTextView*) (void *) ((priv->text_view))))),
    				    &match_start,
    				    0.0,
    				    TRUE(!(0)),
    				    0.0, 0.0);
    ctk_text_buffer_place_cursor (priv->buffer, &match_end);
    ctk_text_buffer_move_mark (priv->buffer,
    				 ctk_text_buffer_get_mark (priv->buffer, "selection_bound"),
    				 &match_start);
    ctk_text_buffer_create_mark (priv->buffer, "last-search-prev", &match_start, FALSE(0));
    ctk_text_buffer_create_mark (priv->buffer, "last-search-next", &match_end, FALSE(0));

    return TRUE(!(0));
  }

return FALSE(0);
1088}

1090static gboolean
1091hide_find_pane (gpointer user_data)
1092{
GdictDefbox *defbox = user_data;

ctk_widget_hide (defbox->priv->find_pane);
defbox->priv->show_find = FALSE(0);

ctk_widget_grab_focus (defbox->priv->text_view);

defbox->priv->hide_timeout = 0;

return FALSE(0);
1103}

1105static void
1106find_prev_clicked_cb (CtkWidget *widget,
      gpointer   user_data)
1108{
GdictDefbox *defbox = GDICT_DEFBOX (user_data)((((GdictDefbox*) (void *) ((user_data)))));
GdictDefboxPrivate *priv = defbox->priv;
const gchar *text;
gboolean found;

ctk_widget_hide (priv->find_label);

text = ctk_entry_get_text (CTK_ENTRY (priv->find_entry)((((CtkEntry*) (void *) ((priv->find_entry))))));
if (!text)
  return;

found = gdict_defbox_find_backward (defbox, text);
if (!found)
  {
    gchar *str;

    str = g_strconcat ("  <i>", _("Not found")((char *) g_dgettext ("cafe-utils", "Not found")), "</i>", NULL((void*)0));
    ctk_label_set_markup (CTK_LABEL (priv->find_label)((((CtkLabel*) (void *) ((priv->find_label))))), str);
    ctk_widget_show (priv->find_label);

    g_free (str);
  }

if (priv->hide_timeout)
  {
    g_source_remove (priv->hide_timeout);
    priv->hide_timeout = g_timeout_add_seconds (5, hide_find_pane, defbox);
  }
1137}

1139static gboolean
1140gdict_defbox_find_forward (GdictDefbox *defbox,
	   const gchar *text,
	   gboolean     is_typing)
1143{
GdictDefboxPrivate *priv = defbox->priv;
CtkTextIter start_iter, end_iter;
CtkTextIter match_start, match_end;
CtkTextIter iter;
CtkTextMark *last_search;
gboolean res;

g_assert (CTK_IS_TEXT_BUFFER (priv->buffer))do { (void) 0; } while (0);
4
←
Loop condition is false.  Exiting loop→

ctk_text_buffer_get_bounds (priv->buffer, &start_iter, &end_iter);

if (!is_typing4.1
'is_typing' is 1
)
5
←
Taking false branch→
  {
    /* if there already has been another result, begin from there */
    last_search = ctk_text_buffer_get_mark (priv->buffer, "last-search-next");

    if (last_search)
      ctk_text_buffer_get_iter_at_mark (priv->buffer, &iter, last_search);
    else
iter = start_iter;
  }
else
  {
    last_search = ctk_text_buffer_get_mark (priv->buffer, "last-search-prev");

    if (last_search)
6
←
Assuming 'last_search' is null→
7
←
Taking false branch→
ctk_text_buffer_get_iter_at_mark (priv->buffer, &iter, last_search);
    else
iter = start_iter;
  }

res = gdict_defbox_iter_forward_search (&iter, text,
8
←
Calling 'gdict_defbox_iter_forward_search'→
                                        &match_start,
                                        &match_end,
                                        NULL((void*)0));
if (res)
  {
    ctk_text_view_scroll_to_iter (CTK_TEXT_VIEW (priv->text_view)((((CtkTextView*) (void *) ((priv->text_view))))),
    				    &match_start,
    				    0.0,
    				    TRUE(!(0)),
    				    0.0, 0.0);
    ctk_text_buffer_place_cursor (priv->buffer, &match_end);
    ctk_text_buffer_move_mark (priv->buffer,
    				 ctk_text_buffer_get_mark (priv->buffer, "selection_bound"),
    				 &match_start);
    ctk_text_buffer_create_mark (priv->buffer, "last-search-prev", &match_start, FALSE(0));
    ctk_text_buffer_create_mark (priv->buffer, "last-search-next", &match_end, FALSE(0));

    return TRUE(!(0));
  }

return FALSE(0);
1197}

1199static void
1200find_next_clicked_cb (CtkWidget *widget,
      gpointer   user_data)
1202{
GdictDefbox *defbox = GDICT_DEFBOX (user_data)((((GdictDefbox*) (void *) ((user_data)))));
GdictDefboxPrivate *priv = defbox->priv;
const gchar *text;
gboolean found;

ctk_widget_hide (priv->find_label);

text = ctk_entry_get_text (CTK_ENTRY (priv->find_entry)((((CtkEntry*) (void *) ((priv->find_entry))))));
if (!text)
  return;

found = gdict_defbox_find_forward (defbox, text, FALSE(0));
if (!found)
  {
    gchar *str;

    str = g_strconcat ("  <i>", _("Not found")((char *) g_dgettext ("cafe-utils", "Not found")), "</i>", NULL((void*)0));
    ctk_label_set_markup (CTK_LABEL (priv->find_label)((((CtkLabel*) (void *) ((priv->find_label))))), str);
    ctk_widget_show (priv->find_label);

    g_free (str);
  }

if (priv->hide_timeout)
  {
    g_source_remove (priv->hide_timeout);
    priv->hide_timeout = g_timeout_add_seconds (5, hide_find_pane, defbox);
  }
1231}

1233static void
1234find_entry_changed_cb (CtkWidget *widget,
       gpointer   user_data)
1236{
GdictDefbox *defbox = GDICT_DEFBOX (user_data)((((GdictDefbox*) (void *) ((user_data)))));
GdictDefboxPrivate *priv = defbox->priv;
gchar *text;
gboolean found;

ctk_widget_hide (priv->find_label);

text = ctk_editable_get_chars (CTK_EDITABLE (widget)((((CtkEditable*) (void *) ((widget))))), 0, -1);
if (!text)
1
Assuming 'text' is non-null→
2
←
Taking false branch→
  return;

found = gdict_defbox_find_forward (defbox, text, TRUE(!(0)));
3
←
Calling 'gdict_defbox_find_forward'→
if (!found)
  {
    gchar *str;

    str = g_strconcat ("  <i>", _("Not found")((char *) g_dgettext ("cafe-utils", "Not found")), "</i>", NULL((void*)0));
    ctk_label_set_markup (CTK_LABEL (priv->find_label)((((CtkLabel*) (void *) ((priv->find_label))))), str);
    ctk_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_seconds (5, hide_find_pane, defbox);
  }
1267}

1269static void
1270close_button_clicked (CtkButton *button,
                    gpointer   data)
1272{
GdictDefboxPrivate *priv = GDICT_DEFBOX (data)((((GdictDefbox*) (void *) ((data)))))->priv;

if (priv->hide_timeout)
  g_source_remove (priv->hide_timeout);

(void) hide_find_pane (data);
1279}

1281static CtkWidget *
1282create_find_pane (GdictDefbox *defbox)
1283{
GdictDefboxPrivate *priv;
CtkWidget *find_pane;
CtkWidget *label;
CtkWidget *sep;
CtkWidget *hbox1, *hbox2;
CtkWidget *button;

priv = defbox->priv;

find_pane = ctk_box_new (CTK_ORIENTATION_HORIZONTAL, 0);
ctk_container_set_border_width (CTK_CONTAINER (find_pane)((((CtkContainer*) (void *) ((find_pane))))), 0);

hbox1 = ctk_box_new (CTK_ORIENTATION_HORIZONTAL, 6);
ctk_box_pack_start (CTK_BOX (find_pane)((((CtkBox*) (void *) ((find_pane))))), hbox1, TRUE(!(0)), TRUE(!(0)), 0);
ctk_widget_show (hbox1);

button = ctk_button_new ();
ctk_button_set_relief (CTK_BUTTON (button)((((CtkButton*) (void *) ((button))))), CTK_RELIEF_NONE);
ctk_button_set_image (CTK_BUTTON (button)((((CtkButton*) (void *) ((button))))),
                      ctk_image_new_from_icon_name ("window-close",
                                                    CTK_ICON_SIZE_BUTTON));
g_signal_connect (button, "clicked",g_signal_connect_data ((button), ("clicked"), (((GCallback) (
close_button_clicked))), (defbox), ((void*)0), (GConnectFlags
) 0)
                  G_CALLBACK (close_button_clicked), defbox)g_signal_connect_data ((button), ("clicked"), (((GCallback) (
close_button_clicked))), (defbox), ((void*)0), (GConnectFlags
) 0);
ctk_box_pack_start (CTK_BOX (hbox1)((((CtkBox*) (void *) ((hbox1))))), button, FALSE(0), FALSE(0), 0);
ctk_widget_show (button);

hbox2 = ctk_box_new (CTK_ORIENTATION_HORIZONTAL, 12);
ctk_box_pack_start (CTK_BOX (hbox1)((((CtkBox*) (void *) ((hbox1))))), hbox2, TRUE(!(0)), TRUE(!(0)), 0);
ctk_widget_show (hbox2);

label = ctk_label_new_with_mnemonic (_("F_ind:")((char *) g_dgettext ("cafe-utils", "F_ind:")));
ctk_box_pack_start (CTK_BOX (hbox2)((((CtkBox*) (void *) ((hbox2))))), label, FALSE(0), FALSE(0), 0);

priv->find_entry = ctk_entry_new ();
g_signal_connect (priv->find_entry, "changed",g_signal_connect_data ((priv->find_entry), ("changed"), ((
(GCallback) (find_entry_changed_cb))), (defbox), ((void*)0), (
GConnectFlags) 0)
		    G_CALLBACK (find_entry_changed_cb), defbox)g_signal_connect_data ((priv->find_entry), ("changed"), ((
(GCallback) (find_entry_changed_cb))), (defbox), ((void*)0), (
GConnectFlags) 0);
ctk_box_pack_start (CTK_BOX (hbox2)((((CtkBox*) (void *) ((hbox2))))), priv->find_entry, TRUE(!(0)), TRUE(!(0)), 0);
ctk_label_set_mnemonic_widget (CTK_LABEL (label)((((CtkLabel*) (void *) ((label))))), priv->find_entry);

sep = ctk_separator_new (CTK_ORIENTATION_VERTICAL);
ctk_box_pack_start (CTK_BOX (hbox1)((((CtkBox*) (void *) ((hbox1))))), sep, FALSE(0), FALSE(0), 0);
ctk_widget_show (sep);

priv->find_prev = ctk_button_new_with_mnemonic (_("_Previous")((char *) g_dgettext ("cafe-utils", "_Previous")));
ctk_button_set_image (CTK_BUTTON (priv->find_prev)((((CtkButton*) (void *) ((priv->find_prev))))),
                      ctk_image_new_from_icon_name ("go-previous",
                                                    CTK_ICON_SIZE_MENU));
g_signal_connect (priv->find_prev, "clicked",g_signal_connect_data ((priv->find_prev), ("clicked"), (((
GCallback) (find_prev_clicked_cb))), (defbox), ((void*)0), (GConnectFlags
) 0)
		    G_CALLBACK (find_prev_clicked_cb), defbox)g_signal_connect_data ((priv->find_prev), ("clicked"), (((
GCallback) (find_prev_clicked_cb))), (defbox), ((void*)0), (GConnectFlags
) 0);
ctk_box_pack_start (CTK_BOX (hbox1)((((CtkBox*) (void *) ((hbox1))))), priv->find_prev, FALSE(0), FALSE(0), 0);

priv->find_next = ctk_button_new_with_mnemonic (_("_Next")((char *) g_dgettext ("cafe-utils", "_Next")));
ctk_button_set_image (CTK_BUTTON (priv->find_next)((((CtkButton*) (void *) ((priv->find_next))))),
                      ctk_image_new_from_icon_name ("go-next",
                                                    CTK_ICON_SIZE_MENU));
g_signal_connect (priv->find_next, "clicked",g_signal_connect_data ((priv->find_next), ("clicked"), (((
GCallback) (find_next_clicked_cb))), (defbox), ((void*)0), (GConnectFlags
) 0)
		    G_CALLBACK (find_next_clicked_cb), defbox)g_signal_connect_data ((priv->find_next), ("clicked"), (((
GCallback) (find_next_clicked_cb))), (defbox), ((void*)0), (GConnectFlags
) 0);
ctk_box_pack_start (CTK_BOX (hbox1)((((CtkBox*) (void *) ((hbox1))))), priv->find_next, FALSE(0), FALSE(0), 0);

priv->find_label = ctk_label_new (NULL((void*)0));
ctk_label_set_use_markup (CTK_LABEL (priv->find_label)((((CtkLabel*) (void *) ((priv->find_label))))), TRUE(!(0)));
ctk_box_pack_end (CTK_BOX (find_pane)((((CtkBox*) (void *) ((find_pane))))), priv->find_label, FALSE(0), FALSE(0), 0);
ctk_widget_hide (priv->find_label);

return find_pane;
1349}

1351static void
1352gdict_defbox_init_tags (GdictDefbox *defbox)
1353{
GdictDefboxPrivate *priv = defbox->priv;

g_assert (CTK_IS_TEXT_BUFFER (priv->buffer))do { (void) 0; } while (0);

ctk_text_buffer_create_tag (priv->buffer, "italic",
			      "style", PANGO_STYLE_ITALIC,
			      NULL((void*)0));
ctk_text_buffer_create_tag (priv->buffer, "bold",
			      "weight", PANGO_WEIGHT_BOLD,
			      NULL((void*)0));
ctk_text_buffer_create_tag (priv->buffer, "underline",
			      "underline", PANGO_UNDERLINE_SINGLE,
			      NULL((void*)0));

ctk_text_buffer_create_tag (priv->buffer, "big",
			      "scale", 1.6,
			      NULL((void*)0));
ctk_text_buffer_create_tag (priv->buffer, "small",
  	      "scale", PANGO_SCALE_SMALL((double)0.8333333333333),
	      NULL((void*)0));

{
  CtkSettings *settings = ctk_widget_get_settings (CTK_WIDGET (defbox)((((CtkWidget*) (void *) ((defbox))))));
  gboolean prefer_dark = FALSE(0);
  CdkRGBA rgba;

  /* HACK: we're hardcoding the Adwaita values because CtkTextTag
   * cannot be styled via CSS
   */
  g_object_get (settings, "ctk-application-prefer-dark-theme", &prefer_dark, NULL((void*)0));

  if (!prefer_dark)
    cdk_rgba_parse (&rgba, "#2a76c6");
  else
    cdk_rgba_parse (&rgba, "#4a90d9");

  priv->link_tag =
    ctk_text_buffer_create_tag (priv->buffer, "link",
                                "underline", PANGO_UNDERLINE_SINGLE,
                                "foreground-rgba", &rgba,
                                NULL((void*)0));

  if (!prefer_dark)
    cdk_rgba_parse (&rgba, "#215d9c");
  else
    cdk_rgba_parse (&rgba, "#2a76c6");

  priv->visited_link_tag =
    ctk_text_buffer_create_tag (priv->buffer, "visited-link",
                                "underline", PANGO_UNDERLINE_SINGLE,
                                "foreground-rgba", &rgba,
                                NULL((void*)0));
}

ctk_text_buffer_create_tag (priv->buffer, "phonetic",
                            "foreground", "dark gray",
                            NULL((void*)0));

ctk_text_buffer_create_tag (priv->buffer, "query-title",
              "left-margin", QUERY_MARGIN48,
			      "pixels-above-lines", 5,
			      "pixels-below-lines", 20,
	      NULL((void*)0));
ctk_text_buffer_create_tag (priv->buffer, "query-from",
  	      "foreground", "dark gray",
	      "scale", PANGO_SCALE_SMALL((double)0.8333333333333),
  	      "left-margin", QUERY_MARGIN48,
	      "pixels-above-lines", 5,
	      "pixels-below-lines", 10,
	      NULL((void*)0));

ctk_text_buffer_create_tag (priv->buffer, "error-title",
  	      "foreground", "dark red",
	      "left-margin", ERROR_MARGIN24,
	      NULL((void*)0));
ctk_text_buffer_create_tag (priv->buffer, "error-message",
              "left-margin", ERROR_MARGIN24,
	      NULL((void*)0));
1432}

1434static void
1435follow_if_is_link (GdictDefbox *defbox,
                 CtkTextView *text_view,
                 CtkTextIter *iter)
1438{
GSList *tags, *l;

tags = ctk_text_iter_get_tags (iter);

for (l = tags; l != NULL((void*)0); l = l->next)
  {
    CtkTextTag *tag = l->data;
    gchar *name;

    g_object_get (G_OBJECT (tag)((((GObject*) (void *) ((tag))))), "name", &name, NULL((void*)0));
    if (name &&
        (strcmp (name, "link") == 0 ||
         strcmp (name, "visited-link") == 0))
      {
        CtkTextBuffer *buffer = ctk_text_view_get_buffer (text_view);
        CtkTextIter start, end;
        gchar *link_str;

        start = *iter;
        end = *iter;

        ctk_text_iter_backward_to_tag_toggle (&start, tag);
        ctk_text_iter_forward_to_tag_toggle (&end, tag);

        link_str = ctk_text_buffer_get_text (buffer, &start, &end, FALSE(0));

        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);
1477}

1479static gboolean
1480defbox_event_after_cb (CtkWidget   *text_view,
                     CdkEvent    *event,
                     GdictDefbox *defbox)
1483{
CtkTextIter iter;
CtkTextBuffer *buffer;
CdkEventButton *button_event;
gint bx, by;

if (event->type != CDK_BUTTON_RELEASE)
  return FALSE(0);

button_event = (CdkEventButton *) event;

if (button_event->button != 1)
  return FALSE(0);

buffer = ctk_text_view_get_buffer (CTK_TEXT_VIEW (text_view)((((CtkTextView*) (void *) ((text_view))))));
if (ctk_text_buffer_get_has_selection (buffer))
  return FALSE(0);

ctk_text_view_window_to_buffer_coords (CTK_TEXT_VIEW (text_view)((((CtkTextView*) (void *) ((text_view))))),
                                       CTK_TEXT_WINDOW_WIDGET,
                                       button_event->x, button_event->y,
                                       &bx, &by);

ctk_text_view_get_iter_at_location (CTK_TEXT_VIEW (text_view)((((CtkTextView*) (void *) ((text_view))))),
                                    &iter,
                                    bx, by);

follow_if_is_link (defbox, CTK_TEXT_VIEW (text_view)((((CtkTextView*) (void *) ((text_view))))), &iter);

return FALSE(0);
1513}

1515static void
1516set_cursor_if_appropriate (GdictDefbox *defbox,
                         CtkTextView *text_view,
                         gint         x,
                         gint         y)
1520{
GdictDefboxPrivate *priv;
GSList *tags, *l;
CtkTextIter iter;
gboolean hovering = FALSE(0);

priv = defbox->priv;

if (!priv->hand_cursor)
  {
    CdkDisplay *display = ctk_widget_get_display (CTK_WIDGET (defbox)((((CtkWidget*) (void *) ((defbox))))));
    priv->hand_cursor = cdk_cursor_new_for_display (display, CDK_HAND2);
  }

if (!priv->regular_cursor)
  {
    CdkDisplay *display = ctk_widget_get_display (CTK_WIDGET (defbox)((((CtkWidget*) (void *) ((defbox))))));
    priv->regular_cursor = cdk_cursor_new_for_display (display, CDK_XTERM);
  }

ctk_text_view_get_iter_at_location (text_view, &iter, x, y);

tags = ctk_text_iter_get_tags (&iter);
for (l = tags; l != NULL((void*)0); l = l->next)
  {
    CtkTextTag *tag = l->data;
    gchar *name;

    g_object_get (G_OBJECT (tag)((((GObject*) (void *) ((tag))))), "name", &name, NULL((void*)0));
    if (name &&
        (strcmp (name, "link") == 0 ||
         strcmp (name, "visited-link") == 0))
      {
        hovering = TRUE(!(0));
        g_free (name);

        break;
      }

    g_free (name);
  }

if (hovering != defbox->priv->is_hovering)
  {
    defbox->priv->is_hovering = hovering;

    if (defbox->priv->is_hovering)
      cdk_window_set_cursor (ctk_text_view_get_window (text_view,
                                                       CTK_TEXT_WINDOW_TEXT),
                             defbox->priv->hand_cursor);
    else
      cdk_window_set_cursor (ctk_text_view_get_window (text_view,
                                                       CTK_TEXT_WINDOW_TEXT),
                             defbox->priv->regular_cursor);
  }

if (tags)
  g_slist_free (tags);
1578}

1580static gboolean
1581defbox_motion_notify_cb (CtkWidget      *text_view,
                       CdkEventMotion *event,
                       GdictDefbox    *defbox)
1584{
gint bx, by;

ctk_text_view_window_to_buffer_coords (CTK_TEXT_VIEW (text_view)((((CtkTextView*) (void *) ((text_view))))),
                                       CTK_TEXT_WINDOW_WIDGET,
                                       event->x, event->y,
                                       &bx, &by);

set_cursor_if_appropriate (defbox, CTK_TEXT_VIEW (text_view)((((CtkTextView*) (void *) ((text_view))))), bx, by);

return FALSE(0);
1595}

1597static gboolean
1598defbox_visibility_notify_cb (CtkWidget          *text_view,
                           CdkEventVisibility *event,
                           GdictDefbox        *defbox)
1601{
CdkDisplay *display;
CdkSeat *seat;
CdkDevice *pointer;
gint wx, wy;
gint bx, by;

display = cdk_window_get_display (event->window);
seat = cdk_display_get_default_seat (display);
pointer = cdk_seat_get_pointer (seat);
cdk_window_get_device_position (ctk_widget_get_window (text_view), pointer, &wx, &wy, NULL((void*)0));

ctk_text_view_window_to_buffer_coords (CTK_TEXT_VIEW (text_view)((((CtkTextView*) (void *) ((text_view))))),
                                       CTK_TEXT_WINDOW_WIDGET,
                                       wx, wy,
                                       &bx, &by);

set_cursor_if_appropriate (defbox, CTK_TEXT_VIEW (text_view)((((CtkTextView*) (void *) ((text_view))))), bx, by);

return FALSE(0);
1621}

1623static GObject *
1624gdict_defbox_constructor (GType                  type,
	  guint                  n_construct_properties,
	  GObjectConstructParam *construct_params)
1627{
GdictDefbox *defbox;
GdictDefboxPrivate *priv;
GObject *object;
CtkWidget *sw;

object = G_OBJECT_CLASS (gdict_defbox_parent_class)((((GObjectClass*) (void *) ((gdict_defbox_parent_class)))))->constructor (type,
						   n_construct_properties,
						   construct_params);
defbox = GDICT_DEFBOX (object)((((GdictDefbox*) (void *) ((object)))));
priv = defbox->priv;

sw = ctk_scrolled_window_new (NULL((void*)0), NULL((void*)0));
ctk_widget_set_vexpand (sw, TRUE(!(0)));
ctk_scrolled_window_set_policy (CTK_SCROLLED_WINDOW (sw)((((CtkScrolledWindow*) (void *) ((sw))))),
				  CTK_POLICY_AUTOMATIC,
				  CTK_POLICY_AUTOMATIC);
ctk_scrolled_window_set_shadow_type (CTK_SCROLLED_WINDOW (sw)((((CtkScrolledWindow*) (void *) ((sw))))),
				       CTK_SHADOW_IN);
ctk_box_pack_start (CTK_BOX (defbox)((((CtkBox*) (void *) ((defbox))))), sw, TRUE(!(0)), TRUE(!(0)), 0);
ctk_widget_show (sw);

priv->buffer = ctk_text_buffer_new (NULL((void*)0));
gdict_defbox_init_tags (defbox);

priv->text_view = ctk_text_view_new_with_buffer (priv->buffer);
ctk_text_view_set_editable (CTK_TEXT_VIEW (priv->text_view)((((CtkTextView*) (void *) ((priv->text_view))))), FALSE(0));
ctk_text_view_set_left_margin (CTK_TEXT_VIEW (priv->text_view)((((CtkTextView*) (void *) ((priv->text_view))))), 4);
ctk_container_add (CTK_CONTAINER (sw)((((CtkContainer*) (void *) ((sw))))), priv->text_view);
ctk_widget_show (priv->text_view);

priv->find_pane = create_find_pane (defbox);
ctk_box_pack_end (CTK_BOX (defbox)((((CtkBox*) (void *) ((defbox))))), priv->find_pane, FALSE(0), FALSE(0), 0);

/* stuff to make the link machinery work */
g_signal_connect (priv->text_view, "event-after",g_signal_connect_data ((priv->text_view), ("event-after"),
 (((GCallback) (defbox_event_after_cb))), (defbox), ((void*)0
), (GConnectFlags) 0)
                  G_CALLBACK (defbox_event_after_cb),g_signal_connect_data ((priv->text_view), ("event-after"),
 (((GCallback) (defbox_event_after_cb))), (defbox), ((void*)0
), (GConnectFlags) 0)
                  defbox)g_signal_connect_data ((priv->text_view), ("event-after"),
 (((GCallback) (defbox_event_after_cb))), (defbox), ((void*)0
), (GConnectFlags) 0);
g_signal_connect (priv->text_view, "motion-notify-event",g_signal_connect_data ((priv->text_view), ("motion-notify-event"
), (((GCallback) (defbox_motion_notify_cb))), (defbox), ((void
*)0), (GConnectFlags) 0)
                  G_CALLBACK (defbox_motion_notify_cb),g_signal_connect_data ((priv->text_view), ("motion-notify-event"
), (((GCallback) (defbox_motion_notify_cb))), (defbox), ((void
*)0), (GConnectFlags) 0)
                  defbox)g_signal_connect_data ((priv->text_view), ("motion-notify-event"
), (((GCallback) (defbox_motion_notify_cb))), (defbox), ((void
*)0), (GConnectFlags) 0);
g_signal_connect (priv->text_view, "visibility-notify-event",g_signal_connect_data ((priv->text_view), ("visibility-notify-event"
), (((GCallback) (defbox_visibility_notify_cb))), (defbox), (
(void*)0), (GConnectFlags) 0)
                  G_CALLBACK (defbox_visibility_notify_cb),g_signal_connect_data ((priv->text_view), ("visibility-notify-event"
), (((GCallback) (defbox_visibility_notify_cb))), (defbox), (
(void*)0), (GConnectFlags) 0)
                  defbox)g_signal_connect_data ((priv->text_view), ("visibility-notify-event"
), (((GCallback) (defbox_visibility_notify_cb))), (defbox), (
(void*)0), (GConnectFlags) 0);

return object;
1673}

1675/* we override the CtkWidget::show_all method since we have widgets
* we don't want to show, such as the find pane
*/
1678static void
1679gdict_defbox_show_all (CtkWidget *widget)
1680{
GdictDefbox *defbox = GDICT_DEFBOX (widget)((((GdictDefbox*) (void *) ((widget)))));
GdictDefboxPrivate *priv = defbox->priv;

ctk_widget_show (widget);

if (priv->show_find)
  ctk_widget_show_all (priv->find_pane);
1688}

1690static void
1691gdict_defbox_real_show_find (GdictDefbox *defbox)
1692{
ctk_widget_show_all (defbox->priv->find_pane);
defbox->priv->show_find = TRUE(!(0));

ctk_widget_grab_focus (defbox->priv->find_entry);

defbox->priv->hide_timeout = g_timeout_add_seconds (5, hide_find_pane, defbox);
1699}

1701static void
1702gdict_defbox_real_find_next (GdictDefbox *defbox)
1703{
/* synthetize a "clicked" signal to the "next" button */
ctk_button_clicked (CTK_BUTTON (defbox->priv->find_next)((((CtkButton*) (void *) ((defbox->priv->find_next))))));
1706}

1708static void
1709gdict_defbox_real_find_previous (GdictDefbox *defbox)
1710{
/* synthetize a "clicked" signal to the "prev" button */
ctk_button_clicked (CTK_BUTTON (defbox->priv->find_prev)((((CtkButton*) (void *) ((defbox->priv->find_prev))))));
1713}

1715static void
1716gdict_defbox_real_hide_find (GdictDefbox *defbox)
1717{
ctk_widget_hide (defbox->priv->find_pane);
defbox->priv->show_find = FALSE(0);

ctk_widget_grab_focus (defbox->priv->text_view);

if (defbox->priv->hide_timeout)
  {
    g_source_remove (defbox->priv->hide_timeout);
    defbox->priv->hide_timeout = 0;
  }
1728}

1730static void
1731gdict_defbox_class_init (GdictDefboxClass *klass)
1732{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass)((((GObjectClass*) (void *) ((klass)))));
CtkWidgetClass *widget_class = CTK_WIDGET_CLASS (klass)((((CtkWidgetClass*) (void *) ((klass)))));
CtkBindingSet *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;

/**
 * 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((void*)0),
                                                      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(gdict_context_get_type ()),
				   			(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"Sans 10",
					(G_PARAM_READABLE | G_PARAM_WRITABLE)));

gdict_defbox_signals[SHOW_FIND] =
  g_signal_new ("show-find",
  G_OBJECT_CLASS_TYPE (gobject_class)((((GTypeClass*) (gobject_class))->g_type)),
  G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
  G_STRUCT_OFFSET (GdictDefboxClass, show_find)((glong) __builtin_offsetof(GdictDefboxClass, show_find)),
  NULL((void*)0), NULL((void*)0),
  gdict_marshal_VOID__VOIDg_cclosure_marshal_VOID__VOID,
  G_TYPE_NONE((GType) ((1) << (2))), 0);
gdict_defbox_signals[FIND_PREVIOUS] =
  g_signal_new ("find-previous",
                G_OBJECT_CLASS_TYPE (gobject_class)((((GTypeClass*) (gobject_class))->g_type)),
                G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
                G_STRUCT_OFFSET (GdictDefboxClass, find_previous)((glong) __builtin_offsetof(GdictDefboxClass, find_previous)),
                NULL((void*)0), NULL((void*)0),
                gdict_marshal_VOID__VOIDg_cclosure_marshal_VOID__VOID,
                G_TYPE_NONE((GType) ((1) << (2))), 0);
gdict_defbox_signals[FIND_NEXT] =
  g_signal_new ("find-next",
  G_OBJECT_CLASS_TYPE (gobject_class)((((GTypeClass*) (gobject_class))->g_type)),
  G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
  G_STRUCT_OFFSET (GdictDefboxClass, find_next)((glong) __builtin_offsetof(GdictDefboxClass, find_next)),
  NULL((void*)0), NULL((void*)0),
  gdict_marshal_VOID__VOIDg_cclosure_marshal_VOID__VOID,
  G_TYPE_NONE((GType) ((1) << (2))), 0);
gdict_defbox_signals[HIDE_FIND] =
  g_signal_new ("hide-find",
  G_OBJECT_CLASS_TYPE (gobject_class)((((GTypeClass*) (gobject_class))->g_type)),
  G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
  G_STRUCT_OFFSET (GdictDefboxClass, hide_find)((glong) __builtin_offsetof(GdictDefboxClass, hide_find)),
  NULL((void*)0), NULL((void*)0),
  gdict_marshal_VOID__VOIDg_cclosure_marshal_VOID__VOID,
  G_TYPE_NONE((GType) ((1) << (2))), 0);
gdict_defbox_signals[LINK_CLICKED] =
  g_signal_new ("link-clicked",
                G_OBJECT_CLASS_TYPE (gobject_class)((((GTypeClass*) (gobject_class))->g_type)),
                G_SIGNAL_RUN_LAST,
                G_STRUCT_OFFSET (GdictDefboxClass, link_clicked)((glong) __builtin_offsetof(GdictDefboxClass, link_clicked)),
                NULL((void*)0), NULL((void*)0),
                gdict_marshal_VOID__STRINGg_cclosure_marshal_VOID__STRING,
                G_TYPE_NONE((GType) ((1) << (2))), 1,
                G_TYPE_STRING((GType) ((16) << (2))));

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 = ctk_binding_set_by_class (klass);
ctk_binding_entry_add_signal (binding_set,
			        CDK_KEY_f0x066, CDK_CONTROL_MASK,
			        "show-find",
			        0);
ctk_binding_entry_add_signal (binding_set,
			        CDK_KEY_g0x067, CDK_CONTROL_MASK,
			        "find-next",
			        0);
ctk_binding_entry_add_signal (binding_set,
				CDK_KEY_g0x067, CDK_SHIFT_MASK | CDK_CONTROL_MASK,
				"find-previous",
				0);
ctk_binding_entry_add_signal (binding_set,
			        CDK_KEY_Escape0xff1b, 0,
			        "hide-find",
			        0);
1868}

1870static void
1871gdict_defbox_init (GdictDefbox *defbox)
1872{
GdictDefboxPrivate *priv;

ctk_orientable_set_orientation (CTK_ORIENTABLE (defbox)((((CtkOrientable*) (void *) ((defbox))))), CTK_ORIENTATION_VERTICAL);
ctk_box_set_spacing (CTK_BOX (defbox)((((CtkBox*) (void *) ((defbox))))), 6);

priv = gdict_defbox_get_instance_private (defbox);
defbox->priv = priv;

priv->context = NULL((void*)0);
priv->database = g_strdup (GDICT_DEFAULT_DATABASE)g_strdup_inline ("*");
priv->font_name = g_strdup (GDICT_DEFAULT_FONT_NAME)g_strdup_inline ("Sans 10");
priv->word = NULL((void*)0);

priv->definitions = NULL((void*)0);

priv->busy_cursor = NULL((void*)0);
priv->hand_cursor = NULL((void*)0);
priv->regular_cursor = NULL((void*)0);

priv->show_find = FALSE(0);
priv->is_searching = FALSE(0);
priv->is_hovering = FALSE(0);

priv->hide_timeout = 0;
1897}

1899/**
* 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
*/
1911CtkWidget *
1912gdict_defbox_new (void)
1913{
return g_object_new (GDICT_TYPE_DEFBOX(gdict_defbox_get_type ()), NULL((void*)0));
1915}

1917/**
* 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
*/
1928CtkWidget *
1929gdict_defbox_new_with_context (GdictContext *context)
1930{
g_return_val_if_fail (GDICT_IS_CONTEXT (context), NULL)do{ (void)0; }while (0);

return g_object_new (GDICT_TYPE_DEFBOX(gdict_defbox_get_type ()), "context", context, NULL((void*)0));
1934}

1936/**
* 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
*/
1946void
1947gdict_defbox_set_context (GdictDefbox  *defbox,
	  GdictContext *context)
1949{
g_return_if_fail (GDICT_IS_DEFBOX (defbox))do{ (void)0; }while (0);
g_return_if_fail (context == NULL || GDICT_IS_CONTEXT (context))do{ (void)0; }while (0);

g_object_set (defbox, "context", context, NULL((void*)0));
1954}

1956/**
* gdict_defbox_get_context:
* @defbox: a #GdictDefbox
*
* Gets the #GdictContext used by @defbox.
*
* Return value: a #GdictContext.
*
* Since: 0.1
*/
1966GdictContext *
1967gdict_defbox_get_context (GdictDefbox *defbox)
1968{
g_return_val_if_fail (GDICT_IS_DEFBOX (defbox), NULL)do{ (void)0; }while (0);

return defbox->priv->context;
1972}

1974/**
* 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
*/
1984void
1985gdict_defbox_set_database (GdictDefbox *defbox,
	   const gchar *database)
1987{
GdictDefboxPrivate *priv;

g_return_if_fail (GDICT_IS_DEFBOX (defbox))do{ (void)0; }while (0);

priv = defbox->priv;

g_free (priv->database);
priv->database = g_strdup (database)g_strdup_inline (database);

g_object_notify (G_OBJECT (defbox)((((GObject*) (void *) ((defbox))))), "database");
1998}

2000/**
* 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
*/
2011const gchar *
2012gdict_defbox_get_database (GdictDefbox *defbox)
2013{
g_return_val_if_fail (GDICT_IS_DEFBOX (defbox), NULL)do{ (void)0; }while (0);

return defbox->priv->database;
2017}

2019/**
* 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
*/
2031const gchar *
2032gdict_defbox_get_word (GdictDefbox *defbox)
2033{
g_return_val_if_fail (GDICT_IS_DEFBOX (defbox), NULL)do{ (void)0; }while (0);

return defbox->priv->word;
2037}

2039/**
* 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
*/
2048void
2049gdict_defbox_set_show_find (GdictDefbox *defbox,
	    gboolean     show_find)
2051{
GdictDefboxPrivate *priv;

g_return_if_fail (GDICT_IS_DEFBOX (defbox))do{ (void)0; }while (0);

priv = defbox->priv;

if (priv->show_find == show_find)
  return;

priv->show_find = show_find;
if (priv->show_find)
  {
    ctk_widget_show_all (priv->find_pane);
    ctk_widget_grab_focus (priv->find_entry);

    if (!priv->hide_timeout)
      priv->hide_timeout = g_timeout_add_seconds (5, hide_find_pane, defbox);
  }
else
  {
    ctk_widget_hide (priv->find_pane);

    if (priv->hide_timeout)
      {
        g_source_remove (priv->hide_timeout);
        priv->hide_timeout = 0;
      }
  }
2080}

2082/**
* 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
*/
2092gboolean
2093gdict_defbox_get_show_find (GdictDefbox *defbox)
2094{
g_return_val_if_fail (GDICT_IS_DEFBOX (defbox), FALSE)do{ (void)0; }while (0);

return (defbox->priv->show_find == TRUE(!(0)));
2098}

2100static void
2101lookup_start_cb (GdictContext *context,
 gpointer      user_data)
2103{
GdictDefbox *defbox = GDICT_DEFBOX (user_data)((((GdictDefbox*) (void *) ((user_data)))));
GdictDefboxPrivate *priv = defbox->priv;
CdkWindow *window;

priv->is_searching = TRUE(!(0));

if (!priv->busy_cursor)
  {
    CdkDisplay *display = ctk_widget_get_display (CTK_WIDGET (defbox)((((CtkWidget*) (void *) ((defbox))))));
    priv->busy_cursor = cdk_cursor_new_for_display (display, CDK_WATCH);
  }

window = ctk_text_view_get_window (CTK_TEXT_VIEW (priv->text_view)((((CtkTextView*) (void *) ((priv->text_view))))),
				     CTK_TEXT_WINDOW_WIDGET);

cdk_window_set_cursor (window, priv->busy_cursor);
2120}

2122static void
2123lookup_end_cb (GdictContext *context,
      gpointer      user_data)
2125{
GdictDefbox *defbox = GDICT_DEFBOX (user_data)((((GdictDefbox*) (void *) ((user_data)))));
GdictDefboxPrivate *priv = defbox->priv;
CtkTextBuffer *buffer;
CtkTextIter start;
CdkWindow *window;

/* explicitely move the cursor to the beginning */
buffer = ctk_text_view_get_buffer (CTK_TEXT_VIEW (priv->text_view)((((CtkTextView*) (void *) ((priv->text_view))))));
ctk_text_buffer_get_start_iter (buffer, &start);
ctk_text_buffer_place_cursor (buffer, &start);

window = ctk_text_view_get_window (CTK_TEXT_VIEW (priv->text_view)((((CtkTextView*) (void *) ((priv->text_view))))),
				     CTK_TEXT_WINDOW_WIDGET);

cdk_window_set_cursor (window, NULL((void*)0));

priv->is_searching = FALSE(0);
2143}

2145static void
2146gdict_defbox_insert_word (GdictDefbox *defbox,
	  CtkTextIter *iter,
	  const gchar *word)
2149{
GdictDefboxPrivate *priv;
gchar *text;

if (!word)
  return;

g_assert (GDICT_IS_DEFBOX (defbox))do { (void) 0; } while (0);
priv = defbox->priv;

g_assert (CTK_IS_TEXT_BUFFER (priv->buffer))do { (void) 0; } while (0);

text = g_strdup_printf ("%s\n", word);
ctk_text_buffer_insert_with_tags_by_name (priv->buffer,
					    iter,
					    text, strlen (text),
					    "big", "bold", "query-title",
					    NULL((void*)0));
g_free (text);
2168}

2170/* 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.
*/
2175static const gchar *
2176escape_link (const gchar  *str,
           gchar       **link_str)
2178{
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)g_string_append_c_inline (link_buf, *p);
  }

if (link_str)
  *link_str = g_string_free (link_buf, FALSE)(__builtin_constant_p ((0)) ? (((0)) ? (g_string_free) ((link_buf
), ((0))) : g_string_free_and_steal (link_buf)) : (g_string_free
) ((link_buf), ((0))));

p++;

return p;
2197}

2199static const gchar *
2200escape_phonethic (const gchar  *str,
                gchar       **phon_str)
2202{
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)g_string_append_c_inline (phon_buf, *p);
  }

if (phon_str)
  *phon_str = g_string_free (phon_buf, FALSE)(__builtin_constant_p ((0)) ? (((0)) ? (g_string_free) ((phon_buf
), ((0))) : g_string_free_and_steal (phon_buf)) : (g_string_free
) ((phon_buf), ((0))));

p++;

return p;
2221}

2223static void
2224gdict_defbox_insert_body (GdictDefbox *defbox,
	  CtkTextIter *iter,
	  const gchar *body)
2227{
GdictDefboxPrivate *priv;
gchar **words;
gint len, i;
CtkTextIter end_iter;

if (!body)
  return;

g_assert (GDICT_IS_DEFBOX (defbox))do { (void) 0; } while (0);
priv = defbox->priv;

g_assert (CTK_IS_TEXT_BUFFER (priv->buffer))do { (void) 0; } while (0);

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);

            ctk_text_buffer_insert_with_tags_by_name (priv->buffer,
                                                      &end_iter,
                                                      link_str, -1,
                                                      "link",
                                                      NULL((void*)0));

            ctk_text_buffer_insert (priv->buffer, &end_iter, rest, -1);

            ctk_text_buffer_get_end_iter (priv->buffer, &end_iter);
            ctk_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((void*)0));
            next = words[cur++];

            while (next && (end = g_utf8_strrchr (next, -1, '}')) == NULL((void*)0))
              {
                buf = g_string_append (buf, next)(__builtin_constant_p (next) ? __extension__ ({ const char * const
 __val = (next); g_string_append_len_inline (buf, __val, (__val
 != ((void*)0)) ? (gssize) strlen (((__val) + !(__val))) : (gssize
) -1); }) : g_string_append_len_inline (buf, next, (gssize) -
1));
                buf = g_string_append_c (buf, ' ')g_string_append_c_inline (buf, ' ');

                next = words[cur++];
              }

            buf = g_string_append (buf, next)(__builtin_constant_p (next) ? __extension__ ({ const char * const
 __val = (next); g_string_append_len_inline (buf, __val, (__val
 != ((void*)0)) ? (gssize) strlen (((__val) + !(__val))) : (gssize
) -1); }) : g_string_append_len_inline (buf, next, (gssize) -
1));

            next = g_string_free (buf, FALSE)(__builtin_constant_p ((0)) ? (((0)) ? (g_string_free) ((buf)
, ((0))) : g_string_free_and_steal (buf)) : (g_string_free) (
(buf), ((0))));

            if (end && *end == '}')
              {
                const gchar *rest;
                gchar *link_str;

                rest = escape_link (next, &link_str);

                ctk_text_buffer_insert_with_tags_by_name (priv->buffer,
                                                          &end_iter,
                                                          link_str, -1,
                                                          "link",
                                                          NULL((void*)0));

                ctk_text_buffer_insert (priv->buffer, &end_iter, rest, -1);
                ctk_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);

            ctk_text_buffer_insert_with_tags_by_name (priv->buffer,
                                                      &end_iter,
                                                      phon, -1,
                                                      "italic", "phonetic",
                                                      NULL((void*)0));

            ctk_text_buffer_insert (priv->buffer, &end_iter, rest, -1);

            ctk_text_buffer_get_end_iter (priv->buffer, &end_iter);
            ctk_text_buffer_insert (priv->buffer, &end_iter, " ", -1);

            g_free (phon);

            continue;
          }
      }

    ctk_text_buffer_insert (priv->buffer, &end_iter, w, w_len);

    ctk_text_buffer_get_end_iter (priv->buffer, &end_iter);
    ctk_text_buffer_insert (priv->buffer, &end_iter, " ", 1);
  }

ctk_text_buffer_get_end_iter (priv->buffer, &end_iter);
ctk_text_buffer_insert (priv->buffer, &end_iter, "\n", 1);

*iter = end_iter;

g_strfreev (words);
2370}

2372static void
2373gdict_defbox_insert_from (GdictDefbox *defbox,
	  CtkTextIter *iter,
	  const gchar *database)
2376{
GdictDefboxPrivate *priv;
gchar *text;

if (!database)
  return;

g_assert (GDICT_IS_DEFBOX (defbox))do { (void) 0; } while (0);
priv = defbox->priv;

g_assert (CTK_IS_TEXT_BUFFER (priv->buffer))do { (void) 0; } while (0);

text = g_strdup_printf ("\t-- From %s\n\n", database);
ctk_text_buffer_insert_with_tags_by_name (priv->buffer,
					    iter,
					    text, strlen (text),
					    "small", "query-from",
					    NULL((void*)0));
g_free (text);
2395}

2397static void
2398gdict_defbox_insert_error (GdictDefbox *defbox,
	   CtkTextIter *iter,
	   const gchar *title,
	   const gchar *message)
2402{
GdictDefboxPrivate *priv;
CtkTextMark *mark;
CtkTextIter cur_iter;

if (!title)
  return;

g_assert (GDICT_IS_DEFBOX (defbox))do { (void) 0; } while (0);
priv = defbox->priv;

g_assert (CTK_IS_TEXT_BUFFER (priv->buffer))do { (void) 0; } while (0);

mark = ctk_text_buffer_create_mark (priv->buffer, "block-cursor", iter, FALSE(0));
ctk_text_buffer_get_iter_at_mark (priv->buffer, &cur_iter, mark);

ctk_text_buffer_insert_with_tags_by_name (priv->buffer,
					    &cur_iter,
					    title, strlen (title),
					    "error-title", "big", "bold",
					    NULL((void*)0));
ctk_text_buffer_get_iter_at_mark (priv->buffer, &cur_iter, mark);

ctk_text_buffer_insert (priv->buffer, &cur_iter, "\n\n", -1);
ctk_text_buffer_get_iter_at_mark (priv->buffer, &cur_iter, mark);

ctk_text_buffer_insert_with_tags_by_name (priv->buffer,
  			    &cur_iter,
			    message, strlen (message),
			    "error-message",
			    NULL((void*)0));
2433}

2435static void
2436definition_found_cb (GdictContext    *context,
     GdictDefinition *definition,
     gpointer         user_data)
2439{
GdictDefbox *defbox = GDICT_DEFBOX (user_data)((((GdictDefbox*) (void *) ((user_data)))));
GdictDefboxPrivate *priv = defbox->priv;
CtkTextIter iter;
Definition *def;

/* insert the word if this is the first definition */
if (!priv->definitions)
  {
    ctk_text_buffer_get_start_iter (priv->buffer, &iter);
    gdict_defbox_insert_word (defbox, &iter,
		gdict_definition_get_word (definition));
  }

def = definition_new ();

ctk_text_buffer_get_end_iter (priv->buffer, &iter);
def->begin = ctk_text_iter_get_offset (&iter);
gdict_defbox_insert_body (defbox, &iter, gdict_definition_get_text (definition));

ctk_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);
2465}

2467static void
2468error_cb (GdictContext *context,
 const GError *error,
 gpointer      user_data)
2471{
GdictDefbox *defbox = GDICT_DEFBOX (user_data)((((GdictDefbox*) (void *) ((user_data)))));
GdictDefboxPrivate *priv = defbox->priv;
CtkTextIter iter;

if (!error)
  return;

gdict_defbox_clear (defbox);

ctk_text_buffer_get_start_iter (priv->buffer, &iter);
gdict_defbox_insert_error (defbox, &iter,
             _("Error while looking up definition")((char *) g_dgettext ("cafe-utils", "Error while looking up definition"
)),
             error->message);

g_free (priv->word);
priv->word = NULL((void*)0);

defbox->priv->is_searching = FALSE(0);
2490}

2492/**
* 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
*/
2502void
2503gdict_defbox_lookup (GdictDefbox *defbox,
     const gchar *word)
2505{
GdictDefboxPrivate *priv;
GError *define_error;

g_return_if_fail (GDICT_IS_DEFBOX (defbox))do{ (void)0; }while (0);

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 (CTK_WIDGET (defbox)((((CtkWidget*) (void *) ((defbox))))),
    			        _("Another search is in progress")((char *) g_dgettext ("cafe-utils", "Another search is in progress"
)),
    			        _("Please wait until the current search ends.")((char *) g_dgettext ("cafe-utils", "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_signal_connect_data ((priv->context), ("lookup-start"), (
((GCallback) (lookup_start_cb))), (defbox), ((void*)0), (GConnectFlags
) 0)
				         G_CALLBACK (lookup_start_cb),g_signal_connect_data ((priv->context), ("lookup-start"), (
((GCallback) (lookup_start_cb))), (defbox), ((void*)0), (GConnectFlags
) 0)
			 defbox)g_signal_connect_data ((priv->context), ("lookup-start"), (
((GCallback) (lookup_start_cb))), (defbox), ((void*)0), (GConnectFlags
) 0);
    priv->define_id = g_signal_connect (priv->context, "definition-found",g_signal_connect_data ((priv->context), ("definition-found"
), (((GCallback) (definition_found_cb))), (defbox), ((void*)0
), (GConnectFlags) 0)
				          G_CALLBACK (definition_found_cb),g_signal_connect_data ((priv->context), ("definition-found"
), (((GCallback) (definition_found_cb))), (defbox), ((void*)0
), (GConnectFlags) 0)
				          defbox)g_signal_connect_data ((priv->context), ("definition-found"
), (((GCallback) (definition_found_cb))), (defbox), ((void*)0
), (GConnectFlags) 0);
    priv->end_id = g_signal_connect (priv->context, "lookup-end",g_signal_connect_data ((priv->context), ("lookup-end"), ((
(GCallback) (lookup_end_cb))), (defbox), ((void*)0), (GConnectFlags
) 0)
				       G_CALLBACK (lookup_end_cb),g_signal_connect_data ((priv->context), ("lookup-end"), ((
(GCallback) (lookup_end_cb))), (defbox), ((void*)0), (GConnectFlags
) 0)
				       defbox)g_signal_connect_data ((priv->context), ("lookup-end"), ((
(GCallback) (lookup_end_cb))), (defbox), ((void*)0), (GConnectFlags
) 0);
  }

if (!priv->error_id)
  priv->error_id = g_signal_connect (priv->context, "error",g_signal_connect_data ((priv->context), ("error"), (((GCallback
) (error_cb))), (defbox), ((void*)0), (GConnectFlags) 0)
				       G_CALLBACK (error_cb),g_signal_connect_data ((priv->context), ("error"), (((GCallback
) (error_cb))), (defbox), ((void*)0), (GConnectFlags) 0)
				       defbox)g_signal_connect_data ((priv->context), ("error"), (((GCallback
) (error_cb))), (defbox), ((void*)0), (GConnectFlags) 0);

priv->word = g_strdup (word)g_strdup_inline (word);
g_object_notify (G_OBJECT (defbox)((((GObject*) (void *) ((defbox))))), "word");

define_error = NULL((void*)0);
gdict_context_define_word (priv->context,
			     priv->database,
			     word,
			     &define_error);
if (define_error)
  {
    CtkTextIter iter;

    ctk_text_buffer_get_start_iter (priv->buffer, &iter);
    gdict_defbox_insert_error (defbox, &iter,
  			         _("Error while retrieving the definition")((char *) g_dgettext ("cafe-utils", "Error while retrieving the definition"
)),
		 define_error->message);

    g_error_free (define_error);
  }
2570}

2572/**
* gdict_defbox_clear:
* @defbox: a @GdictDefbox
*
* Clears the buffer of @defbox
*
* Since: 0.1
*/
2580void
2581gdict_defbox_clear (GdictDefbox *defbox)
2582{
GdictDefboxPrivate *priv;
CtkTextIter start, end;

g_return_if_fail (GDICT_IS_DEFBOX (defbox))do{ (void)0; }while (0);

priv = defbox->priv;

/* destroy previously found definitions */
if (priv->definitions)
  {
    g_slist_free_full (priv->definitions, (GDestroyNotify) definition_free);
    priv->definitions = NULL((void*)0);
  }

ctk_text_buffer_get_bounds (priv->buffer, &start, &end);
ctk_text_buffer_delete (priv->buffer, &start, &end);
2599}

2601/**
* gdict_defbox_find_next:
* @defbox: a #GdictDefbox
*
* Emits the "find-next" signal.
*
* Since: 0.1
*/
2609void
2610gdict_defbox_find_next (GdictDefbox *defbox)
2611{
g_return_if_fail (GDICT_IS_DEFBOX (defbox))do{ (void)0; }while (0);

g_signal_emit (defbox, gdict_defbox_signals[FIND_NEXT], 0);
2615}

2617/**
* gdict_defbox_find_previous:
* @defbox: a #GdictDefbox
*
* Emits the "find-previous" signal.
*
* Since: 0.1
*/
2625void
2626gdict_defbox_find_previous (GdictDefbox *defbox)
2627{
g_return_if_fail (GDICT_IS_DEFBOX (defbox))do{ (void)0; }while (0);

g_signal_emit (defbox, gdict_defbox_signals[FIND_PREVIOUS], 0);
2631}

2633/**
* gdict_defbox_select_all:
* @defbox: a #GdictDefbox
*
* Selects all the text displayed by @defbox
*
* Since: 0.1
*/
2641void
2642gdict_defbox_select_all (GdictDefbox *defbox)
2643{
GdictDefboxPrivate *priv;
CtkTextBuffer *buffer;
CtkTextIter start, end;

g_return_if_fail (GDICT_IS_DEFBOX (defbox))do{ (void)0; }while (0);

priv = defbox->priv;
buffer = ctk_text_view_get_buffer (CTK_TEXT_VIEW (priv->text_view)((((CtkTextView*) (void *) ((priv->text_view))))));

ctk_text_buffer_get_bounds (buffer, &start, &end);
ctk_text_buffer_select_range (buffer, &start, &end);
2655}

2657/**
* gdict_defbox_copy_to_clipboard:
* @defbox: a #GdictDefbox
* @clipboard: a #CtkClipboard
*
* Copies the selected text inside @defbox into @clipboard.
*
* Since: 0.1
*/
2666void
2667gdict_defbox_copy_to_clipboard (GdictDefbox  *defbox,
		CtkClipboard *clipboard)
2669{
GdictDefboxPrivate *priv;
CtkTextBuffer *buffer;

g_return_if_fail (GDICT_IS_DEFBOX (defbox))do{ (void)0; }while (0);
g_return_if_fail (CTK_IS_CLIPBOARD (clipboard))do{ (void)0; }while (0);

priv = defbox->priv;
buffer = ctk_text_view_get_buffer (CTK_TEXT_VIEW (priv->text_view)((((CtkTextView*) (void *) ((priv->text_view))))));

ctk_text_buffer_copy_clipboard (buffer, clipboard);
2680}

2682/**
* gdict_defbox_count_definitions:
* @defbox: a #GdictDefbox
*
* Gets the number of definitions displayed by @defbox
*
* Return value: the number of definitions.
*
* Since: 0.1
*/
2692gint
2693gdict_defbox_count_definitions (GdictDefbox *defbox)
2694{
GdictDefboxPrivate *priv;

g_return_val_if_fail (GDICT_IS_DEFBOX (defbox), -1)do{ (void)0; }while (0);

priv = defbox->priv;
if (!priv->definitions)
  return -1;

return g_slist_length (priv->definitions);
2704}

2706/**
* 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
*/
2716void
2717gdict_defbox_jump_to_definition (GdictDefbox *defbox,
		 gint         number)
2719{
GdictDefboxPrivate *priv;
gint count;
Definition *def;
CtkTextBuffer *buffer;
CtkTextIter def_start;

g_return_if_fail (GDICT_IS_DEFBOX (defbox))do{ (void)0; }while (0);

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 = ctk_text_view_get_buffer (CTK_TEXT_VIEW (priv->text_view)((((CtkTextView*) (void *) ((priv->text_view))))));
ctk_text_buffer_get_iter_at_offset (buffer, &def_start, def->begin);
ctk_text_view_scroll_to_iter (CTK_TEXT_VIEW (priv->text_view)((((CtkTextView*) (void *) ((priv->text_view))))),
    				&def_start,
    				0.0,
    				TRUE(!(0)),
    				0.0, 0.0);
2747}

2749/**
* 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
*/
2761gchar *
2762gdict_defbox_get_text (GdictDefbox *defbox,
       gsize       *length)
2764{
GdictDefboxPrivate *priv;
CtkTextBuffer *buffer;
CtkTextIter start, end;
gchar *retval;

g_return_val_if_fail (GDICT_IS_DEFBOX (defbox), NULL)do{ (void)0; }while (0);

priv = defbox->priv;
buffer = ctk_text_view_get_buffer (CTK_TEXT_VIEW (priv->text_view)((((CtkTextView*) (void *) ((priv->text_view))))));

ctk_text_buffer_get_bounds (buffer, &start, &end);

retval = ctk_text_buffer_get_text (buffer, &start, &end, FALSE(0));

if (length)
  *length = strlen (retval);

return retval;
2783}

2785/**
* 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 ctk_widget_modify_font().
*
* Passing %NULL for @font_name will reset any previously set font.
*
* Since: 0.3.0
*/
2797void
2798gdict_defbox_set_font_name (GdictDefbox *defbox,
	    const gchar *font_name)
2800{
GdictDefboxPrivate *priv;
PangoFontDescription *font_desc;

g_return_if_fail (GDICT_IS_DEFBOX (defbox))do{ (void)0; }while (0);

priv = defbox->priv;

if (font_name)
  {
    font_desc = pango_font_description_from_string (font_name);
    g_return_if_fail (font_desc != NULL)do{ (void)0; }while (0);
  }
else
  font_desc = NULL((void*)0);

ctk_widget_override_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)g_strdup_inline (font_name);
2823}

2825/**
* 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
*/
2836const gchar *
2837gdict_defbox_get_font_name (GdictDefbox *defbox)
2838{
g_return_val_if_fail (GDICT_IS_DEFBOX (defbox), NULL)do{ (void)0; }while (0);

return defbox->priv->font_name;
2842}

2844/**
* 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
*/
2855gchar *
2856gdict_defbox_get_selected_word (GdictDefbox *defbox)
2857{
GdictDefboxPrivate *priv;
CtkTextBuffer *buffer;

g_return_val_if_fail (GDICT_IS_DEFBOX (defbox), NULL)do{ (void)0; }while (0);

priv = defbox->priv;
buffer = ctk_text_view_get_buffer (CTK_TEXT_VIEW (priv->text_view)((((CtkTextView*) (void *) ((priv->text_view))))));

if (!ctk_text_buffer_get_has_selection (buffer))
  return NULL((void*)0);
else
  {
    CtkTextIter start, end;
    gchar *retval;

    ctk_text_buffer_get_selection_bounds (buffer, &start, &end);
    retval = ctk_text_buffer_get_text (buffer, &start, &end, FALSE(0));

    return retval;
  }
2878}