[gtk/wip/matthiasc/popup4: 28/76] Reimplement GtkPopover



commit d31de77a6a03fb4669ed689725ae0d99fb761139
Author: Matthias Clasen <mclasen redhat com>
Date:   Tue Mar 19 22:49:32 2019 -0400

    Reimplement GtkPopover

 gtk/gtkmain.c               |   21 +
 gtk/gtkpopover.c            | 2708 ++++++++++++++++---------------------------
 gtk/gtkpopover.h            |   98 +-
 gtk/gtkpopovermenu.c        |    2 +
 gtk/gtkpopoverprivate.h     |    2 -
 gtk/gtkwidget.c             |   10 +-
 gtk/gtkwindow.c             |    2 +
 gtk/inspector/object-tree.c |    2 +
 tests/meson.build           |    1 -
 tests/testpopup.c           |   62 -
 10 files changed, 1075 insertions(+), 1833 deletions(-)
---
diff --git a/gtk/gtkmain.c b/gtk/gtkmain.c
index e24c52f971..5f974ac99c 100644
--- a/gtk/gtkmain.c
+++ b/gtk/gtkmain.c
@@ -1329,6 +1329,27 @@ rewrite_event_for_grabs (GdkEvent *event)
   event_widget = gtk_get_event_widget (event);
   grab_widget = gtk_root_get_for_surface (grab_surface);
 
+  switch ((guint) event->any.type)
+    {
+    case GDK_BUTTON_PRESS:
+    case GDK_BUTTON_RELEASE:
+    case GDK_KEY_PRESS:
+    case GDK_KEY_RELEASE:
+    case GDK_TOUCH_BEGIN:
+    case GDK_TOUCH_END:
+    case GDK_TOUCH_CANCEL:
+    case GDK_TOUCHPAD_SWIPE:
+    case GDK_TOUCHPAD_PINCH:
+      if (grab_surface != event->any.surface &&
+          GTK_IS_POPOVER (grab_widget))
+        {
+          gtk_widget_hide (grab_widget);
+          return NULL;
+        }
+      break;
+    default:;
+    }
+
   if (grab_widget &&
       gtk_main_get_window_group (grab_widget) != gtk_main_get_window_group (event_widget))
     return rewrite_event_for_surface (event, grab_surface);
diff --git a/gtk/gtkpopover.c b/gtk/gtkpopover.c
index 58cd6473bd..078c970e0d 100644
--- a/gtk/gtkpopover.c
+++ b/gtk/gtkpopover.c
@@ -1,5 +1,8 @@
 /* GTK - The GIMP Toolkit
- * Copyright © 2013 Carlos Garnacho <carlosg gnome org>
+ * Copyright (C) 2019 Red Hat, Inc.
+ *
+ * Authors:
+ * - Matthias Clasen <mclasen redhat com>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -22,7 +25,8 @@
  *
  * GtkPopover is a bubble-like context window, primarily meant to
  * provide context-dependent information or options. Popovers are
- * attached to a widget, passed at construction time on gtk_popover_new(),
+ * attached to a widget, passed at construction time on gtk_popover_new
+(),
  * or updated afterwards through gtk_popover_set_relative_to(), by
  * default they will point to the whole widget area, although this
  * behavior can be changed through gtk_popover_set_pointing_to().
@@ -104,128 +108,256 @@
 #include "config.h"
 
 #include "gtkpopoverprivate.h"
-
-#include "gtkadjustment.h"
-#include "gtkbox.h"
-#include "gtkbutton.h"
-#include "gtkcontainerprivate.h"
+#include "gtkroot.h"
+#include "gtkwidgetprivate.h"
+#include "gtkeventcontrollerkey.h"
 #include "gtkcssnodeprivate.h"
-#include "gtkentry.h"
+#include "gtkbindings.h"
+#include "gtkenums.h"
+#include "gtktypebuiltins.h"
+#include "gtkmnemonichash.h"
 #include "gtkgizmoprivate.h"
 #include "gtkintl.h"
-#include "gtklabel.h"
-#include "gtkmain.h"
-#include "gtkmenusectionbox.h"
-#include "gtkmenutracker.h"
-#include "gtkmodelbutton.h"
 #include "gtkprivate.h"
-#include "gtkprogresstrackerprivate.h"
-#include "gtkrender.h"
-#include "gtkroundedboxprivate.h"
-#include "gtkscrollable.h"
-#include "gtksettingsprivate.h"
-#include "gtksizegroup.h"
-#include "gtksnapshot.h"
+#include "gtkmain.h"
 #include "gtkstack.h"
-#include "gtkstylecontextprivate.h"
-#include "gtktypebuiltins.h"
-#include "gtkwidgetprivate.h"
-#include "gtkwindowprivate.h"
-#include "gtkgesturemultipress.h"
-#include "gtkeventcontrollerkey.h"
+#include "gtkmenusectionbox.h"
+#include "gdk/gdkeventsprivate.h"
+#include "gtkpointerfocusprivate.h"
+#include "gtkcssnodeprivate.h"
 
-#include "a11y/gtkpopoveraccessible.h"
+static GListStore *popover_list = NULL;
 
-#include "gsk/gskroundedrectprivate.h"
+typedef struct {
+  GdkDisplay *display;
+  GskRenderer *renderer;
+  GdkSurface *surface;
+  GtkWidget *focus_widget;
+  gboolean active;
+  GtkWidget *default_widget;
+  GtkMnemonicHash *mnemonic_hash;
+  GList *foci;
 
-#ifdef GDK_WINDOWING_WAYLAND
-#include "wayland/gdkwayland.h"
-#endif
+  GdkSurfaceState state;
+  GtkWidget *relative_to;
+  GdkRectangle pointing_to;
+  gboolean has_pointing_to;
+  GtkPositionType position;
+  gboolean modal;
+  gboolean has_grab;
+
+  GtkWidget *contents_widget;
+} GtkPopoverPrivate;
 
-#define TAIL_GAP_WIDTH  24
-#define TAIL_HEIGHT     12
-#define TRANSITION_DIFF 20
-#define TRANSITION_DURATION 150 * 1000
+enum {
+  ACTIVATE_FOCUS,
+  ACTIVATE_DEFAULT,
+  CLOSE,
+  CLOSED,
+  LAST_SIGNAL
+};
 
-#define POS_IS_VERTICAL(p) ((p) == GTK_POS_TOP || (p) == GTK_POS_BOTTOM)
+static guint signals[LAST_SIGNAL] = { 0 };
 
 enum {
   PROP_RELATIVE_TO = 1,
   PROP_POINTING_TO,
   PROP_POSITION,
   PROP_MODAL,
-  PROP_CONSTRAIN_TO,
   NUM_PROPERTIES
 };
 
-enum {
-  CLOSED,
-  N_SIGNALS
-};
+static void gtk_popover_set_is_active (GtkPopover *popover,
+                                       gboolean    active);
+static void gtk_popover_set_focus     (GtkPopover *popover,
+                                       GtkWidget  *widget);
+static void gtk_popover_set_default   (GtkPopover *popover,
+                                       GtkWidget  *widget);
 
-enum {
-  STATE_SHOWING,
-  STATE_SHOWN,
-  STATE_HIDING,
-  STATE_HIDDEN
-};
+static GParamSpec *properties[NUM_PROPERTIES] = { NULL };
+
+static void gtk_popover_root_interface_init (GtkRootInterface *iface);
 
-typedef struct _GtkPopoverPrivate GtkPopoverPrivate;
-struct _GtkPopoverPrivate
+G_DEFINE_TYPE_WITH_CODE (GtkPopover, gtk_popover, GTK_TYPE_BIN,
+                         G_ADD_PRIVATE (GtkPopover)
+                         G_IMPLEMENT_INTERFACE (GTK_TYPE_ROOT,
+                                                gtk_popover_root_interface_init))
+
+
+static GdkDisplay *
+gtk_popover_root_get_display (GtkRoot *root)
 {
-  GtkWidget *widget;
-  GtkWidget *contents_widget;
-  GtkCssNode *arrow_node;
-  GtkWindow *window;
-  GtkWidget *prev_focus_widget;
-  GtkWidget *default_widget;
-  GtkWidget *prev_default;
-  GtkScrollable *parent_scrollable;
-  GtkAdjustment *vadj;
-  GtkAdjustment *hadj;
-  GdkRectangle pointing_to;
-  GtkPopoverConstraint constraint;
-  GtkProgressTracker tracker;
-  guint prev_focus_unmap_id;
-  guint hierarchy_changed_id;
-  guint size_allocate_id;
-  guint unmap_id;
-  guint scrollable_notify_id;
-  guint grab_notify_id;
-  guint state_changed_id;
-  guint has_pointing_to    : 1;
-  guint preferred_position : 2;
-  guint final_position     : 2;
-  guint current_position   : 2;
-  guint modal              : 1;
-  guint button_pressed     : 1;
-  guint grab_notify_blocked : 1;
-  guint state               : 2;
-  guint visible             : 1;
-  guint first_frame_skipped : 1;
-  gint transition_diff;
-  guint tick_id;
-
-  gint tip_x;
-  gint tip_y;
-};
+  GtkPopover *popover = GTK_POPOVER (root);
+  GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
+
+  return priv->display;
+}
+
+static GskRenderer *
+gtk_popover_root_get_renderer (GtkRoot *root)
+{
+  GtkPopover *popover = GTK_POPOVER (root);
+  GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
+
+  return priv->renderer;
+}
+
+static void
+gtk_popover_root_get_surface_transform (GtkRoot *root,
+                                        int     *x,
+                                        int     *y)
+{
+  GtkStyleContext *context;
+  GtkBorder margin, border, padding;
+
+  context = gtk_widget_get_style_context (GTK_WIDGET (root));
+  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;
+}
+
+static void
+move_to_rect (GtkPopover *popover)
+{
+  GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
+  GdkRectangle rect;
+  GdkGravity parent_anchor;
+  GdkGravity surface_anchor;
+  GdkAnchorHints anchor_hints;
+
+  gtk_widget_get_surface_allocation (priv->relative_to, &rect);
+  if (priv->has_pointing_to)
+    {
+      rect.x += priv->pointing_to.x;
+      rect.y += priv->pointing_to.y;
+      rect.width = priv->pointing_to.width;
+      rect.height = priv->pointing_to.height;
+    }
+
+  switch (priv->position)
+    {
+    case GTK_POS_LEFT:
+      parent_anchor = GDK_GRAVITY_WEST;
+      surface_anchor = GDK_GRAVITY_EAST;
+      anchor_hints = GDK_ANCHOR_FLIP_X;
+      break;
+
+    case GTK_POS_RIGHT:
+      parent_anchor = GDK_GRAVITY_EAST;
+      surface_anchor = GDK_GRAVITY_WEST;
+      anchor_hints = GDK_ANCHOR_FLIP_X;
+      break;
+
+    case GTK_POS_TOP:
+      parent_anchor = GDK_GRAVITY_NORTH;
+      surface_anchor = GDK_GRAVITY_SOUTH;
+      anchor_hints = GDK_ANCHOR_FLIP_Y;
+      break;
+
+    case GTK_POS_BOTTOM:
+      parent_anchor = GDK_GRAVITY_SOUTH;
+      surface_anchor = GDK_GRAVITY_NORTH;
+      anchor_hints = GDK_ANCHOR_FLIP_Y;
+      break;
+
+    default:
+      g_assert_not_reached ();
+    }
+
+  gdk_surface_move_to_rect (priv->surface,
+                            &rect,
+                            parent_anchor,
+                            surface_anchor,
+                            anchor_hints,
+                            0, 0);
+}
+
+static void
+gtk_popover_move_resize (GtkPopover *popover)
+{
+  GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
+  GtkRequisition req;
+ 
+  gtk_widget_get_preferred_size (GTK_WIDGET (popover), NULL, &req);
+  gdk_surface_resize (priv->surface, req.width, req.height);
+  move_to_rect (popover);
+}
+
+static void
+gtk_popover_root_check_resize (GtkRoot *root)
+{
+  GtkPopover *popover = GTK_POPOVER (root);
+  GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
+  GtkWidget *widget = GTK_WIDGET (popover);
+
+  if (!_gtk_widget_get_alloc_needed (widget))
+    gtk_widget_ensure_allocate (widget);
+  else if (gtk_widget_get_visible (widget))
+    {
+      gtk_popover_move_resize (popover);
+      gtk_widget_allocate (GTK_WIDGET (popover),
+                           gdk_surface_get_width (priv->surface),
+                           gdk_surface_get_height (priv->surface),
+                           -1, NULL);
+    }
+}
+
+
+static void
+gtk_popover_focus_in (GtkWidget *widget)
+{
+  gtk_popover_set_is_active (GTK_POPOVER (widget), TRUE);
+}
+
+static void
+gtk_popover_focus_out (GtkWidget *widget)
+{
+  gtk_popover_set_is_active (GTK_POPOVER (widget), FALSE);
+}
+
+static void
+ensure_state_flag_backdrop (GtkWidget *widget)
+{
+  GtkPopover *popover = GTK_POPOVER (widget);
+  GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
+
+  if ((priv->state & GDK_SURFACE_STATE_FOCUSED) != 0)
+    gtk_widget_unset_state_flags (widget, GTK_STATE_FLAG_BACKDROP);
+  else
+    gtk_widget_set_state_flags (widget, GTK_STATE_FLAG_BACKDROP, FALSE);
+}
 
-static GParamSpec *properties[NUM_PROPERTIES];
-static GQuark quark_widget_popovers = 0;
-static guint signals[N_SIGNALS] = { 0 };
+static void
+surface_state_changed (GtkWidget *widget)
+{
+  GtkPopover *popover = GTK_POPOVER (widget);
+  GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
+  GdkSurfaceState new_surface_state;
+  GdkSurfaceState changed_mask;
 
-static void gtk_popover_update_relative_to (GtkPopover *popover,
-                                            GtkWidget  *relative_to);
-static void gtk_popover_set_state          (GtkPopover *popover,
-                                            guint       state);
-static void gtk_popover_apply_modality     (GtkPopover *popover,
-                                            gboolean    modal);
+  new_surface_state = gdk_surface_get_state (_gtk_widget_get_surface (widget));
+  changed_mask = new_surface_state ^ priv->state;
+  priv->state = new_surface_state;
 
-static void gtk_popover_set_scrollable_full (GtkPopover    *popover,
-                                             GtkScrollable *scrollable);
+  if (changed_mask & GDK_SURFACE_STATE_FOCUSED)
+    ensure_state_flag_backdrop (widget);
 
-G_DEFINE_TYPE_WITH_PRIVATE (GtkPopover, gtk_popover, GTK_TYPE_BIN)
+  if (changed_mask & GDK_SURFACE_STATE_WITHDRAWN)
+    {
+      if (priv->state & GDK_SURFACE_STATE_WITHDRAWN)
+        gtk_widget_hide (widget);
+    }
+}
 
+static void
+surface_size_changed (GtkWindow *window,
+                      guint      width,
+                      guint      height)
+{
+}
 
 static void
 measure_contents (GtkGizmo       *gizmo,
@@ -256,262 +388,165 @@ allocate_contents (GtkGizmo *gizmo,
 
   if (child)
     gtk_widget_size_allocate (child,
-                              &(GtkAllocation) {
-                                0, 0,
-                                width, height
+                              &(GtkAllocation) { 0, 0, width, height
                               }, -1);
 }
 
 static void
-node_style_changed_cb (GtkCssNode        *node,
-                       GtkCssStyleChange *change,
-                       GtkWidget         *widget)
+gtk_popover_init (GtkPopover *popover)
 {
-  if (gtk_css_style_change_affects (change, GTK_CSS_AFFECTS_SIZE))
-    gtk_widget_queue_resize (widget);
-  else
-    gtk_widget_queue_draw (widget);
+  GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
+  GtkEventController *controller;
+  GtkStyleContext *context;
+
+  gtk_widget_set_has_surface (GTK_WIDGET (popover), TRUE);
+
+  priv->position = GTK_POS_TOP;
+  priv->modal = TRUE;
+
+  priv->display = gdk_display_get_default ();
+
+  controller = gtk_event_controller_key_new ();
+  g_signal_connect_swapped (controller, "focus-in", G_CALLBACK (gtk_popover_focus_in), popover);
+  g_signal_connect_swapped (controller, "focus-out", G_CALLBACK (gtk_popover_focus_out), popover);
+  gtk_widget_add_controller (GTK_WIDGET (popover), controller);
+
+  priv->contents_widget = gtk_gizmo_new ("contents",
+                                         measure_contents,
+                                         allocate_contents,
+                                         NULL,
+                                         NULL);
+  gtk_widget_set_parent (priv->contents_widget, GTK_WIDGET (popover));
+
+  context = gtk_widget_get_style_context (GTK_WIDGET (popover));
+  gtk_style_context_add_class (context, GTK_STYLE_CLASS_BACKGROUND);
 }
 
-static gboolean
-key_controller_key_pressed (GtkEventControllerKey *key,
-                            guint                  keyval,
-                            guint                  keycode,
-                            GdkModifierType        modifiers,
-                            GtkPopover            *popover)
+static void
+gtk_popover_realize (GtkWidget *widget)
 {
+  GtkPopover *popover = GTK_POPOVER (widget);
   GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
-  GtkWidget *toplevel, *focus;
+  GdkRectangle parent_rect;
 
-  if (keyval == GDK_KEY_Escape)
-    {
-      gtk_popover_popdown (popover);
-      return TRUE;
-    }
+  gtk_widget_get_surface_allocation (priv->relative_to, &parent_rect);
 
-  if (priv->modal)
-    {
-      toplevel = gtk_widget_get_toplevel (GTK_WIDGET (popover));
+  priv->surface = gdk_surface_new_popup_full (priv->display, gtk_widget_get_surface (priv->relative_to));
 
-      if (GTK_IS_WINDOW (toplevel))
-        {
-          focus = gtk_window_get_focus (GTK_WINDOW (toplevel));
+  gtk_widget_set_surface (widget, priv->surface);
+  g_signal_connect_swapped (priv->surface, "notify::state", G_CALLBACK (surface_state_changed), widget);
+  g_signal_connect_swapped (priv->surface, "size-changed", G_CALLBACK (surface_size_changed), widget);
 
-          if (focus && gtk_widget_is_ancestor (focus, GTK_WIDGET (popover)))
-            {
-              if (gtk_event_controller_key_forward (key, focus))
-                return TRUE;
-            }
+  gtk_widget_register_surface (widget, priv->surface);
 
-          /* Piggyback on the toplevel to have it handle key navigation */
-          return gtk_event_controller_key_forward (key, toplevel);
-        }
-    }
+  GTK_WIDGET_CLASS (gtk_popover_parent_class)->realize (widget);
 
-  return FALSE;
+  priv->renderer = gsk_renderer_new_for_surface (priv->surface);
 }
 
 static void
-gesture_pressed (GtkGestureMultiPress *gesture,
-                 gint                  n_press,
-                 gdouble               x,
-                 gdouble               y,
-                 GtkPopover           *popover)
+gtk_popover_unrealize (GtkWidget *widget)
 {
+  GtkPopover *popover = GTK_POPOVER (widget);
   GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
 
-  priv->button_pressed = TRUE;
-}
+  GTK_WIDGET_CLASS (gtk_popover_parent_class)->unrealize (widget);
 
-static void
-gesture_released (GtkGestureMultiPress *gesture,
-                  gint                  n_press,
-                  gdouble               x,
-                  gdouble               y,
-                  GtkPopover           *popover)
-{
-  GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
-  graphene_rect_t child_bounds;
-  GtkWidget *child;
+  gsk_renderer_unrealize (priv->renderer);
+  g_clear_object (&priv->renderer);
 
-  if (!priv->button_pressed)
-    return;
+  g_signal_handlers_disconnect_by_func (priv->surface, surface_state_changed, widget);
+  g_signal_handlers_disconnect_by_func (priv->surface, surface_size_changed, widget);
 
-  child = gtk_bin_get_child (GTK_BIN (popover));
-  if (!child ||
-      !gtk_widget_compute_bounds (child, GTK_WIDGET (popover), &child_bounds) ||
-      !graphene_rect_contains_point (&child_bounds,
-                                     &(graphene_point_t){x, y}))
-    gtk_popover_popdown (popover);
+  g_clear_object (&priv->surface);
 }
 
 static void
-gtk_popover_init (GtkPopover *popover)
+gtk_popover_move_focus (GtkWidget        *widget,
+                        GtkDirectionType  dir)
 {
-  GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
-  GtkWidget *widget;
-  GtkStyleContext *context;
-  GtkEventController *controller;
-
-  widget = GTK_WIDGET (popover);
-  gtk_widget_set_has_surface (widget, TRUE);
-  priv->modal = TRUE;
-  priv->tick_id = 0;
-  priv->state = STATE_HIDDEN;
-  priv->visible = FALSE;
-  priv->preferred_position = GTK_POS_TOP;
-  priv->constraint = GTK_POPOVER_CONSTRAINT_WINDOW;
-
-  priv->arrow_node = gtk_css_node_new ();
-  gtk_css_node_set_name (priv->arrow_node, I_("arrow"));
-  gtk_css_node_set_parent (priv->arrow_node, gtk_widget_get_css_node (widget));
-  gtk_css_node_set_state (priv->arrow_node,
-                          gtk_css_node_get_state (gtk_widget_get_css_node (widget)));
-  g_signal_connect_object (priv->arrow_node, "style-changed",
-                           G_CALLBACK (node_style_changed_cb), popover, 0);
-  g_object_unref (priv->arrow_node);
-
-  priv->contents_widget = gtk_gizmo_new ("contents", measure_contents, allocate_contents, NULL, NULL);
-
-  gtk_widget_set_parent (priv->contents_widget, widget);
-
-  context = gtk_widget_get_style_context (priv->contents_widget);
-  gtk_style_context_add_class (context, GTK_STYLE_CLASS_BACKGROUND);
-
-  controller = gtk_event_controller_key_new ();
-  g_signal_connect (controller, "key-pressed",
-                    G_CALLBACK (key_controller_key_pressed), popover);
-  gtk_widget_add_controller (widget, controller);
+  gtk_widget_child_focus (widget, dir);
 
-  controller = GTK_EVENT_CONTROLLER (gtk_gesture_multi_press_new ());
-  g_signal_connect (controller, "pressed",
-                    G_CALLBACK (gesture_pressed), popover);
-  g_signal_connect (controller, "released",
-                    G_CALLBACK (gesture_released), popover);
-  gtk_widget_add_controller (widget, controller);
+  if (!gtk_widget_get_focus_child (widget))
+    gtk_root_set_focus (GTK_ROOT (widget), NULL);
 }
 
 static void
-gtk_popover_set_property (GObject      *object,
-                          guint         prop_id,
-                          const GValue *value,
-                          GParamSpec   *pspec)
+gtk_popover_show (GtkWidget *widget)
 {
-  switch (prop_id)
-    {
-    case PROP_RELATIVE_TO:
-      gtk_popover_set_relative_to (GTK_POPOVER (object),
-                                   g_value_get_object (value));
-      break;
-    case PROP_POINTING_TO:
-      gtk_popover_set_pointing_to (GTK_POPOVER (object),
-                                   g_value_get_boxed (value));
-      break;
-    case PROP_POSITION:
-      gtk_popover_set_position (GTK_POPOVER (object),
-                                g_value_get_enum (value));
-      break;
-    case PROP_MODAL:
-      gtk_popover_set_modal (GTK_POPOVER (object),
-                             g_value_get_boolean (value));
-      break;
-    case PROP_CONSTRAIN_TO:
-      gtk_popover_set_constrain_to (GTK_POPOVER (object),
-                                    g_value_get_enum (value));
-      break;
-    default:
-      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
-    }
+  _gtk_widget_set_visible_flag (widget, TRUE);
+  gtk_css_node_validate (gtk_widget_get_css_node (widget));
+  gtk_widget_realize (widget);
+  gtk_popover_root_check_resize (GTK_ROOT (widget));
+  gtk_widget_map (widget);
+
+  if (!gtk_widget_get_focus_child (widget))
+    gtk_widget_child_focus (widget, GTK_DIR_TAB_FORWARD);
 }
 
 static void
-gtk_popover_get_property (GObject    *object,
-                          guint       prop_id,
-                          GValue     *value,
-                          GParamSpec *pspec)
+gtk_popover_hide (GtkWidget *widget)
 {
-  GtkPopoverPrivate *priv = gtk_popover_get_instance_private (GTK_POPOVER (object));
-
-  switch (prop_id)
-    {
-    case PROP_RELATIVE_TO:
-      g_value_set_object (value, priv->widget);
-      break;
-    case PROP_POINTING_TO:
-      g_value_set_boxed (value, &priv->pointing_to);
-      break;
-    case PROP_POSITION:
-      g_value_set_enum (value, priv->preferred_position);
-      break;
-    case PROP_MODAL:
-      g_value_set_boolean (value, priv->modal);
-      break;
-    case PROP_CONSTRAIN_TO:
-      g_value_set_enum (value, priv->constraint);
-      break;
-    default:
-      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
-    }
+  _gtk_widget_set_visible_flag (widget, FALSE);
+  gtk_widget_unmap (widget);
+  g_signal_emit (widget, signals[CLOSED], 0);
 }
 
-static gboolean
-transitions_enabled (GtkPopover *popover)
+static void
+grab_prepare_func (GdkSeat    *seat,
+                   GdkSurface *surface,
+                   gpointer    data)
 {
-  return gtk_settings_get_enable_animations (gtk_widget_get_settings (GTK_WIDGET (popover)));
+  gdk_surface_show (surface);
 }
 
 static void
-gtk_popover_hide_internal (GtkPopover *popover)
+gtk_popover_map (GtkWidget *widget)
 {
+  GtkPopover *popover = GTK_POPOVER (widget);
   GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
-  GtkWidget *widget = GTK_WIDGET (popover);
-
-  if (!priv->visible)
-    return;
-
-  priv->visible = FALSE;
-  g_signal_emit (widget, signals[CLOSED], 0);
+  GtkWidget *child;
+  GdkRectangle parent_rect;
 
   if (priv->modal)
-    gtk_popover_apply_modality (popover, FALSE);
-
-  if (gtk_widget_get_realized (widget))
     {
-      cairo_region_t *region = cairo_region_create ();
-      gdk_surface_input_shape_combine_region (gtk_widget_get_surface (widget),
-                                             region, 0, 0);
-      cairo_region_destroy (region);
+      gdk_seat_grab (gdk_display_get_default_seat (priv->display),
+                     priv->surface,
+                     GDK_SEAT_CAPABILITY_ALL,
+                     TRUE,
+                     NULL, NULL, grab_prepare_func, NULL);
+      priv->has_grab = TRUE;
     }
-}
 
-static void
-gtk_popover_finalize (GObject *object)
-{
-  GtkPopover *popover = GTK_POPOVER (object);
-  GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
+  gtk_widget_get_surface_allocation (priv->relative_to, &parent_rect);
+  move_to_rect (popover);
 
-  if (priv->widget)
-    gtk_popover_update_relative_to (popover, NULL);
+  GTK_WIDGET_CLASS (gtk_popover_parent_class)->map (widget);
 
-  G_OBJECT_CLASS (gtk_popover_parent_class)->finalize (object);
+  child = gtk_bin_get_child (GTK_BIN (widget));
+  if (child != NULL && gtk_widget_get_visible (child))
+    gtk_widget_map (child);
 }
 
 static void
-popover_unset_prev_focus (GtkPopover *popover)
+gtk_popover_unmap (GtkWidget *widget)
 {
+  GtkPopover *popover = GTK_POPOVER (widget);
   GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
+  GtkWidget *child;
 
-  if (!priv->prev_focus_widget)
-    return;
+  GTK_WIDGET_CLASS (gtk_popover_parent_class)->unmap (widget);
 
-  if (priv->prev_focus_unmap_id)
+  gdk_surface_hide (priv->surface);
+  if (priv->has_grab)
     {
-      g_signal_handler_disconnect (priv->prev_focus_widget,
-                                   priv->prev_focus_unmap_id);
-      priv->prev_focus_unmap_id = 0;
+      gdk_seat_ungrab (gdk_display_get_default_seat (priv->display));
+      priv->has_grab = FALSE;
     }
 
-  g_clear_object (&priv->prev_focus_widget);
+  child = gtk_bin_get_child (GTK_BIN (widget));
+  if (child != NULL)
+    gtk_widget_unmap (child);
 }
 
 static void
@@ -519,751 +554,80 @@ gtk_popover_dispose (GObject *object)
 {
   GtkPopover *popover = GTK_POPOVER (object);
   GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
+  guint i;
+  GtkWidget *child;
 
-  if (priv->modal)
-    gtk_popover_apply_modality (popover, FALSE);
-
-  if (priv->window)
+  for (i = 0; i < g_list_model_get_n_items (G_LIST_MODEL (popover_list)); i++)
     {
-      g_signal_handlers_disconnect_by_data (priv->window, popover);
-      _gtk_window_remove_popover (priv->window, GTK_WIDGET (object));
+      gpointer item = g_list_model_get_item (G_LIST_MODEL (popover_list), i);
+      if (item == object)
+        {
+          g_list_store_remove (popover_list, i);
+          break;
+        }
+      else
+        g_object_unref (item);
     }
 
-  priv->window = NULL;
-
-  if (priv->widget)
-    gtk_popover_update_relative_to (popover, NULL);
-
-  popover_unset_prev_focus (popover);
-
-  g_clear_object (&priv->default_widget);
+  child = gtk_bin_get_child (GTK_BIN (popover));
 
-  if (priv->contents_widget)
+  if (child)
     {
-      GtkWidget *child = gtk_bin_get_child (GTK_BIN (popover));
-
-      if (child)
-        {
-          /* Parent is content_widget! */
-          gtk_widget_unparent (child);
-          _gtk_bin_set_child (GTK_BIN (popover), NULL);
-        }
-
-      gtk_widget_unparent (priv->contents_widget);
-      priv->contents_widget = NULL;
+      gtk_widget_unparent (child);
+      _gtk_bin_set_child (GTK_BIN (popover), NULL);
     }
 
+  g_clear_pointer (&priv->contents_widget, gtk_widget_unparent);
+
   G_OBJECT_CLASS (gtk_popover_parent_class)->dispose (object);
 }
 
 static void
-gtk_popover_realize (GtkWidget *widget)
+gtk_popover_finalize (GObject *object)
 {
-  GtkAllocation allocation;
-  GdkSurface *surface;
-
-  gtk_widget_get_surface_allocation (widget, &allocation);
-
-  surface = gdk_surface_new_child (gtk_widget_get_parent_surface (widget), &allocation);
-
-  gtk_widget_set_surface (widget, surface);
-  gtk_widget_register_surface (widget, surface);
-
-  GTK_WIDGET_CLASS (gtk_popover_parent_class)->realize (widget);
+  G_OBJECT_CLASS (gtk_popover_parent_class)->finalize (object);
 }
 
 static void
-window_active_changed (GtkWindow  *window,
-                       GParamSpec *pspec,
-                       GtkPopover *popover)
+gtk_popover_constructed (GObject *object)
 {
-  GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
-
-  if (!priv->modal ||
-      !gtk_widget_is_drawable (GTK_WIDGET (popover)))
-    return;
+  g_list_store_append (popover_list, object);
+  g_object_unref (object);
+}
 
-  if (gtk_window_is_active (window))
-    {
-      /* Regain the grab when the window is focused */
-      GtkWidget *focus;
-
-      gtk_grab_add (GTK_WIDGET (popover));
-
-      focus = gtk_window_get_focus (window);
-
-      if (focus == NULL || !gtk_widget_is_ancestor (focus, GTK_WIDGET (popover)))
-        gtk_widget_grab_focus (GTK_WIDGET (popover));
-
-      if (priv->grab_notify_blocked)
-        g_signal_handler_unblock (priv->widget, priv->grab_notify_id);
-
-      priv->grab_notify_blocked = FALSE;
-    }
-  else
-    {
-      /* Temporarily remove the grab when unfocused */
-      g_signal_handler_block (priv->widget, priv->grab_notify_id);
-      gtk_grab_remove (GTK_WIDGET (popover));
-
-      priv->grab_notify_blocked = TRUE;
-    }
-}
-
-static void
-window_set_focus (GtkWindow  *window,
-                  GParamSpec *pspec,
-                  GtkPopover *popover)
-{
-  GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
-  GtkWidget *widget = gtk_root_get_focus (GTK_ROOT (window));
-
-  if (!priv->modal || !widget || !gtk_widget_is_drawable (GTK_WIDGET (popover)))
-    return;
-
-  widget = gtk_widget_get_ancestor (widget, GTK_TYPE_POPOVER);
-  while (widget != NULL)
-    {
-      if (widget == GTK_WIDGET (popover))
-        return;
-
-      widget = gtk_popover_get_relative_to (GTK_POPOVER (widget));
-      if (widget == NULL)
-        break;
-      widget = gtk_widget_get_ancestor (widget, GTK_TYPE_POPOVER);
-    }
-
-  popover_unset_prev_focus (popover);
-  gtk_widget_hide (GTK_WIDGET (popover));
-}
-
-static void
-prev_focus_unmap_cb (GtkWidget  *widget,
-                     GtkPopover *popover)
-{
-  popover_unset_prev_focus (popover);
-}
-
-static void
-gtk_popover_apply_modality (GtkPopover *popover,
-                            gboolean    modal)
-{
-  GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
-
-  if (!priv->window)
-    return;
-
-  if (modal)
-    {
-      GtkWidget *prev_focus;
-
-      prev_focus = gtk_window_get_focus (priv->window);
-      priv->prev_focus_widget = prev_focus;
-      if (priv->prev_focus_widget)
-        {
-          priv->prev_focus_unmap_id =
-            g_signal_connect (prev_focus, "unmap",
-                              G_CALLBACK (prev_focus_unmap_cb), popover);
-          g_object_ref (prev_focus);
-        }
-      gtk_grab_add (GTK_WIDGET (popover));
-      gtk_window_set_focus (priv->window, NULL);
-      gtk_widget_grab_focus (GTK_WIDGET (popover));
-
-      g_signal_connect (priv->window, "notify::is-active",
-                        G_CALLBACK (window_active_changed), popover);
-      g_signal_connect (priv->window, "notify::focus-widget",
-                        G_CALLBACK (window_set_focus), popover);
-    }
-  else
-    {
-      g_signal_handlers_disconnect_by_data (priv->window, popover);
-      if (priv->prev_focus_widget == GTK_WIDGET (priv->window))
-        priv->prev_focus_unmap_id = 0;
-      gtk_grab_remove (GTK_WIDGET (popover));
-
-      /* Let prev_focus_widget regain focus */
-      if (priv->prev_focus_widget &&
-          gtk_widget_is_drawable (priv->prev_focus_widget))
-        {
-           if (GTK_IS_ENTRY (priv->prev_focus_widget))
-             gtk_entry_grab_focus_without_selecting (GTK_ENTRY (priv->prev_focus_widget));
-           else
-             gtk_widget_grab_focus (priv->prev_focus_widget);
-        }
-      else if (priv->window)
-        gtk_widget_grab_focus (GTK_WIDGET (priv->window));
-
-      popover_unset_prev_focus (popover);
-    }
-}
-
-static gboolean
-show_animate_cb (GtkWidget     *widget,
-                 GdkFrameClock *frame_clock,
-                 gpointer       user_data)
-{
-  GtkPopover *popover = GTK_POPOVER (widget);
-  GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
-  gdouble t;
-
-  if (priv->first_frame_skipped)
-    gtk_progress_tracker_advance_frame (&priv->tracker,
-                                        gdk_frame_clock_get_frame_time (frame_clock));
-  else
-    priv->first_frame_skipped = TRUE;
-
-  t = gtk_progress_tracker_get_ease_out_cubic (&priv->tracker, FALSE);
-
-  if (priv->state == STATE_SHOWING)
-    {
-      priv->transition_diff = TRANSITION_DIFF - (TRANSITION_DIFF * t);
-      gtk_widget_set_opacity (widget, t);
-    }
-  else if (priv->state == STATE_HIDING)
-    {
-      priv->transition_diff = -TRANSITION_DIFF * t;
-      gtk_widget_set_opacity (widget, 1.0 - t);
-    }
-
-  gtk_popover_update_position (popover);
-  gtk_widget_queue_allocate (GTK_WIDGET (priv->window));
-
-  if (gtk_progress_tracker_get_state (&priv->tracker) == GTK_PROGRESS_STATE_AFTER)
-    {
-      if (priv->state == STATE_SHOWING)
-        {
-          gtk_popover_set_state (popover, STATE_SHOWN);
-
-          if (!priv->visible)
-            gtk_popover_set_state (popover, STATE_HIDING);
-        }
-      else
-        {
-          gtk_widget_hide (widget);
-        }
-
-      priv->tick_id = 0;
-      return G_SOURCE_REMOVE;
-    }
-  else
-    return G_SOURCE_CONTINUE;
-}
-
-static void
-gtk_popover_stop_transition (GtkPopover *popover)
-{
-  GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
-
-  if (priv->tick_id != 0)
-    {
-      gtk_widget_remove_tick_callback (GTK_WIDGET (popover), priv->tick_id);
-      priv->tick_id = 0;
-    }
-}
-
-static void
-gtk_popover_start_transition (GtkPopover *popover)
-{
-  GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
-
-  if (priv->tick_id != 0)
-    return;
-
-  priv->first_frame_skipped = FALSE;
-  gtk_progress_tracker_start (&priv->tracker, TRANSITION_DURATION, 0, 1.0);
-  priv->tick_id = gtk_widget_add_tick_callback (GTK_WIDGET (popover),
-                                                show_animate_cb,
-                                                popover, NULL);
-}
-
-static void
-gtk_popover_set_state (GtkPopover *popover,
-                       guint       state)
-{
-  GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
-
-  if (!transitions_enabled (popover) ||
-      !gtk_widget_get_realized (GTK_WIDGET (popover)))
-    {
-      if (state == STATE_SHOWING)
-        state = STATE_SHOWN;
-      else if (state == STATE_HIDING)
-        state = STATE_HIDDEN;
-    }
-
-  priv->state = state;
-
-  if (state == STATE_SHOWING || state == STATE_HIDING)
-    gtk_popover_start_transition (popover);
-  else
-    {
-      gtk_popover_stop_transition (popover);
-
-      gtk_widget_set_visible (GTK_WIDGET (popover), state == STATE_SHOWN);
-    }
-}
-
-static void
-gtk_popover_map (GtkWidget *widget)
-{
-  GtkPopoverPrivate *priv = gtk_popover_get_instance_private (GTK_POPOVER (widget));
-
-  priv->prev_default = gtk_window_get_default_widget (priv->window);
-  if (priv->prev_default)
-    g_object_ref (priv->prev_default);
-
-  GTK_WIDGET_CLASS (gtk_popover_parent_class)->map (widget);
-
-  gdk_surface_show (gtk_widget_get_surface (widget));
-  gtk_popover_update_position (GTK_POPOVER (widget));
-
-  gtk_window_set_default (priv->window, priv->default_widget);
-}
-
-static void
-gtk_popover_unmap (GtkWidget *widget)
-{
-  GtkPopoverPrivate *priv = gtk_popover_get_instance_private (GTK_POPOVER (widget));
-
-  priv->button_pressed = FALSE;
-
-  gdk_surface_hide (gtk_widget_get_surface (widget));
-  GTK_WIDGET_CLASS (gtk_popover_parent_class)->unmap (widget);
-
-  if (gtk_window_get_default_widget (priv->window) == priv->default_widget)
-    gtk_window_set_default (priv->window, priv->prev_default);
-  g_clear_object (&priv->prev_default);
-}
-
-static GtkPositionType
-get_effective_position (GtkPopover      *popover,
-                        GtkPositionType  pos)
-{
-  if (_gtk_widget_get_direction (GTK_WIDGET (popover)) == GTK_TEXT_DIR_RTL)
-    {
-      if (pos == GTK_POS_LEFT)
-        pos = GTK_POS_RIGHT;
-      else if (pos == GTK_POS_RIGHT)
-        pos = GTK_POS_LEFT;
-    }
-
-  return pos;
-}
-
-static void
-get_margin (GtkWidget *widget,
-            GtkBorder *border)
-{
-  GtkStyleContext *context;
-
-  context = gtk_widget_get_style_context (widget);
-  gtk_style_context_get_margin (context,
-                                border);
-}
-
-static void
-gtk_popover_get_gap_coords (GtkPopover      *popover,
-                            gint            *initial_x_out,
-                            gint            *initial_y_out,
-                            gint            *tip_x_out,
-                            gint            *tip_y_out,
-                            gint            *final_x_out,
-                            gint            *final_y_out)
-{
-  GtkWidget *widget = GTK_WIDGET (popover);
-  GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
-  GdkRectangle rect = { 0 };
-  gint base, tip, tip_pos;
-  gint initial_x, initial_y;
-  gint tip_x, tip_y;
-  gint final_x, final_y;
-  GtkPositionType pos;
-  gint border_radius;
-  GtkStyleContext *context;
-  GtkBorder border;
-  int popover_width, popover_height;
-
-  gtk_popover_get_pointing_to (popover, &rect);
-  popover_width = gtk_widget_get_width (widget);
-  popover_height = gtk_widget_get_height (widget);
-
-#ifdef GDK_WINDOWING_WAYLAND
-  if (GDK_IS_WAYLAND_DISPLAY (gtk_widget_get_display (widget)))
-    {
-      gint win_x, win_y;
-
-      gtk_widget_translate_coordinates (priv->widget, GTK_WIDGET (priv->window),
-                                        rect.x, rect.y, &rect.x, &rect.y);
-      gdk_surface_get_origin (gtk_widget_get_surface (GTK_WIDGET (popover)),
-                             &win_x, &win_y);
-      rect.x -= win_x;
-      rect.y -= win_y;
-    }
-  else
-#endif
-    gtk_widget_translate_coordinates (priv->widget, widget,
-                                      rect.x, rect.y, &rect.x, &rect.y);
-
-  context = gtk_widget_get_style_context (priv->contents_widget);
-  gtk_style_context_get_border (context, &border);
-
-  pos = get_effective_position (popover, priv->final_position);
-
-  gtk_style_context_get_border (context, &border);
-  gtk_style_context_get (context,
-                         GTK_STYLE_PROPERTY_BORDER_RADIUS, &border_radius,
-                         NULL);
-
-  if (pos == GTK_POS_BOTTOM || pos == GTK_POS_RIGHT)
-    {
-      tip = 0;
-      base = tip + TAIL_HEIGHT + border.top;
-    }
-  else if (pos == GTK_POS_TOP)
-    {
-      base = popover_height - border.bottom - TAIL_HEIGHT;
-      tip = base + TAIL_HEIGHT;
-    }
-  else if (pos == GTK_POS_LEFT)
-    {
-      base = popover_width - border.right - TAIL_HEIGHT;
-      tip = base + TAIL_HEIGHT;
-    }
-  else
-    g_assert_not_reached ();
-
-  if (POS_IS_VERTICAL (pos))
-    {
-      tip_pos = rect.x + (rect.width / 2);
-      initial_x = CLAMP (tip_pos - TAIL_GAP_WIDTH / 2,
-                         border_radius,
-                         popover_width - TAIL_GAP_WIDTH - border_radius);
-      initial_y = base;
-
-      tip_x = CLAMP (tip_pos, 0, popover_width);
-      tip_y = tip;
-
-      final_x = CLAMP (tip_pos + TAIL_GAP_WIDTH / 2,
-                       border_radius + TAIL_GAP_WIDTH,
-                       popover_width - border_radius);
-      final_y = base;
-    }
-  else
-    {
-      tip_pos = rect.y + (rect.height / 2);
-
-      initial_x = base;
-      initial_y = CLAMP (tip_pos - TAIL_GAP_WIDTH / 2,
-                         border_radius,
-                         popover_height - TAIL_GAP_WIDTH - border_radius);
-
-      tip_x = tip;
-      tip_y = CLAMP (tip_pos, 0, popover_height);
-
-      final_x = base;
-      final_y = CLAMP (tip_pos + TAIL_GAP_WIDTH / 2,
-                       border_radius + TAIL_GAP_WIDTH,
-                       popover_height - border_radius);
-    }
-
-  *initial_x_out = initial_x;
-  *initial_y_out = initial_y;
-
-  *tip_x_out = tip_x;
-  *tip_y_out = tip_y;
-
-  *final_x_out = final_x;
-  *final_y_out = final_y;
-}
-
-static void
-gtk_popover_get_rect_for_size (GtkPopover   *popover,
-                               int           popover_width,
-                               int           popover_height,
-                               GdkRectangle *rect)
-{
-  GtkWidget *widget = GTK_WIDGET (popover);
-  int x, y, w, h;
-  GtkBorder margin;
-
-  get_margin (widget, &margin);
-
-  x = 0;
-  y = 0;
-  w = popover_width;
-  h = popover_height;
-
-  x += MAX (TAIL_HEIGHT, margin.left);
-  y += MAX (TAIL_HEIGHT, margin.top);
-  w -= x + MAX (TAIL_HEIGHT, margin.right);
-  h -= y + MAX (TAIL_HEIGHT, margin.bottom);
-
-  rect->x = x;
-  rect->y = y;
-  rect->width = w;
-  rect->height = h;
-}
-
-static void
-gtk_popover_get_rect_coords (GtkPopover *popover,
-                             int        *x_out,
-                             int        *y_out,
-                             int        *w_out,
-                             int        *h_out)
-{
-  GtkWidget *widget = GTK_WIDGET (popover);
-  GdkRectangle rect;
-  GtkAllocation allocation;
-
-  gtk_widget_get_allocation (widget, &allocation);
-  gtk_popover_get_rect_for_size (popover, allocation.width, allocation.height, &rect);
-
-  *x_out = rect.x;
-  *y_out = rect.y;
-  *w_out = rect.width;
-  *h_out = rect.height;
-}
-
-static void
-gtk_popover_apply_tail_path (GtkPopover *popover,
-                             cairo_t    *cr)
-{
-  GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
-  gint initial_x, initial_y;
-  gint tip_x, tip_y;
-  gint final_x, final_y;
-  GtkStyleContext *context;
-  GtkBorder border;
-
-  if (!priv->widget)
-    return;
-
-  context = gtk_widget_get_style_context (priv->contents_widget);
-  gtk_style_context_get_border (context, &border);
-
-  cairo_set_line_width (cr, 1);
-  gtk_popover_get_gap_coords (popover,
-                              &initial_x, &initial_y,
-                              &tip_x, &tip_y,
-                              &final_x, &final_y);
-
-  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_popover_fill_border_path (GtkPopover *popover,
-                              cairo_t    *cr)
-{
-  GtkWidget *widget = GTK_WIDGET (popover);
-  GtkAllocation allocation;
-  GtkStyleContext *context;
-  int x, y, w, h;
-  GskRoundedRect box;
-
-  context = gtk_widget_get_style_context (widget);
-  gtk_widget_get_allocation (widget, &allocation);
-
-  cairo_set_source_rgba (cr, 0, 0, 0, 1);
-
-  gtk_popover_apply_tail_path (popover, cr);
-  cairo_close_path (cr);
-  cairo_fill (cr);
-
-  gtk_popover_get_rect_coords (popover, &x, &y, &w, &h);
-
-  gtk_rounded_boxes_init_for_style (&box,
-                                    NULL, NULL,
-                                    gtk_style_context_lookup_style (context),
-                                    x, y, w, h);
-  gsk_rounded_rect_path (&box, cr);
-  cairo_fill (cr);
-}
-
-static void
-gtk_popover_update_shape (GtkPopover *popover)
-{
-  GtkWidget *widget = GTK_WIDGET (popover);
-  cairo_surface_t *cairo_surface;
-  cairo_region_t *region;
-  GdkSurface *surface;
-  cairo_t *cr;
-
-#ifdef GDK_WINDOWING_WAYLAND
-  if (GDK_IS_WAYLAND_DISPLAY (gtk_widget_get_display (widget)))
-    return;
-#endif
-
-  surface = gtk_widget_get_surface (widget);
-  cairo_surface =
-    gdk_surface_create_similar_surface (surface,
-                                       CAIRO_CONTENT_COLOR_ALPHA,
-                                       gdk_surface_get_width (surface),
-                                       gdk_surface_get_height (surface));
-
-  cr = cairo_create (cairo_surface);
-  gtk_popover_fill_border_path (popover, cr);
-  cairo_destroy (cr);
-
-  region = gdk_cairo_region_create_from_surface (cairo_surface);
-  cairo_surface_destroy (cairo_surface);
-
-  gtk_widget_input_shape_combine_region (widget, region);
-  cairo_region_destroy (region);
-
-  gdk_surface_set_child_input_shapes (gtk_widget_get_surface (widget));
-}
-
-static void
-_gtk_popover_update_child_visible (GtkPopover *popover)
-{
-  GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
-  GtkWidget *widget = GTK_WIDGET (popover);
-  GdkRectangle rect;
-  GtkAllocation allocation;
-  GtkWidget *parent;
-
-  if (!priv->parent_scrollable)
-    {
-      gtk_widget_set_child_visible (widget, TRUE);
-      return;
-    }
-
-  parent = gtk_widget_get_parent (GTK_WIDGET (priv->parent_scrollable));
-  gtk_popover_get_pointing_to (popover, &rect);
-
-  gtk_widget_translate_coordinates (priv->widget, parent,
-                                    rect.x, rect.y, &rect.x, &rect.y);
-
-  gtk_widget_get_allocation (GTK_WIDGET (parent), &allocation);
-
-  if (rect.x + rect.width < 0 || rect.x > allocation.width ||
-      rect.y + rect.height < 0 || rect.y > allocation.height)
-    gtk_widget_set_child_visible (widget, FALSE);
-  else
-    gtk_widget_set_child_visible (widget, TRUE);
-}
-
-static GtkPositionType
-opposite_position (GtkPositionType pos)
-{
-  switch (pos)
-    {
-    default:
-    case GTK_POS_LEFT: return GTK_POS_RIGHT;
-    case GTK_POS_RIGHT: return GTK_POS_LEFT;
-    case GTK_POS_TOP: return GTK_POS_BOTTOM;
-    case GTK_POS_BOTTOM: return GTK_POS_TOP;
-    }
-}
-
-void
-gtk_popover_update_position (GtkPopover *popover)
-{
-  GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
-  GtkWidget *widget = GTK_WIDGET (popover);
-  GtkAllocation window_alloc;
-  GtkBorder window_shadow;
-  GdkRectangle rect = { 0 };
-  GtkRequisition req;
-  GtkPositionType pos;
-  gint overshoot[4];
-  gint i, j;
-  gint best;
-
-  if (!priv->window || !gtk_widget_get_mapped (widget))
-    return;
-
-  gtk_widget_get_preferred_size (widget, NULL, &req);
-  gtk_widget_get_allocation (GTK_WIDGET (priv->window), &window_alloc);
-  _gtk_window_get_shadow_width (priv->window, &window_shadow);
-  priv->final_position = priv->preferred_position;
-
-  gtk_popover_get_pointing_to (popover, &rect);
-  gtk_widget_translate_coordinates (priv->widget, GTK_WIDGET (priv->window),
-                                    rect.x, rect.y, &rect.x, &rect.y);
-
-  pos = get_effective_position (popover, priv->preferred_position);
-
-  overshoot[GTK_POS_TOP] = req.height - rect.y + window_shadow.top;
-  overshoot[GTK_POS_BOTTOM] = rect.y + rect.height + req.height - window_alloc.height
-                              + window_shadow.bottom;
-  overshoot[GTK_POS_LEFT] = req.width - rect.x + window_shadow.left;
-  overshoot[GTK_POS_RIGHT] = rect.x + rect.width + req.width - window_alloc.width
-                             + window_shadow.right;
-
-#ifdef GDK_WINDOWING_WAYLAND
-  if (GDK_IS_WAYLAND_DISPLAY (gtk_widget_get_display (widget)) &&
-      priv->constraint == GTK_POPOVER_CONSTRAINT_NONE)
-    {
-      priv->final_position = priv->preferred_position;
-    }
-  else
-#endif
-  if (overshoot[pos] <= 0)
-    {
-      priv->final_position = priv->preferred_position;
-    }
-  else if (overshoot[opposite_position (pos)] <= 0)
-    {
-      priv->final_position = opposite_position (priv->preferred_position);
-    }
-  else
-    {
-      best = G_MAXINT;
-      pos = 0;
-      for (i = 0; i < 4; i++)
-        {
-          j = get_effective_position (popover, i);
-          if (overshoot[j] < best)
-            {
-              pos = i;
-              best = overshoot[j];
-            }
-        }
-      priv->final_position = pos;
-    }
-
-  switch (priv->final_position)
-    {
-    case GTK_POS_TOP:
-      rect.y += priv->transition_diff;
-      break;
-    case GTK_POS_BOTTOM:
-      rect.y -= priv->transition_diff;
-      break;
-    case GTK_POS_LEFT:
-      rect.x += priv->transition_diff;
-      break;
-    case GTK_POS_RIGHT:
-      rect.x -= priv->transition_diff;
-      break;
-    default:
-      break;
-    }
-
-  _gtk_window_set_popover_position (priv->window, widget,
-                                    priv->final_position, &rect);
-
-  if (priv->final_position != priv->current_position)
-    {
-      if (gtk_widget_is_drawable (widget))
-        gtk_popover_update_shape (popover);
-
-      priv->current_position = priv->final_position;
-    }
+static void
+gtk_popover_measure (GtkWidget      *widget,
+                     GtkOrientation  orientation,
+                     int             for_size,
+                     int            *minimum,
+                     int            *natural,
+                     int            *minimum_baseline,
+                     int            *natural_baseline)
+{
+  GtkPopover *popover = GTK_POPOVER (widget);
+  GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
 
-  _gtk_popover_update_child_visible (popover);
+  gtk_widget_measure (priv->contents_widget,
+                      orientation, for_size,
+                      minimum, natural,
+                      minimum_baseline, natural_baseline);
 }
 
-GtkWidget *
-gtk_popover_get_contents_widget (GtkPopover *popover)
+static void
+gtk_popover_size_allocate (GtkWidget *widget,
+                           int        width,
+                           int        height,
+                           int        baseline)
 {
+  GtkPopover *popover = GTK_POPOVER (widget);
   GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
 
-  return priv->contents_widget;
+  if (priv->surface)
+    gtk_popover_move_resize (popover);
+
+  gtk_widget_size_allocate (priv->contents_widget,
+                            &(GtkAllocation) { 0, 0, width, height },
+                            baseline);
 }
 
 static void
@@ -1272,253 +636,141 @@ gtk_popover_snapshot (GtkWidget   *widget,
 {
   GtkPopover *popover = GTK_POPOVER (widget);
   GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
-  GtkStyleContext *context;
-  GtkBorder border;
-  cairo_t *cr;
 
-  /* Draw the child first so we can draw the arrow (partially) over it */
   gtk_widget_snapshot_child (widget, priv->contents_widget, snapshot);
-
-  cr = gtk_snapshot_append_cairo (snapshot,
-                                  &GRAPHENE_RECT_INIT (
-                                    0, 0,
-                                    gtk_widget_get_width (widget),
-                                    gtk_widget_get_height (widget)
-                                  ));
-
-  /* Clip to the arrow shape */
-  cairo_save (cr);
-
-  gtk_popover_apply_tail_path (popover, cr);
-
-  cairo_clip (cr);
-
-  context = gtk_widget_get_style_context (widget);
-  gtk_style_context_save_to_node (context, priv->arrow_node);
-  gtk_style_context_get_border (context, &border);
-
-  /* Render the arrow background */
-  gtk_render_background (context, cr,
-                         0, 0,
-                         gtk_widget_get_width (widget),
-                         gtk_widget_get_height (widget));
-
-  /* Render the border of the arrow tip */
-  if (border.bottom > 0)
-    {
-      GdkRGBA *border_color;
-
-      gtk_style_context_get (context, "border-color", &border_color, NULL);
-      gtk_popover_apply_tail_path (popover, cr);
-      gdk_cairo_set_source_rgba (cr, border_color);
-
-      cairo_set_line_width (cr, border.bottom + 1);
-      cairo_stroke (cr);
-      gdk_rgba_free (border_color);
-    }
-
-  cairo_restore (cr);
-  /* We're done */
-  cairo_destroy (cr);
-
-  gtk_style_context_restore (context);
-}
-
-static gint
-get_border_radius (GtkWidget *widget)
-{
-  GtkStyleContext *context;
-  gint border_radius;
-
-  context = gtk_widget_get_style_context (widget);
-  gtk_style_context_get (context,
-                         GTK_STYLE_PROPERTY_BORDER_RADIUS, &border_radius,
-                         NULL);
-  return border_radius;
 }
 
-static gint
-get_minimal_size (GtkPopover     *popover,
-                  GtkOrientation  orientation)
+static void
+gtk_popover_set_property (GObject      *object,
+                          guint         prop_id,
+                          const GValue *value,
+                          GParamSpec   *pspec)
 {
-  GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
-  GtkPositionType pos;
-  gint minimal_size;
-
-  minimal_size = 2 * get_border_radius (GTK_WIDGET (popover));
-  pos = get_effective_position (popover, priv->preferred_position);
-
-  if ((orientation == GTK_ORIENTATION_HORIZONTAL && POS_IS_VERTICAL (pos)) ||
-      (orientation == GTK_ORIENTATION_VERTICAL && !POS_IS_VERTICAL (pos)))
-    minimal_size += TAIL_GAP_WIDTH;
+  GtkPopover *popover = GTK_POPOVER (object);
 
-  return minimal_size;
-}
+  switch (prop_id)
+    {
+    case PROP_RELATIVE_TO:
+      gtk_popover_set_relative_to (popover, g_value_get_object (value));
+      break;
 
-static void
-gtk_popover_measure (GtkWidget      *widget,
-                     GtkOrientation  orientation,
-                     int             for_size,
-                     int            *minimum,
-                     int            *natural,
-                     int            *minimum_baseline,
-                     int            *natural_baseline)
-{
-  GtkPopover *popover = GTK_POPOVER (widget);
-  GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
-  int minimal_size;
+    case PROP_POINTING_TO:
+      gtk_popover_set_pointing_to (popover, g_value_get_boxed (value));
+      break;
 
-  *minimum = 0;
-  *natural = 0;
+    case PROP_POSITION:
+      gtk_popover_set_position (popover, g_value_get_enum (value));
+      break;
 
-  if (for_size >= 0)
-    for_size -= TAIL_HEIGHT;
+    case PROP_MODAL:
+      gtk_popover_set_modal (popover, g_value_get_boolean (value));
+      break;
 
-  gtk_widget_measure (priv->contents_widget, orientation, for_size, minimum, natural, NULL, NULL);
+    case NUM_PROPERTIES + GTK_ROOT_PROP_FOCUS_WIDGET:
+      gtk_popover_set_focus (popover, g_value_get_object (value));
+      break;
 
-  minimal_size = get_minimal_size (popover, orientation);
-  *minimum = MAX (*minimum, minimal_size);
-  *natural = MAX (*natural, minimal_size);
+    case NUM_PROPERTIES + GTK_ROOT_PROP_DEFAULT_WIDGET:
+      gtk_popover_set_default (popover, g_value_get_object (value));
+      break;
 
-  *minimum += TAIL_HEIGHT;
-  *natural += TAIL_HEIGHT;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+    }
 }
 
 static void
-gtk_popover_size_allocate (GtkWidget *widget,
-                           int        width,
-                           int        height,
-                           int        baseline)
+gtk_popover_get_property (GObject      *object,
+                          guint         prop_id,
+                          GValue       *value,
+                          GParamSpec   *pspec)
 {
-  GtkPopover *popover = GTK_POPOVER (widget);
+  GtkPopover *popover = GTK_POPOVER (object);
   GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
-  GtkAllocation child_alloc = (GtkAllocation) {0, 0, width, height};
-
-  /* Note that we in measure() we add TAIL_HEIGHT in both directions, regardless
-   * of the popovers position. This is to ensure that we get enough space
-   * even priv->current_position changes between measure and size-allocate.
-   */
-  child_alloc.height -= TAIL_HEIGHT;
-  child_alloc.width -= TAIL_HEIGHT;
 
-  switch (priv->current_position)
+  switch (prop_id)
     {
-    case GTK_POS_TOP:
-      child_alloc.x += TAIL_HEIGHT / 2;
+    case PROP_RELATIVE_TO:
+      g_value_set_object (value, priv->relative_to);
       break;
-    case GTK_POS_BOTTOM:
-      child_alloc.x += TAIL_HEIGHT / 2;
-      child_alloc.y += TAIL_HEIGHT;
+
+    case PROP_POINTING_TO:
+      g_value_set_boxed (value, &priv->pointing_to);
       break;
-    case GTK_POS_LEFT:
-      child_alloc.y += TAIL_HEIGHT / 2;
+
+    case PROP_POSITION:
+      g_value_set_enum (value, priv->position);
       break;
-    case GTK_POS_RIGHT:
-      child_alloc.x += TAIL_HEIGHT;
-      child_alloc.y += TAIL_HEIGHT / 2;
+
+    case PROP_MODAL:
+      g_value_set_boolean (value, priv->modal);
       break;
-    default:
+
+    case NUM_PROPERTIES + GTK_ROOT_PROP_FOCUS_WIDGET:
+      g_value_set_object (value, priv->focus_widget);
       break;
-    }
 
-  gtk_widget_size_allocate (priv->contents_widget, &child_alloc, -1);
+    case NUM_PROPERTIES + GTK_ROOT_PROP_DEFAULT_WIDGET:
+      g_value_set_object (value, priv->default_widget);
+      break;
 
-  if (gtk_widget_get_realized (widget))
-    {
-      GtkAllocation a;
-      gtk_widget_get_surface_allocation (widget, &a);
-      gdk_surface_move_resize (gtk_widget_get_surface (widget),
-                              a.x, a.y, a.width, a.height);
-      gtk_popover_update_shape (popover);
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
     }
 }
 
 static void
-gtk_popover_grab_focus (GtkWidget *widget)
+gtk_popover_activate_default (GtkPopover *popover)
 {
-  GtkPopoverPrivate *priv = gtk_popover_get_instance_private (GTK_POPOVER (widget));
-  GtkWidget *child;
-
-  if (!priv->visible)
-    return;
-
-  /* Focus the first natural child */
-  child = gtk_bin_get_child (GTK_BIN (widget));
-
-  if (child)
-    gtk_widget_child_focus (child, GTK_DIR_TAB_FORWARD);
+  gtk_root_activate_default (GTK_ROOT (popover));
 }
 
-static gboolean
-gtk_popover_focus (GtkWidget        *widget,
-                   GtkDirectionType  direction)
+static void
+gtk_popover_activate_focus (GtkPopover *popover)
 {
-  GtkPopover *popover = GTK_POPOVER (widget);
-  GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
-
-  if (!priv->visible)
-    return FALSE;
-
-  if (!GTK_WIDGET_CLASS (gtk_popover_parent_class)->focus (widget, direction))
-    {
-      GtkWidget *focus;
-
-      focus = gtk_window_get_focus (priv->window);
-      focus = gtk_widget_get_parent (focus);
-
-      /* Unset focus child through children, so it is next stepped from
-       * scratch.
-       */
-      while (focus && focus != widget)
-        {
-          gtk_widget_set_focus_child (focus, NULL);
-          focus = gtk_widget_get_parent (focus);
-        }
-
-      return gtk_widget_child_focus (gtk_bin_get_child (GTK_BIN (widget)),
-                                     direction);
-    }
-
-  return TRUE;
+  gtk_root_activate_focus (GTK_ROOT (popover));
 }
 
 static void
-gtk_popover_show (GtkWidget *widget)
+gtk_popover_close (GtkPopover *popover)
 {
-  GtkPopoverPrivate *priv = gtk_popover_get_instance_private (GTK_POPOVER (widget));
-
-  if (priv->window)
-    _gtk_window_raise_popover (priv->window, widget);
-
-  priv->visible = TRUE;
-
-  GTK_WIDGET_CLASS (gtk_popover_parent_class)->show (widget);
-
-  if (priv->modal)
-    gtk_popover_apply_modality (GTK_POPOVER (widget), TRUE);
-
-  priv->state = STATE_SHOWN;
-
-  if (gtk_widget_get_realized (widget))
-    gdk_surface_input_shape_combine_region (gtk_widget_get_surface (widget),
-                                           NULL, 0, 0);
+  gtk_widget_hide (GTK_WIDGET (popover));
 }
 
 static void
-gtk_popover_hide (GtkWidget *widget)
+add_tab_bindings (GtkBindingSet    *binding_set,
+                  GdkModifierType   modifiers,
+                  GtkDirectionType  direction)
 {
-  GtkPopoverPrivate *priv = gtk_popover_get_instance_private (GTK_POPOVER (widget));
-
-  gtk_popover_hide_internal (GTK_POPOVER (widget));
-
-  gtk_popover_stop_transition (GTK_POPOVER (widget));
-  priv->state = STATE_HIDDEN;
-  priv->transition_diff = 0;
-  gtk_progress_tracker_finish (&priv->tracker);
-  gtk_widget_set_opacity (widget, 1.0);
-
+  gtk_binding_entry_add_signal (binding_set, GDK_KEY_Tab, modifiers,
+                                "move-focus", 1,
+                                GTK_TYPE_DIRECTION_TYPE, direction);
+  gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Tab, modifiers,
+                                "move-focus", 1,
+                                GTK_TYPE_DIRECTION_TYPE, direction);
+}
 
-  GTK_WIDGET_CLASS (gtk_popover_parent_class)->hide (widget);
+static void
+add_arrow_bindings (GtkBindingSet    *binding_set,
+                    guint             keysym,
+                    GtkDirectionType  direction)
+{
+  guint keypad_keysym = keysym - GDK_KEY_Left + GDK_KEY_KP_Left;
+
+  gtk_binding_entry_add_signal (binding_set, keysym, 0,
+                                "move-focus", 1,
+                                GTK_TYPE_DIRECTION_TYPE, direction);
+  gtk_binding_entry_add_signal (binding_set, keysym, GDK_CONTROL_MASK,
+                                "move-focus", 1,
+                                GTK_TYPE_DIRECTION_TYPE, direction);
+  gtk_binding_entry_add_signal (binding_set, keypad_keysym, 0,
+                                "move-focus", 1,
+                                GTK_TYPE_DIRECTION_TYPE, direction);
+  gtk_binding_entry_add_signal (binding_set, keypad_keysym, GDK_CONTROL_MASK,
+                                "move-focus", 1,
+                                GTK_TYPE_DIRECTION_TYPE, direction);
 }
 
 static void
@@ -1529,10 +781,9 @@ gtk_popover_add (GtkContainer *container,
   GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
 
   _gtk_bin_set_child (GTK_BIN (popover), child);
-
   gtk_widget_set_parent (child, priv->contents_widget);
 }
-
+ 
 static void
 gtk_popover_remove (GtkContainer *container,
                     GtkWidget    *child)
@@ -1543,52 +794,41 @@ gtk_popover_remove (GtkContainer *container,
   gtk_widget_unparent (child);
 }
 
-static void
-gtk_popover_state_flags_changed (GtkWidget     *widget,
-                                 GtkStateFlags  previous_state)
-{
-  GtkPopover *popover = GTK_POPOVER (widget);
-  GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
-  GtkStateFlags state;
-
-  state = gtk_widget_get_state_flags (widget);
-  gtk_css_node_set_state (priv->arrow_node, state);
-
-  GTK_WIDGET_CLASS (gtk_popover_parent_class)->state_flags_changed (widget, previous_state);
-}
-
 static void
 gtk_popover_class_init (GtkPopoverClass *klass)
 {
   GObjectClass *object_class = G_OBJECT_CLASS (klass);
   GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
   GtkContainerClass *container_class = GTK_CONTAINER_CLASS (klass);
+  GtkBindingSet *binding_set;
+
+  if (popover_list == NULL)
+    popover_list = g_list_store_new (GTK_TYPE_WIDGET);
 
+  object_class->constructed = gtk_popover_constructed;
+  object_class->dispose = gtk_popover_dispose;
+  object_class->finalize = gtk_popover_finalize;
   object_class->set_property = gtk_popover_set_property;
   object_class->get_property = gtk_popover_get_property;
-  object_class->finalize = gtk_popover_finalize;
-  object_class->dispose = gtk_popover_dispose;
 
   widget_class->realize = gtk_popover_realize;
+  widget_class->unrealize = gtk_popover_unrealize;
   widget_class->map = gtk_popover_map;
   widget_class->unmap = gtk_popover_unmap;
+  widget_class->show = gtk_popover_show;
+  widget_class->hide = gtk_popover_hide;
   widget_class->measure = gtk_popover_measure;
   widget_class->size_allocate = gtk_popover_size_allocate;
   widget_class->snapshot = gtk_popover_snapshot;
-  widget_class->grab_focus = gtk_popover_grab_focus;
-  widget_class->focus = gtk_popover_focus;
-  widget_class->show = gtk_popover_show;
-  widget_class->hide = gtk_popover_hide;
-  widget_class->state_flags_changed = gtk_popover_state_flags_changed;
+  widget_class->move_focus = gtk_popover_move_focus;
 
   container_class->add = gtk_popover_add;
   container_class->remove = gtk_popover_remove;
 
-  /**
-   * GtkPopover:relative-to:
-   *
-   * Sets the attached widget.
-   */
+  klass->activate_default = gtk_popover_activate_default;
+  klass->activate_focus = gtk_popover_activate_focus;
+  klass->close = gtk_popover_close;
+
   properties[PROP_RELATIVE_TO] =
       g_param_spec_object ("relative-to",
                            P_("Relative to"),
@@ -1596,11 +836,6 @@ gtk_popover_class_init (GtkPopoverClass *klass)
                            GTK_TYPE_WIDGET,
                            GTK_PARAM_READWRITE);
 
-  /**
-   * GtkPopover:pointing-to:
-   *
-   * Marks a specific rectangle to be pointed.
-   */
   properties[PROP_POINTING_TO] =
       g_param_spec_boxed ("pointing-to",
                           P_("Pointing to"),
@@ -1608,11 +843,6 @@ gtk_popover_class_init (GtkPopoverClass *klass)
                           GDK_TYPE_RECTANGLE,
                           GTK_PARAM_READWRITE);
 
-  /**
-   * GtkPopover:position
-   *
-   * Sets the preferred position of the popover.
-   */
   properties[PROP_POSITION] =
       g_param_spec_enum ("position",
                          P_("Position"),
@@ -1620,12 +850,6 @@ gtk_popover_class_init (GtkPopoverClass *klass)
                          GTK_TYPE_POSITION_TYPE, GTK_POS_TOP,
                          GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY);
 
-  /**
-   * GtkPopover:modal
-   *
-   * Sets whether the popover is modal (so other elements in the window do not
-   * receive input while the popover is visible).
-   */
   properties[PROP_MODAL] =
       g_param_spec_boolean ("modal",
                             P_("Modal"),
@@ -1633,420 +857,549 @@ gtk_popover_class_init (GtkPopoverClass *klass)
                             TRUE,
                             GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY);
 
-  /**
-   * GtkPopover:constrain-to:
-   *
-   * Sets a constraint for the popover position.
-   */
-  properties[PROP_CONSTRAIN_TO] =
-      g_param_spec_enum ("constrain-to",
-                         P_("Constraint"),
-                         P_("Constraint for the popover position"),
-                         GTK_TYPE_POPOVER_CONSTRAINT, GTK_POPOVER_CONSTRAINT_WINDOW,
-                         GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY);
-
   g_object_class_install_properties (object_class, NUM_PROPERTIES, properties);
+  gtk_root_install_properties (object_class, NUM_PROPERTIES);
+
+  signals[ACTIVATE_FOCUS] =
+    g_signal_new (I_("activate-focus"),
+                  G_TYPE_FROM_CLASS (object_class),
+                  G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
+                  G_STRUCT_OFFSET (GtkPopoverClass, activate_focus),
+                  NULL, NULL,
+                  NULL,
+                  G_TYPE_NONE,
+                  0);
+
+  signals[ACTIVATE_DEFAULT] =
+    g_signal_new (I_("activate-default"),
+                  G_TYPE_FROM_CLASS (object_class),
+                  G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
+                  G_STRUCT_OFFSET (GtkPopoverClass, activate_default),
+                  NULL, NULL,
+                  NULL,
+                  G_TYPE_NONE,
+                  0);
+
+  signals[CLOSE] =
+    g_signal_new (I_("close"),
+                  G_TYPE_FROM_CLASS (object_class),
+                  G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
+                  G_STRUCT_OFFSET (GtkPopoverClass, close),
+                  NULL, NULL,
+                  NULL,
+                  G_TYPE_NONE,
+                  0);
 
-  /**
-   * GtkPopover::closed:
-   *
-   * This signal is emitted when the popover is dismissed either through
-   * API or user interaction.
-   */
   signals[CLOSED] =
     g_signal_new (I_("closed"),
                   G_TYPE_FROM_CLASS (object_class),
                   G_SIGNAL_RUN_LAST,
                   G_STRUCT_OFFSET (GtkPopoverClass, closed),
-                  NULL, NULL, NULL,
-                  G_TYPE_NONE, 0);
+                  NULL, NULL,
+                  NULL,
+                  G_TYPE_NONE,
+                  0);
+
+  binding_set = gtk_binding_set_by_class (klass);
+
+  add_arrow_bindings (binding_set, GDK_KEY_Up, GTK_DIR_UP);
+  add_arrow_bindings (binding_set, GDK_KEY_Down, GTK_DIR_DOWN);
+  add_arrow_bindings (binding_set, GDK_KEY_Left, GTK_DIR_LEFT);
+  add_arrow_bindings (binding_set, GDK_KEY_Right, GTK_DIR_RIGHT);
+
+  add_tab_bindings (binding_set, 0, GTK_DIR_TAB_FORWARD);
+  add_tab_bindings (binding_set, GDK_CONTROL_MASK, GTK_DIR_TAB_FORWARD);
+  add_tab_bindings (binding_set, GDK_SHIFT_MASK, GTK_DIR_TAB_BACKWARD);
+  add_tab_bindings (binding_set, GDK_CONTROL_MASK | GDK_SHIFT_MASK, GTK_DIR_TAB_BACKWARD);
+
+
+  gtk_binding_entry_add_signal (binding_set, GDK_KEY_space, 0, "activate-focus", 0);
+  gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Space, 0, "activate-focus", 0);
 
-  quark_widget_popovers = g_quark_from_static_string ("gtk-quark-widget-popovers");
-  gtk_widget_class_set_accessible_type (widget_class, GTK_TYPE_POPOVER_ACCESSIBLE);
-  gtk_widget_class_set_css_name (widget_class, I_("popover"));
+  gtk_binding_entry_add_signal (binding_set, GDK_KEY_Return, 0, "activate-default", 0);
+  gtk_binding_entry_add_signal (binding_set, GDK_KEY_ISO_Enter, 0, "activate-default", 0);
+  gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Enter, 0, "activate-default", 0);
+  gtk_binding_entry_add_signal (binding_set, GDK_KEY_Escape, 0, "close", 0);
+
+  gtk_widget_class_set_css_name (widget_class, "popover");
+}
+
+GtkWidget *
+gtk_popover_new (GtkWidget *relative_to)
+{
+  return GTK_WIDGET (g_object_new (GTK_TYPE_POPOVER,
+                                   "relative-to", relative_to,
+                                   NULL));
 }
 
 static void
-gtk_popover_update_scrollable (GtkPopover *popover)
+size_changed (GtkWidget   *widget,
+              int          width,
+              int          height,
+              int          baseline,
+              GtkPopover  *popover)
 {
   GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
-  GtkScrollable *scrollable;
 
-  scrollable = GTK_SCROLLABLE (gtk_widget_get_ancestor (priv->widget,
-                                                        GTK_TYPE_SCROLLABLE));
-  gtk_popover_set_scrollable_full (popover, scrollable);
+  if (priv->surface)
+    gtk_popover_move_resize (popover);
 }
 
 static void
-_gtk_popover_parent_hierarchy_changed (GtkWidget  *widget,
-                                       GParamSpec *pspec,
-                                       GtkPopover *popover)
+gtk_popover_set_focus (GtkPopover *popover,
+                       GtkWidget  *focus)
 {
   GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
-  GtkWindow *new_window;
+  GtkWidget *old_focus = NULL;
+  GdkSeat *seat;
+  GdkDevice *device;
+  GdkEvent *event;
 
-  new_window = GTK_WINDOW (gtk_widget_get_ancestor (widget, GTK_TYPE_WINDOW));
-
-  if (priv->window == new_window)
+  if (focus && !gtk_widget_is_sensitive (focus))
     return;
 
-  g_object_ref (popover);
+  if (priv->focus_widget)
+    old_focus = g_object_ref (priv->focus_widget);
+  g_set_object (&priv->focus_widget, NULL);
 
-  if (gtk_widget_has_grab (GTK_WIDGET (popover)))
-    gtk_popover_apply_modality (popover, FALSE);
+  seat = gdk_display_get_default_seat (gtk_widget_get_display (GTK_WIDGET (popover)));
+  device = gdk_seat_get_keyboard (seat);
 
-  if (priv->window)
-    _gtk_window_remove_popover (priv->window, GTK_WIDGET (popover));
+  event = gdk_event_new (GDK_FOCUS_CHANGE);
+  gdk_event_set_display (event, gtk_widget_get_display (GTK_WIDGET (popover)));
+  gdk_event_set_device (event, device);
+  event->any.surface = _gtk_widget_get_surface (GTK_WIDGET (popover));
+  if (event->any.surface)
+    g_object_ref (event->any.surface);
 
-  if (priv->parent_scrollable)
-    gtk_popover_set_scrollable_full (popover, NULL);
+  gtk_synthesize_crossing_events (GTK_ROOT (popover), old_focus, focus, event, GDK_CROSSING_NORMAL);
 
-  priv->window = new_window;
+  g_object_unref (event);
 
-  if (new_window)
-    {
-      _gtk_window_add_popover (new_window, GTK_WIDGET (popover), priv->widget, TRUE);
-      gtk_popover_update_scrollable (popover);
-      gtk_popover_update_position (popover);
-    }
+  g_set_object (&priv->focus_widget, focus);
 
-  if (gtk_widget_is_visible (GTK_WIDGET (popover)))
-    gtk_widget_queue_resize (GTK_WIDGET (popover));
+  g_clear_object (&old_focus);
 
-  g_object_unref (popover);
+  g_object_notify (G_OBJECT (popover), "focus-widget");
 }
 
 static void
-_popover_propagate_state (GtkPopover    *popover,
-                          GtkStateFlags  state,
-                          GtkStateFlags  old_state,
-                          GtkStateFlags  flag)
+do_focus_change (GtkWidget *widget,
+                 gboolean   in)
 {
-  if ((state & flag) != (old_state & flag))
-    {
-      if ((state & flag) == flag)
-        gtk_widget_set_state_flags (GTK_WIDGET (popover), flag, FALSE);
-      else
-        gtk_widget_unset_state_flags (GTK_WIDGET (popover), flag);
-    }
+  GdkSeat *seat;
+  GdkDevice *device;
+  GdkEvent *event;
+
+  seat = gdk_display_get_default_seat (gtk_widget_get_display (widget));
+  device = gdk_seat_get_keyboard (seat);
+
+  event = gdk_event_new (GDK_FOCUS_CHANGE);
+  gdk_event_set_display (event, gtk_widget_get_display (widget));
+  gdk_event_set_device (event, device);
+
+  event->any.type = GDK_FOCUS_CHANGE;
+  event->any.surface = _gtk_widget_get_surface (widget);
+  if (event->any.surface)
+    g_object_ref (event->any.surface);
+  event->focus_change.in = in;
+  event->focus_change.mode = GDK_CROSSING_STATE_CHANGED;
+  event->focus_change.detail = GDK_NOTIFY_ANCESTOR;
+
+  gtk_widget_set_has_focus (widget, in);
+  gtk_widget_event (widget, event);
+
+  g_object_unref (event);
 }
 
 static void
-_gtk_popover_parent_state_changed (GtkWidget     *widget,
-                                   GtkStateFlags  old_state,
-                                   GtkPopover    *popover)
+gtk_popover_set_is_active (GtkPopover *popover,
+                           gboolean    active)
+{
+  GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
+
+  if (priv->active == active)
+    return;
+
+  priv->active = active;
+
+  if (priv->focus_widget &&
+      priv->focus_widget != GTK_WIDGET (popover) &&
+      gtk_widget_has_focus (priv->focus_widget) != active)
+    do_focus_change (priv->focus_widget, active);
+}
+
+GListModel *
+gtk_popover_get_popovers (void)
 {
-  guint state;
+  if (popover_list == NULL)
+    popover_list = g_list_store_new (GTK_TYPE_WIDGET);
 
-  state = gtk_widget_get_state_flags (widget);
-  _popover_propagate_state (popover, state, old_state,
-                            GTK_STATE_FLAG_INSENSITIVE);
-  _popover_propagate_state (popover, state, old_state,
-                            GTK_STATE_FLAG_BACKDROP);
+  return G_LIST_MODEL (popover_list);
 }
 
 static void
-_gtk_popover_parent_grab_notify (GtkWidget  *widget,
-                                 gboolean    was_shadowed,
-                                 GtkPopover *popover)
+gtk_popover_set_default (GtkPopover *popover,
+                         GtkWidget  *widget)
 {
   GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
 
-  if (priv->modal &&
-      gtk_widget_is_visible (GTK_WIDGET (popover)) &&
-      !gtk_widget_has_grab (GTK_WIDGET (popover)))
+  g_return_if_fail (GTK_IS_POPOVER (popover));
+
+  if (widget && !gtk_widget_get_can_default (widget))
+    return;
+
+  if (priv->default_widget == widget)
+    return;
+
+  if (priv->default_widget)
     {
-      GtkWidget *grab_widget;
+      if (priv->focus_widget != priv->default_widget ||
+          !gtk_widget_get_receives_default (priv->default_widget))
+        _gtk_widget_set_has_default (priv->default_widget, FALSE);
+
+      gtk_widget_queue_draw (priv->default_widget);
+      g_object_notify (G_OBJECT (priv->default_widget), "has-default");
+    }
+
+  g_set_object (&priv->default_widget, widget);
 
-      grab_widget = gtk_grab_get_current ();
+  if (priv->default_widget)
+    {
+      if (priv->focus_widget == NULL ||
+          !gtk_widget_get_receives_default (priv->focus_widget))
+        _gtk_widget_set_has_default (priv->default_widget, TRUE);
 
-      if (!grab_widget || !GTK_IS_POPOVER (grab_widget))
-        gtk_popover_popdown (popover);
+      gtk_widget_queue_draw (priv->default_widget);
+      g_object_notify (G_OBJECT (priv->default_widget), "has-default");
     }
+
+  g_object_notify (G_OBJECT (popover), "default-widget");
 }
 
-static void
-_gtk_popover_parent_unmap (GtkWidget *widget,
-                           GtkPopover *popover)
+static GtkMnemonicHash *
+gtk_popover_get_mnemonic_hash (GtkPopover *popover,
+                               gboolean    create)
 {
   GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
 
-  if (priv->state == STATE_SHOWING)
-    priv->visible = FALSE;
-  else if (priv->state == STATE_SHOWN)
-    gtk_popover_set_state (popover, STATE_HIDING);
+  if (!priv->mnemonic_hash && create)
+    priv->mnemonic_hash = _gtk_mnemonic_hash_new ();
+
+  return priv->mnemonic_hash;
 }
 
 static void
-gtk_popover_parent_size_allocate (GtkWidget  *widget,
-                                  int         width,
-                                  int         height,
-                                  int         baseline,
-                                  GtkPopover *popover)
+gtk_popover_root_add_mnemonic (GtkRoot   *root,
+                               guint      keyval,
+                               GtkWidget *target)
 {
-  gtk_popover_update_position (popover);
+  _gtk_mnemonic_hash_add (gtk_popover_get_mnemonic_hash (GTK_POPOVER (root), TRUE), keyval, target);
 }
 
 static void
-_unmanage_popover (GObject *object)
+gtk_popover_root_remove_mnemonic (GtkRoot   *root,
+                                  guint      keyval,
+                                  GtkWidget *target)
 {
-  gtk_popover_update_relative_to (GTK_POPOVER (object), NULL);
-  g_object_unref (object);
+  _gtk_mnemonic_hash_remove (gtk_popover_get_mnemonic_hash (GTK_POPOVER (root), TRUE), keyval, target);
 }
 
-static void
-widget_manage_popover (GtkWidget  *widget,
-                       GtkPopover *popover)
+static gboolean
+gtk_popover_root_activate_key (GtkRoot     *root,
+                               GdkEventKey *event)
 {
-  GHashTable *popovers;
+  GdkModifierType modifier = event->state;
+  guint keyval = event->keyval;
 
-  popovers = g_object_get_qdata (G_OBJECT (widget), quark_widget_popovers);
-
-  if (G_UNLIKELY (!popovers))
+  if ((modifier & gtk_accelerator_get_default_mod_mask ()) == GDK_MOD1_MASK)
     {
-      popovers = g_hash_table_new_full (NULL, NULL,
-                                        (GDestroyNotify) _unmanage_popover, NULL);
-      g_object_set_qdata_full (G_OBJECT (widget),
-                               quark_widget_popovers, popovers,
-                               (GDestroyNotify) g_hash_table_unref);
+      GtkMnemonicHash *hash = gtk_popover_get_mnemonic_hash (GTK_POPOVER (root), FALSE);
+      if (hash)
+        return _gtk_mnemonic_hash_activate (hash, keyval);      
     }
 
-  g_hash_table_add (popovers, g_object_ref_sink (popover));
+  return FALSE;
 }
 
-static void
-widget_unmanage_popover (GtkWidget  *widget,
-                         GtkPopover *popover)
+static GtkPointerFocus *
+gtk_popover_lookup_pointer_focus (GtkPopover       *popover,
+                                  GdkDevice        *device,
+                                  GdkEventSequence *sequence)
 {
-  GHashTable *popovers;
+  GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
+  GList *l;
 
-  popovers = g_object_get_qdata (G_OBJECT (widget), quark_widget_popovers);
+  for (l = priv->foci; l; l = l->next)
+    {
+      GtkPointerFocus *focus = l->data;
 
-  if (G_UNLIKELY (!popovers))
-    return;
+      if (focus->device == device && focus->sequence == sequence)
+        return focus;
+    }
 
-  g_hash_table_remove (popovers, popover);
+  return NULL;
 }
 
 static void
-adjustment_changed_cb (GtkAdjustment *adjustment,
-                       GtkPopover    *popover)
+gtk_popover_add_pointer_focus (GtkPopover      *popover,
+                               GtkPointerFocus *focus)
 {
-  gtk_popover_update_position (popover);
+  GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
+
+  priv->foci = g_list_prepend (priv->foci, gtk_pointer_focus_ref (focus));
 }
 
 static void
-_gtk_popover_set_scrollable (GtkPopover    *popover,
-                             GtkScrollable *scrollable)
+gtk_popover_remove_pointer_focus (GtkPopover      *popover,
+                                  GtkPointerFocus *focus)
 {
   GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
+  GList *pos;
+
+  pos = g_list_find (priv->foci, focus);
+  if (!pos)
+    return;
+
+  priv->foci = g_list_remove (priv->foci, focus);
+  gtk_pointer_focus_unref (focus);
+}
 
-  if (priv->parent_scrollable)
+static void
+gtk_popover_root_update_pointer_focus (GtkRoot          *root,
+                                       GdkDevice        *device,
+                                       GdkEventSequence *sequence,
+                                       GtkWidget        *target,
+                                       double            x,
+                                       double            y)
+{
+  GtkPopover *popover = GTK_POPOVER (root);
+  GtkPointerFocus *focus;
+
+  focus = gtk_popover_lookup_pointer_focus (popover, device, sequence);
+  if (focus)
     {
-      if (priv->vadj)
+      gtk_pointer_focus_ref (focus);
+
+      if (target)
+        {
+          gtk_pointer_focus_set_target (focus, target);
+          gtk_pointer_focus_set_coordinates (focus, x, y);
+        }
+      else
         {
-          g_signal_handlers_disconnect_by_data (priv->vadj, popover);
-          g_object_unref (priv->vadj);
-          priv->vadj = NULL;
+          gtk_popover_remove_pointer_focus (popover, focus);
         }
 
-      if (priv->hadj)
-        {
-          g_signal_handlers_disconnect_by_data (priv->hadj, popover);
-          g_object_unref (priv->hadj);
-          priv->hadj = NULL;
-        }
+      gtk_pointer_focus_unref (focus);
+    }
+  else if (target)
+    {
+      focus = gtk_pointer_focus_new (root, target, device, sequence, x, y);
+      gtk_popover_add_pointer_focus (popover, focus);
+      gtk_pointer_focus_unref (focus);
+    }
+}
+
+static void
+gtk_popover_root_update_pointer_focus_on_state_change (GtkRoot   *root,
+                                                       GtkWidget *widget)
+{
+  GtkPopover *popover = GTK_POPOVER (root);
+  GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
+  GList *l = priv->foci, *cur;
+
+  while (l)
+    {
+      GtkPointerFocus *focus = l->data;
 
-      g_object_unref (priv->parent_scrollable);
-    }
+      cur = l;
+      focus = cur->data;
+      l = cur->next;
 
-  priv->parent_scrollable = scrollable;
+      gtk_pointer_focus_ref (focus);
 
-  if (scrollable)
-    {
-      g_object_ref (scrollable);
-      priv->vadj = gtk_scrollable_get_vadjustment (scrollable);
-      priv->hadj = gtk_scrollable_get_hadjustment (scrollable);
+      if (focus->grab_widget &&
+          (focus->grab_widget == widget ||
+           gtk_widget_is_ancestor (focus->grab_widget, widget)))
+        gtk_pointer_focus_set_implicit_grab (focus, NULL);
 
-      if (priv->vadj)
+      if (GTK_WIDGET (focus->toplevel) == widget)
         {
-          g_object_ref (priv->vadj);
-          g_signal_connect (priv->vadj, "changed",
-                            G_CALLBACK (adjustment_changed_cb), popover);
-          g_signal_connect (priv->vadj, "value-changed",
-                            G_CALLBACK (adjustment_changed_cb), popover);
+          /* Unmapping the toplevel, remove pointer focus */
+          priv->foci = g_list_remove_link (priv->foci, cur);
+          gtk_pointer_focus_unref (focus);
         }
-
-      if (priv->hadj)
+      else if (focus->target == widget ||
+               gtk_widget_is_ancestor (focus->target, widget))
         {
-          g_object_ref (priv->hadj);
-          g_signal_connect (priv->hadj, "changed",
-                            G_CALLBACK (adjustment_changed_cb), popover);
-          g_signal_connect (priv->hadj, "value-changed",
-                            G_CALLBACK (adjustment_changed_cb), popover);
+          gtk_pointer_focus_repick_target (focus);
         }
+
+      gtk_pointer_focus_unref (focus);
     }
 }
 
-static void
-scrollable_notify_cb (GObject    *object,
-                      GParamSpec *pspec,
-                      GtkPopover *popover)
+static GtkWidget *
+gtk_popover_root_lookup_pointer_focus (GtkRoot          *root,
+                                       GdkDevice        *device,
+                                       GdkEventSequence *sequence)
 {
-  if (pspec->value_type == GTK_TYPE_ADJUSTMENT)
-    _gtk_popover_set_scrollable (popover, GTK_SCROLLABLE (object));
+  GtkPopover *popover = GTK_POPOVER (root);
+  GtkPointerFocus *focus;
+
+  focus = gtk_popover_lookup_pointer_focus (popover, device, sequence);
+  return focus ? gtk_pointer_focus_get_target (focus) : NULL;
 }
 
-static void
-gtk_popover_set_scrollable_full (GtkPopover    *popover,
-                                 GtkScrollable *scrollable)
+static GtkWidget *
+gtk_popover_root_lookup_effective_pointer_focus (GtkRoot          *root,
+                                                 GdkDevice        *device,
+                                                 GdkEventSequence *sequence)
 {
-  GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
+  GtkPopover *popover = GTK_POPOVER (root);
+  GtkPointerFocus *focus;
 
-  if (priv->scrollable_notify_id != 0 &&
-      g_signal_handler_is_connected (priv->parent_scrollable, priv->scrollable_notify_id))
-    {
-      g_signal_handler_disconnect (priv->parent_scrollable, priv->scrollable_notify_id);
-      priv->scrollable_notify_id = 0;
-    }
+  focus = gtk_popover_lookup_pointer_focus (popover, device, sequence);
+  return focus ? gtk_pointer_focus_get_effective_target (focus) : NULL;
+}
 
-  _gtk_popover_set_scrollable (popover, scrollable);
+static GtkWidget *
+gtk_popover_root_lookup_pointer_focus_implicit_grab (GtkRoot          *root,
+                                                     GdkDevice        *device,
+                                                     GdkEventSequence *sequence)
+{  
+  GtkPopover *popover = GTK_POPOVER (root);
+  GtkPointerFocus *focus;
 
-  if (scrollable)
-    {
-      priv->scrollable_notify_id =
-        g_signal_connect (priv->parent_scrollable, "notify",
-                          G_CALLBACK (scrollable_notify_cb), popover);
-    }
+  focus = gtk_popover_lookup_pointer_focus (popover, device, sequence);
+  return focus ? gtk_pointer_focus_get_implicit_grab (focus) : NULL;
 }
 
 static void
-gtk_popover_update_relative_to (GtkPopover *popover,
-                                GtkWidget  *relative_to)
+gtk_popover_root_set_pointer_focus_grab (GtkRoot          *root,
+                                         GdkDevice        *device,
+                                         GdkEventSequence *sequence,
+                                         GtkWidget        *grab_widget)
 {
-  GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
+  GtkPopover *popover = GTK_POPOVER (root);
+  GtkPointerFocus *focus;
 
-  if (priv->widget == relative_to)
+  focus = gtk_popover_lookup_pointer_focus (popover, device, sequence);
+  if (!focus && !grab_widget)
     return;
+  g_assert (focus != NULL);
+  gtk_pointer_focus_set_implicit_grab (focus, grab_widget);
+}
 
-  g_object_ref (popover);
+static void
+update_cursor (GtkRoot   *root,
+               GdkDevice *device,
+               GtkWidget *grab_widget,
+               GtkWidget *target)
+{
+  GdkCursor *cursor = NULL;
 
-  if (priv->window)
+  if (grab_widget && !gtk_widget_is_ancestor (target, grab_widget))
     {
-      _gtk_window_remove_popover (priv->window, GTK_WIDGET (popover));
-      priv->window = NULL;
+      /* Outside the grab widget, cursor stays to whatever the grab
+       * widget says.
+       */
+      cursor = gtk_widget_get_cursor (grab_widget);
     }
-
-  popover_unset_prev_focus (popover);
-
-  if (priv->widget)
+  else
     {
-      if (g_signal_handler_is_connected (priv->widget, priv->hierarchy_changed_id))
-        g_signal_handler_disconnect (priv->widget, priv->hierarchy_changed_id);
-      if (g_signal_handler_is_connected (priv->widget, priv->size_allocate_id))
-        g_signal_handler_disconnect (priv->widget, priv->size_allocate_id);
-      if (g_signal_handler_is_connected (priv->widget, priv->unmap_id))
-        g_signal_handler_disconnect (priv->widget, priv->unmap_id);
-      if (g_signal_handler_is_connected (priv->widget, priv->state_changed_id))
-        g_signal_handler_disconnect (priv->widget, priv->state_changed_id);
-      if (g_signal_handler_is_connected (priv->widget, priv->grab_notify_id))
-        g_signal_handler_disconnect (priv->widget, priv->grab_notify_id);
-
-      widget_unmanage_popover (priv->widget, popover);
-    }
+      /* Inside the grab widget or in absence of grabs, allow walking
+       * up the hierarchy to find out the cursor.
+       */
+      while (target)
+        {
+          if (grab_widget && target == grab_widget)
+            break;
 
-  if (priv->parent_scrollable)
-    gtk_popover_set_scrollable_full (popover, NULL);
+          cursor = gtk_widget_get_cursor (target);
 
-  priv->widget = relative_to;
-  g_object_notify_by_pspec (G_OBJECT (popover), properties[PROP_RELATIVE_TO]);
+          if (cursor)
+            break;
 
-  if (priv->widget)
-    {
-      priv->window =
-        GTK_WINDOW (gtk_widget_get_ancestor (priv->widget, GTK_TYPE_WINDOW));
-
-      priv->hierarchy_changed_id =
-        g_signal_connect (priv->widget, "notify::root",
-                          G_CALLBACK (_gtk_popover_parent_hierarchy_changed),
-                          popover);
-      priv->size_allocate_id =
-        g_signal_connect (priv->widget, "size-allocate",
-                          G_CALLBACK (gtk_popover_parent_size_allocate),
-                          popover);
-      priv->unmap_id =
-        g_signal_connect (priv->widget, "unmap",
-                          G_CALLBACK (_gtk_popover_parent_unmap),
-                          popover);
-      priv->state_changed_id =
-        g_signal_connect (priv->widget, "state-flags-changed",
-                          G_CALLBACK (_gtk_popover_parent_state_changed),
-                          popover);
-      priv->grab_notify_id =
-        g_signal_connect (priv->widget, "grab-notify",
-                          G_CALLBACK (_gtk_popover_parent_grab_notify),
-                          popover);
-
-      /* Give ownership of the popover to widget */
-      widget_manage_popover (priv->widget, popover);
+          target = _gtk_widget_get_parent (target);
+        }
     }
 
-  if (priv->window)
-    _gtk_window_add_popover (priv->window, GTK_WIDGET (popover), priv->widget, TRUE);
-
-  if (priv->widget)
-    gtk_popover_update_scrollable (popover);
-
-  _gtk_widget_update_parent_muxer (GTK_WIDGET (popover));
-  g_object_unref (popover);
+  gdk_surface_set_device_cursor (gtk_widget_get_surface (GTK_WIDGET (root)), device, cursor);
 }
 
 static void
-gtk_popover_update_pointing_to (GtkPopover         *popover,
-                                const GdkRectangle *pointing_to)
+gtk_popover_root_maybe_update_cursor (GtkRoot   *root,
+                                      GtkWidget *widget,
+                                      GdkDevice *device)
 {
+  GtkPopover *popover = GTK_POPOVER (root);
   GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
+  GList *l;
 
-  if (pointing_to)
+  for (l = priv->foci; l; l = l->next)
     {
-      priv->pointing_to = *pointing_to;
-      priv->has_pointing_to = TRUE;
-    }
-  else
-    priv->has_pointing_to = FALSE;
+      GtkPointerFocus *focus = l->data;
+      GtkWidget *grab_widget = NULL;
+      GtkWidget  *target;
 
-  g_object_notify_by_pspec (G_OBJECT (popover), properties[PROP_POINTING_TO]);
-}
+      if (focus->sequence)
+        continue;
+      if (device && device != focus->device)
+        continue;
 
-static void
-gtk_popover_update_preferred_position (GtkPopover      *popover,
-                                       GtkPositionType  position)
-{
-  GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
+#if 0
+        {
+          GtkWindowGroup *group = gtk_window_get_group (root);
+          grab_widget = gtk_window_group_get_current_device_grab (group, focus->device);
+          if (!grab_widget)
+            grab_widget = gtk_window_group_get_current_grab (group);
+        }
+#endif
 
-  if (priv->preferred_position == position)
-    return;
+      if (!grab_widget)
+        grab_widget = gtk_pointer_focus_get_implicit_grab (focus);
 
-  priv->preferred_position = position;
-  g_object_notify_by_pspec (G_OBJECT (popover), properties[PROP_POSITION]);
-}
+      target = gtk_pointer_focus_get_target (focus);
 
-/**
- * gtk_popover_new:
- * @relative_to: (allow-none): #GtkWidget the popover is related to
- *
- * Creates a new popover to point to @relative_to
- *
- * Returns: a new #GtkPopover
- **/
-GtkWidget *
-gtk_popover_new (GtkWidget *relative_to)
-{
-  g_return_val_if_fail (relative_to == NULL || GTK_IS_WIDGET (relative_to), NULL);
+      if (widget)
+        {
+          /* Check whether the changed widget affects the current cursor
+           * lookups.
+           */
+          if (grab_widget && grab_widget != widget &&
+              !gtk_widget_is_ancestor (widget, grab_widget))
+            continue;
+          if (target != widget &&
+              !gtk_widget_is_ancestor (target, widget))
+            continue;
+        }
+
+      update_cursor (focus->toplevel, focus->device, grab_widget, target);
+
+      if (device)
+        break;
+    }
+}
 
-  return g_object_new (GTK_TYPE_POPOVER,
-                       "relative-to", relative_to,
-                       NULL);
+static void
+gtk_popover_root_interface_init (GtkRootInterface *iface)
+{
+  iface->get_display = gtk_popover_root_get_display;
+  iface->get_renderer = gtk_popover_root_get_renderer;
+  iface->get_surface_transform = gtk_popover_root_get_surface_transform;
+  iface->check_resize = gtk_popover_root_check_resize;
+  iface->add_mnemonic = gtk_popover_root_add_mnemonic;
+  iface->remove_mnemonic = gtk_popover_root_remove_mnemonic;
+  iface->activate_key = gtk_popover_root_activate_key;
+  iface->update_pointer_focus = gtk_popover_root_update_pointer_focus;
+  iface->update_pointer_focus_on_state_change = gtk_popover_root_update_pointer_focus_on_state_change;
+  iface->lookup_pointer_focus = gtk_popover_root_lookup_pointer_focus;
+  iface->lookup_pointer_focus_implicit_grab = gtk_popover_root_lookup_pointer_focus_implicit_grab;
+  iface->lookup_effective_pointer_focus = gtk_popover_root_lookup_effective_pointer_focus;
+  iface->set_pointer_focus_grab = gtk_popover_root_set_pointer_focus_grab;
+  iface->maybe_update_cursor = gtk_popover_root_maybe_update_cursor;
 }
 
 /**
@@ -2057,7 +1410,8 @@ gtk_popover_new (GtkWidget *relative_to)
  * Sets a new widget to be attached to @popover. If @popover is
  * visible, the position will be updated.
  *
- * Note: the ownership of popovers is always given to their @relative_to
+ * Note: the ownership of popovers is always given to their @relative_t
+o
  * widget, so if @relative_to is set to %NULL on an attached @popover, it
  * will be detached from its previous widget, and consequently destroyed
  * unless extra references are kept.
@@ -2066,13 +1420,32 @@ void
 gtk_popover_set_relative_to (GtkPopover *popover,
                              GtkWidget  *relative_to)
 {
+  GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
+  
   g_return_if_fail (GTK_IS_POPOVER (popover));
-  g_return_if_fail (relative_to == NULL || GTK_IS_WIDGET (relative_to));
 
-  gtk_popover_update_relative_to (popover, relative_to);
+  g_object_ref (popover);
+
+  if (priv->relative_to)
+    {
+      g_signal_handlers_disconnect_by_func (priv->relative_to, size_changed, popover);
+      gtk_widget_unparent (GTK_WIDGET (popover));
+    }
+
+  priv->relative_to = relative_to;
+
+  if (priv->relative_to)
+    {
+      g_signal_connect (priv->relative_to, "size-allocate", G_CALLBACK (size_changed), popover);
+      priv->display = gtk_widget_get_display (relative_to);
+      gtk_css_node_set_parent (gtk_widget_get_css_node (GTK_WIDGET (popover)),
+                               gtk_widget_get_css_node (relative_to));
+      gtk_widget_set_parent (GTK_WIDGET (popover), relative_to);
+    }
+
+  g_object_notify_by_pspec (G_OBJECT (popover), properties[PROP_RELATIVE_TO]);
 
-  if (relative_to)
-    gtk_popover_update_position (popover);
+  g_object_unref (popover);
 }
 
 /**
@@ -2090,7 +1463,7 @@ gtk_popover_get_relative_to (GtkPopover *popover)
 
   g_return_val_if_fail (GTK_IS_POPOVER (popover), NULL);
 
-  return priv->widget;
+  return priv->relative_to;
 }
 
 /**
@@ -2106,11 +1479,19 @@ void
 gtk_popover_set_pointing_to (GtkPopover         *popover,
                              const GdkRectangle *rect)
 {
+  GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
+
   g_return_if_fail (GTK_IS_POPOVER (popover));
-  g_return_if_fail (rect != NULL);
 
-  gtk_popover_update_pointing_to (popover, rect);
-  gtk_popover_update_position (popover);
+  if (rect)
+    {
+      priv->pointing_to = *rect;
+      priv->has_pointing_to = TRUE;
+    }
+  else
+    priv->has_pointing_to = FALSE;
+
+  g_object_notify_by_pspec (G_OBJECT (popover), properties[PROP_POINTING_TO]);
 }
 
 /**
@@ -2136,18 +1517,6 @@ gtk_popover_get_pointing_to (GtkPopover   *popover,
 
   if (priv->has_pointing_to)
     *rect = priv->pointing_to;
-  else if (priv->widget)
-    {
-      graphene_rect_t r;
-
-      if (!gtk_widget_compute_bounds (priv->widget, priv->widget, &r))
-        return FALSE;
-
-      rect->x = floorf (r.origin.x);
-      rect->y = floorf (r.origin.y);
-      rect->width = ceilf (r.size.width);
-      rect->height = ceilf (r.size.height);
-    }
 
   return priv->has_pointing_to;
 }
@@ -2168,11 +1537,16 @@ void
 gtk_popover_set_position (GtkPopover      *popover,
                           GtkPositionType  position)
 {
+  GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
+
   g_return_if_fail (GTK_IS_POPOVER (popover));
-  g_return_if_fail (position >= GTK_POS_LEFT && position <= GTK_POS_BOTTOM);
 
-  gtk_popover_update_preferred_position (popover, position);
-  gtk_popover_update_position (popover);
+  if (priv->position == position)
+    return;
+
+  priv->position = position;
+
+  g_object_notify_by_pspec (G_OBJECT (popover), properties[PROP_POSITION]);
 }
 
 /**
@@ -2190,7 +1564,7 @@ gtk_popover_get_position (GtkPopover *popover)
 
   g_return_val_if_fail (GTK_IS_POPOVER (popover), GTK_POS_TOP);
 
-  return priv->preferred_position;
+  return priv->position;
 }
 
 /**
@@ -2218,9 +1592,6 @@ gtk_popover_set_modal (GtkPopover *popover,
 
   priv->modal = modal;
 
-  if (gtk_widget_is_visible (GTK_WIDGET (popover)))
-    gtk_popover_apply_modality (popover, priv->modal);
-
   g_object_notify_by_pspec (G_OBJECT (popover), properties[PROP_MODAL]);
 }
 
@@ -2243,6 +1614,57 @@ gtk_popover_get_modal (GtkPopover *popover)
   return priv->modal;
 }
 
+/**
+ * gtk_popover_popup:
+ * @popover: a #GtkPopover
+ *
+ * Pops @popover up. This is different than a gtk_widget_show() call
+ * in that it shows the popover with a transition. If you want to show
+ * the popover without a transition, use gtk_widget_show().
+ */
+void
+gtk_popover_popup (GtkPopover *popover)
+{
+  g_return_if_fail (GTK_IS_POPOVER (popover));
+
+  gtk_widget_show (GTK_WIDGET (popover));
+}
+
+/**
+ * gtk_popover_popdown:
+ * @popover: a #GtkPopover
+ *
+ * Pops @popover down.This is different than a gtk_widget_hide() call
+ * in that it shows the popover with a transition. If you want to hide
+ * the popover without a transition, use gtk_widget_hide().
+ */
+void
+gtk_popover_popdown (GtkPopover *popover)
+{
+  g_return_if_fail (GTK_IS_POPOVER (popover));
+
+  gtk_widget_hide (GTK_WIDGET (popover));
+}
+
+/**
+ * gtk_popover_set_default_widget:
+ * @popover: a #GtkPopover
+ * @widget: (allow-none): the new default widget, or %NULL
+ *
+ * Sets the widget that should be set as default widget while
+ * the popover is shown (see gtk_window_set_default()). #GtkPopover
+ * remembers the previous default widget and reestablishes it
+ * when the popover is dismissed.
+ */
+void
+gtk_popover_set_default_widget (GtkPopover *popover,
+                                GtkWidget  *widget)
+{
+  g_return_if_fail (GTK_IS_POPOVER (popover));
+
+  gtk_root_set_default (GTK_ROOT (popover), widget);
+}
+
 static void
 back_to_main (GtkWidget *popover)
 {
@@ -2289,7 +1711,6 @@ gtk_popover_bind_model (GtkPopover  *popover,
                         GMenuModel  *model,
                         const gchar *action_namespace)
 {
-  GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
   GtkWidget *child;
   GtkWidget *stack;
   GtkStyleContext *style_context;
@@ -2301,7 +1722,7 @@ gtk_popover_bind_model (GtkPopover  *popover,
   if (child)
     gtk_widget_destroy (child);
 
-  style_context = gtk_widget_get_style_context (priv->contents_widget);
+  style_context = gtk_widget_get_style_context (GTK_WIDGET (popover));
 
   if (model)
     {
@@ -2309,6 +1730,7 @@ gtk_popover_bind_model (GtkPopover  *popover,
       gtk_stack_set_vhomogeneous (GTK_STACK (stack), FALSE);
       gtk_stack_set_transition_type (GTK_STACK (stack), GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT_RIGHT);
       gtk_stack_set_interpolate_size (GTK_STACK (stack), TRUE);
+      gtk_widget_show (stack);
       gtk_container_add (GTK_CONTAINER (popover), stack);
 
       gtk_menu_section_box_new_toplevel (GTK_STACK (stack),
@@ -2361,155 +1783,11 @@ gtk_popover_new_from_model (GtkWidget  *relative_to,
   return popover;
 }
 
-/**
- * gtk_popover_set_default_widget:
- * @popover: a #GtkPopover
- * @widget: (allow-none): the new default widget, or %NULL
- *
- * Sets the widget that should be set as default widget while
- * the popover is shown (see gtk_window_set_default()). #GtkPopover
- * remembers the previous default widget and reestablishes it
- * when the popover is dismissed.
- */
-void
-gtk_popover_set_default_widget (GtkPopover *popover,
-                                GtkWidget  *widget)
-{
-  GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
-
-  g_return_if_fail (GTK_IS_POPOVER (popover));
-  g_return_if_fail (widget == NULL || gtk_widget_get_can_default (widget));
-
-  if (priv->default_widget == widget)
-    return;
-
-  if (priv->default_widget)
-    g_object_unref (priv->default_widget);
-
-  priv->default_widget = widget;
-
-  if (priv->default_widget)
-    g_object_ref (priv->default_widget);
-
-  if (gtk_widget_get_mapped (GTK_WIDGET (popover)))
-    gtk_window_set_default (priv->window, priv->default_widget);
-}
 
-/**
- * gtk_popover_get_default_widget:
- * @popover: a #GtkPopover
- *
- * Gets the widget that should be set as the default while
- * the popover is shown.
- *
- * Returns: (nullable) (transfer none): the default widget,
- * or %NULL if there is none
- */
 GtkWidget *
-gtk_popover_get_default_widget (GtkPopover *popover)
-{
-  GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
-
-  g_return_val_if_fail (GTK_IS_POPOVER (popover), NULL);
-
-  return priv->default_widget;
-}
-
-/**
- * gtk_popover_set_constrain_to:
- * @popover: a #GtkPopover
- * @constraint: the new constraint
- *
- * Sets a constraint for positioning this popover.
- *
- * Note that not all platforms support placing popovers freely,
- * and may already impose constraints.
- */
-void
-gtk_popover_set_constrain_to (GtkPopover           *popover,
-                              GtkPopoverConstraint  constraint)
-{
-  GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
-
-  g_return_if_fail (GTK_IS_POPOVER (popover));
-
-  if (priv->constraint == constraint)
-    return;
-
-  priv->constraint = constraint;
-  gtk_popover_update_position (popover);
-
-  g_object_notify_by_pspec (G_OBJECT (popover), properties[PROP_CONSTRAIN_TO]);
-}
-
-/**
- * gtk_popover_get_constrain_to:
- * @popover: a #GtkPopover
- *
- * Returns the constraint for placing this popover.
- * See gtk_popover_set_constrain_to().
- *
- * Returns: the constraint for placing this popover.
- */
-GtkPopoverConstraint
-gtk_popover_get_constrain_to (GtkPopover *popover)
-{
-  GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
-
-  g_return_val_if_fail (GTK_IS_POPOVER (popover), GTK_POPOVER_CONSTRAINT_WINDOW);
-
-  return priv->constraint;
-}
-
-/**
- * gtk_popover_popup:
- * @popover: a #GtkPopover
- *
- * Pops @popover up. This is different than a gtk_widget_show() call
- * in that it shows the popover with a transition. If you want to show
- * the popover without a transition, use gtk_widget_show().
- */
-void
-gtk_popover_popup (GtkPopover *popover)
-{
-  GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
-
-  g_return_if_fail (GTK_IS_POPOVER (popover));
-
-  if (priv->state == STATE_SHOWING ||
-      priv->state == STATE_SHOWN)
-    return;
-
-  gtk_widget_show (GTK_WIDGET (popover));
-
-  if (transitions_enabled (popover))
-    gtk_popover_set_state (popover, STATE_SHOWING);
-}
-
-/**
- * gtk_popover_popdown:
- * @popover: a #GtkPopover
- *
- * Pops @popover down.This is different than a gtk_widget_hide() call
- * in that it shows the popover with a transition. If you want to hide
- * the popover without a transition, use gtk_widget_hide().
- */
-void
-gtk_popover_popdown (GtkPopover *popover)
+gtk_popover_get_contents_widget (GtkPopover *popover)
 {
   GtkPopoverPrivate *priv = gtk_popover_get_instance_private (popover);
 
-  g_return_if_fail (GTK_IS_POPOVER (popover));
-
-  if (priv->state == STATE_HIDING ||
-      priv->state == STATE_HIDDEN)
-    return;
-
-
-  if (!transitions_enabled (popover))
-    gtk_widget_hide (GTK_WIDGET (popover));
-  else
-    gtk_popover_set_state (popover, STATE_HIDING);
-
-  gtk_popover_hide_internal (popover);
+  return priv->contents_widget;
 }
diff --git a/gtk/gtkpopover.h b/gtk/gtkpopover.h
index 11acc02645..d628bfdf1c 100644
--- a/gtk/gtkpopover.h
+++ b/gtk/gtkpopover.h
@@ -1,5 +1,8 @@
 /* GTK - The GIMP Toolkit
- * Copyright © 2013 Carlos Garnacho <carlosg gnome org>
+ * Copyright (C) 2019 Red Hat, Inc.
+ *
+ * Authors:
+ * - Matthias Clasen <mclasen redhat com>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -22,95 +25,92 @@
 #error "Only <gtk/gtk.h> can be included directly."
 #endif
 
-#include <gtk/gtkwindow.h>
+#include <gtk/gtkbin.h>
 
 G_BEGIN_DECLS
 
-#define GTK_TYPE_POPOVER           (gtk_popover_get_type ())
-#define GTK_POPOVER(o)             (G_TYPE_CHECK_INSTANCE_CAST ((o), GTK_TYPE_POPOVER, GtkPopover))
-#define GTK_POPOVER_CLASS(c)       (G_TYPE_CHECK_CLASS_CAST ((c), GTK_TYPE_POPOVER, GtkPopoverClass))
-#define GTK_IS_POPOVER(o)          (G_TYPE_CHECK_INSTANCE_TYPE ((o), GTK_TYPE_POPOVER))
-#define GTK_IS_POPOVER_CLASS(o)    (G_TYPE_CHECK_CLASS_TYPE ((o), GTK_TYPE_POPOVER))
-#define GTK_POPOVER_GET_CLASS(o)   (G_TYPE_INSTANCE_GET_CLASS ((o), GTK_TYPE_POPOVER, GtkPopoverClass))
+#define GTK_TYPE_POPOVER                 (gtk_popover_get_type ())
+#define GTK_POPOVER(obj)                 (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_POPOVER, GtkPopover))
+#define GTK_POPOVER_CLASS(klass)         (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_POPOVER, 
GtkPopoverClass))
+#define GTK_IS_POPOVER(obj)              (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_POPOVER))
+#define GTK_IS_POPOVER_CLASS(klass)      (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_POPOVER))
+#define GTK_POPOVER_GET_CLASS(obj)       (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_POPOVER, 
GtkPopoverClass))
 
-typedef struct _GtkPopover GtkPopover;
-typedef struct _GtkPopoverClass GtkPopoverClass;
+typedef struct _GtkPopover       GtkPopover;
+typedef struct _GtkPopoverClass  GtkPopoverClass;
 
 struct _GtkPopover
 {
-  GtkBin parent_instance;
+  GtkBin parent;
 };
 
 struct _GtkPopoverClass
 {
   GtkBinClass parent_class;
 
-  void (* closed) (GtkPopover *popover);
+  /* keybinding signals */
+
+  void     (* activate_focus)   (GtkPopover *popover);
+  void     (* activate_default) (GtkPopover *popover);
+  void     (* close)            (GtkPopover *popover);
 
-  /*< private >*/
+  /* signals */
 
-  /* Padding for future expansion */
-  gpointer reserved[10];
+  void     (* closed)           (GtkPopover *popover);
 };
 
 GDK_AVAILABLE_IN_ALL
-GType           gtk_popover_get_type        (void) G_GNUC_CONST;
+GType           gtk_popover_get_type (void) G_GNUC_CONST;
 
 GDK_AVAILABLE_IN_ALL
-GtkWidget *     gtk_popover_new             (GtkWidget             *relative_to);
+GtkWidget *     gtk_popover_new      (GtkWidget *relative_to);
 
 GDK_AVAILABLE_IN_ALL
-GtkWidget *     gtk_popover_new_from_model  (GtkWidget             *relative_to,
-                                             GMenuModel            *model);
+GtkWidget *     gtk_popover_new_from_model  (GtkWidget  *relative_to,
+                                             GMenuModel *model);
 
 GDK_AVAILABLE_IN_ALL
-void            gtk_popover_set_relative_to (GtkPopover            *popover,
-                                             GtkWidget             *relative_to);
-GDK_AVAILABLE_IN_ALL
-GtkWidget *     gtk_popover_get_relative_to (GtkPopover            *popover);
+void            gtk_popover_bind_model      (GtkPopover  *popover,
+                                             GMenuModel  *model,
+                                             const gchar *action_namespace);
 
 GDK_AVAILABLE_IN_ALL
-void            gtk_popover_set_pointing_to (GtkPopover            *popover,
-                                             const GdkRectangle    *rect);
-GDK_AVAILABLE_IN_ALL
-gboolean        gtk_popover_get_pointing_to (GtkPopover            *popover,
-                                             GdkRectangle          *rect);
-GDK_AVAILABLE_IN_ALL
-void            gtk_popover_set_position    (GtkPopover            *popover,
-                                             GtkPositionType        position);
+void            gtk_popover_set_relative_to (GtkPopover   *popover,
+                                           GtkWidget  *relative_to);
 GDK_AVAILABLE_IN_ALL
-GtkPositionType gtk_popover_get_position    (GtkPopover            *popover);
+GtkWidget *     gtk_popover_get_relative_to (GtkPopover   *popover);
 
 GDK_AVAILABLE_IN_ALL
-void            gtk_popover_set_modal       (GtkPopover            *popover,
-                                             gboolean               modal);
+void            gtk_popover_set_pointing_to (GtkPopover           *popover,
+                                           const GdkRectangle *rect);
 GDK_AVAILABLE_IN_ALL
-gboolean        gtk_popover_get_modal       (GtkPopover            *popover);
-
+gboolean        gtk_popover_get_pointing_to (GtkPopover           *popover,
+                                           GdkRectangle       *rect);
+GDK_AVAILABLE_IN_ALL
+void            gtk_popover_set_position    (GtkPopover           *popover,
+                                           GtkPositionType     position);
 GDK_AVAILABLE_IN_ALL
-void            gtk_popover_bind_model      (GtkPopover            *popover,
-                                             GMenuModel            *model,
-                                             const gchar           *action_namespace);
+GtkPositionType gtk_popover_get_position    (GtkPopover           *popover);
 
 GDK_AVAILABLE_IN_ALL
-void            gtk_popover_set_default_widget (GtkPopover *popover,
-                                                GtkWidget  *widget);
+void            gtk_popover_set_modal       (GtkPopover           *popover,
+                                           gboolean            modal);
 GDK_AVAILABLE_IN_ALL
-GtkWidget *     gtk_popover_get_default_widget (GtkPopover *popover);
+gboolean        gtk_popover_get_modal       (GtkPopover           *popover);
 
 GDK_AVAILABLE_IN_ALL
-void                 gtk_popover_set_constrain_to (GtkPopover           *popover,
-                                                   GtkPopoverConstraint  constraint);
-
+void            gtk_popover_popup (GtkPopover *popover);
 GDK_AVAILABLE_IN_ALL
-GtkPopoverConstraint gtk_popover_get_constrain_to (GtkPopover           *popover);
+void            gtk_popover_popdown (GtkPopover *popover);
 
 GDK_AVAILABLE_IN_ALL
-void                 gtk_popover_popup            (GtkPopover *popover);
+void
+gtk_popover_set_default_widget (GtkPopover *popover,
+                                GtkWidget  *widget);
 
-GDK_AVAILABLE_IN_ALL
-void                 gtk_popover_popdown          (GtkPopover *popover);
 
+GDK_AVAILABLE_IN_ALL
+GListModel *    gtk_popover_get_popovers (void);
 
 G_END_DECLS
 
diff --git a/gtk/gtkpopovermenu.c b/gtk/gtkpopovermenu.c
index 241f02857d..89abd8b65e 100644
--- a/gtk/gtkpopovermenu.c
+++ b/gtk/gtkpopovermenu.c
@@ -139,8 +139,10 @@ gtk_popover_menu_init (GtkPopoverMenu *popover)
   g_signal_connect (stack, "notify::visible-child-name",
                     G_CALLBACK (visible_submenu_changed), popover);
 
+#if 0
   style_context = gtk_widget_get_style_context (gtk_popover_get_contents_widget (GTK_POPOVER (popover)));
   gtk_style_context_add_class (style_context, GTK_STYLE_CLASS_MENU);
+#endif
 }
 
 static void
diff --git a/gtk/gtkpopoverprivate.h b/gtk/gtkpopoverprivate.h
index fe24a5d775..db5fa6e57a 100644
--- a/gtk/gtkpopoverprivate.h
+++ b/gtk/gtkpopoverprivate.h
@@ -22,8 +22,6 @@
 
 G_BEGIN_DECLS
 
-void gtk_popover_update_position (GtkPopover *popover);
-
 GtkWidget *gtk_popover_get_contents_widget (GtkPopover *popover);
 
 G_END_DECLS
diff --git a/gtk/gtkwidget.c b/gtk/gtkwidget.c
index 1b6fa0eee0..b9950b5828 100644
--- a/gtk/gtkwidget.c
+++ b/gtk/gtkwidget.c
@@ -7290,10 +7290,12 @@ gtk_widget_get_scale_factor (GtkWidget *widget)
    * just returning 1:
    */
   display = _gtk_widget_get_display (widget);
-  monitor = gdk_display_get_monitor (display, 0);
-
-  if (monitor)
-    return gdk_monitor_get_scale_factor (monitor);
+  if (display)
+    {
+      monitor = gdk_display_get_monitor (display, 0);
+      if (monitor)
+        return gdk_monitor_get_scale_factor (monitor);
+    }
 
   return 1;
 }
diff --git a/gtk/gtkwindow.c b/gtk/gtkwindow.c
index 0e86d264a6..dd33c78fb5 100644
--- a/gtk/gtkwindow.c
+++ b/gtk/gtkwindow.c
@@ -5966,8 +5966,10 @@ popover_size_allocate (GtkWindowPopover *popover,
   if (!gtk_widget_get_mapped (popover->widget))
     return;
 
+#if 0
   if (GTK_IS_POPOVER (popover->widget))
     gtk_popover_update_position (GTK_POPOVER (popover->widget));
+#endif
 
   popover_get_rect (popover, window, &rect);
   gtk_widget_size_allocate (popover->widget, &rect, -1);
diff --git a/gtk/inspector/object-tree.c b/gtk/inspector/object-tree.c
index f2caf34708..f977096d69 100644
--- a/gtk/inspector/object-tree.c
+++ b/gtk/inspector/object-tree.c
@@ -41,6 +41,7 @@
 #include "gtklabel.h"
 #include "gtklistbox.h"
 #include "gtkmenuitem.h"
+#include "gtkpopover.h"
 #include "gtksettings.h"
 #include "gtksizegroup.h"
 #include "gtktextview.h"
@@ -1144,6 +1145,7 @@ create_root_model (void)
                                          g_object_unref);
   gtk_filter_list_model_set_model (filter, gtk_window_get_toplevels ());
   g_list_store_append (list, filter);
+  g_list_store_append (list, gtk_popover_get_popovers ());
   g_object_unref (filter);
 
   flatten = gtk_flatten_list_model_new (G_TYPE_OBJECT, G_LIST_MODEL (list));
diff --git a/tests/meson.build b/tests/meson.build
index f70401b2d4..677fbb74e6 100644
--- a/tests/meson.build
+++ b/tests/meson.build
@@ -114,7 +114,6 @@ gtk_tests = [
   ['testpopover'],
   ['gdkgears', ['gtkgears.c']],
   ['listmodel'],
-  ['testpopup'],
   ['testgaction'],
   ['testwidgetfocus'],
   ['testwidgettransforms'],


[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]