X-Git-Url: http://pileus.org/git/?a=blobdiff_plain;f=gtk%2Fgtkbubblewindow.c;h=f46887808070ae1020803bc10841c015c2921a8c;hb=cc75ebec15d8fddbd0485e1b82a3c6c9e71f8a64;hp=4198a95814b8012d90d5b009bae0c52c30350b1d;hpb=51be6b88dbff3ff6ed83d1247508ad58c0278df6;p=~andy%2Fgtk

diff --git a/gtk/gtkbubblewindow.c b/gtk/gtkbubblewindow.c
index 4198a9581..f46887808 100644
--- a/gtk/gtkbubblewindow.c
+++ b/gtk/gtkbubblewindow.c
@@ -15,11 +15,7 @@
  * 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.
  *
@@ -39,7 +35,9 @@
 #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"
 
@@ -74,17 +72,17 @@ struct _GtkBubbleWindowPrivate
   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),
@@ -96,6 +94,9 @@ gtk_bubble_window_init (GtkBubbleWindow *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 *
@@ -106,7 +107,7 @@ gtk_bubble_window_constructor (GType                  type,
   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);
@@ -123,16 +124,16 @@ gtk_bubble_window_set_property (GObject      *object,
   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);
@@ -145,7 +146,7 @@ gtk_bubble_window_get_property (GObject    *object,
                                 GValue     *value,
                                 GParamSpec *pspec)
 {
-  GtkBubbleWindowPrivate *priv = GTK_BUBBLE_WINDOW (object)->_priv;
+  GtkBubbleWindowPrivate *priv = GTK_BUBBLE_WINDOW (object)->priv;
 
   switch (prop_id)
     {
@@ -167,23 +168,23 @@ static void
 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;
 
@@ -218,80 +219,216 @@ _gtk_bubble_window_get_pointed_to_coords (GtkBubbleWindow       *window,
 }
 
 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 + TAIL_GAP_WIDTH / 2,
-                                TAIL_GAP_WIDTH, allocation->width), base);
-      cairo_line_to (cr, CLAMP (x - priv->win_x, 0, allocation->width), tip);
+      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, 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));
+      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);
     }
 
-  cairo_close_path (cr);
+  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);
+  gtk_bubble_window_get_rect_coords (window, &x1, &y1, &x2, &y2);
+
   if (priv->final_position == GTK_POS_TOP)
-    cairo_rectangle (cr, 0, 0, allocation.width, 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_rectangle (cr, 0, TAIL_HEIGHT , allocation.width,
-                     allocation.height - 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_rectangle (cr, 0, 0, allocation.width - TAIL_HEIGHT, allocation.height);
+    {
+      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_rectangle (cr, TAIL_HEIGHT, 0,
-                     allocation.width - 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);
+    }
 
-  _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;
@@ -306,7 +443,7 @@ _gtk_bubble_window_update_shape (GtkBubbleWindow *window)
                                        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);
 
@@ -321,7 +458,7 @@ _gtk_bubble_window_update_shape (GtkBubbleWindow *window)
 }
 
 static void
-_gtk_bubble_window_update_position (GtkBubbleWindow *window)
+gtk_bubble_window_update_position (GtkBubbleWindow *window)
 {
   GtkBubbleWindowPrivate *priv;
   cairo_rectangle_int_t rect;
@@ -329,13 +466,13 @@ _gtk_bubble_window_update_position (GtkBubbleWindow *window)
   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.
@@ -385,9 +522,16 @@ gtk_bubble_window_draw (GtkWidget *widget,
   GtkStyleContext *context;
   GtkAllocation allocation;
   GtkWidget *child;
+  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);
 
   if (gtk_widget_is_composited (widget))
@@ -397,23 +541,95 @@ gtk_bubble_window_draw (GtkWidget *widget,
       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_apply_border_path (GTK_BUBBLE_WINDOW (widget), cr);
-      cairo_clip (cr);
+  gtk_bubble_window_get_gap_coords (GTK_BUBBLE_WINDOW (widget),
+                                    &initial_x, &initial_y,
+                                    NULL, NULL,
+                                    &final_x, &final_y,
+                                    &gap_side);
+
+  if (POS_IS_VERTICAL (gap_side))
+    {
+      gap_start = initial_x;
+      gap_end = final_x;
+    }
+  else
+    {
+      gap_start = initial_y;
+      gap_end = final_y;
     }
 
-  gtk_render_background (context, cr, 0, 0,
+  /* 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);
+
+  /* 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);
+
+  /* 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);
+    }
+
+  /* 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;
 }
 
+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,
@@ -422,14 +638,19 @@ gtk_bubble_window_get_preferred_width (GtkWidget *widget,
   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;
@@ -451,13 +672,18 @@ gtk_bubble_window_get_preferred_height (GtkWidget *widget,
   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))
     {
@@ -479,17 +705,21 @@ gtk_bubble_window_size_allocate (GtkWidget     *widget,
   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;
@@ -505,10 +735,10 @@ gtk_bubble_window_size_allocate (GtkWidget     *widget,
     }
 
   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
@@ -529,10 +759,10 @@ gtk_bubble_window_button_press (GtkWidget      *widget,
           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;
 }
@@ -543,7 +773,7 @@ gtk_bubble_window_key_press (GtkWidget   *widget,
 {
   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;
     }
 
@@ -558,12 +788,12 @@ gtk_bubble_window_grab_broken (GtkWidget          *widget,
   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;
 }
@@ -575,10 +805,10 @@ gtk_bubble_window_grab_notify (GtkWidget *widget,
   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
@@ -596,7 +826,7 @@ gtk_bubble_window_screen_changed (GtkWidget *widget,
 }
 
 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);
@@ -642,12 +872,12 @@ gtk_bubble_window_class_init (GtkBubbleWindowClass *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;
@@ -660,29 +890,29 @@ _gtk_bubble_window_update_relative_to (GtkBubbleWindow *window,
 }
 
 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
@@ -690,14 +920,14 @@ _gtk_bubble_window_update_preferred_position (GtkBubbleWindow *window,
  * 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
@@ -710,21 +940,21 @@ gtk_bubble_window_new (void)
  * 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
  *
@@ -735,20 +965,20 @@ gtk_bubble_window_set_relative_to (GtkBubbleWindow *window,
  * 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
@@ -758,21 +988,21 @@ gtk_bubble_window_get_relative_to (GtkBubbleWindow *window)
  * 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
@@ -784,16 +1014,16 @@ gtk_bubble_window_set_pointing_to (GtkBubbleWindow       *window,
  * 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;
@@ -801,7 +1031,7 @@ gtk_bubble_window_get_pointing_to (GtkBubbleWindow       *window,
   return priv->has_pointing_to;
 }
 
-/**
+/*
  * gtk_bubble_window_set_position:
  * @window: a #GtkBubbleWindow
  * @position: preferred bubble position
@@ -817,21 +1047,21 @@ gtk_bubble_window_get_pointing_to (GtkBubbleWindow       *window,
  * </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
  *
@@ -840,20 +1070,20 @@ gtk_bubble_window_set_position (GtkBubbleWindow *window,
  * 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
@@ -864,29 +1094,29 @@ gtk_bubble_window_get_position (GtkBubbleWindow *window)
  * 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
  *
@@ -898,22 +1128,22 @@ gtk_bubble_window_popup (GtkBubbleWindow       *window,
  * </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
@@ -935,11 +1165,11 @@ gtk_bubble_window_popdown (GtkBubbleWindow *window)
  * 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;
@@ -950,14 +1180,14 @@ gtk_bubble_window_grab (GtkBubbleWindow *window,
   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));
@@ -987,7 +1217,7 @@ gtk_bubble_window_grab (GtkBubbleWindow *window,
   return status == GDK_GRAB_SUCCESS;
 }
 
-/**
+/*
  * gtk_bubble_window_ungrab:
  * @window: a #GtkBubbleWindow
  *
@@ -995,15 +1225,15 @@ gtk_bubble_window_grab (GtkBubbleWindow *window,
  * 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;