* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*/
-/**
- * SECTION:gtkbubblewindow
- * @Short_description: Bubble-like context window
- * @Title: GtkBubbleWindow
- *
+/*
* GtkBubbleWindow is a bubble-like context window, primarily mean for
* context-dependent helpers on touch interfaces.
*
#include "config.h"
#include <gdk/gdk.h>
#include <cairo-gobject.h>
-#include "gtkbubblewindow.h"
+#include "gtkbubblewindowprivate.h"
+#include "gtktypebuiltins.h"
+#include "gtkmain.h"
#include "gtkprivate.h"
#include "gtkintl.h"
guint final_position : 2;
};
-G_DEFINE_TYPE (GtkBubbleWindow, gtk_bubble_window, GTK_TYPE_WINDOW)
+G_DEFINE_TYPE (GtkBubbleWindow, _gtk_bubble_window, GTK_TYPE_WINDOW)
static void
-gtk_bubble_window_init (GtkBubbleWindow *window)
+_gtk_bubble_window_init (GtkBubbleWindow *window)
{
GtkWidget *widget;
GdkScreen *screen;
GdkVisual *visual;
widget = GTK_WIDGET (window);
- window->_priv = G_TYPE_INSTANCE_GET_PRIVATE (window,
+ window->priv = G_TYPE_INSTANCE_GET_PRIVATE (window,
GTK_TYPE_BUBBLE_WINDOW,
GtkBubbleWindowPrivate);
gtk_window_set_default_size (GTK_WINDOW (window),
GObject *object;
object =
- G_OBJECT_CLASS (gtk_bubble_window_parent_class)->constructor (type,
+ G_OBJECT_CLASS (_gtk_bubble_window_parent_class)->constructor (type,
n_construct_properties,
construct_properties);
g_object_set (object, "type", GTK_WINDOW_POPUP, NULL);
switch (prop_id)
{
case PROP_RELATIVE_TO:
- gtk_bubble_window_set_relative_to (GTK_BUBBLE_WINDOW (object),
- g_value_get_object (value));
+ _gtk_bubble_window_set_relative_to (GTK_BUBBLE_WINDOW (object),
+ g_value_get_object (value));
break;
case PROP_POINTING_TO:
- gtk_bubble_window_set_pointing_to (GTK_BUBBLE_WINDOW (object),
- g_value_get_boxed (value));
+ _gtk_bubble_window_set_pointing_to (GTK_BUBBLE_WINDOW (object),
+ g_value_get_boxed (value));
break;
case PROP_POSITION:
- gtk_bubble_window_set_position (GTK_BUBBLE_WINDOW (object),
- g_value_get_enum (value));
+ _gtk_bubble_window_set_position (GTK_BUBBLE_WINDOW (object),
+ g_value_get_enum (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
GValue *value,
GParamSpec *pspec)
{
- GtkBubbleWindowPrivate *priv = GTK_BUBBLE_WINDOW (object)->_priv;
+ GtkBubbleWindowPrivate *priv = GTK_BUBBLE_WINDOW (object)->priv;
switch (prop_id)
{
gtk_bubble_window_finalize (GObject *object)
{
GtkBubbleWindow *window = GTK_BUBBLE_WINDOW (object);
- GtkBubbleWindowPrivate *priv = window->_priv;;
+ GtkBubbleWindowPrivate *priv = window->priv;
- gtk_bubble_window_popdown (window);
+ _gtk_bubble_window_popdown (window);
if (priv->relative_to)
g_object_unref (priv->relative_to);
- G_OBJECT_CLASS (gtk_bubble_window_parent_class)->finalize (object);
+ G_OBJECT_CLASS (_gtk_bubble_window_parent_class)->finalize (object);
}
static void
-_gtk_bubble_window_get_pointed_to_coords (GtkBubbleWindow *window,
- gint *x,
- gint *y,
- cairo_rectangle_int_t *root_rect)
+gtk_bubble_window_get_pointed_to_coords (GtkBubbleWindow *window,
+ gint *x,
+ gint *y,
+ cairo_rectangle_int_t *root_rect)
{
- GtkBubbleWindowPrivate *priv = window->_priv;
+ GtkBubbleWindowPrivate *priv = window->priv;
cairo_rectangle_int_t rect;
GdkScreen *screen;
}
static void
-_gtk_bubble_window_apply_tail_path (GtkBubbleWindow *window,
- cairo_t *cr,
- GtkAllocation *allocation)
+gtk_bubble_window_apply_tail_path (GtkBubbleWindow *window,
+ cairo_t *cr,
+ GtkAllocation *allocation)
{
- GtkBubbleWindowPrivate *priv = window->_priv;
+ GtkBubbleWindowPrivate *priv = window->priv;
gint base, tip, x, y;
- _gtk_bubble_window_get_pointed_to_coords (window, &x, &y, NULL);
+ gtk_bubble_window_get_pointed_to_coords (window, &x, &y, NULL);
if (priv->final_position == GTK_POS_BOTTOM ||
priv->final_position == GTK_POS_RIGHT)
{
cairo_move_to (cr, CLAMP (x - priv->win_x - TAIL_GAP_WIDTH / 2,
0, allocation->width - TAIL_GAP_WIDTH), base);
+ cairo_line_to (cr, CLAMP (x - priv->win_x, 0, allocation->width), tip);
cairo_line_to (cr, CLAMP (x - priv->win_x + TAIL_GAP_WIDTH / 2,
TAIL_GAP_WIDTH, allocation->width), base);
- cairo_line_to (cr, CLAMP (x - priv->win_x, 0, allocation->width), tip);
}
else
{
cairo_move_to (cr, base,
CLAMP (y - priv->win_y - TAIL_GAP_WIDTH / 2,
0, allocation->height - TAIL_GAP_WIDTH));
+ cairo_line_to (cr, tip, CLAMP (y - priv->win_y, 0, allocation->height));
cairo_line_to (cr, base,
CLAMP (y - priv->win_y + TAIL_GAP_WIDTH / 2,
TAIL_GAP_WIDTH, allocation->height));
- cairo_line_to (cr, tip, CLAMP (y - priv->win_y, 0, allocation->height));
}
-
- cairo_close_path (cr);
}
static void
-_gtk_bubble_window_apply_border_path (GtkBubbleWindow *window,
- cairo_t *cr)
+gtk_bubble_window_apply_border_path (GtkBubbleWindow *window,
+ cairo_t *cr)
{
GtkBubbleWindowPrivate *priv;
GtkAllocation allocation;
- priv = window->_priv;
+ priv = window->priv;
gtk_widget_get_allocation (GTK_WIDGET (window), &allocation);
+ gtk_bubble_window_apply_tail_path (window, cr, &allocation);
+
if (priv->final_position == GTK_POS_TOP)
- cairo_rectangle (cr, 0, 0, allocation.width, allocation.height - TAIL_HEIGHT);
+ {
+ cairo_line_to (cr, allocation.width, allocation.height - TAIL_HEIGHT);
+ cairo_line_to (cr, allocation.width, 0);
+ cairo_line_to (cr, 0, 0);
+ cairo_line_to (cr, 0, allocation.height - TAIL_HEIGHT);
+ }
else if (priv->final_position == GTK_POS_BOTTOM)
- cairo_rectangle (cr, 0, TAIL_HEIGHT , allocation.width,
- allocation.height - TAIL_HEIGHT);
+ {
+ cairo_line_to (cr, allocation.width, TAIL_HEIGHT);
+ cairo_line_to (cr, allocation.width, allocation.height);
+ cairo_line_to (cr, 0, allocation.height);
+ cairo_line_to (cr, 0, TAIL_HEIGHT);
+ }
else if (priv->final_position == GTK_POS_LEFT)
- cairo_rectangle (cr, 0, 0, allocation.width - TAIL_HEIGHT, allocation.height);
+ {
+ cairo_line_to (cr, allocation.width - TAIL_HEIGHT, allocation.height);
+ cairo_line_to (cr, 0, allocation.height);
+ cairo_line_to (cr, 0, 0);
+ cairo_line_to (cr, allocation.width - TAIL_HEIGHT, 0);
+ }
else if (priv->final_position == GTK_POS_RIGHT)
- cairo_rectangle (cr, TAIL_HEIGHT, 0,
- allocation.width - TAIL_HEIGHT, allocation.height);
+ {
+ cairo_line_to (cr, TAIL_HEIGHT, 0);
+ cairo_line_to (cr, allocation.width, 0);
+ cairo_line_to (cr, allocation.width, allocation.height);
+ cairo_line_to (cr, TAIL_HEIGHT, allocation.height);
+ }
- _gtk_bubble_window_apply_tail_path (window, cr, &allocation);
+ cairo_close_path (cr);
}
static void
-_gtk_bubble_window_update_shape (GtkBubbleWindow *window)
+gtk_bubble_window_update_shape (GtkBubbleWindow *window)
{
cairo_surface_t *surface;
cairo_region_t *region;
gdk_window_get_height (win));
cr = cairo_create (surface);
- _gtk_bubble_window_apply_border_path (window, cr);
+ gtk_bubble_window_apply_border_path (window, cr);
cairo_fill (cr);
cairo_destroy (cr);
}
static void
-_gtk_bubble_window_update_position (GtkBubbleWindow *window)
+gtk_bubble_window_update_position (GtkBubbleWindow *window)
{
GtkBubbleWindowPrivate *priv;
cairo_rectangle_int_t rect;
gint win_x, win_y, x, y;
GdkScreen *screen;
- priv = window->_priv;
+ priv = window->priv;
screen = gtk_widget_get_screen (GTK_WIDGET (window));
gtk_widget_get_allocation (GTK_WIDGET (window), &allocation);
priv->final_position = priv->preferred_position;
rect = priv->pointing_to;
- _gtk_bubble_window_get_pointed_to_coords (window, &x, &y, &rect);
+ gtk_bubble_window_get_pointed_to_coords (window, &x, &y, &rect);
/* Check whether there's enough room on the
* preferred side, move to the opposite one if not.
GtkStyleContext *context;
GtkAllocation allocation;
GtkWidget *child;
+ GdkRGBA *border;
cairo_save (cr);
context = gtk_widget_get_style_context (widget);
gtk_widget_get_allocation (widget, &allocation);
+ gtk_render_background (context, cr, 0, 0,
+ allocation.width, allocation.height);
+
if (gtk_widget_is_composited (widget))
{
cairo_save (cr);
cairo_paint (cr);
cairo_restore (cr);
- _gtk_bubble_window_apply_border_path (GTK_BUBBLE_WINDOW (widget), cr);
+ gtk_bubble_window_apply_border_path (GTK_BUBBLE_WINDOW (widget), cr);
cairo_clip (cr);
}
gtk_render_background (context, cr, 0, 0,
allocation.width, allocation.height);
+
+ gtk_style_context_get (context, gtk_widget_get_state_flags (widget),
+ GTK_STYLE_PROPERTY_BORDER_COLOR, &border,
+ NULL);
+
+ gtk_bubble_window_apply_border_path (GTK_BUBBLE_WINDOW (widget), cr);
+ gdk_cairo_set_source_rgba (cr, border);
+ cairo_stroke (cr);
+
child = gtk_bin_get_child (GTK_BIN (widget));
if (child)
cairo_restore (cr);
+ gdk_rgba_free (border);
+
return TRUE;
}
+static void
+get_padding_and_border (GtkWidget *widget,
+ GtkBorder *border)
+{
+ GtkStyleContext *context;
+ GtkStateFlags state;
+ GtkBorder tmp;
+
+ context = gtk_widget_get_style_context (widget);
+ state = gtk_widget_get_state_flags (widget);
+
+ gtk_style_context_get_padding (context, state, border);
+ gtk_style_context_get_border (context, state, &tmp);
+ border->top += tmp.top;
+ border->right += tmp.right;
+ border->bottom += tmp.bottom;
+ border->left += tmp.left;
+}
+
static void
gtk_bubble_window_get_preferred_width (GtkWidget *widget,
gint *minimum_width,
GtkBubbleWindowPrivate *priv;
GtkWidget *child;
gint min, nat;
+ GtkBorder border;
- priv = GTK_BUBBLE_WINDOW (widget)->_priv;
+ priv = GTK_BUBBLE_WINDOW (widget)->priv;
child = gtk_bin_get_child (GTK_BIN (widget));
min = nat = 0;
if (child)
gtk_widget_get_preferred_width (child, &min, &nat);
+ get_padding_and_border (widget, &border);
+ min += border.left + border.right;
+ nat += border.left + border.right;
+
if (!POS_IS_VERTICAL (priv->final_position))
{
min += TAIL_HEIGHT;
GtkBubbleWindowPrivate *priv;
GtkWidget *child;
gint min, nat;
+ GtkBorder border;
- priv = GTK_BUBBLE_WINDOW (widget)->_priv;
+ priv = GTK_BUBBLE_WINDOW (widget)->priv;
child = gtk_bin_get_child (GTK_BIN (widget));
min = nat = 0;
if (child)
- gtk_widget_get_preferred_height (child, &min, &nat);
+ gtk_widget_get_preferred_height (child, &min, &nat);
+
+ get_padding_and_border (widget, &border);
+ min += border.top + border.bottom;
+ nat += border.top + border.bottom;
if (POS_IS_VERTICAL (priv->final_position))
{
GtkBubbleWindowPrivate *priv;
GtkWidget *child;
- priv = GTK_BUBBLE_WINDOW (widget)->_priv;
+ priv = GTK_BUBBLE_WINDOW (widget)->priv;
gtk_widget_set_allocation (widget, allocation);
child = gtk_bin_get_child (GTK_BIN (widget));
if (child)
{
GtkAllocation child_alloc;
+ GtkBorder border;
+
+ get_padding_and_border (widget, &border);
- child_alloc.x = child_alloc.y = 0;
- child_alloc.width = allocation->width;
- child_alloc.height = allocation->height;
+ child_alloc.x = border.left;
+ child_alloc.y = border.top;
+ child_alloc.width = allocation->width - border.left - border.right;
+ child_alloc.height = allocation->height - border.top - border.bottom;
if (POS_IS_VERTICAL (priv->final_position))
child_alloc.height -= TAIL_HEIGHT;
}
if (gtk_widget_get_realized (widget))
- _gtk_bubble_window_update_shape (GTK_BUBBLE_WINDOW (widget));
+ gtk_bubble_window_update_shape (GTK_BUBBLE_WINDOW (widget));
if (gtk_widget_get_visible (widget))
- _gtk_bubble_window_update_position (GTK_BUBBLE_WINDOW (widget));
+ gtk_bubble_window_update_position (GTK_BUBBLE_WINDOW (widget));
}
static gboolean
event->x > child_alloc.x + child_alloc.width ||
event->y < child_alloc.y ||
event->y > child_alloc.y + child_alloc.height)
- gtk_bubble_window_popdown (GTK_BUBBLE_WINDOW (widget));
+ _gtk_bubble_window_popdown (GTK_BUBBLE_WINDOW (widget));
}
else
- gtk_bubble_window_popdown (GTK_BUBBLE_WINDOW (widget));
+ _gtk_bubble_window_popdown (GTK_BUBBLE_WINDOW (widget));
return GDK_EVENT_PROPAGATE;
}
{
if (event->keyval == GDK_KEY_Escape)
{
- gtk_bubble_window_popdown (GTK_BUBBLE_WINDOW (widget));
+ _gtk_bubble_window_popdown (GTK_BUBBLE_WINDOW (widget));
return GDK_EVENT_STOP;
}
GtkBubbleWindowPrivate *priv;
GdkDevice *event_device;
- priv = window->_priv;
+ priv = window->priv;
event_device = gdk_event_get_device ((GdkEvent *) grab_broken);
if (event_device == priv->device ||
event_device == gdk_device_get_associated_device (priv->device))
- gtk_bubble_window_ungrab (window);
+ _gtk_bubble_window_ungrab (window);
return FALSE;
}
GtkBubbleWindow *window = GTK_BUBBLE_WINDOW (widget);
GtkBubbleWindowPrivate *priv;
- priv = window->_priv;
+ priv = window->priv;
if (priv->device && gtk_widget_device_is_shadowed (widget, priv->device))
- gtk_bubble_window_ungrab (window);
+ _gtk_bubble_window_ungrab (window);
}
static void
}
static void
-gtk_bubble_window_class_init (GtkBubbleWindowClass *klass)
+_gtk_bubble_window_class_init (GtkBubbleWindowClass *klass)
{
GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
GObjectClass *object_class = G_OBJECT_CLASS (klass);
}
static void
-_gtk_bubble_window_update_relative_to (GtkBubbleWindow *window,
- GdkWindow *relative_to)
+gtk_bubble_window_update_relative_to (GtkBubbleWindow *window,
+ GdkWindow *relative_to)
{
GtkBubbleWindowPrivate *priv;
- priv = window->_priv;
+ priv = window->priv;
if (priv->relative_to == relative_to)
return;
}
static void
-_gtk_bubble_window_update_pointing_to (GtkBubbleWindow *window,
- cairo_rectangle_int_t *pointing_to)
+gtk_bubble_window_update_pointing_to (GtkBubbleWindow *window,
+ cairo_rectangle_int_t *pointing_to)
{
GtkBubbleWindowPrivate *priv;
- priv = window->_priv;
+ priv = window->priv;
priv->pointing_to = *pointing_to;
priv->has_pointing_to = TRUE;
g_object_notify (G_OBJECT (window), "pointing-to");
}
static void
-_gtk_bubble_window_update_preferred_position (GtkBubbleWindow *window,
- GtkPositionType position)
+gtk_bubble_window_update_preferred_position (GtkBubbleWindow *window,
+ GtkPositionType position)
{
GtkBubbleWindowPrivate *priv;
- priv = window->_priv;
+ priv = window->priv;
priv->preferred_position = position;
g_object_notify (G_OBJECT (window), "position");
}
-/**
+/*
* gtk_bubble_window_new:
*
* Returns a newly created #GtkBubblewindow
* Returns: a new #GtkBubbleWindow
*
* Since: 3.8
- **/
+ */
GtkWidget *
-gtk_bubble_window_new (void)
+_gtk_bubble_window_new (void)
{
return g_object_new (GTK_TYPE_BUBBLE_WINDOW, NULL);
}
-/**
+/*
* gtk_bubble_window_set_relative_to:
* @window: a #GtkBubbleWindow
* @relative_to: a #GdkWindow
* this change.
*
* Since: 3.8
- **/
+ */
void
-gtk_bubble_window_set_relative_to (GtkBubbleWindow *window,
- GdkWindow *relative_to)
+_gtk_bubble_window_set_relative_to (GtkBubbleWindow *window,
+ GdkWindow *relative_to)
{
g_return_if_fail (GTK_IS_BUBBLE_WINDOW (window));
g_return_if_fail (!relative_to || GDK_IS_WINDOW (relative_to));
- _gtk_bubble_window_update_relative_to (window, relative_to);
+ gtk_bubble_window_update_relative_to (window, relative_to);
if (gtk_widget_get_visible (GTK_WIDGET (window)))
- _gtk_bubble_window_update_position (window);
+ gtk_bubble_window_update_position (window);
}
-/**
+/*
* gtk_bubble_window_get_relative_to:
* @window: a #GtkBubbleWindow
*
* Returns: the #GdkWindow @window is placed upon
*
* Since: 3.8
- **/
+ */
GdkWindow *
-gtk_bubble_window_get_relative_to (GtkBubbleWindow *window)
+_gtk_bubble_window_get_relative_to (GtkBubbleWindow *window)
{
GtkBubbleWindowPrivate *priv;
g_return_val_if_fail (GTK_IS_BUBBLE_WINDOW (window), NULL);
- priv = window->_priv;
+ priv = window->priv;
return priv->relative_to;
}
-/**
+/*
* gtk_bubble_window_set_pointing_to:
* @window: a #GtkBubbleWindow
* @rect: rectangle to point to
* gtk_bubble_window_set_relative_to().
*
* Since: 3.8
- **/
+ */
void
-gtk_bubble_window_set_pointing_to (GtkBubbleWindow *window,
- cairo_rectangle_int_t *rect)
+_gtk_bubble_window_set_pointing_to (GtkBubbleWindow *window,
+ cairo_rectangle_int_t *rect)
{
g_return_if_fail (GTK_IS_BUBBLE_WINDOW (window));
g_return_if_fail (rect != NULL);
- _gtk_bubble_window_update_pointing_to (window, rect);
+ gtk_bubble_window_update_pointing_to (window, rect);
if (gtk_widget_get_visible (GTK_WIDGET (window)))
- _gtk_bubble_window_update_position (window);
+ gtk_bubble_window_update_position (window);
}
-/**
+/*
* gtk_bubble_window_get_pointing_to:
* @window: a #GtkBubbleWindow
* @rect: (out): location to store the rectangle
* Returns: %TRUE if a rectangle is set
*
* Since: 3.8
- **/
+ */
gboolean
-gtk_bubble_window_get_pointing_to (GtkBubbleWindow *window,
- cairo_rectangle_int_t *rect)
+_gtk_bubble_window_get_pointing_to (GtkBubbleWindow *window,
+ cairo_rectangle_int_t *rect)
{
GtkBubbleWindowPrivate *priv;
g_return_val_if_fail (GTK_IS_BUBBLE_WINDOW (window), FALSE);
- priv = window->_priv;
+ priv = window->priv;
if (rect)
*rect = priv->pointing_to;
return priv->has_pointing_to;
}
-/**
+/*
* gtk_bubble_window_set_position:
* @window: a #GtkBubbleWindow
* @position: preferred bubble position
* </note>
*
* Since: 3.8
- **/
+ */
void
-gtk_bubble_window_set_position (GtkBubbleWindow *window,
- GtkPositionType position)
+_gtk_bubble_window_set_position (GtkBubbleWindow *window,
+ GtkPositionType position)
{
g_return_if_fail (GTK_IS_BUBBLE_WINDOW (window));
g_return_if_fail (position >= GTK_POS_LEFT && position <= GTK_POS_BOTTOM);
- _gtk_bubble_window_update_preferred_position (window, position);
+ gtk_bubble_window_update_preferred_position (window, position);
if (gtk_widget_get_visible (GTK_WIDGET (window)))
- _gtk_bubble_window_update_position (window);
+ gtk_bubble_window_update_position (window);
}
-/**
+/*
* gtk_bubble_window_get_position:
* @window: a #GtkBubbleWindow
*
* Returns: The preferred position
*
* Since: 3.8
- **/
+ */
GtkPositionType
-gtk_bubble_window_get_position (GtkBubbleWindow *window)
+_gtk_bubble_window_get_position (GtkBubbleWindow *window)
{
GtkBubbleWindowPrivate *priv;
g_return_val_if_fail (GTK_IS_BUBBLE_WINDOW (window), GTK_POS_TOP);
- priv = window->_priv;
+ priv = window->priv;
return priv->preferred_position;
}
-/**
+/*
* gtk_bubble_window_popup:
* @window: a #GtkBubbleWindow
* @relative_to: #GdkWindow to position upon
* parameters, and shows/updates @window
*
* Since: 3.8
- **/
+ */
void
-gtk_bubble_window_popup (GtkBubbleWindow *window,
- GdkWindow *relative_to,
- cairo_rectangle_int_t *pointing_to,
- GtkPositionType position)
+_gtk_bubble_window_popup (GtkBubbleWindow *window,
+ GdkWindow *relative_to,
+ cairo_rectangle_int_t *pointing_to,
+ GtkPositionType position)
{
g_return_if_fail (GTK_IS_BUBBLE_WINDOW (window));
g_return_if_fail (!relative_to || GDK_IS_WINDOW (relative_to));
g_return_if_fail (position >= GTK_POS_LEFT && position <= GTK_POS_BOTTOM);
g_return_if_fail (pointing_to != NULL);
- _gtk_bubble_window_update_preferred_position (window, position);
- _gtk_bubble_window_update_relative_to (window, relative_to);
- _gtk_bubble_window_update_pointing_to (window, pointing_to);
+ gtk_bubble_window_update_preferred_position (window, position);
+ gtk_bubble_window_update_relative_to (window, relative_to);
+ gtk_bubble_window_update_pointing_to (window, pointing_to);
if (!gtk_widget_get_visible (GTK_WIDGET (window)))
gtk_widget_show (GTK_WIDGET (window));
- _gtk_bubble_window_update_position (window);
+ gtk_bubble_window_update_position (window);
}
-/**
+/*
* gtk_bubble_window_popdown:
* @window: a #GtkBubbleWindow
*
* </note>
*
* Since: 3.8
- **/
+ */
void
-gtk_bubble_window_popdown (GtkBubbleWindow *window)
+_gtk_bubble_window_popdown (GtkBubbleWindow *window)
{
- GtkBubbleWindowPrivate *priv = window->_priv;
+ GtkBubbleWindowPrivate *priv = window->priv;
g_return_if_fail (GTK_IS_BUBBLE_WINDOW (window));
if (priv->grabbed)
- gtk_bubble_window_ungrab (window);
+ _gtk_bubble_window_ungrab (window);
if (gtk_widget_get_visible (GTK_WIDGET (window)))
gtk_widget_hide (GTK_WIDGET (window));
}
-/**
+/*
* gtk_bubble_window_grab:
* @window: a #GtkBubbleWindow
* @device: a master #GdkDevice
* Returns: %TRUE if the grab was successful
*
* Since: 3.8
- **/
+ */
gboolean
-gtk_bubble_window_grab (GtkBubbleWindow *window,
- GdkDevice *device,
- guint32 activate_time)
+_gtk_bubble_window_grab (GtkBubbleWindow *window,
+ GdkDevice *device,
+ guint32 activate_time)
{
GtkBubbleWindowPrivate *priv;
GdkDevice *other_device;
g_return_val_if_fail (GDK_IS_DEVICE (device), FALSE);
g_return_val_if_fail (gdk_device_get_device_type (device) == GDK_DEVICE_TYPE_MASTER, FALSE);
- priv = window->_priv;
+ priv = window->priv;
if (!priv->has_pointing_to ||
gdk_window_is_destroyed (priv->relative_to))
return FALSE;
if (priv->device)
- gtk_bubble_window_ungrab (window);
+ _gtk_bubble_window_ungrab (window);
gtk_widget_realize (GTK_WIDGET (window));
grab_window = gtk_widget_get_window (GTK_WIDGET (window));
return status == GDK_GRAB_SUCCESS;
}
-/**
+/*
* gtk_bubble_window_ungrab:
* @window: a #GtkBubbleWindow
*
* in this @window,
*
* Since: 3.8
- **/
+ */
void
-gtk_bubble_window_ungrab (GtkBubbleWindow *window)
+_gtk_bubble_window_ungrab (GtkBubbleWindow *window)
{
GtkBubbleWindowPrivate *priv;
g_return_if_fail (GTK_IS_BUBBLE_WINDOW (window));
- priv = window->_priv;
+ priv = window->priv;
if (!priv->device)
return;
projects / ~andy / gtk / blobdiff