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