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

   1 /* GTK - The GIMP Toolkit
   2  * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
   3  *
   4  * GtkQueryTips: Query onscreen widgets for their tooltips
   5  * Copyright (C) 1998 Tim Janik
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the
  19  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  20  * Boston, MA 02111-1307, USA.
  21  */
  22
  23 /*
  24  * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS
  25  * file for a list of people on the GTK+ Team.  See the ChangeLog
  26  * files for a list of changes.  These files are distributed with
  27  * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
  28  */
  29
  30 #undef GTK_DISABLE_DEPRECATED
  31
  32 #include        "gtktipsquery.h"
  33 #include        "gtksignal.h"
  34 #include        "gtktooltips.h"
  35 #include        "gtkmain.h"
  36 #include        "gtkmarshalers.h"
  37 #include        "gtkintl.h"
  38
  39
  40
  41 /* --- arguments --- */
  42 enum {
  43   ARG_0,
  44   ARG_EMIT_ALWAYS,
  45   ARG_CALLER,
  46   ARG_LABEL_INACTIVE,
  47   ARG_LABEL_NO_TIP
  48 };
  49
  50
  51 /* --- signals --- */
  52 enum
  53 {
  54   SIGNAL_START_QUERY,
  55   SIGNAL_STOP_QUERY,
  56   SIGNAL_WIDGET_ENTERED,
  57   SIGNAL_WIDGET_SELECTED,
  58   SIGNAL_LAST
  59 };
  60
  61 /* --- prototypes --- */
  62 static void     gtk_tips_query_class_init       (GtkTipsQueryClass      *class);
  63 static void     gtk_tips_query_init             (GtkTipsQuery           *tips_query);
  64 static void     gtk_tips_query_destroy          (GtkObject              *object);
  65 static gint     gtk_tips_query_event            (GtkWidget              *widget,
  66                                                  GdkEvent               *event);
  67 static void     gtk_tips_query_set_arg          (GtkObject              *object,
  68                                                  GtkArg                 *arg,
  69                                                  guint                   arg_id);
  70 static void     gtk_tips_query_get_arg          (GtkObject              *object,
  71                                                  GtkArg                 *arg,
  72                                                  guint                  arg_id);
  73 static void     gtk_tips_query_real_start_query (GtkTipsQuery           *tips_query);
  74 static void     gtk_tips_query_real_stop_query  (GtkTipsQuery           *tips_query);
  75 static void     gtk_tips_query_widget_entered   (GtkTipsQuery           *tips_query,
  76                                                  GtkWidget              *widget,
  77                                                  const gchar            *tip_text,
  78                                                  const gchar            *tip_private);
  79
  80
  81 /* --- variables --- */
  82 static GtkLabelClass    *parent_class = NULL;
  83 static guint             tips_query_signals[SIGNAL_LAST] = { 0 };
  84
  85
  86 /* --- functions --- */
  87 GtkType
  88 gtk_tips_query_get_type (void)
  89 {
  90   static GtkType tips_query_type = 0;
  91
  92   if (!tips_query_type)
  93     {
  94       static const GtkTypeInfo tips_query_info =
  95       {
  96         "GtkTipsQuery",
  97         sizeof (GtkTipsQuery),
  98         sizeof (GtkTipsQueryClass),
  99         (GtkClassInitFunc) gtk_tips_query_class_init,
 100         (GtkObjectInitFunc) gtk_tips_query_init,
 101         /* reserved_1 */ NULL,
 102         /* reserved_2 */ NULL,
 103         (GtkClassInitFunc) NULL,
 104       };
 105
 106       tips_query_type = gtk_type_unique (gtk_label_get_type (), &tips_query_info);
 107     }
 108
 109   return tips_query_type;
 110 }
 111
 112 static void
 113 gtk_tips_query_class_init (GtkTipsQueryClass *class)
 114 {
 115   GtkObjectClass *object_class;
 116   GtkWidgetClass *widget_class;
 117
 118   object_class = (GtkObjectClass*) class;
 119   widget_class = (GtkWidgetClass*) class;
 120
 121   parent_class = gtk_type_class (gtk_label_get_type ());
 122
 123
 124   object_class->set_arg = gtk_tips_query_set_arg;
 125   object_class->get_arg = gtk_tips_query_get_arg;
 126   object_class->destroy = gtk_tips_query_destroy;
 127
 128   widget_class->event = gtk_tips_query_event;
 129
 130   class->start_query = gtk_tips_query_real_start_query;
 131   class->stop_query = gtk_tips_query_real_stop_query;
 132   class->widget_entered = gtk_tips_query_widget_entered;
 133   class->widget_selected = NULL;
 134
 135   gtk_object_add_arg_type ("GtkTipsQuery::emit_always", GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_EMIT_ALWAYS);
 136   gtk_object_add_arg_type ("GtkTipsQuery::caller", GTK_TYPE_WIDGET, GTK_ARG_READWRITE, ARG_CALLER);
 137   gtk_object_add_arg_type ("GtkTipsQuery::label_inactive", GTK_TYPE_STRING, GTK_ARG_READWRITE, ARG_LABEL_INACTIVE);
 138   gtk_object_add_arg_type ("GtkTipsQuery::label_no_tip", GTK_TYPE_STRING, GTK_ARG_READWRITE, ARG_LABEL_NO_TIP);
 139
 140   tips_query_signals[SIGNAL_START_QUERY] =
 141     gtk_signal_new ("start_query",
 142                     GTK_RUN_FIRST,
 143                     GTK_CLASS_TYPE (object_class),
 144                     GTK_SIGNAL_OFFSET (GtkTipsQueryClass, start_query),
 145                     _gtk_marshal_VOID__VOID,
 146                     GTK_TYPE_NONE, 0);
 147   tips_query_signals[SIGNAL_STOP_QUERY] =
 148     gtk_signal_new ("stop_query",
 149                     GTK_RUN_FIRST,
 150                     GTK_CLASS_TYPE (object_class),
 151                     GTK_SIGNAL_OFFSET (GtkTipsQueryClass, stop_query),
 152                     _gtk_marshal_VOID__VOID,
 153                     GTK_TYPE_NONE, 0);
 154   tips_query_signals[SIGNAL_WIDGET_ENTERED] =
 155     gtk_signal_new ("widget_entered",
 156                     GTK_RUN_LAST,
 157                     GTK_CLASS_TYPE (object_class),
 158                     GTK_SIGNAL_OFFSET (GtkTipsQueryClass, widget_entered),
 159                     _gtk_marshal_VOID__OBJECT_STRING_STRING,
 160                     GTK_TYPE_NONE, 3,
 161                     GTK_TYPE_WIDGET,
 162                     GTK_TYPE_STRING,
 163                     GTK_TYPE_STRING);
 164   tips_query_signals[SIGNAL_WIDGET_SELECTED] =
 165     g_signal_new ("widget_selected",
 166                   G_TYPE_FROM_CLASS(object_class),
 167                   G_SIGNAL_RUN_LAST,
 168                   G_STRUCT_OFFSET(GtkTipsQueryClass, widget_selected),
 169                   _gtk_boolean_handled_accumulator, NULL,
 170                   _gtk_marshal_BOOLEAN__OBJECT_STRING_STRING_BOXED,
 171                   G_TYPE_BOOLEAN, 4,
 172                   GTK_TYPE_WIDGET,
 173                   G_TYPE_STRING,
 174                   G_TYPE_STRING,
 175                   GDK_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
 176 }
 177
 178 static void
 179 gtk_tips_query_init (GtkTipsQuery *tips_query)
 180 {
 181   tips_query->emit_always = FALSE;
 182   tips_query->in_query = FALSE;
 183   tips_query->label_inactive = g_strdup ("");
 184   tips_query->label_no_tip = g_strdup (_("--- No Tip ---"));
 185   tips_query->caller = NULL;
 186   tips_query->last_crossed = NULL;
 187   tips_query->query_cursor = NULL;
 188
 189   gtk_label_set_text (GTK_LABEL (tips_query), tips_query->label_inactive);
 190 }
 191
 192 static void
 193 gtk_tips_query_set_arg (GtkObject              *object,
 194                         GtkArg                 *arg,
 195                         guint                   arg_id)
 196 {
 197   GtkTipsQuery *tips_query;
 198
 199   tips_query = GTK_TIPS_QUERY (object);
 200
 201   switch (arg_id)
 202     {
 203     case ARG_EMIT_ALWAYS:
 204       tips_query->emit_always = (GTK_VALUE_BOOL (*arg) != FALSE);
 205       break;
 206     case ARG_CALLER:
 207       gtk_tips_query_set_caller (tips_query, GTK_WIDGET (GTK_VALUE_OBJECT (*arg)));
 208       break;
 209     case ARG_LABEL_INACTIVE:
 210       gtk_tips_query_set_labels (tips_query, GTK_VALUE_STRING (*arg), tips_query->label_no_tip);
 211       break;
 212     case ARG_LABEL_NO_TIP:
 213       gtk_tips_query_set_labels (tips_query, tips_query->label_inactive, GTK_VALUE_STRING (*arg));
 214       break;
 215     default:
 216       break;
 217     }
 218 }
 219
 220 static void
 221 gtk_tips_query_get_arg (GtkObject             *object,
 222                         GtkArg                *arg,
 223                         guint                  arg_id)
 224 {
 225   GtkTipsQuery *tips_query;
 226
 227   tips_query = GTK_TIPS_QUERY (object);
 228
 229   switch (arg_id)
 230     {
 231     case ARG_EMIT_ALWAYS:
 232       GTK_VALUE_BOOL (*arg) = tips_query->emit_always;
 233       break;
 234     case ARG_CALLER:
 235       GTK_VALUE_OBJECT (*arg) = (GtkObject*) tips_query->caller;
 236       break;
 237     case ARG_LABEL_INACTIVE:
 238       GTK_VALUE_STRING (*arg) = g_strdup (tips_query->label_inactive);
 239       break;
 240     case ARG_LABEL_NO_TIP:
 241       GTK_VALUE_STRING (*arg) = g_strdup (tips_query->label_no_tip);
 242       break;
 243     default:
 244       arg->type = GTK_TYPE_INVALID;
 245       break;
 246     }
 247 }
 248
 249 static void
 250 gtk_tips_query_destroy (GtkObject       *object)
 251 {
 252   GtkTipsQuery *tips_query;
 253
 254   g_return_if_fail (GTK_IS_TIPS_QUERY (object));
 255
 256   tips_query = GTK_TIPS_QUERY (object);
 257
 258   if (tips_query->in_query)
 259     gtk_tips_query_stop_query (tips_query);
 260
 261   gtk_tips_query_set_caller (tips_query, NULL);
 262
 263   g_free (tips_query->label_inactive);
 264   tips_query->label_inactive = NULL;
 265   g_free (tips_query->label_no_tip);
 266   tips_query->label_no_tip = NULL;
 267
 268   if (GTK_OBJECT_CLASS (parent_class)->destroy)
 269     (* GTK_OBJECT_CLASS (parent_class)->destroy) (object);
 270 }
 271
 272 GtkWidget*
 273 gtk_tips_query_new (void)
 274 {
 275   GtkTipsQuery *tips_query;
 276
 277   tips_query = gtk_type_new (gtk_tips_query_get_type ());
 278
 279   return GTK_WIDGET (tips_query);
 280 }
 281
 282 void
 283 gtk_tips_query_set_labels (GtkTipsQuery   *tips_query,
 284                            const gchar    *label_inactive,
 285                            const gchar    *label_no_tip)
 286 {
 287   gchar *old;
 288
 289   g_return_if_fail (GTK_IS_TIPS_QUERY (tips_query));
 290   g_return_if_fail (label_inactive != NULL);
 291   g_return_if_fail (label_no_tip != NULL);
 292
 293   old = tips_query->label_inactive;
 294   tips_query->label_inactive = g_strdup (label_inactive);
 295   g_free (old);
 296   old = tips_query->label_no_tip;
 297   tips_query->label_no_tip = g_strdup (label_no_tip);
 298   g_free (old);
 299 }
 300
 301 void
 302 gtk_tips_query_set_caller (GtkTipsQuery   *tips_query,
 303                            GtkWidget       *caller)
 304 {
 305   g_return_if_fail (GTK_IS_TIPS_QUERY (tips_query));
 306   g_return_if_fail (tips_query->in_query == FALSE);
 307   if (caller)
 308     g_return_if_fail (GTK_IS_WIDGET (caller));
 309
 310   if (caller)
 311     gtk_widget_ref (caller);
 312
 313   if (tips_query->caller)
 314     gtk_widget_unref (tips_query->caller);
 315
 316   tips_query->caller = caller;
 317 }
 318
 319 void
 320 gtk_tips_query_start_query (GtkTipsQuery *tips_query)
 321 {
 322   g_return_if_fail (GTK_IS_TIPS_QUERY (tips_query));
 323   g_return_if_fail (tips_query->in_query == FALSE);
 324   g_return_if_fail (GTK_WIDGET_REALIZED (tips_query));
 325
 326   tips_query->in_query = TRUE;
 327   gtk_signal_emit (GTK_OBJECT (tips_query), tips_query_signals[SIGNAL_START_QUERY]);
 328 }
 329
 330 void
 331 gtk_tips_query_stop_query (GtkTipsQuery *tips_query)
 332 {
 333   g_return_if_fail (GTK_IS_TIPS_QUERY (tips_query));
 334   g_return_if_fail (tips_query->in_query == TRUE);
 335
 336   gtk_signal_emit (GTK_OBJECT (tips_query), tips_query_signals[SIGNAL_STOP_QUERY]);
 337   tips_query->in_query = FALSE;
 338 }
 339
 340 static void
 341 gtk_tips_query_real_start_query (GtkTipsQuery *tips_query)
 342 {
 343   gint failure;
 344
 345   g_return_if_fail (GTK_IS_TIPS_QUERY (tips_query));
 346
 347   tips_query->query_cursor = gdk_cursor_new_for_display (gtk_widget_get_display (GTK_WIDGET (tips_query)),
 348                                                          GDK_QUESTION_ARROW);
 349   failure = gdk_pointer_grab (GTK_WIDGET (tips_query)->window,
 350                               TRUE,
 351                               GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK |
 352                               GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK,
 353                               NULL,
 354                               tips_query->query_cursor,
 355                               GDK_CURRENT_TIME);
 356   if (failure)
 357     {
 358       gdk_cursor_unref (tips_query->query_cursor);
 359       tips_query->query_cursor = NULL;
 360     }
 361   gtk_grab_add (GTK_WIDGET (tips_query));
 362 }
 363
 364 static void
 365 gtk_tips_query_real_stop_query (GtkTipsQuery *tips_query)
 366 {
 367   g_return_if_fail (GTK_IS_TIPS_QUERY (tips_query));
 368
 369   gtk_grab_remove (GTK_WIDGET (tips_query));
 370   if (tips_query->query_cursor)
 371     {
 372       gdk_display_pointer_ungrab (gtk_widget_get_display (GTK_WIDGET (tips_query)),
 373                                   GDK_CURRENT_TIME);
 374       gdk_cursor_unref (tips_query->query_cursor);
 375       tips_query->query_cursor = NULL;
 376     }
 377   if (tips_query->last_crossed)
 378     {
 379       gtk_widget_unref (tips_query->last_crossed);
 380       tips_query->last_crossed = NULL;
 381     }
 382
 383   gtk_label_set_text (GTK_LABEL (tips_query), tips_query->label_inactive);
 384 }
 385
 386 static void
 387 gtk_tips_query_widget_entered (GtkTipsQuery   *tips_query,
 388                                GtkWidget      *widget,
 389                                const gchar    *tip_text,
 390                                const gchar    *tip_private)
 391 {
 392   g_return_if_fail (GTK_IS_TIPS_QUERY (tips_query));
 393
 394   if (!tip_text)
 395     tip_text = tips_query->label_no_tip;
 396
 397   if (!g_str_equal (GTK_LABEL (tips_query)->label, (gchar*) tip_text))
 398     gtk_label_set_text (GTK_LABEL (tips_query), tip_text);
 399 }
 400
 401 static void
 402 gtk_tips_query_emit_widget_entered (GtkTipsQuery *tips_query,
 403                                     GtkWidget    *widget)
 404 {
 405   GtkTooltipsData *tdata;
 406
 407   if (widget == (GtkWidget*) tips_query)
 408     widget = NULL;
 409
 410   if (widget)
 411     tdata = gtk_tooltips_data_get (widget);
 412   else
 413     tdata = NULL;
 414
 415   if (!widget && tips_query->last_crossed)
 416     {
 417       gtk_signal_emit (GTK_OBJECT (tips_query),
 418                        tips_query_signals[SIGNAL_WIDGET_ENTERED],
 419                        NULL,
 420                        NULL,
 421                        NULL);
 422       gtk_widget_unref (tips_query->last_crossed);
 423       tips_query->last_crossed = NULL;
 424     }
 425   else if (widget && widget != tips_query->last_crossed)
 426     {
 427       gtk_widget_ref (widget);
 428       if (tdata || tips_query->emit_always)
 429           gtk_signal_emit (GTK_OBJECT (tips_query),
 430                            tips_query_signals[SIGNAL_WIDGET_ENTERED],
 431                            widget,
 432                            tdata ? tdata->tip_text : NULL,
 433                            tdata ? tdata->tip_private : NULL);
 434       if (tips_query->last_crossed)
 435         gtk_widget_unref (tips_query->last_crossed);
 436       tips_query->last_crossed = widget;
 437     }
 438 }
 439
 440 static gint
 441 gtk_tips_query_event (GtkWidget        *widget,
 442                       GdkEvent         *event)
 443 {
 444   GtkTipsQuery *tips_query;
 445   GtkWidget *event_widget;
 446   gboolean event_handled;
 447
 448   g_return_val_if_fail (GTK_IS_TIPS_QUERY (widget), FALSE);
 449
 450   tips_query = GTK_TIPS_QUERY (widget);
 451   if (!tips_query->in_query)
 452     {
 453       if (GTK_WIDGET_CLASS (parent_class)->event)
 454         return GTK_WIDGET_CLASS (parent_class)->event (widget, event);
 455       else
 456         return FALSE;
 457     }
 458
 459   event_widget = gtk_get_event_widget (event);
 460
 461   event_handled = FALSE;
 462   switch (event->type)
 463     {
 464       GdkWindow *pointer_window;
 465
 466     case  GDK_LEAVE_NOTIFY:
 467       if (event_widget)
 468         pointer_window = gdk_window_get_pointer (event_widget->window, NULL, NULL, NULL);
 469       else
 470         pointer_window = NULL;
 471       event_widget = NULL;
 472       if (pointer_window)
 473         gdk_window_get_user_data (pointer_window, (gpointer*) &event_widget);
 474       gtk_tips_query_emit_widget_entered (tips_query, event_widget);
 475       event_handled = TRUE;
 476       break;
 477
 478     case  GDK_ENTER_NOTIFY:
 479       gtk_tips_query_emit_widget_entered (tips_query, event_widget);
 480       event_handled = TRUE;
 481       break;
 482
 483     case  GDK_BUTTON_PRESS:
 484     case  GDK_BUTTON_RELEASE:
 485       if (event_widget)
 486         {
 487           if (event_widget == (GtkWidget*) tips_query ||
 488               event_widget == tips_query->caller)
 489             gtk_tips_query_stop_query (tips_query);
 490           else
 491             {
 492               gint stop;
 493               GtkTooltipsData *tdata;
 494
 495               stop = TRUE;
 496               tdata = gtk_tooltips_data_get (event_widget);
 497               if (tdata || tips_query->emit_always)
 498                 gtk_signal_emit (GTK_OBJECT (tips_query),
 499                                  tips_query_signals[SIGNAL_WIDGET_SELECTED],
 500                                  event_widget,
 501                                  tdata ? tdata->tip_text : NULL,
 502                                  tdata ? tdata->tip_private : NULL,
 503                                  event,
 504                                  &stop);
 505
 506               if (stop)
 507                 gtk_tips_query_stop_query (tips_query);
 508             }
 509         }
 510       event_handled = TRUE;
 511       break;
 512
 513     default:
 514       break;
 515     }
 516
 517   return event_handled;
 518 }