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

   1 /* GTK - The GIMP Toolkit
   2  * gtklinkbutton.c - an hyperlink-enabled button
   3  *
   4  * Copyright (C) 2006 Emmanuele Bassi <ebassi@gmail.com>
   5  * All rights reserved.
   6  *
   7  * Based on gnome-href code by:
   8  *      James Henstridge <james@daa.com.au>
   9  *
  10  * This library is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU Library General Public
  12  * License as published by the Free Software Foundation; either
  13  * version 2 of the License, or (at your option) any later version.
  14  *
  15  * This library is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18  * Library General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Library General Public
  21  * License along with this library; if not, write to the Free Software
  22  * Foundation, Inc., 59 Temple Place - Suite 330, Cambridge, MA 02139, USA.
  23  */
  24
  25 /**
  26  * SECTION:gtklinkbutton
  27  * @Title: GtkLinkButton
  28  * @Short_description: Create buttons bound to a URL
  29  * @See_also: #GtkButton
  30  *
  31  * A GtkLinkButton is a #GtkButton with a hyperlink, similar to the one
  32  * used by web browsers, which triggers an action when clicked. It is useful
  33  * to show quick links to resources.
  34  *
  35  * A link button is created by calling either gtk_link_button_new() or
  36  * gtk_link_button_new_with_label(). If using the former, the URI you pass
  37  * to the constructor is used as a label for the widget.
  38  *
  39  * The URI bound to a GtkLinkButton can be set specifically using
  40  * gtk_link_button_set_uri(), and retrieved using gtk_link_button_get_uri().
  41  *
  42  * By default, GtkLinkButton calls gtk_show_uri() when the button is
  43  * clicked. This behaviour can be overridden by connecting to the
  44  * #GtkLinkButton::activate-link signal and returning %TRUE from the
  45  * signal handler.
  46  */
  47
  48 #include "config.h"
  49
  50 #include "gtklinkbutton.h"
  51
  52 #include <string.h>
  53
  54 #include "gtkclipboard.h"
  55 #include "gtkdnd.h"
  56 #include "gtkimagemenuitem.h"
  57 #include "gtklabel.h"
  58 #include "gtkmain.h"
  59 #include "gtkmarshalers.h"
  60 #include "gtkmenu.h"
  61 #include "gtkmenuitem.h"
  62 #include "gtksizerequest.h"
  63 #include "gtkstock.h"
  64 #include "gtkshow.h"
  65 #include "gtktooltip.h"
  66 #include "gtkprivate.h"
  67 #include "gtkintl.h"
  68
  69 #include "a11y/gtklinkbuttonaccessible.h"
  70
  71 struct _GtkLinkButtonPrivate
  72 {
  73   gchar *uri;
  74
  75   gboolean visited;
  76
  77   GtkWidget *popup_menu;
  78 };
  79
  80 enum
  81 {
  82   PROP_0,
  83   PROP_URI,
  84   PROP_VISITED
  85 };
  86
  87 enum
  88 {
  89   ACTIVATE_LINK,
  90
  91   LAST_SIGNAL
  92 };
  93
  94 static void     gtk_link_button_finalize     (GObject          *object);
  95 static void     gtk_link_button_get_property (GObject          *object,
  96                                               guint             prop_id,
  97                                               GValue           *value,
  98                                               GParamSpec       *pspec);
  99 static void     gtk_link_button_set_property (GObject          *object,
 100                                               guint             prop_id,
 101                                               const GValue     *value,
 102                                               GParamSpec       *pspec);
 103 static void     gtk_link_button_add          (GtkContainer     *container,
 104                                               GtkWidget        *widget);
 105 static gboolean gtk_link_button_button_press (GtkWidget        *widget,
 106                                               GdkEventButton   *event);
 107 static void     gtk_link_button_clicked      (GtkButton        *button);
 108 static gboolean gtk_link_button_popup_menu   (GtkWidget        *widget);
 109 static void     gtk_link_button_style_updated (GtkWidget        *widget);
 110 static void     gtk_link_button_unrealize    (GtkWidget        *widget);
 111 static gboolean gtk_link_button_enter_cb     (GtkWidget        *widget,
 112                                               GdkEventCrossing *event,
 113                                               gpointer          user_data);
 114 static gboolean gtk_link_button_leave_cb     (GtkWidget        *widget,
 115                                               GdkEventCrossing *event,
 116                                               gpointer          user_data);
 117 static void gtk_link_button_drag_data_get_cb (GtkWidget        *widget,
 118                                               GdkDragContext   *context,
 119                                               GtkSelectionData *selection,
 120                                               guint             _info,
 121                                               guint             _time,
 122                                               gpointer          user_data);
 123 static gboolean gtk_link_button_query_tooltip_cb (GtkWidget    *widget,
 124                                                   gint          x,
 125                                                   gint          y,
 126                                                   gboolean      keyboard_tip,
 127                                                   GtkTooltip   *tooltip,
 128                                                   gpointer      data);
 129 static gboolean gtk_link_button_activate_link (GtkLinkButton *link_button);
 130
 131 static const GtkTargetEntry link_drop_types[] = {
 132   { "text/uri-list", 0, 0 },
 133   { "_NETSCAPE_URL", 0, 0 }
 134 };
 135
 136 static const GdkColor default_link_color = { 0, 0, 0, 0xeeee };
 137 static const GdkColor default_visited_link_color = { 0, 0x5555, 0x1a1a, 0x8b8b };
 138
 139 static guint link_signals[LAST_SIGNAL] = { 0, };
 140
 141 G_DEFINE_TYPE (GtkLinkButton, gtk_link_button, GTK_TYPE_BUTTON)
 142
 143 static void
 144 gtk_link_button_class_init (GtkLinkButtonClass *klass)
 145 {
 146   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
 147   GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
 148   GtkContainerClass *container_class = GTK_CONTAINER_CLASS (klass);
 149   GtkButtonClass *button_class = GTK_BUTTON_CLASS (klass);
 150
 151   gobject_class->set_property = gtk_link_button_set_property;
 152   gobject_class->get_property = gtk_link_button_get_property;
 153   gobject_class->finalize = gtk_link_button_finalize;
 154
 155   widget_class->button_press_event = gtk_link_button_button_press;
 156   widget_class->popup_menu = gtk_link_button_popup_menu;
 157   widget_class->style_updated = gtk_link_button_style_updated;
 158   widget_class->unrealize = gtk_link_button_unrealize;
 159
 160   container_class->add = gtk_link_button_add;
 161
 162   button_class->clicked = gtk_link_button_clicked;
 163
 164   klass->activate_link = gtk_link_button_activate_link;
 165
 166   /**
 167    * GtkLinkButton:uri
 168    *
 169    * The URI bound to this button.
 170    *
 171    * Since: 2.10
 172    */
 173   g_object_class_install_property (gobject_class,
 174                                    PROP_URI,
 175                                    g_param_spec_string ("uri",
 176                                                         P_("URI"),
 177                                                         P_("The URI bound to this button"),
 178                                                         NULL,
 179                                                         G_PARAM_READWRITE));
 180   /**
 181    * GtkLinkButton:visited
 182    *
 183    * The 'visited' state of this button. A visited link is drawn in a
 184    * different color.
 185    *
 186    * Since: 2.14
 187    */
 188   g_object_class_install_property (gobject_class,
 189                                    PROP_VISITED,
 190                                    g_param_spec_boolean ("visited",
 191                                                          P_("Visited"),
 192                                                          P_("Whether this link has been visited."),
 193                                                          FALSE,
 194                                                          G_PARAM_READWRITE));
 195
 196   g_type_class_add_private (gobject_class, sizeof (GtkLinkButtonPrivate));
 197
 198   /**
 199    * GtkLinkButton::activate-link:
 200    * @button: the #GtkLinkButton that emitted the signal
 201    *
 202    * The ::activate-link signal is emitted each time the #GtkLinkButton
 203    * has been clicked.
 204    *
 205    * The default handler will call gtk_show_uri() with the URI stored inside
 206    * the #GtkLinkButton:uri property.
 207    *
 208    * To override the default behavior, you can connect to the ::activate-link
 209    * signal and stop the propagation of the signal by returning %TRUE from
 210    * your handler.
 211    */
 212   link_signals[ACTIVATE_LINK] =
 213     g_signal_new (I_("activate-link"),
 214                   G_TYPE_FROM_CLASS (klass),
 215                   G_SIGNAL_RUN_LAST,
 216                   G_STRUCT_OFFSET (GtkLinkButtonClass, activate_link),
 217                   _gtk_boolean_handled_accumulator, NULL,
 218                   _gtk_marshal_BOOLEAN__VOID,
 219                   G_TYPE_BOOLEAN, 0);
 220
 221   gtk_widget_class_set_accessible_type (widget_class, GTK_TYPE_LINK_BUTTON_ACCESSIBLE);
 222 }
 223
 224 static void
 225 gtk_link_button_init (GtkLinkButton *link_button)
 226 {
 227   link_button->priv = G_TYPE_INSTANCE_GET_PRIVATE (link_button,
 228                                                    GTK_TYPE_LINK_BUTTON,
 229                                                    GtkLinkButtonPrivate);
 230
 231   gtk_button_set_relief (GTK_BUTTON (link_button), GTK_RELIEF_NONE);
 232
 233   g_signal_connect (link_button, "enter-notify-event",
 234                     G_CALLBACK (gtk_link_button_enter_cb), NULL);
 235   g_signal_connect (link_button, "leave-notify-event",
 236                     G_CALLBACK (gtk_link_button_leave_cb), NULL);
 237   g_signal_connect (link_button, "drag-data-get",
 238                     G_CALLBACK (gtk_link_button_drag_data_get_cb), NULL);
 239
 240   g_object_set (link_button, "has-tooltip", TRUE, NULL);
 241   g_signal_connect (link_button, "query-tooltip",
 242                     G_CALLBACK (gtk_link_button_query_tooltip_cb), NULL);
 243
 244   /* enable drag source */
 245   gtk_drag_source_set (GTK_WIDGET (link_button),
 246                        GDK_BUTTON1_MASK,
 247                        link_drop_types, G_N_ELEMENTS (link_drop_types),
 248                        GDK_ACTION_COPY);
 249 }
 250
 251 static void
 252 gtk_link_button_finalize (GObject *object)
 253 {
 254   GtkLinkButton *link_button = GTK_LINK_BUTTON (object);
 255
 256   g_free (link_button->priv->uri);
 257
 258   G_OBJECT_CLASS (gtk_link_button_parent_class)->finalize (object);
 259 }
 260
 261 static void
 262 gtk_link_button_get_property (GObject    *object,
 263                               guint       prop_id,
 264                               GValue     *value,
 265                               GParamSpec *pspec)
 266 {
 267   GtkLinkButton *link_button = GTK_LINK_BUTTON (object);
 268
 269   switch (prop_id)
 270     {
 271     case PROP_URI:
 272       g_value_set_string (value, link_button->priv->uri);
 273       break;
 274     case PROP_VISITED:
 275       g_value_set_boolean (value, link_button->priv->visited);
 276       break;
 277     default:
 278       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 279       break;
 280     }
 281 }
 282
 283 static void
 284 gtk_link_button_set_property (GObject      *object,
 285                               guint         prop_id,
 286                               const GValue *value,
 287                               GParamSpec   *pspec)
 288 {
 289   GtkLinkButton *link_button = GTK_LINK_BUTTON (object);
 290
 291   switch (prop_id)
 292     {
 293     case PROP_URI:
 294       gtk_link_button_set_uri (link_button, g_value_get_string (value));
 295       break;
 296     case PROP_VISITED:
 297       gtk_link_button_set_visited (link_button, g_value_get_boolean (value));
 298       break;
 299     default:
 300       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 301       break;
 302     }
 303 }
 304
 305 static void
 306 set_link_color (GtkLinkButton *link_button)
 307 {
 308   GdkColor *link_color = NULL;
 309   GtkWidget *label;
 310   GdkRGBA rgba;
 311
 312   label = gtk_bin_get_child (GTK_BIN (link_button));
 313   if (!GTK_IS_LABEL (label))
 314     return;
 315
 316   if (link_button->priv->visited)
 317     {
 318       gtk_widget_style_get (GTK_WIDGET (link_button),
 319                             "visited-link-color", &link_color, NULL);
 320       if (!link_color)
 321         link_color = (GdkColor *) &default_visited_link_color;
 322     }
 323   else
 324     {
 325       gtk_widget_style_get (GTK_WIDGET (link_button),
 326                             "link-color", &link_color, NULL);
 327       if (!link_color)
 328         link_color = (GdkColor *) &default_link_color;
 329     }
 330
 331   rgba.red = link_color->red / 65535.;
 332   rgba.green = link_color->green / 65535.;
 333   rgba.blue = link_color->blue / 65535.;
 334   rgba.alpha = 1;
 335   gtk_widget_override_color (label, GTK_STATE_FLAG_NORMAL, &rgba);
 336   gtk_widget_override_color (label, GTK_STATE_FLAG_ACTIVE, &rgba);
 337   gtk_widget_override_color (label, GTK_STATE_FLAG_PRELIGHT, &rgba);
 338   gtk_widget_override_color (label, GTK_STATE_FLAG_SELECTED, &rgba);
 339
 340   if (link_color != &default_link_color &&
 341       link_color != &default_visited_link_color)
 342     gdk_color_free (link_color);
 343 }
 344
 345 static void
 346 set_link_underline (GtkLinkButton *link_button)
 347 {
 348   GtkWidget *label;
 349
 350   label = gtk_bin_get_child (GTK_BIN (link_button));
 351   if (GTK_IS_LABEL (label))
 352     {
 353       PangoAttrList *attributes;
 354       PangoAttribute *uline;
 355
 356       uline = pango_attr_underline_new (PANGO_UNDERLINE_SINGLE);
 357       uline->start_index = 0;
 358       uline->end_index = G_MAXUINT;
 359       attributes = pango_attr_list_new ();
 360       pango_attr_list_insert (attributes, uline);
 361       gtk_label_set_attributes (GTK_LABEL (label), attributes);
 362       pango_attr_list_unref (attributes);
 363     }
 364 }
 365
 366 static void
 367 gtk_link_button_add (GtkContainer *container,
 368                      GtkWidget    *widget)
 369 {
 370   GTK_CONTAINER_CLASS (gtk_link_button_parent_class)->add (container, widget);
 371
 372   set_link_color (GTK_LINK_BUTTON (container));
 373   set_link_underline (GTK_LINK_BUTTON (container));
 374 }
 375
 376 static void
 377 gtk_link_button_style_updated (GtkWidget *widget)
 378 {
 379   GTK_WIDGET_CLASS (gtk_link_button_parent_class)->style_updated (widget);
 380
 381   set_link_color (GTK_LINK_BUTTON (widget));
 382 }
 383
 384 static void
 385 set_hand_cursor (GtkWidget *widget,
 386                  gboolean   show_hand)
 387 {
 388   GdkDisplay *display;
 389   GdkCursor *cursor;
 390
 391   display = gtk_widget_get_display (widget);
 392
 393   cursor = NULL;
 394   if (show_hand)
 395     cursor = gdk_cursor_new_for_display (display, GDK_HAND2);
 396
 397   gdk_window_set_cursor (gtk_widget_get_window (widget), cursor);
 398   gdk_display_flush (display);
 399
 400   if (cursor)
 401     g_object_unref (cursor);
 402 }
 403
 404 static void
 405 gtk_link_button_unrealize (GtkWidget *widget)
 406 {
 407   set_hand_cursor (widget, FALSE);
 408
 409   GTK_WIDGET_CLASS (gtk_link_button_parent_class)->unrealize (widget);
 410 }
 411
 412 static void
 413 popup_menu_detach (GtkWidget *attach_widget,
 414                    GtkMenu   *menu)
 415 {
 416   GtkLinkButton *link_button = GTK_LINK_BUTTON (attach_widget);
 417
 418   link_button->priv->popup_menu = NULL;
 419 }
 420
 421 static void
 422 popup_position_func (GtkMenu  *menu,
 423                      gint     *x,
 424                      gint     *y,
 425                      gboolean *push_in,
 426                      gpointer  user_data)
 427 {
 428   GtkLinkButton *link_button = GTK_LINK_BUTTON (user_data);
 429   GtkLinkButtonPrivate *priv = link_button->priv;
 430   GtkAllocation allocation;
 431   GtkWidget *widget = GTK_WIDGET (link_button);
 432   GdkScreen *screen = gtk_widget_get_screen (widget);
 433   GtkRequisition req;
 434   gint monitor_num;
 435   GdkRectangle monitor;
 436
 437   g_return_if_fail (gtk_widget_get_realized (widget));
 438
 439   gdk_window_get_origin (gtk_widget_get_window (widget), x, y);
 440
 441   gtk_widget_get_preferred_size (priv->popup_menu, &req, NULL);
 442
 443   gtk_widget_get_allocation (widget, &allocation);
 444   *x += allocation.width / 2;
 445   *y += allocation.height;
 446
 447   monitor_num = gdk_screen_get_monitor_at_point (screen, *x, *y);
 448   gtk_menu_set_monitor (menu, monitor_num);
 449   gdk_screen_get_monitor_workarea (screen, monitor_num, &monitor);
 450
 451   *x = CLAMP (*x, monitor.x, monitor.x + MAX (0, monitor.width - req.width));
 452   *y = CLAMP (*y, monitor.y, monitor.y + MAX (0, monitor.height - req.height));
 453
 454   *push_in = FALSE;
 455 }
 456
 457 static void
 458 copy_activate_cb (GtkWidget     *widget,
 459                   GtkLinkButton *link_button)
 460 {
 461   GtkLinkButtonPrivate *priv = link_button->priv;
 462
 463   gtk_clipboard_set_text (gtk_widget_get_clipboard (GTK_WIDGET (link_button),
 464                                                     GDK_SELECTION_CLIPBOARD),
 465                           priv->uri, -1);
 466 }
 467
 468 static void
 469 gtk_link_button_do_popup (GtkLinkButton  *link_button,
 470                           GdkEventButton *event)
 471 {
 472   GtkLinkButtonPrivate *priv = link_button->priv;
 473   gint button;
 474   guint time;
 475
 476   if (event)
 477     {
 478       button = event->button;
 479       time = event->time;
 480     }
 481   else
 482     {
 483       button = 0;
 484       time = gtk_get_current_event_time ();
 485     }
 486
 487   if (gtk_widget_get_realized (GTK_WIDGET (link_button)))
 488     {
 489       GtkWidget *menu_item;
 490
 491       if (priv->popup_menu)
 492         gtk_widget_destroy (priv->popup_menu);
 493
 494       priv->popup_menu = gtk_menu_new ();
 495
 496       gtk_menu_attach_to_widget (GTK_MENU (priv->popup_menu),
 497                                  GTK_WIDGET (link_button),
 498                                  popup_menu_detach);
 499
 500       menu_item = gtk_image_menu_item_new_with_mnemonic (_("Copy URL"));
 501       gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menu_item),
 502                                      gtk_image_new_from_stock (GTK_STOCK_COPY,
 503                                                                GTK_ICON_SIZE_MENU));
 504       g_signal_connect (menu_item, "activate",
 505                         G_CALLBACK (copy_activate_cb), link_button);
 506       gtk_widget_show (menu_item);
 507       gtk_menu_shell_append (GTK_MENU_SHELL (priv->popup_menu), menu_item);
 508
 509       if (button)
 510         gtk_menu_popup (GTK_MENU (priv->popup_menu), NULL, NULL,
 511                         NULL, NULL,
 512                         button, time);
 513       else
 514         {
 515           gtk_menu_popup (GTK_MENU (priv->popup_menu), NULL, NULL,
 516                           popup_position_func, link_button,
 517                           button, time);
 518           gtk_menu_shell_select_first (GTK_MENU_SHELL (priv->popup_menu), FALSE);
 519         }
 520     }
 521 }
 522
 523 static gboolean
 524 gtk_link_button_button_press (GtkWidget      *widget,
 525                               GdkEventButton *event)
 526 {
 527   if (!gtk_widget_has_focus (widget))
 528     gtk_widget_grab_focus (widget);
 529
 530   if (gdk_event_triggers_context_menu ((GdkEvent *) event))
 531     {
 532       gtk_link_button_do_popup (GTK_LINK_BUTTON (widget), event);
 533
 534       return TRUE;
 535     }
 536
 537   if (GTK_WIDGET_CLASS (gtk_link_button_parent_class)->button_press_event)
 538     return GTK_WIDGET_CLASS (gtk_link_button_parent_class)->button_press_event (widget, event);
 539
 540   return FALSE;
 541 }
 542
 543 static gboolean
 544 gtk_link_button_activate_link (GtkLinkButton *link_button)
 545 {
 546   GdkScreen *screen;
 547   GError *error;
 548
 549   if (gtk_widget_has_screen (GTK_WIDGET (link_button)))
 550     screen = gtk_widget_get_screen (GTK_WIDGET (link_button));
 551   else
 552     screen = NULL;
 553
 554   error = NULL;
 555   gtk_show_uri (screen, link_button->priv->uri, GDK_CURRENT_TIME, &error);
 556   if (error)
 557     {
 558       g_warning ("Unable to show '%s': %s",
 559                  link_button->priv->uri,
 560                  error->message);
 561       g_error_free (error);
 562
 563       return FALSE;
 564     }
 565
 566   gtk_link_button_set_visited (link_button, TRUE);
 567
 568   return TRUE;
 569 }
 570
 571 static void
 572 gtk_link_button_clicked (GtkButton *button)
 573 {
 574   gboolean retval = FALSE;
 575
 576   g_signal_emit (button, link_signals[ACTIVATE_LINK], 0, &retval);
 577 }
 578
 579 static gboolean
 580 gtk_link_button_popup_menu (GtkWidget *widget)
 581 {
 582   gtk_link_button_do_popup (GTK_LINK_BUTTON (widget), NULL);
 583
 584   return TRUE;
 585 }
 586
 587 static gboolean
 588 gtk_link_button_enter_cb (GtkWidget        *widget,
 589                           GdkEventCrossing *crossing,
 590                           gpointer          user_data)
 591 {
 592   set_hand_cursor (widget, TRUE);
 593
 594   return FALSE;
 595 }
 596
 597 static gboolean
 598 gtk_link_button_leave_cb (GtkWidget        *widget,
 599                           GdkEventCrossing *crossing,
 600                           gpointer          user_data)
 601 {
 602   set_hand_cursor (widget, FALSE);
 603
 604   return FALSE;
 605 }
 606
 607 static void
 608 gtk_link_button_drag_data_get_cb (GtkWidget        *widget,
 609                                   GdkDragContext   *context,
 610                                   GtkSelectionData *selection,
 611                                   guint             _info,
 612                                   guint             _time,
 613                                   gpointer          user_data)
 614 {
 615   GtkLinkButton *link_button = GTK_LINK_BUTTON (widget);
 616   gchar *uri;
 617
 618   uri = g_strdup_printf ("%s\r\n", link_button->priv->uri);
 619   gtk_selection_data_set (selection,
 620                           gtk_selection_data_get_target (selection),
 621                           8,
 622                           (guchar *) uri,
 623                           strlen (uri));
 624
 625   g_free (uri);
 626 }
 627
 628 /**
 629  * gtk_link_button_new:
 630  * @uri: a valid URI
 631  *
 632  * Creates a new #GtkLinkButton with the URI as its text.
 633  *
 634  * Return value: a new link button widget.
 635  *
 636  * Since: 2.10
 637  */
 638 GtkWidget *
 639 gtk_link_button_new (const gchar *uri)
 640 {
 641   gchar *utf8_uri = NULL;
 642   GtkWidget *retval;
 643
 644   g_return_val_if_fail (uri != NULL, NULL);
 645
 646   if (g_utf8_validate (uri, -1, NULL))
 647     {
 648       utf8_uri = g_strdup (uri);
 649     }
 650   else
 651     {
 652       GError *conv_err = NULL;
 653
 654       utf8_uri = g_locale_to_utf8 (uri, -1, NULL, NULL, &conv_err);
 655       if (conv_err)
 656         {
 657           g_warning ("Attempting to convert URI `%s' to UTF-8, but failed "
 658                      "with error: %s\n",
 659                      uri,
 660                      conv_err->message);
 661           g_error_free (conv_err);
 662
 663           utf8_uri = g_strdup (_("Invalid URI"));
 664         }
 665     }
 666
 667   retval = g_object_new (GTK_TYPE_LINK_BUTTON,
 668                          "label", utf8_uri,
 669                          "uri", uri,
 670                          NULL);
 671
 672   g_free (utf8_uri);
 673
 674   return retval;
 675 }
 676
 677 /**
 678  * gtk_link_button_new_with_label:
 679  * @uri: a valid URI
 680  * @label: (allow-none): the text of the button
 681  *
 682  * Creates a new #GtkLinkButton containing a label.
 683  *
 684  * Return value: (transfer none): a new link button widget.
 685  *
 686  * Since: 2.10
 687  */
 688 GtkWidget *
 689 gtk_link_button_new_with_label (const gchar *uri,
 690                                 const gchar *label)
 691 {
 692   GtkWidget *retval;
 693
 694   g_return_val_if_fail (uri != NULL, NULL);
 695
 696   if (!label)
 697     return gtk_link_button_new (uri);
 698
 699   retval = g_object_new (GTK_TYPE_LINK_BUTTON,
 700                          "label", label,
 701                          "uri", uri,
 702                          NULL);
 703
 704   return retval;
 705 }
 706
 707 static gboolean
 708 gtk_link_button_query_tooltip_cb (GtkWidget    *widget,
 709                                   gint          x,
 710                                   gint          y,
 711                                   gboolean      keyboard_tip,
 712                                   GtkTooltip   *tooltip,
 713                                   gpointer      data)
 714 {
 715   GtkLinkButton *link_button = GTK_LINK_BUTTON (widget);
 716   const gchar *label, *uri;
 717
 718   label = gtk_button_get_label (GTK_BUTTON (link_button));
 719   uri = link_button->priv->uri;
 720
 721   if (!gtk_widget_get_tooltip_text (widget)
 722     && !gtk_widget_get_tooltip_markup (widget)
 723     && label && *label != '\0' && uri && strcmp (label, uri) != 0)
 724     {
 725       gtk_tooltip_set_text (tooltip, uri);
 726       return TRUE;
 727     }
 728
 729   return FALSE;
 730 }
 731
 732
 733 /**
 734  * gtk_link_button_set_uri:
 735  * @link_button: a #GtkLinkButton
 736  * @uri: a valid URI
 737  *
 738  * Sets @uri as the URI where the #GtkLinkButton points. As a side-effect
 739  * this unsets the 'visited' state of the button.
 740  *
 741  * Since: 2.10
 742  */
 743 void
 744 gtk_link_button_set_uri (GtkLinkButton *link_button,
 745                          const gchar   *uri)
 746 {
 747   GtkLinkButtonPrivate *priv;
 748
 749   g_return_if_fail (GTK_IS_LINK_BUTTON (link_button));
 750   g_return_if_fail (uri != NULL);
 751
 752   priv = link_button->priv;
 753
 754   g_free (priv->uri);
 755   priv->uri = g_strdup (uri);
 756
 757   g_object_notify (G_OBJECT (link_button), "uri");
 758
 759   gtk_link_button_set_visited (link_button, FALSE);
 760 }
 761
 762 /**
 763  * gtk_link_button_get_uri:
 764  * @link_button: a #GtkLinkButton
 765  *
 766  * Retrieves the URI set using gtk_link_button_set_uri().
 767  *
 768  * Return value: a valid URI.  The returned string is owned by the link button
 769  *   and should not be modified or freed.
 770  *
 771  * Since: 2.10
 772  */
 773 const gchar *
 774 gtk_link_button_get_uri (GtkLinkButton *link_button)
 775 {
 776   g_return_val_if_fail (GTK_IS_LINK_BUTTON (link_button), NULL);
 777
 778   return link_button->priv->uri;
 779 }
 780
 781 /**
 782  * gtk_link_button_set_visited:
 783  * @link_button: a #GtkLinkButton
 784  * @visited: the new 'visited' state
 785  *
 786  * Sets the 'visited' state of the URI where the #GtkLinkButton
 787  * points.  See gtk_link_button_get_visited() for more details.
 788  *
 789  * Since: 2.14
 790  */
 791 void
 792 gtk_link_button_set_visited (GtkLinkButton *link_button,
 793                              gboolean       visited)
 794 {
 795   g_return_if_fail (GTK_IS_LINK_BUTTON (link_button));
 796
 797   visited = visited != FALSE;
 798
 799   if (link_button->priv->visited != visited)
 800     {
 801       link_button->priv->visited = visited;
 802
 803       set_link_color (link_button);
 804
 805       g_object_notify (G_OBJECT (link_button), "visited");
 806     }
 807 }
 808
 809 /**
 810  * gtk_link_button_get_visited:
 811  * @link_button: a #GtkLinkButton
 812  *
 813  * Retrieves the 'visited' state of the URI where the #GtkLinkButton
 814  * points. The button becomes visited when it is clicked. If the URI
 815  * is changed on the button, the 'visited' state is unset again.
 816  *
 817  * The state may also be changed using gtk_link_button_set_visited().
 818  *
 819  * Return value: %TRUE if the link has been visited, %FALSE otherwise
 820  *
 821  * Since: 2.14
 822  */
 823 gboolean
 824 gtk_link_button_get_visited (GtkLinkButton *link_button)
 825 {
 826   g_return_val_if_fail (GTK_IS_LINK_BUTTON (link_button), FALSE);
 827
 828   return link_button->priv->visited;
 829 }