* 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"
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),
if (visual)
gtk_widget_set_visual (widget, visual);
+
+ gtk_style_context_add_class (gtk_widget_get_style_context (widget),
+ GTK_STYLE_CLASS_OSD);
}
static GObject *
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_get_gap_coords (GtkBubbleWindow *window,
+ gint *initial_x_out,
+ gint *initial_y_out,
+ gint *tip_x_out,
+ gint *tip_y_out,
+ gint *final_x_out,
+ gint *final_y_out,
+ GtkPositionType *gap_side_out)
{
- GtkBubbleWindowPrivate *priv = window->_priv;
+ GtkBubbleWindowPrivate *priv = window->priv;
gint base, tip, x, y;
+ gint initial_x, initial_y;
+ gint tip_x, tip_y;
+ gint final_x, final_y;
+ GtkPositionType gap_side;
+ GtkAllocation allocation;
- _gtk_bubble_window_get_pointed_to_coords (window, &x, &y, NULL);
+ gtk_bubble_window_get_pointed_to_coords (window, &x, &y, NULL);
+ gtk_widget_get_allocation (GTK_WIDGET (window), &allocation);
+
+ base = tip = 0;
+ gap_side = GTK_POS_LEFT;
if (priv->final_position == GTK_POS_BOTTOM ||
priv->final_position == GTK_POS_RIGHT)
{
base = TAIL_HEIGHT;
tip = 0;
+
+ gap_side = (priv->final_position == GTK_POS_BOTTOM) ? GTK_POS_TOP : GTK_POS_LEFT;
}
else if (priv->final_position == GTK_POS_TOP)
{
- base = allocation->height - TAIL_HEIGHT;
- tip = allocation->height;
+ base = allocation.height - TAIL_HEIGHT;
+ tip = allocation.height;
+ gap_side = GTK_POS_BOTTOM;
}
else if (priv->final_position == GTK_POS_LEFT)
{
- base = allocation->width - TAIL_HEIGHT;
- tip = allocation->width;
+ base = allocation.width - TAIL_HEIGHT;
+ tip = allocation.width;
+ gap_side = GTK_POS_RIGHT;
}
if (POS_IS_VERTICAL (priv->final_position))
{
- 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);
+ initial_x = CLAMP (x - priv->win_x - TAIL_GAP_WIDTH / 2,
+ 0, allocation.width - TAIL_GAP_WIDTH);
+ initial_y = base;
+
+ tip_x = CLAMP (x - priv->win_x, 0, allocation.width);
+ tip_y = tip;
+
+ final_x = CLAMP (x - priv->win_x + TAIL_GAP_WIDTH / 2,
+ TAIL_GAP_WIDTH, allocation.width);
+ final_y = base;
}
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));
+ initial_x = base;
+ initial_y = CLAMP (y - priv->win_y - TAIL_GAP_WIDTH / 2,
+ 0, allocation.height - TAIL_GAP_WIDTH);
+
+ tip_x = tip;
+ tip_y = CLAMP (y - priv->win_y, 0, allocation.height);
+
+ final_x = base;
+ final_y = CLAMP (y - priv->win_y + TAIL_GAP_WIDTH / 2,
+ TAIL_GAP_WIDTH, allocation.height);
}
+
+ if (initial_x_out)
+ *initial_x_out = initial_x;
+ if (initial_y_out)
+ *initial_y_out = initial_y;
+
+ if (tip_x_out)
+ *tip_x_out = tip_x;
+ if (tip_y_out)
+ *tip_y_out = tip_y;
+
+ if (final_x_out)
+ *final_x_out = final_x;
+ if (final_y_out)
+ *final_y_out = final_y;
+
+ if (gap_side_out)
+ *gap_side_out = gap_side;
}
static void
-_gtk_bubble_window_apply_border_path (GtkBubbleWindow *window,
- cairo_t *cr)
+gtk_bubble_window_get_rect_coords (GtkBubbleWindow *window,
+ gint *x1_out,
+ gint *y1_out,
+ gint *x2_out,
+ gint *y2_out)
+{
+ GtkBubbleWindowPrivate *priv = window->priv;
+ gint x1, x2, y1, y2;
+ GtkAllocation allocation;
+
+ x1 = y1 = x2 = y2 = 0;
+ gtk_widget_get_allocation (GTK_WIDGET (window), &allocation);
+
+ if (priv->final_position == GTK_POS_TOP)
+ {
+ x1 = 0;
+ y1 = 0;
+ x2 = allocation.width;
+ y2 = allocation.height - TAIL_HEIGHT;
+ }
+ else if (priv->final_position == GTK_POS_BOTTOM)
+ {
+ x1 = 0;
+ y1 = TAIL_HEIGHT;
+ x2 = allocation.width;
+ y2 = allocation.height;
+ }
+ else if (priv->final_position == GTK_POS_LEFT)
+ {
+ x1 = 0;
+ y1 = 0;
+ x2 = allocation.width - TAIL_HEIGHT;
+ y2 = allocation.height;
+ }
+ else if (priv->final_position == GTK_POS_RIGHT)
+ {
+ x1 = TAIL_HEIGHT;
+ y1 = 0;
+ x2 = allocation.width;
+ y2 = allocation.height;
+ }
+
+ if (x1_out)
+ *x1_out = x1;
+ if (y1_out)
+ *y1_out = y1;
+ if (x2_out)
+ *x2_out = x2;
+ if (y2_out)
+ *y2_out = y2;
+}
+
+static void
+gtk_bubble_window_apply_tail_path (GtkBubbleWindow *window,
+ cairo_t *cr)
+{
+ gint initial_x, initial_y;
+ gint tip_x, tip_y;
+ gint final_x, final_y;
+
+ gtk_bubble_window_get_gap_coords (window,
+ &initial_x, &initial_y,
+ &tip_x, &tip_y,
+ &final_x, &final_y,
+ NULL);
+
+ cairo_move_to (cr, initial_x, initial_y);
+ cairo_line_to (cr, tip_x, tip_y);
+ cairo_line_to (cr, final_x, final_y);
+}
+
+static void
+gtk_bubble_window_apply_border_path (GtkBubbleWindow *window,
+ cairo_t *cr)
{
GtkBubbleWindowPrivate *priv;
GtkAllocation allocation;
+ gint x1, y1, x2, y2;
- priv = window->_priv;
+ priv = window->priv;
gtk_widget_get_allocation (GTK_WIDGET (window), &allocation);
- _gtk_bubble_window_apply_tail_path (window, cr, &allocation);
+ gtk_bubble_window_apply_tail_path (window, cr);
+ gtk_bubble_window_get_rect_coords (window, &x1, &y1, &x2, &y2);
if (priv->final_position == GTK_POS_TOP)
{
- 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);
+ cairo_line_to (cr, x2, y2);
+ cairo_line_to (cr, x2, y1);
+ cairo_line_to (cr, x1, y1);
+ cairo_line_to (cr, x1, y2);
}
else if (priv->final_position == GTK_POS_BOTTOM)
{
- 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);
+ cairo_line_to (cr, x2, y1);
+ cairo_line_to (cr, x2, y2);
+ cairo_line_to (cr, x1, y2);
+ cairo_line_to (cr, x1, y1);
}
else if (priv->final_position == GTK_POS_LEFT)
{
- 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);
+ cairo_line_to (cr, x2, y2);
+ cairo_line_to (cr, x1, y2);
+ cairo_line_to (cr, x1, y1);
+ cairo_line_to (cr, x2, y1);
}
else if (priv->final_position == GTK_POS_RIGHT)
{
- 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);
+ cairo_line_to (cr, x1, y1);
+ cairo_line_to (cr, x2, y1);
+ cairo_line_to (cr, x2, y2);
+ cairo_line_to (cr, x1, y2);
}
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;
+ GtkBorder border;
+ GdkRGBA border_color;
+ gint rect_x1, rect_x2, rect_y1, rect_y2;
+ gint initial_x, initial_y, final_x, final_y;
+ gint gap_start, gap_end;
+ GtkPositionType gap_side;
+ GtkStateFlags state;
- cairo_save (cr);
context = gtk_widget_get_style_context (widget);
+ state = gtk_widget_get_state_flags (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_set_source_rgba (cr, 0, 0, 0, 0);
cairo_paint (cr);
cairo_restore (cr);
+ }
+
+ gtk_bubble_window_get_rect_coords (GTK_BUBBLE_WINDOW (widget),
+ &rect_x1, &rect_y1,
+ &rect_x2, &rect_y2);
+
+ /* Render the rect background */
+ gtk_render_background (context, cr,
+ rect_x1, rect_y1,
+ rect_x2 - rect_x1, rect_y2 - rect_y1);
+
+ gtk_bubble_window_get_gap_coords (GTK_BUBBLE_WINDOW (widget),
+ &initial_x, &initial_y,
+ NULL, NULL,
+ &final_x, &final_y,
+ &gap_side);
- _gtk_bubble_window_apply_border_path (GTK_BUBBLE_WINDOW (widget), cr);
- cairo_clip (cr);
+ if (POS_IS_VERTICAL (gap_side))
+ {
+ gap_start = initial_x;
+ gap_end = final_x;
}
+ else
+ {
+ gap_start = initial_y;
+ gap_end = final_y;
+ }
+
+ /* Now render the frame, without the gap for the arrow tip */
+ gtk_render_frame_gap (context, cr,
+ rect_x1, rect_y1,
+ rect_x2 - rect_x1, rect_y2 - rect_y1,
+ gap_side,
+ gap_start, gap_end);
- gtk_render_background (context, cr, 0, 0,
+ /* Clip to the arrow shape */
+ cairo_save (cr);
+
+ gtk_bubble_window_apply_tail_path (GTK_BUBBLE_WINDOW (widget), cr);
+ cairo_clip (cr);
+
+ /* Render the arrow background */
+ 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);
+ /* Render the border of the arrow tip */
+ gtk_style_context_get_border (context, state, &border);
+
+ if (border.bottom > 0)
+ {
+ gtk_style_context_get_border_color (context, state, &border_color);
+ gtk_bubble_window_apply_tail_path (GTK_BUBBLE_WINDOW (widget), cr);
+ gdk_cairo_set_source_rgba (cr, &border_color);
+
+ cairo_set_line_width (cr, border.bottom);
+ cairo_stroke (cr);
+ }
- _gtk_bubble_window_apply_border_path (GTK_BUBBLE_WINDOW (widget), cr);
- gdk_cairo_set_source_rgba (cr, border);
- cairo_stroke (cr);
+ /* We're done */
+ cairo_restore (cr);
child = gtk_bin_get_child (GTK_BIN (widget));
if (child)
gtk_container_propagate_draw (GTK_CONTAINER (widget), child, cr);
- cairo_restore (cr);
+ return TRUE;
+}
- gdk_rgba_free (border);
+static void
+get_padding_and_border (GtkWidget *widget,
+ GtkBorder *border)
+{
+ GtkStyleContext *context;
+ GtkStateFlags state;
+ GtkBorder tmp;
- return TRUE;
+ 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
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;
- child_alloc.x = child_alloc.y = 0;
- child_alloc.width = allocation->width;
- child_alloc.height = allocation->height;
+ get_padding_and_border (widget, &border);
+
+ 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