AuroraMiddleware/gtk2
1
0
Fork 0
forked from AuroraMiddleware/gtk
Code Issues Pull Requests Projects Releases Wiki Activity
2a11f5f889
gtk2/gtk/gtktooltipwindow.c

601 lines
17 KiB
C
Raw Normal View History

Add GtkTooltipWindow private sub-class GtkTooltip does a lot of set up on the GtkWindow it uses internally. We should move that code to a separate class to keep it contained.
2015-11-08 15:46:23 +00:00
/* GTK - The GIMP Toolkit
* Copyright 2015 Emmanuele Bassi
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*/
/*
* Modified by the GTK+ Team and others 1997-2000. See the AUTHORS
* file for a list of people on the GTK+ Team. See the ChangeLog
* files for a list of changes. These files are distributed with
* GTK+ at ftp://ftp.gtk.org/pub/gtk/.
*/
#include "config.h"
#include "gtktooltipwindowprivate.h"
#include "gtkprivate.h"
Use CSS node name for GtkTooltipWindow Instead of a style class.
2015-11-08 17:10:00 +00:00
#include "gtkintl.h"
Add GtkTooltipWindow private sub-class GtkTooltip does a lot of set up on the GtkWindow it uses internally. We should move that code to a separate class to keep it contained.
2015-11-08 15:46:23 +00:00
#include "gtkaccessible.h"
#include "gtkbox.h"
#include "gtkimage.h"
#include "gtklabel.h"
#include "gtkmain.h"
#include "gtksettings.h"
#include "gtksizerequest.h"
#include "gtkwindowprivate.h"
Use CSS node name for GtkTooltipWindow Instead of a style class.
2015-11-08 17:10:00 +00:00
#include "gtkwidgetprivate.h"
tooltips: Stop using GTK_WINDOW_POPUP Make GtkTooltipWindow a GtkNative implementation, instead of using a GTK_WINDOW_POPUP window.
2019-12-29 02:04:19 +00:00
#include "gtknative.h"
#include "gtkstylecontext.h"
#include "gtkcssnodeprivate.h"
Use CSS node name for GtkTooltipWindow Instead of a style class.
2015-11-08 17:10:00 +00:00
Add GtkTooltipWindow private sub-class GtkTooltip does a lot of set up on the GtkWindow it uses internally. We should move that code to a separate class to keep it contained.
2015-11-08 15:46:23 +00:00
struct _GtkTooltipWindow
{
tooltipwindow: Cosmetic fix
2019-12-30 03:47:49 +00:00
GtkWindow parent_instance;
Add GtkTooltipWindow private sub-class GtkTooltip does a lot of set up on the GtkWindow it uses internally. We should move that code to a separate class to keep it contained.
2015-11-08 15:46:23 +00:00
tooltips: Stop using GTK_WINDOW_POPUP Make GtkTooltipWindow a GtkNative implementation, instead of using a GTK_WINDOW_POPUP window.
2019-12-29 02:04:19 +00:00
GdkSurface *surface;
GskRenderer *renderer;
GdkSurfaceState state;
GtkWidget *relative_to;
GdkRectangle rect;
GdkGravity rect_anchor;
GdkGravity surface_anchor;
GdkAnchorHints anchor_hints;
int dx;
int dy;
guint surface_transform_changed_cb;
Add GtkTooltipWindow private sub-class GtkTooltip does a lot of set up on the GtkWindow it uses internally. We should move that code to a separate class to keep it contained.
2015-11-08 15:46:23 +00:00
GtkWidget *box;
GtkWidget *image;
GtkWidget *label;
GtkWidget *custom_widget;
};
struct _GtkTooltipWindowClass
{
GtkWindowClass parent_class;
};
tooltips: Stop using GTK_WINDOW_POPUP Make GtkTooltipWindow a GtkNative implementation, instead of using a GTK_WINDOW_POPUP window.
2019-12-29 02:04:19 +00:00
static void gtk_tooltip_window_native_init (GtkNativeInterface *iface);
G_DEFINE_TYPE_WITH_CODE (GtkTooltipWindow, gtk_tooltip_window, GTK_TYPE_BIN,
G_IMPLEMENT_INTERFACE (GTK_TYPE_NATIVE,
gtk_tooltip_window_native_init))
static GdkSurface *
gtk_tooltip_window_native_get_surface (GtkNative *native)
{
GtkTooltipWindow *window = GTK_TOOLTIP_WINDOW (native);
return window->surface;
}
static GskRenderer *
gtk_tooltip_window_native_get_renderer (GtkNative *native)
{
GtkTooltipWindow *window = GTK_TOOLTIP_WINDOW (native);
return window->renderer;
}
static void
gtk_tooltip_window_native_get_surface_transform (GtkNative *native,
int *x,
int *y)
{
GtkStyleContext *context;
GtkBorder margin, border, padding;
context = gtk_widget_get_style_context (GTK_WIDGET (native));
gtk_style_context_get_margin (context, &margin);
gtk_style_context_get_border (context, &border);
gtk_style_context_get_padding (context, &padding);
*x = margin.left + border.left + padding.left;
*y = margin.top + border.top + padding.top;
}
gdk/surface: Replace move_to_rect() with GdkPopupLayout based API Replace the gdk_surface_move_to_rect() API with a new GdkSurface method called gdk_surface_present_popup() taking a new GdkPopupLayout object describing how they should be laid out on screen. The layout properties provided are the same as the ones used with gdk_surface_move_to_rect(), except they are now set up using GdkPopupLayout. Calling gdk_surface_present_popup() will either show the popup at the position described using the popup layout object and a new unconstrained size, or reposition it accordingly. In some situations, such as when a popup is set to autohide, presenting may immediately fail, in case the grab was not granted by the display server. After a successful present, the result of the layout can be queried using the following methods: * gdk_surface_get_position() - to get the position relative to its parent * gdk_surface_get_width() - to get the current width * gdk_surface_get_height() - to get the current height * gdk_surface_get_rect_anchor() - to get the anchor point on the anchor rectangle the popup was effectively positioned against given constraints defined by the environment and the layout rules provided via GdkPopupLayout. * gdk_surface_get_surface_anchor() - the same as the one above but for the surface anchor. A new signal replaces the old "moved-to-rect" one - "popup-layout-changed". However, it is only intended to be emitted when the layout changes implicitly by the windowing system, for example if the monitor resolution changed, or the parent window moved.
2020-02-16 11:59:24 +00:00
static GdkPopupLayout *
create_popup_layout (GtkTooltipWindow *window)
{
GdkPopupLayout *layout;
layout = gdk_popup_layout_new (&window->rect,
window->rect_anchor,
window->surface_anchor);
gdk_popup_layout_set_anchor_hints (layout, window->anchor_hints);
gdk_popup_layout_set_offset (layout, window->dx, window->dy);
return layout;
}
tooltips: Stop using GTK_WINDOW_POPUP Make GtkTooltipWindow a GtkNative implementation, instead of using a GTK_WINDOW_POPUP window.
2019-12-29 02:04:19 +00:00
static void
Ensure all natives request at least a 1px wide surface FIXME: Is this necessary? Could the surfaces just clamp to 1x1 themselves? We recently declared that surfaces can decide on whatever size they want so natives need to inspect the size they requested anyway.
2020-02-22 03:49:52 +00:00
gtk_tooltip_window_relayout (GtkTooltipWindow *window)
tooltips: Stop using GTK_WINDOW_POPUP Make GtkTooltipWindow a GtkNative implementation, instead of using a GTK_WINDOW_POPUP window.
2019-12-29 02:04:19 +00:00
{
Ensure all natives request at least a 1px wide surface FIXME: Is this necessary? Could the surfaces just clamp to 1x1 themselves? We recently declared that surfaces can decide on whatever size they want so natives need to inspect the size they requested anyway.
2020-02-22 03:49:52 +00:00
GtkRequisition req;
gdk/surface: Replace move_to_rect() with GdkPopupLayout based API Replace the gdk_surface_move_to_rect() API with a new GdkSurface method called gdk_surface_present_popup() taking a new GdkPopupLayout object describing how they should be laid out on screen. The layout properties provided are the same as the ones used with gdk_surface_move_to_rect(), except they are now set up using GdkPopupLayout. Calling gdk_surface_present_popup() will either show the popup at the position described using the popup layout object and a new unconstrained size, or reposition it accordingly. In some situations, such as when a popup is set to autohide, presenting may immediately fail, in case the grab was not granted by the display server. After a successful present, the result of the layout can be queried using the following methods: * gdk_surface_get_position() - to get the position relative to its parent * gdk_surface_get_width() - to get the current width * gdk_surface_get_height() - to get the current height * gdk_surface_get_rect_anchor() - to get the anchor point on the anchor rectangle the popup was effectively positioned against given constraints defined by the environment and the layout rules provided via GdkPopupLayout. * gdk_surface_get_surface_anchor() - the same as the one above but for the surface anchor. A new signal replaces the old "moved-to-rect" one - "popup-layout-changed". However, it is only intended to be emitted when the layout changes implicitly by the windowing system, for example if the monitor resolution changed, or the parent window moved.
2020-02-16 11:59:24 +00:00
GdkPopupLayout *layout;
Ensure all natives request at least a 1px wide surface FIXME: Is this necessary? Could the surfaces just clamp to 1x1 themselves? We recently declared that surfaces can decide on whatever size they want so natives need to inspect the size they requested anyway.
2020-02-22 03:49:52 +00:00
if (!gtk_widget_get_visible (GTK_WIDGET (window)) ||
window->surface == NULL)
gdk/surface: Replace move_to_rect() with GdkPopupLayout based API Replace the gdk_surface_move_to_rect() API with a new GdkSurface method called gdk_surface_present_popup() taking a new GdkPopupLayout object describing how they should be laid out on screen. The layout properties provided are the same as the ones used with gdk_surface_move_to_rect(), except they are now set up using GdkPopupLayout. Calling gdk_surface_present_popup() will either show the popup at the position described using the popup layout object and a new unconstrained size, or reposition it accordingly. In some situations, such as when a popup is set to autohide, presenting may immediately fail, in case the grab was not granted by the display server. After a successful present, the result of the layout can be queried using the following methods: * gdk_surface_get_position() - to get the position relative to its parent * gdk_surface_get_width() - to get the current width * gdk_surface_get_height() - to get the current height * gdk_surface_get_rect_anchor() - to get the anchor point on the anchor rectangle the popup was effectively positioned against given constraints defined by the environment and the layout rules provided via GdkPopupLayout. * gdk_surface_get_surface_anchor() - the same as the one above but for the surface anchor. A new signal replaces the old "moved-to-rect" one - "popup-layout-changed". However, it is only intended to be emitted when the layout changes implicitly by the windowing system, for example if the monitor resolution changed, or the parent window moved.
2020-02-16 11:59:24 +00:00
return;
Ensure all natives request at least a 1px wide surface FIXME: Is this necessary? Could the surfaces just clamp to 1x1 themselves? We recently declared that surfaces can decide on whatever size they want so natives need to inspect the size they requested anyway.
2020-02-22 03:49:52 +00:00
gtk_widget_get_preferred_size (GTK_WIDGET (window), NULL, &req);
gdk/surface: Replace move_to_rect() with GdkPopupLayout based API Replace the gdk_surface_move_to_rect() API with a new GdkSurface method called gdk_surface_present_popup() taking a new GdkPopupLayout object describing how they should be laid out on screen. The layout properties provided are the same as the ones used with gdk_surface_move_to_rect(), except they are now set up using GdkPopupLayout. Calling gdk_surface_present_popup() will either show the popup at the position described using the popup layout object and a new unconstrained size, or reposition it accordingly. In some situations, such as when a popup is set to autohide, presenting may immediately fail, in case the grab was not granted by the display server. After a successful present, the result of the layout can be queried using the following methods: * gdk_surface_get_position() - to get the position relative to its parent * gdk_surface_get_width() - to get the current width * gdk_surface_get_height() - to get the current height * gdk_surface_get_rect_anchor() - to get the anchor point on the anchor rectangle the popup was effectively positioned against given constraints defined by the environment and the layout rules provided via GdkPopupLayout. * gdk_surface_get_surface_anchor() - the same as the one above but for the surface anchor. A new signal replaces the old "moved-to-rect" one - "popup-layout-changed". However, it is only intended to be emitted when the layout changes implicitly by the windowing system, for example if the monitor resolution changed, or the parent window moved.
2020-02-16 11:59:24 +00:00
layout = create_popup_layout (window);
tooltip: Use GdkPopup
2020-02-29 14:46:13 +00:00
gdk_popup_present (GDK_POPUP (window->surface),
MAX (req.width, 1),
MAX (req.height, 1),
layout);
gdk/surface: Replace move_to_rect() with GdkPopupLayout based API Replace the gdk_surface_move_to_rect() API with a new GdkSurface method called gdk_surface_present_popup() taking a new GdkPopupLayout object describing how they should be laid out on screen. The layout properties provided are the same as the ones used with gdk_surface_move_to_rect(), except they are now set up using GdkPopupLayout. Calling gdk_surface_present_popup() will either show the popup at the position described using the popup layout object and a new unconstrained size, or reposition it accordingly. In some situations, such as when a popup is set to autohide, presenting may immediately fail, in case the grab was not granted by the display server. After a successful present, the result of the layout can be queried using the following methods: * gdk_surface_get_position() - to get the position relative to its parent * gdk_surface_get_width() - to get the current width * gdk_surface_get_height() - to get the current height * gdk_surface_get_rect_anchor() - to get the anchor point on the anchor rectangle the popup was effectively positioned against given constraints defined by the environment and the layout rules provided via GdkPopupLayout. * gdk_surface_get_surface_anchor() - the same as the one above but for the surface anchor. A new signal replaces the old "moved-to-rect" one - "popup-layout-changed". However, it is only intended to be emitted when the layout changes implicitly by the windowing system, for example if the monitor resolution changed, or the parent window moved.
2020-02-16 11:59:24 +00:00
gdk_popup_layout_unref (layout);
tooltips: Stop using GTK_WINDOW_POPUP Make GtkTooltipWindow a GtkNative implementation, instead of using a GTK_WINDOW_POPUP window.
2019-12-29 02:04:19 +00:00
}
static void
gtk_tooltip_window_native_check_resize (GtkNative *native)
{
GtkTooltipWindow *window = GTK_TOOLTIP_WINDOW (native);
GtkWidget *widget = GTK_WIDGET (native);
if (!_gtk_widget_get_alloc_needed (widget))
gtk_widget_ensure_allocate (widget);
else if (gtk_widget_get_visible (widget))
{
Ensure all natives request at least a 1px wide surface FIXME: Is this necessary? Could the surfaces just clamp to 1x1 themselves? We recently declared that surfaces can decide on whatever size they want so natives need to inspect the size they requested anyway.
2020-02-22 03:49:52 +00:00
gtk_tooltip_window_relayout (window);
tooltips: Stop using GTK_WINDOW_POPUP Make GtkTooltipWindow a GtkNative implementation, instead of using a GTK_WINDOW_POPUP window.
2019-12-29 02:04:19 +00:00
if (window->surface)
gtk_widget_allocate (GTK_WIDGET (window),
gdk_surface_get_width (window->surface),
gdk_surface_get_height (window->surface),
-1, NULL);
}
}
static void
gtk_tooltip_window_native_init (GtkNativeInterface *iface)
{
iface->get_surface = gtk_tooltip_window_native_get_surface;
iface->get_renderer = gtk_tooltip_window_native_get_renderer;
iface->get_surface_transform = gtk_tooltip_window_native_get_surface_transform;
iface->check_resize = gtk_tooltip_window_native_check_resize;
}
static void
surface_state_changed (GtkWidget *widget)
{
GtkTooltipWindow *window = GTK_TOOLTIP_WINDOW (widget);
GdkSurfaceState new_surface_state;
GdkSurfaceState changed_mask;
gtk: use toplevel state getter
2020-03-01 01:32:15 +00:00
new_surface_state = gdk_toplevel_get_state (GDK_TOPLEVEL (window->surface));
tooltips: Stop using GTK_WINDOW_POPUP Make GtkTooltipWindow a GtkNative implementation, instead of using a GTK_WINDOW_POPUP window.
2019-12-29 02:04:19 +00:00
changed_mask = new_surface_state ^ window->state;
window->state = new_surface_state;
if (changed_mask & GDK_SURFACE_STATE_WITHDRAWN)
{
if (window->state & GDK_SURFACE_STATE_WITHDRAWN)
gtk_widget_hide (widget);
}
}
static void
surface_size_changed (GtkWidget *widget,
guint width,
guint height)
{
}
static gboolean
surface_render (GdkSurface *surface,
cairo_region_t *region,
GtkWidget *widget)
{
gtk_widget_render (widget, surface, region);
return TRUE;
}
static gboolean
surface_event (GdkSurface *surface,
GdkEvent *event,
GtkWidget *widget)
{
gtk_main_do_event (event);
return TRUE;
}
static void
gtk_tooltip_window_realize (GtkWidget *widget)
{
GtkTooltipWindow *window = GTK_TOOLTIP_WINDOW (widget);
GdkSurface *parent;
parent = gtk_native_get_surface (gtk_widget_get_native (window->relative_to));
surface: Don't take a display argument in gdk_surface_new_popup() The display can be taken from the surface, it must not be different.
2020-02-21 20:13:09 +00:00
window->surface = gdk_surface_new_popup (parent, FALSE);
tooltips: Stop using GTK_WINDOW_POPUP Make GtkTooltipWindow a GtkNative implementation, instead of using a GTK_WINDOW_POPUP window.
2019-12-29 02:04:19 +00:00
gdk_surface_set_widget (window->surface, widget);
g_signal_connect_swapped (window->surface, "notify::state", G_CALLBACK (surface_state_changed), widget);
g_signal_connect_swapped (window->surface, "size-changed", G_CALLBACK (surface_size_changed), widget);
g_signal_connect (window->surface, "render", G_CALLBACK (surface_render), widget);
g_signal_connect (window->surface, "event", G_CALLBACK (surface_event), widget);
GTK_WIDGET_CLASS (gtk_tooltip_window_parent_class)->realize (widget);
window->renderer = gsk_renderer_new_for_surface (window->surface);
}
static void
gtk_tooltip_window_unrealize (GtkWidget *widget)
{
GtkTooltipWindow *window = GTK_TOOLTIP_WINDOW (widget);
GTK_WIDGET_CLASS (gtk_tooltip_window_parent_class)->unrealize (widget);
gsk_renderer_unrealize (window->renderer);
g_clear_object (&window->renderer);
g_signal_handlers_disconnect_by_func (window->surface, surface_state_changed, widget);
g_signal_handlers_disconnect_by_func (window->surface, surface_size_changed, widget);
g_signal_handlers_disconnect_by_func (window->surface, surface_render, widget);
g_signal_handlers_disconnect_by_func (window->surface, surface_event, widget);
gdk_surface_set_widget (window->surface, NULL);
gdk_surface_destroy (window->surface);
g_clear_object (&window->surface);
}
static void
unset_surface_transform_changed_cb (gpointer data)
{
GtkTooltipWindow *window = GTK_TOOLTIP_WINDOW (data);
window->surface_transform_changed_cb = 0;
}
static gboolean
surface_transform_changed_cb (GtkWidget *widget,
const graphene_matrix_t *transform,
gpointer user_data)
{
GtkTooltipWindow *window = GTK_TOOLTIP_WINDOW (widget);
Ensure all natives request at least a 1px wide surface FIXME: Is this necessary? Could the surfaces just clamp to 1x1 themselves? We recently declared that surfaces can decide on whatever size they want so natives need to inspect the size they requested anyway.
2020-02-22 03:49:52 +00:00
gtk_tooltip_window_relayout (window);
tooltips: Stop using GTK_WINDOW_POPUP Make GtkTooltipWindow a GtkNative implementation, instead of using a GTK_WINDOW_POPUP window.
2019-12-29 02:04:19 +00:00
return G_SOURCE_CONTINUE;
}
static void
gtk_tooltip_window_map (GtkWidget *widget)
{
GtkTooltipWindow *window = GTK_TOOLTIP_WINDOW (widget);
gdk/surface: Replace move_to_rect() with GdkPopupLayout based API Replace the gdk_surface_move_to_rect() API with a new GdkSurface method called gdk_surface_present_popup() taking a new GdkPopupLayout object describing how they should be laid out on screen. The layout properties provided are the same as the ones used with gdk_surface_move_to_rect(), except they are now set up using GdkPopupLayout. Calling gdk_surface_present_popup() will either show the popup at the position described using the popup layout object and a new unconstrained size, or reposition it accordingly. In some situations, such as when a popup is set to autohide, presenting may immediately fail, in case the grab was not granted by the display server. After a successful present, the result of the layout can be queried using the following methods: * gdk_surface_get_position() - to get the position relative to its parent * gdk_surface_get_width() - to get the current width * gdk_surface_get_height() - to get the current height * gdk_surface_get_rect_anchor() - to get the anchor point on the anchor rectangle the popup was effectively positioned against given constraints defined by the environment and the layout rules provided via GdkPopupLayout. * gdk_surface_get_surface_anchor() - the same as the one above but for the surface anchor. A new signal replaces the old "moved-to-rect" one - "popup-layout-changed". However, it is only intended to be emitted when the layout changes implicitly by the windowing system, for example if the monitor resolution changed, or the parent window moved.
2020-02-16 11:59:24 +00:00
GdkPopupLayout *layout;
tooltips: Stop using GTK_WINDOW_POPUP Make GtkTooltipWindow a GtkNative implementation, instead of using a GTK_WINDOW_POPUP window.
2019-12-29 02:04:19 +00:00
GtkWidget *child;
gdk/surface: Replace move_to_rect() with GdkPopupLayout based API Replace the gdk_surface_move_to_rect() API with a new GdkSurface method called gdk_surface_present_popup() taking a new GdkPopupLayout object describing how they should be laid out on screen. The layout properties provided are the same as the ones used with gdk_surface_move_to_rect(), except they are now set up using GdkPopupLayout. Calling gdk_surface_present_popup() will either show the popup at the position described using the popup layout object and a new unconstrained size, or reposition it accordingly. In some situations, such as when a popup is set to autohide, presenting may immediately fail, in case the grab was not granted by the display server. After a successful present, the result of the layout can be queried using the following methods: * gdk_surface_get_position() - to get the position relative to its parent * gdk_surface_get_width() - to get the current width * gdk_surface_get_height() - to get the current height * gdk_surface_get_rect_anchor() - to get the anchor point on the anchor rectangle the popup was effectively positioned against given constraints defined by the environment and the layout rules provided via GdkPopupLayout. * gdk_surface_get_surface_anchor() - the same as the one above but for the surface anchor. A new signal replaces the old "moved-to-rect" one - "popup-layout-changed". However, it is only intended to be emitted when the layout changes implicitly by the windowing system, for example if the monitor resolution changed, or the parent window moved.
2020-02-16 11:59:24 +00:00
layout = create_popup_layout (window);
tooltip: Use GdkPopup
2020-02-29 14:46:13 +00:00
gdk_popup_present (GDK_POPUP (window->surface),
gdk_surface_get_width (window->surface),
gdk_surface_get_height (window->surface),
layout);
gdk/surface: Replace move_to_rect() with GdkPopupLayout based API Replace the gdk_surface_move_to_rect() API with a new GdkSurface method called gdk_surface_present_popup() taking a new GdkPopupLayout object describing how they should be laid out on screen. The layout properties provided are the same as the ones used with gdk_surface_move_to_rect(), except they are now set up using GdkPopupLayout. Calling gdk_surface_present_popup() will either show the popup at the position described using the popup layout object and a new unconstrained size, or reposition it accordingly. In some situations, such as when a popup is set to autohide, presenting may immediately fail, in case the grab was not granted by the display server. After a successful present, the result of the layout can be queried using the following methods: * gdk_surface_get_position() - to get the position relative to its parent * gdk_surface_get_width() - to get the current width * gdk_surface_get_height() - to get the current height * gdk_surface_get_rect_anchor() - to get the anchor point on the anchor rectangle the popup was effectively positioned against given constraints defined by the environment and the layout rules provided via GdkPopupLayout. * gdk_surface_get_surface_anchor() - the same as the one above but for the surface anchor. A new signal replaces the old "moved-to-rect" one - "popup-layout-changed". However, it is only intended to be emitted when the layout changes implicitly by the windowing system, for example if the monitor resolution changed, or the parent window moved.
2020-02-16 11:59:24 +00:00
gdk_popup_layout_unref (layout);
tooltips: Stop using GTK_WINDOW_POPUP Make GtkTooltipWindow a GtkNative implementation, instead of using a GTK_WINDOW_POPUP window.
2019-12-29 02:04:19 +00:00
window->surface_transform_changed_cb =
gtk_widget_add_surface_transform_changed_callback (window->relative_to,
surface_transform_changed_cb,
window,
unset_surface_transform_changed_cb);
GTK_WIDGET_CLASS (gtk_tooltip_window_parent_class)->map (widget);
child = gtk_bin_get_child (GTK_BIN (widget));
if (child != NULL && gtk_widget_get_visible (child))
gtk_widget_map (child);
}
static void
gtk_tooltip_window_unmap (GtkWidget *widget)
{
GtkTooltipWindow *window = GTK_TOOLTIP_WINDOW (widget);
GtkWidget *child;
gtk_widget_remove_surface_transform_changed_callback (window->relative_to,
window->surface_transform_changed_cb);
window->surface_transform_changed_cb = 0;
GTK_WIDGET_CLASS (gtk_tooltip_window_parent_class)->unmap (widget);
gdk_surface_hide (window->surface);
child = gtk_bin_get_child (GTK_BIN (widget));
if (child != NULL)
gtk_widget_unmap (child);
}
static void
gtk_tooltip_window_measure (GtkWidget *widget,
GtkOrientation orientation,
int for_size,
int *minimum,
int *natural,
int *minimum_baseline,
int *natural_baseline)
{
GtkWidget *child;
child = gtk_bin_get_child (GTK_BIN (widget));
if (child)
gtk_widget_measure (child,
orientation, for_size,
minimum, natural,
minimum_baseline, natural_baseline);
}
static void
gtk_tooltip_window_size_allocate (GtkWidget *widget,
int width,
int height,
int baseline)
{
GtkTooltipWindow *window = GTK_TOOLTIP_WINDOW (widget);
GtkWidget *child;
child = gtk_bin_get_child (GTK_BIN (window));
if (child)
gtk_widget_allocate (child, width, height, baseline, NULL);
}
static void
gtk_tooltip_window_show (GtkWidget *widget)
{
_gtk_widget_set_visible_flag (widget, TRUE);
gtk_widget_realize (widget);
gtk_tooltip_window_native_check_resize (GTK_NATIVE (widget));
gtk_widget_map (widget);
}
static void
gtk_tooltip_window_hide (GtkWidget *widget)
{
_gtk_widget_set_visible_flag (widget, FALSE);
gtk_widget_unmap (widget);
}
static void size_changed (GtkWidget *widget,
int width,
int height,
int baseline,
GtkTooltipWindow *window);
static void
gtk_tooltip_window_dispose (GObject *object)
{
GtkTooltipWindow *window = GTK_TOOLTIP_WINDOW (object);
if (window->relative_to)
{
g_signal_handlers_disconnect_by_func (window->relative_to, size_changed, window);
gtk_widget_unparent (GTK_WIDGET (window));
}
G_OBJECT_CLASS (gtk_tooltip_window_parent_class)->dispose (object);
}
Add GtkTooltipWindow private sub-class GtkTooltip does a lot of set up on the GtkWindow it uses internally. We should move that code to a separate class to keep it contained.
2015-11-08 15:46:23 +00:00
static void
gtk_tooltip_window_class_init (GtkTooltipWindowClass *klass)
{
tooltips: Stop using GTK_WINDOW_POPUP Make GtkTooltipWindow a GtkNative implementation, instead of using a GTK_WINDOW_POPUP window.
2019-12-29 02:04:19 +00:00
GObjectClass *object_class = G_OBJECT_CLASS (klass);
Add GtkTooltipWindow private sub-class GtkTooltip does a lot of set up on the GtkWindow it uses internally. We should move that code to a separate class to keep it contained.
2015-11-08 15:46:23 +00:00
GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
tooltips: Stop using GTK_WINDOW_POPUP Make GtkTooltipWindow a GtkNative implementation, instead of using a GTK_WINDOW_POPUP window.
2019-12-29 02:04:19 +00:00
object_class->dispose = gtk_tooltip_window_dispose;
widget_class->realize = gtk_tooltip_window_realize;
widget_class->unrealize = gtk_tooltip_window_unrealize;
widget_class->map = gtk_tooltip_window_map;
widget_class->unmap = gtk_tooltip_window_unmap;
widget_class->measure = gtk_tooltip_window_measure;
widget_class->size_allocate = gtk_tooltip_window_size_allocate;
widget_class->show = gtk_tooltip_window_show;
widget_class->hide = gtk_tooltip_window_hide;
Use CSS node name for GtkTooltipWindow Instead of a style class.
2015-11-08 17:10:00 +00:00
gtk_widget_class_set_css_name (widget_class, I_("tooltip"));
Add GtkTooltipWindow private sub-class GtkTooltip does a lot of set up on the GtkWindow it uses internally. We should move that code to a separate class to keep it contained.
2015-11-08 15:46:23 +00:00
gtk_widget_class_set_accessible_role (widget_class, ATK_ROLE_TOOL_TIP);
tooltipwindow: Use a builder UI file It's not a hugely complicated file, but it's easier to deal with some of the details of tooltip windows styling if we have a UI file to edit, instead of source code.
2015-11-11 12:27:07 +00:00
gtk_widget_class_set_template_from_resource (widget_class, "/org/gtk/libgtk/ui/gtktooltipwindow.ui");
gtk_widget_class_bind_template_child (widget_class, GtkTooltipWindow, box);
gtk_widget_class_bind_template_child (widget_class, GtkTooltipWindow, image);
gtk_widget_class_bind_template_child (widget_class, GtkTooltipWindow, label);
tooltips: Stop using GTK_WINDOW_POPUP Make GtkTooltipWindow a GtkNative implementation, instead of using a GTK_WINDOW_POPUP window.
2019-12-29 02:04:19 +00:00
gtk_widget_class_set_css_name (widget_class, "tooltip");
Add GtkTooltipWindow private sub-class GtkTooltip does a lot of set up on the GtkWindow it uses internally. We should move that code to a separate class to keep it contained.
2015-11-08 15:46:23 +00:00
}
static void
gtk_tooltip_window_init (GtkTooltipWindow *self)
{
tooltipwindow: Use a builder UI file It's not a hugely complicated file, but it's easier to deal with some of the details of tooltip windows styling if we have a UI file to edit, instead of source code.
2015-11-11 12:27:07 +00:00
gtk_widget_init_template (GTK_WIDGET (self));
Add GtkTooltipWindow private sub-class GtkTooltip does a lot of set up on the GtkWindow it uses internally. We should move that code to a separate class to keep it contained.
2015-11-08 15:46:23 +00:00
}
GtkWidget *
gtk_tooltip_window_new (void)
{
tooltips: Stop using GTK_WINDOW_POPUP Make GtkTooltipWindow a GtkNative implementation, instead of using a GTK_WINDOW_POPUP window.
2019-12-29 02:04:19 +00:00
return g_object_new (GTK_TYPE_TOOLTIP_WINDOW, NULL);
Add GtkTooltipWindow private sub-class GtkTooltip does a lot of set up on the GtkWindow it uses internally. We should move that code to a separate class to keep it contained.
2015-11-08 15:46:23 +00:00
}
void
gtk_tooltip_window_set_label_markup (GtkTooltipWindow *window,
const char *markup)
{
if (markup != NULL)
{
gtk_label_set_markup (GTK_LABEL (window->label), markup);
gtk_widget_show (window->label);
}
else
{
gtk_widget_hide (window->label);
}
}
void
gtk_tooltip_window_set_label_text (GtkTooltipWindow *window,
const char *text)
{
if (text != NULL)
{
gtk_label_set_text (GTK_LABEL (window->label), text);
gtk_widget_show (window->label);
}
else
{
gtk_widget_hide (window->label);
}
}
void
gtk_tooltip_window_set_image_icon (GtkTooltipWindow *window,
tooltips: Make icon a paintable
2018-03-16 02:38:50 +00:00
GdkPaintable *paintable)
Add GtkTooltipWindow private sub-class GtkTooltip does a lot of set up on the GtkWindow it uses internally. We should move that code to a separate class to keep it contained.
2015-11-08 15:46:23 +00:00
{
tooltips: Make icon a paintable
2018-03-16 02:38:50 +00:00
if (paintable != NULL)
Add GtkTooltipWindow private sub-class GtkTooltip does a lot of set up on the GtkWindow it uses internally. We should move that code to a separate class to keep it contained.
2015-11-08 15:46:23 +00:00
{
tooltips: Make icon a paintable
2018-03-16 02:38:50 +00:00
gtk_image_set_from_paintable (GTK_IMAGE (window->image), paintable);
Add GtkTooltipWindow private sub-class GtkTooltip does a lot of set up on the GtkWindow it uses internally. We should move that code to a separate class to keep it contained.
2015-11-08 15:46:23 +00:00
gtk_widget_show (window->image);
}
else
{
gtk_widget_hide (window->image);
}
}
void
gtk_tooltip_window_set_image_icon_from_name (GtkTooltipWindow *window,
tooltips: Remove GtkIconSize usage
2017-01-20 01:02:44 +00:00
const char *icon_name)
Add GtkTooltipWindow private sub-class GtkTooltip does a lot of set up on the GtkWindow it uses internally. We should move that code to a separate class to keep it contained.
2015-11-08 15:46:23 +00:00
{
if (icon_name)
{
image: Remove icon-size argument from icon setters Instead, add a function gtk_image_set_icon_size() for the cases where overriding the icon size is necessary. Treat icon sizes the same way as pixel sizes, too. So gtk_image_clear() no longer unsets the icon size.
2017-11-15 00:43:13 +00:00
gtk_image_set_from_icon_name (GTK_IMAGE (window->image), icon_name);
Add GtkTooltipWindow private sub-class GtkTooltip does a lot of set up on the GtkWindow it uses internally. We should move that code to a separate class to keep it contained.
2015-11-08 15:46:23 +00:00
gtk_widget_show (window->image);
}
else
{
gtk_widget_hide (window->image);
}
}
void
gtk_tooltip_window_set_image_icon_from_gicon (GtkTooltipWindow *window,
tooltips: Remove GtkIconSize usage
2017-01-20 01:02:44 +00:00
GIcon *gicon)
Add GtkTooltipWindow private sub-class GtkTooltip does a lot of set up on the GtkWindow it uses internally. We should move that code to a separate class to keep it contained.
2015-11-08 15:46:23 +00:00
{
if (gicon != NULL)
{
image: Remove icon-size argument from icon setters Instead, add a function gtk_image_set_icon_size() for the cases where overriding the icon size is necessary. Treat icon sizes the same way as pixel sizes, too. So gtk_image_clear() no longer unsets the icon size.
2017-11-15 00:43:13 +00:00
gtk_image_set_from_gicon (GTK_IMAGE (window->image), gicon);
Add GtkTooltipWindow private sub-class GtkTooltip does a lot of set up on the GtkWindow it uses internally. We should move that code to a separate class to keep it contained.
2015-11-08 15:46:23 +00:00
gtk_widget_show (window->image);
}
else
{
gtk_widget_hide (window->image);
}
}
void
gtk_tooltip_window_set_custom_widget (GtkTooltipWindow *window,
GtkWidget *custom_widget)
{
/* No need to do anything if the custom widget stays the same */
if (window->custom_widget == custom_widget)
return;
if (window->custom_widget != NULL)
{
GtkWidget *custom = window->custom_widget;
/* Note: We must reset window->custom_widget first,
* since gtk_container_remove() will recurse into
* gtk_tooltip_set_custom()
*/
window->custom_widget = NULL;
gtk_container_remove (GTK_CONTAINER (window->box), custom);
g_object_unref (custom);
}
if (custom_widget != NULL)
{
window->custom_widget = g_object_ref (custom_widget);
gtk_container_add (GTK_CONTAINER (window->box), custom_widget);
gtk_widget_show (custom_widget);
tooltips: Stop using GTK_WINDOW_POPUP Make GtkTooltipWindow a GtkNative implementation, instead of using a GTK_WINDOW_POPUP window.
2019-12-29 02:04:19 +00:00
gtk_widget_hide (window->image);
gtk_widget_hide (window->label);
Add GtkTooltipWindow private sub-class GtkTooltip does a lot of set up on the GtkWindow it uses internally. We should move that code to a separate class to keep it contained.
2015-11-08 15:46:23 +00:00
}
}
tooltips: Stop using GTK_WINDOW_POPUP Make GtkTooltipWindow a GtkNative implementation, instead of using a GTK_WINDOW_POPUP window.
2019-12-29 02:04:19 +00:00
static void
size_changed (GtkWidget *widget,
int width,
int height,
int baseline,
GtkTooltipWindow *window)
{
gtk_native_check_resize (GTK_NATIVE (window));
}
void
gtk_tooltip_window_set_relative_to (GtkTooltipWindow *window,
GtkWidget *relative_to)
{
tooltip: Never set a window to be its own parent We do get events on the tooltip window too, and we better ignore them, or bad things may happen, such as widgets that are their own parents and cause infinite loops. Fixes: https://gitlab.gnome.org/GNOME/gtk/issues/2339
2019-12-30 14:52:13 +00:00
g_return_if_fail (GTK_WIDGET (window) != relative_to);
tooltips: Stop using GTK_WINDOW_POPUP Make GtkTooltipWindow a GtkNative implementation, instead of using a GTK_WINDOW_POPUP window.
2019-12-29 02:04:19 +00:00
if (window->relative_to == relative_to)
return;
g_object_ref (window);
if (window->relative_to)
{
g_signal_handlers_disconnect_by_func (window->relative_to, size_changed, window);
gtk_widget_unparent (GTK_WIDGET (window));
}
window->relative_to = relative_to;
if (window->relative_to)
{
g_signal_connect (window->relative_to, "size-allocate", G_CALLBACK (size_changed), window);
gtk_css_node_set_parent (gtk_widget_get_css_node (GTK_WIDGET (window)),
gtk_widget_get_css_node (relative_to));
gtk_widget_set_parent (GTK_WIDGET (window), relative_to);
}
g_object_unref (window);
}
void
gtk_tooltip_window_position (GtkTooltipWindow *window,
GdkRectangle *rect,
GdkGravity rect_anchor,
GdkGravity surface_anchor,
GdkAnchorHints anchor_hints,
int dx,
int dy)
{
window->rect = *rect;
window->rect_anchor = rect_anchor;
window->surface_anchor = surface_anchor;
window->anchor_hints = anchor_hints;
window->dx = dx;
window->dy = dy;
Ensure all natives request at least a 1px wide surface FIXME: Is this necessary? Could the surfaces just clamp to 1x1 themselves? We recently declared that surfaces can decide on whatever size they want so natives need to inspect the size they requested anyway.
2020-02-22 03:49:52 +00:00
gtk_tooltip_window_relayout (window);
tooltips: Stop using GTK_WINDOW_POPUP Make GtkTooltipWindow a GtkNative implementation, instead of using a GTK_WINDOW_POPUP window.
2019-12-29 02:04:19 +00:00
}
Reference in New Issue Copy Permalink