+ const gchar *pattern)
+{
+ const char *start;
+ const char *p = label->text;
+ const char *q = pattern;
+ PangoAttrList *attrs;
+
+ attrs = pango_attr_list_new ();
+
+ while (1)
+ {
+ while (*p && *q && *q != '_')
+ {
+ p = g_utf8_next_char (p);
+ q++;
+ }
+ start = p;
+ while (*p && *q && *q == '_')
+ {
+ p = g_utf8_next_char (p);
+ q++;
+ }
+
+ if (p > start)
+ {
+ PangoAttribute *attr = pango_attr_underline_new (PANGO_UNDERLINE_LOW);
+ attr->start_index = start - label->text;
+ attr->end_index = p - label->text;
+
+ pango_attr_list_insert (attrs, attr);
+ }
+ else
+ break;
+ }
+
+ return attrs;
+}
+
+static void
+gtk_label_set_pattern_internal (GtkLabel *label,
+ const gchar *pattern)
+{
+ PangoAttrList *attrs;
+ g_return_if_fail (GTK_IS_LABEL (label));
+
+ attrs = gtk_label_pattern_to_attrs (label, pattern);
+
+ if (label->effective_attrs)
+ pango_attr_list_unref (label->effective_attrs);
+ label->effective_attrs = attrs;
+}
+
+void
+gtk_label_set_pattern (GtkLabel *label,
+ const gchar *pattern)
+{
+ g_return_if_fail (GTK_IS_LABEL (label));
+
+ gtk_label_set_pattern_internal (label, pattern);
+
+ gtk_label_clear_layout (label);
+ gtk_widget_queue_resize (GTK_WIDGET (label));
+}
+
+
+/**
+ * gtk_label_set_justify:
+ * @label: a #GtkLabel
+ * @jtype: a #GtkJustification
+ *
+ * Sets the alignment of the lines in the text of the label relative to
+ * each other. %GTK_JUSTIFY_LEFT is the default value when the
+ * widget is first created with gtk_label_new(). If you instead want
+ * to set the alignment of the label as a whole, use
+ * gtk_misc_set_alignment() instead. gtk_label_set_justify() has no
+ * effect on labels containing only a single line.
+ **/
+void
+gtk_label_set_justify (GtkLabel *label,
+ GtkJustification jtype)
+{
+ g_return_if_fail (GTK_IS_LABEL (label));
+ g_return_if_fail (jtype >= GTK_JUSTIFY_LEFT && jtype <= GTK_JUSTIFY_FILL);
+
+ if ((GtkJustification) label->jtype != jtype)
+ {
+ label->jtype = jtype;
+
+ /* No real need to be this drastic, but easier than duplicating the code */
+ gtk_label_clear_layout (label);
+
+ g_object_notify (G_OBJECT (label), "justify");
+ gtk_widget_queue_resize (GTK_WIDGET (label));
+ }
+}
+
+/**
+ * gtk_label_get_justify:
+ * @label: a #GtkLabel
+ *
+ * Returns the justification of the label. See gtk_label_set_justify ().
+ *
+ * Return value: #GtkJustification
+ **/
+GtkJustification
+gtk_label_get_justify (GtkLabel *label)
+{
+ g_return_val_if_fail (GTK_IS_LABEL (label), 0);
+
+ return label->jtype;
+}
+
+/**
+ * gtk_label_set_line_wrap:
+ * @label: a #GtkLabel
+ * @wrap: the setting
+ *
+ * Toggles line wrapping within the #GtkLabel widget. %TRUE makes it break
+ * lines if text exceeds the widget's size. %FALSE lets the text get cut off
+ * by the edge of the widget if it exceeds the widget size.
+ **/
+void
+gtk_label_set_line_wrap (GtkLabel *label,
+ gboolean wrap)
+{
+ g_return_if_fail (GTK_IS_LABEL (label));
+
+ wrap = wrap != FALSE;
+
+ if (label->wrap != wrap)
+ {
+ label->wrap = wrap;
+ g_object_notify (G_OBJECT (label), "wrap");
+
+ gtk_widget_queue_resize (GTK_WIDGET (label));
+ }
+}
+
+/**
+ * gtk_label_get_line_wrap:
+ * @label: a #GtkLabel
+ *
+ * Returns whether lines in the label are automatically wrapped. See gtk_label_set_line_wrap ().
+ *
+ * Return value: %TRUE if the lines of the label are automatically wrapped.
+ */
+gboolean
+gtk_label_get_line_wrap (GtkLabel *label)
+{
+ g_return_val_if_fail (GTK_IS_LABEL (label), FALSE);
+
+ return label->wrap;
+}
+
+void
+gtk_label_get (GtkLabel *label,
+ gchar **str)
+{
+ g_return_if_fail (GTK_IS_LABEL (label));
+ g_return_if_fail (str != NULL);
+
+ *str = label->text;
+}
+
+static void
+gtk_label_destroy (GtkObject *object)
+{
+ GtkLabel *label = GTK_LABEL (object);
+
+ gtk_label_set_mnemonic_widget (label, NULL);
+
+ GTK_OBJECT_CLASS (parent_class)->destroy (object);
+}
+
+static void
+gtk_label_finalize (GObject *object)
+{
+ GtkLabel *label;
+
+ g_return_if_fail (GTK_IS_LABEL (object));
+
+ label = GTK_LABEL (object);
+
+ g_free (label->label);
+ g_free (label->text);
+
+ if (label->layout)
+ g_object_unref (label->layout);
+
+ if (label->attrs)
+ pango_attr_list_unref (label->attrs);
+
+ if (label->effective_attrs)
+ pango_attr_list_unref (label->effective_attrs);
+
+ g_free (label->select_info);
+
+ G_OBJECT_CLASS (parent_class)->finalize (object);
+}
+
+static void
+gtk_label_clear_layout (GtkLabel *label)
+{
+ if (label->layout)
+ {
+ g_object_unref (label->layout);
+ label->layout = NULL;
+ }
+}
+
+typedef struct _LabelWrapWidth LabelWrapWidth;
+struct _LabelWrapWidth
+{
+ gint width;
+ PangoFontDescription *font_desc;
+};
+
+static void
+label_wrap_width_free (gpointer data)
+{
+ LabelWrapWidth *wrap_width = data;
+ pango_font_description_free (wrap_width->font_desc);
+ g_free (wrap_width);
+}
+
+static gint
+get_label_wrap_width (GtkLabel *label)
+{
+ PangoLayout *layout;
+ GtkStyle *style = GTK_WIDGET (label)->style;
+
+ LabelWrapWidth *wrap_width = g_object_get_data (G_OBJECT (style), "gtk-label-wrap-width");
+ if (!wrap_width)
+ {
+ wrap_width = g_new0 (LabelWrapWidth, 1);
+ g_object_set_data_full (G_OBJECT (style), "gtk-label-wrap-width",
+ wrap_width, label_wrap_width_free);
+ }
+
+ if (wrap_width->font_desc && pango_font_description_equal (wrap_width->font_desc, style->font_desc))
+ return wrap_width->width;
+
+ if (wrap_width->font_desc)
+ pango_font_description_free (wrap_width->font_desc);
+
+ wrap_width->font_desc = pango_font_description_copy (style->font_desc);
+
+ layout = gtk_widget_create_pango_layout (GTK_WIDGET (label),
+ "This long string gives a good enough length for any line to have.");
+ pango_layout_get_size (layout, &wrap_width->width, NULL);
+ g_object_unref (layout);
+
+ return wrap_width->width;
+}
+
+static void
+gtk_label_ensure_layout (GtkLabel *label)
+{
+ GtkWidget *widget;
+ PangoRectangle logical_rect;
+ gint rwidth, rheight;
+
+ widget = GTK_WIDGET (label);
+
+ rwidth = label->misc.xpad * 2;
+ rheight = label->misc.ypad * 2;
+
+ if (!label->layout)
+ {
+ PangoAlignment align = PANGO_ALIGN_LEFT; /* Quiet gcc */
+
+ label->layout = gtk_widget_create_pango_layout (widget, label->text);
+
+ if (label->effective_attrs)
+ pango_layout_set_attributes (label->layout, label->effective_attrs);
+
+ switch (label->jtype)
+ {
+ case GTK_JUSTIFY_LEFT:
+ align = PANGO_ALIGN_LEFT;
+ break;
+ case GTK_JUSTIFY_RIGHT:
+ align = PANGO_ALIGN_RIGHT;
+ break;
+ case GTK_JUSTIFY_CENTER:
+ align = PANGO_ALIGN_CENTER;
+ break;
+ case GTK_JUSTIFY_FILL:
+ /* FIXME: This just doesn't work to do this */
+ align = PANGO_ALIGN_LEFT;
+ pango_layout_set_justify (label->layout, TRUE);
+ break;
+ default:
+ g_assert_not_reached();
+ }
+
+ pango_layout_set_alignment (label->layout, align);
+
+ if (label->wrap)
+ {
+ GtkWidgetAuxInfo *aux_info;
+ gint longest_paragraph;
+ gint width, height;
+
+ aux_info = _gtk_widget_get_aux_info (widget, FALSE);
+ if (aux_info && aux_info->width > 0)
+ pango_layout_set_width (label->layout, aux_info->width * PANGO_SCALE);
+ else
+ {
+ GdkScreen *screen = gtk_widget_get_screen (GTK_WIDGET (label));
+ gint wrap_width;
+
+ pango_layout_set_width (label->layout, -1);
+ pango_layout_get_extents (label->layout, NULL, &logical_rect);
+
+ width = logical_rect.width;
+
+ /* Try to guess a reasonable maximum width */
+ longest_paragraph = width;
+
+ wrap_width = get_label_wrap_width (label);
+ width = MIN (width, wrap_width);
+ width = MIN (width,
+ PANGO_SCALE * (gdk_screen_get_width (screen) + 1) / 2);
+
+ pango_layout_set_width (label->layout, width);
+ pango_layout_get_extents (label->layout, NULL, &logical_rect);
+ width = logical_rect.width;
+ height = logical_rect.height;
+
+ /* Unfortunately, the above may leave us with a very unbalanced looking paragraph,
+ * so we try short search for a narrower width that leaves us with the same height
+ */
+ if (longest_paragraph > 0)
+ {
+ gint nlines, perfect_width;
+
+ nlines = pango_layout_get_line_count (label->layout);
+ perfect_width = (longest_paragraph + nlines - 1) / nlines;
+
+ if (perfect_width < width)
+ {
+ pango_layout_set_width (label->layout, perfect_width);
+ pango_layout_get_extents (label->layout, NULL, &logical_rect);
+
+ if (logical_rect.height <= height)
+ width = logical_rect.width;
+ else
+ {
+ gint mid_width = (perfect_width + width) / 2;
+
+ if (mid_width > perfect_width)
+ {
+ pango_layout_set_width (label->layout, mid_width);
+ pango_layout_get_extents (label->layout, NULL, &logical_rect);
+
+ if (logical_rect.height <= height)
+ width = logical_rect.width;
+ }
+ }
+ }
+ }
+ pango_layout_set_width (label->layout, width);
+ }
+ }
+ else /* !label->wrap */
+ pango_layout_set_width (label->layout, -1);
+ }
+}
+
+static void
+gtk_label_size_request (GtkWidget *widget,
+ GtkRequisition *requisition)
+{
+ GtkLabel *label;
+ gint width, height;
+ PangoRectangle logical_rect;
+ GtkWidgetAuxInfo *aux_info;
+
+ g_return_if_fail (GTK_IS_LABEL (widget));
+ g_return_if_fail (requisition != NULL);
+
+ label = GTK_LABEL (widget);
+
+ /*
+ * If word wrapping is on, then the height requisition can depend
+ * on:
+ *
+ * - Any width set on the widget via gtk_widget_set_usize().
+ * - The padding of the widget (xpad, set by gtk_misc_set_padding)
+ *
+ * Instead of trying to detect changes to these quantities, if we
+ * are wrapping, we just rewrap for each size request. Since
+ * size requisitions are cached by the GTK+ core, this is not
+ * expensive.
+ */
+
+ if (label->wrap)
+ gtk_label_clear_layout (label);
+
+ gtk_label_ensure_layout (label);
+
+ width = label->misc.xpad * 2;
+ height = label->misc.ypad * 2;
+
+ pango_layout_get_extents (label->layout, NULL, &logical_rect);
+
+ aux_info = _gtk_widget_get_aux_info (widget, FALSE);
+ if (label->wrap && aux_info && aux_info->width > 0)
+ width += aux_info->width;
+ else
+ width += PANGO_PIXELS (logical_rect.width);
+
+ height += PANGO_PIXELS (logical_rect.height);
+
+ requisition->width = width;
+ requisition->height = height;
+}
+
+static void
+gtk_label_size_allocate (GtkWidget *widget,
+ GtkAllocation *allocation)
+{
+ GtkLabel *label;
+
+ label = GTK_LABEL (widget);
+
+ (* GTK_WIDGET_CLASS (parent_class)->size_allocate) (widget, allocation);
+
+ if (label->select_info && label->select_info->window)
+ {
+ gdk_window_move_resize (label->select_info->window,
+ allocation->x,
+ allocation->y,
+ allocation->width,
+ allocation->height);
+ }
+}
+
+static void
+gtk_label_state_changed (GtkWidget *widget,
+ GtkStateType prev_state)
+{
+ GtkLabel *label;
+
+ label = GTK_LABEL (widget);
+
+ if (label->select_info)
+ gtk_label_select_region (label, 0, 0);
+
+ if (GTK_WIDGET_CLASS (parent_class)->state_changed)
+ GTK_WIDGET_CLASS (parent_class)->state_changed (widget, prev_state);
+}
+
+static void
+gtk_label_style_set (GtkWidget *widget,
+ GtkStyle *previous_style)
+{
+ GtkLabel *label;
+
+ g_return_if_fail (GTK_IS_LABEL (widget));
+
+ label = GTK_LABEL (widget);
+
+ /* We have to clear the layout, fonts etc. may have changed */
+ gtk_label_clear_layout (label);
+}
+
+static void
+gtk_label_direction_changed (GtkWidget *widget,
+ GtkTextDirection previous_dir)
+{
+ GtkLabel *label = GTK_LABEL (widget);
+
+ if (label->layout)
+ pango_layout_context_changed (label->layout);
+
+ GTK_WIDGET_CLASS (parent_class)->direction_changed (widget, previous_dir);
+}
+
+#if 0
+static void
+gtk_label_paint_word (GtkLabel *label,
+ gint x,
+ gint y,
+ GtkLabelWord *word,
+ GdkRectangle *area)
+{
+ GtkWidget *widget = GTK_WIDGET (label);
+ GtkLabelULine *uline;
+ gchar *tmp_str;
+
+ tmp_str = gdk_wcstombs (word->beginning);
+ if (tmp_str)
+ {
+ gtk_paint_string (widget->style, widget->window, widget->state,
+ area, widget, "label",
+ x + word->x,
+ y + word->y,
+ tmp_str);
+ g_free (tmp_str);
+ }
+
+ for (uline = word->uline; uline; uline = uline->next)
+ gtk_paint_hline (widget->style, widget->window,
+ widget->state, area,
+ widget, "label",
+ x + uline->x1, x + uline->x2, y + uline->y);
+}
+#endif
+
+static void
+get_layout_location (GtkLabel *label,
+ gint *xp,
+ gint *yp)
+{
+ GtkMisc *misc;
+ GtkWidget *widget;
+ gfloat xalign;
+ gint x, y;
+
+ misc = GTK_MISC (label);
+ widget = GTK_WIDGET (label);
+
+ if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_LTR)
+ xalign = misc->xalign;
+ else
+ xalign = 1.0 - misc->xalign;
+
+ x = floor (widget->allocation.x + (gint)misc->xpad +
+ xalign * (widget->allocation.width - widget->requisition.width)
+ + 0.5);
+
+ if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_LTR)
+ x = MAX (x, widget->allocation.x + misc->xpad);
+ else
+ x = MIN (x,
+ widget->allocation.x + widget->allocation.width -
+ widget->requisition.width - misc->xpad);
+
+ y = floor (widget->allocation.y + (gint)misc->ypad
+ + MAX (((widget->allocation.height - widget->requisition.height) * misc->yalign)
+ + 0.5, 0));
+
+ if (xp)
+ *xp = x;
+
+ if (yp)
+ *yp = y;
+}
+
+static void
+gtk_label_draw_cursor (GtkLabel *label, gint xoffset, gint yoffset)
+{
+ if (label->select_info == NULL)
+ return;
+
+ if (GTK_WIDGET_DRAWABLE (label))
+ {
+ GtkWidget *widget = GTK_WIDGET (label);
+
+ GtkTextDirection keymap_direction;
+ GtkTextDirection widget_direction;
+ PangoRectangle strong_pos, weak_pos;
+ gboolean split_cursor;
+ PangoRectangle *cursor1 = NULL;
+ PangoRectangle *cursor2 = NULL;
+ GdkRectangle cursor_location;
+ GtkTextDirection dir1 = GTK_TEXT_DIR_NONE;
+ GtkTextDirection dir2 = GTK_TEXT_DIR_NONE;
+ GdkGC *gc;
+
+ keymap_direction =
+ (gdk_keymap_get_direction (gdk_keymap_get_for_display (gtk_widget_get_display (widget))) == PANGO_DIRECTION_LTR) ?
+ GTK_TEXT_DIR_LTR : GTK_TEXT_DIR_RTL;
+
+ widget_direction = gtk_widget_get_direction (widget);
+
+ gtk_label_ensure_layout (label);
+
+ pango_layout_get_cursor_pos (label->layout, label->select_info->selection_end,
+ &strong_pos, &weak_pos);
+
+ g_object_get (gtk_widget_get_settings (widget),
+ "gtk-split-cursor", &split_cursor,
+ NULL);
+
+ dir1 = widget_direction;
+
+ if (split_cursor)
+ {
+ cursor1 = &strong_pos;
+
+ if (strong_pos.x != weak_pos.x ||
+ strong_pos.y != weak_pos.y)
+ {
+ dir2 = (widget_direction == GTK_TEXT_DIR_LTR) ? GTK_TEXT_DIR_RTL : GTK_TEXT_DIR_LTR;
+ cursor2 = &weak_pos;
+ }
+ }
+ else
+ {
+ if (keymap_direction == widget_direction)
+ cursor1 = &strong_pos;
+ else
+ cursor1 = &weak_pos;
+ }
+
+ cursor_location.x = xoffset + PANGO_PIXELS (cursor1->x);
+ cursor_location.y = yoffset + PANGO_PIXELS (cursor1->y);
+ cursor_location.width = 0;
+ cursor_location.height = PANGO_PIXELS (cursor1->height);
+
+ gc = _gtk_get_insertion_cursor_gc (widget, TRUE);
+ _gtk_draw_insertion_cursor (widget, widget->window, gc,
+ &cursor_location, dir1,
+ dir2 != GTK_TEXT_DIR_NONE);
+ g_object_unref (gc);
+
+ if (dir2 != GTK_TEXT_DIR_NONE)
+ {
+ cursor_location.x = xoffset + PANGO_PIXELS (cursor2->x);
+ cursor_location.y = yoffset + PANGO_PIXELS (cursor2->y);
+ cursor_location.width = 0;
+ cursor_location.height = PANGO_PIXELS (cursor2->height);
+
+ gc = _gtk_get_insertion_cursor_gc (widget, FALSE);
+ _gtk_draw_insertion_cursor (widget, widget->window, gc,
+ &cursor_location, dir2, TRUE);
+ g_object_unref (gc);
+ }
+ }
+}
+
+
+static gint
+gtk_label_expose (GtkWidget *widget,
+ GdkEventExpose *event)
+{
+ GtkLabel *label;
+ gint x, y;
+
+ g_return_val_if_fail (GTK_IS_LABEL (widget), FALSE);
+ g_return_val_if_fail (event != NULL, FALSE);
+
+ label = GTK_LABEL (widget);
+
+ gtk_label_ensure_layout (label);
+
+ if (GTK_WIDGET_VISIBLE (widget) && GTK_WIDGET_MAPPED (widget) &&
+ label->text && (*label->text != '\0'))
+ {
+ get_layout_location (label, &x, &y);
+
+ gtk_paint_layout (widget->style,
+ widget->window,
+ GTK_WIDGET_STATE (widget),
+ FALSE,
+ &event->area,
+ widget,
+ "label",
+ x, y,
+ label->layout);
+
+ if (label->select_info &&
+ (label->select_info->selection_anchor !=
+ label->select_info->selection_end))
+ {
+ gint range[2];
+ GdkRegion *clip;
+ GtkStateType state;
+
+ range[0] = label->select_info->selection_anchor;
+ range[1] = label->select_info->selection_end;
+
+ if (range[0] > range[1])
+ {
+ gint tmp = range[0];
+ range[0] = range[1];
+ range[1] = tmp;
+ }
+
+ clip = gdk_pango_layout_get_clip_region (label->layout,
+ x, y,
+ range,
+ 1);
+
+ /* FIXME should use gtk_paint, but it can't use a clip
+ * region
+ */
+
+ gdk_gc_set_clip_region (widget->style->black_gc, clip);
+
+
+ state = GTK_STATE_SELECTED;
+ if (!GTK_WIDGET_HAS_FOCUS (widget))
+ state = GTK_STATE_ACTIVE;
+
+ gdk_draw_layout_with_colors (widget->window,
+ widget->style->black_gc,
+ x, y,
+ label->layout,
+ &widget->style->text[state],
+ &widget->style->base[state]);
+
+ gdk_gc_set_clip_region (widget->style->black_gc, NULL);
+ gdk_region_destroy (clip);
+ }
+ else if (label->select_info && GTK_WIDGET_HAS_FOCUS (widget))
+ gtk_label_draw_cursor (label, x, y);
+ }
+
+ return FALSE;
+}
+
+static void
+gtk_label_set_uline_text_internal (GtkLabel *label,
+ const gchar *str)
+{
+ guint accel_key = GDK_VoidSymbol;
+
+ gchar *new_str;
+ gchar *pattern;
+ const gchar *src;
+ gchar *dest, *pattern_dest;
+ gboolean underscore;
+
+ g_return_if_fail (GTK_IS_LABEL (label));
+ g_return_if_fail (str != NULL);
+
+ /* Split text into the base text and a separate pattern
+ * of underscores.
+ */
+
+ new_str = g_new (gchar, strlen (str) + 1);
+ pattern = g_new (gchar, g_utf8_strlen (str, -1) + 1);
+
+ underscore = FALSE;
+
+ if (str == NULL)
+ str = "";
+
+ src = str;
+ dest = new_str;
+ pattern_dest = pattern;
+
+ while (*src)
+ {
+ gunichar c;
+ gchar *next_src;
+
+ c = g_utf8_get_char (src);
+ if (c == (gunichar)-1)
+ {
+ g_warning ("Invalid input string");
+ g_free (new_str);
+ g_free (pattern);
+ return;
+ }
+ next_src = g_utf8_next_char (src);
+
+ if (underscore)
+ {
+ if (c == '_')
+ *pattern_dest++ = ' ';
+ else
+ {
+ *pattern_dest++ = '_';
+ if (accel_key == GDK_VoidSymbol)
+ accel_key = gdk_keyval_to_lower (gdk_unicode_to_keyval (c));
+ }
+
+ while (src < next_src)
+ *dest++ = *src++;
+
+ underscore = FALSE;
+ }
+ else
+ {
+ if (c == '_')
+ {
+ underscore = TRUE;
+ src = next_src;
+ }
+ else
+ {
+ while (src < next_src)
+ *dest++ = *src++;
+
+ *pattern_dest++ = ' ';
+ }
+ }
+ }
+ *dest = 0;
+ *pattern_dest = 0;
+
+ gtk_label_set_text_internal (label, new_str);
+ gtk_label_set_pattern_internal (label, pattern);
+
+ g_free (pattern);
+
+ label->mnemonic_keyval = accel_key;
+}
+
+guint
+gtk_label_parse_uline (GtkLabel *label,
+ const gchar *str)
+{
+ guint keyval;
+ guint orig_keyval;
+
+ g_return_val_if_fail (GTK_IS_LABEL (label), GDK_VoidSymbol);
+ g_return_val_if_fail (str != NULL, GDK_VoidSymbol);
+
+ orig_keyval = label->mnemonic_keyval;
+
+ g_object_freeze_notify (G_OBJECT (label));
+
+ gtk_label_set_label_internal (label, g_strdup (str ? str : ""));
+ gtk_label_set_use_markup_internal (label, FALSE);
+ gtk_label_set_use_underline_internal (label, TRUE);
+
+ gtk_label_recalculate (label);
+
+ keyval = label->mnemonic_keyval;
+ label->mnemonic_keyval = GDK_VoidSymbol;
+
+ gtk_label_setup_mnemonic (label, orig_keyval);
+
+ g_object_thaw_notify (G_OBJECT (label));
+
+ return keyval;
+}
+
+/**
+ * gtk_label_set_text_with_mnemonic:
+ * @label: a #GtkLabel
+ * @str: a string
+ *
+ * Sets the label's text from the string @str.
+ * If characters in @str are preceded by an underscore, they are underlined
+ * indicating that they represent a keyboard accelerator called a mnemonic.
+ * The mnemonic key can be used to activate another widget, chosen automatically,
+ * or explicitly using gtk_label_set_mnemonic_widget().
+ **/
+void
+gtk_label_set_text_with_mnemonic (GtkLabel *label,
+ const gchar *str)
+{
+ guint last_keyval;
+
+ g_return_if_fail (GTK_IS_LABEL (label));
+ g_return_if_fail (str != NULL);
+
+ last_keyval = label->mnemonic_keyval;
+
+ g_object_freeze_notify (G_OBJECT (label));
+
+ gtk_label_set_label_internal (label, g_strdup (str ? str : ""));
+ gtk_label_set_use_markup_internal (label, FALSE);
+ gtk_label_set_use_underline_internal (label, TRUE);
+
+ gtk_label_recalculate (label);
+
+ gtk_label_setup_mnemonic (label, last_keyval);
+
+ g_object_thaw_notify (G_OBJECT (label));
+}
+
+static void
+gtk_label_realize (GtkWidget *widget)
+{
+ GtkLabel *label;
+
+ label = GTK_LABEL (widget);
+
+ (* GTK_WIDGET_CLASS (parent_class)->realize) (widget);
+
+ if (label->select_info)
+ gtk_label_create_window (label);
+}
+
+static void
+gtk_label_unrealize (GtkWidget *widget)
+{
+ GtkLabel *label;
+
+ label = GTK_LABEL (widget);
+
+ if (label->select_info)
+ gtk_label_destroy_window (label);
+
+ (* GTK_WIDGET_CLASS (parent_class)->unrealize) (widget);
+}
+
+static void
+gtk_label_map (GtkWidget *widget)
+{
+ GtkLabel *label;
+
+ label = GTK_LABEL (widget);
+
+ (* GTK_WIDGET_CLASS (parent_class)->map) (widget);
+
+ if (label->select_info)
+ gdk_window_show (label->select_info->window);
+}
+
+static void
+gtk_label_unmap (GtkWidget *widget)
+{
+ GtkLabel *label;
+
+ label = GTK_LABEL (widget);
+
+ if (label->select_info)
+ gdk_window_hide (label->select_info->window);
+
+ (* GTK_WIDGET_CLASS (parent_class)->unmap) (widget);
+}
+
+static void
+window_to_layout_coords (GtkLabel *label,
+ gint *x,
+ gint *y)
+{
+ gint lx, ly;
+ GtkWidget *widget;
+
+ widget = GTK_WIDGET (label);
+
+ /* get layout location in widget->window coords */
+ get_layout_location (label, &lx, &ly);
+
+ if (x)
+ {
+ *x += widget->allocation.x; /* go to widget->window */
+ *x -= lx; /* go to layout */
+ }
+
+ if (y)
+ {
+ *y += widget->allocation.y; /* go to widget->window */
+ *y -= ly; /* go to layout */
+ }
+}
+
+#if 0
+static void
+layout_to_window_coords (GtkLabel *label,
+ gint *x,
+ gint *y)
+{
+ gint lx, ly;
+ GtkWidget *widget;
+
+ widget = GTK_WIDGET (label);
+
+ /* get layout location in widget->window coords */
+ get_layout_location (label, &lx, &ly);
+
+ if (x)
+ {
+ *x += lx; /* go to widget->window */
+ *x -= widget->allocation.x; /* go to selection window */
+ }
+
+ if (y)
+ {
+ *y += ly; /* go to widget->window */
+ *y -= widget->allocation.y; /* go to selection window */
+ }
+}
+#endif
+
+static void
+get_layout_index (GtkLabel *label,
+ gint x,
+ gint y,
+ gint *index)
+{
+ gint trailing = 0;
+ const gchar *cluster;
+ const gchar *cluster_end;
+
+ *index = 0;
+
+ gtk_label_ensure_layout (label);
+
+ window_to_layout_coords (label, &x, &y);
+
+ x *= PANGO_SCALE;
+ y *= PANGO_SCALE;
+
+ pango_layout_xy_to_index (label->layout,
+ x, y,
+ index, &trailing);
+
+
+ cluster = label->text + *index;
+ cluster_end = cluster;
+ while (trailing)
+ {
+ cluster_end = g_utf8_next_char (cluster_end);
+ --trailing;
+ }
+
+ *index += (cluster_end - cluster);
+}
+
+static void
+gtk_label_select_word (GtkLabel *label)
+{
+ gint min, max;
+
+ gint start_index = gtk_label_move_backward_word (label, label->select_info->selection_end);
+ gint end_index = gtk_label_move_forward_word (label, label->select_info->selection_end);
+
+ min = MIN (label->select_info->selection_anchor,
+ label->select_info->selection_end);
+ max = MAX (label->select_info->selection_anchor,
+ label->select_info->selection_end);
+
+ min = MIN (min, start_index);
+ max = MAX (max, end_index);
+
+ gtk_label_select_region_index (label, min, max);
+}
+
+static gint
+gtk_label_button_press (GtkWidget *widget,
+ GdkEventButton *event)
+{
+ GtkLabel *label;
+ gint index = 0;
+
+ label = GTK_LABEL (widget);
+
+ if (label->select_info == NULL)
+ return FALSE;
+
+ if (event->button == 1)
+ {
+ if (!GTK_WIDGET_HAS_FOCUS (widget))
+ gtk_widget_grab_focus (widget);
+
+ if (event->type == GDK_3BUTTON_PRESS)
+ {
+ gtk_label_select_region_index (label, 0, strlen (label->text));
+ return TRUE;
+ }
+
+ if (event->type == GDK_2BUTTON_PRESS)
+ {
+ gtk_label_select_word (label);
+ return TRUE;
+ }
+
+ get_layout_index (label, event->x, event->y, &index);
+
+ if ((label->select_info->selection_anchor !=
+ label->select_info->selection_end) &&
+ (event->state & GDK_SHIFT_MASK))
+ {
+ gint min, max;
+
+ /* extend (same as motion) */
+ min = MIN (label->select_info->selection_anchor,
+ label->select_info->selection_end);
+ max = MAX (label->select_info->selection_anchor,
+ label->select_info->selection_end);
+
+ min = MIN (min, index);
+ max = MAX (max, index);
+
+ /* ensure the anchor is opposite index */
+ if (index == min)
+ {
+ gint tmp = min;
+ min = max;
+ max = tmp;
+ }
+
+ gtk_label_select_region_index (label, min, max);
+ }
+ else
+ {
+ if (event->type == GDK_3BUTTON_PRESS)
+ gtk_label_select_region_index (label, 0, strlen (label->text));
+ else if (event->type == GDK_2BUTTON_PRESS)
+ gtk_label_select_word (label);
+ else
+ /* start a replacement */
+ gtk_label_select_region_index (label, index, index);
+ }
+
+ return TRUE;
+ }
+ else if (event->button == 3 && event->type == GDK_BUTTON_PRESS)
+ {
+ gtk_label_do_popup (label, event);
+
+ return TRUE;
+
+ }
+ return FALSE;
+}
+
+static gint
+gtk_label_button_release (GtkWidget *widget,
+ GdkEventButton *event)
+
+{
+ GtkLabel *label;
+
+ label = GTK_LABEL (widget);
+
+ if (label->select_info == NULL)
+ return FALSE;
+
+ if (event->button != 1)
+ return FALSE;
+
+ /* The goal here is to return TRUE iff we ate the
+ * button press to start selecting.
+ */
+
+ return TRUE;
+}
+
+static gint
+gtk_label_motion (GtkWidget *widget,
+ GdkEventMotion *event)
+{
+ GtkLabel *label;
+ gint index;
+ gint x, y;
+
+ label = GTK_LABEL (widget);
+
+ if (label->select_info == NULL)
+ return FALSE;
+
+ if ((event->state & GDK_BUTTON1_MASK) == 0)
+ return FALSE;
+
+ gdk_window_get_pointer (label->select_info->window,
+ &x, &y, NULL);
+
+ get_layout_index (label, x, y, &index);
+
+ gtk_label_select_region_index (label,
+ label->select_info->selection_anchor,
+ index);
+
+ return TRUE;
+}
+
+static void
+gtk_label_create_window (GtkLabel *label)
+{
+ GtkWidget *widget;
+ GdkWindowAttr attributes;
+ gint attributes_mask;
+
+ g_assert (label->select_info);
+ g_assert (GTK_WIDGET_REALIZED (label));
+
+ if (label->select_info->window)
+ return;
+
+ widget = GTK_WIDGET (label);
+
+ attributes.x = widget->allocation.x;
+ attributes.y = widget->allocation.y;
+ attributes.width = widget->allocation.width;
+ attributes.height = widget->allocation.height;
+ attributes.window_type = GDK_WINDOW_TEMP;
+ attributes.wclass = GDK_INPUT_ONLY;
+ attributes.override_redirect = TRUE;
+ attributes.cursor = gdk_cursor_new_for_display (gtk_widget_get_display (widget),
+ GDK_XTERM);
+ attributes.event_mask = gtk_widget_get_events (widget) |
+ GDK_BUTTON_PRESS_MASK |
+ GDK_BUTTON_RELEASE_MASK |
+ GDK_BUTTON_MOTION_MASK;
+
+ attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_NOREDIR | GDK_WA_CURSOR;
+
+ label->select_info->window = gdk_window_new (widget->window,
+ &attributes, attributes_mask);
+ gdk_window_set_user_data (label->select_info->window, widget);
+
+ gdk_cursor_unref (attributes.cursor);
+}
+
+static void
+gtk_label_destroy_window (GtkLabel *label)
+{
+ g_assert (label->select_info);
+
+ if (label->select_info->window == NULL)
+ return;
+
+ gdk_window_set_user_data (label->select_info->window, NULL);
+ gdk_window_destroy (label->select_info->window);
+ label->select_info->window = NULL;
+}
+
+/**
+ * gtk_label_set_selectable:
+ * @label: a #GtkLabel
+ * @setting: %TRUE to allow selecting text in the label
+ *
+ * Selectable labels allow the user to select text from the label, for
+ * copy-and-paste.
+ *
+ **/
+void
+gtk_label_set_selectable (GtkLabel *label,
+ gboolean setting)
+{
+ gboolean old_setting;
+
+ g_return_if_fail (GTK_IS_LABEL (label));
+
+ setting = setting != FALSE;
+ old_setting = label->select_info != NULL;
+
+ if (setting)
+ {
+ if (label->select_info == NULL)
+ {
+ label->select_info = g_new0 (GtkLabelSelectionInfo, 1);
+
+ GTK_WIDGET_SET_FLAGS (label, GTK_CAN_FOCUS);
+
+ if (GTK_WIDGET_REALIZED (label))
+ gtk_label_create_window (label);
+
+ if (GTK_WIDGET_MAPPED (label))
+ gdk_window_show (label->select_info->window);
+ }
+ }
+ else
+ {
+ if (label->select_info)
+ {
+ /* unselect, to give up the selection */
+ gtk_label_select_region (label, 0, 0);
+
+ if (label->select_info->window)
+ {
+ gtk_label_destroy_window (label);
+ }
+
+ g_free (label->select_info);
+
+ label->select_info = NULL;
+
+ GTK_WIDGET_UNSET_FLAGS (label, GTK_CAN_FOCUS);
+ }
+ }
+ if (setting != old_setting)
+ {
+ g_object_freeze_notify (G_OBJECT (label));
+ g_object_notify (G_OBJECT (label), "selectable");
+ g_object_notify (G_OBJECT (label), "cursor_position");
+ g_object_notify (G_OBJECT (label), "selection_bound");
+ g_object_thaw_notify (G_OBJECT (label));
+ gtk_widget_queue_draw (GTK_WIDGET (label));
+ }
+}
+
+/**
+ * gtk_label_get_selectable:
+ * @label: a #GtkLabel
+ *
+ * Gets the value set by gtk_label_set_selectable().
+ *
+ * Return value: %TRUE if the user can copy text from the label
+ **/
+gboolean
+gtk_label_get_selectable (GtkLabel *label)
+{
+ g_return_val_if_fail (GTK_IS_LABEL (label), FALSE);
+
+ return label->select_info != NULL;
+}
+
+static void
+get_text_callback (GtkClipboard *clipboard,
+ GtkSelectionData *selection_data,
+ guint info,
+ gpointer user_data_or_owner)
+{
+ GtkLabel *label;
+
+ label = GTK_LABEL (user_data_or_owner);
+
+ if ((label->select_info->selection_anchor !=
+ label->select_info->selection_end) &&
+ label->text)
+ {
+ gint start, end;
+ gint len;
+
+ start = MIN (label->select_info->selection_anchor,
+ label->select_info->selection_end);
+ end = MAX (label->select_info->selection_anchor,
+ label->select_info->selection_end);
+
+ len = strlen (label->text);
+
+ if (end > len)
+ end = len;
+
+ if (start > len)
+ start = len;
+
+ gtk_selection_data_set_text (selection_data,
+ label->text + start,
+ end - start);
+ }
+}
+
+static void
+clear_text_callback (GtkClipboard *clipboard,
+ gpointer user_data_or_owner)
+{
+ GtkLabel *label;
+
+ label = GTK_LABEL (user_data_or_owner);
+
+ if (label->select_info)
+ {
+ label->select_info->selection_anchor = label->select_info->selection_end;
+
+ gtk_widget_queue_draw (GTK_WIDGET (label));
+ }
+}
+
+static void
+gtk_label_select_region_index (GtkLabel *label,
+ gint anchor_index,
+ gint end_index)
+{
+ static const GtkTargetEntry targets[] = {
+ { "STRING", 0, 0 },
+ { "TEXT", 0, 0 },
+ { "COMPOUND_TEXT", 0, 0 },
+ { "UTF8_STRING", 0, 0 }
+ };
+
+ g_return_if_fail (GTK_IS_LABEL (label));
+
+ if (label->select_info)
+ {
+ GtkClipboard *clipboard;
+
+ if (label->select_info->selection_anchor == anchor_index &&
+ label->select_info->selection_end == end_index)
+ return;
+
+ label->select_info->selection_anchor = anchor_index;
+ label->select_info->selection_end = end_index;
+
+ clipboard = gtk_widget_get_clipboard (GTK_WIDGET (label),
+ GDK_SELECTION_PRIMARY);
+
+ if (anchor_index != end_index)
+ {
+ gtk_clipboard_set_with_owner (clipboard,
+ targets,
+ G_N_ELEMENTS (targets),
+ get_text_callback,
+ clear_text_callback,
+ G_OBJECT (label));
+ }
+ else
+ {
+ if (gtk_clipboard_get_owner (clipboard) == G_OBJECT (label))
+ gtk_clipboard_clear (clipboard);
+ }
+
+ gtk_widget_queue_draw (GTK_WIDGET (label));
+
+ g_object_freeze_notify (G_OBJECT (label));
+ g_object_notify (G_OBJECT (label), "cursor_position");
+ g_object_notify (G_OBJECT (label), "selection_bound");
+ g_object_thaw_notify (G_OBJECT (label));
+ }
+}
+
+/**
+ * gtk_label_select_region:
+ * @label: a #GtkLabel
+ * @start_offset: start offset (in characters not bytes)
+ * @end_offset: end offset (in characters not bytes)
+ *
+ * Selects a range of characters in the label, if the label is selectable.
+ * See gtk_label_set_selectable(). If the label is not selectable,
+ * this function has no effect. If @start_offset or
+ * @end_offset are -1, then the end of the label will be substituted.
+ *
+ **/
+void
+gtk_label_select_region (GtkLabel *label,
+ gint start_offset,
+ gint end_offset)
+{
+ g_return_if_fail (GTK_IS_LABEL (label));
+
+ if (label->text && label->select_info)
+ {
+ if (start_offset < 0)
+ start_offset = g_utf8_strlen (label->text, -1);
+
+ if (end_offset < 0)
+ end_offset = g_utf8_strlen (label->text, -1);
+
+ gtk_label_select_region_index (label,
+ g_utf8_offset_to_pointer (label->text, start_offset) - label->text,
+ g_utf8_offset_to_pointer (label->text, end_offset) - label->text);
+ }
+}
+
+/**
+ * gtk_label_get_selection_bounds:
+ * @label: a #GtkLabel
+ * @start: return location for start of selection, as a character offset
+ * @end: return location for end of selection, as a character offset
+ *
+ * Gets the selected range of characters in the label, returning %TRUE
+ * if there's a selection.
+ *
+ * Return value: %TRUE if selection is non-empty
+ **/
+gboolean
+gtk_label_get_selection_bounds (GtkLabel *label,
+ gint *start,
+ gint *end)
+{
+ g_return_val_if_fail (GTK_IS_LABEL (label), FALSE);
+
+ if (label->select_info == NULL)
+ {
+ /* not a selectable label */
+ if (start)
+ *start = 0;
+ if (end)
+ *end = 0;
+
+ return FALSE;
+ }
+ else
+ {
+ gint start_index, end_index;
+ gint start_offset, end_offset;
+ gint len;
+
+ start_index = MIN (label->select_info->selection_anchor,
+ label->select_info->selection_end);
+ end_index = MAX (label->select_info->selection_anchor,
+ label->select_info->selection_end);
+
+ len = strlen (label->text);
+
+ if (end_index > len)
+ end_index = len;
+
+ if (start_index > len)
+ start_index = len;
+
+ start_offset = g_utf8_strlen (label->text, start_index);
+ end_offset = g_utf8_strlen (label->text, end_index);
+
+ if (start_offset > end_offset)
+ {
+ gint tmp = start_offset;
+ start_offset = end_offset;
+ end_offset = tmp;
+ }
+
+ if (start)
+ *start = start_offset;
+
+ if (end)
+ *end = end_offset;
+
+ return start_offset != end_offset;
+ }
+}
+
+
+/**
+ * gtk_label_get_layout:
+ * @label: a #GtkLabel
+ *
+ * Gets the #PangoLayout used to display the label.
+ * The layout is useful to e.g. convert text positions to
+ * pixel positions, in combination with gtk_label_get_layout_offsets().
+ * The returned layout is owned by the label so need not be
+ * freed by the caller.
+ *
+ * Return value: the #PangoLayout for this label
+ **/
+PangoLayout*
+gtk_label_get_layout (GtkLabel *label)
+{
+ g_return_val_if_fail (GTK_IS_LABEL (label), NULL);
+
+ gtk_label_ensure_layout (label);
+
+ return label->layout;
+}
+
+/**
+ * gtk_label_get_layout_offsets:
+ * @label: a #GtkLabel
+ * @x: location to store X offset of layout, or %NULL
+ * @y: location to store Y offset of layout, or %NULL
+ *
+ * Obtains the coordinates where the label will draw the #PangoLayout
+ * representing the text in the label; useful to convert mouse events
+ * into coordinates inside the #PangoLayout, e.g. to take some action
+ * if some part of the label is clicked. Of course you will need to
+ * create a #GtkEventBox to receive the events, and pack the label
+ * inside it, since labels are a #GTK_NO_WINDOW widget. Remember
+ * when using the #PangoLayout functions you need to convert to
+ * and from pixels using PANGO_PIXELS() or #PANGO_SCALE.
+ *
+ **/
+void
+gtk_label_get_layout_offsets (GtkLabel *label,
+ gint *x,
+ gint *y)
+{
+ g_return_if_fail (GTK_IS_LABEL (label));
+
+ get_layout_location (label, x, y);
+}
+
+/**
+ * gtk_label_set_use_markup:
+ * @label: a #GtkLabel
+ * @setting: %TRUE if the label's text should be parsed for markup.
+ *
+ * Sets whether the text of the label contains markup in <link
+ * linkend="PangoMarkupFormat">Pango's text markup
+ * language</link>. See gtk_label_set_markup().
+ **/
+void
+gtk_label_set_use_markup (GtkLabel *label,
+ gboolean setting)
+{
+ g_return_if_fail (GTK_IS_LABEL (label));
+
+ gtk_label_set_use_markup_internal (label, setting);
+ gtk_label_recalculate (label);
+}
+
+/**
+ * gtk_label_get_use_markup:
+ * @label: a #GtkLabel
+ *
+ * Returns whether the label's text is interpreted as marked up with
+ * the <link linkend="PangoMarkupFormat">Pango text markup
+ * language</link>. See gtk_label_set_use_markup ().
+ *
+ * Return value: %TRUE if the label's text will be parsed for markup.
+ **/
+gboolean
+gtk_label_get_use_markup (GtkLabel *label)
+{
+ g_return_val_if_fail (GTK_IS_LABEL (label), FALSE);
+
+ return label->use_markup;
+}
+
+/**
+ * gtk_label_set_use_underline:
+ * @label: a #GtkLabel
+ * @setting: %TRUE if underlines in the text indicate mnemonics
+ *
+ * If true, an underline in the text indicates the next character should be
+ * used for the mnemonic accelerator key.
+ */
+void
+gtk_label_set_use_underline (GtkLabel *label,
+ gboolean setting)
+{
+ g_return_if_fail (GTK_IS_LABEL (label));
+
+ gtk_label_set_use_underline_internal (label, setting);
+ gtk_label_recalculate (label);
+ if (label->use_underline)
+ gtk_label_setup_mnemonic (label, label->mnemonic_keyval);
+}
+
+/**
+ * gtk_label_get_use_underline:
+ * @label: a #GtkLabel
+ *
+ * Returns whether an embedded underline in the label indicates a
+ * mnemonic. See gtk_label_set_use_underline ().
+ *
+ * Return value: %TRUE whether an embedded underline in the label indicates
+ * the mnemonic accelerator keys.
+ **/
+gboolean
+gtk_label_get_use_underline (GtkLabel *label)
+{
+ g_return_val_if_fail (GTK_IS_LABEL (label), FALSE);
+
+ return label->use_underline;
+}
+
+static gboolean
+gtk_label_focus (GtkWidget *widget,
+ GtkDirectionType direction)
+{
+ /* We never want to be in the tab chain */
+ return FALSE;
+}
+
+/* Compute the X position for an offset that corresponds to the "more important
+ * cursor position for that offset. We use this when trying to guess to which
+ * end of the selection we should go to when the user hits the left or
+ * right arrow key.
+ */
+static void
+get_better_cursor (GtkLabel *label,
+ gint index,
+ gint *x,
+ gint *y)
+{
+ GdkKeymap *keymap = gdk_keymap_get_for_display (gtk_widget_get_display (GTK_WIDGET (label)));
+ GtkTextDirection keymap_direction =
+ (gdk_keymap_get_direction (keymap) == PANGO_DIRECTION_LTR) ?
+ GTK_TEXT_DIR_LTR : GTK_TEXT_DIR_RTL;
+ GtkTextDirection widget_direction = gtk_widget_get_direction (GTK_WIDGET (label));
+ gboolean split_cursor;
+ PangoRectangle strong_pos, weak_pos;
+
+ g_object_get (gtk_widget_get_settings (GTK_WIDGET (label)),
+ "gtk-split-cursor", &split_cursor,
+ NULL);
+
+ gtk_label_ensure_layout (label);
+
+ pango_layout_get_cursor_pos (label->layout, index,
+ &strong_pos, &weak_pos);
+
+ if (split_cursor)
+ {
+ *x = strong_pos.x / PANGO_SCALE;
+ *y = strong_pos.y / PANGO_SCALE;
+ }
+ else
+ {
+ if (keymap_direction == widget_direction)
+ {
+ *x = strong_pos.x / PANGO_SCALE;
+ *y = strong_pos.y / PANGO_SCALE;
+ }
+ else
+ {
+ *x = weak_pos.x / PANGO_SCALE;
+ *y = weak_pos.y / PANGO_SCALE;
+ }
+ }
+}
+
+
+static gint
+gtk_label_move_logically (GtkLabel *label,
+ gint start,
+ gint count)
+{
+ gint offset = g_utf8_pointer_to_offset (label->text,
+ label->text + start);
+
+ if (label->text)
+ {
+ PangoLogAttr *log_attrs;
+ gint n_attrs;
+ gint length;
+
+ gtk_label_ensure_layout (label);
+
+ length = g_utf8_strlen (label->text, -1);
+
+ pango_layout_get_log_attrs (label->layout, &log_attrs, &n_attrs);
+
+ while (count > 0 && offset < length)
+ {
+ do
+ offset++;
+ while (offset < length && !log_attrs[offset].is_cursor_position);
+
+ count--;
+ }
+ while (count < 0 && offset > 0)
+ {
+ do
+ offset--;
+ while (offset > 0 && !log_attrs[offset].is_cursor_position);
+
+ count++;
+ }
+
+ g_free (log_attrs);
+ }
+
+ return g_utf8_offset_to_pointer (label->text, offset) - label->text;
+}
+
+static gint
+gtk_label_move_visually (GtkLabel *label,
+ gint start,
+ gint count)
+{
+ gint index;
+
+ index = start;
+
+ while (count != 0)
+ {
+ int new_index, new_trailing;
+ gboolean split_cursor;
+ gboolean strong;
+
+ gtk_label_ensure_layout (label);
+
+ g_object_get (gtk_widget_get_settings (GTK_WIDGET (label)),
+ "gtk-split-cursor", &split_cursor,
+ NULL);
+
+ if (split_cursor)
+ strong = TRUE;
+ else
+ {
+ GdkKeymap *keymap = gdk_keymap_get_for_display (gtk_widget_get_display (GTK_WIDGET (label)));
+ GtkTextDirection keymap_direction =
+ (gdk_keymap_get_direction (keymap) == PANGO_DIRECTION_LTR) ?
+ GTK_TEXT_DIR_LTR : GTK_TEXT_DIR_RTL;
+
+ strong = keymap_direction == gtk_widget_get_direction (GTK_WIDGET (label));
+ }
+
+ if (count > 0)
+ {
+ pango_layout_move_cursor_visually (label->layout, strong, index, 0, 1, &new_index, &new_trailing);
+ count--;
+ }
+ else
+ {
+ pango_layout_move_cursor_visually (label->layout, strong, index, 0, -1, &new_index, &new_trailing);
+ count++;
+ }
+
+ if (new_index < 0 || new_index == G_MAXINT)
+ break;
+
+ index = new_index;
+
+ while (new_trailing--)
+ index = g_utf8_next_char (label->text + new_index) - label->text;
+ }
+
+ return index;
+}
+
+static gint
+gtk_label_move_forward_word (GtkLabel *label,
+ gint start)
+{
+ gint new_pos = g_utf8_pointer_to_offset (label->text,
+ label->text + start);
+ gint length;
+
+ length = g_utf8_strlen (label->text, -1);
+ if (new_pos < length)
+ {
+ PangoLogAttr *log_attrs;
+ gint n_attrs;
+
+ gtk_label_ensure_layout (label);
+
+ pango_layout_get_log_attrs (label->layout, &log_attrs, &n_attrs);
+
+ /* Find the next word end */
+ new_pos++;
+ while (new_pos < n_attrs && !log_attrs[new_pos].is_word_end)
+ new_pos++;
+
+ g_free (log_attrs);
+ }
+
+ return g_utf8_offset_to_pointer (label->text, new_pos) - label->text;
+}
+
+
+static gint
+gtk_label_move_backward_word (GtkLabel *label,
+ gint start)