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