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  * @height: the height to measure with in pango units, or -1 for infinite
3216  *
3217  * Gets a layout that can be used for measuring sizes. The returned
3218  * layout will be identical to the label's layout except for the
3219  * layout's width, which will be set to @width. Do not modify the returned
3220  * layout.
3221  *
3222  * Returns: a new reference to a pango layout
3223  **/
3224 static PangoLayout *
3225 gtk_label_get_measuring_layout (GtkLabel *   label,
3226                                 PangoLayout *existing_layout,
3227                                 int          width,
3228                                 int          height)
3229 {
3230   GtkLabelPrivate *priv = label->priv;
3231   PangoRectangle rect;
3232   PangoLayout *copy;
3233
3234   if (existing_layout != NULL)
3235     {
3236       if (existing_layout != priv->layout)
3237         {
3238           pango_layout_set_width (existing_layout, width);
3239           pango_layout_set_height (existing_layout, height);
3240           return existing_layout;
3241         }
3242
3243       g_object_unref (existing_layout);
3244     }
3245
3246   gtk_label_ensure_layout (label);
3247
3248   if (pango_layout_get_width (priv->layout) == width &&
3249       pango_layout_get_height (priv->layout) == height)
3250     {
3251       g_object_ref (priv->layout);
3252       return priv->layout;
3253     }
3254
3255   /* We can use the label's own layout if we're not allocated a size yet,
3256    * because we don't need it to be properly setup at that point.
3257    * This way we can make use of caching upon the label's creation.
3258    */
3259   if (gtk_widget_get_allocated_width (GTK_WIDGET (label)) <= 1)
3260     {
3261       g_object_ref (priv->layout);
3262       pango_layout_set_width (priv->layout, width);
3263       pango_layout_set_height (priv->layout, height);
3264       return priv->layout;
3265     }
3266
3267   /* oftentimes we want to measure a width that is far wider than the current width,
3268    * even though the layout would not change if we made it wider. In that case, we
3269    * can just return the current layout, because for measuring purposes, it will be
3270    * identical.
3271    */
3272   pango_layout_get_extents (priv->layout, NULL, &rect);
3273   if ((width == -1 || rect.width <= width) &&
3274       (height == -1 || rect.height <= height) &&
3275       !pango_layout_is_wrapped (priv->layout) &&
3276       !pango_layout_is_ellipsized (priv->layout))
3277     {
3278       g_object_ref (priv->layout);
3279       return priv->layout;
3280     }
3281
3282   copy = pango_layout_copy (priv->layout);
3283   pango_layout_set_width (copy, width);
3284   pango_layout_set_height (copy, height);
3285   return copy;
3286 }
3287
3288 static void
3289 gtk_label_update_layout_width (GtkLabel *label)
3290 {
3291   GtkLabelPrivate *priv = label->priv;
3292   GtkWidget *widget = GTK_WIDGET (label);
3293
3294   g_assert (priv->layout);
3295
3296   if (priv->ellipsize || priv->wrap)
3297     {
3298       PangoRectangle logical;
3299       gint xpad, ypad;
3300       gint width, height;
3301
3302       gtk_misc_get_padding (GTK_MISC (label), &xpad, &ypad);
3303
3304       width = gtk_widget_get_allocated_width (GTK_WIDGET (label)) - xpad * 2;
3305       height = gtk_widget_get_allocated_height (GTK_WIDGET (label)) - ypad * 2;
3306
3307       if (priv->have_transform)
3308         {
3309           PangoContext *context = gtk_widget_get_pango_context (widget);
3310           const PangoMatrix *matrix = pango_context_get_matrix (context);
3311           const gdouble dx = matrix->xx; /* cos (M_PI * angle / 180) */
3312           const gdouble dy = matrix->xy; /* sin (M_PI * angle / 180) */
3313
3314           pango_layout_set_width (priv->layout, -1);
3315           pango_layout_set_height (priv->layout, -1);
3316           pango_layout_get_pixel_extents (priv->layout, NULL, &logical);
3317
3318           if (fabs (dy) < 0.01)
3319             {
3320               if (logical.width > width)
3321                 pango_layout_set_width (priv->layout, width * PANGO_SCALE);
3322             }
3323           else if (fabs (dx) < 0.01)
3324             {
3325               if (logical.width > height)
3326                 pango_layout_set_width (priv->layout, height * PANGO_SCALE);
3327             }
3328           else
3329             {
3330               gdouble x0, y0, x1, y1, length;
3331               gboolean vertical;
3332               gint cy;
3333
3334               x0 = width / 2;
3335               y0 = dx ? x0 * dy / dx : G_MAXDOUBLE;
3336               vertical = fabs (y0) > height / 2;
3337
3338               if (vertical)
3339                 {
3340                   y0 = height/2;
3341                   x0 = dy ? y0 * dx / dy : G_MAXDOUBLE;
3342                 }
3343
3344               length = 2 * sqrt (x0 * x0 + y0 * y0);
3345               pango_layout_set_width (priv->layout, rint (length * PANGO_SCALE));
3346               pango_layout_get_pixel_size (priv->layout, NULL, &cy);
3347
3348               x1 = +dy * cy/2;
3349               y1 = -dx * cy/2;
3350
3351               if (vertical)
3352                 {
3353                   y0 = height/2 + y1 - y0;
3354                   x0 = -y0 * dx/dy;
3355                 }
3356               else
3357                 {
3358                   x0 = width/2 + x1 - x0;
3359                   y0 = -x0 * dy/dx;
3360                 }
3361
3362               length = length - sqrt (x0 * x0 + y0 * y0) * 2;
3363               pango_layout_set_width (priv->layout, rint (length * PANGO_SCALE));
3364             }
3365         }
3366       else
3367         {
3368           pango_layout_set_width (priv->layout, width * PANGO_SCALE);
3369           pango_layout_set_height (priv->layout, priv->ellipsize ? height * PANGO_SCALE : -1);
3370         }
3371     }
3372   else
3373     {
3374       pango_layout_set_width (priv->layout, -1);
3375       pango_layout_set_height (priv->layout, -1);
3376     }
3377 }
3378
3379 static void
3380 gtk_label_ensure_layout (GtkLabel *label)
3381 {
3382   GtkLabelPrivate *priv = label->priv;
3383   GtkWidget *widget;
3384   gboolean rtl;
3385
3386   widget = GTK_WIDGET (label);
3387
3388   rtl = gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL;
3389
3390   if (!priv->layout)
3391     {
3392       PangoAlignment align = PANGO_ALIGN_LEFT; /* Quiet gcc */
3393       gdouble angle = gtk_label_get_angle (label);
3394
3395       if (angle != 0.0 && !priv->select_info)
3396         {
3397           PangoMatrix matrix = PANGO_MATRIX_INIT;
3398
3399           /* We rotate the standard singleton PangoContext for the widget,
3400            * depending on the fact that it's meant pretty much exclusively
3401            * for our use.
3402            */
3403           pango_matrix_rotate (&matrix, angle);
3404
3405           pango_context_set_matrix (gtk_widget_get_pango_context (widget), &matrix);
3406
3407           priv->have_transform = TRUE;
3408         }
3409       else
3410         {
3411           if (priv->have_transform)
3412             pango_context_set_matrix (gtk_widget_get_pango_context (widget), NULL);
3413
3414           priv->have_transform = FALSE;
3415         }
3416
3417       priv->layout = gtk_widget_create_pango_layout (widget, priv->text);
3418
3419       if (priv->effective_attrs)
3420         pango_layout_set_attributes (priv->layout, priv->effective_attrs);
3421
3422       gtk_label_rescan_links (label);
3423
3424       switch (priv->jtype)
3425         {
3426         case GTK_JUSTIFY_LEFT:
3427           align = rtl ? PANGO_ALIGN_RIGHT : PANGO_ALIGN_LEFT;
3428           break;
3429         case GTK_JUSTIFY_RIGHT:
3430           align = rtl ? PANGO_ALIGN_LEFT : PANGO_ALIGN_RIGHT;
3431           break;
3432         case GTK_JUSTIFY_CENTER:
3433           align = PANGO_ALIGN_CENTER;
3434           break;
3435         case GTK_JUSTIFY_FILL:
3436           align = rtl ? PANGO_ALIGN_RIGHT : PANGO_ALIGN_LEFT;
3437           pango_layout_set_justify (priv->layout, TRUE);
3438           break;
3439         default:
3440           g_assert_not_reached();
3441         }
3442
3443       pango_layout_set_alignment (priv->layout, align);
3444       pango_layout_set_ellipsize (priv->layout, priv->ellipsize);
3445       pango_layout_set_wrap (priv->layout, priv->wrap_mode);
3446       pango_layout_set_single_paragraph_mode (priv->layout, priv->single_line_mode);
3447
3448       gtk_label_update_layout_width (label);
3449     }
3450 }
3451
3452 static gint
3453 get_single_line_height (GtkWidget   *widget,
3454                         PangoLayout *layout)
3455 {
3456   PangoContext *context;
3457   PangoFontMetrics *metrics;
3458   gint ascent, descent;
3459
3460   context = pango_layout_get_context (layout);
3461   metrics = get_font_metrics (context, widget);
3462   ascent = pango_font_metrics_get_ascent (metrics);
3463   descent = pango_font_metrics_get_descent (metrics);
3464   pango_font_metrics_unref (metrics);
3465
3466   return ascent + descent;
3467 }
3468
3469 static GtkSizeRequestMode
3470 gtk_label_get_request_mode (GtkWidget *widget)
3471 {
3472   GtkLabel *label = GTK_LABEL (widget);
3473   gdouble   angle = gtk_label_get_angle (label);
3474
3475   if (label->priv->wrap)
3476     return (angle == 90 || angle == 270) ?
3477       GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT :
3478       GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH;
3479
3480     return GTK_SIZE_REQUEST_CONSTANT_SIZE;
3481 }
3482
3483 static void
3484 get_size_for_allocation (GtkLabel        *label,
3485                          GtkOrientation   orientation,
3486                          gint             allocation,
3487                          gint            *minimum_size,
3488                          gint            *natural_size)
3489 {
3490   PangoLayout *layout;
3491   gint text_height;
3492
3493   layout = gtk_label_get_measuring_layout (label, NULL, allocation * PANGO_SCALE, -1);
3494
3495   pango_layout_get_pixel_size (layout, NULL, &text_height);
3496
3497   if (minimum_size)
3498     *minimum_size = text_height;
3499
3500   if (natural_size)
3501     *natural_size = text_height;
3502
3503   g_object_unref (layout);
3504 }
3505
3506 static gint
3507 get_char_pixels (GtkWidget   *label,
3508                  PangoLayout *layout)
3509 {
3510   PangoContext *context;
3511   PangoFontMetrics *metrics;
3512   gint char_width, digit_width;
3513
3514   context = pango_layout_get_context (layout);
3515   metrics = get_font_metrics (context, GTK_WIDGET (label));
3516   char_width = pango_font_metrics_get_approximate_char_width (metrics);
3517   digit_width = pango_font_metrics_get_approximate_digit_width (metrics);
3518   pango_font_metrics_unref (metrics);
3519
3520   return MAX (char_width, digit_width);;
3521 }
3522
3523 static void
3524 gtk_label_get_preferred_layout_size (GtkLabel *label,
3525                                      PangoRectangle *required,
3526                                      PangoRectangle *natural)
3527 {
3528   GtkLabelPrivate *priv = label->priv;
3529   PangoLayout *layout;
3530
3531   /* "width-chars" Hard-coded minimum width:
3532    *    - minimum size should be MAX (width-chars, strlen ("..."));
3533    *    - natural size should be MAX (width-chars, strlen (priv->text));
3534    *
3535    * "max-width-chars" User specified maximum size requisition
3536    *    - minimum size should be MAX (width-chars, 0)
3537    *    - natural size should be MIN (max-width-chars, strlen (priv->text))
3538    *
3539    *    For ellipsizing labels; if max-width-chars is specified: either it is used as
3540    *    a minimum size or the label text as a minimum size (natural size still overflows).
3541    *
3542    *    For wrapping labels; A reasonable minimum size is useful to naturally layout
3543    *    interfaces automatically. In this case if no "width-chars" is specified, the minimum
3544    *    width will default to the wrap guess that gtk_label_ensure_layout() does.
3545    */
3546
3547   /* Start off with the pixel extents of an as-wide-as-possible layout */
3548   layout = gtk_label_get_measuring_layout (label, NULL, -1, -1);
3549
3550   pango_layout_get_extents (layout, NULL, natural);
3551   natural->x = natural->y = 0;
3552
3553   if (priv->single_line_mode || priv->wrap)
3554     natural->height = get_single_line_height (GTK_WIDGET (label), layout);
3555
3556   if (priv->ellipsize || priv->wrap)
3557     {
3558       /* a layout with width 0 will be as small as humanly possible */
3559       layout = gtk_label_get_measuring_layout (label, layout, 0, -1);
3560
3561       pango_layout_get_extents (layout, NULL, required);
3562       required->x = required->y = 0;
3563       required->height = natural->height;
3564     }
3565   else
3566     {
3567       *required = *natural;
3568     }
3569
3570   if (priv->width_chars > -1 || priv->max_width_chars > -1)
3571     {
3572       gint char_pixels;
3573
3574       char_pixels = get_char_pixels (GTK_WIDGET (label), layout);
3575
3576       if (priv->width_chars > -1)
3577         required->width = MAX (required->width, char_pixels * priv->width_chars);
3578
3579       if (priv->max_width_chars > -1)
3580         natural->width = MIN (natural->width, priv->max_width_chars * char_pixels);
3581       natural->width = MAX (natural->width, required->width);
3582     }
3583
3584   g_object_unref (layout);
3585 }
3586
3587 static void
3588 gtk_label_get_preferred_size (GtkWidget      *widget,
3589                               GtkOrientation  orientation,
3590                               gint           *minimum_size,
3591                               gint           *natural_size)
3592 {
3593   GtkLabel      *label = GTK_LABEL (widget);
3594   GtkLabelPrivate  *priv = label->priv;
3595   PangoRectangle required_rect;
3596   PangoRectangle natural_rect;
3597   gint           xpad, ypad;
3598
3599   gtk_label_get_preferred_layout_size (label, &required_rect, &natural_rect);
3600
3601   /* Now that we have minimum and natural sizes in pango extents, apply a possible transform */
3602   if (priv->have_transform)
3603     {
3604       PangoLayout *copy;
3605       PangoContext *context;
3606       const PangoMatrix *matrix;
3607
3608       copy = pango_layout_copy (priv->layout);
3609       context = pango_layout_get_context (copy);
3610       matrix = pango_context_get_matrix (context);
3611
3612       pango_layout_set_width (copy, -1);
3613       pango_layout_set_ellipsize (copy, PANGO_ELLIPSIZE_NONE);
3614
3615       pango_layout_get_extents (copy, NULL, &natural_rect);
3616       g_object_unref (copy);
3617
3618       pango_matrix_transform_rectangle (matrix, &required_rect);
3619       pango_matrix_transform_rectangle (matrix, &natural_rect);
3620
3621       /* Bump the natural size in case of ellipsize to ensure pango has
3622        * enough space in the angles (note, we could alternatively set the
3623        * layout to not ellipsize when we know we have been allocated our
3624        * full natural size, or it may be that pango needs a fix here).
3625        */
3626       if (priv->ellipsize && priv->angle != 0 && priv->angle != 90 &&
3627           priv->angle != 180 && priv->angle != 270 && priv->angle != 360)
3628         {
3629           /* For some reason we only need this at about 110 degrees, and only
3630            * when gaining in height
3631            */
3632           natural_rect.height += ROTATION_ELLIPSIZE_PADDING * 2 * PANGO_SCALE;
3633           natural_rect.width  += ROTATION_ELLIPSIZE_PADDING * 2 * PANGO_SCALE;
3634         }
3635     }
3636
3637   required_rect.width  = PANGO_PIXELS_CEIL (required_rect.width);
3638   required_rect.height = PANGO_PIXELS_CEIL (required_rect.height);
3639
3640   natural_rect.width  = PANGO_PIXELS_CEIL (natural_rect.width);
3641   natural_rect.height = PANGO_PIXELS_CEIL (natural_rect.height);
3642
3643   gtk_misc_get_padding (GTK_MISC (label), &xpad, &ypad);
3644
3645   if (orientation == GTK_ORIENTATION_HORIZONTAL)
3646     {
3647       /* Note, we cant use get_size_for_allocation() when rotating
3648        * ellipsized labels.
3649        */
3650       if (!(priv->ellipsize && priv->have_transform) &&
3651           (priv->angle == 90 || priv->angle == 270))
3652         {
3653           /* Doing a h4w request on a rotated label here, return the
3654            * required width for the minimum height.
3655            */
3656           get_size_for_allocation (label,
3657                                    GTK_ORIENTATION_VERTICAL,
3658                                    required_rect.height,
3659                                    minimum_size, natural_size);
3660
3661         }
3662       else
3663         {
3664           /* Normal desired width */
3665           *minimum_size = required_rect.width;
3666           *natural_size = natural_rect.width;
3667         }
3668
3669       *minimum_size += xpad * 2;
3670       *natural_size += xpad * 2;
3671     }
3672   else /* GTK_ORIENTATION_VERTICAL */
3673     {
3674       /* Note, we cant use get_size_for_allocation() when rotating
3675        * ellipsized labels.
3676        */
3677       if (!(priv->ellipsize && priv->have_transform) &&
3678           (priv->angle == 0 || priv->angle == 180 || priv->angle == 360))
3679         {
3680           /* Doing a w4h request on a label here, return the required
3681            * height for the minimum width.
3682            */
3683           get_size_for_allocation (label,
3684                                    GTK_ORIENTATION_HORIZONTAL,
3685                                    required_rect.width,
3686                                    minimum_size, natural_size);
3687         }
3688       else
3689         {
3690           /* A vertically rotated label does w4h, so return the base
3691            * desired height (text length)
3692            */
3693           *minimum_size = required_rect.height;
3694           *natural_size = natural_rect.height;
3695         }
3696
3697       *minimum_size += ypad * 2;
3698       *natural_size += ypad * 2;
3699     }
3700 }
3701
3702
3703 static void
3704 gtk_label_get_preferred_width (GtkWidget *widget,
3705                                gint      *minimum_size,
3706                                gint      *natural_size)
3707 {
3708   gtk_label_get_preferred_size (widget, GTK_ORIENTATION_HORIZONTAL, minimum_size, natural_size);
3709 }
3710
3711 static void
3712 gtk_label_get_preferred_height (GtkWidget *widget,
3713                                 gint      *minimum_size,
3714                                 gint      *natural_size)
3715 {
3716   gtk_label_get_preferred_size (widget, GTK_ORIENTATION_VERTICAL, minimum_size, natural_size);
3717 }
3718
3719 static void
3720 gtk_label_get_preferred_width_for_height (GtkWidget *widget,
3721                                           gint       height,
3722                                           gint      *minimum_width,
3723                                           gint      *natural_width)
3724 {
3725   GtkLabel *label = GTK_LABEL (widget);
3726   GtkLabelPrivate *priv = label->priv;
3727
3728   if (priv->wrap && (priv->angle == 90 || priv->angle == 270))
3729     {
3730       gint xpad, ypad;
3731
3732       gtk_misc_get_padding (GTK_MISC (label), &xpad, &ypad);
3733
3734       if (priv->wrap)
3735         gtk_label_clear_layout (label);
3736
3737       get_size_for_allocation (label, GTK_ORIENTATION_VERTICAL,
3738                                MAX (1, height - (ypad * 2)),
3739                                minimum_width, natural_width);
3740
3741       if (minimum_width)
3742         *minimum_width += xpad * 2;
3743
3744       if (natural_width)
3745         *natural_width += xpad * 2;
3746     }
3747   else
3748     GTK_WIDGET_GET_CLASS (widget)->get_preferred_width (widget, minimum_width, natural_width);
3749 }
3750
3751 static void
3752 gtk_label_get_preferred_height_for_width (GtkWidget *widget,
3753                                           gint       width,
3754                                           gint      *minimum_height,
3755                                           gint      *natural_height)
3756 {
3757   GtkLabel *label = GTK_LABEL (widget);
3758   GtkLabelPrivate *priv = label->priv;
3759
3760   if (priv->wrap && (priv->angle == 0 || priv->angle == 180 || priv->angle == 360))
3761     {
3762       gint xpad, ypad;
3763
3764       gtk_misc_get_padding (GTK_MISC (label), &xpad, &ypad);
3765
3766       if (priv->wrap)
3767         gtk_label_clear_layout (label);
3768
3769       get_size_for_allocation (label, GTK_ORIENTATION_HORIZONTAL,
3770                                MAX (1, width - xpad * 2),
3771                                minimum_height, natural_height);
3772
3773       if (minimum_height)
3774         *minimum_height += ypad * 2;
3775
3776       if (natural_height)
3777         *natural_height += ypad * 2;
3778     }
3779   else
3780     GTK_WIDGET_GET_CLASS (widget)->get_preferred_height (widget, minimum_height, natural_height);
3781 }
3782
3783 static void
3784 gtk_label_size_allocate (GtkWidget     *widget,
3785                          GtkAllocation *allocation)
3786 {
3787   GtkLabel *label = GTK_LABEL (widget);
3788   GtkLabelPrivate *priv = label->priv;
3789
3790   GTK_WIDGET_CLASS (gtk_label_parent_class)->size_allocate (widget, allocation);
3791
3792   if (priv->layout)
3793     gtk_label_update_layout_width (label);
3794
3795   if (priv->select_info && priv->select_info->window)
3796     {
3797       gdk_window_move_resize (priv->select_info->window,
3798                               allocation->x,
3799                               allocation->y,
3800                               allocation->width,
3801                               allocation->height);
3802     }
3803 }
3804
3805 static void
3806 gtk_label_update_cursor (GtkLabel *label)
3807 {
3808   GtkLabelPrivate *priv = label->priv;
3809   GtkWidget *widget;
3810
3811   if (!priv->select_info)
3812     return;
3813
3814   widget = GTK_WIDGET (label);
3815
3816   if (gtk_widget_get_realized (widget))
3817     {
3818       GdkDisplay *display;
3819       GdkCursor *cursor;
3820
3821       if (gtk_widget_is_sensitive (widget))
3822         {
3823           display = gtk_widget_get_display (widget);
3824
3825           if (priv->select_info->active_link)
3826             cursor = gdk_cursor_new_for_display (display, GDK_HAND2);
3827           else if (priv->select_info->selectable)
3828             cursor = gdk_cursor_new_for_display (display, GDK_XTERM);
3829           else
3830             cursor = NULL;
3831         }
3832       else
3833         cursor = NULL;
3834
3835       gdk_window_set_cursor (priv->select_info->window, cursor);
3836
3837       if (cursor)
3838         g_object_unref (cursor);
3839     }
3840 }
3841
3842 static void
3843 gtk_label_state_changed (GtkWidget   *widget,
3844                          GtkStateType prev_state)
3845 {
3846   GtkLabel *label = GTK_LABEL (widget);
3847   GtkLabelPrivate *priv = label->priv;
3848
3849   if (priv->select_info)
3850     {
3851       if (!gtk_widget_is_sensitive (widget))
3852         gtk_label_select_region (label, 0, 0);
3853
3854       gtk_label_update_cursor (label);
3855     }
3856
3857   if (GTK_WIDGET_CLASS (gtk_label_parent_class)->state_changed)
3858     GTK_WIDGET_CLASS (gtk_label_parent_class)->state_changed (widget, prev_state);
3859 }
3860
3861 static void
3862 gtk_label_style_updated (GtkWidget *widget)
3863 {
3864   GtkLabel *label = GTK_LABEL (widget);
3865
3866   GTK_WIDGET_CLASS (gtk_label_parent_class)->style_updated (widget);
3867
3868   /* We have to clear the layout, fonts etc. may have changed */
3869   gtk_label_clear_layout (label);
3870 }
3871
3872 static void
3873 gtk_label_direction_changed (GtkWidget        *widget,
3874                              GtkTextDirection previous_dir)
3875 {
3876   GtkLabel *label = GTK_LABEL (widget);
3877   GtkLabelPrivate *priv = label->priv;
3878
3879   if (priv->layout)
3880     pango_layout_context_changed (priv->layout);
3881
3882   GTK_WIDGET_CLASS (gtk_label_parent_class)->direction_changed (widget, previous_dir);
3883 }
3884
3885 static void
3886 get_layout_location (GtkLabel  *label,
3887                      gint      *xp,
3888                      gint      *yp)
3889 {
3890   GtkAllocation allocation;
3891   GtkMisc *misc;
3892   GtkWidget *widget;
3893   GtkLabelPrivate *priv;
3894   gint req_width, x, y;
3895   gint req_height;
3896   gint xpad, ypad;
3897   gfloat xalign, yalign;
3898   PangoRectangle logical;
3899
3900   misc   = GTK_MISC (label);
3901   widget = GTK_WIDGET (label);
3902   priv   = label->priv;
3903
3904   gtk_misc_get_alignment (misc, &xalign, &yalign);
3905   gtk_misc_get_padding (misc, &xpad, &ypad);
3906
3907   if (gtk_widget_get_direction (widget) != GTK_TEXT_DIR_LTR)
3908     xalign = 1.0 - xalign;
3909
3910   pango_layout_get_extents (priv->layout, NULL, &logical);
3911
3912   if (priv->have_transform)
3913     {
3914       PangoContext *context = gtk_widget_get_pango_context (widget);
3915       const PangoMatrix *matrix = pango_context_get_matrix (context);
3916       pango_matrix_transform_rectangle (matrix, &logical);
3917     }
3918
3919   pango_extents_to_pixels (&logical, NULL);
3920
3921   req_width  = logical.width;
3922   req_height = logical.height;
3923
3924   req_width  += 2 * xpad;
3925   req_height += 2 * ypad;
3926
3927   gtk_widget_get_allocation (widget, &allocation);
3928
3929   x = floor (allocation.x + xpad + xalign * (allocation.width - req_width));
3930
3931   if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_LTR)
3932     x = MAX (x, allocation.x + xpad);
3933   else
3934     x = MIN (x, allocation.x + allocation.width - xpad);
3935
3936
3937   /* bgo#315462 - For single-line labels, *do* align the requisition with
3938    * respect to the allocation, even if we are under-allocated.  For multi-line
3939    * labels, always show the top of the text when they are under-allocated.  The
3940    * rationale is this:
3941    *
3942    * - Single-line labels appear in GtkButtons, and it is very easy to get them
3943    *   to be smaller than their requisition.  The button may clip the label, but
3944    *   the label will still be able to show most of itself and the focus
3945    *   rectangle.  Also, it is fairly easy to read a single line of clipped text.
3946    *
3947    * - Multi-line labels should not be clipped to showing "something in the
3948    *   middle".  You want to read the first line, at least, to get some context.
3949    */
3950   if (pango_layout_get_line_count (priv->layout) == 1)
3951     y = floor (allocation.y + ypad + (allocation.height - req_height) * yalign);
3952   else
3953     y = floor (allocation.y + ypad + MAX ((allocation.height - req_height) * yalign, 0));
3954
3955   if (xp)
3956     *xp = x;
3957
3958   if (yp)
3959     *yp = y;
3960 }
3961
3962 static void
3963 draw_insertion_cursor (GtkLabel      *label,
3964                        cairo_t       *cr,
3965                        GdkRectangle  *cursor_location,
3966                        gboolean       is_primary,
3967                        PangoDirection direction,
3968                        gboolean       draw_arrow)
3969 {
3970   GtkWidget *widget = GTK_WIDGET (label);
3971   GtkTextDirection text_dir;
3972
3973   if (direction == PANGO_DIRECTION_LTR)
3974     text_dir = GTK_TEXT_DIR_LTR;
3975   else
3976     text_dir = GTK_TEXT_DIR_RTL;
3977
3978   gtk_draw_insertion_cursor (widget, cr, cursor_location,
3979                              is_primary, text_dir, draw_arrow);
3980 }
3981
3982 static PangoDirection
3983 get_cursor_direction (GtkLabel *label)
3984 {
3985   GtkLabelPrivate *priv = label->priv;
3986   GSList *l;
3987
3988   g_assert (priv->select_info);
3989
3990   gtk_label_ensure_layout (label);
3991
3992   for (l = pango_layout_get_lines_readonly (priv->layout); l; l = l->next)
3993     {
3994       PangoLayoutLine *line = l->data;
3995
3996       /* If priv->select_info->selection_end is at the very end of
3997        * the line, we don't know if the cursor is on this line or
3998        * the next without looking ahead at the next line. (End
3999        * of paragraph is different from line break.) But it's
4000        * definitely in this paragraph, which is good enough
4001        * to figure out the resolved direction.
4002        */
4003        if (line->start_index + line->length >= priv->select_info->selection_end)
4004         return line->resolved_dir;
4005     }
4006
4007   return PANGO_DIRECTION_LTR;
4008 }
4009
4010 static void
4011 gtk_label_draw_cursor (GtkLabel  *label, cairo_t *cr, gint xoffset, gint yoffset)
4012 {
4013   GtkLabelPrivate *priv = label->priv;
4014   GtkWidget *widget;
4015
4016   if (priv->select_info == NULL)
4017     return;
4018
4019   widget = GTK_WIDGET (label);
4020
4021   if (gtk_widget_is_drawable (widget))
4022     {
4023       PangoDirection keymap_direction;
4024       PangoDirection cursor_direction;
4025       PangoRectangle strong_pos, weak_pos;
4026       gboolean split_cursor;
4027       PangoRectangle *cursor1 = NULL;
4028       PangoRectangle *cursor2 = NULL;
4029       GdkRectangle cursor_location;
4030       PangoDirection dir1 = PANGO_DIRECTION_NEUTRAL;
4031       PangoDirection dir2 = PANGO_DIRECTION_NEUTRAL;
4032
4033       keymap_direction = gdk_keymap_get_direction (gdk_keymap_get_for_display (gtk_widget_get_display (widget)));
4034       cursor_direction = get_cursor_direction (label);
4035
4036       gtk_label_ensure_layout (label);
4037
4038       pango_layout_get_cursor_pos (priv->layout, priv->select_info->selection_end,
4039                                    &strong_pos, &weak_pos);
4040
4041       g_object_get (gtk_widget_get_settings (widget),
4042                     "gtk-split-cursor", &split_cursor,
4043                     NULL);
4044
4045       dir1 = cursor_direction;
4046
4047       if (split_cursor)
4048         {
4049           cursor1 = &strong_pos;
4050
4051           if (strong_pos.x != weak_pos.x ||
4052               strong_pos.y != weak_pos.y)
4053             {
4054               dir2 = (cursor_direction == PANGO_DIRECTION_LTR) ? PANGO_DIRECTION_RTL : PANGO_DIRECTION_LTR;
4055               cursor2 = &weak_pos;
4056             }
4057         }
4058       else
4059         {
4060           if (keymap_direction == cursor_direction)
4061             cursor1 = &strong_pos;
4062           else
4063             cursor1 = &weak_pos;
4064         }
4065
4066       cursor_location.x = xoffset + PANGO_PIXELS (cursor1->x);
4067       cursor_location.y = yoffset + PANGO_PIXELS (cursor1->y);
4068       cursor_location.width = 0;
4069       cursor_location.height = PANGO_PIXELS (cursor1->height);
4070
4071       draw_insertion_cursor (label, cr,
4072                              &cursor_location, TRUE, dir1,
4073                              dir2 != PANGO_DIRECTION_NEUTRAL);
4074
4075       if (dir2 != PANGO_DIRECTION_NEUTRAL)
4076         {
4077           cursor_location.x = xoffset + PANGO_PIXELS (cursor2->x);
4078           cursor_location.y = yoffset + PANGO_PIXELS (cursor2->y);
4079           cursor_location.width = 0;
4080           cursor_location.height = PANGO_PIXELS (cursor2->height);
4081
4082           draw_insertion_cursor (label, cr,
4083                                  &cursor_location, FALSE, dir2,
4084                                  TRUE);
4085         }
4086     }
4087 }
4088
4089 static GtkLabelLink *
4090 gtk_label_get_focus_link (GtkLabel *label)
4091 {
4092   GtkLabelPrivate *priv = label->priv;
4093   GtkLabelSelectionInfo *info = priv->select_info;
4094   GList *l;
4095
4096   if (!info)
4097     return NULL;
4098
4099   if (info->selection_anchor != info->selection_end)
4100     return NULL;
4101
4102   for (l = info->links; l; l = l->next)
4103     {
4104       GtkLabelLink *link = l->data;
4105       if (link->start <= info->selection_anchor &&
4106           info->selection_anchor <= link->end)
4107         return link;
4108     }
4109
4110   return NULL;
4111 }
4112
4113 static gint
4114 gtk_label_draw (GtkWidget *widget,
4115                 cairo_t   *cr)
4116 {
4117   GtkLabel *label = GTK_LABEL (widget);
4118   GtkLabelPrivate *priv = label->priv;
4119   GtkLabelSelectionInfo *info = priv->select_info;
4120   GtkAllocation allocation;
4121   GtkStyleContext *context;
4122   GtkStateFlags state;
4123   gint x, y;
4124
4125   gtk_label_ensure_layout (label);
4126
4127   if (priv->text && (*priv->text != '\0'))
4128     {
4129       GdkRGBA *bg_color, *fg_color;
4130
4131       get_layout_location (label, &x, &y);
4132
4133       context = gtk_widget_get_style_context (widget);
4134       gtk_widget_get_allocation (widget, &allocation);
4135
4136       cairo_translate (cr, -allocation.x, -allocation.y);
4137
4138       state = gtk_widget_get_state_flags (widget);
4139       gtk_style_context_set_state (context, state);
4140
4141       gtk_render_layout (context, cr,
4142                          x, y,
4143                          priv->layout);
4144
4145       if (info &&
4146           (info->selection_anchor != info->selection_end))
4147         {
4148           gint range[2];
4149           cairo_region_t *clip;
4150
4151           range[0] = info->selection_anchor;
4152           range[1] = info->selection_end;
4153
4154           if (range[0] > range[1])
4155             {
4156               gint tmp = range[0];
4157               range[0] = range[1];
4158               range[1] = tmp;
4159             }
4160
4161           clip = gdk_pango_layout_get_clip_region (priv->layout,
4162                                                    x, y,
4163                                                    range,
4164                                                    1);
4165
4166          /* FIXME should use gtk_paint, but it can't use a clip region */
4167           cairo_save (cr);
4168
4169           gdk_cairo_region (cr, clip);
4170           cairo_clip (cr);
4171
4172           state = GTK_STATE_FLAG_SELECTED;
4173
4174           if (gtk_widget_has_focus (widget))
4175             state |= GTK_STATE_FLAG_FOCUSED;
4176
4177           gtk_style_context_get (context, state,
4178                                  "background-color", &bg_color,
4179                                  "color", &fg_color,
4180                                  NULL);
4181
4182           gdk_cairo_set_source_rgba (cr, bg_color);
4183           cairo_paint (cr);
4184
4185           gdk_cairo_set_source_rgba (cr, fg_color);
4186           cairo_move_to (cr, x, y);
4187           _gtk_pango_fill_layout (cr, priv->layout);
4188
4189           cairo_restore (cr);
4190           cairo_region_destroy (clip);
4191
4192           gdk_rgba_free (bg_color);
4193           gdk_rgba_free (fg_color);
4194         }
4195       else if (info)
4196         {
4197           GtkLabelLink *focus_link;
4198           GtkLabelLink *active_link;
4199           gint range[2];
4200           cairo_region_t *clip;
4201           GdkRectangle rect;
4202           GdkColor *text_color;
4203           GdkColor *link_color;
4204           GdkColor *visited_link_color;
4205
4206           if (info->selectable && gtk_widget_has_focus (widget))
4207             gtk_label_draw_cursor (label, cr, x, y);
4208
4209           focus_link = gtk_label_get_focus_link (label);
4210           active_link = info->active_link;
4211
4212
4213           if (active_link)
4214             {
4215               GdkRGBA *bg_color;
4216
4217               range[0] = active_link->start;
4218               range[1] = active_link->end;
4219
4220               cairo_save (cr);
4221
4222               clip = gdk_pango_layout_get_clip_region (priv->layout,
4223                                                        x, y,
4224                                                        range,
4225                                                        1);
4226               gdk_cairo_region (cr, clip);
4227               cairo_clip (cr);
4228               cairo_region_destroy (clip);
4229
4230               gtk_label_get_link_colors (widget, &link_color, &visited_link_color);
4231               if (active_link->visited)
4232                 text_color = visited_link_color;
4233               else
4234                 text_color = link_color;
4235
4236               if (info->link_clicked)
4237                 state = GTK_STATE_FLAG_ACTIVE;
4238               else
4239                 state = GTK_STATE_FLAG_PRELIGHT;
4240
4241               gtk_style_context_get (context, state,
4242                                      "background-color", &bg_color,
4243                                      NULL);
4244
4245               gdk_cairo_set_source_rgba (cr, bg_color);
4246               cairo_paint (cr);
4247
4248               gdk_cairo_set_source_color (cr, text_color);
4249               cairo_move_to (cr, x, y);
4250               _gtk_pango_fill_layout (cr, priv->layout);
4251
4252               gdk_color_free (link_color);
4253               gdk_color_free (visited_link_color);
4254               gdk_rgba_free (bg_color);
4255
4256               cairo_restore (cr);
4257             }
4258
4259           if (focus_link && gtk_widget_has_focus (widget))
4260             {
4261               range[0] = focus_link->start;
4262               range[1] = focus_link->end;
4263
4264               clip = gdk_pango_layout_get_clip_region (priv->layout,
4265                                                        x, y,
4266                                                        range,
4267                                                        1);
4268               cairo_region_get_extents (clip, &rect);
4269
4270               state = gtk_widget_get_state_flags (widget);
4271               gtk_style_context_set_state (context, state);
4272
4273               gtk_render_focus (context, cr,
4274                                 rect.x, rect.y,
4275                                 rect.width, rect.height);
4276
4277               cairo_region_destroy (clip);
4278             }
4279         }
4280     }
4281
4282   return FALSE;
4283 }
4284
4285 static gboolean
4286 separate_uline_pattern (const gchar  *str,
4287                         guint        *accel_key,
4288                         gchar       **new_str,
4289                         gchar       **pattern)
4290 {
4291   gboolean underscore;
4292   const gchar *src;
4293   gchar *dest;
4294   gchar *pattern_dest;
4295
4296   *accel_key = GDK_KEY_VoidSymbol;
4297   *new_str = g_new (gchar, strlen (str) + 1);
4298   *pattern = g_new (gchar, g_utf8_strlen (str, -1) + 1);
4299
4300   underscore = FALSE;
4301
4302   src = str;
4303   dest = *new_str;
4304   pattern_dest = *pattern;
4305
4306   while (*src)
4307     {
4308       gunichar c;
4309       const gchar *next_src;
4310
4311       c = g_utf8_get_char (src);
4312       if (c == (gunichar)-1)
4313         {
4314           g_warning ("Invalid input string");
4315           g_free (*new_str);
4316           g_free (*pattern);
4317
4318           return FALSE;
4319         }
4320       next_src = g_utf8_next_char (src);
4321
4322       if (underscore)
4323         {
4324           if (c == '_')
4325             *pattern_dest++ = ' ';
4326           else
4327             {
4328               *pattern_dest++ = '_';
4329               if (*accel_key == GDK_KEY_VoidSymbol)
4330                 *accel_key = gdk_keyval_to_lower (gdk_unicode_to_keyval (c));
4331             }
4332
4333           while (src < next_src)
4334             *dest++ = *src++;
4335
4336           underscore = FALSE;
4337         }
4338       else
4339         {
4340           if (c == '_')
4341             {
4342               underscore = TRUE;
4343               src = next_src;
4344             }
4345           else
4346             {
4347               while (src < next_src)
4348                 *dest++ = *src++;
4349
4350               *pattern_dest++ = ' ';
4351             }
4352         }
4353     }
4354
4355   *dest = 0;
4356   *pattern_dest = 0;
4357
4358   return TRUE;
4359 }
4360
4361 static void
4362 gtk_label_set_uline_text_internal (GtkLabel    *label,
4363                                    const gchar *str)
4364 {
4365   GtkLabelPrivate *priv = label->priv;
4366   guint accel_key = GDK_KEY_VoidSymbol;
4367   gchar *new_str;
4368   gchar *pattern;
4369
4370   g_return_if_fail (GTK_IS_LABEL (label));
4371   g_return_if_fail (str != NULL);
4372
4373   /* Split text into the base text and a separate pattern
4374    * of underscores.
4375    */
4376   if (!separate_uline_pattern (str, &accel_key, &new_str, &pattern))
4377     return;
4378
4379   gtk_label_set_text_internal (label, new_str);
4380   gtk_label_set_pattern_internal (label, pattern, TRUE);
4381   priv->mnemonic_keyval = accel_key;
4382
4383   g_free (pattern);
4384 }
4385
4386 /**
4387  * gtk_label_set_text_with_mnemonic:
4388  * @label: a #GtkLabel
4389  * @str: a string
4390  *
4391  * Sets the label's text from the string @str.
4392  * If characters in @str are preceded by an underscore, they are underlined
4393  * indicating that they represent a keyboard accelerator called a mnemonic.
4394  * The mnemonic key can be used to activate another widget, chosen
4395  * automatically, or explicitly using gtk_label_set_mnemonic_widget().
4396  **/
4397 void
4398 gtk_label_set_text_with_mnemonic (GtkLabel    *label,
4399                                   const gchar *str)
4400 {
4401   g_return_if_fail (GTK_IS_LABEL (label));
4402   g_return_if_fail (str != NULL);
4403
4404   g_object_freeze_notify (G_OBJECT (label));
4405
4406   gtk_label_set_label_internal (label, g_strdup (str ? str : ""));
4407   gtk_label_set_use_markup_internal (label, FALSE);
4408   gtk_label_set_use_underline_internal (label, TRUE);
4409
4410   gtk_label_recalculate (label);
4411
4412   g_object_thaw_notify (G_OBJECT (label));
4413 }
4414
4415 static void
4416 gtk_label_realize (GtkWidget *widget)
4417 {
4418   GtkLabel *label = GTK_LABEL (widget);
4419   GtkLabelPrivate *priv = label->priv;
4420
4421   GTK_WIDGET_CLASS (gtk_label_parent_class)->realize (widget);
4422
4423   if (priv->select_info)
4424     gtk_label_create_window (label);
4425 }
4426
4427 static void
4428 gtk_label_unrealize (GtkWidget *widget)
4429 {
4430   GtkLabel *label = GTK_LABEL (widget);
4431   GtkLabelPrivate *priv = label->priv;
4432
4433   if (priv->select_info)
4434     gtk_label_destroy_window (label);
4435
4436   GTK_WIDGET_CLASS (gtk_label_parent_class)->unrealize (widget);
4437 }
4438
4439 static void
4440 gtk_label_map (GtkWidget *widget)
4441 {
4442   GtkLabel *label = GTK_LABEL (widget);
4443   GtkLabelPrivate *priv = label->priv;
4444
4445   GTK_WIDGET_CLASS (gtk_label_parent_class)->map (widget);
4446
4447   if (priv->select_info)
4448     gdk_window_show (priv->select_info->window);
4449 }
4450
4451 static void
4452 gtk_label_unmap (GtkWidget *widget)
4453 {
4454   GtkLabel *label = GTK_LABEL (widget);
4455   GtkLabelPrivate *priv = label->priv;
4456
4457   if (priv->select_info)
4458     gdk_window_hide (priv->select_info->window);
4459
4460   GTK_WIDGET_CLASS (gtk_label_parent_class)->unmap (widget);
4461 }
4462
4463 static void
4464 window_to_layout_coords (GtkLabel *label,
4465                          gint     *x,
4466                          gint     *y)
4467 {
4468   GtkAllocation allocation;
4469   gint lx, ly;
4470   GtkWidget *widget;
4471
4472   widget = GTK_WIDGET (label);
4473
4474   /* get layout location in widget->window coords */
4475   get_layout_location (label, &lx, &ly);
4476
4477   gtk_widget_get_allocation (widget, &allocation);
4478
4479   if (x)
4480     {
4481       *x += allocation.x; /* go to widget->window */
4482       *x -= lx;                   /* go to layout */
4483     }
4484
4485   if (y)
4486     {
4487       *y += allocation.y; /* go to widget->window */
4488       *y -= ly;                   /* go to layout */
4489     }
4490 }
4491
4492 #if 0
4493 static void
4494 layout_to_window_coords (GtkLabel *label,
4495                          gint     *x,
4496                          gint     *y)
4497 {
4498   gint lx, ly;
4499   GtkWidget *widget;
4500
4501   widget = GTK_WIDGET (label);
4502
4503   /* get layout location in widget->window coords */
4504   get_layout_location (label, &lx, &ly);
4505
4506   if (x)
4507     {
4508       *x += lx;                   /* go to widget->window */
4509       *x -= widget->allocation.x; /* go to selection window */
4510     }
4511
4512   if (y)
4513     {
4514       *y += ly;                   /* go to widget->window */
4515       *y -= widget->allocation.y; /* go to selection window */
4516     }
4517 }
4518 #endif
4519
4520 static gboolean
4521 get_layout_index (GtkLabel *label,
4522                   gint      x,
4523                   gint      y,
4524                   gint     *index)
4525 {
4526   GtkLabelPrivate *priv = label->priv;
4527   gint trailing = 0;
4528   const gchar *cluster;
4529   const gchar *cluster_end;
4530   gboolean inside;
4531
4532   *index = 0;
4533
4534   gtk_label_ensure_layout (label);
4535
4536   window_to_layout_coords (label, &x, &y);
4537
4538   x *= PANGO_SCALE;
4539   y *= PANGO_SCALE;
4540
4541   inside = pango_layout_xy_to_index (priv->layout,
4542                                      x, y,
4543                                      index, &trailing);
4544
4545   cluster = priv->text + *index;
4546   cluster_end = cluster;
4547   while (trailing)
4548     {
4549       cluster_end = g_utf8_next_char (cluster_end);
4550       --trailing;
4551     }
4552
4553   *index += (cluster_end - cluster);
4554
4555   return inside;
4556 }
4557
4558 static void
4559 gtk_label_select_word (GtkLabel *label)
4560 {
4561   GtkLabelPrivate *priv = label->priv;
4562   gint min, max;
4563
4564   gint start_index = gtk_label_move_backward_word (label, priv->select_info->selection_end);
4565   gint end_index = gtk_label_move_forward_word (label, priv->select_info->selection_end);
4566
4567   min = MIN (priv->select_info->selection_anchor,
4568              priv->select_info->selection_end);
4569   max = MAX (priv->select_info->selection_anchor,
4570              priv->select_info->selection_end);
4571
4572   min = MIN (min, start_index);
4573   max = MAX (max, end_index);
4574
4575   gtk_label_select_region_index (label, min, max);
4576 }
4577
4578 static void
4579 gtk_label_grab_focus (GtkWidget *widget)
4580 {
4581   GtkLabel *label = GTK_LABEL (widget);
4582   GtkLabelPrivate *priv = label->priv;
4583   gboolean select_on_focus;
4584   GtkLabelLink *link;
4585
4586   if (priv->select_info == NULL)
4587     return;
4588
4589   GTK_WIDGET_CLASS (gtk_label_parent_class)->grab_focus (widget);
4590
4591   if (priv->select_info->selectable)
4592     {
4593       g_object_get (gtk_widget_get_settings (widget),
4594                     "gtk-label-select-on-focus",
4595                     &select_on_focus,
4596                     NULL);
4597
4598       if (select_on_focus && !priv->in_click)
4599         gtk_label_select_region (label, 0, -1);
4600     }
4601   else
4602     {
4603       if (priv->select_info->links && !priv->in_click)
4604         {
4605           link = priv->select_info->links->data;
4606           priv->select_info->selection_anchor = link->start;
4607           priv->select_info->selection_end = link->start;
4608         }
4609     }
4610 }
4611
4612 static gboolean
4613 gtk_label_focus (GtkWidget        *widget,
4614                  GtkDirectionType  direction)
4615 {
4616   GtkLabel *label = GTK_LABEL (widget);
4617   GtkLabelPrivate *priv = label->priv;
4618   GtkLabelSelectionInfo *info = priv->select_info;
4619   GtkLabelLink *focus_link;
4620   GList *l;
4621
4622   if (!gtk_widget_is_focus (widget))
4623     {
4624       gtk_widget_grab_focus (widget);
4625       if (info)
4626         {
4627           focus_link = gtk_label_get_focus_link (label);
4628           if (focus_link && direction == GTK_DIR_TAB_BACKWARD)
4629             {
4630               l = g_list_last (info->links);
4631               focus_link = l->data;
4632               info->selection_anchor = focus_link->start;
4633               info->selection_end = focus_link->start;
4634             }
4635         }
4636
4637       return TRUE;
4638     }
4639
4640   if (!info)
4641     return FALSE;
4642
4643   if (info->selectable)
4644     {
4645       gint index;
4646
4647       if (info->selection_anchor != info->selection_end)
4648         goto out;
4649
4650       index = info->selection_anchor;
4651
4652       if (direction == GTK_DIR_TAB_FORWARD)
4653         for (l = info->links; l; l = l->next)
4654           {
4655             GtkLabelLink *link = l->data;
4656
4657             if (link->start > index)
4658               {
4659                 gtk_label_select_region_index (label, link->start, link->start);
4660                 return TRUE;
4661               }
4662           }
4663       else if (direction == GTK_DIR_TAB_BACKWARD)
4664         for (l = g_list_last (info->links); l; l = l->prev)
4665           {
4666             GtkLabelLink *link = l->data;
4667
4668             if (link->end < index)
4669               {
4670                 gtk_label_select_region_index (label, link->start, link->start);
4671                 return TRUE;
4672               }
4673           }
4674
4675       goto out;
4676     }
4677   else
4678     {
4679       focus_link = gtk_label_get_focus_link (label);
4680       switch (direction)
4681         {
4682         case GTK_DIR_TAB_FORWARD:
4683           if (focus_link)
4684             {
4685               l = g_list_find (info->links, focus_link);
4686               l = l->next;
4687             }
4688           else
4689             l = info->links;
4690           break;
4691
4692         case GTK_DIR_TAB_BACKWARD:
4693           if (focus_link)
4694             {
4695               l = g_list_find (info->links, focus_link);
4696               l = l->prev;
4697             }
4698           else
4699             l = g_list_last (info->links);
4700           break;
4701
4702         default:
4703           goto out;
4704         }
4705
4706       if (l)
4707         {
4708           focus_link = l->data;
4709           info->selection_anchor = focus_link->start;
4710           info->selection_end = focus_link->start;
4711           gtk_widget_queue_draw (widget);
4712
4713           return TRUE;
4714         }
4715     }
4716
4717 out:
4718
4719   return FALSE;
4720 }
4721
4722 static gboolean
4723 gtk_label_button_press (GtkWidget      *widget,
4724                         GdkEventButton *event)
4725 {
4726   GtkLabel *label = GTK_LABEL (widget);
4727   GtkLabelPrivate *priv = label->priv;
4728   GtkLabelSelectionInfo *info = priv->select_info;
4729   gint index = 0;
4730   gint min, max;
4731
4732   if (info == NULL)
4733     return FALSE;
4734
4735   if (info->active_link)
4736     {
4737       if (event->button == 1)
4738         {
4739           info->link_clicked = 1;
4740           gtk_widget_queue_draw (widget);
4741         }
4742       else if (event->button == 3 && event->type == GDK_BUTTON_PRESS)
4743         {
4744           info->link_clicked = 1;
4745           gtk_label_do_popup (label, event);
4746           return TRUE;
4747         }
4748     }
4749
4750   if (!info->selectable)
4751     return FALSE;
4752
4753   info->in_drag = FALSE;
4754   info->select_words = FALSE;
4755
4756   if (event->button == 1)
4757     {
4758       if (!gtk_widget_has_focus (widget))
4759         {
4760           priv->in_click = TRUE;
4761           gtk_widget_grab_focus (widget);
4762           priv->in_click = FALSE;
4763         }
4764
4765       if (event->type == GDK_3BUTTON_PRESS)
4766         {
4767           gtk_label_select_region_index (label, 0, strlen (priv->text));
4768           return TRUE;
4769         }
4770
4771       if (event->type == GDK_2BUTTON_PRESS)
4772         {
4773           info->select_words = TRUE;
4774           gtk_label_select_word (label);
4775           return TRUE;
4776         }
4777
4778       get_layout_index (label, event->x, event->y, &index);
4779
4780       min = MIN (info->selection_anchor, info->selection_end);
4781       max = MAX (info->selection_anchor, info->selection_end);
4782
4783       if ((info->selection_anchor != info->selection_end) &&
4784           (event->state & GDK_SHIFT_MASK))
4785         {
4786           /* extend (same as motion) */
4787           min = MIN (min, index);
4788           max = MAX (max, index);
4789
4790           /* ensure the anchor is opposite index */
4791           if (index == min)
4792             {
4793               gint tmp = min;
4794               min = max;
4795               max = tmp;
4796             }
4797
4798           gtk_label_select_region_index (label, min, max);
4799         }
4800       else
4801         {
4802           if (event->type == GDK_3BUTTON_PRESS)
4803             gtk_label_select_region_index (label, 0, strlen (priv->text));
4804           else if (event->type == GDK_2BUTTON_PRESS)
4805             gtk_label_select_word (label);
4806           else if (min < max && min <= index && index <= max)
4807             {
4808               info->in_drag = TRUE;
4809               info->drag_start_x = event->x;
4810               info->drag_start_y = event->y;
4811             }
4812           else
4813             /* start a replacement */
4814             gtk_label_select_region_index (label, index, index);
4815         }
4816
4817       return TRUE;
4818     }
4819   else if (event->button == 3 && event->type == GDK_BUTTON_PRESS)
4820     {
4821       gtk_label_do_popup (label, event);
4822
4823       return TRUE;
4824     }
4825   return FALSE;
4826 }
4827
4828 static gboolean
4829 gtk_label_button_release (GtkWidget      *widget,
4830                           GdkEventButton *event)
4831
4832 {
4833   GtkLabel *label = GTK_LABEL (widget);
4834   GtkLabelPrivate *priv = label->priv;
4835   GtkLabelSelectionInfo *info = priv->select_info;
4836   gint index;
4837
4838   if (info == NULL)
4839     return FALSE;
4840
4841   if (info->in_drag)
4842     {
4843       info->in_drag = 0;
4844
4845       get_layout_index (label, event->x, event->y, &index);
4846       gtk_label_select_region_index (label, index, index);
4847
4848       return FALSE;
4849     }
4850
4851   if (event->button != 1)
4852     return FALSE;
4853
4854   if (info->active_link &&
4855       info->selection_anchor == info->selection_end &&
4856       info->link_clicked)
4857     {
4858       emit_activate_link (label, info->active_link);
4859       info->link_clicked = 0;
4860
4861       return TRUE;
4862     }
4863
4864   /* The goal here is to return TRUE iff we ate the
4865    * button press to start selecting.
4866    */
4867   return TRUE;
4868 }
4869
4870 static void
4871 connect_mnemonics_visible_notify (GtkLabel *label)
4872 {
4873   GtkLabelPrivate *priv = label->priv;
4874   GtkWidget *toplevel;
4875   gboolean connected;
4876
4877   toplevel = gtk_widget_get_toplevel (GTK_WIDGET (label));
4878
4879   if (!GTK_IS_WINDOW (toplevel))
4880     return;
4881
4882   /* always set up this widgets initial value */
4883   priv->mnemonics_visible =
4884     gtk_window_get_mnemonics_visible (GTK_WINDOW (toplevel));
4885
4886   connected =
4887     GPOINTER_TO_INT (g_object_get_data (G_OBJECT (toplevel),
4888                                         "gtk-label-mnemonics-visible-connected"));
4889
4890   if (!connected)
4891     {
4892       g_signal_connect (toplevel,
4893                         "notify::mnemonics-visible",
4894                         G_CALLBACK (label_mnemonics_visible_changed),
4895                         label);
4896       g_object_set_data (G_OBJECT (toplevel),
4897                          "gtk-label-mnemonics-visible-connected",
4898                          GINT_TO_POINTER (1));
4899     }
4900 }
4901
4902 static void
4903 drag_begin_cb (GtkWidget      *widget,
4904                GdkDragContext *context,
4905                gpointer        data)
4906 {
4907   GtkLabel *label = GTK_LABEL (widget);
4908   GtkLabelPrivate *priv = label->priv;
4909   cairo_surface_t *surface = NULL;
4910
4911   g_signal_handlers_disconnect_by_func (widget, drag_begin_cb, NULL);
4912
4913   if ((priv->select_info->selection_anchor !=
4914        priv->select_info->selection_end) &&
4915       priv->text)
4916     {
4917       gint start, end;
4918       gint len;
4919
4920       start = MIN (priv->select_info->selection_anchor,
4921                    priv->select_info->selection_end);
4922       end = MAX (priv->select_info->selection_anchor,
4923                  priv->select_info->selection_end);
4924
4925       len = strlen (priv->text);
4926
4927       if (end > len)
4928         end = len;
4929
4930       if (start > len)
4931         start = len;
4932
4933       surface = _gtk_text_util_create_drag_icon (widget,
4934                                                  priv->text + start,
4935                                                  end - start);
4936     }
4937
4938   if (surface)
4939     {
4940       gtk_drag_set_icon_surface (context, surface);
4941       cairo_surface_destroy (surface);
4942     }
4943   else
4944     {
4945       gtk_drag_set_icon_default (context);
4946     }
4947 }
4948
4949 static gboolean
4950 gtk_label_motion (GtkWidget      *widget,
4951                   GdkEventMotion *event)
4952 {
4953   GtkLabel *label = GTK_LABEL (widget);
4954   GtkLabelPrivate *priv = label->priv;
4955   GtkLabelSelectionInfo *info = priv->select_info;
4956   gint index;
4957
4958   if (info == NULL)
4959     return FALSE;
4960
4961   if (info->links && !info->in_drag)
4962     {
4963       GList *l;
4964       GtkLabelLink *link;
4965       gboolean found = FALSE;
4966
4967       if (info->selection_anchor == info->selection_end)
4968         {
4969           if (get_layout_index (label, event->x, event->y, &index))
4970             {
4971               for (l = info->links; l != NULL; l = l->next)
4972                 {
4973                   link = l->data;
4974                   if (index >= link->start && index <= link->end)
4975                     {
4976                       found = TRUE;
4977                       break;
4978                     }
4979                 }
4980             }
4981         }
4982
4983       if (found)
4984         {
4985           if (info->active_link != link)
4986             {
4987               info->link_clicked = 0;
4988               info->active_link = link;
4989               gtk_label_update_cursor (label);
4990               gtk_widget_queue_draw (widget);
4991             }
4992         }
4993       else
4994         {
4995           if (info->active_link != NULL)
4996             {
4997               info->link_clicked = 0;
4998               info->active_link = NULL;
4999               gtk_label_update_cursor (label);
5000               gtk_widget_queue_draw (widget);
5001             }
5002         }
5003     }
5004
5005   if (!info->selectable)
5006     return FALSE;
5007
5008   if ((event->state & GDK_BUTTON1_MASK) == 0)
5009     return FALSE;
5010
5011   if (info->in_drag)
5012     {
5013       if (gtk_drag_check_threshold (widget,
5014                                     info->drag_start_x,
5015                                     info->drag_start_y,
5016                                     event->x, event->y))
5017         {
5018           GtkTargetList *target_list = gtk_target_list_new (NULL, 0);
5019
5020           gtk_target_list_add_text_targets (target_list, 0);
5021
5022           g_signal_connect (widget, "drag-begin",
5023                             G_CALLBACK (drag_begin_cb), NULL);
5024           gtk_drag_begin (widget, target_list,
5025                           GDK_ACTION_COPY,
5026                           1, (GdkEvent *)event);
5027
5028           info->in_drag = FALSE;
5029
5030           gtk_target_list_unref (target_list);
5031         }
5032     }
5033   else
5034     {
5035       gint x, y;
5036
5037       gdk_window_get_device_position (info->window, event->device, &x, &y, NULL);
5038       get_layout_index (label, x, y, &index);
5039
5040       if (info->select_words)
5041         {
5042           gint min, max;
5043           gint old_min, old_max;
5044           gint anchor, end;
5045
5046           min = gtk_label_move_backward_word (label, index);
5047           max = gtk_label_move_forward_word (label, index);
5048
5049           anchor = info->selection_anchor;
5050           end = info->selection_end;
5051
5052           old_min = MIN (anchor, end);
5053           old_max = MAX (anchor, end);
5054
5055           if (min < old_min)
5056             {
5057               anchor = min;
5058               end = old_max;
5059             }
5060           else if (old_max < max)
5061             {
5062               anchor = max;
5063               end = old_min;
5064             }
5065           else if (anchor == old_min)
5066             {
5067               if (anchor != min)
5068                 anchor = max;
5069             }
5070           else
5071             {
5072               if (anchor != max)
5073                 anchor = min;
5074             }
5075
5076           gtk_label_select_region_index (label, anchor, end);
5077         }
5078       else
5079         gtk_label_select_region_index (label, info->selection_anchor, index);
5080     }
5081
5082   return TRUE;
5083 }
5084
5085 static gboolean
5086 gtk_label_leave_notify (GtkWidget        *widget,
5087                         GdkEventCrossing *event)
5088 {
5089   GtkLabel *label = GTK_LABEL (widget);
5090   GtkLabelPrivate *priv = label->priv;
5091
5092   if (priv->select_info)
5093     {
5094       priv->select_info->active_link = NULL;
5095       gtk_label_update_cursor (label);
5096       gtk_widget_queue_draw (widget);
5097     }
5098
5099   if (GTK_WIDGET_CLASS (gtk_label_parent_class)->leave_notify_event)
5100     return GTK_WIDGET_CLASS (gtk_label_parent_class)->leave_notify_event (widget, event);
5101
5102  return FALSE;
5103 }
5104
5105 static void
5106 gtk_label_create_window (GtkLabel *label)
5107 {
5108   GtkLabelPrivate *priv = label->priv;
5109   GtkAllocation allocation;
5110   GtkWidget *widget;
5111   GdkWindowAttr attributes;
5112   gint attributes_mask;
5113
5114   g_assert (priv->select_info);
5115   widget = GTK_WIDGET (label);
5116   g_assert (gtk_widget_get_realized (widget));
5117
5118   if (priv->select_info->window)
5119     return;
5120
5121   gtk_widget_get_allocation (widget, &allocation);
5122
5123   attributes.x = allocation.x;
5124   attributes.y = allocation.y;
5125   attributes.width = allocation.width;
5126   attributes.height = allocation.height;
5127   attributes.window_type = GDK_WINDOW_CHILD;
5128   attributes.wclass = GDK_INPUT_ONLY;
5129   attributes.override_redirect = TRUE;
5130   attributes.event_mask = gtk_widget_get_events (widget) |
5131     GDK_BUTTON_PRESS_MASK        |
5132     GDK_BUTTON_RELEASE_MASK      |
5133     GDK_LEAVE_NOTIFY_MASK        |
5134     GDK_BUTTON_MOTION_MASK       |
5135     GDK_POINTER_MOTION_MASK      |
5136     GDK_POINTER_MOTION_HINT_MASK;
5137   attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_NOREDIR;
5138   if (gtk_widget_is_sensitive (widget))
5139     {
5140       attributes.cursor = gdk_cursor_new_for_display (gtk_widget_get_display (widget),
5141                                                       GDK_XTERM);
5142       attributes_mask |= GDK_WA_CURSOR;
5143     }
5144
5145
5146   priv->select_info->window = gdk_window_new (gtk_widget_get_window (widget),
5147                                                &attributes, attributes_mask);
5148   gdk_window_set_user_data (priv->select_info->window, widget);
5149
5150   if (attributes_mask & GDK_WA_CURSOR)
5151     g_object_unref (attributes.cursor);
5152 }
5153
5154 static void
5155 gtk_label_destroy_window (GtkLabel *label)
5156 {
5157   GtkLabelPrivate *priv = label->priv;
5158
5159   g_assert (priv->select_info);
5160
5161   if (priv->select_info->window == NULL)
5162     return;
5163
5164   gdk_window_set_user_data (priv->select_info->window, NULL);
5165   gdk_window_destroy (priv->select_info->window);
5166   priv->select_info->window = NULL;
5167 }
5168
5169 static void
5170 gtk_label_ensure_select_info (GtkLabel *label)
5171 {
5172   GtkLabelPrivate *priv = label->priv;
5173
5174   if (priv->select_info == NULL)
5175     {
5176       priv->select_info = g_new0 (GtkLabelSelectionInfo, 1);
5177
5178       gtk_widget_set_can_focus (GTK_WIDGET (label), TRUE);
5179
5180       if (gtk_widget_get_realized (GTK_WIDGET (label)))
5181         gtk_label_create_window (label);
5182
5183       if (gtk_widget_get_mapped (GTK_WIDGET (label)))
5184         gdk_window_show (priv->select_info->window);
5185     }
5186 }
5187
5188 static void
5189 gtk_label_clear_select_info (GtkLabel *label)
5190 {
5191   GtkLabelPrivate *priv = label->priv;
5192
5193   if (priv->select_info == NULL)
5194     return;
5195
5196   if (!priv->select_info->selectable && !priv->select_info->links)
5197     {
5198       gtk_label_destroy_window (label);
5199
5200       g_free (priv->select_info);
5201       priv->select_info = NULL;
5202
5203       gtk_widget_set_can_focus (GTK_WIDGET (label), FALSE);
5204     }
5205 }
5206
5207 /**
5208  * gtk_label_set_selectable:
5209  * @label: a #GtkLabel
5210  * @setting: %TRUE to allow selecting text in the label
5211  *
5212  * Selectable labels allow the user to select text from the label, for
5213  * copy-and-paste.
5214  **/
5215 void
5216 gtk_label_set_selectable (GtkLabel *label,
5217                           gboolean  setting)
5218 {
5219   GtkLabelPrivate *priv;
5220   gboolean old_setting;
5221
5222   g_return_if_fail (GTK_IS_LABEL (label));
5223
5224   priv = label->priv;
5225
5226   setting = setting != FALSE;
5227   old_setting = priv->select_info && priv->select_info->selectable;
5228
5229   if (setting)
5230     {
5231       gtk_label_ensure_select_info (label);
5232       priv->select_info->selectable = TRUE;
5233       gtk_label_update_cursor (label);
5234     }
5235   else
5236     {
5237       if (old_setting)
5238         {
5239           /* unselect, to give up the selection */
5240           gtk_label_select_region (label, 0, 0);
5241
5242           priv->select_info->selectable = FALSE;
5243           gtk_label_clear_select_info (label);
5244           gtk_label_update_cursor (label);
5245         }
5246     }
5247   if (setting != old_setting)
5248     {
5249       g_object_freeze_notify (G_OBJECT (label));
5250       g_object_notify (G_OBJECT (label), "selectable");
5251       g_object_notify (G_OBJECT (label), "cursor-position");
5252       g_object_notify (G_OBJECT (label), "selection-bound");
5253       g_object_thaw_notify (G_OBJECT (label));
5254       gtk_widget_queue_draw (GTK_WIDGET (label));
5255     }
5256 }
5257
5258 /**
5259  * gtk_label_get_selectable:
5260  * @label: a #GtkLabel
5261  *
5262  * Gets the value set by gtk_label_set_selectable().
5263  *
5264  * Return value: %TRUE if the user can copy text from the label
5265  **/
5266 gboolean
5267 gtk_label_get_selectable (GtkLabel *label)
5268 {
5269   GtkLabelPrivate *priv;
5270
5271   g_return_val_if_fail (GTK_IS_LABEL (label), FALSE);
5272
5273   priv = label->priv;
5274
5275   return priv->select_info && priv->select_info->selectable;
5276 }
5277
5278 /**
5279  * gtk_label_set_angle:
5280  * @label: a #GtkLabel
5281  * @angle: the angle that the baseline of the label makes with
5282  *   the horizontal, in degrees, measured counterclockwise
5283  *
5284  * Sets the angle of rotation for the label. An angle of 90 reads from
5285  * from bottom to top, an angle of 270, from top to bottom. The angle
5286  * setting for the label is ignored if the label is selectable,
5287  * wrapped, or ellipsized.
5288  *
5289  * Since: 2.6
5290  **/
5291 void
5292 gtk_label_set_angle (GtkLabel *label,
5293                      gdouble   angle)
5294 {
5295   GtkLabelPrivate *priv;
5296
5297   g_return_if_fail (GTK_IS_LABEL (label));
5298
5299   priv = label->priv;
5300
5301   /* Canonicalize to [0,360]. We don't canonicalize 360 to 0, because
5302    * double property ranges are inclusive, and changing 360 to 0 would
5303    * make a property editor behave strangely.
5304    */
5305   if (angle < 0 || angle > 360.0)
5306     angle = angle - 360. * floor (angle / 360.);
5307
5308   if (priv->angle != angle)
5309     {
5310       priv->angle = angle;
5311
5312       gtk_label_clear_layout (label);
5313       gtk_widget_queue_resize (GTK_WIDGET (label));
5314
5315       g_object_notify (G_OBJECT (label), "angle");
5316     }
5317 }
5318
5319 /**
5320  * gtk_label_get_angle:
5321  * @label: a #GtkLabel
5322  *
5323  * Gets the angle of rotation for the label. See
5324  * gtk_label_set_angle().
5325  *
5326  * Return value: the angle of rotation for the label
5327  *
5328  * Since: 2.6
5329  **/
5330 gdouble
5331 gtk_label_get_angle  (GtkLabel *label)
5332 {
5333   g_return_val_if_fail (GTK_IS_LABEL (label), 0.0);
5334
5335   return label->priv->angle;
5336 }
5337
5338 static void
5339 gtk_label_set_selection_text (GtkLabel         *label,
5340                               GtkSelectionData *selection_data)
5341 {
5342   GtkLabelPrivate *priv = label->priv;
5343
5344   if ((priv->select_info->selection_anchor !=
5345        priv->select_info->selection_end) &&
5346       priv->text)
5347     {
5348       gint start, end;
5349       gint len;
5350
5351       start = MIN (priv->select_info->selection_anchor,
5352                    priv->select_info->selection_end);
5353       end = MAX (priv->select_info->selection_anchor,
5354                  priv->select_info->selection_end);
5355
5356       len = strlen (priv->text);
5357
5358       if (end > len)
5359         end = len;
5360
5361       if (start > len)
5362         start = len;
5363
5364       gtk_selection_data_set_text (selection_data,
5365                                    priv->text + start,
5366                                    end - start);
5367     }
5368 }
5369
5370 static void
5371 gtk_label_drag_data_get (GtkWidget        *widget,
5372                          GdkDragContext   *context,
5373                          GtkSelectionData *selection_data,
5374                          guint             info,
5375                          guint             time)
5376 {
5377   gtk_label_set_selection_text (GTK_LABEL (widget), selection_data);
5378 }
5379
5380 static void
5381 get_text_callback (GtkClipboard     *clipboard,
5382                    GtkSelectionData *selection_data,
5383                    guint             info,
5384                    gpointer          user_data_or_owner)
5385 {
5386   gtk_label_set_selection_text (GTK_LABEL (user_data_or_owner), selection_data);
5387 }
5388
5389 static void
5390 clear_text_callback (GtkClipboard     *clipboard,
5391                      gpointer          user_data_or_owner)
5392 {
5393   GtkLabel *label;
5394   GtkLabelPrivate *priv;
5395
5396   label = GTK_LABEL (user_data_or_owner);
5397   priv = label->priv;
5398
5399   if (priv->select_info)
5400     {
5401       priv->select_info->selection_anchor = priv->select_info->selection_end;
5402
5403       gtk_widget_queue_draw (GTK_WIDGET (label));
5404     }
5405 }
5406
5407 static void
5408 gtk_label_select_region_index (GtkLabel *label,
5409                                gint      anchor_index,
5410                                gint      end_index)
5411 {
5412   GtkLabelPrivate *priv;
5413
5414   g_return_if_fail (GTK_IS_LABEL (label));
5415
5416   priv = label->priv;
5417
5418   if (priv->select_info && priv->select_info->selectable)
5419     {
5420       GtkClipboard *clipboard;
5421
5422       if (priv->select_info->selection_anchor == anchor_index &&
5423           priv->select_info->selection_end == end_index)
5424         return;
5425
5426       priv->select_info->selection_anchor = anchor_index;
5427       priv->select_info->selection_end = end_index;
5428
5429       clipboard = gtk_widget_get_clipboard (GTK_WIDGET (label),
5430                                             GDK_SELECTION_PRIMARY);
5431
5432       if (anchor_index != end_index)
5433         {
5434           GtkTargetList *list;
5435           GtkTargetEntry *targets;
5436           gint n_targets;
5437
5438           list = gtk_target_list_new (NULL, 0);
5439           gtk_target_list_add_text_targets (list, 0);
5440           targets = gtk_target_table_new_from_list (list, &n_targets);
5441
5442           gtk_clipboard_set_with_owner (clipboard,
5443                                         targets, n_targets,
5444                                         get_text_callback,
5445                                         clear_text_callback,
5446                                         G_OBJECT (label));
5447
5448           gtk_target_table_free (targets, n_targets);
5449           gtk_target_list_unref (list);
5450         }
5451       else
5452         {
5453           if (gtk_clipboard_get_owner (clipboard) == G_OBJECT (label))
5454             gtk_clipboard_clear (clipboard);
5455         }
5456
5457       gtk_widget_queue_draw (GTK_WIDGET (label));
5458
5459       g_object_freeze_notify (G_OBJECT (label));
5460       g_object_notify (G_OBJECT (label), "cursor-position");
5461       g_object_notify (G_OBJECT (label), "selection-bound");
5462       g_object_thaw_notify (G_OBJECT (label));
5463     }
5464 }
5465
5466 /**
5467  * gtk_label_select_region:
5468  * @label: a #GtkLabel
5469  * @start_offset: start offset (in characters not bytes)
5470  * @end_offset: end offset (in characters not bytes)
5471  *
5472  * Selects a range of characters in the label, if the label is selectable.
5473  * See gtk_label_set_selectable(). If the label is not selectable,
5474  * this function has no effect. If @start_offset or
5475  * @end_offset are -1, then the end of the label will be substituted.
5476  **/
5477 void
5478 gtk_label_select_region  (GtkLabel *label,
5479                           gint      start_offset,
5480                           gint      end_offset)
5481 {
5482   GtkLabelPrivate *priv;
5483
5484   g_return_if_fail (GTK_IS_LABEL (label));
5485
5486   priv = label->priv;
5487
5488   if (priv->text && priv->select_info)
5489     {
5490       if (start_offset < 0)
5491         start_offset = g_utf8_strlen (priv->text, -1);
5492
5493       if (end_offset < 0)
5494         end_offset = g_utf8_strlen (priv->text, -1);
5495
5496       gtk_label_select_region_index (label,
5497                                      g_utf8_offset_to_pointer (priv->text, start_offset) - priv->text,
5498                                      g_utf8_offset_to_pointer (priv->text, end_offset) - priv->text);
5499     }
5500 }
5501
5502 /**
5503  * gtk_label_get_selection_bounds:
5504  * @label: a #GtkLabel
5505  * @start: (out): return location for start of selection, as a character offset
5506  * @end: (out): return location for end of selection, as a character offset
5507  *
5508  * Gets the selected range of characters in the label, returning %TRUE
5509  * if there's a selection.
5510  *
5511  * Return value: %TRUE if selection is non-empty
5512  **/
5513 gboolean
5514 gtk_label_get_selection_bounds (GtkLabel  *label,
5515                                 gint      *start,
5516                                 gint      *end)
5517 {
5518   GtkLabelPrivate *priv;
5519
5520   g_return_val_if_fail (GTK_IS_LABEL (label), FALSE);
5521
5522   priv = label->priv;
5523
5524   if (priv->select_info == NULL)
5525     {
5526       /* not a selectable label */
5527       if (start)
5528         *start = 0;
5529       if (end)
5530         *end = 0;
5531
5532       return FALSE;
5533     }
5534   else
5535     {
5536       gint start_index, end_index;
5537       gint start_offset, end_offset;
5538       gint len;
5539
5540       start_index = MIN (priv->select_info->selection_anchor,
5541                    priv->select_info->selection_end);
5542       end_index = MAX (priv->select_info->selection_anchor,
5543                  priv->select_info->selection_end);
5544
5545       len = strlen (priv->text);
5546
5547       if (end_index > len)
5548         end_index = len;
5549
5550       if (start_index > len)
5551         start_index = len;
5552
5553       start_offset = g_utf8_strlen (priv->text, start_index);
5554       end_offset = g_utf8_strlen (priv->text, end_index);
5555
5556       if (start_offset > end_offset)
5557         {
5558           gint tmp = start_offset;
5559           start_offset = end_offset;
5560           end_offset = tmp;
5561         }
5562
5563       if (start)
5564         *start = start_offset;
5565
5566       if (end)
5567         *end = end_offset;
5568
5569       return start_offset != end_offset;
5570     }
5571 }
5572
5573
5574 /**
5575  * gtk_label_get_layout:
5576  * @label: a #GtkLabel
5577  *
5578  * Gets the #PangoLayout used to display the label.
5579  * The layout is useful to e.g. convert text positions to
5580  * pixel positions, in combination with gtk_label_get_layout_offsets().
5581  * The returned layout is owned by the @label so need not be
5582  * freed by the caller. The @label is free to recreate its layout at
5583  * any time, so it should be considered read-only.
5584  *
5585  * Return value: (transfer none): the #PangoLayout for this label
5586  **/
5587 PangoLayout*
5588 gtk_label_get_layout (GtkLabel *label)
5589 {
5590   GtkLabelPrivate *priv;
5591
5592   g_return_val_if_fail (GTK_IS_LABEL (label), NULL);
5593
5594   priv = label->priv;
5595
5596   gtk_label_ensure_layout (label);
5597
5598   return priv->layout;
5599 }
5600
5601 /**
5602  * gtk_label_get_layout_offsets:
5603  * @label: a #GtkLabel
5604  * @x: (out) (allow-none): location to store X offset of layout, or %NULL
5605  * @y: (out) (allow-none): location to store Y offset of layout, or %NULL
5606  *
5607  * Obtains the coordinates where the label will draw the #PangoLayout
5608  * representing the text in the label; useful to convert mouse events
5609  * into coordinates inside the #PangoLayout, e.g. to take some action
5610  * if some part of the label is clicked. Of course you will need to
5611  * create a #GtkEventBox to receive the events, and pack the label
5612  * inside it, since labels are a #GTK_NO_WINDOW widget. Remember
5613  * when using the #PangoLayout functions you need to convert to
5614  * and from pixels using PANGO_PIXELS() or #PANGO_SCALE.
5615  **/
5616 void
5617 gtk_label_get_layout_offsets (GtkLabel *label,
5618                               gint     *x,
5619                               gint     *y)
5620 {
5621   g_return_if_fail (GTK_IS_LABEL (label));
5622
5623   gtk_label_ensure_layout (label);
5624
5625   get_layout_location (label, x, y);
5626 }
5627
5628 /**
5629  * gtk_label_set_use_markup:
5630  * @label: a #GtkLabel
5631  * @setting: %TRUE if the label's text should be parsed for markup.
5632  *
5633  * Sets whether the text of the label contains markup in <link
5634  * linkend="PangoMarkupFormat">Pango's text markup
5635  * language</link>. See gtk_label_set_markup().
5636  **/
5637 void
5638 gtk_label_set_use_markup (GtkLabel *label,
5639                           gboolean  setting)
5640 {
5641   g_return_if_fail (GTK_IS_LABEL (label));
5642
5643   gtk_label_set_use_markup_internal (label, setting);
5644   gtk_label_recalculate (label);
5645 }
5646
5647 /**
5648  * gtk_label_get_use_markup:
5649  * @label: a #GtkLabel
5650  *
5651  * Returns whether the label's text is interpreted as marked up with
5652  * the <link linkend="PangoMarkupFormat">Pango text markup
5653  * language</link>. See gtk_label_set_use_markup ().
5654  *
5655  * Return value: %TRUE if the label's text will be parsed for markup.
5656  **/
5657 gboolean
5658 gtk_label_get_use_markup (GtkLabel *label)
5659 {
5660   g_return_val_if_fail (GTK_IS_LABEL (label), FALSE);
5661
5662   return label->priv->use_markup;
5663 }
5664
5665 /**
5666  * gtk_label_set_use_underline:
5667  * @label: a #GtkLabel
5668  * @setting: %TRUE if underlines in the text indicate mnemonics
5669  *
5670  * If true, an underline in the text indicates the next character should be
5671  * used for the mnemonic accelerator key.
5672  */
5673 void
5674 gtk_label_set_use_underline (GtkLabel *label,
5675                              gboolean  setting)
5676 {
5677   g_return_if_fail (GTK_IS_LABEL (label));
5678
5679   gtk_label_set_use_underline_internal (label, setting);
5680   gtk_label_recalculate (label);
5681 }
5682
5683 /**
5684  * gtk_label_get_use_underline:
5685  * @label: a #GtkLabel
5686  *
5687  * Returns whether an embedded underline in the label indicates a
5688  * mnemonic. See gtk_label_set_use_underline().
5689  *
5690  * Return value: %TRUE whether an embedded underline in the label indicates
5691  *               the mnemonic accelerator keys.
5692  **/
5693 gboolean
5694 gtk_label_get_use_underline (GtkLabel *label)
5695 {
5696   g_return_val_if_fail (GTK_IS_LABEL (label), FALSE);
5697
5698   return label->priv->use_underline;
5699 }
5700
5701 /**
5702  * gtk_label_set_single_line_mode:
5703  * @label: a #GtkLabel
5704  * @single_line_mode: %TRUE if the label should be in single line mode
5705  *
5706  * Sets whether the label is in single line mode.
5707  *
5708  * Since: 2.6
5709  */
5710 void
5711 gtk_label_set_single_line_mode (GtkLabel *label,
5712                                 gboolean single_line_mode)
5713 {
5714   GtkLabelPrivate *priv;
5715
5716   g_return_if_fail (GTK_IS_LABEL (label));
5717
5718   priv = label->priv;
5719
5720   single_line_mode = single_line_mode != FALSE;
5721
5722   if (priv->single_line_mode != single_line_mode)
5723     {
5724       priv->single_line_mode = single_line_mode;
5725
5726       gtk_label_clear_layout (label);
5727       gtk_widget_queue_resize (GTK_WIDGET (label));
5728
5729       g_object_notify (G_OBJECT (label), "single-line-mode");
5730     }
5731 }
5732
5733 /**
5734  * gtk_label_get_single_line_mode:
5735  * @label: a #GtkLabel
5736  *
5737  * Returns whether the label is in single line mode.
5738  *
5739  * Return value: %TRUE when the label is in single line mode.
5740  *
5741  * Since: 2.6
5742  **/
5743 gboolean
5744 gtk_label_get_single_line_mode  (GtkLabel *label)
5745 {
5746   g_return_val_if_fail (GTK_IS_LABEL (label), FALSE);
5747
5748   return label->priv->single_line_mode;
5749 }
5750
5751 /* Compute the X position for an offset that corresponds to the "more important
5752  * cursor position for that offset. We use this when trying to guess to which
5753  * end of the selection we should go to when the user hits the left or
5754  * right arrow key.
5755  */
5756 static void
5757 get_better_cursor (GtkLabel *label,
5758                    gint      index,
5759                    gint      *x,
5760                    gint      *y)
5761 {
5762   GtkLabelPrivate *priv = label->priv;
5763   GdkKeymap *keymap = gdk_keymap_get_for_display (gtk_widget_get_display (GTK_WIDGET (label)));
5764   PangoDirection keymap_direction = gdk_keymap_get_direction (keymap);
5765   PangoDirection cursor_direction = get_cursor_direction (label);
5766   gboolean split_cursor;
5767   PangoRectangle strong_pos, weak_pos;
5768
5769   g_object_get (gtk_widget_get_settings (GTK_WIDGET (label)),
5770                 "gtk-split-cursor", &split_cursor,
5771                 NULL);
5772
5773   gtk_label_ensure_layout (label);
5774
5775   pango_layout_get_cursor_pos (priv->layout, index,
5776                                &strong_pos, &weak_pos);
5777
5778   if (split_cursor)
5779     {
5780       *x = strong_pos.x / PANGO_SCALE;
5781       *y = strong_pos.y / PANGO_SCALE;
5782     }
5783   else
5784     {
5785       if (keymap_direction == cursor_direction)
5786         {
5787           *x = strong_pos.x / PANGO_SCALE;
5788           *y = strong_pos.y / PANGO_SCALE;
5789         }
5790       else
5791         {
5792           *x = weak_pos.x / PANGO_SCALE;
5793           *y = weak_pos.y / PANGO_SCALE;
5794         }
5795     }
5796 }
5797
5798
5799 static gint
5800 gtk_label_move_logically (GtkLabel *label,
5801                           gint      start,
5802                           gint      count)
5803 {
5804   GtkLabelPrivate *priv = label->priv;
5805   gint offset = g_utf8_pointer_to_offset (priv->text,
5806                                           priv->text + start);
5807
5808   if (priv->text)
5809     {
5810       PangoLogAttr *log_attrs;
5811       gint n_attrs;
5812       gint length;
5813
5814       gtk_label_ensure_layout (label);
5815
5816       length = g_utf8_strlen (priv->text, -1);
5817
5818       pango_layout_get_log_attrs (priv->layout, &log_attrs, &n_attrs);
5819
5820       while (count > 0 && offset < length)
5821         {
5822           do
5823             offset++;
5824           while (offset < length && !log_attrs[offset].is_cursor_position);
5825
5826           count--;
5827         }
5828       while (count < 0 && offset > 0)
5829         {
5830           do
5831             offset--;
5832           while (offset > 0 && !log_attrs[offset].is_cursor_position);
5833
5834           count++;
5835         }
5836
5837       g_free (log_attrs);
5838     }
5839
5840   return g_utf8_offset_to_pointer (priv->text, offset) - priv->text;
5841 }
5842
5843 static gint
5844 gtk_label_move_visually (GtkLabel *label,
5845                          gint      start,
5846                          gint      count)
5847 {
5848   GtkLabelPrivate *priv = label->priv;
5849   gint index;
5850
5851   index = start;
5852
5853   while (count != 0)
5854     {
5855       int new_index, new_trailing;
5856       gboolean split_cursor;
5857       gboolean strong;
5858
5859       gtk_label_ensure_layout (label);
5860
5861       g_object_get (gtk_widget_get_settings (GTK_WIDGET (label)),
5862                     "gtk-split-cursor", &split_cursor,
5863                     NULL);
5864
5865       if (split_cursor)
5866         strong = TRUE;
5867       else
5868         {
5869           GdkKeymap *keymap = gdk_keymap_get_for_display (gtk_widget_get_display (GTK_WIDGET (label)));
5870           PangoDirection keymap_direction = gdk_keymap_get_direction (keymap);
5871
5872           strong = keymap_direction == get_cursor_direction (label);
5873         }
5874
5875       if (count > 0)
5876         {
5877           pango_layout_move_cursor_visually (priv->layout, strong, index, 0, 1, &new_index, &new_trailing);
5878           count--;
5879         }
5880       else
5881         {
5882           pango_layout_move_cursor_visually (priv->layout, strong, index, 0, -1, &new_index, &new_trailing);
5883           count++;
5884         }
5885
5886       if (new_index < 0 || new_index == G_MAXINT)
5887         break;
5888
5889       index = new_index;
5890
5891       while (new_trailing--)
5892         index = g_utf8_next_char (priv->text + new_index) - priv->text;
5893     }
5894
5895   return index;
5896 }
5897
5898 static gint
5899 gtk_label_move_forward_word (GtkLabel *label,
5900                              gint      start)
5901 {
5902   GtkLabelPrivate *priv = label->priv;
5903   gint new_pos = g_utf8_pointer_to_offset (priv->text,
5904                                            priv->text + start);
5905   gint length;
5906
5907   length = g_utf8_strlen (priv->text, -1);
5908   if (new_pos < length)
5909     {
5910       PangoLogAttr *log_attrs;
5911       gint n_attrs;
5912
5913       gtk_label_ensure_layout (label);
5914
5915       pango_layout_get_log_attrs (priv->layout, &log_attrs, &n_attrs);
5916
5917       /* Find the next word end */
5918       new_pos++;
5919       while (new_pos < n_attrs && !log_attrs[new_pos].is_word_end)
5920         new_pos++;
5921
5922       g_free (log_attrs);
5923     }
5924
5925   return g_utf8_offset_to_pointer (priv->text, new_pos) - priv->text;
5926 }
5927
5928
5929 static gint
5930 gtk_label_move_backward_word (GtkLabel *label,
5931                               gint      start)
5932 {
5933   GtkLabelPrivate *priv = label->priv;
5934   gint new_pos = g_utf8_pointer_to_offset (priv->text,
5935                                            priv->text + start);
5936
5937   if (new_pos > 0)
5938     {
5939       PangoLogAttr *log_attrs;
5940       gint n_attrs;
5941
5942       gtk_label_ensure_layout (label);
5943
5944       pango_layout_get_log_attrs (priv->layout, &log_attrs, &n_attrs);
5945
5946       new_pos -= 1;
5947
5948       /* Find the previous word beginning */
5949       while (new_pos > 0 && !log_attrs[new_pos].is_word_start)
5950         new_pos--;
5951
5952       g_free (log_attrs);
5953     }
5954
5955   return g_utf8_offset_to_pointer (priv->text, new_pos) - priv->text;
5956 }
5957
5958 static void
5959 gtk_label_move_cursor (GtkLabel       *label,
5960                        GtkMovementStep step,
5961                        gint            count,
5962                        gboolean        extend_selection)
5963 {
5964   GtkLabelPrivate *priv = label->priv;
5965   gint old_pos;
5966   gint new_pos;
5967
5968   if (priv->select_info == NULL)
5969     return;
5970
5971   old_pos = new_pos = priv->select_info->selection_end;
5972
5973   if (priv->select_info->selection_end != priv->select_info->selection_anchor &&
5974       !extend_selection)
5975     {
5976       /* If we have a current selection and aren't extending it, move to the
5977        * start/or end of the selection as appropriate
5978        */
5979       switch (step)
5980         {
5981         case GTK_MOVEMENT_VISUAL_POSITIONS:
5982           {
5983             gint end_x, end_y;
5984             gint anchor_x, anchor_y;
5985             gboolean end_is_left;
5986
5987             get_better_cursor (label, priv->select_info->selection_end, &end_x, &end_y);
5988             get_better_cursor (label, priv->select_info->selection_anchor, &anchor_x, &anchor_y);
5989
5990             end_is_left = (end_y < anchor_y) || (end_y == anchor_y && end_x < anchor_x);
5991
5992             if (count < 0)
5993               new_pos = end_is_left ? priv->select_info->selection_end : priv->select_info->selection_anchor;
5994             else
5995               new_pos = !end_is_left ? priv->select_info->selection_end : priv->select_info->selection_anchor;
5996             break;
5997           }
5998         case GTK_MOVEMENT_LOGICAL_POSITIONS:
5999         case GTK_MOVEMENT_WORDS:
6000           if (count < 0)
6001             new_pos = MIN (priv->select_info->selection_end, priv->select_info->selection_anchor);
6002           else
6003             new_pos = MAX (priv->select_info->selection_end, priv->select_info->selection_anchor);
6004           break;
6005         case GTK_MOVEMENT_DISPLAY_LINE_ENDS:
6006         case GTK_MOVEMENT_PARAGRAPH_ENDS:
6007         case GTK_MOVEMENT_BUFFER_ENDS:
6008           /* FIXME: Can do better here */
6009           new_pos = count < 0 ? 0 : strlen (priv->text);
6010           break;
6011         case GTK_MOVEMENT_DISPLAY_LINES:
6012         case GTK_MOVEMENT_PARAGRAPHS:
6013         case GTK_MOVEMENT_PAGES:
6014         case GTK_MOVEMENT_HORIZONTAL_PAGES:
6015           break;
6016         }
6017     }
6018   else
6019     {
6020       switch (step)
6021         {
6022         case GTK_MOVEMENT_LOGICAL_POSITIONS:
6023           new_pos = gtk_label_move_logically (label, new_pos, count);
6024           break;
6025         case GTK_MOVEMENT_VISUAL_POSITIONS:
6026           new_pos = gtk_label_move_visually (label, new_pos, count);
6027           if (new_pos == old_pos)
6028             {
6029               if (!extend_selection)
6030                 {
6031                   if (!gtk_widget_keynav_failed (GTK_WIDGET (label),
6032                                                  count > 0 ?
6033                                                  GTK_DIR_RIGHT : GTK_DIR_LEFT))
6034                     {
6035                       GtkWidget *toplevel = gtk_widget_get_toplevel (GTK_WIDGET (label));
6036
6037                       if (toplevel)
6038                         gtk_widget_child_focus (toplevel,
6039                                                 count > 0 ?
6040                                                 GTK_DIR_RIGHT : GTK_DIR_LEFT);
6041                     }
6042                 }
6043               else
6044                 {
6045                   gtk_widget_error_bell (GTK_WIDGET (label));
6046                 }
6047             }
6048           break;
6049         case GTK_MOVEMENT_WORDS:
6050           while (count > 0)
6051             {
6052               new_pos = gtk_label_move_forward_word (label, new_pos);
6053               count--;
6054             }
6055           while (count < 0)
6056             {
6057               new_pos = gtk_label_move_backward_word (label, new_pos);
6058               count++;
6059             }
6060           if (new_pos == old_pos)
6061             gtk_widget_error_bell (GTK_WIDGET (label));
6062           break;
6063         case GTK_MOVEMENT_DISPLAY_LINE_ENDS:
6064         case GTK_MOVEMENT_PARAGRAPH_ENDS:
6065         case GTK_MOVEMENT_BUFFER_ENDS:
6066           /* FIXME: Can do better here */
6067           new_pos = count < 0 ? 0 : strlen (priv->text);
6068           if (new_pos == old_pos)
6069             gtk_widget_error_bell (GTK_WIDGET (label));
6070           break;
6071         case GTK_MOVEMENT_DISPLAY_LINES:
6072         case GTK_MOVEMENT_PARAGRAPHS:
6073         case GTK_MOVEMENT_PAGES:
6074         case GTK_MOVEMENT_HORIZONTAL_PAGES:
6075           break;
6076         }
6077     }
6078
6079   if (extend_selection)
6080     gtk_label_select_region_index (label,
6081                                    priv->select_info->selection_anchor,
6082                                    new_pos);
6083   else
6084     gtk_label_select_region_index (label, new_pos, new_pos);
6085 }
6086
6087 static void
6088 gtk_label_copy_clipboard (GtkLabel *label)
6089 {
6090   GtkLabelPrivate *priv = label->priv;
6091
6092   if (priv->text && priv->select_info)
6093     {
6094       gint start, end;
6095       gint len;
6096       GtkClipboard *clipboard;
6097
6098       start = MIN (priv->select_info->selection_anchor,
6099                    priv->select_info->selection_end);
6100       end = MAX (priv->select_info->selection_anchor,
6101                  priv->select_info->selection_end);
6102
6103       len = strlen (priv->text);
6104
6105       if (end > len)
6106         end = len;
6107
6108       if (start > len)
6109         start = len;
6110
6111       clipboard = gtk_widget_get_clipboard (GTK_WIDGET (label), GDK_SELECTION_CLIPBOARD);
6112
6113       if (start != end)
6114         gtk_clipboard_set_text (clipboard, priv->text + start, end - start);
6115       else
6116         {
6117           GtkLabelLink *link;
6118
6119           link = gtk_label_get_focus_link (label);
6120           if (link)
6121             gtk_clipboard_set_text (clipboard, link->uri, -1);
6122         }
6123     }
6124 }
6125
6126 static void
6127 gtk_label_select_all (GtkLabel *label)
6128 {
6129   GtkLabelPrivate *priv = label->priv;
6130
6131   gtk_label_select_region_index (label, 0, strlen (priv->text));
6132 }
6133
6134 /* Quick hack of a popup menu
6135  */
6136 static void
6137 activate_cb (GtkWidget *menuitem,
6138              GtkLabel  *label)
6139 {
6140   const gchar *signal = g_object_get_data (G_OBJECT (menuitem), "gtk-signal");
6141   g_signal_emit_by_name (label, signal);
6142 }
6143
6144 static void
6145 append_action_signal (GtkLabel     *label,
6146                       GtkWidget    *menu,
6147                       const gchar  *stock_id,
6148                       const gchar  *signal,
6149                       gboolean      sensitive)
6150 {
6151   GtkWidget *menuitem = gtk_image_menu_item_new_from_stock (stock_id, NULL);
6152
6153   g_object_set_data (G_OBJECT (menuitem), I_("gtk-signal"), (char *)signal);
6154   g_signal_connect (menuitem, "activate",
6155                     G_CALLBACK (activate_cb), label);
6156
6157   gtk_widget_set_sensitive (menuitem, sensitive);
6158
6159   gtk_widget_show (menuitem);
6160   gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
6161 }
6162
6163 static void
6164 popup_menu_detach (GtkWidget *attach_widget,
6165                    GtkMenu   *menu)
6166 {
6167   GtkLabel *label = GTK_LABEL (attach_widget);
6168   GtkLabelPrivate *priv = label->priv;
6169
6170   if (priv->select_info)
6171     priv->select_info->popup_menu = NULL;
6172 }
6173
6174 static void
6175 popup_position_func (GtkMenu   *menu,
6176                      gint      *x,
6177                      gint      *y,
6178                      gboolean  *push_in,
6179                      gpointer   user_data)
6180 {
6181   GtkLabel *label;
6182   GtkWidget *widget;
6183   GtkAllocation allocation;
6184   GtkRequisition req;
6185   GdkScreen *screen;
6186
6187   label = GTK_LABEL (user_data);
6188   widget = GTK_WIDGET (label);
6189
6190   g_return_if_fail (gtk_widget_get_realized (widget));
6191
6192   screen = gtk_widget_get_screen (widget);
6193   gdk_window_get_origin (gtk_widget_get_window (widget), x, y);
6194
6195   gtk_widget_get_allocation (widget, &allocation);
6196
6197   *x += allocation.x;
6198   *y += allocation.y;
6199
6200   gtk_widget_get_preferred_size (GTK_WIDGET (menu),
6201                                  &req, NULL);
6202
6203   gtk_widget_get_allocation (widget, &allocation);
6204
6205   *x += allocation.width / 2;
6206   *y += allocation.height;
6207
6208   *x = CLAMP (*x, 0, MAX (0, gdk_screen_get_width (screen) - req.width));
6209   *y = CLAMP (*y, 0, MAX (0, gdk_screen_get_height (screen) - req.height));
6210 }
6211
6212 static void
6213 open_link_activate_cb (GtkMenuItem *menu_item,
6214                        GtkLabel    *label)
6215 {
6216   GtkLabelLink *link;
6217
6218   link = gtk_label_get_current_link (label);
6219
6220   if (link)
6221     emit_activate_link (label, link);
6222 }
6223
6224 static void
6225 copy_link_activate_cb (GtkMenuItem *menu_item,
6226                        GtkLabel    *label)
6227 {
6228   GtkClipboard *clipboard;
6229   const gchar *uri;
6230
6231   uri = gtk_label_get_current_uri (label);
6232   if (uri)
6233     {
6234       clipboard = gtk_widget_get_clipboard (GTK_WIDGET (label), GDK_SELECTION_CLIPBOARD);
6235       gtk_clipboard_set_text (clipboard, uri, -1);
6236     }
6237 }
6238
6239 static gboolean
6240 gtk_label_popup_menu (GtkWidget *widget)
6241 {
6242   gtk_label_do_popup (GTK_LABEL (widget), NULL);
6243
6244   return TRUE;
6245 }
6246
6247 static void
6248 gtk_label_do_popup (GtkLabel       *label,
6249                     GdkEventButton *event)
6250 {
6251   GtkLabelPrivate *priv = label->priv;
6252   GtkWidget *menuitem;
6253   GtkWidget *menu;
6254   GtkWidget *image;
6255   gboolean have_selection;
6256   GtkLabelLink *link;
6257
6258   if (!priv->select_info)
6259     return;
6260
6261   if (priv->select_info->popup_menu)
6262     gtk_widget_destroy (priv->select_info->popup_menu);
6263
6264   priv->select_info->popup_menu = menu = gtk_menu_new ();
6265
6266   gtk_menu_attach_to_widget (GTK_MENU (menu), GTK_WIDGET (label), popup_menu_detach);
6267
6268   have_selection =
6269     priv->select_info->selection_anchor != priv->select_info->selection_end;
6270
6271   if (event)
6272     {
6273       if (priv->select_info->link_clicked)
6274         link = priv->select_info->active_link;
6275       else
6276         link = NULL;
6277     }
6278   else
6279     link = gtk_label_get_focus_link (label);
6280
6281   if (!have_selection && link)
6282     {
6283       /* Open Link */
6284       menuitem = gtk_image_menu_item_new_with_mnemonic (_("_Open Link"));
6285       gtk_widget_show (menuitem);
6286       gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
6287
6288       g_signal_connect (G_OBJECT (menuitem), "activate",
6289                         G_CALLBACK (open_link_activate_cb), label);
6290
6291       image = gtk_image_new_from_stock (GTK_STOCK_JUMP_TO, GTK_ICON_SIZE_MENU);
6292       gtk_widget_show (image);
6293       gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
6294
6295       /* Copy Link Address */
6296       menuitem = gtk_image_menu_item_new_with_mnemonic (_("Copy _Link Address"));
6297       gtk_widget_show (menuitem);
6298       gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
6299
6300       g_signal_connect (G_OBJECT (menuitem), "activate",
6301                         G_CALLBACK (copy_link_activate_cb), label);
6302
6303       image = gtk_image_new_from_stock (GTK_STOCK_COPY, GTK_ICON_SIZE_MENU);
6304       gtk_widget_show (image);
6305       gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
6306     }
6307   else
6308     {
6309       append_action_signal (label, menu, GTK_STOCK_CUT, "cut-clipboard", FALSE);
6310       append_action_signal (label, menu, GTK_STOCK_COPY, "copy-clipboard", have_selection);
6311       append_action_signal (label, menu, GTK_STOCK_PASTE, "paste-clipboard", FALSE);
6312
6313       menuitem = gtk_image_menu_item_new_from_stock (GTK_STOCK_DELETE, NULL);
6314       gtk_widget_set_sensitive (menuitem, FALSE);
6315       gtk_widget_show (menuitem);
6316       gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
6317
6318       menuitem = gtk_separator_menu_item_new ();
6319       gtk_widget_show (menuitem);
6320       gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
6321
6322       menuitem = gtk_image_menu_item_new_from_stock (GTK_STOCK_SELECT_ALL, NULL);
6323       g_signal_connect_swapped (menuitem, "activate",
6324                                 G_CALLBACK (gtk_label_select_all), label);
6325       gtk_widget_show (menuitem);
6326       gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
6327     }
6328
6329   g_signal_emit (label, signals[POPULATE_POPUP], 0, menu);
6330
6331   if (event)
6332     gtk_menu_popup (GTK_MENU (menu), NULL, NULL,
6333                     NULL, NULL,
6334                     event->button, event->time);
6335   else
6336     {
6337       gtk_menu_popup (GTK_MENU (menu), NULL, NULL,
6338                       popup_position_func, label,
6339                       0, gtk_get_current_event_time ());
6340       gtk_menu_shell_select_first (GTK_MENU_SHELL (menu), FALSE);
6341     }
6342 }
6343
6344 static void
6345 gtk_label_clear_links (GtkLabel *label)
6346 {
6347   GtkLabelPrivate *priv = label->priv;
6348
6349   if (!priv->select_info)
6350     return;
6351
6352   g_list_foreach (priv->select_info->links, (GFunc)link_free, NULL);
6353   g_list_free (priv->select_info->links);
6354   priv->select_info->links = NULL;
6355   priv->select_info->active_link = NULL;
6356 }
6357
6358 static void
6359 gtk_label_rescan_links (GtkLabel *label)
6360 {
6361   GtkLabelPrivate *priv = label->priv;
6362   PangoLayout *layout = priv->layout;
6363   PangoAttrList *attlist;
6364   PangoAttrIterator *iter;
6365   GList *links;
6366
6367   if (!priv->select_info || !priv->select_info->links)
6368     return;
6369
6370   attlist = pango_layout_get_attributes (layout);
6371
6372   if (attlist == NULL)
6373     return;
6374
6375   iter = pango_attr_list_get_iterator (attlist);
6376
6377   links = priv->select_info->links;
6378
6379   do
6380     {
6381       PangoAttribute *underline;
6382       PangoAttribute *color;
6383
6384       underline = pango_attr_iterator_get (iter, PANGO_ATTR_UNDERLINE);
6385       color = pango_attr_iterator_get (iter, PANGO_ATTR_FOREGROUND);
6386
6387       if (underline != NULL && color != NULL)
6388         {
6389           gint start, end;
6390           PangoRectangle start_pos;
6391           PangoRectangle end_pos;
6392           GtkLabelLink *link;
6393
6394           pango_attr_iterator_range (iter, &start, &end);
6395           pango_layout_index_to_pos (layout, start, &start_pos);
6396           pango_layout_index_to_pos (layout, end, &end_pos);
6397
6398           if (links == NULL)
6399             {
6400               g_warning ("Ran out of links");
6401               break;
6402             }
6403           link = links->data;
6404           links = links->next;
6405           link->start = start;
6406           link->end = end;
6407         }
6408       } while (pango_attr_iterator_next (iter));
6409
6410     pango_attr_iterator_destroy (iter);
6411 }
6412
6413 static gboolean
6414 gtk_label_activate_link (GtkLabel    *label,
6415                          const gchar *uri)
6416 {
6417   GtkWidget *widget = GTK_WIDGET (label);
6418   GError *error = NULL;
6419
6420   if (!gtk_show_uri (gtk_widget_get_screen (widget),
6421                      uri, gtk_get_current_event_time (), &error))
6422     {
6423       g_warning ("Unable to show '%s': %s", uri, error->message);
6424       g_error_free (error);
6425     }
6426
6427   return TRUE;
6428 }
6429
6430 static void
6431 emit_activate_link (GtkLabel     *label,
6432                     GtkLabelLink *link)
6433 {
6434   GtkLabelPrivate *priv = label->priv;
6435   gboolean handled;
6436
6437   g_signal_emit (label, signals[ACTIVATE_LINK], 0, link->uri, &handled);
6438   if (handled && priv->track_links && !link->visited)
6439     {
6440       link->visited = TRUE;
6441       /* FIXME: shouldn't have to redo everything here */
6442       gtk_label_recalculate (label);
6443     }
6444 }
6445
6446 static void
6447 gtk_label_activate_current_link (GtkLabel *label)
6448 {
6449   GtkLabelLink *link;
6450   GtkWidget *widget = GTK_WIDGET (label);
6451
6452   link = gtk_label_get_focus_link (label);
6453
6454   if (link)
6455     {
6456       emit_activate_link (label, link);
6457     }
6458   else
6459     {
6460       GtkWidget *toplevel;
6461       GtkWindow *window;
6462       GtkWidget *default_widget, *focus_widget;
6463
6464       toplevel = gtk_widget_get_toplevel (widget);
6465       if (GTK_IS_WINDOW (toplevel))
6466         {
6467           window = GTK_WINDOW (toplevel);
6468
6469           if (window)
6470             {
6471               default_widget = gtk_window_get_default_widget (window);
6472               focus_widget = gtk_window_get_focus (window);
6473
6474               if (default_widget != widget &&
6475                   !(widget == focus_widget && (!default_widget || !gtk_widget_is_sensitive (default_widget))))
6476                 gtk_window_activate_default (window);
6477             }
6478         }
6479     }
6480 }
6481
6482 static GtkLabelLink *
6483 gtk_label_get_current_link (GtkLabel *label)
6484 {
6485   GtkLabelPrivate *priv = label->priv;
6486   GtkLabelLink *link;
6487
6488   if (!priv->select_info)
6489     return NULL;
6490
6491   if (priv->select_info->link_clicked)
6492     link = priv->select_info->active_link;
6493   else
6494     link = gtk_label_get_focus_link (label);
6495
6496   return link;
6497 }
6498
6499 /**
6500  * gtk_label_get_current_uri:
6501  * @label: a #GtkLabel
6502  *
6503  * Returns the URI for the currently active link in the label.
6504  * The active link is the one under the mouse pointer or, in a
6505  * selectable label, the link in which the text cursor is currently
6506  * positioned.
6507  *
6508  * This function is intended for use in a #GtkLabel::activate-link handler
6509  * or for use in a #GtkWidget::query-tooltip handler.
6510  *
6511  * Returns: the currently active URI. The string is owned by GTK+ and must
6512  *   not be freed or modified.
6513  *
6514  * Since: 2.18
6515  */
6516 G_CONST_RETURN gchar *
6517 gtk_label_get_current_uri (GtkLabel *label)
6518 {
6519   GtkLabelLink *link;
6520
6521   g_return_val_if_fail (GTK_IS_LABEL (label), NULL);
6522
6523   link = gtk_label_get_current_link (label);
6524
6525   if (link)
6526     return link->uri;
6527
6528   return NULL;
6529 }
6530
6531 /**
6532  * gtk_label_set_track_visited_links:
6533  * @label: a #GtkLabel
6534  * @track_links: %TRUE to track visited links
6535  *
6536  * Sets whether the label should keep track of clicked
6537  * links (and use a different color for them).
6538  *
6539  * Since: 2.18
6540  */
6541 void
6542 gtk_label_set_track_visited_links (GtkLabel *label,
6543                                    gboolean  track_links)
6544 {
6545   GtkLabelPrivate *priv;
6546
6547   g_return_if_fail (GTK_IS_LABEL (label));
6548
6549   priv = label->priv;
6550
6551   track_links = track_links != FALSE;
6552
6553   if (priv->track_links != track_links)
6554     {
6555       priv->track_links = track_links;
6556
6557       /* FIXME: shouldn't have to redo everything here */
6558       gtk_label_recalculate (label);
6559
6560       g_object_notify (G_OBJECT (label), "track-visited-links");
6561     }
6562 }
6563
6564 /**
6565  * gtk_label_get_track_visited_links:
6566  * @label: a #GtkLabel
6567  *
6568  * Returns whether the label is currently keeping track
6569  * of clicked links.
6570  *
6571  * Returns: %TRUE if clicked links are remembered
6572  *
6573  * Since: 2.18
6574  */
6575 gboolean
6576 gtk_label_get_track_visited_links (GtkLabel *label)
6577 {
6578   g_return_val_if_fail (GTK_IS_LABEL (label), FALSE);
6579
6580   return label->priv->track_links;
6581 }
6582
6583 static gboolean
6584 gtk_label_query_tooltip (GtkWidget  *widget,
6585                          gint        x,
6586                          gint        y,
6587                          gboolean    keyboard_tip,
6588                          GtkTooltip *tooltip)
6589 {
6590   GtkLabel *label = GTK_LABEL (widget);
6591   GtkLabelPrivate *priv = label->priv;
6592   GtkLabelSelectionInfo *info = priv->select_info;
6593   gint index = -1;
6594   GList *l;
6595
6596   if (info && info->links)
6597     {
6598       if (keyboard_tip)
6599         {
6600           if (info->selection_anchor == info->selection_end)
6601             index = info->selection_anchor;
6602         }
6603       else
6604         {
6605           if (!get_layout_index (label, x, y, &index))
6606             index = -1;
6607         }
6608
6609       if (index != -1)
6610         {
6611           for (l = info->links; l != NULL; l = l->next)
6612             {
6613               GtkLabelLink *link = l->data;
6614               if (index >= link->start && index <= link->end)
6615                 {
6616                   if (link->title)
6617                     {
6618                       gtk_tooltip_set_markup (tooltip, link->title);
6619                       return TRUE;
6620                     }
6621                   break;
6622                 }
6623             }
6624         }
6625     }
6626
6627   return GTK_WIDGET_CLASS (gtk_label_parent_class)->query_tooltip (widget,
6628                                                                    x, y,
6629                                                                    keyboard_tip,
6630                                                                    tooltip);
6631 }