New widget GtkTipsQuery for letting the user query tooltips of widgets.

Fri Feb 20 06:40:00 1998  Tim Janik  <timj@gimp.org>

        * gtk/gtktipsquery.h:
        * gtk/gtktipsquery.c:
        New widget GtkTipsQuery for letting the user query tooltips of widgets.

        * gtk/testgtk.c: add example for GtkTipsQuery.

        * gtk/gtk.h: include gtk/gtktipsquery.h.

        * gtk/gtklabel.c: enable default constructing.

6 files changed, 743 insertions, 8 deletions

diff --git a/gtk/Makefile.am b/gtk/Makefile.am
index 4074395ad3..6a306704de 100644
--- a/gtk/Makefile.am
+++ b/gtk/Makefile.am
@@ -74,6 +74,7 @@ libgtk_la_SOURCES = \
 	gtkstatusbar.c		\
 	gtktable.c		\
 	gtktext.c		\
+	gtktipsquery.c		\
 	gtktogglebutton.c	\
 	gtktoolbar.c		\
 	gtktooltips.c		\
@@ -167,6 +168,7 @@ gtkinclude_HEADERS = \
 	gtkstatusbar.h		\
 	gtktable.h		\
 	gtktext.h		\
+	gtktipsquery.h		\
 	gtktogglebutton.h	\
 	gtktoolbar.h		\
 	gtktooltips.h		\
diff --git a/gtk/gtk.h b/gtk/gtk.h
index 22b81b22ee..312a417951 100644
--- a/gtk/gtk.h
+++ b/gtk/gtk.h
@@ -90,6 +90,7 @@
 #include <gtk/gtkstatusbar.h>
 #include <gtk/gtktable.h>
 #include <gtk/gtktext.h>
+#include <gtk/gtktipsquery.h>
 #include <gtk/gtktogglebutton.h>
 #include <gtk/gtktoolbar.h>
 #include <gtk/gtktooltips.h>
diff --git a/gtk/gtklabel.c b/gtk/gtklabel.c
index 0b48b42f93..694f9620a8 100644
--- a/gtk/gtklabel.c
+++ b/gtk/gtklabel.c
@@ -132,6 +132,8 @@ gtk_label_init (GtkLabel *label)
   label->label = NULL;
   label->row = NULL;
   label->jtype = GTK_JUSTIFY_CENTER;
+
+  gtk_label_set (label, "");
 }
 
 GtkWidget*
diff --git a/gtk/gtktipsquery.c b/gtk/gtktipsquery.c
new file mode 100644
index 0000000000..22fa1b0aa5
--- /dev/null
+++ b/gtk/gtktipsquery.c
@@ -0,0 +1,562 @@
+/* GTK - The GIMP Toolkit
+ * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
+ *
+ * GtkQueryTips: Query onscreen widgets for their tooltips
+ * Copyright (C) 1998 Tim Janik
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	 See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * $Id$
+ */
+#include	"gtktipsquery.h"
+#include	"gtksignal.h"
+#include	"gtktooltips.h"
+#include	"gtkmain.h"
+
+
+
+/* --- arguments --- */
+enum {
+  ARG_0,
+  ARG_EMIT_ALWAYS,
+  ARG_CALLER,
+  ARG_LABEL_INACTIVE,
+  ARG_LABEL_NO_TIP
+};
+
+
+/* --- signals --- */
+enum
+{
+  SIGNAL_START_QUERY,
+  SIGNAL_STOP_QUERY,
+  SIGNAL_WIDGET_ENTERED,
+  SIGNAL_WIDGET_SELECTED,
+  SIGNAL_LAST
+};
+typedef	void	(*SignalWidgetEntered)		(GtkObject	*object,
+						 GtkWidget	*widget,
+						 const gchar	*tip_text,
+						 const gchar	*tip_private,
+						 gpointer	 func_data);
+typedef	gint	(*SignalWidgetSelected)		(GtkObject	*object,
+						 GtkWidget	*widget,
+						 const gchar	*tip_text,
+						 const gchar	*tip_private,
+						 GdkEventButton *event,
+						 gpointer	 func_data);
+
+
+/* --- prototypes --- */
+static void	gtk_tips_query_class_init	(GtkTipsQueryClass	*class);
+static void	gtk_tips_query_init		(GtkTipsQuery		*tips_query);
+static void	gtk_tips_query_destroy		(GtkObject		*object);
+static gint	gtk_tips_query_event		(GtkWidget		*widget,
+						 GdkEvent		*event);
+static void	gtk_tips_query_set_arg		(GtkTipsQuery		*tips_query,
+						 GtkArg			*arg,
+						 guint			 arg_id);
+static void	gtk_tips_query_get_arg		(GtkTipsQuery		*tips_query,
+						 GtkArg			*arg,
+						 guint			arg_id);
+static void	gtk_tips_query_real_start_query	(GtkTipsQuery		*tips_query);
+static void	gtk_tips_query_real_stop_query	(GtkTipsQuery		*tips_query);
+static void	gtk_tips_query_widget_entered	(GtkTipsQuery		*tips_query,
+						 GtkWidget		*widget,
+						 const gchar		*tip_text,
+						 const gchar		*tip_private);
+
+
+/* --- variables --- */
+static GtkLabelClass	*parent_class = NULL;
+static gint		 tips_query_signals[SIGNAL_LAST] = { 0 };
+static const gchar	*key_event_mask = "gtk-tips-query-saved-event-mask";
+
+
+/* --- functions --- */
+guint
+gtk_tips_query_get_type (void)
+{
+  static guint tips_query_type = 0;
+
+  if (!tips_query_type)
+    {
+      GtkTypeInfo tips_query_info =
+      {
+	"GtkTipsQuery",
+	sizeof (GtkTipsQuery),
+	sizeof (GtkTipsQueryClass),
+	(GtkClassInitFunc) gtk_tips_query_class_init,
+	(GtkObjectInitFunc) gtk_tips_query_init,
+	(GtkArgSetFunc) gtk_tips_query_set_arg,
+	(GtkArgGetFunc) gtk_tips_query_get_arg,
+      };
+
+      tips_query_type = gtk_type_unique (gtk_label_get_type (), &tips_query_info);
+    }
+
+  return tips_query_type;
+}
+
+static void
+gtk_tips_query_marshal_widget_entered (GtkObject      *object,
+				       GtkSignalFunc  func,
+				       gpointer	      func_data,
+				       GtkArg	      *args)
+{
+  SignalWidgetEntered sfunc = (SignalWidgetEntered) func;
+
+  (* sfunc) (object,
+	     (GtkWidget*) GTK_VALUE_OBJECT (args[0]),
+	     GTK_VALUE_STRING (args[1]),
+	     GTK_VALUE_STRING (args[2]),
+	     func_data);
+}
+
+static void
+gtk_tips_query_marshal_widget_selected (GtkObject      *object,
+					GtkSignalFunc  func,
+					gpointer       func_data,
+					GtkArg	       *args)
+{
+  gint *return_val;
+
+  SignalWidgetSelected sfunc = (SignalWidgetSelected) func;
+  return_val = GTK_RETLOC_BOOL (args[4]);
+  
+  *return_val = (* sfunc) (object,
+			   (GtkWidget*) GTK_VALUE_OBJECT (args[0]),
+			   GTK_VALUE_STRING (args[1]),
+			   GTK_VALUE_STRING (args[2]),
+			   GTK_VALUE_BOXED (args[3]),
+			   func_data);
+}
+
+static void
+gtk_tips_query_class_init (GtkTipsQueryClass *class)
+{
+  GtkObjectClass *object_class;
+  GtkWidgetClass *widget_class;
+
+  object_class = (GtkObjectClass*) class;
+  widget_class = (GtkWidgetClass*) class;
+
+  parent_class = gtk_type_class (gtk_label_get_type ());
+
+  gtk_object_add_arg_type ("GtkTipsQuery::emit_always", GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_EMIT_ALWAYS);
+  gtk_object_add_arg_type ("GtkTipsQuery::caller", GTK_TYPE_WIDGET, GTK_ARG_READWRITE, ARG_CALLER);
+  gtk_object_add_arg_type ("GtkTipsQuery::label_inactive", GTK_TYPE_STRING, GTK_ARG_READWRITE, ARG_LABEL_INACTIVE);
+  gtk_object_add_arg_type ("GtkTipsQuery::label_no_tip", GTK_TYPE_STRING, GTK_ARG_READWRITE, ARG_LABEL_NO_TIP);
+
+  tips_query_signals[SIGNAL_START_QUERY] =
+    gtk_signal_new ("start_query",
+		    GTK_RUN_FIRST,
+		    object_class->type,
+		    GTK_SIGNAL_OFFSET (GtkTipsQueryClass, start_query),
+		    gtk_signal_default_marshaller,
+		    GTK_TYPE_NONE, 0);
+  tips_query_signals[SIGNAL_STOP_QUERY] =
+    gtk_signal_new ("stop_query",
+		    GTK_RUN_FIRST,
+		    object_class->type,
+		    GTK_SIGNAL_OFFSET (GtkTipsQueryClass, stop_query),
+		    gtk_signal_default_marshaller,
+		    GTK_TYPE_NONE, 0);
+  tips_query_signals[SIGNAL_WIDGET_ENTERED] =
+    gtk_signal_new ("widget_entered",
+		    GTK_RUN_FIRST,
+		    object_class->type,
+		    GTK_SIGNAL_OFFSET (GtkTipsQueryClass, widget_entered),
+		    gtk_tips_query_marshal_widget_entered,
+		    GTK_TYPE_NONE, 3,
+		    GTK_TYPE_WIDGET,
+		    GTK_TYPE_STRING,
+		    GTK_TYPE_STRING);
+  tips_query_signals[SIGNAL_WIDGET_SELECTED] =
+    gtk_signal_new ("widget_selected",
+		    GTK_RUN_FIRST,
+		    object_class->type,
+		    GTK_SIGNAL_OFFSET (GtkTipsQueryClass, widget_selected),
+		    gtk_tips_query_marshal_widget_selected,
+		    GTK_TYPE_INT, 4,
+		    GTK_TYPE_WIDGET,
+		    GTK_TYPE_STRING,
+		    GTK_TYPE_STRING,
+		    GTK_TYPE_BOXED);
+  gtk_object_class_add_signals (object_class, tips_query_signals, SIGNAL_LAST);
+
+  object_class->destroy = gtk_tips_query_destroy;
+  widget_class->event = gtk_tips_query_event;
+
+  class->start_query = gtk_tips_query_real_start_query;
+  class->stop_query = gtk_tips_query_real_stop_query;
+  class->widget_entered = gtk_tips_query_widget_entered;
+  class->widget_selected = NULL;
+}
+
+static void
+gtk_tips_query_init (GtkTipsQuery *tips_query)
+{
+  tips_query->emit_always = FALSE;
+  tips_query->in_query = FALSE;
+  tips_query->label_inactive = g_strdup ("");
+  tips_query->label_no_tip = g_strdup ("--- No Tip ---");
+  tips_query->caller = NULL;
+  tips_query->last_crossed = NULL;
+  tips_query->event_restore_list = NULL;
+
+  gtk_label_set (GTK_LABEL (tips_query), tips_query->label_inactive);
+}
+
+static void
+gtk_tips_query_set_arg (GtkTipsQuery           *tips_query,
+			GtkArg                 *arg,
+			guint                   arg_id)
+{
+  switch (arg_id)
+    {
+    case ARG_EMIT_ALWAYS:
+      tips_query->emit_always = (GTK_VALUE_BOOL (*arg) != FALSE);
+      break;
+    case ARG_CALLER:
+      gtk_tips_query_set_caller (tips_query, GTK_WIDGET (GTK_VALUE_OBJECT (*arg)));
+      break;
+    case ARG_LABEL_INACTIVE:
+      gtk_tips_query_set_labels (tips_query, GTK_VALUE_STRING (*arg), tips_query->label_no_tip);
+      break;
+    case ARG_LABEL_NO_TIP:
+      gtk_tips_query_set_labels (tips_query, tips_query->label_inactive, GTK_VALUE_STRING (*arg));
+      break;
+    default:
+      arg->type = GTK_TYPE_INVALID;
+      break;
+    }
+}
+
+static void
+gtk_tips_query_get_arg (GtkTipsQuery           *tips_query,
+			GtkArg                 *arg,
+			guint                  arg_id)
+{
+  switch (arg_id)
+    {
+    case ARG_EMIT_ALWAYS:
+      GTK_VALUE_BOOL (*arg) = tips_query->emit_always;
+      break;
+    case ARG_CALLER:
+      GTK_VALUE_OBJECT (*arg) = (GtkObject*) tips_query->caller;
+      break;
+    case ARG_LABEL_INACTIVE:
+      GTK_VALUE_STRING (*arg) = g_strdup (tips_query->label_inactive);
+      break;
+    case ARG_LABEL_NO_TIP:
+      GTK_VALUE_STRING (*arg) = g_strdup (tips_query->label_no_tip);
+      break;
+    default:
+      arg->type = GTK_TYPE_INVALID;
+      break;
+    }
+}
+
+static void
+gtk_tips_query_destroy (GtkObject	*object)
+{
+  GtkTipsQuery *tips_query;
+
+  g_return_if_fail (object != NULL);
+  g_return_if_fail (GTK_IS_TIPS_QUERY (object));
+
+  tips_query = GTK_TIPS_QUERY (object);
+
+  if (tips_query->in_query)
+    gtk_tips_query_stop_query (tips_query);
+
+  gtk_tips_query_set_caller (tips_query, NULL);
+
+  if (GTK_OBJECT_CLASS (parent_class)->destroy)
+    (* GTK_OBJECT_CLASS (parent_class)->destroy) (object);
+}
+
+GtkWidget*
+gtk_tips_query_new (void)
+{
+  GtkTipsQuery *tips_query;
+
+  tips_query = gtk_type_new (gtk_tips_query_get_type ());
+
+  return GTK_WIDGET (tips_query);
+}
+
+void
+gtk_tips_query_set_labels (GtkTipsQuery   *tips_query,
+			   const gchar	  *label_inactive,
+			   const gchar	  *label_no_tip)
+{
+  gchar *old;
+
+  g_return_if_fail (tips_query != NULL);
+  g_return_if_fail (GTK_IS_TIPS_QUERY (tips_query));
+  g_return_if_fail (label_inactive != NULL);
+  g_return_if_fail (label_no_tip != NULL);
+
+  old = tips_query->label_inactive;
+  tips_query->label_inactive = g_strdup (label_inactive);
+  g_free (old);
+  old = tips_query->label_no_tip;
+  tips_query->label_no_tip = g_strdup (label_no_tip);
+  g_free (old);
+}
+
+void
+gtk_tips_query_set_caller (GtkTipsQuery   *tips_query,
+			   GtkWidget	   *caller)
+{
+  g_return_if_fail (tips_query != NULL);
+  g_return_if_fail (GTK_IS_TIPS_QUERY (tips_query));
+  g_return_if_fail (tips_query->in_query == FALSE);
+  if (caller)
+    g_return_if_fail (GTK_IS_WIDGET (caller));
+
+  if (caller)
+    gtk_widget_ref (caller);
+
+  if (tips_query->caller)
+    gtk_widget_unref (tips_query->caller);
+
+  tips_query->caller = caller;
+}
+
+void
+gtk_tips_query_start_query (GtkTipsQuery *tips_query)
+{
+  g_return_if_fail (tips_query != NULL);
+  g_return_if_fail (GTK_IS_TIPS_QUERY (tips_query));
+  g_return_if_fail (tips_query->in_query == FALSE);
+
+  tips_query->in_query = TRUE;
+  gtk_signal_emit (GTK_OBJECT (tips_query), tips_query_signals[SIGNAL_START_QUERY]);
+}
+
+void
+gtk_tips_query_stop_query (GtkTipsQuery *tips_query)
+{
+  g_return_if_fail (tips_query != NULL);
+  g_return_if_fail (GTK_IS_TIPS_QUERY (tips_query));
+  g_return_if_fail (tips_query->in_query == TRUE);
+
+  gtk_signal_emit (GTK_OBJECT (tips_query), tips_query_signals[SIGNAL_STOP_QUERY]);
+  tips_query->in_query = FALSE;
+}
+
+void
+gtk_tips_query_real_start_query (GtkTipsQuery *tips_query)
+{
+  g_return_if_fail (tips_query != NULL);
+  g_return_if_fail (GTK_IS_TIPS_QUERY (tips_query));
+
+  gtk_grab_add (GTK_WIDGET (tips_query));
+}
+
+void
+gtk_tips_query_real_stop_query (GtkTipsQuery *tips_query)
+{
+  GSList *list;
+
+  g_return_if_fail (tips_query != NULL);
+  g_return_if_fail (GTK_IS_TIPS_QUERY (tips_query));
+  
+  gtk_grab_remove (GTK_WIDGET (tips_query));
+  if (tips_query->last_crossed)
+    {
+      gtk_widget_unref (tips_query->last_crossed);
+      tips_query->last_crossed = NULL;
+    }
+  
+  list = tips_query->event_restore_list;
+  while (list)
+    {
+      GtkWidget *win_widget;
+      GdkEventMask *event_mask;
+      
+      win_widget = list->data;
+      event_mask = gtk_object_get_data (GTK_OBJECT (win_widget), key_event_mask);
+      if (event_mask)
+	{
+	  gtk_object_remove_data (GTK_OBJECT (win_widget), key_event_mask);
+	  if (GTK_WIDGET_REALIZED (win_widget))
+	    gdk_window_set_events (win_widget->window, *event_mask);
+	  g_free (event_mask);
+	}
+      gtk_widget_unref (win_widget);
+      list = list->next;
+    }
+  g_slist_free (tips_query->event_restore_list);
+  tips_query->event_restore_list = NULL;
+
+  gtk_label_set (GTK_LABEL (tips_query), tips_query->label_inactive);
+}
+
+static void
+gtk_tips_query_widget_entered (GtkTipsQuery   *tips_query,
+			       GtkWidget      *widget,
+			       const gchar    *tip_text,
+			       const gchar    *tip_private)
+{
+  g_return_if_fail (tips_query != NULL);
+  g_return_if_fail (GTK_IS_TIPS_QUERY (tips_query));
+
+  if (!tip_text)
+    tip_text = tips_query->label_no_tip;
+
+  if (!g_str_equal (GTK_LABEL (tips_query)->label, (gchar*) tip_text))
+    gtk_label_set (GTK_LABEL (tips_query), tip_text);
+}
+
+static void
+gtk_tips_query_emit_widget_entered (GtkTipsQuery *tips_query,
+				    GtkWidget	 *widget)
+{
+  GtkTooltipsData *tdata;
+
+  if (widget == (GtkWidget*) tips_query)
+    widget = NULL;
+
+  if (widget)
+    tdata = gtk_tooltips_data_get (widget);
+  else
+    tdata = NULL;
+
+  if (!widget && tips_query->last_crossed)
+    {
+      gtk_signal_emit (GTK_OBJECT (tips_query),
+		       tips_query_signals[SIGNAL_WIDGET_ENTERED],
+		       NULL,
+		       NULL,
+		       NULL);
+      gtk_widget_unref (tips_query->last_crossed);
+      tips_query->last_crossed = NULL;
+    }
+  else if (widget && widget != tips_query->last_crossed)
+    {
+      gtk_widget_ref (widget);
+      if (tdata || tips_query->emit_always)
+	  gtk_signal_emit (GTK_OBJECT (tips_query),
+			   tips_query_signals[SIGNAL_WIDGET_ENTERED],
+			   widget,
+			   tdata ? tdata->tip_text : NULL,
+			   tdata ? tdata->tip_private : NULL);
+      if (tips_query->last_crossed)
+	gtk_widget_unref (tips_query->last_crossed);
+      tips_query->last_crossed = widget;
+    }
+}
+
+static gint
+gtk_tips_query_event (GtkWidget	       *widget,
+		      GdkEvent	       *event)
+{
+  GtkTipsQuery *tips_query;
+  GtkWidget *event_widget;
+  gboolean event_handled;
+  
+  g_return_val_if_fail (widget != NULL, FALSE);
+  g_return_val_if_fail (GTK_IS_TIPS_QUERY (widget), FALSE);
+
+  tips_query = GTK_TIPS_QUERY (widget);
+  if (!tips_query->in_query)
+    {
+      if (GTK_WIDGET_CLASS (parent_class)->event)
+	return GTK_WIDGET_CLASS (parent_class)->event (widget, event);
+      else
+	return FALSE;
+    }
+
+  event_widget = gtk_get_event_widget (event);
+
+  event_handled = FALSE;
+  switch (event->type)
+    {
+      GdkEventMask *event_mask;
+      GdkWindow *pointer_window;
+      
+    case  GDK_LEAVE_NOTIFY:
+      if (event_widget)
+	pointer_window = gdk_window_get_pointer (event_widget->window, NULL, NULL, NULL);
+      else
+	pointer_window = NULL;
+      event_widget = NULL;
+      if (pointer_window)
+	gdk_window_get_user_data (pointer_window, (gpointer*) &event_widget);
+      /* fall through */
+    case  GDK_ENTER_NOTIFY:
+      if (event_widget)
+	{
+	  event_mask = gtk_object_get_data (GTK_OBJECT (event_widget), key_event_mask);
+	  if (!event_mask)
+	    {
+	      event_mask = g_new (GdkEventMask, 1);
+	      *event_mask = gdk_window_get_events (event_widget->window);
+	      gtk_object_set_data (GTK_OBJECT (event_widget), key_event_mask, event_mask);
+	      gdk_window_set_events (event_widget->window,
+				     *event_mask |
+				     GDK_BUTTON_PRESS_MASK |
+				     GDK_BUTTON_RELEASE_MASK |
+				     GDK_ENTER_NOTIFY_MASK |
+				     GDK_LEAVE_NOTIFY_MASK);
+	      tips_query->event_restore_list =
+		g_slist_prepend (tips_query->event_restore_list, event_widget);
+	      gtk_widget_ref (event_widget);
+	    }
+	}
+      gtk_tips_query_emit_widget_entered (tips_query, event_widget);
+      event_handled = TRUE;
+      break;
+
+    case  GDK_BUTTON_PRESS:
+    case  GDK_BUTTON_RELEASE:
+      if (event_widget)
+	{
+	  if (event_widget == (GtkWidget*) tips_query ||
+	      event_widget == tips_query->caller)
+	    gtk_tips_query_stop_query (tips_query);
+	  else
+	    {
+	      gint stop;
+	      GtkTooltipsData *tdata;
+	      
+	      stop = TRUE;
+	      tdata = gtk_tooltips_data_get (event_widget);
+	      if (tdata || tips_query->emit_always)
+		gtk_signal_emit (GTK_OBJECT (tips_query),
+				 tips_query_signals[SIGNAL_WIDGET_SELECTED],
+				 event_widget,
+				 tdata ? tdata->tip_text : NULL,
+				 tdata ? tdata->tip_private : NULL,
+				 event,
+				 &stop);
+	      
+	      if (stop)
+		gtk_tips_query_stop_query (tips_query);
+	    }
+	}
+      event_handled = TRUE;
+      break;
+
+    default:
+      break;
+    }
+
+  return event_handled;
+}
diff --git a/gtk/gtktipsquery.h b/gtk/gtktipsquery.h
new file mode 100644
index 0000000000..06033c2ca4
--- /dev/null
+++ b/gtk/gtktipsquery.h
@@ -0,0 +1,97 @@
+/* GTK - The GIMP Toolkit
+ * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
+ *
+ * GtkQueryTips: Query onscreen widgets for their tooltips
+ * Copyright (C) 1998 Tim Janik
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+#ifndef __GTKTIPSQUERY_H__
+#define __GTKTIPSQUERY_H__
+
+
+#include <gtk/gtklabel.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#pragma }
+#endif /* __cplusplus */
+
+
+/* --- type macros --- */
+#define GTK_TIPS_QUERY(obj)		(GTK_CHECK_CAST (obj, gtk_tips_query_get_type (), GtkTipsQuery))
+#define GTK_TIPS_QUERY_CLASS(klass)	(GTK_CHECK_CLASS_CAST (klass, gtk_tips_query_get_type (), GtkTipsQueryClass))
+#define GTK_IS_TIPS_QUERY(obj)		(GTK_CHECK_TYPE (obj, gtk_tips_query_get_type ()))
+
+
+/* --- typedefs --- */
+typedef	struct	_GtkTipsQuery		GtkTipsQuery;
+typedef	struct	_GtkTipsQueryClass	GtkTipsQueryClass;
+
+
+/* --- structures --- */
+struct	_GtkTipsQuery
+{
+  GtkLabel	label;
+
+  guint		emit_always : 1;
+  guint		in_query : 1;
+  gchar		*label_inactive;
+  gchar		*label_no_tip;
+
+  GtkWidget	*caller;
+  GtkWidget	*last_crossed;
+  GSList	*event_restore_list;
+};
+
+struct	_GtkTipsQueryClass
+{
+  GtkLabelClass			parent_class;
+
+  void	(*start_query)		(GtkTipsQuery	*tips_query);
+  void	(*stop_query)		(GtkTipsQuery	*tips_query);
+  void	(*widget_entered)	(GtkTipsQuery	*tips_query,
+				 GtkWidget	*widget,
+				 const gchar	*tip_text,
+				 const gchar	*tip_private);
+  gint	(*widget_selected)	(GtkTipsQuery	*tips_query,
+				 GtkWidget	*widget,
+				 const gchar	*tip_text,
+				 const gchar	*tip_private,
+				 GdkEventButton	*event);
+};
+
+
+/* --- prototypes --- */
+GtkType		gtk_tips_query_get_type		(void);
+GtkWidget*	gtk_tips_query_new		(void);
+void		gtk_tips_query_start_query	(GtkTipsQuery	*tips_query);
+void		gtk_tips_query_stop_query	(GtkTipsQuery	*tips_query);
+void		gtk_tips_query_set_caller	(GtkTipsQuery	*tips_query,
+						 GtkWidget	*caller);
+void		gtk_tips_query_set_labels 	(GtkTipsQuery   *tips_query,
+						 const gchar    *label_inactive,
+						 const gchar    *label_no_tip);
+     
+
+
+#ifdef __cplusplus
+#pragma {
+}
+#endif /* __cplusplus */
+
+
+#endif	/* __GTKTIPSQUERY_H__ */
diff --git a/gtk/testgtk.c b/gtk/testgtk.c
index 7718b6c3ba..61fdb38a13 100644
--- a/gtk/testgtk.c
+++ b/gtk/testgtk.c
@@ -1038,19 +1038,47 @@ create_pixmap ()
     gtk_widget_destroy (window);
 }
 
+static gint
+tips_query_widget_selected (GtkObject      *object,
+			    GtkWidget      *widget,
+			    const gchar    *tip_text,
+			    const gchar    *tip_private,
+			    GdkEventButton *event,
+			    gpointer        func_data)
+{
+  if (widget)
+    g_print ("Help \"%s\" requested for <%s>\n",
+	     tip_private ? tip_private : "None",
+	     gtk_type_name (widget->object.klass->type));
+
+  return TRUE;
+}
+
 static void
 create_tooltips ()
 {
   static GtkWidget *window = NULL;
   GtkWidget *box1;
   GtkWidget *box2;
+  GtkWidget *box3;
   GtkWidget *button;
+  GtkWidget *frame;
+  GtkWidget *tips_query;
   GtkWidget *separator;
   GtkTooltips *tooltips;
 
   if (!window)
     {
-      window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+      window =
+	gtk_widget_new (gtk_window_get_type (),
+			"GtkWindow::type", GTK_WINDOW_TOPLEVEL,
+			"GtkContainer::border_width", 0,
+			"GtkWindow::title", "Tooltips",
+			"GtkWindow::allow_shrink", TRUE,
+			"GtkWindow::allow_grow", FALSE,
+			"GtkWindow::auto_shrink", TRUE,
+			"GtkWidget::width", 200,
+			NULL);
 
       gtk_signal_connect (GTK_OBJECT (window), "destroy",
                           GTK_SIGNAL_FUNC (destroy_tooltips),
@@ -1059,9 +1087,6 @@ create_tooltips ()
                           GTK_SIGNAL_FUNC (gtk_true),
                           &window);
 
-      gtk_window_set_title (GTK_WINDOW (window), "tooltips");
-      gtk_container_border_width (GTK_CONTAINER (window), 0);
-
       tooltips=gtk_tooltips_new();
       gtk_object_set_data (GTK_OBJECT (window), "tooltips", tooltips);
       
@@ -1080,19 +1105,64 @@ create_tooltips ()
       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
       gtk_widget_show (button);
 
-      gtk_tooltips_set_tips(tooltips,button,"This is button 1");
+      gtk_tooltips_set_tip (tooltips,button,"This is button 1", "ContextHelp/buttons/1");
 
       button = gtk_toggle_button_new_with_label ("button2");
       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
       gtk_widget_show (button);
 
-      gtk_tooltips_set_tips(tooltips,button,"This is button 2");
+      gtk_tooltips_set_tip (tooltips,button,"This is button 2", "ContextHelp/buttons/2");
 
       button = gtk_toggle_button_new_with_label ("button3");
       gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
       gtk_widget_show (button);
 
-      gtk_tooltips_set_tips (tooltips, button, "This is button 3. This is also a really long tooltip which probably won't fit on a single line and will therefore need to be wrapped. Hopefully the wrapping will work correctly.");
+      gtk_tooltips_set_tip (tooltips,
+			    button,
+			    "This is button 3. This is also a really long tooltip which probably won't fit on a single line and will therefore need to be wrapped. Hopefully the wrapping will work correctly.",
+			    "ContextHelp/buttons/3_long");
+
+      box3 =
+	gtk_widget_new (gtk_vbox_get_type (),
+			"GtkBox::homogeneous", FALSE,
+			"GtkBox::spacing", 5,
+			"GtkContainer::border_width", 5,
+			"GtkWidget::visible", TRUE,
+			NULL);
+
+      tips_query = gtk_tips_query_new ();
+
+      button =
+	gtk_widget_new (gtk_button_get_type (),
+			"GtkButton::label", "[?]",
+			"GtkWidget::visible", TRUE,
+			"GtkWidget::parent", box3,
+			"GtkObject::object_signal::clicked", gtk_tips_query_start_query, tips_query,
+			NULL);
+      gtk_box_set_child_packing (GTK_BOX (box3), button, FALSE, FALSE, 0, GTK_PACK_START);
+      gtk_tooltips_set_tip (tooltips,
+			    button,
+			    "Push this button to start the Tooltips Inspector",
+			    "ContextHelp/buttons/?");
+      
+      
+      gtk_widget_set (tips_query,
+		      "GtkWidget::visible", TRUE,
+		      "GtkWidget::parent", box3,
+		      "GtkTipsQuery::caller", button,
+		      "GtkObject::signal::widget_selected", tips_query_widget_selected, NULL,
+		      NULL);
+      
+      frame =
+	gtk_widget_new (gtk_frame_get_type (),
+			"GtkFrame::label", "ToolTips Inspector",
+			"GtkFrame::label_xalign", (double) 0.5,
+			"GtkContainer::border_width", 0,
+			"GtkWidget::visible", TRUE,
+			"GtkWidget::parent", box2,
+			"GtkContainer::child", box3,
+			NULL);
+      gtk_box_set_child_packing (GTK_BOX (box2), frame, TRUE, TRUE, 10, GTK_PACK_START);
 
       separator = gtk_hseparator_new ();
       gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
@@ -1114,7 +1184,7 @@ create_tooltips ()
       gtk_widget_grab_default (button);
       gtk_widget_show (button);
 
-      gtk_tooltips_set_tips (tooltips, button, "Push this button to close window");
+      gtk_tooltips_set_tip (tooltips, button, "Push this button to close window", "ContextHelp/buttons/Close");
     }
 
   if (!GTK_WIDGET_VISIBLE (window))
@@ -4260,6 +4330,7 @@ main (int argc, char *argv[])
   gtk_set_locale ();
 
   gtk_init (&argc, &argv);
+  /* gle_init (&argc, &argv); */
   gtk_rc_parse ("testgtkrc");
 
   create_main_window ();