Pileus Git - ~andy/gtk/blob - gtk/gtktooltips.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
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19
  20 /*
  21  * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS
  22  * file for a list of people on the GTK+ Team.  See the ChangeLog
  23  * files for a list of changes.  These files are distributed with
  24  * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
  25  */
  26
  27 #include <stdlib.h>
  28 #include <string.h>
  29 #include <stdio.h>
  30
  31 #include "gtklabel.h"
  32 #include "gtkmain.h"
  33 #include "gtkmenuitem.h"
  34 #include "gtkprivate.h"
  35 #include "gtkwidget.h"
  36 #include "gtkwindow.h"
  37 #include "gtkstyle.h"
  38 #include "gtktooltips.h"
  39
  40
  41 #define DEFAULT_DELAY 500           /* Default delay in ms */
  42 #define STICKY_DELAY 0              /* Delay before popping up next tip
  43                                      * if we're sticky
  44                                      */
  45 #define STICKY_REVERT_DELAY 1000    /* Delay before sticky tooltips revert
  46                                      * to normal
  47                                      */
  48
  49 static void gtk_tooltips_class_init        (GtkTooltipsClass *klass);
  50 static void gtk_tooltips_init              (GtkTooltips      *tooltips);
  51 static void gtk_tooltips_destroy           (GtkObject        *object);
  52
  53 static void gtk_tooltips_event_handler     (GtkWidget   *widget,
  54                                             GdkEvent    *event);
  55 static void gtk_tooltips_widget_unmap      (GtkWidget   *widget,
  56                                             gpointer     data);
  57 static void gtk_tooltips_widget_remove     (GtkWidget   *widget,
  58                                             gpointer     data);
  59 static void gtk_tooltips_set_active_widget (GtkTooltips *tooltips,
  60                                             GtkWidget   *widget);
  61 static gint gtk_tooltips_timeout           (gpointer     data);
  62
  63 static gint gtk_tooltips_paint_window      (GtkTooltips *tooltips);
  64 static void gtk_tooltips_draw_tips         (GtkTooltips *tooltips);
  65 static void gtk_tooltips_unset_tip_window  (GtkTooltips *tooltips);
  66
  67 static gboolean get_keyboard_mode          (GtkWidget   *widget);
  68
  69 static GtkObjectClass *parent_class;
  70 static const gchar  *tooltips_data_key = "_GtkTooltipsData";
  71
  72 GType
  73 gtk_tooltips_get_type (void)
  74 {
  75   static GType tooltips_type = 0;
  76
  77   if (!tooltips_type)
  78     {
  79       static const GTypeInfo tooltips_info =
  80       {
  81         sizeof (GtkTooltipsClass),
  82         NULL,           /* base_init */
  83         NULL,           /* base_finalize */
  84         (GClassInitFunc) gtk_tooltips_class_init,
  85         NULL,           /* class_finalize */
  86         NULL,           /* class_data */
  87         sizeof (GtkTooltips),
  88         0,              /* n_preallocs */
  89         (GInstanceInitFunc) gtk_tooltips_init,
  90       };
  91
  92       tooltips_type = g_type_register_static (GTK_TYPE_OBJECT, "GtkTooltips",
  93                                               &tooltips_info, 0);
  94     }
  95
  96   return tooltips_type;
  97 }
  98
  99 static void
 100 gtk_tooltips_class_init (GtkTooltipsClass *class)
 101 {
 102   GtkObjectClass *object_class;
 103
 104   object_class = (GtkObjectClass*) class;
 105
 106   parent_class = g_type_class_peek_parent (class);
 107
 108   object_class->destroy = gtk_tooltips_destroy;
 109 }
 110
 111 static void
 112 gtk_tooltips_init (GtkTooltips *tooltips)
 113 {
 114   tooltips->tip_window = NULL;
 115   tooltips->active_tips_data = NULL;
 116   tooltips->tips_data_list = NULL;
 117
 118   tooltips->delay = DEFAULT_DELAY;
 119   tooltips->enabled = TRUE;
 120   tooltips->timer_tag = 0;
 121   tooltips->use_sticky_delay = FALSE;
 122   tooltips->last_popdown.tv_sec = -1;
 123   tooltips->last_popdown.tv_usec = -1;
 124 }
 125
 126 GtkTooltips *
 127 gtk_tooltips_new (void)
 128 {
 129   return g_object_new (GTK_TYPE_TOOLTIPS, NULL);
 130 }
 131
 132 static void
 133 gtk_tooltips_destroy_data (GtkTooltipsData *tooltipsdata)
 134 {
 135   g_free (tooltipsdata->tip_text);
 136   g_free (tooltipsdata->tip_private);
 137
 138   g_signal_handlers_disconnect_by_func (tooltipsdata->widget,
 139                                         gtk_tooltips_event_handler,
 140                                         tooltipsdata);
 141   g_signal_handlers_disconnect_by_func (tooltipsdata->widget,
 142                                         gtk_tooltips_widget_unmap,
 143                                         tooltipsdata);
 144   g_signal_handlers_disconnect_by_func (tooltipsdata->widget,
 145                                         gtk_tooltips_widget_remove,
 146                                         tooltipsdata);
 147
 148   g_object_set_data (G_OBJECT (tooltipsdata->widget), tooltips_data_key, NULL);
 149   g_object_unref (tooltipsdata->widget);
 150   g_free (tooltipsdata);
 151 }
 152
 153 static void
 154 tip_window_display_closed (GdkDisplay  *display,
 155                            gboolean     was_error,
 156                            GtkTooltips *tooltips)
 157 {
 158   gtk_tooltips_unset_tip_window (tooltips);
 159 }
 160
 161 static void
 162 disconnect_tip_window_display_closed (GtkTooltips *tooltips)
 163 {
 164   g_signal_handlers_disconnect_by_func (gtk_widget_get_display (tooltips->tip_window),
 165                                         (gpointer) tip_window_display_closed,
 166                                         tooltips);
 167 }
 168
 169 static void
 170 gtk_tooltips_unset_tip_window (GtkTooltips *tooltips)
 171 {
 172   if (tooltips->tip_window)
 173     {
 174       disconnect_tip_window_display_closed (tooltips);
 175
 176       gtk_widget_destroy (tooltips->tip_window);
 177       tooltips->tip_window = NULL;
 178     }
 179 }
 180
 181 static void
 182 gtk_tooltips_destroy (GtkObject *object)
 183 {
 184   GtkTooltips *tooltips = GTK_TOOLTIPS (object);
 185   GList *current;
 186   GtkTooltipsData *tooltipsdata;
 187
 188   g_return_if_fail (tooltips != NULL);
 189
 190   if (tooltips->timer_tag)
 191     {
 192       g_source_remove (tooltips->timer_tag);
 193       tooltips->timer_tag = 0;
 194     }
 195
 196   if (tooltips->tips_data_list != NULL)
 197     {
 198       current = g_list_first (tooltips->tips_data_list);
 199       while (current != NULL)
 200         {
 201           tooltipsdata = (GtkTooltipsData*) current->data;
 202           current = current->next;
 203           gtk_tooltips_widget_remove (tooltipsdata->widget, tooltipsdata);
 204         }
 205     }
 206
 207   gtk_tooltips_unset_tip_window (tooltips);
 208 }
 209
 210 static void
 211 gtk_tooltips_update_screen (GtkTooltips *tooltips,
 212                             gboolean     new_window)
 213 {
 214   gboolean screen_changed = FALSE;
 215
 216   if (tooltips->active_tips_data &&
 217       tooltips->active_tips_data->widget)
 218     {
 219       GdkScreen *screen = gtk_widget_get_screen (tooltips->active_tips_data->widget);
 220
 221       screen_changed = (screen != gtk_widget_get_screen (tooltips->tip_window));
 222
 223       if (screen_changed)
 224         {
 225           if (!new_window)
 226             disconnect_tip_window_display_closed (tooltips);
 227
 228           gtk_window_set_screen (GTK_WINDOW (tooltips->tip_window), screen);
 229         }
 230     }
 231
 232   if (screen_changed || new_window)
 233     g_signal_connect (gtk_widget_get_display (tooltips->tip_window), "closed",
 234                       G_CALLBACK (tip_window_display_closed), tooltips);
 235
 236 }
 237
 238 void
 239 gtk_tooltips_force_window (GtkTooltips *tooltips)
 240 {
 241   g_return_if_fail (GTK_IS_TOOLTIPS (tooltips));
 242
 243   if (!tooltips->tip_window)
 244     {
 245       tooltips->tip_window = gtk_window_new (GTK_WINDOW_POPUP);
 246       gtk_tooltips_update_screen (tooltips, TRUE);
 247       gtk_widget_set_app_paintable (tooltips->tip_window, TRUE);
 248       gtk_window_set_resizable (GTK_WINDOW (tooltips->tip_window), FALSE);
 249       gtk_widget_set_name (tooltips->tip_window, "gtk-tooltips");
 250       gtk_container_set_border_width (GTK_CONTAINER (tooltips->tip_window), 4);
 251
 252       g_signal_connect_swapped (tooltips->tip_window,
 253                                 "expose_event",
 254                                 G_CALLBACK (gtk_tooltips_paint_window),
 255                                 tooltips);
 256
 257       tooltips->tip_label = gtk_label_new (NULL);
 258       gtk_label_set_line_wrap (GTK_LABEL (tooltips->tip_label), TRUE);
 259       gtk_misc_set_alignment (GTK_MISC (tooltips->tip_label), 0.5, 0.5);
 260       gtk_widget_show (tooltips->tip_label);
 261
 262       gtk_container_add (GTK_CONTAINER (tooltips->tip_window), tooltips->tip_label);
 263
 264       g_signal_connect (tooltips->tip_window,
 265                         "destroy",
 266                         G_CALLBACK (gtk_widget_destroyed),
 267                         &tooltips->tip_window);
 268     }
 269 }
 270
 271 void
 272 gtk_tooltips_enable (GtkTooltips *tooltips)
 273 {
 274   g_return_if_fail (tooltips != NULL);
 275
 276   tooltips->enabled = TRUE;
 277 }
 278
 279 void
 280 gtk_tooltips_disable (GtkTooltips *tooltips)
 281 {
 282   g_return_if_fail (tooltips != NULL);
 283
 284   gtk_tooltips_set_active_widget (tooltips, NULL);
 285
 286   tooltips->enabled = FALSE;
 287 }
 288
 289 void
 290 gtk_tooltips_set_delay (GtkTooltips *tooltips,
 291                         guint         delay)
 292 {
 293   g_return_if_fail (tooltips != NULL);
 294
 295   tooltips->delay = delay;
 296 }
 297
 298 GtkTooltipsData*
 299 gtk_tooltips_data_get (GtkWidget       *widget)
 300 {
 301   g_return_val_if_fail (widget != NULL, NULL);
 302
 303   return g_object_get_data (G_OBJECT (widget), tooltips_data_key);
 304 }
 305
 306 void
 307 gtk_tooltips_set_tip (GtkTooltips *tooltips,
 308                       GtkWidget   *widget,
 309                       const gchar *tip_text,
 310                       const gchar *tip_private)
 311 {
 312   GtkTooltipsData *tooltipsdata;
 313
 314   g_return_if_fail (GTK_IS_TOOLTIPS (tooltips));
 315   g_return_if_fail (widget != NULL);
 316
 317   tooltipsdata = gtk_tooltips_data_get (widget);
 318
 319   if (!tip_text)
 320     {
 321       if (tooltipsdata)
 322         gtk_tooltips_widget_remove (tooltipsdata->widget, tooltipsdata);
 323       return;
 324     }
 325
 326   if (tooltips->active_tips_data
 327       && tooltips->active_tips_data->widget == widget
 328       && GTK_WIDGET_DRAWABLE (tooltips->active_tips_data->widget))
 329     {
 330       g_free (tooltipsdata->tip_text);
 331       g_free (tooltipsdata->tip_private);
 332
 333       tooltipsdata->tip_text = g_strdup (tip_text);
 334       tooltipsdata->tip_private = g_strdup (tip_private);
 335
 336       gtk_tooltips_draw_tips (tooltips);
 337     }
 338   else
 339     {
 340       g_object_ref (widget);
 341
 342       if (tooltipsdata)
 343         gtk_tooltips_widget_remove (tooltipsdata->widget, tooltipsdata);
 344
 345       tooltipsdata = g_new0 (GtkTooltipsData, 1);
 346
 347       tooltipsdata->tooltips = tooltips;
 348       tooltipsdata->widget = widget;
 349
 350       tooltipsdata->tip_text = g_strdup (tip_text);
 351       tooltipsdata->tip_private = g_strdup (tip_private);
 352
 353       tooltips->tips_data_list = g_list_append (tooltips->tips_data_list,
 354                                                 tooltipsdata);
 355       g_signal_connect_after (widget, "event-after",
 356                               G_CALLBACK (gtk_tooltips_event_handler),
 357                               tooltipsdata);
 358
 359       g_object_set_data (G_OBJECT (widget), tooltips_data_key,
 360                          tooltipsdata);
 361
 362       g_signal_connect (widget, "unmap",
 363                         G_CALLBACK (gtk_tooltips_widget_unmap),
 364                         tooltipsdata);
 365
 366       g_signal_connect (widget, "unrealize",
 367                         G_CALLBACK (gtk_tooltips_widget_unmap),
 368                         tooltipsdata);
 369
 370       g_signal_connect (widget, "destroy",
 371                         G_CALLBACK (gtk_tooltips_widget_remove),
 372                         tooltipsdata);
 373     }
 374 }
 375
 376 static gint
 377 gtk_tooltips_paint_window (GtkTooltips *tooltips)
 378 {
 379   gtk_paint_flat_box (tooltips->tip_window->style, tooltips->tip_window->window,
 380                       GTK_STATE_NORMAL, GTK_SHADOW_OUT,
 381                       NULL, GTK_WIDGET(tooltips->tip_window), "tooltip",
 382                       0, 0, -1, -1);
 383
 384   return FALSE;
 385 }
 386
 387 static void
 388 gtk_tooltips_draw_tips (GtkTooltips *tooltips)
 389 {
 390   GtkRequisition requisition;
 391   GtkWidget *widget;
 392   GtkStyle *style;
 393   gint x, y, w, h;
 394   GtkTooltipsData *data;
 395   gboolean keyboard_mode;
 396   GdkScreen *screen;
 397   GdkScreen *pointer_screen;
 398   gint monitor_num, px, py;
 399   GdkRectangle monitor;
 400
 401   if (!tooltips->tip_window)
 402     gtk_tooltips_force_window (tooltips);
 403   else if (GTK_WIDGET_VISIBLE (tooltips->tip_window))
 404     g_get_current_time (&tooltips->last_popdown);
 405
 406   gtk_widget_ensure_style (tooltips->tip_window);
 407   style = tooltips->tip_window->style;
 408
 409   widget = tooltips->active_tips_data->widget;
 410
 411   keyboard_mode = get_keyboard_mode (widget);
 412
 413   gtk_tooltips_update_screen (tooltips, FALSE);
 414
 415   screen = gtk_widget_get_screen (widget);
 416
 417   data = tooltips->active_tips_data;
 418
 419   gtk_label_set_text (GTK_LABEL (tooltips->tip_label), data->tip_text);
 420
 421   gtk_widget_size_request (tooltips->tip_window, &requisition);
 422   w = requisition.width;
 423   h = requisition.height;
 424
 425   gdk_window_get_origin (widget->window, &x, &y);
 426   if (GTK_WIDGET_NO_WINDOW (widget))
 427     {
 428       x += widget->allocation.x;
 429       y += widget->allocation.y;
 430     }
 431
 432   x += widget->allocation.width / 2;
 433
 434   if (!keyboard_mode)
 435     gdk_window_get_pointer (gdk_screen_get_root_window (screen),
 436                             &x, NULL, NULL);
 437
 438   x -= (w / 2 + 4);
 439
 440   gdk_display_get_pointer (gdk_screen_get_display (screen),
 441                            &pointer_screen, &px, &py, NULL);
 442   if (pointer_screen != screen)
 443     {
 444       px = x;
 445       py = y;
 446     }
 447   monitor_num = gdk_screen_get_monitor_at_point (screen, px, py);
 448   gdk_screen_get_monitor_geometry (screen, monitor_num, &monitor);
 449
 450   if ((x + w) > monitor.x + monitor.width)
 451     x -= (x + w) - (monitor.x + monitor.width);
 452   else if (x < monitor.x)
 453     x = monitor.x;
 454
 455   if ((y + h + widget->allocation.height + 4) > monitor.y + monitor.height)
 456     y = y - h - 4;
 457   else
 458     y = y + widget->allocation.height + 4;
 459
 460   gtk_window_move (GTK_WINDOW (tooltips->tip_window), x, y);
 461   gtk_widget_show (tooltips->tip_window);
 462 }
 463
 464 static gint
 465 gtk_tooltips_timeout (gpointer data)
 466 {
 467   GtkTooltips *tooltips = (GtkTooltips *) data;
 468
 469   GDK_THREADS_ENTER ();
 470
 471   if (tooltips->active_tips_data != NULL &&
 472       GTK_WIDGET_DRAWABLE (tooltips->active_tips_data->widget))
 473     gtk_tooltips_draw_tips (tooltips);
 474
 475   GDK_THREADS_LEAVE ();
 476
 477   return FALSE;
 478 }
 479
 480 static void
 481 gtk_tooltips_set_active_widget (GtkTooltips *tooltips,
 482                                 GtkWidget   *widget)
 483 {
 484   if (tooltips->tip_window)
 485     {
 486       if (GTK_WIDGET_VISIBLE (tooltips->tip_window))
 487         g_get_current_time (&tooltips->last_popdown);
 488       gtk_widget_hide (tooltips->tip_window);
 489     }
 490   if (tooltips->timer_tag)
 491     {
 492       g_source_remove (tooltips->timer_tag);
 493       tooltips->timer_tag = 0;
 494     }
 495
 496   tooltips->active_tips_data = NULL;
 497
 498   if (widget)
 499     {
 500       GList *list;
 501
 502       for (list = tooltips->tips_data_list; list; list = list->next)
 503         {
 504           GtkTooltipsData *tooltipsdata;
 505
 506           tooltipsdata = list->data;
 507
 508           if (tooltipsdata->widget == widget &&
 509               GTK_WIDGET_DRAWABLE (widget))
 510             {
 511               tooltips->active_tips_data = tooltipsdata;
 512               break;
 513             }
 514         }
 515     }
 516   else
 517     {
 518       tooltips->use_sticky_delay = FALSE;
 519     }
 520 }
 521
 522 static void
 523 gtk_tooltips_show_tip (GtkWidget *widget)
 524 {
 525   GtkTooltipsData *tooltipsdata;
 526
 527   tooltipsdata = gtk_tooltips_data_get (widget);
 528
 529   if (tooltipsdata &&
 530       (!tooltipsdata->tooltips->active_tips_data ||
 531        tooltipsdata->tooltips->active_tips_data->widget != widget))
 532     {
 533       gtk_tooltips_set_active_widget (tooltipsdata->tooltips, widget);
 534       gtk_tooltips_draw_tips (tooltipsdata->tooltips);
 535     }
 536 }
 537
 538 static void
 539 gtk_tooltips_hide_tip (GtkWidget *widget)
 540 {
 541   GtkTooltipsData *tooltipsdata;
 542
 543   tooltipsdata = gtk_tooltips_data_get (widget);
 544
 545   if (tooltipsdata &&
 546       (tooltipsdata->tooltips->active_tips_data &&
 547        tooltipsdata->tooltips->active_tips_data->widget == widget))
 548     gtk_tooltips_set_active_widget (tooltipsdata->tooltips, NULL);
 549 }
 550
 551 static gboolean
 552 gtk_tooltips_recently_shown (GtkTooltips *tooltips)
 553 {
 554   GTimeVal now;
 555   glong msec;
 556
 557   g_get_current_time (&now);
 558   msec = (now.tv_sec  - tooltips->last_popdown.tv_sec) * 1000 +
 559           (now.tv_usec - tooltips->last_popdown.tv_usec) / 1000;
 560   return (msec < STICKY_REVERT_DELAY);
 561 }
 562
 563 static gboolean
 564 get_keyboard_mode (GtkWidget *widget)
 565 {
 566   GtkWidget *toplevel = gtk_widget_get_toplevel (widget);
 567   if (GTK_IS_WINDOW (toplevel))
 568     return GPOINTER_TO_UINT (g_object_get_data (G_OBJECT (toplevel), "gtk-tooltips-keyboard-mode"));
 569   else
 570     return FALSE;
 571 }
 572
 573 static void
 574 start_keyboard_mode (GtkWidget *widget)
 575 {
 576   GtkWidget *toplevel = gtk_widget_get_toplevel (widget);
 577   if (GTK_IS_WINDOW (toplevel))
 578     {
 579       GtkWidget *focus = GTK_WINDOW (toplevel)->focus_widget;
 580
 581       g_object_set_data (G_OBJECT (toplevel), "gtk-tooltips-keyboard-mode", GUINT_TO_POINTER (TRUE));
 582
 583       if (focus)
 584         gtk_tooltips_show_tip (focus);
 585     }
 586 }
 587
 588 static void
 589 stop_keyboard_mode (GtkWidget *widget)
 590 {
 591   GtkWidget *toplevel = gtk_widget_get_toplevel (widget);
 592   if (GTK_IS_WINDOW (toplevel))
 593     {
 594       GtkWidget *focus = GTK_WINDOW (toplevel)->focus_widget;
 595       if (focus)
 596         gtk_tooltips_hide_tip (focus);
 597
 598       g_object_set_data (G_OBJECT (toplevel), "gtk-tooltips-keyboard-mode", GUINT_TO_POINTER (FALSE));
 599     }
 600 }
 601
 602 static void
 603 gtk_tooltips_start_delay (GtkTooltips *tooltips,
 604                           GtkWidget   *widget)
 605 {
 606   GtkTooltipsData *old_tips_data;
 607
 608   old_tips_data = tooltips->active_tips_data;
 609   if (tooltips->enabled &&
 610       (!old_tips_data || old_tips_data->widget != widget))
 611     {
 612       guint delay;
 613
 614       gtk_tooltips_set_active_widget (tooltips, widget);
 615
 616       if (tooltips->use_sticky_delay &&
 617           gtk_tooltips_recently_shown (tooltips))
 618         delay = STICKY_DELAY;
 619       else
 620         delay = tooltips->delay;
 621       tooltips->timer_tag = g_timeout_add (delay,
 622                                            gtk_tooltips_timeout,
 623                                            (gpointer) tooltips);
 624     }
 625 }
 626
 627 static void
 628 gtk_tooltips_event_handler (GtkWidget *widget,
 629                             GdkEvent  *event)
 630 {
 631   GtkTooltips *tooltips;
 632   GtkTooltipsData *old_tips_data;
 633   GtkWidget *event_widget;
 634   gboolean keyboard_mode = get_keyboard_mode (widget);
 635
 636   if ((event->type == GDK_LEAVE_NOTIFY || event->type == GDK_ENTER_NOTIFY) &&
 637       event->crossing.detail == GDK_NOTIFY_INFERIOR)
 638     return;
 639
 640   old_tips_data = gtk_tooltips_data_get (widget);
 641   tooltips = old_tips_data->tooltips;
 642
 643   if (keyboard_mode)
 644     {
 645       switch (event->type)
 646         {
 647         case GDK_FOCUS_CHANGE:
 648           if (event->focus_change.in)
 649             gtk_tooltips_show_tip (widget);
 650           else
 651             gtk_tooltips_hide_tip (widget);
 652           break;
 653         default:
 654           break;
 655         }
 656     }
 657   else
 658     {
 659       if (event->type != GDK_KEY_PRESS && event->type != GDK_KEY_RELEASE)
 660         {
 661           event_widget = gtk_get_event_widget (event);
 662           if (event_widget != widget)
 663             return;
 664         }
 665
 666       switch (event->type)
 667         {
 668         case GDK_EXPOSE:
 669           /* do nothing */
 670           break;
 671         case GDK_ENTER_NOTIFY:
 672           if (!(GTK_IS_MENU_ITEM (widget) && GTK_MENU_ITEM (widget)->submenu))
 673             gtk_tooltips_start_delay (tooltips, widget);
 674           break;
 675
 676         case GDK_LEAVE_NOTIFY:
 677           {
 678             gboolean use_sticky_delay;
 679
 680             use_sticky_delay = tooltips->tip_window &&
 681               GTK_WIDGET_VISIBLE (tooltips->tip_window);
 682             gtk_tooltips_set_active_widget (tooltips, NULL);
 683             tooltips->use_sticky_delay = use_sticky_delay;
 684           }
 685           break;
 686
 687         case GDK_MOTION_NOTIFY:
 688           /* Handle menu items specially ... pend popup for each motion
 689            * on other widgets, we ignore motion.
 690            */
 691           if (GTK_IS_MENU_ITEM (widget) && !GTK_MENU_ITEM (widget)->submenu)
 692             {
 693               /* Completely evil hack to make sure we get the LEAVE_NOTIFY
 694                */
 695               GTK_PRIVATE_SET_FLAG (widget, GTK_LEAVE_PENDING);
 696               gtk_tooltips_set_active_widget (tooltips, NULL);
 697               gtk_tooltips_start_delay (tooltips, widget);
 698               break;
 699             }
 700           break;                /* ignore */
 701         case GDK_BUTTON_PRESS:
 702         case GDK_BUTTON_RELEASE:
 703         case GDK_KEY_PRESS:
 704         case GDK_KEY_RELEASE:
 705         case GDK_PROXIMITY_IN:
 706         case GDK_SCROLL:
 707           gtk_tooltips_set_active_widget (tooltips, NULL);
 708           break;
 709         default:
 710           break;
 711         }
 712     }
 713 }
 714
 715 static void
 716 gtk_tooltips_widget_unmap (GtkWidget *widget,
 717                            gpointer   data)
 718 {
 719   GtkTooltipsData *tooltipsdata = (GtkTooltipsData *)data;
 720   GtkTooltips *tooltips = tooltipsdata->tooltips;
 721
 722   if (tooltips->active_tips_data &&
 723       (tooltips->active_tips_data->widget == widget))
 724     gtk_tooltips_set_active_widget (tooltips, NULL);
 725 }
 726
 727 static void
 728 gtk_tooltips_widget_remove (GtkWidget *widget,
 729                             gpointer   data)
 730 {
 731   GtkTooltipsData *tooltipsdata = (GtkTooltipsData*) data;
 732   GtkTooltips *tooltips = tooltipsdata->tooltips;
 733
 734   gtk_tooltips_widget_unmap (widget, data);
 735   tooltips->tips_data_list = g_list_remove (tooltips->tips_data_list,
 736                                             tooltipsdata);
 737   gtk_tooltips_destroy_data (tooltipsdata);
 738 }
 739
 740 void
 741 _gtk_tooltips_toggle_keyboard_mode (GtkWidget *widget)
 742 {
 743   if (get_keyboard_mode (widget))
 744     stop_keyboard_mode (widget);
 745   else
 746     start_keyboard_mode (widget);
 747 }
 748