forked from AuroraMiddleware/gtk
cab1dcb696
Make GdkEvents hold a single GdkDevice. This device is closer to the logical device conceptually, although it must be sufficient for device checks (i.e. GdkInputSource), which makes it similar to the physical devices. Make the logical devices have a more accurate GdkInputSource where needed, and conflate the event devices altogether.
1052 lines
29 KiB
C
1052 lines
29 KiB
C
/* gtktooltip.c
|
||
*
|
||
* Copyright (C) 2006-2007 Imendio AB
|
||
* Contact: Kristian Rietveld <kris@imendio.com>
|
||
*
|
||
* 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, see <http://www.gnu.org/licenses/>.
|
||
*/
|
||
|
||
#include "config.h"
|
||
|
||
#include "gtktooltip.h"
|
||
#include "gtktooltipprivate.h"
|
||
|
||
#include <math.h>
|
||
#include <string.h>
|
||
|
||
#include "gtkintl.h"
|
||
#include "gtkwindow.h"
|
||
#include "gtkmain.h"
|
||
#include "gtksettings.h"
|
||
#include "gtksizerequest.h"
|
||
#include "gtkstylecontext.h"
|
||
#include "gtktooltipwindowprivate.h"
|
||
#include "gtkwindowprivate.h"
|
||
#include "gtkwidgetprivate.h"
|
||
#include "gtknative.h"
|
||
|
||
/**
|
||
* SECTION:gtktooltip
|
||
* @Short_description: Add tips to your widgets
|
||
* @Title: GtkTooltip
|
||
*
|
||
* Basic tooltips can be realized simply by using gtk_widget_set_tooltip_text()
|
||
* or gtk_widget_set_tooltip_markup() without any explicit tooltip object.
|
||
*
|
||
* When you need a tooltip with a little more fancy contents, like adding an
|
||
* image, or you want the tooltip to have different contents per #GtkTreeView
|
||
* row or cell, you will have to do a little more work:
|
||
*
|
||
* - Set the #GtkWidget:has-tooltip property to %TRUE, this will make GTK+
|
||
* monitor the widget for motion and related events which are needed to
|
||
* determine when and where to show a tooltip.
|
||
*
|
||
* - Connect to the #GtkWidget::query-tooltip signal. This signal will be
|
||
* emitted when a tooltip is supposed to be shown. One of the arguments passed
|
||
* to the signal handler is a GtkTooltip object. This is the object that we
|
||
* are about to display as a tooltip, and can be manipulated in your callback
|
||
* using functions like gtk_tooltip_set_icon(). There are functions for setting
|
||
* the tooltip’s markup, setting an image from a named icon, or even putting in
|
||
* a custom widget.
|
||
*
|
||
* Return %TRUE from your query-tooltip handler. This causes the tooltip to be
|
||
* show. If you return %FALSE, it will not be shown.
|
||
*
|
||
* In the probably rare case where you want to have even more control over the
|
||
* tooltip that is about to be shown, you can set your own #GtkWindow which
|
||
* will be used as tooltip window. This works as follows:
|
||
*
|
||
* - Set #GtkWidget:has-tooltip and connect to #GtkWidget::query-tooltip as before.
|
||
* Use gtk_widget_set_tooltip_window() to set a #GtkWindow created by you as
|
||
* tooltip window.
|
||
*
|
||
* - In the #GtkWidget::query-tooltip callback you can access your window using
|
||
* gtk_widget_get_tooltip_window() and manipulate as you wish. The semantics of
|
||
* the return value are exactly as before, return %TRUE to show the window,
|
||
* %FALSE to not show it.
|
||
*/
|
||
|
||
|
||
#define HOVER_TIMEOUT 500
|
||
#define BROWSE_TIMEOUT 60
|
||
#define BROWSE_DISABLE_TIMEOUT 500
|
||
|
||
#define GTK_TOOLTIP_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_TOOLTIP, GtkTooltipClass))
|
||
#define GTK_IS_TOOLTIP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_TOOLTIP))
|
||
#define GTK_TOOLTIP_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_TOOLTIP, GtkTooltipClass))
|
||
|
||
/* We keep a single GtkTooltip object per display. The tooltip object
|
||
* owns a GtkTooltipWindow widget, which is using a popup surface, similar
|
||
* to what a GtkPopover does. It gets reparented to the right native widget
|
||
* whenever a tooltip is to be shown. The tooltip object keeps a weak
|
||
* ref on the native in order to remove the tooltip window when the
|
||
* native goes away.
|
||
*/
|
||
typedef struct _GtkTooltipClass GtkTooltipClass;
|
||
|
||
struct _GtkTooltip
|
||
{
|
||
GObject parent_instance;
|
||
|
||
GtkWidget *window;
|
||
|
||
GtkWidget *tooltip_widget;
|
||
|
||
GtkWidget *native;
|
||
|
||
guint timeout_id;
|
||
guint browse_mode_timeout_id;
|
||
|
||
GdkRectangle tip_area;
|
||
|
||
guint browse_mode_enabled : 1;
|
||
guint tip_area_set : 1;
|
||
guint custom_was_reset : 1;
|
||
};
|
||
|
||
struct _GtkTooltipClass
|
||
{
|
||
GObjectClass parent_class;
|
||
};
|
||
|
||
#define GTK_TOOLTIP_VISIBLE(tooltip) ((tooltip)->window && gtk_widget_get_visible (GTK_WIDGET((tooltip)->window)))
|
||
|
||
static void gtk_tooltip_dispose (GObject *object);
|
||
|
||
static void gtk_tooltip_window_hide (GtkWidget *widget,
|
||
gpointer user_data);
|
||
static void gtk_tooltip_display_closed (GdkDisplay *display,
|
||
gboolean was_error,
|
||
GtkTooltip *tooltip);
|
||
static void gtk_tooltip_set_surface (GtkTooltip *tooltip,
|
||
GdkSurface *surface);
|
||
|
||
static void gtk_tooltip_handle_event_internal (GdkEventType event_type,
|
||
GdkSurface *surface,
|
||
GtkWidget *target_widget,
|
||
double dx,
|
||
double dy);
|
||
|
||
static GQuark quark_current_tooltip;
|
||
|
||
G_DEFINE_TYPE (GtkTooltip, gtk_tooltip, G_TYPE_OBJECT);
|
||
|
||
static void
|
||
gtk_tooltip_class_init (GtkTooltipClass *klass)
|
||
{
|
||
GObjectClass *object_class;
|
||
|
||
quark_current_tooltip = g_quark_from_static_string ("gdk-display-current-tooltip");
|
||
|
||
object_class = G_OBJECT_CLASS (klass);
|
||
|
||
object_class->dispose = gtk_tooltip_dispose;
|
||
}
|
||
|
||
static void
|
||
gtk_tooltip_init (GtkTooltip *tooltip)
|
||
{
|
||
tooltip->timeout_id = 0;
|
||
tooltip->browse_mode_timeout_id = 0;
|
||
|
||
tooltip->browse_mode_enabled = FALSE;
|
||
|
||
tooltip->tooltip_widget = NULL;
|
||
|
||
tooltip->native = NULL;
|
||
|
||
tooltip->window = gtk_tooltip_window_new ();
|
||
g_object_ref_sink (tooltip->window);
|
||
g_signal_connect (tooltip->window, "hide",
|
||
G_CALLBACK (gtk_tooltip_window_hide),
|
||
tooltip);
|
||
}
|
||
|
||
static void
|
||
gtk_tooltip_dispose (GObject *object)
|
||
{
|
||
GtkTooltip *tooltip = GTK_TOOLTIP (object);
|
||
|
||
if (tooltip->timeout_id)
|
||
{
|
||
g_source_remove (tooltip->timeout_id);
|
||
tooltip->timeout_id = 0;
|
||
}
|
||
|
||
if (tooltip->browse_mode_timeout_id)
|
||
{
|
||
g_source_remove (tooltip->browse_mode_timeout_id);
|
||
tooltip->browse_mode_timeout_id = 0;
|
||
}
|
||
|
||
gtk_tooltip_set_custom (tooltip, NULL);
|
||
gtk_tooltip_set_surface (tooltip, NULL);
|
||
|
||
if (tooltip->window)
|
||
{
|
||
GdkDisplay *display;
|
||
|
||
display = gtk_widget_get_display (tooltip->window);
|
||
g_signal_handlers_disconnect_by_func (display,
|
||
gtk_tooltip_display_closed,
|
||
tooltip);
|
||
gtk_tooltip_window_set_relative_to (GTK_TOOLTIP_WINDOW (tooltip->window), NULL);
|
||
g_clear_object (&tooltip->window);
|
||
}
|
||
|
||
G_OBJECT_CLASS (gtk_tooltip_parent_class)->dispose (object);
|
||
}
|
||
|
||
/* public API */
|
||
|
||
/**
|
||
* gtk_tooltip_set_markup:
|
||
* @tooltip: a #GtkTooltip
|
||
* @markup: (allow-none): a markup string (see [Pango markup format][PangoMarkupFormat]) or %NULL
|
||
*
|
||
* Sets the text of the tooltip to be @markup, which is marked up
|
||
* with the [Pango text markup language][PangoMarkupFormat].
|
||
* If @markup is %NULL, the label will be hidden.
|
||
*/
|
||
void
|
||
gtk_tooltip_set_markup (GtkTooltip *tooltip,
|
||
const char *markup)
|
||
{
|
||
g_return_if_fail (GTK_IS_TOOLTIP (tooltip));
|
||
|
||
gtk_tooltip_window_set_label_markup (GTK_TOOLTIP_WINDOW (tooltip->window), markup);
|
||
}
|
||
|
||
/**
|
||
* gtk_tooltip_set_text:
|
||
* @tooltip: a #GtkTooltip
|
||
* @text: (allow-none): a text string or %NULL
|
||
*
|
||
* Sets the text of the tooltip to be @text. If @text is %NULL, the label
|
||
* will be hidden. See also gtk_tooltip_set_markup().
|
||
*/
|
||
void
|
||
gtk_tooltip_set_text (GtkTooltip *tooltip,
|
||
const char *text)
|
||
{
|
||
g_return_if_fail (GTK_IS_TOOLTIP (tooltip));
|
||
|
||
gtk_tooltip_window_set_label_text (GTK_TOOLTIP_WINDOW (tooltip->window), text);
|
||
}
|
||
|
||
/**
|
||
* gtk_tooltip_set_icon:
|
||
* @tooltip: a #GtkTooltip
|
||
* @paintable: (allow-none): a #GdkPaintable, or %NULL
|
||
*
|
||
* Sets the icon of the tooltip (which is in front of the text) to be
|
||
* @paintable. If @paintable is %NULL, the image will be hidden.
|
||
*/
|
||
void
|
||
gtk_tooltip_set_icon (GtkTooltip *tooltip,
|
||
GdkPaintable *paintable)
|
||
{
|
||
g_return_if_fail (GTK_IS_TOOLTIP (tooltip));
|
||
g_return_if_fail (paintable == NULL || GDK_IS_PAINTABLE (paintable));
|
||
|
||
gtk_tooltip_window_set_image_icon (GTK_TOOLTIP_WINDOW (tooltip->window), paintable);
|
||
}
|
||
|
||
/**
|
||
* gtk_tooltip_set_icon_from_icon_name:
|
||
* @tooltip: a #GtkTooltip
|
||
* @icon_name: (allow-none): an icon name, or %NULL
|
||
*
|
||
* Sets the icon of the tooltip (which is in front of the text) to be
|
||
* the icon indicated by @icon_name with the size indicated
|
||
* by @size. If @icon_name is %NULL, the image will be hidden.
|
||
*/
|
||
void
|
||
gtk_tooltip_set_icon_from_icon_name (GtkTooltip *tooltip,
|
||
const char *icon_name)
|
||
{
|
||
g_return_if_fail (GTK_IS_TOOLTIP (tooltip));
|
||
|
||
gtk_tooltip_window_set_image_icon_from_name (GTK_TOOLTIP_WINDOW (tooltip->window),
|
||
icon_name);
|
||
}
|
||
|
||
/**
|
||
* gtk_tooltip_set_icon_from_gicon:
|
||
* @tooltip: a #GtkTooltip
|
||
* @gicon: (allow-none): a #GIcon representing the icon, or %NULL
|
||
*
|
||
* Sets the icon of the tooltip (which is in front of the text)
|
||
* to be the icon indicated by @gicon with the size indicated
|
||
* by @size. If @gicon is %NULL, the image will be hidden.
|
||
*/
|
||
void
|
||
gtk_tooltip_set_icon_from_gicon (GtkTooltip *tooltip,
|
||
GIcon *gicon)
|
||
{
|
||
g_return_if_fail (GTK_IS_TOOLTIP (tooltip));
|
||
|
||
gtk_tooltip_window_set_image_icon_from_gicon (GTK_TOOLTIP_WINDOW (tooltip->window),
|
||
gicon);
|
||
}
|
||
|
||
/**
|
||
* gtk_tooltip_set_custom:
|
||
* @tooltip: a #GtkTooltip
|
||
* @custom_widget: (allow-none): a #GtkWidget, or %NULL to unset the old custom widget.
|
||
*
|
||
* Replaces the widget packed into the tooltip with
|
||
* @custom_widget. @custom_widget does not get destroyed when the tooltip goes
|
||
* away.
|
||
* By default a box with a #GtkImage and #GtkLabel is embedded in
|
||
* the tooltip, which can be configured using gtk_tooltip_set_markup()
|
||
* and gtk_tooltip_set_icon().
|
||
*/
|
||
void
|
||
gtk_tooltip_set_custom (GtkTooltip *tooltip,
|
||
GtkWidget *custom_widget)
|
||
{
|
||
g_return_if_fail (GTK_IS_TOOLTIP (tooltip));
|
||
g_return_if_fail (custom_widget == NULL || GTK_IS_WIDGET (custom_widget));
|
||
|
||
/* The custom widget has been updated from the query-tooltip
|
||
* callback, so we do not want to reset the custom widget later on.
|
||
*/
|
||
tooltip->custom_was_reset = TRUE;
|
||
|
||
gtk_tooltip_window_set_custom_widget (GTK_TOOLTIP_WINDOW (tooltip->window), custom_widget);
|
||
}
|
||
|
||
/**
|
||
* gtk_tooltip_set_tip_area:
|
||
* @tooltip: a #GtkTooltip
|
||
* @rect: a #GdkRectangle
|
||
*
|
||
* Sets the area of the widget, where the contents of this tooltip apply,
|
||
* to be @rect (in widget coordinates). This is especially useful for
|
||
* properly setting tooltips on #GtkTreeView rows and cells, #GtkIconViews,
|
||
* etc.
|
||
*
|
||
* For setting tooltips on #GtkTreeView, please refer to the convenience
|
||
* functions for this: gtk_tree_view_set_tooltip_row() and
|
||
* gtk_tree_view_set_tooltip_cell().
|
||
*/
|
||
void
|
||
gtk_tooltip_set_tip_area (GtkTooltip *tooltip,
|
||
const GdkRectangle *rect)
|
||
{
|
||
g_return_if_fail (GTK_IS_TOOLTIP (tooltip));
|
||
|
||
if (!rect)
|
||
tooltip->tip_area_set = FALSE;
|
||
else
|
||
{
|
||
tooltip->tip_area_set = TRUE;
|
||
tooltip->tip_area = *rect;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* gtk_tooltip_trigger_tooltip_query:
|
||
* @display: a #GdkDisplay
|
||
*
|
||
* Triggers a new tooltip query on @display, in order to update the current
|
||
* visible tooltip, or to show/hide the current tooltip. This function is
|
||
* useful to call when, for example, the state of the widget changed by a
|
||
* key press.
|
||
*/
|
||
void
|
||
gtk_tooltip_trigger_tooltip_query (GtkWidget *widget)
|
||
{
|
||
GdkDisplay *display;
|
||
GdkSeat *seat;
|
||
GdkDevice *device;
|
||
GdkSurface *surface;
|
||
double x, y;
|
||
GtkWidget *toplevel;
|
||
|
||
g_return_if_fail (GTK_IS_WIDGET (widget));
|
||
|
||
display = gtk_widget_get_display (widget);
|
||
|
||
/* Trigger logic as if the mouse moved */
|
||
seat = gdk_display_get_default_seat (display);
|
||
if (seat)
|
||
device = gdk_seat_get_pointer (seat);
|
||
else
|
||
device = NULL;
|
||
if (device)
|
||
surface = gdk_device_get_surface_at_position (device, &x, &y);
|
||
else
|
||
surface = NULL;
|
||
if (!surface)
|
||
return;
|
||
|
||
toplevel = GTK_WIDGET (gtk_widget_get_root (widget));
|
||
|
||
if (toplevel == NULL)
|
||
return;
|
||
|
||
if (gtk_native_get_surface (GTK_NATIVE (toplevel)) != surface)
|
||
return;
|
||
|
||
gtk_widget_translate_coordinates (toplevel, widget, x, y, &x, &y);
|
||
|
||
gtk_tooltip_handle_event_internal (GDK_MOTION_NOTIFY, surface, widget, x, y);
|
||
}
|
||
|
||
static void
|
||
gtk_tooltip_window_hide (GtkWidget *widget,
|
||
gpointer user_data)
|
||
{
|
||
GtkTooltip *tooltip = GTK_TOOLTIP (user_data);
|
||
|
||
gtk_tooltip_set_custom (tooltip, NULL);
|
||
}
|
||
|
||
GtkWidget *
|
||
_gtk_widget_find_at_coords (GdkSurface *surface,
|
||
int surface_x,
|
||
int surface_y,
|
||
int *widget_x,
|
||
int *widget_y)
|
||
{
|
||
GtkWidget *event_widget;
|
||
GtkWidget *picked_widget;
|
||
double x, y;
|
||
double native_x, native_y;
|
||
|
||
g_return_val_if_fail (GDK_IS_SURFACE (surface), NULL);
|
||
|
||
event_widget = gtk_native_get_for_surface (surface);
|
||
|
||
if (!event_widget)
|
||
return NULL;
|
||
|
||
gtk_native_get_surface_transform (GTK_NATIVE (event_widget), &native_x, &native_y);
|
||
x = surface_x - native_x;
|
||
y = surface_y - native_y;
|
||
|
||
picked_widget = gtk_widget_pick (event_widget, x, y, GTK_PICK_INSENSITIVE);
|
||
|
||
if (picked_widget != NULL)
|
||
gtk_widget_translate_coordinates (event_widget, picked_widget, x, y, &x, &y);
|
||
|
||
*widget_x = x;
|
||
*widget_y = y;
|
||
|
||
return picked_widget;
|
||
}
|
||
|
||
static int
|
||
tooltip_browse_mode_expired (gpointer data)
|
||
{
|
||
GtkTooltip *tooltip;
|
||
GdkDisplay *display;
|
||
|
||
tooltip = GTK_TOOLTIP (data);
|
||
|
||
tooltip->browse_mode_enabled = FALSE;
|
||
tooltip->browse_mode_timeout_id = 0;
|
||
|
||
if (tooltip->timeout_id)
|
||
{
|
||
g_source_remove (tooltip->timeout_id);
|
||
tooltip->timeout_id = 0;
|
||
}
|
||
|
||
/* destroy tooltip */
|
||
display = gtk_widget_get_display (tooltip->window);
|
||
g_object_set_qdata (G_OBJECT (display), quark_current_tooltip, NULL);
|
||
|
||
return FALSE;
|
||
}
|
||
|
||
static void
|
||
gtk_tooltip_display_closed (GdkDisplay *display,
|
||
gboolean was_error,
|
||
GtkTooltip *tooltip)
|
||
{
|
||
if (tooltip->timeout_id)
|
||
{
|
||
g_source_remove (tooltip->timeout_id);
|
||
tooltip->timeout_id = 0;
|
||
}
|
||
|
||
g_object_set_qdata (G_OBJECT (display), quark_current_tooltip, NULL);
|
||
}
|
||
|
||
static void
|
||
native_weak_notify (gpointer data, GObject *former_object)
|
||
{
|
||
GtkTooltip *tooltip = data;
|
||
|
||
gtk_tooltip_window_set_relative_to (GTK_TOOLTIP_WINDOW (tooltip->window), NULL);
|
||
tooltip->native = NULL;
|
||
}
|
||
|
||
static void
|
||
gtk_tooltip_set_surface (GtkTooltip *tooltip,
|
||
GdkSurface *surface)
|
||
{
|
||
GtkWidget *native;
|
||
|
||
if (surface)
|
||
native = gtk_native_get_for_surface (surface);
|
||
else
|
||
native = NULL;
|
||
|
||
if (tooltip->native == native)
|
||
return;
|
||
|
||
if (GTK_IS_TOOLTIP_WINDOW (native))
|
||
return;
|
||
|
||
if (tooltip->native)
|
||
g_object_weak_unref (G_OBJECT (tooltip->native), native_weak_notify, tooltip);
|
||
|
||
tooltip->native = native;
|
||
|
||
if (tooltip->native)
|
||
g_object_weak_ref (G_OBJECT (tooltip->native), native_weak_notify, tooltip);
|
||
|
||
if (native)
|
||
gtk_tooltip_window_set_relative_to (GTK_TOOLTIP_WINDOW (tooltip->window), native);
|
||
else
|
||
gtk_tooltip_window_set_relative_to (GTK_TOOLTIP_WINDOW (tooltip->window), NULL);
|
||
}
|
||
|
||
static gboolean
|
||
gtk_tooltip_run_requery (GtkWidget **widget,
|
||
GtkTooltip *tooltip,
|
||
int *x,
|
||
int *y)
|
||
{
|
||
gboolean has_tooltip = FALSE;
|
||
gboolean return_value = FALSE;
|
||
|
||
/* Reset tooltip */
|
||
gtk_tooltip_set_markup (tooltip, NULL);
|
||
gtk_tooltip_set_icon (tooltip, NULL);
|
||
gtk_tooltip_set_tip_area (tooltip, NULL);
|
||
|
||
/* See if the custom widget is again set from the query-tooltip
|
||
* callback.
|
||
*/
|
||
tooltip->custom_was_reset = FALSE;
|
||
|
||
do
|
||
{
|
||
has_tooltip = gtk_widget_get_has_tooltip (*widget);
|
||
|
||
if (has_tooltip)
|
||
return_value = gtk_widget_query_tooltip (*widget, *x, *y, FALSE, tooltip);
|
||
|
||
if (!return_value)
|
||
{
|
||
GtkWidget *parent = gtk_widget_get_parent (*widget);
|
||
|
||
if (parent)
|
||
{
|
||
double xx = *x;
|
||
double yy = *y;
|
||
|
||
gtk_widget_translate_coordinates (*widget, parent, xx, yy, &xx, &yy);
|
||
|
||
*x = xx;
|
||
*y = yy;
|
||
}
|
||
|
||
*widget = parent;
|
||
}
|
||
else
|
||
break;
|
||
}
|
||
while (*widget);
|
||
|
||
/* If the custom widget was not reset in the query-tooltip
|
||
* callback, we clear it here.
|
||
*/
|
||
if (!tooltip->custom_was_reset)
|
||
gtk_tooltip_set_custom (tooltip, NULL);
|
||
|
||
return return_value;
|
||
}
|
||
|
||
static void
|
||
gtk_tooltip_position (GtkTooltip *tooltip,
|
||
GdkDisplay *display,
|
||
GtkWidget *new_tooltip_widget,
|
||
GdkDevice *device)
|
||
{
|
||
GtkSettings *settings;
|
||
graphene_rect_t anchor_bounds;
|
||
GdkRectangle anchor_rect;
|
||
GdkSurface *effective_toplevel;
|
||
GtkWidget *toplevel;
|
||
int rect_anchor_dx = 0;
|
||
int cursor_size;
|
||
int anchor_rect_padding;
|
||
double native_x, native_y;
|
||
|
||
gtk_widget_realize (GTK_WIDGET (tooltip->window));
|
||
|
||
tooltip->tooltip_widget = new_tooltip_widget;
|
||
|
||
toplevel = GTK_WIDGET (gtk_widget_get_native (new_tooltip_widget));
|
||
gtk_native_get_surface_transform (GTK_NATIVE (toplevel), &native_x, &native_y);
|
||
|
||
if (gtk_widget_compute_bounds (new_tooltip_widget, toplevel, &anchor_bounds))
|
||
{
|
||
anchor_rect = (GdkRectangle) {
|
||
floorf (anchor_bounds.origin.x + native_x),
|
||
floorf (anchor_bounds.origin.y + native_y),
|
||
ceilf (anchor_bounds.size.width),
|
||
ceilf (anchor_bounds.size.height)
|
||
};
|
||
}
|
||
else
|
||
{
|
||
anchor_rect = (GdkRectangle) { 0, 0, 0, 0 };
|
||
}
|
||
|
||
settings = gtk_settings_get_for_display (display);
|
||
g_object_get (settings,
|
||
"gtk-cursor-theme-size", &cursor_size,
|
||
NULL);
|
||
|
||
if (cursor_size == 0)
|
||
cursor_size = 16;
|
||
|
||
if (device)
|
||
anchor_rect_padding = MAX (4, cursor_size - 32);
|
||
else
|
||
anchor_rect_padding = 4;
|
||
|
||
anchor_rect.x -= anchor_rect_padding;
|
||
anchor_rect.y -= anchor_rect_padding;
|
||
anchor_rect.width += anchor_rect_padding * 2;
|
||
anchor_rect.height += anchor_rect_padding * 2;
|
||
|
||
if (device)
|
||
{
|
||
const int max_x_distance = 32;
|
||
/* Max 48x48 icon + default padding */
|
||
const int max_anchor_rect_height = 48 + 8;
|
||
double px, py;
|
||
int pointer_x, pointer_y;
|
||
|
||
/*
|
||
* For pointer position triggered tooltips, implement the following
|
||
* semantics:
|
||
*
|
||
* If the anchor rectangle is too tall (meaning if we'd be constrained
|
||
* and flip, it'd flip too far away), rely only on the pointer position
|
||
* to position the tooltip. The approximate pointer cursorrectangle is
|
||
* used as an anchor rectangle.
|
||
*
|
||
* If the anchor rectangle isn't to tall, make sure the tooltip isn't too
|
||
* far away from the pointer position.
|
||
*/
|
||
effective_toplevel = gtk_native_get_surface (GTK_NATIVE (toplevel));
|
||
gdk_surface_get_device_position (effective_toplevel, device, &px, &py, NULL);
|
||
pointer_x = round (px);
|
||
pointer_y = round (py);
|
||
|
||
if (anchor_rect.height > max_anchor_rect_height)
|
||
{
|
||
anchor_rect.x = pointer_x - 4;
|
||
anchor_rect.y = pointer_y - 4;
|
||
anchor_rect.width = cursor_size;
|
||
anchor_rect.height = cursor_size;
|
||
}
|
||
else
|
||
{
|
||
int anchor_point_x;
|
||
int x_distance;
|
||
|
||
anchor_point_x = anchor_rect.x + anchor_rect.width / 2;
|
||
x_distance = pointer_x - anchor_point_x;
|
||
|
||
if (x_distance > max_x_distance)
|
||
rect_anchor_dx = x_distance - max_x_distance;
|
||
else if (x_distance < -max_x_distance)
|
||
rect_anchor_dx = x_distance + max_x_distance;
|
||
}
|
||
}
|
||
|
||
gtk_tooltip_window_position (GTK_TOOLTIP_WINDOW (tooltip->window),
|
||
&anchor_rect,
|
||
GDK_GRAVITY_SOUTH,
|
||
GDK_GRAVITY_NORTH,
|
||
GDK_ANCHOR_FLIP_Y | GDK_ANCHOR_SLIDE_X,
|
||
rect_anchor_dx, 0);
|
||
}
|
||
|
||
static void
|
||
gtk_tooltip_show_tooltip (GdkDisplay *display)
|
||
{
|
||
double px, py;
|
||
int x, y;
|
||
GdkSurface *surface;
|
||
GtkWidget *tooltip_widget;
|
||
GdkSeat *seat;
|
||
GdkDevice *device;
|
||
GtkTooltip *tooltip;
|
||
gboolean return_value = FALSE;
|
||
|
||
tooltip = g_object_get_qdata (G_OBJECT (display), quark_current_tooltip);
|
||
|
||
if (!tooltip->native)
|
||
return;
|
||
|
||
surface = gtk_native_get_surface (GTK_NATIVE (tooltip->native));
|
||
|
||
seat = gdk_display_get_default_seat (display);
|
||
if (seat)
|
||
device = gdk_seat_get_pointer (seat);
|
||
else
|
||
device = NULL;
|
||
|
||
if (device)
|
||
gdk_surface_get_device_position (surface, device, &px, &py, NULL);
|
||
else
|
||
px = py = 0;
|
||
|
||
x = round (px);
|
||
y = round (py);
|
||
|
||
tooltip_widget = _gtk_widget_find_at_coords (surface, x, y, &x, &y);
|
||
|
||
if (!tooltip_widget)
|
||
return;
|
||
|
||
return_value = gtk_tooltip_run_requery (&tooltip_widget, tooltip, &x, &y);
|
||
if (!return_value)
|
||
return;
|
||
|
||
/* FIXME: should use tooltip->window iso tooltip->window */
|
||
if (display != gtk_widget_get_display (tooltip->window))
|
||
{
|
||
g_signal_handlers_disconnect_by_func (display,
|
||
gtk_tooltip_display_closed,
|
||
tooltip);
|
||
|
||
gtk_window_set_display (GTK_WINDOW (tooltip->window), display);
|
||
|
||
g_signal_connect (display, "closed",
|
||
G_CALLBACK (gtk_tooltip_display_closed), tooltip);
|
||
}
|
||
|
||
gtk_tooltip_position (tooltip, display, tooltip_widget, device);
|
||
|
||
gtk_widget_show (GTK_WIDGET (tooltip->window));
|
||
|
||
/* Now a tooltip is visible again on the display, make sure browse
|
||
* mode is enabled.
|
||
*/
|
||
tooltip->browse_mode_enabled = TRUE;
|
||
if (tooltip->browse_mode_timeout_id)
|
||
{
|
||
g_source_remove (tooltip->browse_mode_timeout_id);
|
||
tooltip->browse_mode_timeout_id = 0;
|
||
}
|
||
}
|
||
|
||
static void
|
||
gtk_tooltip_hide_tooltip (GtkTooltip *tooltip)
|
||
{
|
||
guint timeout = BROWSE_DISABLE_TIMEOUT;
|
||
|
||
if (!tooltip)
|
||
return;
|
||
|
||
if (tooltip->timeout_id)
|
||
{
|
||
g_source_remove (tooltip->timeout_id);
|
||
tooltip->timeout_id = 0;
|
||
}
|
||
|
||
if (!GTK_TOOLTIP_VISIBLE (tooltip))
|
||
return;
|
||
|
||
tooltip->tooltip_widget = NULL;
|
||
|
||
/* The tooltip is gone, after (by default, should be configurable) 500ms
|
||
* we want to turn off browse mode
|
||
*/
|
||
if (!tooltip->browse_mode_timeout_id)
|
||
{
|
||
tooltip->browse_mode_timeout_id =
|
||
g_timeout_add_full (0, timeout,
|
||
tooltip_browse_mode_expired,
|
||
g_object_ref (tooltip),
|
||
g_object_unref);
|
||
g_source_set_name_by_id (tooltip->browse_mode_timeout_id, "[gtk] tooltip_browse_mode_expired");
|
||
}
|
||
|
||
if (tooltip->window)
|
||
gtk_widget_hide (tooltip->window);
|
||
}
|
||
|
||
static int
|
||
tooltip_popup_timeout (gpointer data)
|
||
{
|
||
GdkDisplay *display;
|
||
GtkTooltip *tooltip;
|
||
|
||
display = GDK_DISPLAY (data);
|
||
tooltip = g_object_get_qdata (G_OBJECT (display), quark_current_tooltip);
|
||
|
||
/* This usually does not happen. However, it does occur in language
|
||
* bindings were reference counting of objects behaves differently.
|
||
*/
|
||
if (!tooltip)
|
||
return FALSE;
|
||
|
||
gtk_tooltip_show_tooltip (display);
|
||
|
||
tooltip->timeout_id = 0;
|
||
|
||
return FALSE;
|
||
}
|
||
|
||
static void
|
||
gtk_tooltip_start_delay (GdkDisplay *display)
|
||
{
|
||
guint timeout;
|
||
GtkTooltip *tooltip;
|
||
|
||
tooltip = g_object_get_qdata (G_OBJECT (display), quark_current_tooltip);
|
||
|
||
if (!tooltip || GTK_TOOLTIP_VISIBLE (tooltip))
|
||
return;
|
||
|
||
if (tooltip->timeout_id)
|
||
g_source_remove (tooltip->timeout_id);
|
||
|
||
if (tooltip->browse_mode_enabled)
|
||
timeout = BROWSE_TIMEOUT;
|
||
else
|
||
timeout = HOVER_TIMEOUT;
|
||
|
||
tooltip->timeout_id = g_timeout_add_full (0, timeout,
|
||
tooltip_popup_timeout,
|
||
g_object_ref (display),
|
||
g_object_unref);
|
||
g_source_set_name_by_id (tooltip->timeout_id, "[gtk] tooltip_popup_timeout");
|
||
}
|
||
|
||
void
|
||
_gtk_tooltip_hide (GtkWidget *widget)
|
||
{
|
||
GdkDisplay *display;
|
||
GtkTooltip *tooltip;
|
||
|
||
display = gtk_widget_get_display (widget);
|
||
tooltip = g_object_get_qdata (G_OBJECT (display), quark_current_tooltip);
|
||
|
||
if (!tooltip || !tooltip->window || !tooltip->tooltip_widget)
|
||
return;
|
||
|
||
if (widget == tooltip->tooltip_widget)
|
||
gtk_tooltip_hide_tooltip (tooltip);
|
||
}
|
||
|
||
static gboolean
|
||
tooltips_enabled (GdkEvent *event)
|
||
{
|
||
GdkDevice *source_device;
|
||
GdkInputSource source;
|
||
GdkModifierType event_state = 0;
|
||
|
||
switch ((guint)gdk_event_get_event_type (event))
|
||
{
|
||
case GDK_ENTER_NOTIFY:
|
||
case GDK_LEAVE_NOTIFY:
|
||
case GDK_BUTTON_PRESS:
|
||
case GDK_KEY_PRESS:
|
||
case GDK_DRAG_ENTER:
|
||
case GDK_GRAB_BROKEN:
|
||
case GDK_MOTION_NOTIFY:
|
||
case GDK_TOUCH_UPDATE:
|
||
case GDK_SCROLL:
|
||
break; /* OK */
|
||
|
||
default:
|
||
return FALSE;
|
||
}
|
||
|
||
event_state = gdk_event_get_modifier_state (event);
|
||
if ((event_state &
|
||
(GDK_BUTTON1_MASK |
|
||
GDK_BUTTON2_MASK |
|
||
GDK_BUTTON3_MASK |
|
||
GDK_BUTTON4_MASK |
|
||
GDK_BUTTON5_MASK)) != 0)
|
||
return FALSE;
|
||
|
||
source_device = gdk_event_get_device (event);
|
||
|
||
if (!source_device)
|
||
return FALSE;
|
||
|
||
source = gdk_device_get_source (source_device);
|
||
|
||
if (source != GDK_SOURCE_TOUCHSCREEN)
|
||
return TRUE;
|
||
|
||
return FALSE;
|
||
}
|
||
|
||
void
|
||
_gtk_tooltip_handle_event (GtkWidget *target,
|
||
GdkEvent *event)
|
||
{
|
||
GdkEventType event_type;
|
||
GdkSurface *surface;
|
||
double x, y;
|
||
double nx, ny;
|
||
GtkNative *native;
|
||
|
||
if (!tooltips_enabled (event))
|
||
return;
|
||
|
||
native = gtk_widget_get_native (target);
|
||
if (!native)
|
||
return;
|
||
|
||
event_type = gdk_event_get_event_type (event);
|
||
surface = gdk_event_get_surface (event);
|
||
gdk_event_get_position (event, &x, &y);
|
||
|
||
gtk_native_get_surface_transform (native, &nx, &ny);
|
||
gtk_widget_translate_coordinates (GTK_WIDGET (native), target, x - nx, y - ny, &x, &y);
|
||
gtk_tooltip_handle_event_internal (event_type, surface, target, x, y);
|
||
}
|
||
|
||
/* dx/dy must be in @target_widget's coordinates */
|
||
static void
|
||
gtk_tooltip_handle_event_internal (GdkEventType event_type,
|
||
GdkSurface *surface,
|
||
GtkWidget *target_widget,
|
||
double dx,
|
||
double dy)
|
||
{
|
||
int x = dx, y = dy;
|
||
GdkDisplay *display;
|
||
GtkTooltip *tooltip;
|
||
|
||
display = gdk_surface_get_display (surface);
|
||
tooltip = g_object_get_qdata (G_OBJECT (display), quark_current_tooltip);
|
||
|
||
if (tooltip)
|
||
gtk_tooltip_set_surface (tooltip, surface);
|
||
|
||
/* Hide the tooltip when there's no new tooltip widget */
|
||
if (!target_widget)
|
||
{
|
||
if (tooltip)
|
||
gtk_tooltip_hide_tooltip (tooltip);
|
||
|
||
return;
|
||
}
|
||
|
||
switch ((guint) event_type)
|
||
{
|
||
case GDK_BUTTON_PRESS:
|
||
case GDK_KEY_PRESS:
|
||
case GDK_DRAG_ENTER:
|
||
case GDK_GRAB_BROKEN:
|
||
case GDK_SCROLL:
|
||
gtk_tooltip_hide_tooltip (tooltip);
|
||
break;
|
||
|
||
case GDK_MOTION_NOTIFY:
|
||
case GDK_ENTER_NOTIFY:
|
||
case GDK_LEAVE_NOTIFY:
|
||
if (tooltip)
|
||
{
|
||
gboolean tip_area_set;
|
||
GdkRectangle tip_area;
|
||
gboolean hide_tooltip;
|
||
|
||
tip_area_set = tooltip->tip_area_set;
|
||
tip_area = tooltip->tip_area;
|
||
|
||
gtk_tooltip_run_requery (&target_widget, tooltip, &x, &y);
|
||
|
||
/* Leave notify should override the query function */
|
||
hide_tooltip = (event_type == GDK_LEAVE_NOTIFY);
|
||
|
||
/* Is the pointer above another widget now? */
|
||
if (GTK_TOOLTIP_VISIBLE (tooltip))
|
||
hide_tooltip |= target_widget != tooltip->tooltip_widget;
|
||
|
||
/* Did the pointer move out of the previous "context area"? */
|
||
if (tip_area_set)
|
||
hide_tooltip |= !gdk_rectangle_contains_point (&tip_area, x, y);
|
||
|
||
if (hide_tooltip)
|
||
gtk_tooltip_hide_tooltip (tooltip);
|
||
else
|
||
gtk_tooltip_start_delay (display);
|
||
}
|
||
else
|
||
{
|
||
/* Need a new tooltip for this display */
|
||
tooltip = g_object_new (GTK_TYPE_TOOLTIP, NULL);
|
||
g_object_set_qdata_full (G_OBJECT (display), quark_current_tooltip,
|
||
tooltip, g_object_unref);
|
||
g_signal_connect (display, "closed",
|
||
G_CALLBACK (gtk_tooltip_display_closed), tooltip);
|
||
|
||
gtk_tooltip_set_surface (tooltip, surface);
|
||
|
||
gtk_tooltip_start_delay (display);
|
||
}
|
||
break;
|
||
|
||
default:
|
||
break;
|
||
}
|
||
}
|
||
|
||
void
|
||
gtk_tooltip_maybe_allocate (GtkNative *native)
|
||
{
|
||
GdkDisplay *display = gtk_widget_get_display (GTK_WIDGET (native));
|
||
GtkTooltip *tooltip;
|
||
|
||
tooltip = g_object_get_qdata (G_OBJECT (display), quark_current_tooltip);
|
||
if (!tooltip || GTK_NATIVE (tooltip->native) != native)
|
||
return;
|
||
|
||
gtk_native_check_resize (GTK_NATIVE (tooltip->window));
|
||
}
|
||
|
||
void
|
||
gtk_tooltip_unset_surface (GtkNative *native)
|
||
{
|
||
GdkDisplay *display = gtk_widget_get_display (GTK_WIDGET (native));
|
||
GtkTooltip *tooltip;
|
||
|
||
tooltip = g_object_get_qdata (G_OBJECT (display), quark_current_tooltip);
|
||
if (!tooltip || GTK_NATIVE (tooltip->native) != native)
|
||
return;
|
||
|
||
gtk_tooltip_set_surface (tooltip, NULL);
|
||
}
|
||
|