Pileus Git - ~andy/gtk/blob - gtk/gtklabel.c

   1 /* GTK - The GIMP Toolkit
   2  * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free
  16  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17  */
  18
  19 /*
  20  * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS
  21  * file for a list of people on the GTK+ Team.  See the ChangeLog
  22  * files for a list of changes.  These files are distributed with
  23  * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
  24  */
  25
  26 #include "config.h"
  27
  28 #include <math.h>
  29 #include <string.h>
  30
  31 #include "gtklabel.h"
  32 #include "gtkaccellabel.h"
  33 #include "gtkdnd.h"
  34 #include "gtkmainprivate.h"
  35 #include "gtkmarshalers.h"
  36 #include "gtkpango.h"
  37 #include "gtkwindow.h"
  38 #include "gtkclipboard.h"
  39 #include "gtkimagemenuitem.h"
  40 #include "gtkintl.h"
  41 #include "gtkseparatormenuitem.h"
  42 #include "gtktextutil.h"
  43 #include "gtkmenuitem.h"
  44 #include "gtkmenushellprivate.h"
  45 #include "gtknotebook.h"
  46 #include "gtkstock.h"
  47 #include "gtkbindings.h"
  48 #include "gtkbuildable.h"
  49 #include "gtkimage.h"
  50 #include "gtkshow.h"
  51 #include "gtktooltip.h"
  52 #include "gtkprivate.h"
  53 #include "gtktypebuiltins.h"
  54
  55
  56 /**
  57  * SECTION:gtklabel
  58  * @Short_description: A widget that displays a small to medium amount of text
  59  * @Title: GtkLabel
  60  *
  61  * The #GtkLabel widget displays a small amount of text. As the name
  62  * implies, most labels are used to label another widget such as a
  63  * #GtkButton, a #GtkMenuItem, or a #GtkOptionMenu.
  64  *
  65  * <refsect2 id="GtkLabel-BUILDER-UI">
  66  * <title>GtkLabel as GtkBuildable</title>
  67  * <para>
  68  * The GtkLabel implementation of the GtkBuildable interface supports a
  69  * custom &lt;attributes&gt; element, which supports any number of &lt;attribute&gt;
  70  * elements. the &lt;attribute&gt; element has attributes named name, value,
  71  * start and end and allows you to specify #PangoAttribute values for this label.
  72  *
  73  * <example>
  74  * <title>A UI definition fragment specifying Pango attributes</title>
  75  * <programlisting><![CDATA[
  76  * <object class="GtkLabel">
  77  *   <attributes>
  78  *     <attribute name="weight" value="PANGO_WEIGHT_BOLD"/>
  79  *     <attribute name="background" value="red" start="5" end="10"/>"
  80  *   </attributes>
  81  * </object>
  82  * ]]></programlisting>
  83  * </example>
  84  * The start and end attributes specify the range of characters to which the
  85  * Pango attribute applies. If start and end are not specified, the attribute is
  86  * applied to the whole text. Note that specifying ranges does not make much
  87  * sense with translatable attributes. Use markup embedded in the translatable
  88  * content instead.
  89  * </para>
  90  * </refsect2>
  91  * <refsect2>
  92  * <title>Mnemonics</title>
  93  * <para>
  94  * Labels may contain <firstterm>mnemonics</firstterm>. Mnemonics are
  95  * underlined characters in the label, used for keyboard navigation.
  96  * Mnemonics are created by providing a string with an underscore before
  97  * the mnemonic character, such as <literal>"_File"</literal>, to the
  98  * functions gtk_label_new_with_mnemonic() or
  99  * gtk_label_set_text_with_mnemonic().
 100  *
 101  * Mnemonics automatically activate any activatable widget the label is
 102  * inside, such as a #GtkButton; if the label is not inside the
 103  * mnemonic's target widget, you have to tell the label about the target
 104  * using gtk_label_set_mnemonic_widget(). Here's a simple example where
 105  * the label is inside a button:
 106  *
 107  * <informalexample>
 108  * <programlisting>
 109  *   // Pressing Alt+H will activate this button
 110  *   button = gtk_button_new (<!-- -->);
 111  *   label = gtk_label_new_with_mnemonic ("_Hello");
 112  *   gtk_container_add (GTK_CONTAINER (button), label);
 113  * </programlisting>
 114  * </informalexample>
 115  *
 116  * There's a convenience function to create buttons with a mnemonic label
 117  * already inside:
 118  *
 119  * <informalexample>
 120  * <programlisting>
 121  *   // Pressing Alt+H will activate this button
 122  *   button = gtk_button_new_with_mnemonic ("_Hello");
 123  * </programlisting>
 124  * </informalexample>
 125  *
 126  * To create a mnemonic for a widget alongside the label, such as a
 127  * #GtkEntry, you have to point the label at the entry with
 128  * gtk_label_set_mnemonic_widget():
 129  *
 130  * <informalexample>
 131  * <programlisting>
 132  *   // Pressing Alt+H will focus the entry
 133  *   entry = gtk_entry_new (<!-- -->);
 134  *   label = gtk_label_new_with_mnemonic ("_Hello");
 135  *   gtk_label_set_mnemonic_widget (GTK_LABEL (label), entry);
 136  * </programlisting>
 137  * </informalexample>
 138  * </para>
 139  * </refsect2>
 140  * <refsect2>
 141  * <title>Markup (styled text)</title>
 142  * <para>
 143  * To make it easy to format text in a label (changing colors, fonts,
 144  * etc.), label text can be provided in a simple <link
 145  * linkend="PangoMarkupFormat">markup format</link>.
 146  * Here's how to create a label with a small font:
 147  *
 148  * <informalexample>
 149  * <programlisting>
 150  *   label = gtk_label_new (NULL);
 151  *   gtk_label_set_markup (GTK_LABEL (label), "<small>Small text</small>");
 152  * </programlisting>
 153  * </informalexample>
 154  *
 155  * (See <link
 156  * linkend="PangoMarkupFormat">complete documentation</link> of available
 157  * tags in the Pango manual.)
 158  *
 159  * The markup passed to gtk_label_set_markup() must be valid; for example,
 160  * literal &lt;, &gt; and &amp; characters must be escaped as \&lt;,
 161  * \gt;, and \&amp;. If you pass text obtained from the user, file,
 162  * or a network to gtk_label_set_markup(), you'll want to escape it with
 163  * g_markup_escape_text() or g_markup_printf_escaped().
 164  *
 165  * Markup strings are just a convenient way to set the #PangoAttrList on
 166  * a label; gtk_label_set_attributes() may be a simpler way to set
 167  * attributes in some cases. Be careful though; #PangoAttrList tends to
 168  * cause internationalization problems, unless you're applying attributes
 169  * to the entire string (i.e. unless you set the range of each attribute
 170  * to [0, %G_MAXINT)). The reason is that specifying the start_index and
 171  * end_index for a #PangoAttribute requires knowledge of the exact string
 172  * being displayed, so translations will cause problems.
 173  * </para>
 174  * </refsect2>
 175  * <refsect2>
 176  * <title>Selectable labels</title>
 177  * Labels can be made selectable with gtk_label_set_selectable().
 178  * Selectable labels allow the user to copy the label contents to
 179  * the clipboard. Only labels that contain useful-to-copy information
 180  * &mdash; such as error messages &mdash; should be made selectable.
 181  * </refsect2>
 182  * <refsect2 id="label-text-layout">
 183  * <title>Text layout</title>
 184  * <para>
 185  * A label can contain any number of paragraphs, but will have
 186  * performance problems if it contains more than a small number.
 187  * Paragraphs are separated by newlines or other paragraph separators
 188  * understood by Pango.
 189  *
 190  * Labels can automatically wrap text if you call
 191  * gtk_label_set_line_wrap().
 192  *
 193  * gtk_label_set_justify() sets how the lines in a label align
 194  * with one another. If you want to set how the label as a whole
 195  * aligns in its available space, see gtk_misc_set_alignment().
 196  *
 197  * The #GtkLabel:width-chars and #GtkLabel:max-width-chars properties
 198  * can be used to control the size allocation of ellipsized or wrapped
 199  * labels. For ellipsizing labels, if either is specified (and less
 200  * than the actual text size), it is used as the minimum width, and the actual
 201  * text size is used as the natural width of the label. For wrapping labels,
 202  * width-chars is used as the minimum width, if specified, and max-width-chars
 203  * is used as the natural width. Even if max-width-chars specified, wrapping
 204  * labels will be rewrapped to use all of the available width.
 205  *
 206  * <note><para>
 207  * Note that the interpretation of #GtkLabel:width-chars and
 208  * #GtkLabel:max-width-chars has changed a bit with the introduction of
 209  * <link linkend="geometry-management">width-for-height geometry management.</link>
 210  * </para></note>
 211  * </para>
 212  * </refsect2>
 213  * <refsect2>
 214  * <title>Links</title>
 215  * <para>
 216  * Since 2.18, GTK+ supports markup for clickable hyperlinks in addition
 217  * to regular Pango markup. The markup for links is borrowed from HTML, using the
 218  * <tag>a</tag> with href and title attributes. GTK+ renders links similar to the
 219  * way they appear in web browsers, with colored, underlined text. The title
 220  * attribute is displayed as a tooltip on the link. An example looks like this:
 221  *
 222  * <informalexample><programlisting>
 223  * gtk_label_set_markup (label, "Go to the <a href="http://www.gtk.org" title="&lt;i&gt;Our&lt;/i&gt; website">GTK+ website</a> for more...");
 224  * </programlisting></informalexample>
 225  *
 226  * It is possible to implement custom handling for links and their tooltips with
 227  * the #GtkLabel::activate-link signal and the gtk_label_get_current_uri() function.
 228  * </para>
 229  * </refsect2>
 230  */
 231
 232
 233 /*rint() is only available in GCC and/or C99*/
 234 #if (__STDC_VERSION__ < 199901L && !defined __GNUC__)
 235 double rint(double x)
 236 {
 237         if (ceil(x+0.5) == floor(x+0.5))
 238         {
 239                 int a = (int)ceil(x);
 240                 if (a%2 == 0)
 241                         return ceil(x);
 242                 else
 243                         return floor(x);
 244         }
 245         else
 246                 return floor(x+0.5);
 247 }
 248 #endif
 249
 250
 251
 252 struct _GtkLabelPrivate
 253 {
 254   GtkLabelSelectionInfo *select_info;
 255   GtkWidget *mnemonic_widget;
 256   GtkWindow *mnemonic_window;
 257
 258   PangoAttrList *attrs;
 259   PangoAttrList *effective_attrs;
 260   PangoLayout   *layout;
 261
 262   gchar   *label;
 263   gchar   *text;
 264
 265   gdouble  angle;
 266
 267   guint     mnemonics_visible : 1;
 268   guint    jtype              : 2;
 269   guint    wrap               : 1;
 270   guint    use_underline      : 1;
 271   guint    use_markup         : 1;
 272   guint    ellipsize          : 3;
 273   guint    single_line_mode   : 1;
 274   guint    have_transform     : 1;
 275   guint    in_click           : 1;
 276   guint    wrap_mode          : 3;
 277   guint    pattern_set        : 1;
 278   guint    track_links        : 1;
 279
 280   guint    mnemonic_keyval;
 281
 282   gint     width_chars;
 283   gint     max_width_chars;
 284 };
 285
 286 /* Notes about the handling of links:
 287  *
 288  * Links share the GtkLabelSelectionInfo struct with selectable labels.
 289  * There are some new fields for links. The links field contains the list
 290  * of GtkLabelLink structs that describe the links which are embedded in
 291  * the label. The active_link field points to the link under the mouse
 292  * pointer. For keyboard navigation, the 'focus' link is determined by
 293  * finding the link which contains the selection_anchor position.
 294  * The link_clicked field is used with button press and release events
 295  * to ensure that pressing inside a link and releasing outside of it
 296  * does not activate the link.
 297  *
 298  * Links are rendered with the link-color/visited-link-color colors
 299  * that are determined by the style and with an underline. When the mouse
 300  * pointer is over a link, the pointer is changed to indicate the link,
 301  * and the background behind the link is rendered with the base[PRELIGHT]
 302  * color. While a button is pressed over a link, the background is rendered
 303  * with the base[ACTIVE] color.
 304  *
 305  * Labels with links accept keyboard focus, and it is possible to move
 306  * the focus between the embedded links using Tab/Shift-Tab. The focus
 307  * is indicated by a focus rectangle that is drawn around the link text.
 308  * Pressing Enter activates the focussed link, and there is a suitable
 309  * context menu for links that can be opened with the Menu key. Pressing
 310  * Control-C copies the link URI to the clipboard.
 311  *
 312  * In selectable labels with links, link functionality is only available
 313  * when the selection is empty.
 314  */
 315 typedef struct
 316 {
 317   gchar *uri;
 318   gchar *title;     /* the title attribute, used as tooltip */
 319   gboolean visited; /* get set when the link is activated; this flag
 320                      * gets preserved over later set_markup() calls
 321                      */
 322   gint start;       /* position of the link in the PangoLayout */
 323   gint end;
 324 } GtkLabelLink;
 325
 326 struct _GtkLabelSelectionInfo
 327 {
 328   GdkWindow *window;
 329   gint selection_anchor;
 330   gint selection_end;
 331   GtkWidget *popup_menu;
 332
 333   GList *links;
 334   GtkLabelLink *active_link;
 335
 336   gint drag_start_x;
 337   gint drag_start_y;
 338
 339   guint in_drag      : 1;
 340   guint select_words : 1;
 341   guint selectable   : 1;
 342   guint link_clicked : 1;
 343 };
 344
 345 enum {
 346   MOVE_CURSOR,
 347   COPY_CLIPBOARD,
 348   POPULATE_POPUP,
 349   ACTIVATE_LINK,
 350   ACTIVATE_CURRENT_LINK,
 351   LAST_SIGNAL
 352 };
 353
 354 enum {
 355   PROP_0,
 356   PROP_LABEL,
 357   PROP_ATTRIBUTES,
 358   PROP_USE_MARKUP,
 359   PROP_USE_UNDERLINE,
 360   PROP_JUSTIFY,
 361   PROP_PATTERN,
 362   PROP_WRAP,
 363   PROP_WRAP_MODE,
 364   PROP_SELECTABLE,
 365   PROP_MNEMONIC_KEYVAL,
 366   PROP_MNEMONIC_WIDGET,
 367   PROP_CURSOR_POSITION,
 368   PROP_SELECTION_BOUND,
 369   PROP_ELLIPSIZE,
 370   PROP_WIDTH_CHARS,
 371   PROP_SINGLE_LINE_MODE,
 372   PROP_ANGLE,
 373   PROP_MAX_WIDTH_CHARS,
 374   PROP_TRACK_VISITED_LINKS
 375 };
 376
 377 /* When rotating ellipsizable text we want the natural size to request
 378  * more to ensure the label wont ever ellipsize in an allocation of full natural size.
 379  * */
 380 #define ROTATION_ELLIPSIZE_PADDING 2
 381
 382 static guint signals[LAST_SIGNAL] = { 0 };
 383
 384 static const GdkColor default_link_color = { 0, 0, 0, 0xeeee };
 385 static const GdkColor default_visited_link_color = { 0, 0x5555, 0x1a1a, 0x8b8b };
 386
 387 static void gtk_label_set_property      (GObject          *object,
 388                                          guint             prop_id,
 389                                          const GValue     *value,
 390                                          GParamSpec       *pspec);
 391 static void gtk_label_get_property      (GObject          *object,
 392                                          guint             prop_id,
 393                                          GValue           *value,
 394                                          GParamSpec       *pspec);
 395 static void gtk_label_finalize          (GObject          *object);
 396 static void gtk_label_destroy           (GtkWidget        *widget);
 397 static void gtk_label_size_allocate     (GtkWidget        *widget,
 398                                          GtkAllocation    *allocation);
 399 static void gtk_label_state_changed     (GtkWidget        *widget,
 400                                          GtkStateType      state);
 401 static void gtk_label_style_updated     (GtkWidget        *widget);
 402 static void gtk_label_direction_changed (GtkWidget        *widget,
 403                                          GtkTextDirection  previous_dir);
 404 static gint gtk_label_draw              (GtkWidget        *widget,
 405                                          cairo_t          *cr);
 406 static gboolean gtk_label_focus         (GtkWidget         *widget,
 407                                          GtkDirectionType   direction);
 408
 409 static void gtk_label_realize           (GtkWidget        *widget);
 410 static void gtk_label_unrealize         (GtkWidget        *widget);
 411 static void gtk_label_map               (GtkWidget        *widget);
 412 static void gtk_label_unmap             (GtkWidget        *widget);
 413
 414 static gboolean gtk_label_button_press      (GtkWidget        *widget,
 415                                              GdkEventButton   *event);
 416 static gboolean gtk_label_button_release    (GtkWidget        *widget,
 417                                              GdkEventButton   *event);
 418 static gboolean gtk_label_motion            (GtkWidget        *widget,
 419                                              GdkEventMotion   *event);
 420 static gboolean gtk_label_leave_notify      (GtkWidget        *widget,
 421                                              GdkEventCrossing *event);
 422
 423 static void     gtk_label_grab_focus        (GtkWidget        *widget);
 424
 425 static gboolean gtk_label_query_tooltip     (GtkWidget        *widget,
 426                                              gint              x,
 427                                              gint              y,
 428                                              gboolean          keyboard_tip,
 429                                              GtkTooltip       *tooltip);
 430
 431 static void gtk_label_set_text_internal          (GtkLabel      *label,
 432                                                   gchar         *str);
 433 static void gtk_label_set_label_internal         (GtkLabel      *label,
 434                                                   gchar         *str);
 435 static void gtk_label_set_use_markup_internal    (GtkLabel      *label,
 436                                                   gboolean       val);
 437 static void gtk_label_set_use_underline_internal (GtkLabel      *label,
 438                                                   gboolean       val);
 439 static void gtk_label_set_attributes_internal    (GtkLabel      *label,
 440                                                   PangoAttrList *attrs);
 441 static void gtk_label_set_uline_text_internal    (GtkLabel      *label,
 442                                                   const gchar   *str);
 443 static void gtk_label_set_pattern_internal       (GtkLabel      *label,
 444                                                   const gchar   *pattern,
 445                                                   gboolean       is_mnemonic);
 446 static void gtk_label_set_markup_internal        (GtkLabel      *label,
 447                                                   const gchar   *str,
 448                                                   gboolean       with_uline);
 449 static void gtk_label_recalculate                (GtkLabel      *label);
 450 static void gtk_label_hierarchy_changed          (GtkWidget     *widget,
 451                                                   GtkWidget     *old_toplevel);
 452 static void gtk_label_screen_changed             (GtkWidget     *widget,
 453                                                   GdkScreen     *old_screen);
 454 static gboolean gtk_label_popup_menu             (GtkWidget     *widget);
 455
 456 static void gtk_label_create_window       (GtkLabel *label);
 457 static void gtk_label_destroy_window      (GtkLabel *label);
 458 static void gtk_label_ensure_select_info  (GtkLabel *label);
 459 static void gtk_label_clear_select_info   (GtkLabel *label);
 460 static void gtk_label_update_cursor       (GtkLabel *label);
 461 static void gtk_label_clear_layout        (GtkLabel *label);
 462 static void gtk_label_ensure_layout       (GtkLabel *label);
 463 static void gtk_label_select_region_index (GtkLabel *label,
 464                                            gint      anchor_index,
 465                                            gint      end_index);
 466
 467 static gboolean gtk_label_mnemonic_activate (GtkWidget         *widget,
 468                                              gboolean           group_cycling);
 469 static void     gtk_label_setup_mnemonic    (GtkLabel          *label,
 470                                              guint              last_key);
 471 static void     gtk_label_drag_data_get     (GtkWidget         *widget,
 472                                              GdkDragContext    *context,
 473                                              GtkSelectionData  *selection_data,
 474                                              guint              info,
 475                                              guint              time);
 476
 477 static void     gtk_label_buildable_interface_init     (GtkBuildableIface *iface);
 478 static gboolean gtk_label_buildable_custom_tag_start   (GtkBuildable     *buildable,
 479                                                         GtkBuilder       *builder,
 480                                                         GObject          *child,
 481                                                         const gchar      *tagname,
 482                                                         GMarkupParser    *parser,
 483                                                         gpointer         *data);
 484
 485 static void     gtk_label_buildable_custom_finished    (GtkBuildable     *buildable,
 486                                                         GtkBuilder       *builder,
 487                                                         GObject          *child,
 488                                                         const gchar      *tagname,
 489                                                         gpointer          user_data);
 490
 491
 492 static void connect_mnemonics_visible_notify    (GtkLabel   *label);
 493 static gboolean      separate_uline_pattern     (const gchar  *str,
 494                                                  guint        *accel_key,
 495                                                  gchar       **new_str,
 496                                                  gchar       **pattern);
 497
 498
 499 /* For selectable labels: */
 500 static void gtk_label_move_cursor        (GtkLabel        *label,
 501                                           GtkMovementStep  step,
 502                                           gint             count,
 503                                           gboolean         extend_selection);
 504 static void gtk_label_copy_clipboard     (GtkLabel        *label);
 505 static void gtk_label_select_all         (GtkLabel        *label);
 506 static void gtk_label_do_popup           (GtkLabel        *label,
 507                                           GdkEventButton  *event);
 508 static gint gtk_label_move_forward_word  (GtkLabel        *label,
 509                                           gint             start);
 510 static gint gtk_label_move_backward_word (GtkLabel        *label,
 511                                           gint             start);
 512
 513 /* For links: */
 514 static void          gtk_label_rescan_links     (GtkLabel  *label);
 515 static void          gtk_label_clear_links      (GtkLabel  *label);
 516 static gboolean      gtk_label_activate_link    (GtkLabel    *label,
 517                                                  const gchar *uri);
 518 static void          gtk_label_activate_current_link (GtkLabel *label);
 519 static GtkLabelLink *gtk_label_get_current_link (GtkLabel  *label);
 520 static void          gtk_label_get_link_colors  (GtkWidget  *widget,
 521                                                  GdkColor  **link_color,
 522                                                  GdkColor  **visited_link_color);
 523 static void          emit_activate_link         (GtkLabel     *label,
 524                                                  GtkLabelLink *link);
 525
 526 static GtkSizeRequestMode gtk_label_get_request_mode                (GtkWidget           *widget);
 527 static void               gtk_label_get_preferred_width             (GtkWidget           *widget,
 528                                                                      gint                *minimum_size,
 529                                                                      gint                *natural_size);
 530 static void               gtk_label_get_preferred_height            (GtkWidget           *widget,
 531                                                                      gint                *minimum_size,
 532                                                                      gint                *natural_size);
 533 static void               gtk_label_get_preferred_width_for_height  (GtkWidget           *widget,
 534                                                                      gint                 height,
 535                                                                      gint                *minimum_width,
 536                                                                      gint                *natural_width);
 537 static void               gtk_label_get_preferred_height_for_width  (GtkWidget           *widget,
 538                                                                      gint                 width,
 539                                                                      gint                *minimum_height,
 540                                                                      gint                *natural_height);
 541
 542 static GtkBuildableIface *buildable_parent_iface = NULL;
 543
 544 G_DEFINE_TYPE_WITH_CODE (GtkLabel, gtk_label, GTK_TYPE_MISC,
 545                          G_IMPLEMENT_INTERFACE (GTK_TYPE_BUILDABLE,
 546                                                 gtk_label_buildable_interface_init))
 547
 548 static void
 549 add_move_binding (GtkBindingSet  *binding_set,
 550                   guint           keyval,
 551                   guint           modmask,
 552                   GtkMovementStep step,
 553                   gint            count)
 554 {
 555   g_return_if_fail ((modmask & GDK_SHIFT_MASK) == 0);
 556
 557   gtk_binding_entry_add_signal (binding_set, keyval, modmask,
 558                                 "move-cursor", 3,
 559                                 G_TYPE_ENUM, step,
 560                                 G_TYPE_INT, count,
 561                                 G_TYPE_BOOLEAN, FALSE);
 562
 563   /* Selection-extending version */
 564   gtk_binding_entry_add_signal (binding_set, keyval, modmask | GDK_SHIFT_MASK,
 565                                 "move-cursor", 3,
 566                                 G_TYPE_ENUM, step,
 567                                 G_TYPE_INT, count,
 568                                 G_TYPE_BOOLEAN, TRUE);
 569 }
 570
 571 static void
 572 gtk_label_class_init (GtkLabelClass *class)
 573 {
 574   GObjectClass *gobject_class = G_OBJECT_CLASS (class);
 575   GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (class);
 576   GtkBindingSet *binding_set;
 577
 578   gobject_class->set_property = gtk_label_set_property;
 579   gobject_class->get_property = gtk_label_get_property;
 580   gobject_class->finalize = gtk_label_finalize;
 581
 582   widget_class->destroy = gtk_label_destroy;
 583   widget_class->size_allocate = gtk_label_size_allocate;
 584   widget_class->state_changed = gtk_label_state_changed;
 585   widget_class->style_updated = gtk_label_style_updated;
 586   widget_class->query_tooltip = gtk_label_query_tooltip;
 587   widget_class->direction_changed = gtk_label_direction_changed;
 588   widget_class->draw = gtk_label_draw;
 589   widget_class->realize = gtk_label_realize;
 590   widget_class->unrealize = gtk_label_unrealize;
 591   widget_class->map = gtk_label_map;
 592   widget_class->unmap = gtk_label_unmap;
 593   widget_class->button_press_event = gtk_label_button_press;
 594   widget_class->button_release_event = gtk_label_button_release;
 595   widget_class->motion_notify_event = gtk_label_motion;
 596   widget_class->leave_notify_event = gtk_label_leave_notify;
 597   widget_class->hierarchy_changed = gtk_label_hierarchy_changed;
 598   widget_class->screen_changed = gtk_label_screen_changed;
 599   widget_class->mnemonic_activate = gtk_label_mnemonic_activate;
 600   widget_class->drag_data_get = gtk_label_drag_data_get;
 601   widget_class->grab_focus = gtk_label_grab_focus;
 602   widget_class->popup_menu = gtk_label_popup_menu;
 603   widget_class->focus = gtk_label_focus;
 604   widget_class->get_request_mode = gtk_label_get_request_mode;
 605   widget_class->get_preferred_width = gtk_label_get_preferred_width;
 606   widget_class->get_preferred_height = gtk_label_get_preferred_height;
 607   widget_class->get_preferred_width_for_height = gtk_label_get_preferred_width_for_height;
 608   widget_class->get_preferred_height_for_width = gtk_label_get_preferred_height_for_width;
 609
 610   class->move_cursor = gtk_label_move_cursor;
 611   class->copy_clipboard = gtk_label_copy_clipboard;
 612   class->activate_link = gtk_label_activate_link;
 613
 614   /**
 615    * GtkLabel::move-cursor:
 616    * @entry: the object which received the signal
 617    * @step: the granularity of the move, as a #GtkMovementStep
 618    * @count: the number of @step units to move
 619    * @extend_selection: %TRUE if the move should extend the selection
 620    *
 621    * The ::move-cursor signal is a
 622    * <link linkend="keybinding-signals">keybinding signal</link>
 623    * which gets emitted when the user initiates a cursor movement.
 624    * If the cursor is not visible in @entry, this signal causes
 625    * the viewport to be moved instead.
 626    *
 627    * Applications should not connect to it, but may emit it with
 628    * g_signal_emit_by_name() if they need to control the cursor
 629    * programmatically.
 630    *
 631    * The default bindings for this signal come in two variants,
 632    * the variant with the Shift modifier extends the selection,
 633    * the variant without the Shift modifer does not.
 634    * There are too many key combinations to list them all here.
 635    * <itemizedlist>
 636    * <listitem>Arrow keys move by individual characters/lines</listitem>
 637    * <listitem>Ctrl-arrow key combinations move by words/paragraphs</listitem>
 638    * <listitem>Home/End keys move to the ends of the buffer</listitem>
 639    * </itemizedlist>
 640    */
 641   signals[MOVE_CURSOR] =
 642     g_signal_new (I_("move-cursor"),
 643                   G_OBJECT_CLASS_TYPE (gobject_class),
 644                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
 645                   G_STRUCT_OFFSET (GtkLabelClass, move_cursor),
 646                   NULL, NULL,
 647                   _gtk_marshal_VOID__ENUM_INT_BOOLEAN,
 648                   G_TYPE_NONE, 3,
 649                   GTK_TYPE_MOVEMENT_STEP,
 650                   G_TYPE_INT,
 651                   G_TYPE_BOOLEAN);
 652
 653    /**
 654    * GtkLabel::copy-clipboard:
 655    * @label: the object which received the signal
 656    *
 657    * The ::copy-clipboard signal is a
 658    * <link linkend="keybinding-signals">keybinding signal</link>
 659    * which gets emitted to copy the selection to the clipboard.
 660    *
 661    * The default binding for this signal is Ctrl-c.
 662    */
 663   signals[COPY_CLIPBOARD] =
 664     g_signal_new (I_("copy-clipboard"),
 665                   G_OBJECT_CLASS_TYPE (gobject_class),
 666                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
 667                   G_STRUCT_OFFSET (GtkLabelClass, copy_clipboard),
 668                   NULL, NULL,
 669                   _gtk_marshal_VOID__VOID,
 670                   G_TYPE_NONE, 0);
 671
 672   /**
 673    * GtkLabel::populate-popup:
 674    * @label: The label on which the signal is emitted
 675    * @menu: the menu that is being populated
 676    *
 677    * The ::populate-popup signal gets emitted before showing the
 678    * context menu of the label. Note that only selectable labels
 679    * have context menus.
 680    *
 681    * If you need to add items to the context menu, connect
 682    * to this signal and append your menuitems to the @menu.
 683    */
 684   signals[POPULATE_POPUP] =
 685     g_signal_new (I_("populate-popup"),
 686                   G_OBJECT_CLASS_TYPE (gobject_class),
 687                   G_SIGNAL_RUN_LAST,
 688                   G_STRUCT_OFFSET (GtkLabelClass, populate_popup),
 689                   NULL, NULL,
 690                   _gtk_marshal_VOID__OBJECT,
 691                   G_TYPE_NONE, 1,
 692                   GTK_TYPE_MENU);
 693
 694     /**
 695      * GtkLabel::activate-current-link:
 696      * @label: The label on which the signal was emitted
 697      *
 698      * A <link linkend="keybinding-signals">keybinding signal</link>
 699      * which gets emitted when the user activates a link in the label.
 700      *
 701      * Applications may also emit the signal with g_signal_emit_by_name()
 702      * if they need to control activation of URIs programmatically.
 703      *
 704      * The default bindings for this signal are all forms of the Enter key.
 705      *
 706      * Since: 2.18
 707      */
 708     signals[ACTIVATE_CURRENT_LINK] =
 709       g_signal_new_class_handler ("activate-current-link",
 710                                   G_TYPE_FROM_CLASS (gobject_class),
 711                                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
 712                                   G_CALLBACK (gtk_label_activate_current_link),
 713                                   NULL, NULL,
 714                                   _gtk_marshal_VOID__VOID,
 715                                   G_TYPE_NONE, 0);
 716
 717     /**
 718      * GtkLabel::activate-link:
 719      * @label: The label on which the signal was emitted
 720      * @uri: the URI that is activated
 721      *
 722      * The signal which gets emitted to activate a URI.
 723      * Applications may connect to it to override the default behaviour,
 724      * which is to call gtk_show_uri().
 725      *
 726      * Returns: %TRUE if the link has been activated
 727      *
 728      * Since: 2.18
 729      */
 730     signals[ACTIVATE_LINK] =
 731       g_signal_new ("activate-link",
 732                     G_TYPE_FROM_CLASS (gobject_class),
 733                     G_SIGNAL_RUN_LAST,
 734                     G_STRUCT_OFFSET (GtkLabelClass, activate_link),
 735                     _gtk_boolean_handled_accumulator, NULL,
 736                     _gtk_marshal_BOOLEAN__STRING,
 737                     G_TYPE_BOOLEAN, 1, G_TYPE_STRING);
 738
 739   g_object_class_install_property (gobject_class,
 740                                    PROP_LABEL,
 741                                    g_param_spec_string ("label",
 742                                                         P_("Label"),
 743                                                         P_("The text of the label"),
 744                                                         "",
 745                                                         GTK_PARAM_READWRITE));
 746   g_object_class_install_property (gobject_class,
 747                                    PROP_ATTRIBUTES,
 748                                    g_param_spec_boxed ("attributes",
 749                                                        P_("Attributes"),
 750                                                        P_("A list of style attributes to apply to the text of the label"),
 751                                                        PANGO_TYPE_ATTR_LIST,
 752                                                        GTK_PARAM_READWRITE));
 753   g_object_class_install_property (gobject_class,
 754                                    PROP_USE_MARKUP,
 755                                    g_param_spec_boolean ("use-markup",
 756                                                          P_("Use markup"),
 757                                                          P_("The text of the label includes XML markup. See pango_parse_markup()"),
 758                                                         FALSE,
 759                                                         GTK_PARAM_READWRITE));
 760   g_object_class_install_property (gobject_class,
 761                                    PROP_USE_UNDERLINE,
 762                                    g_param_spec_boolean ("use-underline",
 763                                                          P_("Use underline"),
 764                                                          P_("If set, an underline in the text indicates the next character should be used for the mnemonic accelerator key"),
 765                                                         FALSE,
 766                                                         GTK_PARAM_READWRITE));
 767
 768   g_object_class_install_property (gobject_class,
 769                                    PROP_JUSTIFY,
 770                                    g_param_spec_enum ("justify",
 771                                                       P_("Justification"),
 772                                                       P_("The alignment of the lines in the text of the label relative to each other. This does NOT affect the alignment of the label within its allocation. See GtkMisc::xalign for that"),
 773                                                       GTK_TYPE_JUSTIFICATION,
 774                                                       GTK_JUSTIFY_LEFT,
 775                                                       GTK_PARAM_READWRITE));
 776
 777   g_object_class_install_property (gobject_class,
 778                                    PROP_PATTERN,
 779                                    g_param_spec_string ("pattern",
 780                                                         P_("Pattern"),
 781                                                         P_("A string with _ characters in positions correspond to characters in the text to underline"),
 782                                                         NULL,
 783                                                         GTK_PARAM_WRITABLE));
 784
 785   g_object_class_install_property (gobject_class,
 786                                    PROP_WRAP,
 787                                    g_param_spec_boolean ("wrap",
 788                                                         P_("Line wrap"),
 789                                                         P_("If set, wrap lines if the text becomes too wide"),
 790                                                         FALSE,
 791                                                         GTK_PARAM_READWRITE));
 792   /**
 793    * GtkLabel:wrap-mode:
 794    *
 795    * If line wrapping is on (see the #GtkLabel:wrap property) this controls
 796    * how the line wrapping is done. The default is %PANGO_WRAP_WORD, which
 797    * means wrap on word boundaries.
 798    *
 799    * Since: 2.10
 800    */
 801   g_object_class_install_property (gobject_class,
 802                                    PROP_WRAP_MODE,
 803                                    g_param_spec_enum ("wrap-mode",
 804                                                       P_("Line wrap mode"),
 805                                                       P_("If wrap is set, controls how linewrapping is done"),
 806                                                       PANGO_TYPE_WRAP_MODE,
 807                                                       PANGO_WRAP_WORD,
 808                                                       GTK_PARAM_READWRITE));
 809   g_object_class_install_property (gobject_class,
 810                                    PROP_SELECTABLE,
 811                                    g_param_spec_boolean ("selectable",
 812                                                         P_("Selectable"),
 813                                                         P_("Whether the label text can be selected with the mouse"),
 814                                                         FALSE,
 815                                                         GTK_PARAM_READWRITE));
 816   g_object_class_install_property (gobject_class,
 817                                    PROP_MNEMONIC_KEYVAL,
 818                                    g_param_spec_uint ("mnemonic-keyval",
 819                                                       P_("Mnemonic key"),
 820                                                       P_("The mnemonic accelerator key for this label"),
 821                                                       0,
 822                                                       G_MAXUINT,
 823                                                       GDK_KEY_VoidSymbol,
 824                                                       GTK_PARAM_READABLE));
 825   g_object_class_install_property (gobject_class,
 826                                    PROP_MNEMONIC_WIDGET,
 827                                    g_param_spec_object ("mnemonic-widget",
 828                                                         P_("Mnemonic widget"),
 829                                                         P_("The widget to be activated when the label's mnemonic "
 830                                                           "key is pressed"),
 831                                                         GTK_TYPE_WIDGET,
 832                                                         GTK_PARAM_READWRITE));
 833
 834   g_object_class_install_property (gobject_class,
 835                                    PROP_CURSOR_POSITION,
 836                                    g_param_spec_int ("cursor-position",
 837                                                      P_("Cursor Position"),
 838                                                      P_("The current position of the insertion cursor in chars"),
 839                                                      0,
 840                                                      G_MAXINT,
 841                                                      0,
 842                                                      GTK_PARAM_READABLE));
 843
 844   g_object_class_install_property (gobject_class,
 845                                    PROP_SELECTION_BOUND,
 846                                    g_param_spec_int ("selection-bound",
 847                                                      P_("Selection Bound"),
 848                                                      P_("The position of the opposite end of the selection from the cursor in chars"),
 849                                                      0,
 850                                                      G_MAXINT,
 851                                                      0,
 852                                                      GTK_PARAM_READABLE));
 853
 854   /**
 855    * GtkLabel:ellipsize:
 856    *
 857    * The preferred place to ellipsize the string, if the label does
 858    * not have enough room to display the entire string, specified as a
 859    * #PangoEllisizeMode.
 860    *
 861    * Note that setting this property to a value other than
 862    * %PANGO_ELLIPSIZE_NONE has the side-effect that the label requests
 863    * only enough space to display the ellipsis "...". In particular, this
 864    * means that ellipsizing labels do not work well in notebook tabs, unless
 865    * the tab's #GtkNotebook:tab-expand property is set to %TRUE. Other ways
 866    * to set a label's width are gtk_widget_set_size_request() and
 867    * gtk_label_set_width_chars().
 868    *
 869    * Since: 2.6
 870    */
 871   g_object_class_install_property (gobject_class,
 872                                    PROP_ELLIPSIZE,
 873                                    g_param_spec_enum ("ellipsize",
 874                                                       P_("Ellipsize"),
 875                                                       P_("The preferred place to ellipsize the string, if the label does not have enough room to display the entire string"),
 876                                                       PANGO_TYPE_ELLIPSIZE_MODE,
 877                                                       PANGO_ELLIPSIZE_NONE,
 878                                                       GTK_PARAM_READWRITE));
 879
 880   /**
 881    * GtkLabel:width-chars:
 882    *
 883    * The desired width of the label, in characters. If this property is set to
 884    * -1, the width will be calculated automatically.
 885    *
 886    * See the section on <link linkend="label-text-layout">text layout</link>
 887    * for details of how #GtkLabel:width-chars and #GtkLabel:max-width-chars
 888    * determine the width of ellipsized and wrapped labels.
 889    *
 890    * Since: 2.6
 891    **/
 892   g_object_class_install_property (gobject_class,
 893                                    PROP_WIDTH_CHARS,
 894                                    g_param_spec_int ("width-chars",
 895                                                      P_("Width In Characters"),
 896                                                      P_("The desired width of the label, in characters"),
 897                                                      -1,
 898                                                      G_MAXINT,
 899                                                      -1,
 900                                                      GTK_PARAM_READWRITE));
 901
 902   /**
 903    * GtkLabel:single-line-mode:
 904    *
 905    * Whether the label is in single line mode. In single line mode,
 906    * the height of the label does not depend on the actual text, it
 907    * is always set to ascent + descent of the font. This can be an
 908    * advantage in situations where resizing the label because of text
 909    * changes would be distracting, e.g. in a statusbar.
 910    *
 911    * Since: 2.6
 912    **/
 913   g_object_class_install_property (gobject_class,
 914                                    PROP_SINGLE_LINE_MODE,
 915                                    g_param_spec_boolean ("single-line-mode",
 916                                                         P_("Single Line Mode"),
 917                                                         P_("Whether the label is in single line mode"),
 918                                                         FALSE,
 919                                                         GTK_PARAM_READWRITE));
 920
 921   /**
 922    * GtkLabel:angle:
 923    *
 924    * The angle that the baseline of the label makes with the horizontal,
 925    * in degrees, measured counterclockwise. An angle of 90 reads from
 926    * from bottom to top, an angle of 270, from top to bottom. Ignored
 927    * if the label is selectable, wrapped, or ellipsized.
 928    *
 929    * Since: 2.6
 930    **/
 931   g_object_class_install_property (gobject_class,
 932                                    PROP_ANGLE,
 933                                    g_param_spec_double ("angle",
 934                                                         P_("Angle"),
 935                                                         P_("Angle at which the label is rotated"),
 936                                                         0.0,
 937                                                         360.0,
 938                                                         0.0,
 939                                                         GTK_PARAM_READWRITE));
 940
 941   /**
 942    * GtkLabel:max-width-chars:
 943    *
 944    * The desired maximum width of the label, in characters. If this property
 945    * is set to -1, the width will be calculated automatically.
 946    *
 947    * See the section on <link linkend="label-text-layout">text layout</link>
 948    * for details of how #GtkLabel:width-chars and #GtkLabel:max-width-chars
 949    * determine the width of ellipsized and wrapped labels.
 950    *
 951    * Since: 2.6
 952    **/
 953   g_object_class_install_property (gobject_class,
 954                                    PROP_MAX_WIDTH_CHARS,
 955                                    g_param_spec_int ("max-width-chars",
 956                                                      P_("Maximum Width In Characters"),
 957                                                      P_("The desired maximum width of the label, in characters"),
 958                                                      -1,
 959                                                      G_MAXINT,
 960                                                      -1,
 961                                                      GTK_PARAM_READWRITE));
 962
 963   /**
 964    * GtkLabel:track-visited-links:
 965    *
 966    * Set this property to %TRUE to make the label track which links
 967    * have been clicked. It will then apply the ::visited-link-color
 968    * color, instead of ::link-color.
 969    *
 970    * Since: 2.18
 971    */
 972   g_object_class_install_property (gobject_class,
 973                                    PROP_TRACK_VISITED_LINKS,
 974                                    g_param_spec_boolean ("track-visited-links",
 975                                                          P_("Track visited links"),
 976                                                          P_("Whether visited links should be tracked"),
 977                                                          TRUE,
 978                                                          GTK_PARAM_READWRITE));
 979   /*
 980    * Key bindings
 981    */
 982
 983   binding_set = gtk_binding_set_by_class (class);
 984
 985   /* Moving the insertion point */
 986   add_move_binding (binding_set, GDK_KEY_Right, 0,
 987                     GTK_MOVEMENT_VISUAL_POSITIONS, 1);
 988
 989   add_move_binding (binding_set, GDK_KEY_Left, 0,
 990                     GTK_MOVEMENT_VISUAL_POSITIONS, -1);
 991
 992   add_move_binding (binding_set, GDK_KEY_KP_Right, 0,
 993                     GTK_MOVEMENT_VISUAL_POSITIONS, 1);
 994
 995   add_move_binding (binding_set, GDK_KEY_KP_Left, 0,
 996                     GTK_MOVEMENT_VISUAL_POSITIONS, -1);
 997
 998   add_move_binding (binding_set, GDK_KEY_f, GDK_CONTROL_MASK,
 999                     GTK_MOVEMENT_LOGICAL_POSITIONS, 1);
1000
1001   add_move_binding (binding_set, GDK_KEY_b, GDK_CONTROL_MASK,
1002                     GTK_MOVEMENT_LOGICAL_POSITIONS, -1);
1003
1004   add_move_binding (binding_set, GDK_KEY_Right, GDK_CONTROL_MASK,
1005                     GTK_MOVEMENT_WORDS, 1);
1006
1007   add_move_binding (binding_set, GDK_KEY_Left, GDK_CONTROL_MASK,
1008                     GTK_MOVEMENT_WORDS, -1);
1009
1010   add_move_binding (binding_set, GDK_KEY_KP_Right, GDK_CONTROL_MASK,
1011                     GTK_MOVEMENT_WORDS, 1);
1012
1013   add_move_binding (binding_set, GDK_KEY_KP_Left, GDK_CONTROL_MASK,
1014                     GTK_MOVEMENT_WORDS, -1);
1015
1016   /* select all */
1017   gtk_binding_entry_add_signal (binding_set, GDK_KEY_a, GDK_CONTROL_MASK,
1018                                 "move-cursor", 3,
1019                                 G_TYPE_ENUM, GTK_MOVEMENT_PARAGRAPH_ENDS,
1020                                 G_TYPE_INT, -1,
1021                                 G_TYPE_BOOLEAN, FALSE);
1022
1023   gtk_binding_entry_add_signal (binding_set, GDK_KEY_a, GDK_CONTROL_MASK,
1024                                 "move-cursor", 3,
1025                                 G_TYPE_ENUM, GTK_MOVEMENT_PARAGRAPH_ENDS,
1026                                 G_TYPE_INT, 1,
1027                                 G_TYPE_BOOLEAN, TRUE);
1028
1029   gtk_binding_entry_add_signal (binding_set, GDK_KEY_slash, GDK_CONTROL_MASK,
1030                                 "move-cursor", 3,
1031                                 G_TYPE_ENUM, GTK_MOVEMENT_PARAGRAPH_ENDS,
1032                                 G_TYPE_INT, -1,
1033                                 G_TYPE_BOOLEAN, FALSE);
1034
1035   gtk_binding_entry_add_signal (binding_set, GDK_KEY_slash, GDK_CONTROL_MASK,
1036                                 "move-cursor", 3,
1037                                 G_TYPE_ENUM, GTK_MOVEMENT_PARAGRAPH_ENDS,
1038                                 G_TYPE_INT, 1,
1039                                 G_TYPE_BOOLEAN, TRUE);
1040
1041   /* unselect all */
1042   gtk_binding_entry_add_signal (binding_set, GDK_KEY_a, GDK_SHIFT_MASK | GDK_CONTROL_MASK,
1043                                 "move-cursor", 3,
1044                                 G_TYPE_ENUM, GTK_MOVEMENT_PARAGRAPH_ENDS,
1045                                 G_TYPE_INT, 0,
1046                                 G_TYPE_BOOLEAN, FALSE);
1047
1048   gtk_binding_entry_add_signal (binding_set, GDK_KEY_backslash, GDK_CONTROL_MASK,
1049                                 "move-cursor", 3,
1050                                 G_TYPE_ENUM, GTK_MOVEMENT_PARAGRAPH_ENDS,
1051                                 G_TYPE_INT, 0,
1052                                 G_TYPE_BOOLEAN, FALSE);
1053
1054   add_move_binding (binding_set, GDK_KEY_f, GDK_MOD1_MASK,
1055                     GTK_MOVEMENT_WORDS, 1);
1056
1057   add_move_binding (binding_set, GDK_KEY_b, GDK_MOD1_MASK,
1058                     GTK_MOVEMENT_WORDS, -1);
1059
1060   add_move_binding (binding_set, GDK_KEY_Home, 0,
1061                     GTK_MOVEMENT_DISPLAY_LINE_ENDS, -1);
1062
1063   add_move_binding (binding_set, GDK_KEY_End, 0,
1064                     GTK_MOVEMENT_DISPLAY_LINE_ENDS, 1);
1065
1066   add_move_binding (binding_set, GDK_KEY_KP_Home, 0,
1067                     GTK_MOVEMENT_DISPLAY_LINE_ENDS, -1);
1068
1069   add_move_binding (binding_set, GDK_KEY_KP_End, 0,
1070                     GTK_MOVEMENT_DISPLAY_LINE_ENDS, 1);
1071
1072   add_move_binding (binding_set, GDK_KEY_Home, GDK_CONTROL_MASK,
1073                     GTK_MOVEMENT_BUFFER_ENDS, -1);
1074
1075   add_move_binding (binding_set, GDK_KEY_End, GDK_CONTROL_MASK,
1076                     GTK_MOVEMENT_BUFFER_ENDS, 1);
1077
1078   add_move_binding (binding_set, GDK_KEY_KP_Home, GDK_CONTROL_MASK,
1079                     GTK_MOVEMENT_BUFFER_ENDS, -1);
1080
1081   add_move_binding (binding_set, GDK_KEY_KP_End, GDK_CONTROL_MASK,
1082                     GTK_MOVEMENT_BUFFER_ENDS, 1);
1083
1084   /* copy */
1085   gtk_binding_entry_add_signal (binding_set, GDK_KEY_c, GDK_CONTROL_MASK,
1086                                 "copy-clipboard", 0);
1087
1088   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Return, 0,
1089                                 "activate-current-link", 0);
1090   gtk_binding_entry_add_signal (binding_set, GDK_KEY_ISO_Enter, 0,
1091                                 "activate-current-link", 0);
1092   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Enter, 0,
1093                                 "activate-current-link", 0);
1094
1095   g_type_class_add_private (class, sizeof (GtkLabelPrivate));
1096 }
1097
1098 static void
1099 gtk_label_set_property (GObject      *object,
1100                         guint         prop_id,
1101                         const GValue *value,
1102                         GParamSpec   *pspec)
1103 {
1104   GtkLabel *label = GTK_LABEL (object);
1105
1106   switch (prop_id)
1107     {
1108     case PROP_LABEL:
1109       gtk_label_set_label (label, g_value_get_string (value));
1110       break;
1111     case PROP_ATTRIBUTES:
1112       gtk_label_set_attributes (label, g_value_get_boxed (value));
1113       break;
1114     case PROP_USE_MARKUP:
1115       gtk_label_set_use_markup (label, g_value_get_boolean (value));
1116       break;
1117     case PROP_USE_UNDERLINE:
1118       gtk_label_set_use_underline (label, g_value_get_boolean (value));
1119       break;
1120     case PROP_JUSTIFY:
1121       gtk_label_set_justify (label, g_value_get_enum (value));
1122       break;
1123     case PROP_PATTERN:
1124       gtk_label_set_pattern (label, g_value_get_string (value));
1125       break;
1126     case PROP_WRAP:
1127       gtk_label_set_line_wrap (label, g_value_get_boolean (value));
1128       break;
1129     case PROP_WRAP_MODE:
1130       gtk_label_set_line_wrap_mode (label, g_value_get_enum (value));
1131       break;
1132     case PROP_SELECTABLE:
1133       gtk_label_set_selectable (label, g_value_get_boolean (value));
1134       break;
1135     case PROP_MNEMONIC_WIDGET:
1136       gtk_label_set_mnemonic_widget (label, (GtkWidget*) g_value_get_object (value));
1137       break;
1138     case PROP_ELLIPSIZE:
1139       gtk_label_set_ellipsize (label, g_value_get_enum (value));
1140       break;
1141     case PROP_WIDTH_CHARS:
1142       gtk_label_set_width_chars (label, g_value_get_int (value));
1143       break;
1144     case PROP_SINGLE_LINE_MODE:
1145       gtk_label_set_single_line_mode (label, g_value_get_boolean (value));
1146       break;
1147     case PROP_ANGLE:
1148       gtk_label_set_angle (label, g_value_get_double (value));
1149       break;
1150     case PROP_MAX_WIDTH_CHARS:
1151       gtk_label_set_max_width_chars (label, g_value_get_int (value));
1152       break;
1153     case PROP_TRACK_VISITED_LINKS:
1154       gtk_label_set_track_visited_links (label, g_value_get_boolean (value));
1155       break;
1156     default:
1157       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1158       break;
1159     }
1160 }
1161
1162 static void
1163 gtk_label_get_property (GObject     *object,
1164                         guint        prop_id,
1165                         GValue      *value,
1166                         GParamSpec  *pspec)
1167 {
1168   GtkLabel *label = GTK_LABEL (object);
1169   GtkLabelPrivate *priv = label->priv;
1170
1171   switch (prop_id)
1172     {
1173     case PROP_LABEL:
1174       g_value_set_string (value, priv->label);
1175       break;
1176     case PROP_ATTRIBUTES:
1177       g_value_set_boxed (value, priv->attrs);
1178       break;
1179     case PROP_USE_MARKUP:
1180       g_value_set_boolean (value, priv->use_markup);
1181       break;
1182     case PROP_USE_UNDERLINE:
1183       g_value_set_boolean (value, priv->use_underline);
1184       break;
1185     case PROP_JUSTIFY:
1186       g_value_set_enum (value, priv->jtype);
1187       break;
1188     case PROP_WRAP:
1189       g_value_set_boolean (value, priv->wrap);
1190       break;
1191     case PROP_WRAP_MODE:
1192       g_value_set_enum (value, priv->wrap_mode);
1193       break;
1194     case PROP_SELECTABLE:
1195       g_value_set_boolean (value, gtk_label_get_selectable (label));
1196       break;
1197     case PROP_MNEMONIC_KEYVAL:
1198       g_value_set_uint (value, priv->mnemonic_keyval);
1199       break;
1200     case PROP_MNEMONIC_WIDGET:
1201       g_value_set_object (value, (GObject*) priv->mnemonic_widget);
1202       break;
1203     case PROP_CURSOR_POSITION:
1204       if (priv->select_info && priv->select_info->selectable)
1205         {
1206           gint offset = g_utf8_pointer_to_offset (priv->text,
1207                                                   priv->text + priv->select_info->selection_end);
1208           g_value_set_int (value, offset);
1209         }
1210       else
1211         g_value_set_int (value, 0);
1212       break;
1213     case PROP_SELECTION_BOUND:
1214       if (priv->select_info && priv->select_info->selectable)
1215         {
1216           gint offset = g_utf8_pointer_to_offset (priv->text,
1217                                                   priv->text + priv->select_info->selection_anchor);
1218           g_value_set_int (value, offset);
1219         }
1220       else
1221         g_value_set_int (value, 0);
1222       break;
1223     case PROP_ELLIPSIZE:
1224       g_value_set_enum (value, priv->ellipsize);
1225       break;
1226     case PROP_WIDTH_CHARS:
1227       g_value_set_int (value, gtk_label_get_width_chars (label));
1228       break;
1229     case PROP_SINGLE_LINE_MODE:
1230       g_value_set_boolean (value, gtk_label_get_single_line_mode (label));
1231       break;
1232     case PROP_ANGLE:
1233       g_value_set_double (value, gtk_label_get_angle (label));
1234       break;
1235     case PROP_MAX_WIDTH_CHARS:
1236       g_value_set_int (value, gtk_label_get_max_width_chars (label));
1237       break;
1238     case PROP_TRACK_VISITED_LINKS:
1239       g_value_set_boolean (value, gtk_label_get_track_visited_links (label));
1240       break;
1241     default:
1242       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
1243       break;
1244     }
1245 }
1246
1247 static void
1248 gtk_label_init (GtkLabel *label)
1249 {
1250   GtkLabelPrivate *priv;
1251
1252   label->priv = G_TYPE_INSTANCE_GET_PRIVATE (label,
1253                                              GTK_TYPE_LABEL,
1254                                              GtkLabelPrivate);
1255   priv = label->priv;
1256
1257   gtk_widget_set_has_window (GTK_WIDGET (label), FALSE);
1258
1259   priv->width_chars = -1;
1260   priv->max_width_chars = -1;
1261   priv->label = NULL;
1262
1263   priv->jtype = GTK_JUSTIFY_LEFT;
1264   priv->wrap = FALSE;
1265   priv->wrap_mode = PANGO_WRAP_WORD;
1266   priv->ellipsize = PANGO_ELLIPSIZE_NONE;
1267
1268   priv->use_underline = FALSE;
1269   priv->use_markup = FALSE;
1270   priv->pattern_set = FALSE;
1271   priv->track_links = TRUE;
1272
1273   priv->mnemonic_keyval = GDK_KEY_VoidSymbol;
1274   priv->layout = NULL;
1275   priv->text = NULL;
1276   priv->attrs = NULL;
1277
1278   priv->mnemonic_widget = NULL;
1279   priv->mnemonic_window = NULL;
1280
1281   priv->mnemonics_visible = TRUE;
1282
1283   gtk_label_set_text (label, "");
1284 }
1285
1286
1287 static void
1288 gtk_label_buildable_interface_init (GtkBuildableIface *iface)
1289 {
1290   buildable_parent_iface = g_type_interface_peek_parent (iface);
1291
1292   iface->custom_tag_start = gtk_label_buildable_custom_tag_start;
1293   iface->custom_finished = gtk_label_buildable_custom_finished;
1294 }
1295
1296 typedef struct {
1297   GtkBuilder    *builder;
1298   GObject       *object;
1299   PangoAttrList *attrs;
1300 } PangoParserData;
1301
1302 static PangoAttribute *
1303 attribute_from_text (GtkBuilder   *builder,
1304                      const gchar  *name,
1305                      const gchar  *value,
1306                      GError      **error)
1307 {
1308   PangoAttribute *attribute = NULL;
1309   PangoAttrType   type;
1310   PangoLanguage  *language;
1311   PangoFontDescription *font_desc;
1312   GdkColor       *color;
1313   GValue          val = { 0, };
1314
1315   if (!gtk_builder_value_from_string_type (builder, PANGO_TYPE_ATTR_TYPE, name, &val, error))
1316     return NULL;
1317
1318   type = g_value_get_enum (&val);
1319   g_value_unset (&val);
1320
1321   switch (type)
1322     {
1323       /* PangoAttrLanguage */
1324     case PANGO_ATTR_LANGUAGE:
1325       if ((language = pango_language_from_string (value)))
1326         {
1327           attribute = pango_attr_language_new (language);
1328           g_value_init (&val, G_TYPE_INT);
1329         }
1330       break;
1331       /* PangoAttrInt */
1332     case PANGO_ATTR_STYLE:
1333       if (gtk_builder_value_from_string_type (builder, PANGO_TYPE_STYLE, value, &val, error))
1334         attribute = pango_attr_style_new (g_value_get_enum (&val));
1335       break;
1336     case PANGO_ATTR_WEIGHT:
1337       if (gtk_builder_value_from_string_type (builder, PANGO_TYPE_WEIGHT, value, &val, error))
1338         attribute = pango_attr_weight_new (g_value_get_enum (&val));
1339       break;
1340     case PANGO_ATTR_VARIANT:
1341       if (gtk_builder_value_from_string_type (builder, PANGO_TYPE_VARIANT, value, &val, error))
1342         attribute = pango_attr_variant_new (g_value_get_enum (&val));
1343       break;
1344     case PANGO_ATTR_STRETCH:
1345       if (gtk_builder_value_from_string_type (builder, PANGO_TYPE_STRETCH, value, &val, error))
1346         attribute = pango_attr_stretch_new (g_value_get_enum (&val));
1347       break;
1348     case PANGO_ATTR_UNDERLINE:
1349       if (gtk_builder_value_from_string_type (builder, G_TYPE_BOOLEAN, value, &val, error))
1350         attribute = pango_attr_underline_new (g_value_get_boolean (&val));
1351       break;
1352     case PANGO_ATTR_STRIKETHROUGH:
1353       if (gtk_builder_value_from_string_type (builder, G_TYPE_BOOLEAN, value, &val, error))
1354         attribute = pango_attr_strikethrough_new (g_value_get_boolean (&val));
1355       break;
1356     case PANGO_ATTR_GRAVITY:
1357       if (gtk_builder_value_from_string_type (builder, PANGO_TYPE_GRAVITY, value, &val, error))
1358         attribute = pango_attr_gravity_new (g_value_get_enum (&val));
1359       break;
1360     case PANGO_ATTR_GRAVITY_HINT:
1361       if (gtk_builder_value_from_string_type (builder, PANGO_TYPE_GRAVITY_HINT,
1362                                               value, &val, error))
1363         attribute = pango_attr_gravity_hint_new (g_value_get_enum (&val));
1364       break;
1365       /* PangoAttrString */
1366     case PANGO_ATTR_FAMILY:
1367       attribute = pango_attr_family_new (value);
1368       g_value_init (&val, G_TYPE_INT);
1369       break;
1370
1371       /* PangoAttrSize */
1372     case PANGO_ATTR_SIZE:
1373       if (gtk_builder_value_from_string_type (builder, G_TYPE_INT,
1374                                               value, &val, error))
1375         attribute = pango_attr_size_new (g_value_get_int (&val));
1376       break;
1377     case PANGO_ATTR_ABSOLUTE_SIZE:
1378       if (gtk_builder_value_from_string_type (builder, G_TYPE_INT,
1379                                               value, &val, error))
1380         attribute = pango_attr_size_new_absolute (g_value_get_int (&val));
1381       break;
1382
1383       /* PangoAttrFontDesc */
1384     case PANGO_ATTR_FONT_DESC:
1385       if ((font_desc = pango_font_description_from_string (value)))
1386         {
1387           attribute = pango_attr_font_desc_new (font_desc);
1388           pango_font_description_free (font_desc);
1389           g_value_init (&val, G_TYPE_INT);
1390         }
1391       break;
1392
1393       /* PangoAttrColor */
1394     case PANGO_ATTR_FOREGROUND:
1395       if (gtk_builder_value_from_string_type (builder, GDK_TYPE_COLOR,
1396                                               value, &val, error))
1397         {
1398           color = g_value_get_boxed (&val);
1399           attribute = pango_attr_foreground_new (color->red, color->green, color->blue);
1400         }
1401       break;
1402     case PANGO_ATTR_BACKGROUND:
1403       if (gtk_builder_value_from_string_type (builder, GDK_TYPE_COLOR,
1404                                               value, &val, error))
1405         {
1406           color = g_value_get_boxed (&val);
1407           attribute = pango_attr_background_new (color->red, color->green, color->blue);
1408         }
1409       break;
1410     case PANGO_ATTR_UNDERLINE_COLOR:
1411       if (gtk_builder_value_from_string_type (builder, GDK_TYPE_COLOR,
1412                                               value, &val, error))
1413         {
1414           color = g_value_get_boxed (&val);
1415           attribute = pango_attr_underline_color_new (color->red, color->green, color->blue);
1416         }
1417       break;
1418     case PANGO_ATTR_STRIKETHROUGH_COLOR:
1419       if (gtk_builder_value_from_string_type (builder, GDK_TYPE_COLOR,
1420                                               value, &val, error))
1421         {
1422           color = g_value_get_boxed (&val);
1423           attribute = pango_attr_strikethrough_color_new (color->red, color->green, color->blue);
1424         }
1425       break;
1426
1427       /* PangoAttrShape */
1428     case PANGO_ATTR_SHAPE:
1429       /* Unsupported for now */
1430       break;
1431       /* PangoAttrFloat */
1432     case PANGO_ATTR_SCALE:
1433       if (gtk_builder_value_from_string_type (builder, G_TYPE_DOUBLE,
1434                                               value, &val, error))
1435         attribute = pango_attr_scale_new (g_value_get_double (&val));
1436       break;
1437
1438     case PANGO_ATTR_INVALID:
1439     case PANGO_ATTR_LETTER_SPACING:
1440     case PANGO_ATTR_RISE:
1441     case PANGO_ATTR_FALLBACK:
1442     default:
1443       break;
1444     }
1445
1446   g_value_unset (&val);
1447
1448   return attribute;
1449 }
1450
1451
1452 static void
1453 pango_start_element (GMarkupParseContext *context,
1454                      const gchar         *element_name,
1455                      const gchar        **names,
1456                      const gchar        **values,
1457                      gpointer             user_data,
1458                      GError             **error)
1459 {
1460   PangoParserData *data = (PangoParserData*)user_data;
1461   GValue val = { 0, };
1462   guint i;
1463   gint line_number, char_number;
1464
1465   if (strcmp (element_name, "attribute") == 0)
1466     {
1467       PangoAttribute *attr = NULL;
1468       const gchar *name = NULL;
1469       const gchar *value = NULL;
1470       const gchar *start = NULL;
1471       const gchar *end = NULL;
1472       guint start_val = 0;
1473       guint end_val   = G_MAXUINT;
1474
1475       for (i = 0; names[i]; i++)
1476         {
1477           if (strcmp (names[i], "name") == 0)
1478             name = values[i];
1479           else if (strcmp (names[i], "value") == 0)
1480             value = values[i];
1481           else if (strcmp (names[i], "start") == 0)
1482             start = values[i];
1483           else if (strcmp (names[i], "end") == 0)
1484             end = values[i];
1485           else
1486             {
1487               g_markup_parse_context_get_position (context,
1488                                                    &line_number,
1489                                                    &char_number);
1490               g_set_error (error,
1491                            GTK_BUILDER_ERROR,
1492                            GTK_BUILDER_ERROR_INVALID_ATTRIBUTE,
1493                            "%s:%d:%d '%s' is not a valid attribute of <%s>",
1494                            "<input>",
1495                            line_number, char_number, names[i], "attribute");
1496               return;
1497             }
1498         }
1499
1500       if (!name || !value)
1501         {
1502           g_markup_parse_context_get_position (context,
1503                                                &line_number,
1504                                                &char_number);
1505           g_set_error (error,
1506                        GTK_BUILDER_ERROR,
1507                        GTK_BUILDER_ERROR_MISSING_ATTRIBUTE,
1508                        "%s:%d:%d <%s> requires attribute \"%s\"",
1509                        "<input>",
1510                        line_number, char_number, "attribute",
1511                        name ? "value" : "name");
1512           return;
1513         }
1514
1515       if (start)
1516         {
1517           if (!gtk_builder_value_from_string_type (data->builder, G_TYPE_UINT,
1518                                                    start, &val, error))
1519             return;
1520           start_val = g_value_get_uint (&val);
1521           g_value_unset (&val);
1522         }
1523
1524       if (end)
1525         {
1526           if (!gtk_builder_value_from_string_type (data->builder, G_TYPE_UINT,
1527                                                    end, &val, error))
1528             return;
1529           end_val = g_value_get_uint (&val);
1530           g_value_unset (&val);
1531         }
1532
1533       attr = attribute_from_text (data->builder, name, value, error);
1534       attr->start_index = start_val;
1535       attr->end_index   = end_val;
1536
1537       if (attr)
1538         {
1539           if (!data->attrs)
1540             data->attrs = pango_attr_list_new ();
1541
1542           pango_attr_list_insert (data->attrs, attr);
1543         }
1544     }
1545   else if (strcmp (element_name, "attributes") == 0)
1546     ;
1547   else
1548     g_warning ("Unsupported tag for GtkLabel: %s\n", element_name);
1549 }
1550
1551 static const GMarkupParser pango_parser =
1552   {
1553     pango_start_element,
1554   };
1555
1556 static gboolean
1557 gtk_label_buildable_custom_tag_start (GtkBuildable     *buildable,
1558                                       GtkBuilder       *builder,
1559                                       GObject          *child,
1560                                       const gchar      *tagname,
1561                                       GMarkupParser    *parser,
1562                                       gpointer         *data)
1563 {
1564   if (buildable_parent_iface->custom_tag_start (buildable, builder, child,
1565                                                 tagname, parser, data))
1566     return TRUE;
1567
1568   if (strcmp (tagname, "attributes") == 0)
1569     {
1570       PangoParserData *parser_data;
1571
1572       parser_data = g_slice_new0 (PangoParserData);
1573       parser_data->builder = g_object_ref (builder);
1574       parser_data->object = g_object_ref (buildable);
1575       *parser = pango_parser;
1576       *data = parser_data;
1577       return TRUE;
1578     }
1579   return FALSE;
1580 }
1581
1582 static void
1583 gtk_label_buildable_custom_finished (GtkBuildable *buildable,
1584                                      GtkBuilder   *builder,
1585                                      GObject      *child,
1586                                      const gchar  *tagname,
1587                                      gpointer      user_data)
1588 {
1589   PangoParserData *data;
1590
1591   buildable_parent_iface->custom_finished (buildable, builder, child,
1592                                            tagname, user_data);
1593
1594   if (strcmp (tagname, "attributes") == 0)
1595     {
1596       data = (PangoParserData*)user_data;
1597
1598       if (data->attrs)
1599         {
1600           gtk_label_set_attributes (GTK_LABEL (buildable), data->attrs);
1601           pango_attr_list_unref (data->attrs);
1602         }
1603
1604       g_object_unref (data->object);
1605       g_object_unref (data->builder);
1606       g_slice_free (PangoParserData, data);
1607     }
1608 }
1609
1610
1611 /**
1612  * gtk_label_new:
1613  * @str: The text of the label
1614  *
1615  * Creates a new label with the given text inside it. You can
1616  * pass %NULL to get an empty label widget.
1617  *
1618  * Return value: the new #GtkLabel
1619  **/
1620 GtkWidget*
1621 gtk_label_new (const gchar *str)
1622 {
1623   GtkLabel *label;
1624
1625   label = g_object_new (GTK_TYPE_LABEL, NULL);
1626
1627   if (str && *str)
1628     gtk_label_set_text (label, str);
1629
1630   return GTK_WIDGET (label);
1631 }
1632
1633 /**
1634  * gtk_label_new_with_mnemonic:
1635  * @str: The text of the label, with an underscore in front of the
1636  *       mnemonic character
1637  *
1638  * Creates a new #GtkLabel, containing the text in @str.
1639  *
1640  * If characters in @str are preceded by an underscore, they are
1641  * underlined. If you need a literal underscore character in a label, use
1642  * '__' (two underscores). The first underlined character represents a
1643  * keyboard accelerator called a mnemonic. The mnemonic key can be used
1644  * to activate another widget, chosen automatically, or explicitly using
1645  * gtk_label_set_mnemonic_widget().
1646  *
1647  * If gtk_label_set_mnemonic_widget() is not called, then the first
1648  * activatable ancestor of the #GtkLabel will be chosen as the mnemonic
1649  * widget. For instance, if the label is inside a button or menu item,
1650  * the button or menu item will automatically become the mnemonic widget
1651  * and be activated by the mnemonic.
1652  *
1653  * Return value: the new #GtkLabel
1654  **/
1655 GtkWidget*
1656 gtk_label_new_with_mnemonic (const gchar *str)
1657 {
1658   GtkLabel *label;
1659
1660   label = g_object_new (GTK_TYPE_LABEL, NULL);
1661
1662   if (str && *str)
1663     gtk_label_set_text_with_mnemonic (label, str);
1664
1665   return GTK_WIDGET (label);
1666 }
1667
1668 static gboolean
1669 gtk_label_mnemonic_activate (GtkWidget *widget,
1670                              gboolean   group_cycling)
1671 {
1672   GtkLabel *label = GTK_LABEL (widget);
1673   GtkLabelPrivate *priv = label->priv;
1674   GtkWidget *parent;
1675
1676   if (priv->mnemonic_widget)
1677     return gtk_widget_mnemonic_activate (priv->mnemonic_widget, group_cycling);
1678
1679   /* Try to find the widget to activate by traversing the
1680    * widget's ancestry.
1681    */
1682   parent = gtk_widget_get_parent (widget);
1683
1684   if (GTK_IS_NOTEBOOK (parent))
1685     return FALSE;
1686
1687   while (parent)
1688     {
1689       if (gtk_widget_get_can_focus (parent) ||
1690           (!group_cycling && GTK_WIDGET_GET_CLASS (parent)->activate_signal) ||
1691           GTK_IS_NOTEBOOK (gtk_widget_get_parent (parent)) ||
1692           GTK_IS_MENU_ITEM (parent))
1693         return gtk_widget_mnemonic_activate (parent, group_cycling);
1694       parent = gtk_widget_get_parent (parent);
1695     }
1696
1697   /* barf if there was nothing to activate */
1698   g_warning ("Couldn't find a target for a mnemonic activation.");
1699   gtk_widget_error_bell (widget);
1700
1701   return FALSE;
1702 }
1703
1704 static void
1705 gtk_label_setup_mnemonic (GtkLabel *label,
1706                           guint     last_key)
1707 {
1708   GtkLabelPrivate *priv = label->priv;
1709   GtkWidget *widget = GTK_WIDGET (label);
1710   GtkWidget *toplevel;
1711   GtkWidget *mnemonic_menu;
1712
1713   mnemonic_menu = g_object_get_data (G_OBJECT (label), "gtk-mnemonic-menu");
1714
1715   if (last_key != GDK_KEY_VoidSymbol)
1716     {
1717       if (priv->mnemonic_window)
1718         {
1719           gtk_window_remove_mnemonic  (priv->mnemonic_window,
1720                                        last_key,
1721                                        widget);
1722           priv->mnemonic_window = NULL;
1723         }
1724       if (mnemonic_menu)
1725         {
1726           _gtk_menu_shell_remove_mnemonic (GTK_MENU_SHELL (mnemonic_menu),
1727                                            last_key,
1728                                            widget);
1729           mnemonic_menu = NULL;
1730         }
1731     }
1732
1733   if (priv->mnemonic_keyval == GDK_KEY_VoidSymbol)
1734       goto done;
1735
1736   connect_mnemonics_visible_notify (GTK_LABEL (widget));
1737
1738   toplevel = gtk_widget_get_toplevel (widget);
1739   if (gtk_widget_is_toplevel (toplevel))
1740     {
1741       GtkWidget *menu_shell;
1742
1743       menu_shell = gtk_widget_get_ancestor (widget,
1744                                             GTK_TYPE_MENU_SHELL);
1745
1746       if (menu_shell)
1747         {
1748           _gtk_menu_shell_add_mnemonic (GTK_MENU_SHELL (menu_shell),
1749                                         priv->mnemonic_keyval,
1750                                         widget);
1751           mnemonic_menu = menu_shell;
1752         }
1753
1754       if (!GTK_IS_MENU (menu_shell))
1755         {
1756           gtk_window_add_mnemonic (GTK_WINDOW (toplevel),
1757                                    priv->mnemonic_keyval,
1758                                    widget);
1759           priv->mnemonic_window = GTK_WINDOW (toplevel);
1760         }
1761     }
1762
1763  done:
1764   g_object_set_data (G_OBJECT (label), I_("gtk-mnemonic-menu"), mnemonic_menu);
1765 }
1766
1767 static void
1768 gtk_label_hierarchy_changed (GtkWidget *widget,
1769                              GtkWidget *old_toplevel)
1770 {
1771   GtkLabel *label = GTK_LABEL (widget);
1772   GtkLabelPrivate *priv = label->priv;
1773
1774   gtk_label_setup_mnemonic (label, priv->mnemonic_keyval);
1775 }
1776
1777 static void
1778 label_shortcut_setting_apply (GtkLabel *label)
1779 {
1780   gtk_label_recalculate (label);
1781   if (GTK_IS_ACCEL_LABEL (label))
1782     gtk_accel_label_refetch (GTK_ACCEL_LABEL (label));
1783 }
1784
1785 static void
1786 label_shortcut_setting_traverse_container (GtkWidget *widget,
1787                                            gpointer   data)
1788 {
1789   if (GTK_IS_LABEL (widget))
1790     label_shortcut_setting_apply (GTK_LABEL (widget));
1791   else if (GTK_IS_CONTAINER (widget))
1792     gtk_container_forall (GTK_CONTAINER (widget),
1793                           label_shortcut_setting_traverse_container, data);
1794 }
1795
1796 static void
1797 label_shortcut_setting_changed (GtkSettings *settings)
1798 {
1799   GList *list, *l;
1800
1801   list = gtk_window_list_toplevels ();
1802
1803   for (l = list; l ; l = l->next)
1804     {
1805       GtkWidget *widget = l->data;
1806
1807       if (gtk_widget_get_settings (widget) == settings)
1808         gtk_container_forall (GTK_CONTAINER (widget),
1809                               label_shortcut_setting_traverse_container, NULL);
1810     }
1811
1812   g_list_free (list);
1813 }
1814
1815 static void
1816 mnemonics_visible_apply (GtkWidget *widget,
1817                          gboolean   mnemonics_visible)
1818 {
1819   GtkLabel *label = GTK_LABEL (widget);
1820   GtkLabelPrivate *priv = label->priv;
1821
1822   mnemonics_visible = mnemonics_visible != FALSE;
1823
1824   if (priv->mnemonics_visible != mnemonics_visible)
1825     {
1826       priv->mnemonics_visible = mnemonics_visible;
1827
1828       gtk_label_recalculate (label);
1829     }
1830 }
1831
1832 static void
1833 label_mnemonics_visible_traverse_container (GtkWidget *widget,
1834                                             gpointer   data)
1835 {
1836   gboolean mnemonics_visible = GPOINTER_TO_INT (data);
1837
1838   _gtk_label_mnemonics_visible_apply_recursively (widget, mnemonics_visible);
1839 }
1840
1841 void
1842 _gtk_label_mnemonics_visible_apply_recursively (GtkWidget *widget,
1843                                                 gboolean   mnemonics_visible)
1844 {
1845   if (GTK_IS_LABEL (widget))
1846     mnemonics_visible_apply (widget, mnemonics_visible);
1847   else if (GTK_IS_CONTAINER (widget))
1848     gtk_container_forall (GTK_CONTAINER (widget),
1849                           label_mnemonics_visible_traverse_container,
1850                           GINT_TO_POINTER (mnemonics_visible));
1851 }
1852
1853 static void
1854 label_mnemonics_visible_changed (GtkWindow  *window,
1855                                  GParamSpec *pspec,
1856                                  gpointer    data)
1857 {
1858   gboolean mnemonics_visible;
1859
1860   g_object_get (window, "mnemonics-visible", &mnemonics_visible, NULL);
1861
1862   gtk_container_forall (GTK_CONTAINER (window),
1863                         label_mnemonics_visible_traverse_container,
1864                         GINT_TO_POINTER (mnemonics_visible));
1865 }
1866
1867 static void
1868 gtk_label_screen_changed (GtkWidget *widget,
1869                           GdkScreen *old_screen)
1870 {
1871   GtkSettings *settings;
1872   gboolean shortcuts_connected;
1873
1874   if (!gtk_widget_has_screen (widget))
1875     return;
1876
1877   settings = gtk_widget_get_settings (widget);
1878
1879   shortcuts_connected =
1880     GPOINTER_TO_INT (g_object_get_data (G_OBJECT (settings),
1881                                         "gtk-label-shortcuts-connected"));
1882
1883   if (! shortcuts_connected)
1884     {
1885       g_signal_connect (settings, "notify::gtk-enable-mnemonics",
1886                         G_CALLBACK (label_shortcut_setting_changed),
1887                         NULL);
1888       g_signal_connect (settings, "notify::gtk-enable-accels",
1889                         G_CALLBACK (label_shortcut_setting_changed),
1890                         NULL);
1891
1892       g_object_set_data (G_OBJECT (settings), "gtk-label-shortcuts-connected",
1893                          GINT_TO_POINTER (TRUE));
1894     }
1895
1896   label_shortcut_setting_apply (GTK_LABEL (widget));
1897 }
1898
1899
1900 static void
1901 label_mnemonic_widget_weak_notify (gpointer      data,
1902                                    GObject      *where_the_object_was)
1903 {
1904   GtkLabel *label = data;
1905   GtkLabelPrivate *priv = label->priv;
1906
1907   priv->mnemonic_widget = NULL;
1908   g_object_notify (G_OBJECT (label), "mnemonic-widget");
1909 }
1910
1911 /**
1912  * gtk_label_set_mnemonic_widget:
1913  * @label: a #GtkLabel
1914  * @widget: (allow-none): the target #GtkWidget
1915  *
1916  * If the label has been set so that it has an mnemonic key (using
1917  * i.e. gtk_label_set_markup_with_mnemonic(),
1918  * gtk_label_set_text_with_mnemonic(), gtk_label_new_with_mnemonic()
1919  * or the "use_underline" property) the label can be associated with a
1920  * widget that is the target of the mnemonic. When the label is inside
1921  * a widget (like a #GtkButton or a #GtkNotebook tab) it is
1922  * automatically associated with the correct widget, but sometimes
1923  * (i.e. when the target is a #GtkEntry next to the label) you need to
1924  * set it explicitly using this function.
1925  *
1926  * The target widget will be accelerated by emitting the
1927  * GtkWidget::mnemonic-activate signal on it. The default handler for
1928  * this signal will activate the widget if there are no mnemonic collisions
1929  * and toggle focus between the colliding widgets otherwise.
1930  **/
1931 void
1932 gtk_label_set_mnemonic_widget (GtkLabel  *label,
1933                                GtkWidget *widget)
1934 {
1935   GtkLabelPrivate *priv;
1936
1937   g_return_if_fail (GTK_IS_LABEL (label));
1938
1939   priv = label->priv;
1940
1941   if (widget)
1942     g_return_if_fail (GTK_IS_WIDGET (widget));
1943
1944   if (priv->mnemonic_widget)
1945     {
1946       gtk_widget_remove_mnemonic_label (priv->mnemonic_widget, GTK_WIDGET (label));
1947       g_object_weak_unref (G_OBJECT (priv->mnemonic_widget),
1948                            label_mnemonic_widget_weak_notify,
1949                            label);
1950     }
1951   priv->mnemonic_widget = widget;
1952   if (priv->mnemonic_widget)
1953     {
1954       g_object_weak_ref (G_OBJECT (priv->mnemonic_widget),
1955                          label_mnemonic_widget_weak_notify,
1956                          label);
1957       gtk_widget_add_mnemonic_label (priv->mnemonic_widget, GTK_WIDGET (label));
1958     }
1959
1960   g_object_notify (G_OBJECT (label), "mnemonic-widget");
1961 }
1962
1963 /**
1964  * gtk_label_get_mnemonic_widget:
1965  * @label: a #GtkLabel
1966  *
1967  * Retrieves the target of the mnemonic (keyboard shortcut) of this
1968  * label. See gtk_label_set_mnemonic_widget().
1969  *
1970  * Return value: (transfer none): the target of the label's mnemonic,
1971  *     or %NULL if none has been set and the default algorithm will be used.
1972  **/
1973 GtkWidget *
1974 gtk_label_get_mnemonic_widget (GtkLabel *label)
1975 {
1976   g_return_val_if_fail (GTK_IS_LABEL (label), NULL);
1977
1978   return label->priv->mnemonic_widget;
1979 }
1980
1981 /**
1982  * gtk_label_get_mnemonic_keyval:
1983  * @label: a #GtkLabel
1984  *
1985  * If the label has been set so that it has an mnemonic key this function
1986  * returns the keyval used for the mnemonic accelerator. If there is no
1987  * mnemonic set up it returns #GDK_VoidSymbol.
1988  *
1989  * Returns: GDK keyval usable for accelerators, or #GDK_VoidSymbol
1990  **/
1991 guint
1992 gtk_label_get_mnemonic_keyval (GtkLabel *label)
1993 {
1994   g_return_val_if_fail (GTK_IS_LABEL (label), GDK_KEY_VoidSymbol);
1995
1996   return label->priv->mnemonic_keyval;
1997 }
1998
1999 static void
2000 gtk_label_set_text_internal (GtkLabel *label,
2001                              gchar    *str)
2002 {
2003   GtkLabelPrivate *priv = label->priv;
2004
2005   g_free (priv->text);
2006
2007   priv->text = str;
2008
2009   gtk_label_select_region_index (label, 0, 0);
2010 }
2011
2012 static void
2013 gtk_label_set_label_internal (GtkLabel *label,
2014                               gchar    *str)
2015 {
2016   GtkLabelPrivate *priv = label->priv;
2017
2018   g_free (priv->label);
2019
2020   priv->label = str;
2021
2022   g_object_notify (G_OBJECT (label), "label");
2023 }
2024
2025 static void
2026 gtk_label_set_use_markup_internal (GtkLabel *label,
2027                                    gboolean  val)
2028 {
2029   GtkLabelPrivate *priv = label->priv;
2030
2031   val = val != FALSE;
2032   if (priv->use_markup != val)
2033     {
2034       priv->use_markup = val;
2035
2036       g_object_notify (G_OBJECT (label), "use-markup");
2037     }
2038 }
2039
2040 static void
2041 gtk_label_set_use_underline_internal (GtkLabel *label,
2042                                       gboolean val)
2043 {
2044   GtkLabelPrivate *priv = label->priv;
2045
2046   val = val != FALSE;
2047   if (priv->use_underline != val)
2048     {
2049       priv->use_underline = val;
2050
2051       g_object_notify (G_OBJECT (label), "use-underline");
2052     }
2053 }
2054
2055 static void
2056 gtk_label_compose_effective_attrs (GtkLabel *label)
2057 {
2058   GtkLabelPrivate      *priv = label->priv;
2059   PangoAttrIterator *iter;
2060   PangoAttribute    *attr;
2061   GSList            *iter_attrs, *l;
2062
2063   if (priv->attrs)
2064     {
2065       if (priv->effective_attrs)
2066         {
2067           if ((iter = pango_attr_list_get_iterator (priv->attrs)))
2068             {
2069               do
2070                 {
2071                   iter_attrs = pango_attr_iterator_get_attrs (iter);
2072                   for (l = iter_attrs; l; l = l->next)
2073                     {
2074                       attr = l->data;
2075                       pango_attr_list_insert (priv->effective_attrs, attr);
2076                     }
2077                   g_slist_free (iter_attrs);
2078                 }
2079               while (pango_attr_iterator_next (iter));
2080               pango_attr_iterator_destroy (iter);
2081             }
2082         }
2083       else
2084         priv->effective_attrs =
2085           pango_attr_list_ref (priv->attrs);
2086     }
2087 }
2088
2089 static void
2090 gtk_label_set_attributes_internal (GtkLabel      *label,
2091                                    PangoAttrList *attrs)
2092 {
2093   GtkLabelPrivate *priv = label->priv;
2094
2095   if (attrs)
2096     pango_attr_list_ref (attrs);
2097
2098   if (priv->attrs)
2099     pango_attr_list_unref (priv->attrs);
2100   priv->attrs = attrs;
2101
2102   g_object_notify (G_OBJECT (label), "attributes");
2103 }
2104
2105
2106 /* Calculates text, attrs and mnemonic_keyval from
2107  * label, use_underline and use_markup
2108  */
2109 static void
2110 gtk_label_recalculate (GtkLabel *label)
2111 {
2112   GtkLabelPrivate *priv = label->priv;
2113   guint keyval = priv->mnemonic_keyval;
2114
2115   if (priv->use_markup)
2116     gtk_label_set_markup_internal (label, priv->label, priv->use_underline);
2117   else
2118     {
2119       if (priv->use_underline)
2120         gtk_label_set_uline_text_internal (label, priv->label);
2121       else
2122         {
2123           if (priv->effective_attrs)
2124             pango_attr_list_unref (priv->effective_attrs);
2125           priv->effective_attrs = NULL;
2126           gtk_label_set_text_internal (label, g_strdup (priv->label));
2127         }
2128     }
2129
2130   gtk_label_compose_effective_attrs (label);
2131
2132   if (!priv->use_underline)
2133     priv->mnemonic_keyval = GDK_KEY_VoidSymbol;
2134
2135   if (keyval != priv->mnemonic_keyval)
2136     {
2137       gtk_label_setup_mnemonic (label, keyval);
2138       g_object_notify (G_OBJECT (label), "mnemonic-keyval");
2139     }
2140
2141   gtk_label_clear_layout (label);
2142   gtk_label_clear_select_info (label);
2143   gtk_widget_queue_resize (GTK_WIDGET (label));
2144 }
2145
2146 /**
2147  * gtk_label_set_text:
2148  * @label: a #GtkLabel
2149  * @str: The text you want to set
2150  *
2151  * Sets the text within the #GtkLabel widget. It overwrites any text that
2152  * was there before.
2153  *
2154  * This will also clear any previously set mnemonic accelerators.
2155  **/
2156 void
2157 gtk_label_set_text (GtkLabel    *label,
2158                     const gchar *str)
2159 {
2160   g_return_if_fail (GTK_IS_LABEL (label));
2161
2162   g_object_freeze_notify (G_OBJECT (label));
2163
2164   gtk_label_set_label_internal (label, g_strdup (str ? str : ""));
2165   gtk_label_set_use_markup_internal (label, FALSE);
2166   gtk_label_set_use_underline_internal (label, FALSE);
2167
2168   gtk_label_recalculate (label);
2169
2170   g_object_thaw_notify (G_OBJECT (label));
2171 }
2172
2173 /**
2174  * gtk_label_set_attributes:
2175  * @label: a #GtkLabel
2176  * @attrs: a #PangoAttrList
2177  *
2178  * Sets a #PangoAttrList; the attributes in the list are applied to the
2179  * label text.
2180  *
2181  * <note><para>The attributes set with this function will be applied
2182  * and merged with any other attributes previously effected by way
2183  * of the #GtkLabel:use-underline or #GtkLabel:use-markup properties.
2184  * While it is not recommended to mix markup strings with manually set
2185  * attributes, if you must; know that the attributes will be applied
2186  * to the label after the markup string is parsed.</para></note>
2187  **/
2188 void
2189 gtk_label_set_attributes (GtkLabel         *label,
2190                           PangoAttrList    *attrs)
2191 {
2192   g_return_if_fail (GTK_IS_LABEL (label));
2193
2194   gtk_label_set_attributes_internal (label, attrs);
2195
2196   gtk_label_recalculate (label);
2197
2198   gtk_label_clear_layout (label);
2199   gtk_widget_queue_resize (GTK_WIDGET (label));
2200 }
2201
2202 /**
2203  * gtk_label_get_attributes:
2204  * @label: a #GtkLabel
2205  *
2206  * Gets the attribute list that was set on the label using
2207  * gtk_label_set_attributes(), if any. This function does
2208  * not reflect attributes that come from the labels markup
2209  * (see gtk_label_set_markup()). If you want to get the
2210  * effective attributes for the label, use
2211  * pango_layout_get_attribute (gtk_label_get_layout (label)).
2212  *
2213  * Return value: (transfer none): the attribute list, or %NULL
2214  *     if none was set.
2215  **/
2216 PangoAttrList *
2217 gtk_label_get_attributes (GtkLabel *label)
2218 {
2219   g_return_val_if_fail (GTK_IS_LABEL (label), NULL);
2220
2221   return label->priv->attrs;
2222 }
2223
2224 /**
2225  * gtk_label_set_label:
2226  * @label: a #GtkLabel
2227  * @str: the new text to set for the label
2228  *
2229  * Sets the text of the label. The label is interpreted as
2230  * including embedded underlines and/or Pango markup depending
2231  * on the values of the #GtkLabel:use-underline" and
2232  * #GtkLabel:use-markup properties.
2233  **/
2234 void
2235 gtk_label_set_label (GtkLabel    *label,
2236                      const gchar *str)
2237 {
2238   g_return_if_fail (GTK_IS_LABEL (label));
2239
2240   g_object_freeze_notify (G_OBJECT (label));
2241
2242   gtk_label_set_label_internal (label, g_strdup (str ? str : ""));
2243   gtk_label_recalculate (label);
2244
2245   g_object_thaw_notify (G_OBJECT (label));
2246 }
2247
2248 /**
2249  * gtk_label_get_label:
2250  * @label: a #GtkLabel
2251  *
2252  * Fetches the text from a label widget including any embedded
2253  * underlines indicating mnemonics and Pango markup. (See
2254  * gtk_label_get_text()).
2255  *
2256  * Return value: the text of the label widget. This string is
2257  *   owned by the widget and must not be modified or freed.
2258  **/
2259 G_CONST_RETURN gchar *
2260 gtk_label_get_label (GtkLabel *label)
2261 {
2262   g_return_val_if_fail (GTK_IS_LABEL (label), NULL);
2263
2264   return label->priv->label;
2265 }
2266
2267 typedef struct
2268 {
2269   GtkLabel *label;
2270   GList *links;
2271   GString *new_str;
2272   GdkColor *link_color;
2273   GdkColor *visited_link_color;
2274 } UriParserData;
2275
2276 static void
2277 start_element_handler (GMarkupParseContext  *context,
2278                        const gchar          *element_name,
2279                        const gchar         **attribute_names,
2280                        const gchar         **attribute_values,
2281                        gpointer              user_data,
2282                        GError              **error)
2283 {
2284   GtkLabelPrivate *priv;
2285   UriParserData *pdata = user_data;
2286
2287   if (strcmp (element_name, "a") == 0)
2288     {
2289       GtkLabelLink *link;
2290       const gchar *uri = NULL;
2291       const gchar *title = NULL;
2292       gboolean visited = FALSE;
2293       gint line_number;
2294       gint char_number;
2295       gint i;
2296       GdkColor *color = NULL;
2297
2298       g_markup_parse_context_get_position (context, &line_number, &char_number);
2299
2300       for (i = 0; attribute_names[i] != NULL; i++)
2301         {
2302           const gchar *attr = attribute_names[i];
2303
2304           if (strcmp (attr, "href") == 0)
2305             uri = attribute_values[i];
2306           else if (strcmp (attr, "title") == 0)
2307             title = attribute_values[i];
2308           else
2309             {
2310               g_set_error (error,
2311                            G_MARKUP_ERROR,
2312                            G_MARKUP_ERROR_UNKNOWN_ATTRIBUTE,
2313                            "Attribute '%s' is not allowed on the <a> tag "
2314                            "on line %d char %d",
2315                             attr, line_number, char_number);
2316               return;
2317             }
2318         }
2319
2320       if (uri == NULL)
2321         {
2322           g_set_error (error,
2323                        G_MARKUP_ERROR,
2324                        G_MARKUP_ERROR_INVALID_CONTENT,
2325                        "Attribute 'href' was missing on the <a> tag "
2326                        "on line %d char %d",
2327                        line_number, char_number);
2328           return;
2329         }
2330
2331       visited = FALSE;
2332       priv = pdata->label->priv;
2333       if (priv->track_links && priv->select_info)
2334         {
2335           GList *l;
2336           for (l = priv->select_info->links; l; l = l->next)
2337             {
2338               link = l->data;
2339               if (strcmp (uri, link->uri) == 0)
2340                 {
2341                   visited = link->visited;
2342                   break;
2343                 }
2344             }
2345         }
2346
2347       if (visited)
2348         color = pdata->visited_link_color;
2349       else
2350         color = pdata->link_color;
2351
2352       g_string_append_printf (pdata->new_str,
2353                               "<span color=\"#%04x%04x%04x\" underline=\"single\">",
2354                               color->red,
2355                               color->green,
2356                               color->blue);
2357
2358       link = g_new0 (GtkLabelLink, 1);
2359       link->uri = g_strdup (uri);
2360       link->title = g_strdup (title);
2361       link->visited = visited;
2362       pdata->links = g_list_append (pdata->links, link);
2363     }
2364   else
2365     {
2366       gint i;
2367
2368       g_string_append_c (pdata->new_str, '<');
2369       g_string_append (pdata->new_str, element_name);
2370
2371       for (i = 0; attribute_names[i] != NULL; i++)
2372         {
2373           const gchar *attr  = attribute_names[i];
2374           const gchar *value = attribute_values[i];
2375           gchar *newvalue;
2376
2377           newvalue = g_markup_escape_text (value, -1);
2378
2379           g_string_append_c (pdata->new_str, ' ');
2380           g_string_append (pdata->new_str, attr);
2381           g_string_append (pdata->new_str, "=\"");
2382           g_string_append (pdata->new_str, newvalue);
2383           g_string_append_c (pdata->new_str, '\"');
2384
2385           g_free (newvalue);
2386         }
2387       g_string_append_c (pdata->new_str, '>');
2388     }
2389 }
2390
2391 static void
2392 end_element_handler (GMarkupParseContext  *context,
2393                      const gchar          *element_name,
2394                      gpointer              user_data,
2395                      GError              **error)
2396 {
2397   UriParserData *pdata = user_data;
2398
2399   if (!strcmp (element_name, "a"))
2400     g_string_append (pdata->new_str, "</span>");
2401   else
2402     {
2403       g_string_append (pdata->new_str, "</");
2404       g_string_append (pdata->new_str, element_name);
2405       g_string_append_c (pdata->new_str, '>');
2406     }
2407 }
2408
2409 static void
2410 text_handler (GMarkupParseContext  *context,
2411               const gchar          *text,
2412               gsize                 text_len,
2413               gpointer              user_data,
2414               GError              **error)
2415 {
2416   UriParserData *pdata = user_data;
2417   gchar *newtext;
2418
2419   newtext = g_markup_escape_text (text, text_len);
2420   g_string_append (pdata->new_str, newtext);
2421   g_free (newtext);
2422 }
2423
2424 static const GMarkupParser markup_parser =
2425 {
2426   start_element_handler,
2427   end_element_handler,
2428   text_handler,
2429   NULL,
2430   NULL
2431 };
2432
2433 static gboolean
2434 xml_isspace (gchar c)
2435 {
2436   return (c == ' ' || c == '\t' || c == '\n' || c == '\r');
2437 }
2438
2439 static void
2440 link_free (GtkLabelLink *link)
2441 {
2442   g_free (link->uri);
2443   g_free (link->title);
2444   g_free (link);
2445 }
2446
2447 static void
2448 gtk_label_get_link_colors (GtkWidget  *widget,
2449                            GdkColor  **link_color,
2450                            GdkColor  **visited_link_color)
2451 {
2452   GtkStyleContext *context;
2453
2454   context = gtk_widget_get_style_context (widget);
2455   gtk_style_context_get_style (context,
2456                                "link-color", link_color,
2457                                "visited-link-color", visited_link_color,
2458                                 NULL);
2459   if (!*link_color)
2460     *link_color = gdk_color_copy (&default_link_color);
2461   if (!*visited_link_color)
2462     *visited_link_color = gdk_color_copy (&default_visited_link_color);
2463 }
2464
2465 static gboolean
2466 parse_uri_markup (GtkLabel     *label,
2467                   const gchar  *str,
2468                   gchar       **new_str,
2469                   GList       **links,
2470                   GError      **error)
2471 {
2472   GMarkupParseContext *context = NULL;
2473   const gchar *p, *end;
2474   gboolean needs_root = TRUE;
2475   gsize length;
2476   UriParserData pdata;
2477
2478   length = strlen (str);
2479   p = str;
2480   end = str + length;
2481
2482   pdata.label = label;
2483   pdata.links = NULL;
2484   pdata.new_str = g_string_sized_new (length);
2485
2486   gtk_label_get_link_colors (GTK_WIDGET (label), &pdata.link_color, &pdata.visited_link_color);
2487
2488   while (p != end && xml_isspace (*p))
2489     p++;
2490
2491   if (end - p >= 8 && strncmp (p, "<markup>", 8) == 0)
2492     needs_root = FALSE;
2493
2494   context = g_markup_parse_context_new (&markup_parser, 0, &pdata, NULL);
2495
2496   if (needs_root)
2497     {
2498       if (!g_markup_parse_context_parse (context, "<markup>", -1, error))
2499         goto failed;
2500     }
2501
2502   if (!g_markup_parse_context_parse (context, str, length, error))
2503     goto failed;
2504
2505   if (needs_root)
2506     {
2507       if (!g_markup_parse_context_parse (context, "</markup>", -1, error))
2508         goto failed;
2509     }
2510
2511   if (!g_markup_parse_context_end_parse (context, error))
2512     goto failed;
2513
2514   g_markup_parse_context_free (context);
2515
2516   *new_str = g_string_free (pdata.new_str, FALSE);
2517   *links = pdata.links;
2518
2519   gdk_color_free (pdata.link_color);
2520   gdk_color_free (pdata.visited_link_color);
2521
2522   return TRUE;
2523
2524 failed:
2525   g_markup_parse_context_free (context);
2526   g_string_free (pdata.new_str, TRUE);
2527   g_list_foreach (pdata.links, (GFunc)link_free, NULL);
2528   g_list_free (pdata.links);
2529   gdk_color_free (pdata.link_color);
2530   gdk_color_free (pdata.visited_link_color);
2531
2532   return FALSE;
2533 }
2534
2535 static void
2536 gtk_label_ensure_has_tooltip (GtkLabel *label)
2537 {
2538   GtkLabelPrivate *priv = label->priv;
2539   GList *l;
2540   gboolean has_tooltip = FALSE;
2541
2542   for (l = priv->select_info->links; l; l = l->next)
2543     {
2544       GtkLabelLink *link = l->data;
2545       if (link->title)
2546         {
2547           has_tooltip = TRUE;
2548           break;
2549         }
2550     }
2551
2552   gtk_widget_set_has_tooltip (GTK_WIDGET (label), has_tooltip);
2553 }
2554
2555 static void
2556 gtk_label_set_markup_internal (GtkLabel    *label,
2557                                const gchar *str,
2558                                gboolean     with_uline)
2559 {
2560   GtkLabelPrivate *priv = label->priv;
2561   gchar *text = NULL;
2562   GError *error = NULL;
2563   PangoAttrList *attrs = NULL;
2564   gunichar accel_char = 0;
2565   gchar *new_str;
2566   GList *links = NULL;
2567
2568   if (!parse_uri_markup (label, str, &new_str, &links, &error))
2569     {
2570       g_warning ("Failed to set text from markup due to error parsing markup: %s",
2571                  error->message);
2572       g_error_free (error);
2573       return;
2574     }
2575
2576   gtk_label_clear_links (label);
2577   if (links)
2578     {
2579       gtk_label_ensure_select_info (label);
2580       priv->select_info->links = links;
2581       gtk_label_ensure_has_tooltip (label);
2582     }
2583
2584   if (with_uline)
2585     {
2586       gboolean enable_mnemonics;
2587       gboolean auto_mnemonics;
2588
2589       g_object_get (gtk_widget_get_settings (GTK_WIDGET (label)),
2590                     "gtk-enable-mnemonics", &enable_mnemonics,
2591                     "gtk-auto-mnemonics", &auto_mnemonics,
2592                     NULL);
2593
2594       if (!(enable_mnemonics && priv->mnemonics_visible &&
2595             (!auto_mnemonics ||
2596              (gtk_widget_is_sensitive (GTK_WIDGET (label)) &&
2597               (!priv->mnemonic_widget ||
2598                gtk_widget_is_sensitive (priv->mnemonic_widget))))))
2599         {
2600           gchar *tmp;
2601           gchar *pattern;
2602           guint key;
2603
2604           if (separate_uline_pattern (new_str, &key, &tmp, &pattern))
2605             {
2606               g_free (new_str);
2607               new_str = tmp;
2608               g_free (pattern);
2609             }
2610         }
2611     }
2612
2613   if (!pango_parse_markup (new_str,
2614                            -1,
2615                            with_uline ? '_' : 0,
2616                            &attrs,
2617                            &text,
2618                            with_uline ? &accel_char : NULL,
2619                            &error))
2620     {
2621       g_warning ("Failed to set text from markup due to error parsing markup: %s",
2622                  error->message);
2623       g_free (new_str);
2624       g_error_free (error);
2625       return;
2626     }
2627
2628   g_free (new_str);
2629
2630   if (text)
2631     gtk_label_set_text_internal (label, text);
2632
2633   if (attrs)
2634     {
2635       if (priv->effective_attrs)
2636         pango_attr_list_unref (priv->effective_attrs);
2637       priv->effective_attrs = attrs;
2638     }
2639
2640   if (accel_char != 0)
2641     priv->mnemonic_keyval = gdk_keyval_to_lower (gdk_unicode_to_keyval (accel_char));
2642   else
2643     priv->mnemonic_keyval = GDK_KEY_VoidSymbol;
2644 }
2645
2646 /**
2647  * gtk_label_set_markup:
2648  * @label: a #GtkLabel
2649  * @str: a markup string (see <link linkend="PangoMarkupFormat">Pango markup format</link>)
2650  *
2651  * Parses @str which is marked up with the <link
2652  * linkend="PangoMarkupFormat">Pango text markup language</link>, setting the
2653  * label's text and attribute list based on the parse results. If the @str is
2654  * external data, you may need to escape it with g_markup_escape_text() or
2655  * g_markup_printf_escaped()<!-- -->:
2656  * |[
2657  * char *markup;
2658  *
2659  * markup = g_markup_printf_escaped ("&lt;span style=\"italic\"&gt;&percnt;s&lt;/span&gt;", str);
2660  * gtk_label_set_markup (GTK_LABEL (label), markup);
2661  * g_free (markup);
2662  * ]|
2663  **/
2664 void
2665 gtk_label_set_markup (GtkLabel    *label,
2666                       const gchar *str)
2667 {
2668   g_return_if_fail (GTK_IS_LABEL (label));
2669
2670   g_object_freeze_notify (G_OBJECT (label));
2671
2672   gtk_label_set_label_internal (label, g_strdup (str ? str : ""));
2673   gtk_label_set_use_markup_internal (label, TRUE);
2674   gtk_label_set_use_underline_internal (label, FALSE);
2675
2676   gtk_label_recalculate (label);
2677
2678   g_object_thaw_notify (G_OBJECT (label));
2679 }
2680
2681 /**
2682  * gtk_label_set_markup_with_mnemonic:
2683  * @label: a #GtkLabel
2684  * @str: a markup string (see
2685  *     <link linkend="PangoMarkupFormat">Pango markup format</link>)
2686  *
2687  * Parses @str which is marked up with the
2688  * <link linkend="PangoMarkupFormat">Pango text markup language</link>,
2689  * setting the label's text and attribute list based on the parse results.
2690  * If characters in @str are preceded by an underscore, they are underlined
2691  * indicating that they represent a keyboard accelerator called a mnemonic.
2692  *
2693  * The mnemonic key can be used to activate another widget, chosen
2694  * automatically, or explicitly using gtk_label_set_mnemonic_widget().
2695  */
2696 void
2697 gtk_label_set_markup_with_mnemonic (GtkLabel    *label,
2698                                     const gchar *str)
2699 {
2700   g_return_if_fail (GTK_IS_LABEL (label));
2701
2702   g_object_freeze_notify (G_OBJECT (label));
2703
2704   gtk_label_set_label_internal (label, g_strdup (str ? str : ""));
2705   gtk_label_set_use_markup_internal (label, TRUE);
2706   gtk_label_set_use_underline_internal (label, TRUE);
2707
2708   gtk_label_recalculate (label);
2709
2710   g_object_thaw_notify (G_OBJECT (label));
2711 }
2712
2713 /**
2714  * gtk_label_get_text:
2715  * @label: a #GtkLabel
2716  *
2717  * Fetches the text from a label widget, as displayed on the
2718  * screen. This does not include any embedded underlines
2719  * indicating mnemonics or Pango markup. (See gtk_label_get_label())
2720  *
2721  * Return value: the text in the label widget. This is the internal
2722  *   string used by the label, and must not be modified.
2723  **/
2724 G_CONST_RETURN gchar *
2725 gtk_label_get_text (GtkLabel *label)
2726 {
2727   g_return_val_if_fail (GTK_IS_LABEL (label), NULL);
2728
2729   return label->priv->text;
2730 }
2731
2732 static PangoAttrList *
2733 gtk_label_pattern_to_attrs (GtkLabel      *label,
2734                             const gchar   *pattern)
2735 {
2736   GtkLabelPrivate *priv = label->priv;
2737   const char *start;
2738   const char *p = priv->text;
2739   const char *q = pattern;
2740   PangoAttrList *attrs;
2741
2742   attrs = pango_attr_list_new ();
2743
2744   while (1)
2745     {
2746       while (*p && *q && *q != '_')
2747         {
2748           p = g_utf8_next_char (p);
2749           q++;
2750         }
2751       start = p;
2752       while (*p && *q && *q == '_')
2753         {
2754           p = g_utf8_next_char (p);
2755           q++;
2756         }
2757
2758       if (p > start)
2759         {
2760           PangoAttribute *attr = pango_attr_underline_new (PANGO_UNDERLINE_LOW);
2761           attr->start_index = start - priv->text;
2762           attr->end_index = p - priv->text;
2763
2764           pango_attr_list_insert (attrs, attr);
2765         }
2766       else
2767         break;
2768     }
2769
2770   return attrs;
2771 }
2772
2773 static void
2774 gtk_label_set_pattern_internal (GtkLabel    *label,
2775                                 const gchar *pattern,
2776                                 gboolean     is_mnemonic)
2777 {
2778   GtkLabelPrivate *priv = label->priv;
2779   PangoAttrList *attrs;
2780   gboolean enable_mnemonics;
2781   gboolean auto_mnemonics;
2782
2783   if (priv->pattern_set)
2784     return;
2785
2786   if (is_mnemonic)
2787     {
2788       g_object_get (gtk_widget_get_settings (GTK_WIDGET (label)),
2789                     "gtk-enable-mnemonics", &enable_mnemonics,
2790                     "gtk-auto-mnemonics", &auto_mnemonics,
2791                     NULL);
2792
2793       if (enable_mnemonics && priv->mnemonics_visible && pattern &&
2794           (!auto_mnemonics ||
2795            (gtk_widget_is_sensitive (GTK_WIDGET (label)) &&
2796             (!priv->mnemonic_widget ||
2797              gtk_widget_is_sensitive (priv->mnemonic_widget)))))
2798         attrs = gtk_label_pattern_to_attrs (label, pattern);
2799       else
2800         attrs = NULL;
2801     }
2802   else
2803     attrs = gtk_label_pattern_to_attrs (label, pattern);
2804
2805   if (priv->effective_attrs)
2806     pango_attr_list_unref (priv->effective_attrs);
2807   priv->effective_attrs = attrs;
2808 }
2809
2810 /**
2811  * gtk_label_set_pattern:
2812  * @label: The #GtkLabel you want to set the pattern to.
2813  * @pattern: The pattern as described above.
2814  *
2815  * The pattern of underlines you want under the existing text within the
2816  * #GtkLabel widget.  For example if the current text of the label says
2817  * "FooBarBaz" passing a pattern of "___   ___" will underline
2818  * "Foo" and "Baz" but not "Bar".
2819  */
2820 void
2821 gtk_label_set_pattern (GtkLabel    *label,
2822                        const gchar *pattern)
2823 {
2824   GtkLabelPrivate *priv = label->priv;
2825
2826   g_return_if_fail (GTK_IS_LABEL (label));
2827
2828   priv = label->priv;
2829
2830   priv->pattern_set = FALSE;
2831
2832   if (pattern)
2833     {
2834       gtk_label_set_pattern_internal (label, pattern, FALSE);
2835       priv->pattern_set = TRUE;
2836     }
2837   else
2838     gtk_label_recalculate (label);
2839
2840   gtk_label_clear_layout (label);
2841   gtk_widget_queue_resize (GTK_WIDGET (label));
2842 }
2843
2844
2845 /**
2846  * gtk_label_set_justify:
2847  * @label: a #GtkLabel
2848  * @jtype: a #GtkJustification
2849  *
2850  * Sets the alignment of the lines in the text of the label relative to
2851  * each other. %GTK_JUSTIFY_LEFT is the default value when the
2852  * widget is first created with gtk_label_new(). If you instead want
2853  * to set the alignment of the label as a whole, use
2854  * gtk_misc_set_alignment() instead. gtk_label_set_justify() has no
2855  * effect on labels containing only a single line.
2856  **/
2857 void
2858 gtk_label_set_justify (GtkLabel        *label,
2859                        GtkJustification jtype)
2860 {
2861   GtkLabelPrivate *priv;
2862
2863   g_return_if_fail (GTK_IS_LABEL (label));
2864   g_return_if_fail (jtype >= GTK_JUSTIFY_LEFT && jtype <= GTK_JUSTIFY_FILL);
2865
2866   priv = label->priv;
2867
2868   if ((GtkJustification) priv->jtype != jtype)
2869     {
2870       priv->jtype = jtype;
2871
2872       /* No real need to be this drastic, but easier than duplicating the code */
2873       gtk_label_clear_layout (label);
2874
2875       g_object_notify (G_OBJECT (label), "justify");
2876       gtk_widget_queue_resize (GTK_WIDGET (label));
2877     }
2878 }
2879
2880 /**
2881  * gtk_label_get_justify:
2882  * @label: a #GtkLabel
2883  *
2884  * Returns the justification of the label. See gtk_label_set_justify().
2885  *
2886  * Return value: #GtkJustification
2887  **/
2888 GtkJustification
2889 gtk_label_get_justify (GtkLabel *label)
2890 {
2891   g_return_val_if_fail (GTK_IS_LABEL (label), 0);
2892
2893   return label->priv->jtype;
2894 }
2895
2896 /**
2897  * gtk_label_set_ellipsize:
2898  * @label: a #GtkLabel
2899  * @mode: a #PangoEllipsizeMode
2900  *
2901  * Sets the mode used to ellipsize (add an ellipsis: "...") to the text
2902  * if there is not enough space to render the entire string.
2903  *
2904  * Since: 2.6
2905  **/
2906 void
2907 gtk_label_set_ellipsize (GtkLabel          *label,
2908                          PangoEllipsizeMode mode)
2909 {
2910   GtkLabelPrivate *priv;
2911
2912   g_return_if_fail (GTK_IS_LABEL (label));
2913   g_return_if_fail (mode >= PANGO_ELLIPSIZE_NONE && mode <= PANGO_ELLIPSIZE_END);
2914
2915   priv = label->priv;
2916
2917   if ((PangoEllipsizeMode) priv->ellipsize != mode)
2918     {
2919       priv->ellipsize = mode;
2920
2921       /* No real need to be this drastic, but easier than duplicating the code */
2922       gtk_label_clear_layout (label);
2923
2924       g_object_notify (G_OBJECT (label), "ellipsize");
2925       gtk_widget_queue_resize (GTK_WIDGET (label));
2926     }
2927 }
2928
2929 /**
2930  * gtk_label_get_ellipsize:
2931  * @label: a #GtkLabel
2932  *
2933  * Returns the ellipsizing position of the label. See gtk_label_set_ellipsize().
2934  *
2935  * Return value: #PangoEllipsizeMode
2936  *
2937  * Since: 2.6
2938  **/
2939 PangoEllipsizeMode
2940 gtk_label_get_ellipsize (GtkLabel *label)
2941 {
2942   g_return_val_if_fail (GTK_IS_LABEL (label), PANGO_ELLIPSIZE_NONE);
2943
2944   return label->priv->ellipsize;
2945 }
2946
2947 /**
2948  * gtk_label_set_width_chars:
2949  * @label: a #GtkLabel
2950  * @n_chars: the new desired width, in characters.
2951  *
2952  * Sets the desired width in characters of @label to @n_chars.
2953  *
2954  * Since: 2.6
2955  **/
2956 void
2957 gtk_label_set_width_chars (GtkLabel *label,
2958                            gint      n_chars)
2959 {
2960   GtkLabelPrivate *priv;
2961
2962   g_return_if_fail (GTK_IS_LABEL (label));
2963
2964   priv = label->priv;
2965
2966   if (priv->width_chars != n_chars)
2967     {
2968       priv->width_chars = n_chars;
2969       g_object_notify (G_OBJECT (label), "width-chars");
2970       gtk_widget_queue_resize (GTK_WIDGET (label));
2971     }
2972 }
2973
2974 /**
2975  * gtk_label_get_width_chars:
2976  * @label: a #GtkLabel
2977  *
2978  * Retrieves the desired width of @label, in characters. See
2979  * gtk_label_set_width_chars().
2980  *
2981  * Return value: the width of the label in characters.
2982  *
2983  * Since: 2.6
2984  **/
2985 gint
2986 gtk_label_get_width_chars (GtkLabel *label)
2987 {
2988   g_return_val_if_fail (GTK_IS_LABEL (label), -1);
2989
2990   return label->priv->width_chars;
2991 }
2992
2993 /**
2994  * gtk_label_set_max_width_chars:
2995  * @label: a #GtkLabel
2996  * @n_chars: the new desired maximum width, in characters.
2997  *
2998  * Sets the desired maximum width in characters of @label to @n_chars.
2999  *
3000  * Since: 2.6
3001  **/
3002 void
3003 gtk_label_set_max_width_chars (GtkLabel *label,
3004                                gint      n_chars)
3005 {
3006   GtkLabelPrivate *priv;
3007
3008   g_return_if_fail (GTK_IS_LABEL (label));
3009
3010   priv = label->priv;
3011
3012   if (priv->max_width_chars != n_chars)
3013     {
3014       priv->max_width_chars = n_chars;
3015
3016       g_object_notify (G_OBJECT (label), "max-width-chars");
3017       gtk_widget_queue_resize (GTK_WIDGET (label));
3018     }
3019 }
3020
3021 /**
3022  * gtk_label_get_max_width_chars:
3023  * @label: a #GtkLabel
3024  *
3025  * Retrieves the desired maximum width of @label, in characters. See
3026  * gtk_label_set_width_chars().
3027  *
3028  * Return value: the maximum width of the label in characters.
3029  *
3030  * Since: 2.6
3031  **/
3032 gint
3033 gtk_label_get_max_width_chars (GtkLabel *label)
3034 {
3035   g_return_val_if_fail (GTK_IS_LABEL (label), -1);
3036
3037   return label->priv->max_width_chars;
3038 }
3039
3040 /**
3041  * gtk_label_set_line_wrap:
3042  * @label: a #GtkLabel
3043  * @wrap: the setting
3044  *
3045  * Toggles line wrapping within the #GtkLabel widget. %TRUE makes it break
3046  * lines if text exceeds the widget's size. %FALSE lets the text get cut off
3047  * by the edge of the widget if it exceeds the widget size.
3048  *
3049  * Note that setting line wrapping to %TRUE does not make the label
3050  * wrap at its parent container's width, because GTK+ widgets
3051  * conceptually can't make their requisition depend on the parent
3052  * container's size. For a label that wraps at a specific position,
3053  * set the label's width using gtk_widget_set_size_request().
3054  **/
3055 void
3056 gtk_label_set_line_wrap (GtkLabel *label,
3057                          gboolean  wrap)
3058 {
3059   GtkLabelPrivate *priv;
3060
3061   g_return_if_fail (GTK_IS_LABEL (label));
3062
3063   priv = label->priv;
3064
3065   wrap = wrap != FALSE;
3066
3067   if (priv->wrap != wrap)
3068     {
3069       priv->wrap = wrap;
3070
3071       gtk_label_clear_layout (label);
3072       gtk_widget_queue_resize (GTK_WIDGET (label));
3073       g_object_notify (G_OBJECT (label), "wrap");
3074     }
3075 }
3076
3077 /**
3078  * gtk_label_get_line_wrap:
3079  * @label: a #GtkLabel
3080  *
3081  * Returns whether lines in the label are automatically wrapped.
3082  * See gtk_label_set_line_wrap().
3083  *
3084  * Return value: %TRUE if the lines of the label are automatically wrapped.
3085  */
3086 gboolean
3087 gtk_label_get_line_wrap (GtkLabel *label)
3088 {
3089   g_return_val_if_fail (GTK_IS_LABEL (label), FALSE);
3090
3091   return label->priv->wrap;
3092 }
3093
3094 /**
3095  * gtk_label_set_line_wrap_mode:
3096  * @label: a #GtkLabel
3097  * @wrap_mode: the line wrapping mode
3098  *
3099  * If line wrapping is on (see gtk_label_set_line_wrap()) this controls how
3100  * the line wrapping is done. The default is %PANGO_WRAP_WORD which means
3101  * wrap on word boundaries.
3102  *
3103  * Since: 2.10
3104  **/
3105 void
3106 gtk_label_set_line_wrap_mode (GtkLabel *label,
3107                               PangoWrapMode wrap_mode)
3108 {
3109   GtkLabelPrivate *priv;
3110
3111   g_return_if_fail (GTK_IS_LABEL (label));
3112
3113   priv = label->priv;
3114
3115   if (priv->wrap_mode != wrap_mode)
3116     {
3117       priv->wrap_mode = wrap_mode;
3118       g_object_notify (G_OBJECT (label), "wrap-mode");
3119
3120       gtk_widget_queue_resize (GTK_WIDGET (label));
3121     }
3122 }
3123
3124 /**
3125  * gtk_label_get_line_wrap_mode:
3126  * @label: a #GtkLabel
3127  *
3128  * Returns line wrap mode used by the label. See gtk_label_set_line_wrap_mode().
3129  *
3130  * Return value: %TRUE if the lines of the label are automatically wrapped.
3131  *
3132  * Since: 2.10
3133  */
3134 PangoWrapMode
3135 gtk_label_get_line_wrap_mode (GtkLabel *label)
3136 {
3137   g_return_val_if_fail (GTK_IS_LABEL (label), FALSE);
3138
3139   return label->priv->wrap_mode;
3140 }
3141
3142 static void
3143 gtk_label_destroy (GtkWidget *widget)
3144 {
3145   GtkLabel *label = GTK_LABEL (widget);
3146
3147   gtk_label_set_mnemonic_widget (label, NULL);
3148
3149   GTK_WIDGET_CLASS (gtk_label_parent_class)->destroy (widget);
3150 }
3151
3152 static void
3153 gtk_label_finalize (GObject *object)
3154 {
3155   GtkLabel *label = GTK_LABEL (object);
3156   GtkLabelPrivate *priv = label->priv;
3157
3158   g_free (priv->label);
3159   g_free (priv->text);
3160
3161   if (priv->layout)
3162     g_object_unref (priv->layout);
3163
3164   if (priv->attrs)
3165     pango_attr_list_unref (priv->attrs);
3166
3167   if (priv->effective_attrs)
3168     pango_attr_list_unref (priv->effective_attrs);
3169
3170   gtk_label_clear_links (label);
3171   g_free (priv->select_info);
3172
3173   G_OBJECT_CLASS (gtk_label_parent_class)->finalize (object);
3174 }
3175
3176 static void
3177 gtk_label_clear_layout (GtkLabel *label)
3178 {
3179   GtkLabelPrivate *priv = label->priv;
3180
3181   if (priv->layout)
3182     {
3183       g_object_unref (priv->layout);
3184       priv->layout = NULL;
3185
3186       //gtk_label_clear_links (label);
3187     }
3188 }
3189
3190 static PangoFontMetrics *
3191 get_font_metrics (PangoContext *context, GtkWidget *widget)
3192 {
3193   GtkStyleContext *style_context;
3194   PangoFontDescription *font;
3195   PangoFontMetrics *retval;
3196
3197   style_context = gtk_widget_get_style_context (widget);
3198   gtk_style_context_get (style_context, 0, "font", &font, NULL);
3199
3200   retval = pango_context_get_metrics (context,
3201                                       font,
3202                                       pango_context_get_language (context));
3203
3204   if (font != NULL)
3205     pango_font_description_free (font);
3206
3207   return retval;
3208 }
3209
3210 /**
3211  * gtk_label_get_measuring_layout:
3212  * @label: the label
3213  * @existing_layout: %NULL or an existing layout already in use.
3214  * @width: the width to measure with in pango units, or -1 for infinite
3215  *
3216  * Gets a layout that can be used for measuring sizes. The returned
3217  * layout will be identical to the label's layout except for the
3218  * layout's width, which will be set to @width. Do not modify the returned
3219  * layout.
3220  *
3221  * Returns: a new reference to a pango layout
3222  **/
3223 static PangoLayout *
3224 gtk_label_get_measuring_layout (GtkLabel *   label,
3225                                 PangoLayout *existing_layout,
3226                                 int          width)
3227 {
3228   GtkLabelPrivate *priv = label->priv;
3229   PangoRectangle rect;
3230   PangoLayout *copy;
3231
3232   if (existing_layout != NULL)
3233     {
3234       if (existing_layout != priv->layout)
3235         {
3236           pango_layout_set_width (existing_layout, width);
3237           return existing_layout;
3238         }
3239
3240       g_object_unref (existing_layout);
3241     }
3242
3243   gtk_label_ensure_layout (label);
3244
3245   if (pango_layout_get_width (priv->layout) == width)
3246     {
3247       g_object_ref (priv->layout);
3248       return priv->layout;
3249     }
3250
3251   /* We can use the label's own layout if we're not allocated a size yet,
3252    * because we don't need it to be properly setup at that point.
3253    * This way we can make use of caching upon the label's creation.
3254    */
3255   if (gtk_widget_get_allocated_width (GTK_WIDGET (label)) <= 1)
3256     {
3257       g_object_ref (priv->layout);
3258       pango_layout_set_width (priv->layout, width);
3259       return priv->layout;
3260     }
3261
3262   /* oftentimes we want to measure a width that is far wider than the current width,
3263    * even though the layout would not change if we made it wider. In that case, we
3264    * can just return the current layout, because for measuring purposes, it will be
3265    * identical.
3266    */
3267   pango_layout_get_extents (priv->layout, NULL, &rect);
3268   if ((width == -1 || rect.width <= width) &&
3269       !pango_layout_is_wrapped (priv->layout) &&
3270       !pango_layout_is_ellipsized (priv->layout))
3271     {
3272       g_object_ref (priv->layout);
3273       return priv->layout;
3274     }
3275
3276   copy = pango_layout_copy (priv->layout);
3277   pango_layout_set_width (copy, width);
3278   return copy;
3279 }
3280
3281 static void
3282 gtk_label_update_layout_width (GtkLabel *label)
3283 {
3284   GtkLabelPrivate *priv = label->priv;
3285   GtkWidget *widget = GTK_WIDGET (label);
3286
3287   g_assert (priv->layout);
3288
3289   if (priv->ellipsize || priv->wrap)
3290     {
3291       PangoRectangle logical;
3292       gint xpad, ypad;
3293       gint width, height;
3294
3295       gtk_misc_get_padding (GTK_MISC (label), &xpad, &ypad);
3296
3297       width = gtk_widget_get_allocated_width (GTK_WIDGET (label)) - xpad * 2;
3298       height = gtk_widget_get_allocated_height (GTK_WIDGET (label)) - ypad * 2;
3299
3300       if (priv->have_transform)
3301         {
3302           PangoContext *context = gtk_widget_get_pango_context (widget);
3303           const PangoMatrix *matrix = pango_context_get_matrix (context);
3304           const gdouble dx = matrix->xx; /* cos (M_PI * angle / 180) */
3305           const gdouble dy = matrix->xy; /* sin (M_PI * angle / 180) */
3306
3307           pango_layout_set_width (priv->layout, -1);
3308           pango_layout_get_pixel_extents (priv->layout, NULL, &logical);
3309
3310           if (fabs (dy) < 0.01)
3311             {
3312               if (logical.width > width)
3313                 pango_layout_set_width (priv->layout, width * PANGO_SCALE);
3314             }
3315           else if (fabs (dx) < 0.01)
3316             {
3317               if (logical.width > height)
3318                 pango_layout_set_width (priv->layout, height * PANGO_SCALE);
3319             }
3320           else
3321             {
3322               gdouble x0, y0, x1, y1, length;
3323               gboolean vertical;
3324               gint cy;
3325
3326               x0 = width / 2;
3327               y0 = dx ? x0 * dy / dx : G_MAXDOUBLE;
3328               vertical = fabs (y0) > height / 2;
3329
3330               if (vertical)
3331                 {
3332                   y0 = height/2;
3333                   x0 = dy ? y0 * dx / dy : G_MAXDOUBLE;
3334                 }
3335
3336               length = 2 * sqrt (x0 * x0 + y0 * y0);
3337               pango_layout_set_width (priv->layout, rint (length * PANGO_SCALE));
3338               pango_layout_get_pixel_size (priv->layout, NULL, &cy);
3339
3340               x1 = +dy * cy/2;
3341               y1 = -dx * cy/2;
3342
3343               if (vertical)
3344                 {
3345                   y0 = height/2 + y1 - y0;
3346                   x0 = -y0 * dx/dy;
3347                 }
3348               else
3349                 {
3350                   x0 = width/2 + x1 - x0;
3351                   y0 = -x0 * dy/dx;
3352                 }
3353
3354               length = length - sqrt (x0 * x0 + y0 * y0) * 2;
3355               pango_layout_set_width (priv->layout, rint (length * PANGO_SCALE));
3356             }
3357         }
3358       else
3359         {
3360           pango_layout_set_width (priv->layout, width * PANGO_SCALE);
3361           pango_layout_set_height (priv->layout, height * PANGO_SCALE);
3362         }
3363     }
3364   else
3365     {
3366       pango_layout_set_width (priv->layout, -1);
3367       pango_layout_set_height (priv->layout, -1);
3368     }
3369 }
3370
3371 static void
3372 gtk_label_ensure_layout (GtkLabel *label)
3373 {
3374   GtkLabelPrivate *priv = label->priv;
3375   GtkWidget *widget;
3376   gboolean rtl;
3377
3378   widget = GTK_WIDGET (label);
3379
3380   rtl = gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL;
3381
3382   if (!priv->layout)
3383     {
3384       PangoAlignment align = PANGO_ALIGN_LEFT; /* Quiet gcc */
3385       gdouble angle = gtk_label_get_angle (label);
3386
3387       if (angle != 0.0 && !priv->select_info)
3388         {
3389           PangoMatrix matrix = PANGO_MATRIX_INIT;
3390
3391           /* We rotate the standard singleton PangoContext for the widget,
3392            * depending on the fact that it's meant pretty much exclusively
3393            * for our use.
3394            */
3395           pango_matrix_rotate (&matrix, angle);
3396
3397           pango_context_set_matrix (gtk_widget_get_pango_context (widget), &matrix);
3398
3399           priv->have_transform = TRUE;
3400         }
3401       else
3402         {
3403           if (priv->have_transform)
3404             pango_context_set_matrix (gtk_widget_get_pango_context (widget), NULL);
3405
3406           priv->have_transform = FALSE;
3407         }
3408
3409       priv->layout = gtk_widget_create_pango_layout (widget, priv->text);
3410
3411       if (priv->effective_attrs)
3412         pango_layout_set_attributes (priv->layout, priv->effective_attrs);
3413
3414       gtk_label_rescan_links (label);
3415
3416       switch (priv->jtype)
3417         {
3418         case GTK_JUSTIFY_LEFT:
3419           align = rtl ? PANGO_ALIGN_RIGHT : PANGO_ALIGN_LEFT;
3420           break;
3421         case GTK_JUSTIFY_RIGHT:
3422           align = rtl ? PANGO_ALIGN_LEFT : PANGO_ALIGN_RIGHT;
3423           break;
3424         case GTK_JUSTIFY_CENTER:
3425           align = PANGO_ALIGN_CENTER;
3426           break;
3427         case GTK_JUSTIFY_FILL:
3428           align = rtl ? PANGO_ALIGN_RIGHT : PANGO_ALIGN_LEFT;
3429           pango_layout_set_justify (priv->layout, TRUE);
3430           break;
3431         default:
3432           g_assert_not_reached();
3433         }
3434
3435       pango_layout_set_alignment (priv->layout, align);
3436       pango_layout_set_ellipsize (priv->layout, priv->ellipsize);
3437       pango_layout_set_wrap (priv->layout, priv->wrap_mode);
3438       pango_layout_set_single_paragraph_mode (priv->layout, priv->single_line_mode);
3439
3440       gtk_label_update_layout_width (label);
3441     }
3442 }
3443
3444 static gint
3445 get_single_line_height (GtkWidget   *widget,
3446                         PangoLayout *layout)
3447 {
3448   PangoContext *context;
3449   PangoFontMetrics *metrics;
3450   gint ascent, descent;
3451
3452   context = pango_layout_get_context (layout);
3453   metrics = get_font_metrics (context, widget);
3454   ascent = pango_font_metrics_get_ascent (metrics);
3455   descent = pango_font_metrics_get_descent (metrics);
3456   pango_font_metrics_unref (metrics);
3457
3458   return ascent + descent;
3459 }
3460
3461 static GtkSizeRequestMode
3462 gtk_label_get_request_mode (GtkWidget *widget)
3463 {
3464   GtkLabel *label = GTK_LABEL (widget);
3465   gdouble   angle = gtk_label_get_angle (label);
3466
3467   if (label->priv->wrap)
3468     return (angle == 90 || angle == 270) ?
3469       GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT :
3470       GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH;
3471
3472     return GTK_SIZE_REQUEST_CONSTANT_SIZE;
3473 }
3474
3475 static void
3476 get_size_for_allocation (GtkLabel        *label,
3477                          GtkOrientation   orientation,
3478                          gint             allocation,
3479                          gint            *minimum_size,
3480                          gint            *natural_size)
3481 {
3482   PangoLayout *layout;
3483   gint text_height;
3484
3485   layout = gtk_label_get_measuring_layout (label, NULL, allocation * PANGO_SCALE);
3486
3487   pango_layout_get_pixel_size (layout, NULL, &text_height);
3488
3489   if (minimum_size)
3490     *minimum_size = text_height;
3491
3492   if (natural_size)
3493     *natural_size = text_height;
3494
3495   g_object_unref (layout);
3496 }
3497
3498 static gint
3499 get_char_pixels (GtkWidget   *label,
3500                  PangoLayout *layout)
3501 {
3502   PangoContext *context;
3503   PangoFontMetrics *metrics;
3504   gint char_width, digit_width;
3505
3506   context = pango_layout_get_context (layout);
3507   metrics = get_font_metrics (context, GTK_WIDGET (label));
3508   char_width = pango_font_metrics_get_approximate_char_width (metrics);
3509   digit_width = pango_font_metrics_get_approximate_digit_width (metrics);
3510   pango_font_metrics_unref (metrics);
3511
3512   return MAX (char_width, digit_width);;
3513 }
3514
3515 static void
3516 gtk_label_get_preferred_layout_size (GtkLabel *label,
3517                                      PangoRectangle *required,
3518                                      PangoRectangle *natural)
3519 {
3520   GtkLabelPrivate *priv = label->priv;
3521   PangoLayout *layout;
3522
3523   /* "width-chars" Hard-coded minimum width:
3524    *    - minimum size should be MAX (width-chars, strlen ("..."));
3525    *    - natural size should be MAX (width-chars, strlen (priv->text));
3526    *
3527    * "max-width-chars" User specified maximum size requisition
3528    *    - minimum size should be MAX (width-chars, 0)
3529    *    - natural size should be MIN (max-width-chars, strlen (priv->text))
3530    *
3531    *    For ellipsizing labels; if max-width-chars is specified: either it is used as
3532    *    a minimum size or the label text as a minimum size (natural size still overflows).
3533    *
3534    *    For wrapping labels; A reasonable minimum size is useful to naturally layout
3535    *    interfaces automatically. In this case if no "width-chars" is specified, the minimum
3536    *    width will default to the wrap guess that gtk_label_ensure_layout() does.
3537    */
3538
3539   /* Start off with the pixel extents of an as-wide-as-possible layout */
3540   layout = gtk_label_get_measuring_layout (label, NULL, -1);
3541
3542   pango_layout_get_extents (layout, NULL, natural);
3543   natural->x = natural->y = 0;
3544
3545   if (priv->single_line_mode || priv->wrap)
3546     natural->height = get_single_line_height (GTK_WIDGET (label), layout);
3547
3548   if (priv->ellipsize || priv->wrap)
3549     {
3550       /* a layout with widdth 0 will be as small as humanly possible */
3551       layout = gtk_label_get_measuring_layout (label, layout, 0);
3552
3553       pango_layout_get_extents (layout, NULL, required);
3554       required->x = required->y = 0;
3555       required->height = natural->height;
3556     }
3557   else
3558     {
3559       *required = *natural;
3560     }
3561
3562   if (priv->width_chars > -1 || priv->max_width_chars > -1)
3563     {
3564       gint char_pixels;
3565
3566       char_pixels = get_char_pixels (GTK_WIDGET (label), layout);
3567
3568       if (priv->width_chars > -1)
3569         required->width = MAX (required->width, char_pixels * priv->width_chars);
3570
3571       if (priv->max_width_chars > -1)
3572         natural->width = MIN (natural->width, priv->max_width_chars * char_pixels);
3573       natural->width = MAX (natural->width, required->width);
3574     }
3575
3576   g_object_unref (layout);
3577 }
3578
3579 static void
3580 gtk_label_get_preferred_size (GtkWidget      *widget,
3581                               GtkOrientation  orientation,
3582                               gint           *minimum_size,
3583                               gint           *natural_size)
3584 {
3585   GtkLabel      *label = GTK_LABEL (widget);
3586   GtkLabelPrivate  *priv = label->priv;
3587   PangoRectangle required_rect;
3588   PangoRectangle natural_rect;
3589   gint           xpad, ypad;
3590
3591   gtk_label_get_preferred_layout_size (label, &required_rect, &natural_rect);
3592
3593   /* Now that we have minimum and natural sizes in pango extents, apply a possible transform */
3594   if (priv->have_transform)
3595     {
3596       PangoLayout *copy;
3597       PangoContext *context;
3598       const PangoMatrix *matrix;
3599
3600       copy = pango_layout_copy (priv->layout);
3601       context = pango_layout_get_context (copy);
3602       matrix = pango_context_get_matrix (context);
3603
3604       pango_layout_set_width (copy, -1);
3605       pango_layout_set_ellipsize (copy, PANGO_ELLIPSIZE_NONE);
3606
3607       pango_layout_get_extents (copy, NULL, &natural_rect);
3608       g_object_unref (copy);
3609
3610       pango_matrix_transform_rectangle (matrix, &required_rect);
3611       pango_matrix_transform_rectangle (matrix, &natural_rect);
3612
3613       /* Bump the natural size in case of ellipsize to ensure pango has
3614        * enough space in the angles (note, we could alternatively set the
3615        * layout to not ellipsize when we know we have been allocated our
3616        * full natural size, or it may be that pango needs a fix here).
3617        */
3618       if (priv->ellipsize && priv->angle != 0 && priv->angle != 90 &&
3619           priv->angle != 180 && priv->angle != 270 && priv->angle != 360)
3620         {
3621           /* For some reason we only need this at about 110 degrees, and only
3622            * when gaining in height
3623            */
3624           natural_rect.height += ROTATION_ELLIPSIZE_PADDING * 2 * PANGO_SCALE;
3625           natural_rect.width  += ROTATION_ELLIPSIZE_PADDING * 2 * PANGO_SCALE;
3626         }
3627     }
3628
3629   required_rect.width  = PANGO_PIXELS_CEIL (required_rect.width);
3630   required_rect.height = PANGO_PIXELS_CEIL (required_rect.height);
3631
3632   natural_rect.width  = PANGO_PIXELS_CEIL (natural_rect.width);
3633   natural_rect.height = PANGO_PIXELS_CEIL (natural_rect.height);
3634
3635   gtk_misc_get_padding (GTK_MISC (label), &xpad, &ypad);
3636
3637   if (orientation == GTK_ORIENTATION_HORIZONTAL)
3638     {
3639       /* Note, we cant use get_size_for_allocation() when rotating
3640        * ellipsized labels.
3641        */
3642       if (!(priv->ellipsize && priv->have_transform) &&
3643           (priv->angle == 90 || priv->angle == 270))
3644         {
3645           /* Doing a h4w request on a rotated label here, return the
3646            * required width for the minimum height.
3647            */
3648           get_size_for_allocation (label,
3649                                    GTK_ORIENTATION_VERTICAL,
3650                                    required_rect.height,
3651                                    minimum_size, natural_size);
3652
3653         }
3654       else
3655         {
3656           /* Normal desired width */
3657           *minimum_size = required_rect.width;
3658           *natural_size = natural_rect.width;
3659         }
3660
3661       *minimum_size += xpad * 2;
3662       *natural_size += xpad * 2;
3663     }
3664   else /* GTK_ORIENTATION_VERTICAL */
3665     {
3666       /* Note, we cant use get_size_for_allocation() when rotating
3667        * ellipsized labels.
3668        */
3669       if (!(priv->ellipsize && priv->have_transform) &&
3670           (priv->angle == 0 || priv->angle == 180 || priv->angle == 360))
3671         {
3672           /* Doing a w4h request on a label here, return the required
3673            * height for the minimum width.
3674            */
3675           get_size_for_allocation (label,
3676                                    GTK_ORIENTATION_HORIZONTAL,
3677                                    required_rect.width,
3678                                    minimum_size, natural_size);
3679         }
3680       else
3681         {
3682           /* A vertically rotated label does w4h, so return the base
3683            * desired height (text length)
3684            */
3685           *minimum_size = required_rect.height;
3686           *natural_size = natural_rect.height;
3687         }
3688
3689       *minimum_size += ypad * 2;
3690       *natural_size += ypad * 2;
3691     }
3692 }
3693
3694
3695 static void
3696 gtk_label_get_preferred_width (GtkWidget *widget,
3697                                gint      *minimum_size,
3698                                gint      *natural_size)
3699 {
3700   gtk_label_get_preferred_size (widget, GTK_ORIENTATION_HORIZONTAL, minimum_size, natural_size);
3701 }
3702
3703 static void
3704 gtk_label_get_preferred_height (GtkWidget *widget,
3705                                 gint      *minimum_size,
3706                                 gint      *natural_size)
3707 {
3708   gtk_label_get_preferred_size (widget, GTK_ORIENTATION_VERTICAL, minimum_size, natural_size);
3709 }
3710
3711 static void
3712 gtk_label_get_preferred_width_for_height (GtkWidget *widget,
3713                                           gint       height,
3714                                           gint      *minimum_width,
3715                                           gint      *natural_width)
3716 {
3717   GtkLabel *label = GTK_LABEL (widget);
3718   GtkLabelPrivate *priv = label->priv;
3719
3720   if (priv->wrap && (priv->angle == 90 || priv->angle == 270))
3721     {
3722       gint xpad, ypad;
3723
3724       gtk_misc_get_padding (GTK_MISC (label), &xpad, &ypad);
3725
3726       if (priv->wrap)
3727         gtk_label_clear_layout (label);
3728
3729       get_size_for_allocation (label, GTK_ORIENTATION_VERTICAL,
3730                                MAX (1, height - (ypad * 2)),
3731                                minimum_width, natural_width);
3732
3733       if (minimum_width)
3734         *minimum_width += xpad * 2;
3735
3736       if (natural_width)
3737         *natural_width += xpad * 2;
3738     }
3739   else
3740     GTK_WIDGET_GET_CLASS (widget)->get_preferred_width (widget, minimum_width, natural_width);
3741 }
3742
3743 static void
3744 gtk_label_get_preferred_height_for_width (GtkWidget *widget,
3745                                           gint       width,
3746                                           gint      *minimum_height,
3747                                           gint      *natural_height)
3748 {
3749   GtkLabel *label = GTK_LABEL (widget);
3750   GtkLabelPrivate *priv = label->priv;
3751
3752   if (priv->wrap && (priv->angle == 0 || priv->angle == 180 || priv->angle == 360))
3753     {
3754       gint xpad, ypad;
3755
3756       gtk_misc_get_padding (GTK_MISC (label), &xpad, &ypad);
3757
3758       if (priv->wrap)
3759         gtk_label_clear_layout (label);
3760
3761       get_size_for_allocation (label, GTK_ORIENTATION_HORIZONTAL,
3762                                MAX (1, width - xpad * 2),
3763                                minimum_height, natural_height);
3764
3765       if (minimum_height)
3766         *minimum_height += ypad * 2;
3767
3768       if (natural_height)
3769         *natural_height += ypad * 2;
3770     }
3771   else
3772     GTK_WIDGET_GET_CLASS (widget)->get_preferred_height (widget, minimum_height, natural_height);
3773 }
3774
3775 static void
3776 gtk_label_size_allocate (GtkWidget     *widget,
3777                          GtkAllocation *allocation)
3778 {
3779   GtkLabel *label = GTK_LABEL (widget);
3780   GtkLabelPrivate *priv = label->priv;
3781
3782   GTK_WIDGET_CLASS (gtk_label_parent_class)->size_allocate (widget, allocation);
3783
3784   if (priv->layout)
3785     gtk_label_update_layout_width (label);
3786
3787   if (priv->select_info && priv->select_info->window)
3788     {
3789       gdk_window_move_resize (priv->select_info->window,
3790                               allocation->x,
3791                               allocation->y,
3792                               allocation->width,
3793                               allocation->height);
3794     }
3795 }
3796
3797 static void
3798 gtk_label_update_cursor (GtkLabel *label)
3799 {
3800   GtkLabelPrivate *priv = label->priv;
3801   GtkWidget *widget;
3802
3803   if (!priv->select_info)
3804     return;
3805
3806   widget = GTK_WIDGET (label);
3807
3808   if (gtk_widget_get_realized (widget))
3809     {
3810       GdkDisplay *display;
3811       GdkCursor *cursor;
3812
3813       if (gtk_widget_is_sensitive (widget))
3814         {
3815           display = gtk_widget_get_display (widget);
3816
3817           if (priv->select_info->active_link)
3818             cursor = gdk_cursor_new_for_display (display, GDK_HAND2);
3819           else if (priv->select_info->selectable)
3820             cursor = gdk_cursor_new_for_display (display, GDK_XTERM);
3821           else
3822             cursor = NULL;
3823         }
3824       else
3825         cursor = NULL;
3826
3827       gdk_window_set_cursor (priv->select_info->window, cursor);
3828
3829       if (cursor)
3830         g_object_unref (cursor);
3831     }
3832 }
3833
3834 static void
3835 gtk_label_state_changed (GtkWidget   *widget,
3836                          GtkStateType prev_state)
3837 {
3838   GtkLabel *label = GTK_LABEL (widget);
3839   GtkLabelPrivate *priv = label->priv;
3840
3841   if (priv->select_info)
3842     {
3843       if (!gtk_widget_is_sensitive (widget))
3844         gtk_label_select_region (label, 0, 0);
3845
3846       gtk_label_update_cursor (label);
3847     }
3848
3849   if (GTK_WIDGET_CLASS (gtk_label_parent_class)->state_changed)
3850     GTK_WIDGET_CLASS (gtk_label_parent_class)->state_changed (widget, prev_state);
3851 }
3852
3853 static void
3854 gtk_label_style_updated (GtkWidget *widget)
3855 {
3856   GtkLabel *label = GTK_LABEL (widget);
3857
3858   GTK_WIDGET_CLASS (gtk_label_parent_class)->style_updated (widget);
3859
3860   /* We have to clear the layout, fonts etc. may have changed */
3861   gtk_label_clear_layout (label);
3862 }
3863
3864 static void
3865 gtk_label_direction_changed (GtkWidget        *widget,
3866                              GtkTextDirection previous_dir)
3867 {
3868   GtkLabel *label = GTK_LABEL (widget);
3869   GtkLabelPrivate *priv = label->priv;
3870
3871   if (priv->layout)
3872     pango_layout_context_changed (priv->layout);
3873
3874   GTK_WIDGET_CLASS (gtk_label_parent_class)->direction_changed (widget, previous_dir);
3875 }
3876
3877 static void
3878 get_layout_location (GtkLabel  *label,
3879                      gint      *xp,
3880                      gint      *yp)
3881 {
3882   GtkAllocation allocation;
3883   GtkMisc *misc;
3884   GtkWidget *widget;
3885   GtkLabelPrivate *priv;
3886   gint req_width, x, y;
3887   gint req_height;
3888   gint xpad, ypad;
3889   gfloat xalign, yalign;
3890   PangoRectangle logical;
3891
3892   misc   = GTK_MISC (label);
3893   widget = GTK_WIDGET (label);
3894   priv   = label->priv;
3895
3896   gtk_misc_get_alignment (misc, &xalign, &yalign);
3897   gtk_misc_get_padding (misc, &xpad, &ypad);
3898
3899   if (gtk_widget_get_direction (widget) != GTK_TEXT_DIR_LTR)
3900     xalign = 1.0 - xalign;
3901
3902   pango_layout_get_extents (priv->layout, NULL, &logical);
3903
3904   if (priv->have_transform)
3905     {
3906       PangoContext *context = gtk_widget_get_pango_context (widget);
3907       const PangoMatrix *matrix = pango_context_get_matrix (context);
3908       pango_matrix_transform_rectangle (matrix, &logical);
3909     }
3910
3911   pango_extents_to_pixels (&logical, NULL);
3912
3913   req_width  = logical.width;
3914   req_height = logical.height;
3915
3916   req_width  += 2 * xpad;
3917   req_height += 2 * ypad;
3918
3919   gtk_widget_get_allocation (widget, &allocation);
3920
3921   x = floor (allocation.x + xpad + xalign * (allocation.width - req_width));
3922
3923   if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_LTR)
3924     x = MAX (x, allocation.x + xpad);
3925   else
3926     x = MIN (x, allocation.x + allocation.width - xpad);
3927
3928
3929   /* bgo#315462 - For single-line labels, *do* align the requisition with
3930    * respect to the allocation, even if we are under-allocated.  For multi-line
3931    * labels, always show the top of the text when they are under-allocated.  The
3932    * rationale is this:
3933    *
3934    * - Single-line labels appear in GtkButtons, and it is very easy to get them
3935    *   to be smaller than their requisition.  The button may clip the label, but
3936    *   the label will still be able to show most of itself and the focus
3937    *   rectangle.  Also, it is fairly easy to read a single line of clipped text.
3938    *
3939    * - Multi-line labels should not be clipped to showing "something in the
3940    *   middle".  You want to read the first line, at least, to get some context.
3941    */
3942   if (pango_layout_get_line_count (priv->layout) == 1)
3943     y = floor (allocation.y + ypad + (allocation.height - req_height) * yalign);
3944   else
3945     y = floor (allocation.y + ypad + MAX ((allocation.height - req_height) * yalign, 0));
3946
3947   if (xp)
3948     *xp = x;
3949
3950   if (yp)
3951     *yp = y;
3952 }
3953
3954 static void
3955 draw_insertion_cursor (GtkLabel      *label,
3956                        cairo_t       *cr,
3957                        GdkRectangle  *cursor_location,
3958                        gboolean       is_primary,
3959                        PangoDirection direction,
3960                        gboolean       draw_arrow)
3961 {
3962   GtkWidget *widget = GTK_WIDGET (label);
3963   GtkTextDirection text_dir;
3964
3965   if (direction == PANGO_DIRECTION_LTR)
3966     text_dir = GTK_TEXT_DIR_LTR;
3967   else
3968     text_dir = GTK_TEXT_DIR_RTL;
3969
3970   gtk_draw_insertion_cursor (widget, cr, cursor_location,
3971                              is_primary, text_dir, draw_arrow);
3972 }
3973
3974 static PangoDirection
3975 get_cursor_direction (GtkLabel *label)
3976 {
3977   GtkLabelPrivate *priv = label->priv;
3978   GSList *l;
3979
3980   g_assert (priv->select_info);
3981
3982   gtk_label_ensure_layout (label);
3983
3984   for (l = pango_layout_get_lines_readonly (priv->layout); l; l = l->next)
3985     {
3986       PangoLayoutLine *line = l->data;
3987
3988       /* If priv->select_info->selection_end is at the very end of
3989        * the line, we don't know if the cursor is on this line or
3990        * the next without looking ahead at the next line. (End
3991        * of paragraph is different from line break.) But it's
3992        * definitely in this paragraph, which is good enough
3993        * to figure out the resolved direction.
3994        */
3995        if (line->start_index + line->length >= priv->select_info->selection_end)
3996         return line->resolved_dir;
3997     }
3998
3999   return PANGO_DIRECTION_LTR;
4000 }
4001
4002 static void
4003 gtk_label_draw_cursor (GtkLabel  *label, cairo_t *cr, gint xoffset, gint yoffset)
4004 {
4005   GtkLabelPrivate *priv = label->priv;
4006   GtkWidget *widget;
4007
4008   if (priv->select_info == NULL)
4009     return;
4010
4011   widget = GTK_WIDGET (label);
4012
4013   if (gtk_widget_is_drawable (widget))
4014     {
4015       PangoDirection keymap_direction;
4016       PangoDirection cursor_direction;
4017       PangoRectangle strong_pos, weak_pos;
4018       gboolean split_cursor;
4019       PangoRectangle *cursor1 = NULL;
4020       PangoRectangle *cursor2 = NULL;
4021       GdkRectangle cursor_location;
4022       PangoDirection dir1 = PANGO_DIRECTION_NEUTRAL;
4023       PangoDirection dir2 = PANGO_DIRECTION_NEUTRAL;
4024
4025       keymap_direction = gdk_keymap_get_direction (gdk_keymap_get_for_display (gtk_widget_get_display (widget)));
4026       cursor_direction = get_cursor_direction (label);
4027
4028       gtk_label_ensure_layout (label);
4029
4030       pango_layout_get_cursor_pos (priv->layout, priv->select_info->selection_end,
4031                                    &strong_pos, &weak_pos);
4032
4033       g_object_get (gtk_widget_get_settings (widget),
4034                     "gtk-split-cursor", &split_cursor,
4035                     NULL);
4036
4037       dir1 = cursor_direction;
4038
4039       if (split_cursor)
4040         {
4041           cursor1 = &strong_pos;
4042
4043           if (strong_pos.x != weak_pos.x ||
4044               strong_pos.y != weak_pos.y)
4045             {
4046               dir2 = (cursor_direction == PANGO_DIRECTION_LTR) ? PANGO_DIRECTION_RTL : PANGO_DIRECTION_LTR;
4047               cursor2 = &weak_pos;
4048             }
4049         }
4050       else
4051         {
4052           if (keymap_direction == cursor_direction)
4053             cursor1 = &strong_pos;
4054           else
4055             cursor1 = &weak_pos;
4056         }
4057
4058       cursor_location.x = xoffset + PANGO_PIXELS (cursor1->x);
4059       cursor_location.y = yoffset + PANGO_PIXELS (cursor1->y);
4060       cursor_location.width = 0;
4061       cursor_location.height = PANGO_PIXELS (cursor1->height);
4062
4063       draw_insertion_cursor (label, cr,
4064                              &cursor_location, TRUE, dir1,
4065                              dir2 != PANGO_DIRECTION_NEUTRAL);
4066
4067       if (dir2 != PANGO_DIRECTION_NEUTRAL)
4068         {
4069           cursor_location.x = xoffset + PANGO_PIXELS (cursor2->x);
4070           cursor_location.y = yoffset + PANGO_PIXELS (cursor2->y);
4071           cursor_location.width = 0;
4072           cursor_location.height = PANGO_PIXELS (cursor2->height);
4073
4074           draw_insertion_cursor (label, cr,
4075                                  &cursor_location, FALSE, dir2,
4076                                  TRUE);
4077         }
4078     }
4079 }
4080
4081 static GtkLabelLink *
4082 gtk_label_get_focus_link (GtkLabel *label)
4083 {
4084   GtkLabelPrivate *priv = label->priv;
4085   GtkLabelSelectionInfo *info = priv->select_info;
4086   GList *l;
4087
4088   if (!info)
4089     return NULL;
4090
4091   if (info->selection_anchor != info->selection_end)
4092     return NULL;
4093
4094   for (l = info->links; l; l = l->next)
4095     {
4096       GtkLabelLink *link = l->data;
4097       if (link->start <= info->selection_anchor &&
4098           info->selection_anchor <= link->end)
4099         return link;
4100     }
4101
4102   return NULL;
4103 }
4104
4105 static gint
4106 gtk_label_draw (GtkWidget *widget,
4107                 cairo_t   *cr)
4108 {
4109   GtkLabel *label = GTK_LABEL (widget);
4110   GtkLabelPrivate *priv = label->priv;
4111   GtkLabelSelectionInfo *info = priv->select_info;
4112   GtkAllocation allocation;
4113   GtkStyleContext *context;
4114   GtkStateFlags state;
4115   gint x, y;
4116
4117   gtk_label_ensure_layout (label);
4118
4119   if (priv->text && (*priv->text != '\0'))
4120     {
4121       GdkRGBA *bg_color, *fg_color;
4122
4123       get_layout_location (label, &x, &y);
4124
4125       context = gtk_widget_get_style_context (widget);
4126       gtk_widget_get_allocation (widget, &allocation);
4127
4128       cairo_translate (cr, -allocation.x, -allocation.y);
4129
4130       state = gtk_widget_get_state_flags (widget);
4131       gtk_style_context_set_state (context, state);
4132
4133       gtk_render_layout (context, cr,
4134                          x, y,
4135                          priv->layout);
4136
4137       if (info &&
4138           (info->selection_anchor != info->selection_end))
4139         {
4140           gint range[2];
4141           cairo_region_t *clip;
4142
4143           range[0] = info->selection_anchor;
4144           range[1] = info->selection_end;
4145
4146           if (range[0] > range[1])
4147             {
4148               gint tmp = range[0];
4149               range[0] = range[1];
4150               range[1] = tmp;
4151             }
4152
4153           clip = gdk_pango_layout_get_clip_region (priv->layout,
4154                                                    x, y,
4155                                                    range,
4156                                                    1);
4157
4158          /* FIXME should use gtk_paint, but it can't use a clip region */
4159           cairo_save (cr);
4160
4161           gdk_cairo_region (cr, clip);
4162           cairo_clip (cr);
4163
4164           state = GTK_STATE_FLAG_SELECTED;
4165
4166           if (gtk_widget_has_focus (widget))
4167             state |= GTK_STATE_FLAG_FOCUSED;
4168
4169           gtk_style_context_get (context, state,
4170                                  "background-color", &bg_color,
4171                                  "color", &fg_color,
4172                                  NULL);
4173
4174           gdk_cairo_set_source_rgba (cr, bg_color);
4175           cairo_paint (cr);
4176
4177           gdk_cairo_set_source_rgba (cr, fg_color);
4178           cairo_move_to (cr, x, y);
4179           _gtk_pango_fill_layout (cr, priv->layout);
4180
4181           cairo_restore (cr);
4182           cairo_region_destroy (clip);
4183
4184           gdk_rgba_free (bg_color);
4185           gdk_rgba_free (fg_color);
4186         }
4187       else if (info)
4188         {
4189           GtkLabelLink *focus_link;
4190           GtkLabelLink *active_link;
4191           gint range[2];
4192           cairo_region_t *clip;
4193           GdkRectangle rect;
4194           GdkColor *text_color;
4195           GdkColor *link_color;
4196           GdkColor *visited_link_color;
4197
4198           if (info->selectable && gtk_widget_has_focus (widget))
4199             gtk_label_draw_cursor (label, cr, x, y);
4200
4201           focus_link = gtk_label_get_focus_link (label);
4202           active_link = info->active_link;
4203
4204
4205           if (active_link)
4206             {
4207               GdkRGBA *bg_color;
4208
4209               range[0] = active_link->start;
4210               range[1] = active_link->end;
4211
4212               cairo_save (cr);
4213
4214               clip = gdk_pango_layout_get_clip_region (priv->layout,
4215                                                        x, y,
4216                                                        range,
4217                                                        1);
4218               gdk_cairo_region (cr, clip);
4219               cairo_clip (cr);
4220               cairo_region_destroy (clip);
4221
4222               gtk_label_get_link_colors (widget, &link_color, &visited_link_color);
4223               if (active_link->visited)
4224                 text_color = visited_link_color;
4225               else
4226                 text_color = link_color;
4227
4228               if (info->link_clicked)
4229                 state = GTK_STATE_FLAG_ACTIVE;
4230               else
4231                 state = GTK_STATE_FLAG_PRELIGHT;
4232
4233               gtk_style_context_get (context, state,
4234                                      "background-color", &bg_color,
4235                                      NULL);
4236
4237               gdk_cairo_set_source_rgba (cr, bg_color);
4238               cairo_paint (cr);
4239
4240               gdk_cairo_set_source_color (cr, text_color);
4241               cairo_move_to (cr, x, y);
4242               _gtk_pango_fill_layout (cr, priv->layout);
4243
4244               gdk_color_free (link_color);
4245               gdk_color_free (visited_link_color);
4246               gdk_rgba_free (bg_color);
4247
4248               cairo_restore (cr);
4249             }
4250
4251           if (focus_link && gtk_widget_has_focus (widget))
4252             {
4253               range[0] = focus_link->start;
4254               range[1] = focus_link->end;
4255
4256               clip = gdk_pango_layout_get_clip_region (priv->layout,
4257                                                        x, y,
4258                                                        range,
4259                                                        1);
4260               cairo_region_get_extents (clip, &rect);
4261
4262               state = gtk_widget_get_state_flags (widget);
4263               gtk_style_context_set_state (context, state);
4264
4265               gtk_render_focus (context, cr,
4266                                 rect.x, rect.y,
4267                                 rect.width, rect.height);
4268
4269               cairo_region_destroy (clip);
4270             }
4271         }
4272     }
4273
4274   return FALSE;
4275 }
4276
4277 static gboolean
4278 separate_uline_pattern (const gchar  *str,
4279                         guint        *accel_key,
4280                         gchar       **new_str,
4281                         gchar       **pattern)
4282 {
4283   gboolean underscore;
4284   const gchar *src;
4285   gchar *dest;
4286   gchar *pattern_dest;
4287
4288   *accel_key = GDK_KEY_VoidSymbol;
4289   *new_str = g_new (gchar, strlen (str) + 1);
4290   *pattern = g_new (gchar, g_utf8_strlen (str, -1) + 1);
4291
4292   underscore = FALSE;
4293
4294   src = str;
4295   dest = *new_str;
4296   pattern_dest = *pattern;
4297
4298   while (*src)
4299     {
4300       gunichar c;
4301       const gchar *next_src;
4302
4303       c = g_utf8_get_char (src);
4304       if (c == (gunichar)-1)
4305         {
4306           g_warning ("Invalid input string");
4307           g_free (*new_str);
4308           g_free (*pattern);
4309
4310           return FALSE;
4311         }
4312       next_src = g_utf8_next_char (src);
4313
4314       if (underscore)
4315         {
4316           if (c == '_')
4317             *pattern_dest++ = ' ';
4318           else
4319             {
4320               *pattern_dest++ = '_';
4321               if (*accel_key == GDK_KEY_VoidSymbol)
4322                 *accel_key = gdk_keyval_to_lower (gdk_unicode_to_keyval (c));
4323             }
4324
4325           while (src < next_src)
4326             *dest++ = *src++;
4327
4328           underscore = FALSE;
4329         }
4330       else
4331         {
4332           if (c == '_')
4333             {
4334               underscore = TRUE;
4335               src = next_src;
4336             }
4337           else
4338             {
4339               while (src < next_src)
4340                 *dest++ = *src++;
4341
4342               *pattern_dest++ = ' ';
4343             }
4344         }
4345     }
4346
4347   *dest = 0;
4348   *pattern_dest = 0;
4349
4350   return TRUE;
4351 }
4352
4353 static void
4354 gtk_label_set_uline_text_internal (GtkLabel    *label,
4355                                    const gchar *str)
4356 {
4357   GtkLabelPrivate *priv = label->priv;
4358   guint accel_key = GDK_KEY_VoidSymbol;
4359   gchar *new_str;
4360   gchar *pattern;
4361
4362   g_return_if_fail (GTK_IS_LABEL (label));
4363   g_return_if_fail (str != NULL);
4364
4365   /* Split text into the base text and a separate pattern
4366    * of underscores.
4367    */
4368   if (!separate_uline_pattern (str, &accel_key, &new_str, &pattern))
4369     return;
4370
4371   gtk_label_set_text_internal (label, new_str);
4372   gtk_label_set_pattern_internal (label, pattern, TRUE);
4373   priv->mnemonic_keyval = accel_key;
4374
4375   g_free (pattern);
4376 }
4377
4378 /**
4379  * gtk_label_set_text_with_mnemonic:
4380  * @label: a #GtkLabel
4381  * @str: a string
4382  *
4383  * Sets the label's text from the string @str.
4384  * If characters in @str are preceded by an underscore, they are underlined
4385  * indicating that they represent a keyboard accelerator called a mnemonic.
4386  * The mnemonic key can be used to activate another widget, chosen
4387  * automatically, or explicitly using gtk_label_set_mnemonic_widget().
4388  **/
4389 void
4390 gtk_label_set_text_with_mnemonic (GtkLabel    *label,
4391                                   const gchar *str)
4392 {
4393   g_return_if_fail (GTK_IS_LABEL (label));
4394   g_return_if_fail (str != NULL);
4395
4396   g_object_freeze_notify (G_OBJECT (label));
4397
4398   gtk_label_set_label_internal (label, g_strdup (str ? str : ""));
4399   gtk_label_set_use_markup_internal (label, FALSE);
4400   gtk_label_set_use_underline_internal (label, TRUE);
4401
4402   gtk_label_recalculate (label);
4403
4404   g_object_thaw_notify (G_OBJECT (label));
4405 }
4406
4407 static void
4408 gtk_label_realize (GtkWidget *widget)
4409 {
4410   GtkLabel *label = GTK_LABEL (widget);
4411   GtkLabelPrivate *priv = label->priv;
4412
4413   GTK_WIDGET_CLASS (gtk_label_parent_class)->realize (widget);
4414
4415   if (priv->select_info)
4416     gtk_label_create_window (label);
4417 }
4418
4419 static void
4420 gtk_label_unrealize (GtkWidget *widget)
4421 {
4422   GtkLabel *label = GTK_LABEL (widget);
4423   GtkLabelPrivate *priv = label->priv;
4424
4425   if (priv->select_info)
4426     gtk_label_destroy_window (label);
4427
4428   GTK_WIDGET_CLASS (gtk_label_parent_class)->unrealize (widget);
4429 }
4430
4431 static void
4432 gtk_label_map (GtkWidget *widget)
4433 {
4434   GtkLabel *label = GTK_LABEL (widget);
4435   GtkLabelPrivate *priv = label->priv;
4436
4437   GTK_WIDGET_CLASS (gtk_label_parent_class)->map (widget);
4438
4439   if (priv->select_info)
4440     gdk_window_show (priv->select_info->window);
4441 }
4442
4443 static void
4444 gtk_label_unmap (GtkWidget *widget)
4445 {
4446   GtkLabel *label = GTK_LABEL (widget);
4447   GtkLabelPrivate *priv = label->priv;
4448
4449   if (priv->select_info)
4450     gdk_window_hide (priv->select_info->window);
4451
4452   GTK_WIDGET_CLASS (gtk_label_parent_class)->unmap (widget);
4453 }
4454
4455 static void
4456 window_to_layout_coords (GtkLabel *label,
4457                          gint     *x,
4458                          gint     *y)
4459 {
4460   GtkAllocation allocation;
4461   gint lx, ly;
4462   GtkWidget *widget;
4463
4464   widget = GTK_WIDGET (label);
4465
4466   /* get layout location in widget->window coords */
4467   get_layout_location (label, &lx, &ly);
4468
4469   gtk_widget_get_allocation (widget, &allocation);
4470
4471   if (x)
4472     {
4473       *x += allocation.x; /* go to widget->window */
4474       *x -= lx;                   /* go to layout */
4475     }
4476
4477   if (y)
4478     {
4479       *y += allocation.y; /* go to widget->window */
4480       *y -= ly;                   /* go to layout */
4481     }
4482 }
4483
4484 #if 0
4485 static void
4486 layout_to_window_coords (GtkLabel *label,
4487                          gint     *x,
4488                          gint     *y)
4489 {
4490   gint lx, ly;
4491   GtkWidget *widget;
4492
4493   widget = GTK_WIDGET (label);
4494
4495   /* get layout location in widget->window coords */
4496   get_layout_location (label, &lx, &ly);
4497
4498   if (x)
4499     {
4500       *x += lx;                   /* go to widget->window */
4501       *x -= widget->allocation.x; /* go to selection window */
4502     }
4503
4504   if (y)
4505     {
4506       *y += ly;                   /* go to widget->window */
4507       *y -= widget->allocation.y; /* go to selection window */
4508     }
4509 }
4510 #endif
4511
4512 static gboolean
4513 get_layout_index (GtkLabel *label,
4514                   gint      x,
4515                   gint      y,
4516                   gint     *index)
4517 {
4518   GtkLabelPrivate *priv = label->priv;
4519   gint trailing = 0;
4520   const gchar *cluster;
4521   const gchar *cluster_end;
4522   gboolean inside;
4523
4524   *index = 0;
4525
4526   gtk_label_ensure_layout (label);
4527
4528   window_to_layout_coords (label, &x, &y);
4529
4530   x *= PANGO_SCALE;
4531   y *= PANGO_SCALE;
4532
4533   inside = pango_layout_xy_to_index (priv->layout,
4534                                      x, y,
4535                                      index, &trailing);
4536
4537   cluster = priv->text + *index;
4538   cluster_end = cluster;
4539   while (trailing)
4540     {
4541       cluster_end = g_utf8_next_char (cluster_end);
4542       --trailing;
4543     }
4544
4545   *index += (cluster_end - cluster);
4546
4547   return inside;
4548 }
4549
4550 static void
4551 gtk_label_select_word (GtkLabel *label)
4552 {
4553   GtkLabelPrivate *priv = label->priv;
4554   gint min, max;
4555
4556   gint start_index = gtk_label_move_backward_word (label, priv->select_info->selection_end);
4557   gint end_index = gtk_label_move_forward_word (label, priv->select_info->selection_end);
4558
4559   min = MIN (priv->select_info->selection_anchor,
4560              priv->select_info->selection_end);
4561   max = MAX (priv->select_info->selection_anchor,
4562              priv->select_info->selection_end);
4563
4564   min = MIN (min, start_index);
4565   max = MAX (max, end_index);
4566
4567   gtk_label_select_region_index (label, min, max);
4568 }
4569
4570 static void
4571 gtk_label_grab_focus (GtkWidget *widget)
4572 {
4573   GtkLabel *label = GTK_LABEL (widget);
4574   GtkLabelPrivate *priv = label->priv;
4575   gboolean select_on_focus;
4576   GtkLabelLink *link;
4577
4578   if (priv->select_info == NULL)
4579     return;
4580
4581   GTK_WIDGET_CLASS (gtk_label_parent_class)->grab_focus (widget);
4582
4583   if (priv->select_info->selectable)
4584     {
4585       g_object_get (gtk_widget_get_settings (widget),
4586                     "gtk-label-select-on-focus",
4587                     &select_on_focus,
4588                     NULL);
4589
4590       if (select_on_focus && !priv->in_click)
4591         gtk_label_select_region (label, 0, -1);
4592     }
4593   else
4594     {
4595       if (priv->select_info->links && !priv->in_click)
4596         {
4597           link = priv->select_info->links->data;
4598           priv->select_info->selection_anchor = link->start;
4599           priv->select_info->selection_end = link->start;
4600         }
4601     }
4602 }
4603
4604 static gboolean
4605 gtk_label_focus (GtkWidget        *widget,
4606                  GtkDirectionType  direction)
4607 {
4608   GtkLabel *label = GTK_LABEL (widget);
4609   GtkLabelPrivate *priv = label->priv;
4610   GtkLabelSelectionInfo *info = priv->select_info;
4611   GtkLabelLink *focus_link;
4612   GList *l;
4613
4614   if (!gtk_widget_is_focus (widget))
4615     {
4616       gtk_widget_grab_focus (widget);
4617       if (info)
4618         {
4619           focus_link = gtk_label_get_focus_link (label);
4620           if (focus_link && direction == GTK_DIR_TAB_BACKWARD)
4621             {
4622               l = g_list_last (info->links);
4623               focus_link = l->data;
4624               info->selection_anchor = focus_link->start;
4625               info->selection_end = focus_link->start;
4626             }
4627         }
4628
4629       return TRUE;
4630     }
4631
4632   if (!info)
4633     return FALSE;
4634
4635   if (info->selectable)
4636     {
4637       gint index;
4638
4639       if (info->selection_anchor != info->selection_end)
4640         goto out;
4641
4642       index = info->selection_anchor;
4643
4644       if (direction == GTK_DIR_TAB_FORWARD)
4645         for (l = info->links; l; l = l->next)
4646           {
4647             GtkLabelLink *link = l->data;
4648
4649             if (link->start > index)
4650               {
4651                 gtk_label_select_region_index (label, link->start, link->start);
4652                 return TRUE;
4653               }
4654           }
4655       else if (direction == GTK_DIR_TAB_BACKWARD)
4656         for (l = g_list_last (info->links); l; l = l->prev)
4657           {
4658             GtkLabelLink *link = l->data;
4659
4660             if (link->end < index)
4661               {
4662                 gtk_label_select_region_index (label, link->start, link->start);
4663                 return TRUE;
4664               }
4665           }
4666
4667       goto out;
4668     }
4669   else
4670     {
4671       focus_link = gtk_label_get_focus_link (label);
4672       switch (direction)
4673         {
4674         case GTK_DIR_TAB_FORWARD:
4675           if (focus_link)
4676             {
4677               l = g_list_find (info->links, focus_link);
4678               l = l->next;
4679             }
4680           else
4681             l = info->links;
4682           break;
4683
4684         case GTK_DIR_TAB_BACKWARD:
4685           if (focus_link)
4686             {
4687               l = g_list_find (info->links, focus_link);
4688               l = l->prev;
4689             }
4690           else
4691             l = g_list_last (info->links);
4692           break;
4693
4694         default:
4695           goto out;
4696         }
4697
4698       if (l)
4699         {
4700           focus_link = l->data;
4701           info->selection_anchor = focus_link->start;
4702           info->selection_end = focus_link->start;
4703           gtk_widget_queue_draw (widget);
4704
4705           return TRUE;
4706         }
4707     }
4708
4709 out:
4710
4711   return FALSE;
4712 }
4713
4714 static gboolean
4715 gtk_label_button_press (GtkWidget      *widget,
4716                         GdkEventButton *event)
4717 {
4718   GtkLabel *label = GTK_LABEL (widget);
4719   GtkLabelPrivate *priv = label->priv;
4720   GtkLabelSelectionInfo *info = priv->select_info;
4721   gint index = 0;
4722   gint min, max;
4723
4724   if (info == NULL)
4725     return FALSE;
4726
4727   if (info->active_link)
4728     {
4729       if (event->button == 1)
4730         {
4731           info->link_clicked = 1;
4732           gtk_widget_queue_draw (widget);
4733         }
4734       else if (event->button == 3 && event->type == GDK_BUTTON_PRESS)
4735         {
4736           info->link_clicked = 1;
4737           gtk_label_do_popup (label, event);
4738           return TRUE;
4739         }
4740     }
4741
4742   if (!info->selectable)
4743     return FALSE;
4744
4745   info->in_drag = FALSE;
4746   info->select_words = FALSE;
4747
4748   if (event->button == 1)
4749     {
4750       if (!gtk_widget_has_focus (widget))
4751         {
4752           priv->in_click = TRUE;
4753           gtk_widget_grab_focus (widget);
4754           priv->in_click = FALSE;
4755         }
4756
4757       if (event->type == GDK_3BUTTON_PRESS)
4758         {
4759           gtk_label_select_region_index (label, 0, strlen (priv->text));
4760           return TRUE;
4761         }
4762
4763       if (event->type == GDK_2BUTTON_PRESS)
4764         {
4765           info->select_words = TRUE;
4766           gtk_label_select_word (label);
4767           return TRUE;
4768         }
4769
4770       get_layout_index (label, event->x, event->y, &index);
4771
4772       min = MIN (info->selection_anchor, info->selection_end);
4773       max = MAX (info->selection_anchor, info->selection_end);
4774
4775       if ((info->selection_anchor != info->selection_end) &&
4776           (event->state & GDK_SHIFT_MASK))
4777         {
4778           /* extend (same as motion) */
4779           min = MIN (min, index);
4780           max = MAX (max, index);
4781
4782           /* ensure the anchor is opposite index */
4783           if (index == min)
4784             {
4785               gint tmp = min;
4786               min = max;
4787               max = tmp;
4788             }
4789
4790           gtk_label_select_region_index (label, min, max);
4791         }
4792       else
4793         {
4794           if (event->type == GDK_3BUTTON_PRESS)
4795             gtk_label_select_region_index (label, 0, strlen (priv->text));
4796           else if (event->type == GDK_2BUTTON_PRESS)
4797             gtk_label_select_word (label);
4798           else if (min < max && min <= index && index <= max)
4799             {
4800               info->in_drag = TRUE;
4801               info->drag_start_x = event->x;
4802               info->drag_start_y = event->y;
4803             }
4804           else
4805             /* start a replacement */
4806             gtk_label_select_region_index (label, index, index);
4807         }
4808
4809       return TRUE;
4810     }
4811   else if (event->button == 3 && event->type == GDK_BUTTON_PRESS)
4812     {
4813       gtk_label_do_popup (label, event);
4814
4815       return TRUE;
4816     }
4817   return FALSE;
4818 }
4819
4820 static gboolean
4821 gtk_label_button_release (GtkWidget      *widget,
4822                           GdkEventButton *event)
4823
4824 {
4825   GtkLabel *label = GTK_LABEL (widget);
4826   GtkLabelPrivate *priv = label->priv;
4827   GtkLabelSelectionInfo *info = priv->select_info;
4828   gint index;
4829
4830   if (info == NULL)
4831     return FALSE;
4832
4833   if (info->in_drag)
4834     {
4835       info->in_drag = 0;
4836
4837       get_layout_index (label, event->x, event->y, &index);
4838       gtk_label_select_region_index (label, index, index);
4839
4840       return FALSE;
4841     }
4842
4843   if (event->button != 1)
4844     return FALSE;
4845
4846   if (info->active_link &&
4847       info->selection_anchor == info->selection_end &&
4848       info->link_clicked)
4849     {
4850       emit_activate_link (label, info->active_link);
4851       info->link_clicked = 0;
4852
4853       return TRUE;
4854     }
4855
4856   /* The goal here is to return TRUE iff we ate the
4857    * button press to start selecting.
4858    */
4859   return TRUE;
4860 }
4861
4862 static void
4863 connect_mnemonics_visible_notify (GtkLabel *label)
4864 {
4865   GtkLabelPrivate *priv = label->priv;
4866   GtkWidget *toplevel;
4867   gboolean connected;
4868
4869   toplevel = gtk_widget_get_toplevel (GTK_WIDGET (label));
4870
4871   if (!GTK_IS_WINDOW (toplevel))
4872     return;
4873
4874   /* always set up this widgets initial value */
4875   priv->mnemonics_visible =
4876     gtk_window_get_mnemonics_visible (GTK_WINDOW (toplevel));
4877
4878   connected =
4879     GPOINTER_TO_INT (g_object_get_data (G_OBJECT (toplevel),
4880                                         "gtk-label-mnemonics-visible-connected"));
4881
4882   if (!connected)
4883     {
4884       g_signal_connect (toplevel,
4885                         "notify::mnemonics-visible",
4886                         G_CALLBACK (label_mnemonics_visible_changed),
4887                         label);
4888       g_object_set_data (G_OBJECT (toplevel),
4889                          "gtk-label-mnemonics-visible-connected",
4890                          GINT_TO_POINTER (1));
4891     }
4892 }
4893
4894 static void
4895 drag_begin_cb (GtkWidget      *widget,
4896                GdkDragContext *context,
4897                gpointer        data)
4898 {
4899   GtkLabel *label = GTK_LABEL (widget);
4900   GtkLabelPrivate *priv = label->priv;
4901   cairo_surface_t *surface = NULL;
4902
4903   g_signal_handlers_disconnect_by_func (widget, drag_begin_cb, NULL);
4904
4905   if ((priv->select_info->selection_anchor !=
4906        priv->select_info->selection_end) &&
4907       priv->text)
4908     {
4909       gint start, end;
4910       gint len;
4911
4912       start = MIN (priv->select_info->selection_anchor,
4913                    priv->select_info->selection_end);
4914       end = MAX (priv->select_info->selection_anchor,
4915                  priv->select_info->selection_end);
4916
4917       len = strlen (priv->text);
4918
4919       if (end > len)
4920         end = len;
4921
4922       if (start > len)
4923         start = len;
4924
4925       surface = _gtk_text_util_create_drag_icon (widget,
4926                                                  priv->text + start,
4927                                                  end - start);
4928     }
4929
4930   if (surface)
4931     {
4932       gtk_drag_set_icon_surface (context, surface);
4933       cairo_surface_destroy (surface);
4934     }
4935   else
4936     {
4937       gtk_drag_set_icon_default (context);
4938     }
4939 }
4940
4941 static gboolean
4942 gtk_label_motion (GtkWidget      *widget,
4943                   GdkEventMotion *event)
4944 {
4945   GtkLabel *label = GTK_LABEL (widget);
4946   GtkLabelPrivate *priv = label->priv;
4947   GtkLabelSelectionInfo *info = priv->select_info;
4948   gint index;
4949
4950   if (info == NULL)
4951     return FALSE;
4952
4953   if (info->links && !info->in_drag)
4954     {
4955       GList *l;
4956       GtkLabelLink *link;
4957       gboolean found = FALSE;
4958
4959       if (info->selection_anchor == info->selection_end)
4960         {
4961           if (get_layout_index (label, event->x, event->y, &index))
4962             {
4963               for (l = info->links; l != NULL; l = l->next)
4964                 {
4965                   link = l->data;
4966                   if (index >= link->start && index <= link->end)
4967                     {
4968                       found = TRUE;
4969                       break;
4970                     }
4971                 }
4972             }
4973         }
4974
4975       if (found)
4976         {
4977           if (info->active_link != link)
4978             {
4979               info->link_clicked = 0;
4980               info->active_link = link;
4981               gtk_label_update_cursor (label);
4982               gtk_widget_queue_draw (widget);
4983             }
4984         }
4985       else
4986         {
4987           if (info->active_link != NULL)
4988             {
4989               info->link_clicked = 0;
4990               info->active_link = NULL;
4991               gtk_label_update_cursor (label);
4992               gtk_widget_queue_draw (widget);
4993             }
4994         }
4995     }
4996
4997   if (!info->selectable)
4998     return FALSE;
4999
5000   if ((event->state & GDK_BUTTON1_MASK) == 0)
5001     return FALSE;
5002
5003   if (info->in_drag)
5004     {
5005       if (gtk_drag_check_threshold (widget,
5006                                     info->drag_start_x,
5007                                     info->drag_start_y,
5008                                     event->x, event->y))
5009         {
5010           GtkTargetList *target_list = gtk_target_list_new (NULL, 0);
5011
5012           gtk_target_list_add_text_targets (target_list, 0);
5013
5014           g_signal_connect (widget, "drag-begin",
5015                             G_CALLBACK (drag_begin_cb), NULL);
5016           gtk_drag_begin (widget, target_list,
5017                           GDK_ACTION_COPY,
5018                           1, (GdkEvent *)event);
5019
5020           info->in_drag = FALSE;
5021
5022           gtk_target_list_unref (target_list);
5023         }
5024     }
5025   else
5026     {
5027       gint x, y;
5028
5029       gdk_window_get_device_position (info->window, event->device, &x, &y, NULL);
5030       get_layout_index (label, x, y, &index);
5031
5032       if (info->select_words)
5033         {
5034           gint min, max;
5035           gint old_min, old_max;
5036           gint anchor, end;
5037
5038           min = gtk_label_move_backward_word (label, index);
5039           max = gtk_label_move_forward_word (label, index);
5040
5041           anchor = info->selection_anchor;
5042           end = info->selection_end;
5043
5044           old_min = MIN (anchor, end);
5045           old_max = MAX (anchor, end);
5046
5047           if (min < old_min)
5048             {
5049               anchor = min;
5050               end = old_max;
5051             }
5052           else if (old_max < max)
5053             {
5054               anchor = max;
5055               end = old_min;
5056             }
5057           else if (anchor == old_min)
5058             {
5059               if (anchor != min)
5060                 anchor = max;
5061             }
5062           else
5063             {
5064               if (anchor != max)
5065                 anchor = min;
5066             }
5067
5068           gtk_label_select_region_index (label, anchor, end);
5069         }
5070       else
5071         gtk_label_select_region_index (label, info->selection_anchor, index);
5072     }
5073
5074   return TRUE;
5075 }
5076
5077 static gboolean
5078 gtk_label_leave_notify (GtkWidget        *widget,
5079                         GdkEventCrossing *event)
5080 {
5081   GtkLabel *label = GTK_LABEL (widget);
5082   GtkLabelPrivate *priv = label->priv;
5083
5084   if (priv->select_info)
5085     {
5086       priv->select_info->active_link = NULL;
5087       gtk_label_update_cursor (label);
5088       gtk_widget_queue_draw (widget);
5089     }
5090
5091   if (GTK_WIDGET_CLASS (gtk_label_parent_class)->leave_notify_event)
5092     return GTK_WIDGET_CLASS (gtk_label_parent_class)->leave_notify_event (widget, event);
5093
5094  return FALSE;
5095 }
5096
5097 static void
5098 gtk_label_create_window (GtkLabel *label)
5099 {
5100   GtkLabelPrivate *priv = label->priv;
5101   GtkAllocation allocation;
5102   GtkWidget *widget;
5103   GdkWindowAttr attributes;
5104   gint attributes_mask;
5105
5106   g_assert (priv->select_info);
5107   widget = GTK_WIDGET (label);
5108   g_assert (gtk_widget_get_realized (widget));
5109
5110   if (priv->select_info->window)
5111     return;
5112
5113   gtk_widget_get_allocation (widget, &allocation);
5114
5115   attributes.x = allocation.x;
5116   attributes.y = allocation.y;
5117   attributes.width = allocation.width;
5118   attributes.height = allocation.height;
5119   attributes.window_type = GDK_WINDOW_CHILD;
5120   attributes.wclass = GDK_INPUT_ONLY;
5121   attributes.override_redirect = TRUE;
5122   attributes.event_mask = gtk_widget_get_events (widget) |
5123     GDK_BUTTON_PRESS_MASK        |
5124     GDK_BUTTON_RELEASE_MASK      |
5125     GDK_LEAVE_NOTIFY_MASK        |
5126     GDK_BUTTON_MOTION_MASK       |
5127     GDK_POINTER_MOTION_MASK      |
5128     GDK_POINTER_MOTION_HINT_MASK;
5129   attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_NOREDIR;
5130   if (gtk_widget_is_sensitive (widget))
5131     {
5132       attributes.cursor = gdk_cursor_new_for_display (gtk_widget_get_display (widget),
5133                                                       GDK_XTERM);
5134       attributes_mask |= GDK_WA_CURSOR;
5135     }
5136
5137
5138   priv->select_info->window = gdk_window_new (gtk_widget_get_window (widget),
5139                                                &attributes, attributes_mask);
5140   gdk_window_set_user_data (priv->select_info->window, widget);
5141
5142   if (attributes_mask & GDK_WA_CURSOR)
5143     g_object_unref (attributes.cursor);
5144 }
5145
5146 static void
5147 gtk_label_destroy_window (GtkLabel *label)
5148 {
5149   GtkLabelPrivate *priv = label->priv;
5150
5151   g_assert (priv->select_info);
5152
5153   if (priv->select_info->window == NULL)
5154     return;
5155
5156   gdk_window_set_user_data (priv->select_info->window, NULL);
5157   gdk_window_destroy (priv->select_info->window);
5158   priv->select_info->window = NULL;
5159 }
5160
5161 static void
5162 gtk_label_ensure_select_info (GtkLabel *label)
5163 {
5164   GtkLabelPrivate *priv = label->priv;
5165
5166   if (priv->select_info == NULL)
5167     {
5168       priv->select_info = g_new0 (GtkLabelSelectionInfo, 1);
5169
5170       gtk_widget_set_can_focus (GTK_WIDGET (label), TRUE);
5171
5172       if (gtk_widget_get_realized (GTK_WIDGET (label)))
5173         gtk_label_create_window (label);
5174
5175       if (gtk_widget_get_mapped (GTK_WIDGET (label)))
5176         gdk_window_show (priv->select_info->window);
5177     }
5178 }
5179
5180 static void
5181 gtk_label_clear_select_info (GtkLabel *label)
5182 {
5183   GtkLabelPrivate *priv = label->priv;
5184
5185   if (priv->select_info == NULL)
5186     return;
5187
5188   if (!priv->select_info->selectable && !priv->select_info->links)
5189     {
5190       gtk_label_destroy_window (label);
5191
5192       g_free (priv->select_info);
5193       priv->select_info = NULL;
5194
5195       gtk_widget_set_can_focus (GTK_WIDGET (label), FALSE);
5196     }
5197 }
5198
5199 /**
5200  * gtk_label_set_selectable:
5201  * @label: a #GtkLabel
5202  * @setting: %TRUE to allow selecting text in the label
5203  *
5204  * Selectable labels allow the user to select text from the label, for
5205  * copy-and-paste.
5206  **/
5207 void
5208 gtk_label_set_selectable (GtkLabel *label,
5209                           gboolean  setting)
5210 {
5211   GtkLabelPrivate *priv;
5212   gboolean old_setting;
5213
5214   g_return_if_fail (GTK_IS_LABEL (label));
5215
5216   priv = label->priv;
5217
5218   setting = setting != FALSE;
5219   old_setting = priv->select_info && priv->select_info->selectable;
5220
5221   if (setting)
5222     {
5223       gtk_label_ensure_select_info (label);
5224       priv->select_info->selectable = TRUE;
5225       gtk_label_update_cursor (label);
5226     }
5227   else
5228     {
5229       if (old_setting)
5230         {
5231           /* unselect, to give up the selection */
5232           gtk_label_select_region (label, 0, 0);
5233
5234           priv->select_info->selectable = FALSE;
5235           gtk_label_clear_select_info (label);
5236           gtk_label_update_cursor (label);
5237         }
5238     }
5239   if (setting != old_setting)
5240     {
5241       g_object_freeze_notify (G_OBJECT (label));
5242       g_object_notify (G_OBJECT (label), "selectable");
5243       g_object_notify (G_OBJECT (label), "cursor-position");
5244       g_object_notify (G_OBJECT (label), "selection-bound");
5245       g_object_thaw_notify (G_OBJECT (label));
5246       gtk_widget_queue_draw (GTK_WIDGET (label));
5247     }
5248 }
5249
5250 /**
5251  * gtk_label_get_selectable:
5252  * @label: a #GtkLabel
5253  *
5254  * Gets the value set by gtk_label_set_selectable().
5255  *
5256  * Return value: %TRUE if the user can copy text from the label
5257  **/
5258 gboolean
5259 gtk_label_get_selectable (GtkLabel *label)
5260 {
5261   GtkLabelPrivate *priv;
5262
5263   g_return_val_if_fail (GTK_IS_LABEL (label), FALSE);
5264
5265   priv = label->priv;
5266
5267   return priv->select_info && priv->select_info->selectable;
5268 }
5269
5270 /**
5271  * gtk_label_set_angle:
5272  * @label: a #GtkLabel
5273  * @angle: the angle that the baseline of the label makes with
5274  *   the horizontal, in degrees, measured counterclockwise
5275  *
5276  * Sets the angle of rotation for the label. An angle of 90 reads from
5277  * from bottom to top, an angle of 270, from top to bottom. The angle
5278  * setting for the label is ignored if the label is selectable,
5279  * wrapped, or ellipsized.
5280  *
5281  * Since: 2.6
5282  **/
5283 void
5284 gtk_label_set_angle (GtkLabel *label,
5285                      gdouble   angle)
5286 {
5287   GtkLabelPrivate *priv;
5288
5289   g_return_if_fail (GTK_IS_LABEL (label));
5290
5291   priv = label->priv;
5292
5293   /* Canonicalize to [0,360]. We don't canonicalize 360 to 0, because
5294    * double property ranges are inclusive, and changing 360 to 0 would
5295    * make a property editor behave strangely.
5296    */
5297   if (angle < 0 || angle > 360.0)
5298     angle = angle - 360. * floor (angle / 360.);
5299
5300   if (priv->angle != angle)
5301     {
5302       priv->angle = angle;
5303
5304       gtk_label_clear_layout (label);
5305       gtk_widget_queue_resize (GTK_WIDGET (label));
5306
5307       g_object_notify (G_OBJECT (label), "angle");
5308     }
5309 }
5310
5311 /**
5312  * gtk_label_get_angle:
5313  * @label: a #GtkLabel
5314  *
5315  * Gets the angle of rotation for the label. See
5316  * gtk_label_set_angle().
5317  *
5318  * Return value: the angle of rotation for the label
5319  *
5320  * Since: 2.6
5321  **/
5322 gdouble
5323 gtk_label_get_angle  (GtkLabel *label)
5324 {
5325   g_return_val_if_fail (GTK_IS_LABEL (label), 0.0);
5326
5327   return label->priv->angle;
5328 }
5329
5330 static void
5331 gtk_label_set_selection_text (GtkLabel         *label,
5332                               GtkSelectionData *selection_data)
5333 {
5334   GtkLabelPrivate *priv = label->priv;
5335
5336   if ((priv->select_info->selection_anchor !=
5337        priv->select_info->selection_end) &&
5338       priv->text)
5339     {
5340       gint start, end;
5341       gint len;
5342
5343       start = MIN (priv->select_info->selection_anchor,
5344                    priv->select_info->selection_end);
5345       end = MAX (priv->select_info->selection_anchor,
5346                  priv->select_info->selection_end);
5347
5348       len = strlen (priv->text);
5349
5350       if (end > len)
5351         end = len;
5352
5353       if (start > len)
5354         start = len;
5355
5356       gtk_selection_data_set_text (selection_data,
5357                                    priv->text + start,
5358                                    end - start);
5359     }
5360 }
5361
5362 static void
5363 gtk_label_drag_data_get (GtkWidget        *widget,
5364                          GdkDragContext   *context,
5365                          GtkSelectionData *selection_data,
5366                          guint             info,
5367                          guint             time)
5368 {
5369   gtk_label_set_selection_text (GTK_LABEL (widget), selection_data);
5370 }
5371
5372 static void
5373 get_text_callback (GtkClipboard     *clipboard,
5374                    GtkSelectionData *selection_data,
5375                    guint             info,
5376                    gpointer          user_data_or_owner)
5377 {
5378   gtk_label_set_selection_text (GTK_LABEL (user_data_or_owner), selection_data);
5379 }
5380
5381 static void
5382 clear_text_callback (GtkClipboard     *clipboard,
5383                      gpointer          user_data_or_owner)
5384 {
5385   GtkLabel *label;
5386   GtkLabelPrivate *priv;
5387
5388   label = GTK_LABEL (user_data_or_owner);
5389   priv = label->priv;
5390
5391   if (priv->select_info)
5392     {
5393       priv->select_info->selection_anchor = priv->select_info->selection_end;
5394
5395       gtk_widget_queue_draw (GTK_WIDGET (label));
5396     }
5397 }
5398
5399 static void
5400 gtk_label_select_region_index (GtkLabel *label,
5401                                gint      anchor_index,
5402                                gint      end_index)
5403 {
5404   GtkLabelPrivate *priv;
5405
5406   g_return_if_fail (GTK_IS_LABEL (label));
5407
5408   priv = label->priv;
5409
5410   if (priv->select_info && priv->select_info->selectable)
5411     {
5412       GtkClipboard *clipboard;
5413
5414       if (priv->select_info->selection_anchor == anchor_index &&
5415           priv->select_info->selection_end == end_index)
5416         return;
5417
5418       priv->select_info->selection_anchor = anchor_index;
5419       priv->select_info->selection_end = end_index;
5420
5421       clipboard = gtk_widget_get_clipboard (GTK_WIDGET (label),
5422                                             GDK_SELECTION_PRIMARY);
5423
5424       if (anchor_index != end_index)
5425         {
5426           GtkTargetList *list;
5427           GtkTargetEntry *targets;
5428           gint n_targets;
5429
5430           list = gtk_target_list_new (NULL, 0);
5431           gtk_target_list_add_text_targets (list, 0);
5432           targets = gtk_target_table_new_from_list (list, &n_targets);
5433
5434           gtk_clipboard_set_with_owner (clipboard,
5435                                         targets, n_targets,
5436                                         get_text_callback,
5437                                         clear_text_callback,
5438                                         G_OBJECT (label));
5439
5440           gtk_target_table_free (targets, n_targets);
5441           gtk_target_list_unref (list);
5442         }
5443       else
5444         {
5445           if (gtk_clipboard_get_owner (clipboard) == G_OBJECT (label))
5446             gtk_clipboard_clear (clipboard);
5447         }
5448
5449       gtk_widget_queue_draw (GTK_WIDGET (label));
5450
5451       g_object_freeze_notify (G_OBJECT (label));
5452       g_object_notify (G_OBJECT (label), "cursor-position");
5453       g_object_notify (G_OBJECT (label), "selection-bound");
5454       g_object_thaw_notify (G_OBJECT (label));
5455     }
5456 }
5457
5458 /**
5459  * gtk_label_select_region:
5460  * @label: a #GtkLabel
5461  * @start_offset: start offset (in characters not bytes)
5462  * @end_offset: end offset (in characters not bytes)
5463  *
5464  * Selects a range of characters in the label, if the label is selectable.
5465  * See gtk_label_set_selectable(). If the label is not selectable,
5466  * this function has no effect. If @start_offset or
5467  * @end_offset are -1, then the end of the label will be substituted.
5468  **/
5469 void
5470 gtk_label_select_region  (GtkLabel *label,
5471                           gint      start_offset,
5472                           gint      end_offset)
5473 {
5474   GtkLabelPrivate *priv;
5475
5476   g_return_if_fail (GTK_IS_LABEL (label));
5477
5478   priv = label->priv;
5479
5480   if (priv->text && priv->select_info)
5481     {
5482       if (start_offset < 0)
5483         start_offset = g_utf8_strlen (priv->text, -1);
5484
5485       if (end_offset < 0)
5486         end_offset = g_utf8_strlen (priv->text, -1);
5487
5488       gtk_label_select_region_index (label,
5489                                      g_utf8_offset_to_pointer (priv->text, start_offset) - priv->text,
5490                                      g_utf8_offset_to_pointer (priv->text, end_offset) - priv->text);
5491     }
5492 }
5493
5494 /**
5495  * gtk_label_get_selection_bounds:
5496  * @label: a #GtkLabel
5497  * @start: (out): return location for start of selection, as a character offset
5498  * @end: (out): return location for end of selection, as a character offset
5499  *
5500  * Gets the selected range of characters in the label, returning %TRUE
5501  * if there's a selection.
5502  *
5503  * Return value: %TRUE if selection is non-empty
5504  **/
5505 gboolean
5506 gtk_label_get_selection_bounds (GtkLabel  *label,
5507                                 gint      *start,
5508                                 gint      *end)
5509 {
5510   GtkLabelPrivate *priv;
5511
5512   g_return_val_if_fail (GTK_IS_LABEL (label), FALSE);
5513
5514   priv = label->priv;
5515
5516   if (priv->select_info == NULL)
5517     {
5518       /* not a selectable label */
5519       if (start)
5520         *start = 0;
5521       if (end)
5522         *end = 0;
5523
5524       return FALSE;
5525     }
5526   else
5527     {
5528       gint start_index, end_index;
5529       gint start_offset, end_offset;
5530       gint len;
5531
5532       start_index = MIN (priv->select_info->selection_anchor,
5533                    priv->select_info->selection_end);
5534       end_index = MAX (priv->select_info->selection_anchor,
5535                  priv->select_info->selection_end);
5536
5537       len = strlen (priv->text);
5538
5539       if (end_index > len)
5540         end_index = len;
5541
5542       if (start_index > len)
5543         start_index = len;
5544
5545       start_offset = g_utf8_strlen (priv->text, start_index);
5546       end_offset = g_utf8_strlen (priv->text, end_index);
5547
5548       if (start_offset > end_offset)
5549         {
5550           gint tmp = start_offset;
5551           start_offset = end_offset;
5552           end_offset = tmp;
5553         }
5554
5555       if (start)
5556         *start = start_offset;
5557
5558       if (end)
5559         *end = end_offset;
5560
5561       return start_offset != end_offset;
5562     }
5563 }
5564
5565
5566 /**
5567  * gtk_label_get_layout:
5568  * @label: a #GtkLabel
5569  *
5570  * Gets the #PangoLayout used to display the label.
5571  * The layout is useful to e.g. convert text positions to
5572  * pixel positions, in combination with gtk_label_get_layout_offsets().
5573  * The returned layout is owned by the @label so need not be
5574  * freed by the caller. The @label is free to recreate its layout at
5575  * any time, so it should be considered read-only.
5576  *
5577  * Return value: (transfer none): the #PangoLayout for this label
5578  **/
5579 PangoLayout*
5580 gtk_label_get_layout (GtkLabel *label)
5581 {
5582   GtkLabelPrivate *priv;
5583
5584   g_return_val_if_fail (GTK_IS_LABEL (label), NULL);
5585
5586   priv = label->priv;
5587
5588   gtk_label_ensure_layout (label);
5589
5590   return priv->layout;
5591 }
5592
5593 /**
5594  * gtk_label_get_layout_offsets:
5595  * @label: a #GtkLabel
5596  * @x: (out) (allow-none): location to store X offset of layout, or %NULL
5597  * @y: (out) (allow-none): location to store Y offset of layout, or %NULL
5598  *
5599  * Obtains the coordinates where the label will draw the #PangoLayout
5600  * representing the text in the label; useful to convert mouse events
5601  * into coordinates inside the #PangoLayout, e.g. to take some action
5602  * if some part of the label is clicked. Of course you will need to
5603  * create a #GtkEventBox to receive the events, and pack the label
5604  * inside it, since labels are a #GTK_NO_WINDOW widget. Remember
5605  * when using the #PangoLayout functions you need to convert to
5606  * and from pixels using PANGO_PIXELS() or #PANGO_SCALE.
5607  **/
5608 void
5609 gtk_label_get_layout_offsets (GtkLabel *label,
5610                               gint     *x,
5611                               gint     *y)
5612 {
5613   g_return_if_fail (GTK_IS_LABEL (label));
5614
5615   gtk_label_ensure_layout (label);
5616
5617   get_layout_location (label, x, y);
5618 }
5619
5620 /**
5621  * gtk_label_set_use_markup:
5622  * @label: a #GtkLabel
5623  * @setting: %TRUE if the label's text should be parsed for markup.
5624  *
5625  * Sets whether the text of the label contains markup in <link
5626  * linkend="PangoMarkupFormat">Pango's text markup
5627  * language</link>. See gtk_label_set_markup().
5628  **/
5629 void
5630 gtk_label_set_use_markup (GtkLabel *label,
5631                           gboolean  setting)
5632 {
5633   g_return_if_fail (GTK_IS_LABEL (label));
5634
5635   gtk_label_set_use_markup_internal (label, setting);
5636   gtk_label_recalculate (label);
5637 }
5638
5639 /**
5640  * gtk_label_get_use_markup:
5641  * @label: a #GtkLabel
5642  *
5643  * Returns whether the label's text is interpreted as marked up with
5644  * the <link linkend="PangoMarkupFormat">Pango text markup
5645  * language</link>. See gtk_label_set_use_markup ().
5646  *
5647  * Return value: %TRUE if the label's text will be parsed for markup.
5648  **/
5649 gboolean
5650 gtk_label_get_use_markup (GtkLabel *label)
5651 {
5652   g_return_val_if_fail (GTK_IS_LABEL (label), FALSE);
5653
5654   return label->priv->use_markup;
5655 }
5656
5657 /**
5658  * gtk_label_set_use_underline:
5659  * @label: a #GtkLabel
5660  * @setting: %TRUE if underlines in the text indicate mnemonics
5661  *
5662  * If true, an underline in the text indicates the next character should be
5663  * used for the mnemonic accelerator key.
5664  */
5665 void
5666 gtk_label_set_use_underline (GtkLabel *label,
5667                              gboolean  setting)
5668 {
5669   g_return_if_fail (GTK_IS_LABEL (label));
5670
5671   gtk_label_set_use_underline_internal (label, setting);
5672   gtk_label_recalculate (label);
5673 }
5674
5675 /**
5676  * gtk_label_get_use_underline:
5677  * @label: a #GtkLabel
5678  *
5679  * Returns whether an embedded underline in the label indicates a
5680  * mnemonic. See gtk_label_set_use_underline().
5681  *
5682  * Return value: %TRUE whether an embedded underline in the label indicates
5683  *               the mnemonic accelerator keys.
5684  **/
5685 gboolean
5686 gtk_label_get_use_underline (GtkLabel *label)
5687 {
5688   g_return_val_if_fail (GTK_IS_LABEL (label), FALSE);
5689
5690   return label->priv->use_underline;
5691 }
5692
5693 /**
5694  * gtk_label_set_single_line_mode:
5695  * @label: a #GtkLabel
5696  * @single_line_mode: %TRUE if the label should be in single line mode
5697  *
5698  * Sets whether the label is in single line mode.
5699  *
5700  * Since: 2.6
5701  */
5702 void
5703 gtk_label_set_single_line_mode (GtkLabel *label,
5704                                 gboolean single_line_mode)
5705 {
5706   GtkLabelPrivate *priv;
5707
5708   g_return_if_fail (GTK_IS_LABEL (label));
5709
5710   priv = label->priv;
5711
5712   single_line_mode = single_line_mode != FALSE;
5713
5714   if (priv->single_line_mode != single_line_mode)
5715     {
5716       priv->single_line_mode = single_line_mode;
5717
5718       gtk_label_clear_layout (label);
5719       gtk_widget_queue_resize (GTK_WIDGET (label));
5720
5721       g_object_notify (G_OBJECT (label), "single-line-mode");
5722     }
5723 }
5724
5725 /**
5726  * gtk_label_get_single_line_mode:
5727  * @label: a #GtkLabel
5728  *
5729  * Returns whether the label is in single line mode.
5730  *
5731  * Return value: %TRUE when the label is in single line mode.
5732  *
5733  * Since: 2.6
5734  **/
5735 gboolean
5736 gtk_label_get_single_line_mode  (GtkLabel *label)
5737 {
5738   g_return_val_if_fail (GTK_IS_LABEL (label), FALSE);
5739
5740   return label->priv->single_line_mode;
5741 }
5742
5743 /* Compute the X position for an offset that corresponds to the "more important
5744  * cursor position for that offset. We use this when trying to guess to which
5745  * end of the selection we should go to when the user hits the left or
5746  * right arrow key.
5747  */
5748 static void
5749 get_better_cursor (GtkLabel *label,
5750                    gint      index,
5751                    gint      *x,
5752                    gint      *y)
5753 {
5754   GtkLabelPrivate *priv = label->priv;
5755   GdkKeymap *keymap = gdk_keymap_get_for_display (gtk_widget_get_display (GTK_WIDGET (label)));
5756   PangoDirection keymap_direction = gdk_keymap_get_direction (keymap);
5757   PangoDirection cursor_direction = get_cursor_direction (label);
5758   gboolean split_cursor;
5759   PangoRectangle strong_pos, weak_pos;
5760
5761   g_object_get (gtk_widget_get_settings (GTK_WIDGET (label)),
5762                 "gtk-split-cursor", &split_cursor,
5763                 NULL);
5764
5765   gtk_label_ensure_layout (label);
5766
5767   pango_layout_get_cursor_pos (priv->layout, index,
5768                                &strong_pos, &weak_pos);
5769
5770   if (split_cursor)
5771     {
5772       *x = strong_pos.x / PANGO_SCALE;
5773       *y = strong_pos.y / PANGO_SCALE;
5774     }
5775   else
5776     {
5777       if (keymap_direction == cursor_direction)
5778         {
5779           *x = strong_pos.x / PANGO_SCALE;
5780           *y = strong_pos.y / PANGO_SCALE;
5781         }
5782       else
5783         {
5784           *x = weak_pos.x / PANGO_SCALE;
5785           *y = weak_pos.y / PANGO_SCALE;
5786         }
5787     }
5788 }
5789
5790
5791 static gint
5792 gtk_label_move_logically (GtkLabel *label,
5793                           gint      start,
5794                           gint      count)
5795 {
5796   GtkLabelPrivate *priv = label->priv;
5797   gint offset = g_utf8_pointer_to_offset (priv->text,
5798                                           priv->text + start);
5799
5800   if (priv->text)
5801     {
5802       PangoLogAttr *log_attrs;
5803       gint n_attrs;
5804       gint length;
5805
5806       gtk_label_ensure_layout (label);
5807
5808       length = g_utf8_strlen (priv->text, -1);
5809
5810       pango_layout_get_log_attrs (priv->layout, &log_attrs, &n_attrs);
5811
5812       while (count > 0 && offset < length)
5813         {
5814           do
5815             offset++;
5816           while (offset < length && !log_attrs[offset].is_cursor_position);
5817
5818           count--;
5819         }
5820       while (count < 0 && offset > 0)
5821         {
5822           do
5823             offset--;
5824           while (offset > 0 && !log_attrs[offset].is_cursor_position);
5825
5826           count++;
5827         }
5828
5829       g_free (log_attrs);
5830     }
5831
5832   return g_utf8_offset_to_pointer (priv->text, offset) - priv->text;
5833 }
5834
5835 static gint
5836 gtk_label_move_visually (GtkLabel *label,
5837                          gint      start,
5838                          gint      count)
5839 {
5840   GtkLabelPrivate *priv = label->priv;
5841   gint index;
5842
5843   index = start;
5844
5845   while (count != 0)
5846     {
5847       int new_index, new_trailing;
5848       gboolean split_cursor;
5849       gboolean strong;
5850
5851       gtk_label_ensure_layout (label);
5852
5853       g_object_get (gtk_widget_get_settings (GTK_WIDGET (label)),
5854                     "gtk-split-cursor", &split_cursor,
5855                     NULL);
5856
5857       if (split_cursor)
5858         strong = TRUE;
5859       else
5860         {
5861           GdkKeymap *keymap = gdk_keymap_get_for_display (gtk_widget_get_display (GTK_WIDGET (label)));
5862           PangoDirection keymap_direction = gdk_keymap_get_direction (keymap);
5863
5864           strong = keymap_direction == get_cursor_direction (label);
5865         }
5866
5867       if (count > 0)
5868         {
5869           pango_layout_move_cursor_visually (priv->layout, strong, index, 0, 1, &new_index, &new_trailing);
5870           count--;
5871         }
5872       else
5873         {
5874           pango_layout_move_cursor_visually (priv->layout, strong, index, 0, -1, &new_index, &new_trailing);
5875           count++;
5876         }
5877
5878       if (new_index < 0 || new_index == G_MAXINT)
5879         break;
5880
5881       index = new_index;
5882
5883       while (new_trailing--)
5884         index = g_utf8_next_char (priv->text + new_index) - priv->text;
5885     }
5886
5887   return index;
5888 }
5889
5890 static gint
5891 gtk_label_move_forward_word (GtkLabel *label,
5892                              gint      start)
5893 {
5894   GtkLabelPrivate *priv = label->priv;
5895   gint new_pos = g_utf8_pointer_to_offset (priv->text,
5896                                            priv->text + start);
5897   gint length;
5898
5899   length = g_utf8_strlen (priv->text, -1);
5900   if (new_pos < length)
5901     {
5902       PangoLogAttr *log_attrs;
5903       gint n_attrs;
5904
5905       gtk_label_ensure_layout (label);
5906
5907       pango_layout_get_log_attrs (priv->layout, &log_attrs, &n_attrs);
5908
5909       /* Find the next word end */
5910       new_pos++;
5911       while (new_pos < n_attrs && !log_attrs[new_pos].is_word_end)
5912         new_pos++;
5913
5914       g_free (log_attrs);
5915     }
5916
5917   return g_utf8_offset_to_pointer (priv->text, new_pos) - priv->text;
5918 }
5919
5920
5921 static gint
5922 gtk_label_move_backward_word (GtkLabel *label,
5923                               gint      start)
5924 {
5925   GtkLabelPrivate *priv = label->priv;
5926   gint new_pos = g_utf8_pointer_to_offset (priv->text,
5927                                            priv->text + start);
5928
5929   if (new_pos > 0)
5930     {
5931       PangoLogAttr *log_attrs;
5932       gint n_attrs;
5933
5934       gtk_label_ensure_layout (label);
5935
5936       pango_layout_get_log_attrs (priv->layout, &log_attrs, &n_attrs);
5937
5938       new_pos -= 1;
5939
5940       /* Find the previous word beginning */
5941       while (new_pos > 0 && !log_attrs[new_pos].is_word_start)
5942         new_pos--;
5943
5944       g_free (log_attrs);
5945     }
5946
5947   return g_utf8_offset_to_pointer (priv->text, new_pos) - priv->text;
5948 }
5949
5950 static void
5951 gtk_label_move_cursor (GtkLabel       *label,
5952                        GtkMovementStep step,
5953                        gint            count,
5954                        gboolean        extend_selection)
5955 {
5956   GtkLabelPrivate *priv = label->priv;
5957   gint old_pos;
5958   gint new_pos;
5959
5960   if (priv->select_info == NULL)
5961     return;
5962
5963   old_pos = new_pos = priv->select_info->selection_end;
5964
5965   if (priv->select_info->selection_end != priv->select_info->selection_anchor &&
5966       !extend_selection)
5967     {
5968       /* If we have a current selection and aren't extending it, move to the
5969        * start/or end of the selection as appropriate
5970        */
5971       switch (step)
5972         {
5973         case GTK_MOVEMENT_VISUAL_POSITIONS:
5974           {
5975             gint end_x, end_y;
5976             gint anchor_x, anchor_y;
5977             gboolean end_is_left;
5978
5979             get_better_cursor (label, priv->select_info->selection_end, &end_x, &end_y);
5980             get_better_cursor (label, priv->select_info->selection_anchor, &anchor_x, &anchor_y);
5981
5982             end_is_left = (end_y < anchor_y) || (end_y == anchor_y && end_x < anchor_x);
5983
5984             if (count < 0)
5985               new_pos = end_is_left ? priv->select_info->selection_end : priv->select_info->selection_anchor;
5986             else
5987               new_pos = !end_is_left ? priv->select_info->selection_end : priv->select_info->selection_anchor;
5988             break;
5989           }
5990         case GTK_MOVEMENT_LOGICAL_POSITIONS:
5991         case GTK_MOVEMENT_WORDS:
5992           if (count < 0)
5993             new_pos = MIN (priv->select_info->selection_end, priv->select_info->selection_anchor);
5994           else
5995             new_pos = MAX (priv->select_info->selection_end, priv->select_info->selection_anchor);
5996           break;
5997         case GTK_MOVEMENT_DISPLAY_LINE_ENDS:
5998         case GTK_MOVEMENT_PARAGRAPH_ENDS:
5999         case GTK_MOVEMENT_BUFFER_ENDS:
6000           /* FIXME: Can do better here */
6001           new_pos = count < 0 ? 0 : strlen (priv->text);
6002           break;
6003         case GTK_MOVEMENT_DISPLAY_LINES:
6004         case GTK_MOVEMENT_PARAGRAPHS:
6005         case GTK_MOVEMENT_PAGES:
6006         case GTK_MOVEMENT_HORIZONTAL_PAGES:
6007           break;
6008         }
6009     }
6010   else
6011     {
6012       switch (step)
6013         {
6014         case GTK_MOVEMENT_LOGICAL_POSITIONS:
6015           new_pos = gtk_label_move_logically (label, new_pos, count);
6016           break;
6017         case GTK_MOVEMENT_VISUAL_POSITIONS:
6018           new_pos = gtk_label_move_visually (label, new_pos, count);
6019           if (new_pos == old_pos)
6020             {
6021               if (!extend_selection)
6022                 {
6023                   if (!gtk_widget_keynav_failed (GTK_WIDGET (label),
6024                                                  count > 0 ?
6025                                                  GTK_DIR_RIGHT : GTK_DIR_LEFT))
6026                     {
6027                       GtkWidget *toplevel = gtk_widget_get_toplevel (GTK_WIDGET (label));
6028
6029                       if (toplevel)
6030                         gtk_widget_child_focus (toplevel,
6031                                                 count > 0 ?
6032                                                 GTK_DIR_RIGHT : GTK_DIR_LEFT);
6033                     }
6034                 }
6035               else
6036                 {
6037                   gtk_widget_error_bell (GTK_WIDGET (label));
6038                 }
6039             }
6040           break;
6041         case GTK_MOVEMENT_WORDS:
6042           while (count > 0)
6043             {
6044               new_pos = gtk_label_move_forward_word (label, new_pos);
6045               count--;
6046             }
6047           while (count < 0)
6048             {
6049               new_pos = gtk_label_move_backward_word (label, new_pos);
6050               count++;
6051             }
6052           if (new_pos == old_pos)
6053             gtk_widget_error_bell (GTK_WIDGET (label));
6054           break;
6055         case GTK_MOVEMENT_DISPLAY_LINE_ENDS:
6056         case GTK_MOVEMENT_PARAGRAPH_ENDS:
6057         case GTK_MOVEMENT_BUFFER_ENDS:
6058           /* FIXME: Can do better here */
6059           new_pos = count < 0 ? 0 : strlen (priv->text);
6060           if (new_pos == old_pos)
6061             gtk_widget_error_bell (GTK_WIDGET (label));
6062           break;
6063         case GTK_MOVEMENT_DISPLAY_LINES:
6064         case GTK_MOVEMENT_PARAGRAPHS:
6065         case GTK_MOVEMENT_PAGES:
6066         case GTK_MOVEMENT_HORIZONTAL_PAGES:
6067           break;
6068         }
6069     }
6070
6071   if (extend_selection)
6072     gtk_label_select_region_index (label,
6073                                    priv->select_info->selection_anchor,
6074                                    new_pos);
6075   else
6076     gtk_label_select_region_index (label, new_pos, new_pos);
6077 }
6078
6079 static void
6080 gtk_label_copy_clipboard (GtkLabel *label)
6081 {
6082   GtkLabelPrivate *priv = label->priv;
6083
6084   if (priv->text && priv->select_info)
6085     {
6086       gint start, end;
6087       gint len;
6088       GtkClipboard *clipboard;
6089
6090       start = MIN (priv->select_info->selection_anchor,
6091                    priv->select_info->selection_end);
6092       end = MAX (priv->select_info->selection_anchor,
6093                  priv->select_info->selection_end);
6094
6095       len = strlen (priv->text);
6096
6097       if (end > len)
6098         end = len;
6099
6100       if (start > len)
6101         start = len;
6102
6103       clipboard = gtk_widget_get_clipboard (GTK_WIDGET (label), GDK_SELECTION_CLIPBOARD);
6104
6105       if (start != end)
6106         gtk_clipboard_set_text (clipboard, priv->text + start, end - start);
6107       else
6108         {
6109           GtkLabelLink *link;
6110
6111           link = gtk_label_get_focus_link (label);
6112           if (link)
6113             gtk_clipboard_set_text (clipboard, link->uri, -1);
6114         }
6115     }
6116 }
6117
6118 static void
6119 gtk_label_select_all (GtkLabel *label)
6120 {
6121   GtkLabelPrivate *priv = label->priv;
6122
6123   gtk_label_select_region_index (label, 0, strlen (priv->text));
6124 }
6125
6126 /* Quick hack of a popup menu
6127  */
6128 static void
6129 activate_cb (GtkWidget *menuitem,
6130              GtkLabel  *label)
6131 {
6132   const gchar *signal = g_object_get_data (G_OBJECT (menuitem), "gtk-signal");
6133   g_signal_emit_by_name (label, signal);
6134 }
6135
6136 static void
6137 append_action_signal (GtkLabel     *label,
6138                       GtkWidget    *menu,
6139                       const gchar  *stock_id,
6140                       const gchar  *signal,
6141                       gboolean      sensitive)
6142 {
6143   GtkWidget *menuitem = gtk_image_menu_item_new_from_stock (stock_id, NULL);
6144
6145   g_object_set_data (G_OBJECT (menuitem), I_("gtk-signal"), (char *)signal);
6146   g_signal_connect (menuitem, "activate",
6147                     G_CALLBACK (activate_cb), label);
6148
6149   gtk_widget_set_sensitive (menuitem, sensitive);
6150
6151   gtk_widget_show (menuitem);
6152   gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
6153 }
6154
6155 static void
6156 popup_menu_detach (GtkWidget *attach_widget,
6157                    GtkMenu   *menu)
6158 {
6159   GtkLabel *label = GTK_LABEL (attach_widget);
6160   GtkLabelPrivate *priv = label->priv;
6161
6162   if (priv->select_info)
6163     priv->select_info->popup_menu = NULL;
6164 }
6165
6166 static void
6167 popup_position_func (GtkMenu   *menu,
6168                      gint      *x,
6169                      gint      *y,
6170                      gboolean  *push_in,
6171                      gpointer   user_data)
6172 {
6173   GtkLabel *label;
6174   GtkWidget *widget;
6175   GtkAllocation allocation;
6176   GtkRequisition req;
6177   GdkScreen *screen;
6178
6179   label = GTK_LABEL (user_data);
6180   widget = GTK_WIDGET (label);
6181
6182   g_return_if_fail (gtk_widget_get_realized (widget));
6183
6184   screen = gtk_widget_get_screen (widget);
6185   gdk_window_get_origin (gtk_widget_get_window (widget), x, y);
6186
6187   gtk_widget_get_allocation (widget, &allocation);
6188
6189   *x += allocation.x;
6190   *y += allocation.y;
6191
6192   gtk_widget_get_preferred_size (GTK_WIDGET (menu),
6193                                  &req, NULL);
6194
6195   gtk_widget_get_allocation (widget, &allocation);
6196
6197   *x += allocation.width / 2;
6198   *y += allocation.height;
6199
6200   *x = CLAMP (*x, 0, MAX (0, gdk_screen_get_width (screen) - req.width));
6201   *y = CLAMP (*y, 0, MAX (0, gdk_screen_get_height (screen) - req.height));
6202 }
6203
6204 static void
6205 open_link_activate_cb (GtkMenuItem *menu_item,
6206                        GtkLabel    *label)
6207 {
6208   GtkLabelLink *link;
6209
6210   link = gtk_label_get_current_link (label);
6211
6212   if (link)
6213     emit_activate_link (label, link);
6214 }
6215
6216 static void
6217 copy_link_activate_cb (GtkMenuItem *menu_item,
6218                        GtkLabel    *label)
6219 {
6220   GtkClipboard *clipboard;
6221   const gchar *uri;
6222
6223   uri = gtk_label_get_current_uri (label);
6224   if (uri)
6225     {
6226       clipboard = gtk_widget_get_clipboard (GTK_WIDGET (label), GDK_SELECTION_CLIPBOARD);
6227       gtk_clipboard_set_text (clipboard, uri, -1);
6228     }
6229 }
6230
6231 static gboolean
6232 gtk_label_popup_menu (GtkWidget *widget)
6233 {
6234   gtk_label_do_popup (GTK_LABEL (widget), NULL);
6235
6236   return TRUE;
6237 }
6238
6239 static void
6240 gtk_label_do_popup (GtkLabel       *label,
6241                     GdkEventButton *event)
6242 {
6243   GtkLabelPrivate *priv = label->priv;
6244   GtkWidget *menuitem;
6245   GtkWidget *menu;
6246   GtkWidget *image;
6247   gboolean have_selection;
6248   GtkLabelLink *link;
6249
6250   if (!priv->select_info)
6251     return;
6252
6253   if (priv->select_info->popup_menu)
6254     gtk_widget_destroy (priv->select_info->popup_menu);
6255
6256   priv->select_info->popup_menu = menu = gtk_menu_new ();
6257
6258   gtk_menu_attach_to_widget (GTK_MENU (menu), GTK_WIDGET (label), popup_menu_detach);
6259
6260   have_selection =
6261     priv->select_info->selection_anchor != priv->select_info->selection_end;
6262
6263   if (event)
6264     {
6265       if (priv->select_info->link_clicked)
6266         link = priv->select_info->active_link;
6267       else
6268         link = NULL;
6269     }
6270   else
6271     link = gtk_label_get_focus_link (label);
6272
6273   if (!have_selection && link)
6274     {
6275       /* Open Link */
6276       menuitem = gtk_image_menu_item_new_with_mnemonic (_("_Open Link"));
6277       gtk_widget_show (menuitem);
6278       gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
6279
6280       g_signal_connect (G_OBJECT (menuitem), "activate",
6281                         G_CALLBACK (open_link_activate_cb), label);
6282
6283       image = gtk_image_new_from_stock (GTK_STOCK_JUMP_TO, GTK_ICON_SIZE_MENU);
6284       gtk_widget_show (image);
6285       gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
6286
6287       /* Copy Link Address */
6288       menuitem = gtk_image_menu_item_new_with_mnemonic (_("Copy _Link Address"));
6289       gtk_widget_show (menuitem);
6290       gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
6291
6292       g_signal_connect (G_OBJECT (menuitem), "activate",
6293                         G_CALLBACK (copy_link_activate_cb), label);
6294
6295       image = gtk_image_new_from_stock (GTK_STOCK_COPY, GTK_ICON_SIZE_MENU);
6296       gtk_widget_show (image);
6297       gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
6298     }
6299   else
6300     {
6301       append_action_signal (label, menu, GTK_STOCK_CUT, "cut-clipboard", FALSE);
6302       append_action_signal (label, menu, GTK_STOCK_COPY, "copy-clipboard", have_selection);
6303       append_action_signal (label, menu, GTK_STOCK_PASTE, "paste-clipboard", FALSE);
6304
6305       menuitem = gtk_image_menu_item_new_from_stock (GTK_STOCK_DELETE, NULL);
6306       gtk_widget_set_sensitive (menuitem, FALSE);
6307       gtk_widget_show (menuitem);
6308       gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
6309
6310       menuitem = gtk_separator_menu_item_new ();
6311       gtk_widget_show (menuitem);
6312       gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
6313
6314       menuitem = gtk_image_menu_item_new_from_stock (GTK_STOCK_SELECT_ALL, NULL);
6315       g_signal_connect_swapped (menuitem, "activate",
6316                                 G_CALLBACK (gtk_label_select_all), label);
6317       gtk_widget_show (menuitem);
6318       gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
6319     }
6320
6321   g_signal_emit (label, signals[POPULATE_POPUP], 0, menu);
6322
6323   if (event)
6324     gtk_menu_popup (GTK_MENU (menu), NULL, NULL,
6325                     NULL, NULL,
6326                     event->button, event->time);
6327   else
6328     {
6329       gtk_menu_popup (GTK_MENU (menu), NULL, NULL,
6330                       popup_position_func, label,
6331                       0, gtk_get_current_event_time ());
6332       gtk_menu_shell_select_first (GTK_MENU_SHELL (menu), FALSE);
6333     }
6334 }
6335
6336 static void
6337 gtk_label_clear_links (GtkLabel *label)
6338 {
6339   GtkLabelPrivate *priv = label->priv;
6340
6341   if (!priv->select_info)
6342     return;
6343
6344   g_list_foreach (priv->select_info->links, (GFunc)link_free, NULL);
6345   g_list_free (priv->select_info->links);
6346   priv->select_info->links = NULL;
6347   priv->select_info->active_link = NULL;
6348 }
6349
6350 static void
6351 gtk_label_rescan_links (GtkLabel *label)
6352 {
6353   GtkLabelPrivate *priv = label->priv;
6354   PangoLayout *layout = priv->layout;
6355   PangoAttrList *attlist;
6356   PangoAttrIterator *iter;
6357   GList *links;
6358
6359   if (!priv->select_info || !priv->select_info->links)
6360     return;
6361
6362   attlist = pango_layout_get_attributes (layout);
6363
6364   if (attlist == NULL)
6365     return;
6366
6367   iter = pango_attr_list_get_iterator (attlist);
6368
6369   links = priv->select_info->links;
6370
6371   do
6372     {
6373       PangoAttribute *underline;
6374       PangoAttribute *color;
6375
6376       underline = pango_attr_iterator_get (iter, PANGO_ATTR_UNDERLINE);
6377       color = pango_attr_iterator_get (iter, PANGO_ATTR_FOREGROUND);
6378
6379       if (underline != NULL && color != NULL)
6380         {
6381           gint start, end;
6382           PangoRectangle start_pos;
6383           PangoRectangle end_pos;
6384           GtkLabelLink *link;
6385
6386           pango_attr_iterator_range (iter, &start, &end);
6387           pango_layout_index_to_pos (layout, start, &start_pos);
6388           pango_layout_index_to_pos (layout, end, &end_pos);
6389
6390           if (links == NULL)
6391             {
6392               g_warning ("Ran out of links");
6393               break;
6394             }
6395           link = links->data;
6396           links = links->next;
6397           link->start = start;
6398           link->end = end;
6399         }
6400       } while (pango_attr_iterator_next (iter));
6401
6402     pango_attr_iterator_destroy (iter);
6403 }
6404
6405 static gboolean
6406 gtk_label_activate_link (GtkLabel    *label,
6407                          const gchar *uri)
6408 {
6409   GtkWidget *widget = GTK_WIDGET (label);
6410   GError *error = NULL;
6411
6412   if (!gtk_show_uri (gtk_widget_get_screen (widget),
6413                      uri, gtk_get_current_event_time (), &error))
6414     {
6415       g_warning ("Unable to show '%s': %s", uri, error->message);
6416       g_error_free (error);
6417     }
6418
6419   return TRUE;
6420 }
6421
6422 static void
6423 emit_activate_link (GtkLabel     *label,
6424                     GtkLabelLink *link)
6425 {
6426   GtkLabelPrivate *priv = label->priv;
6427   gboolean handled;
6428
6429   g_signal_emit (label, signals[ACTIVATE_LINK], 0, link->uri, &handled);
6430   if (handled && priv->track_links && !link->visited)
6431     {
6432       link->visited = TRUE;
6433       /* FIXME: shouldn't have to redo everything here */
6434       gtk_label_recalculate (label);
6435     }
6436 }
6437
6438 static void
6439 gtk_label_activate_current_link (GtkLabel *label)
6440 {
6441   GtkLabelLink *link;
6442   GtkWidget *widget = GTK_WIDGET (label);
6443
6444   link = gtk_label_get_focus_link (label);
6445
6446   if (link)
6447     {
6448       emit_activate_link (label, link);
6449     }
6450   else
6451     {
6452       GtkWidget *toplevel;
6453       GtkWindow *window;
6454       GtkWidget *default_widget, *focus_widget;
6455
6456       toplevel = gtk_widget_get_toplevel (widget);
6457       if (GTK_IS_WINDOW (toplevel))
6458         {
6459           window = GTK_WINDOW (toplevel);
6460
6461           if (window)
6462             {
6463               default_widget = gtk_window_get_default_widget (window);
6464               focus_widget = gtk_window_get_focus (window);
6465
6466               if (default_widget != widget &&
6467                   !(widget == focus_widget && (!default_widget || !gtk_widget_is_sensitive (default_widget))))
6468                 gtk_window_activate_default (window);
6469             }
6470         }
6471     }
6472 }
6473
6474 static GtkLabelLink *
6475 gtk_label_get_current_link (GtkLabel *label)
6476 {
6477   GtkLabelPrivate *priv = label->priv;
6478   GtkLabelLink *link;
6479
6480   if (!priv->select_info)
6481     return NULL;
6482
6483   if (priv->select_info->link_clicked)
6484     link = priv->select_info->active_link;
6485   else
6486     link = gtk_label_get_focus_link (label);
6487
6488   return link;
6489 }
6490
6491 /**
6492  * gtk_label_get_current_uri:
6493  * @label: a #GtkLabel
6494  *
6495  * Returns the URI for the currently active link in the label.
6496  * The active link is the one under the mouse pointer or, in a
6497  * selectable label, the link in which the text cursor is currently
6498  * positioned.
6499  *
6500  * This function is intended for use in a #GtkLabel::activate-link handler
6501  * or for use in a #GtkWidget::query-tooltip handler.
6502  *
6503  * Returns: the currently active URI. The string is owned by GTK+ and must
6504  *   not be freed or modified.
6505  *
6506  * Since: 2.18
6507  */
6508 G_CONST_RETURN gchar *
6509 gtk_label_get_current_uri (GtkLabel *label)
6510 {
6511   GtkLabelLink *link;
6512
6513   g_return_val_if_fail (GTK_IS_LABEL (label), NULL);
6514
6515   link = gtk_label_get_current_link (label);
6516
6517   if (link)
6518     return link->uri;
6519
6520   return NULL;
6521 }
6522
6523 /**
6524  * gtk_label_set_track_visited_links:
6525  * @label: a #GtkLabel
6526  * @track_links: %TRUE to track visited links
6527  *
6528  * Sets whether the label should keep track of clicked
6529  * links (and use a different color for them).
6530  *
6531  * Since: 2.18
6532  */
6533 void
6534 gtk_label_set_track_visited_links (GtkLabel *label,
6535                                    gboolean  track_links)
6536 {
6537   GtkLabelPrivate *priv;
6538
6539   g_return_if_fail (GTK_IS_LABEL (label));
6540
6541   priv = label->priv;
6542
6543   track_links = track_links != FALSE;
6544
6545   if (priv->track_links != track_links)
6546     {
6547       priv->track_links = track_links;
6548
6549       /* FIXME: shouldn't have to redo everything here */
6550       gtk_label_recalculate (label);
6551
6552       g_object_notify (G_OBJECT (label), "track-visited-links");
6553     }
6554 }
6555
6556 /**
6557  * gtk_label_get_track_visited_links:
6558  * @label: a #GtkLabel
6559  *
6560  * Returns whether the label is currently keeping track
6561  * of clicked links.
6562  *
6563  * Returns: %TRUE if clicked links are remembered
6564  *
6565  * Since: 2.18
6566  */
6567 gboolean
6568 gtk_label_get_track_visited_links (GtkLabel *label)
6569 {
6570   g_return_val_if_fail (GTK_IS_LABEL (label), FALSE);
6571
6572   return label->priv->track_links;
6573 }
6574
6575 static gboolean
6576 gtk_label_query_tooltip (GtkWidget  *widget,
6577                          gint        x,
6578                          gint        y,
6579                          gboolean    keyboard_tip,
6580                          GtkTooltip *tooltip)
6581 {
6582   GtkLabel *label = GTK_LABEL (widget);
6583   GtkLabelPrivate *priv = label->priv;
6584   GtkLabelSelectionInfo *info = priv->select_info;
6585   gint index = -1;
6586   GList *l;
6587
6588   if (info && info->links)
6589     {
6590       if (keyboard_tip)
6591         {
6592           if (info->selection_anchor == info->selection_end)
6593             index = info->selection_anchor;
6594         }
6595       else
6596         {
6597           if (!get_layout_index (label, x, y, &index))
6598             index = -1;
6599         }
6600
6601       if (index != -1)
6602         {
6603           for (l = info->links; l != NULL; l = l->next)
6604             {
6605               GtkLabelLink *link = l->data;
6606               if (index >= link->start && index <= link->end)
6607                 {
6608                   if (link->title)
6609                     {
6610                       gtk_tooltip_set_markup (tooltip, link->title);
6611                       return TRUE;
6612                     }
6613                   break;
6614                 }
6615             }
6616         }
6617     }
6618
6619   return GTK_WIDGET_CLASS (gtk_label_parent_class)->query_tooltip (widget,
6620                                                                    x, y,
6621                                                                    keyboard_tip,
6622                                                                    tooltip);
6623 }