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