Ticket #4134: 0001-OSK-im-osk-position.3.patch

gtk/gtkimcontext.c

@@ -105 +105 @@
   COMMIT,
   RETRIEVE_SURROUNDING,
   DELETE_SURROUNDING,
+  CLEAR_AREA,
   LAST_SIGNAL
 };
 
@@ -121 +122 @@
 struct _GtkIMContextPrivate {
   GtkInputPurpose purpose;
   GtkInputHints hints;
+  GdkWindow *window;
+  GtkWidget *widget;
+
+  cairo_rectangle_int_t clear_area;
+  cairo_rectangle_int_t cursor_rect;
+  cairo_rectangle_int_t last_notified_clear_area;
+  guint clear_area_signal_id;
+  guint clear_area_idle_id;
+  guint focused : 1;
+  guint need_unset : 1;
+  guint need_position_update : 1;
 };
 
 static void     gtk_im_context_real_get_preedit_string (GtkIMContext   *context,
@@ -145 +157 @@
                                                         guint           property_id,
                                                         const GValue   *value,
                                                         GParamSpec     *pspec);
+static void     gtk_im_context_finalize                (GObject        *obj);
 
 
 G_DEFINE_ABSTRACT_TYPE (GtkIMContext, gtk_im_context, G_TYPE_OBJECT)
@@ -213 +226 @@
 
   object_class->get_property = gtk_im_context_get_property;
   object_class->set_property = gtk_im_context_set_property;
+  object_class->finalize = gtk_im_context_finalize;
 
   klass->get_preedit_string = gtk_im_context_real_get_preedit_string;
   klass->filter_keypress = gtk_im_context_real_filter_keypress;
@@ -327 +341 @@
                   G_TYPE_INT,
                   G_TYPE_INT);
 
+  im_context_signals[CLEAR_AREA] =
+      g_signal_new (I_("clear-area"),
+                    G_TYPE_FROM_CLASS (klass),
+                    G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
+                    0, NULL, NULL,
+                    _gtk_marshal_VOID__BOXED_BOXED,
+                    G_TYPE_NONE, 2,
+                    GDK_TYPE_RECTANGLE, GDK_TYPE_RECTANGLE);
+
   properties[PROP_INPUT_PURPOSE] =
     g_param_spec_enum ("input-purpose",
                          P_("Purpose"),
@@ -438 +461 @@
   return result;
 }
 
+static gboolean
+_gtk_im_context_clear_area_idle (gpointer user_data)
+{
+  GtkIMContext *context = user_data;
+  GtkIMContextPrivate *priv;
+
+  priv = G_TYPE_INSTANCE_GET_PRIVATE (context, GTK_TYPE_IM_CONTEXT,
+                                      GtkIMContextPrivate);
+
+  if (priv->need_position_update &&
+      (priv->clear_area.x != priv->last_notified_clear_area.x ||
+       priv->clear_area.y != priv->last_notified_clear_area.y ||
+       priv->clear_area.width != priv->last_notified_clear_area.width ||
+       priv->clear_area.height != priv->last_notified_clear_area.height))
+    {
+      if (priv->focused &&
+          priv->clear_area.width != 0 && priv->clear_area.height != 0)
+        {
+          cairo_rectangle_int_t rect;
+          GtkAllocation allocation;
+
+          rect = priv->cursor_rect;
+
+          gtk_widget_get_allocation (priv->widget, &allocation);
+          rect.x += allocation.x;
+          rect.y += allocation.y;
+          gdk_window_get_root_coords (priv->window,
+                                      rect.x, rect.y, &rect.x, &rect.y);
+
+          if (gtk_widget_request_clear_area (priv->widget, &priv->clear_area, &rect))
+            priv->need_unset = TRUE;
+        }
+      else if (!priv->focused && priv->need_unset)
+        {
+          gtk_widget_unset_clear_area (priv->widget, TRUE);
+          priv->need_unset = FALSE;
+        }
+
+      priv->last_notified_clear_area = priv->clear_area;
+    }
+
+  priv->need_position_update = FALSE;
+  priv->clear_area_idle_id = 0;
+  return FALSE;
+}
+
+static void
+_gtk_im_context_check_clear_area (GtkIMContext *context)
+{
+  GtkIMContextPrivate *priv;
+
+  priv = G_TYPE_INSTANCE_GET_PRIVATE (context, GTK_TYPE_IM_CONTEXT,
+                                      GtkIMContextPrivate);
+
+  if (priv->clear_area_idle_id)
+    g_source_remove (priv->clear_area_idle_id);
+
+  priv->clear_area_idle_id =
+    g_idle_add (_gtk_im_context_clear_area_idle, context);
+}
+
+static void
+_gtk_im_context_clear_area (GtkIMContext          *context,
+                            cairo_rectangle_int_t *clear_area,
+                            cairo_rectangle_int_t *cursor_rect,
+                            GtkWidget             *widget)
+{
+  GtkIMContextPrivate *priv;
+
+  priv = G_TYPE_INSTANCE_GET_PRIVATE (context, GTK_TYPE_IM_CONTEXT, GtkIMContextPrivate);
+
+  if (priv->clear_area.x != clear_area->x ||
+      priv->clear_area.y != clear_area->y ||
+      priv->clear_area.width != clear_area->width ||
+      priv->clear_area.height != clear_area->height)
+    priv->need_position_update = TRUE;
+
+  priv->clear_area = *clear_area;
+}
+
 /**
  * gtk_im_context_set_client_window:
  * @context: a #GtkIMContext
@@ -454 +557 @@
                                   GdkWindow    *window)
 {
   GtkIMContextClass *klass;
-  
+  GtkIMContextPrivate *priv;
+
   g_return_if_fail (GTK_IS_IM_CONTEXT (context));
 
   klass = GTK_IM_CONTEXT_GET_CLASS (context);
   if (klass->set_client_window)
     klass->set_client_window (context, window);
+
+  priv = G_TYPE_INSTANCE_GET_PRIVATE (context, GTK_TYPE_IM_CONTEXT, GtkIMContextPrivate);
+
+  if (priv->clear_area_signal_id)
+    {
+      g_signal_handler_disconnect (context, priv->clear_area_signal_id);
+      priv->clear_area_signal_id = 0;
+    }
+
+  if (window)
+    {
+      gpointer window_data;
+
+      gdk_window_get_user_data (window, &window_data);
+
+      if (GTK_IS_WIDGET (window_data))
+        {
+          priv->clear_area_signal_id = g_signal_connect (context, "clear-area",
+                                                         G_CALLBACK (_gtk_im_context_clear_area),
+                                                         window_data);
+          priv->window = window;
+          priv->widget = window_data;
+        }
+    }
 }
 
 /**
@@ -531 +659 @@
 gtk_im_context_focus_in (GtkIMContext   *context)
 {
   GtkIMContextClass *klass;
-  
+  GtkIMContextPrivate *priv;
+
   g_return_if_fail (GTK_IS_IM_CONTEXT (context));
   
   klass = GTK_IM_CONTEXT_GET_CLASS (context);
   if (klass->focus_in)
     klass->focus_in (context);
+
+  priv = G_TYPE_INSTANCE_GET_PRIVATE (context, GTK_TYPE_IM_CONTEXT, GtkIMContextPrivate);
+
+  if (!priv->focused)
+    {
+      priv->focused = TRUE;
+      priv->need_position_update = TRUE;
+    }
+
+  _gtk_im_context_check_clear_area (context);
 }
 
 /**
@@ -552 +691 @@
 gtk_im_context_focus_out (GtkIMContext   *context)
 {
   GtkIMContextClass *klass;
-  
+  GtkIMContextPrivate *priv;
+
   g_return_if_fail (GTK_IS_IM_CONTEXT (context));
 
   klass = GTK_IM_CONTEXT_GET_CLASS (context);
   if (klass->focus_out)
     klass->focus_out (context);
+
+  priv = G_TYPE_INSTANCE_GET_PRIVATE (context, GTK_TYPE_IM_CONTEXT, GtkIMContextPrivate);
+
+  if (priv->focused)
+    gtk_widget_unset_clear_area (priv->widget, TRUE);
+
+  _gtk_im_context_check_clear_area (context);
+  priv->focused = FALSE;
 }
 
 /**
@@ -575 +723 @@
   
   g_return_if_fail (GTK_IS_IM_CONTEXT (context));
 
+  _gtk_im_context_check_clear_area (context);
+
   klass = GTK_IM_CONTEXT_GET_CLASS (context);
   if (klass->reset)
     klass->reset (context);
@@ -595 +745 @@
                                     const GdkRectangle *area)
 {
   GtkIMContextClass *klass;
+  GtkIMContextPrivate *priv;
   
   g_return_if_fail (GTK_IS_IM_CONTEXT (context));
 
+  priv = G_TYPE_INSTANCE_GET_PRIVATE (context, GTK_TYPE_IM_CONTEXT,
+                                      GtkIMContextPrivate);
+
+  if (priv->cursor_rect.x != area->x ||
+      priv->cursor_rect.y != area->y ||
+      priv->cursor_rect.width != area->width ||
+      priv->cursor_rect.height != area->height)
+    {
+      priv->cursor_rect = *area;
+      priv->need_position_update = TRUE;
+    }
+
   klass = GTK_IM_CONTEXT_GET_CLASS (context);
   if (klass->set_cursor_location)
     klass->set_cursor_location (context, (GdkRectangle *) area);
+
+  _gtk_im_context_check_clear_area (context);
 }
 
 /**
@@ -798 +963 @@
       break;
     }
 }
+
+static void
+gtk_im_context_finalize (GObject *obj)
+{
+  GtkIMContextPrivate *priv = G_TYPE_INSTANCE_GET_PRIVATE (obj, GTK_TYPE_IM_CONTEXT, GtkIMContextPrivate);
+
+  if (priv->clear_area_signal_id)
+    g_signal_handler_disconnect (obj, priv->clear_area_signal_id);
+
+  if (priv->clear_area_idle_id)
+    g_source_remove (priv->clear_area_idle_id);
+
+  G_OBJECT_CLASS (gtk_im_context_parent_class)->finalize (obj);
+}

gtk/gtkimmulticontext.c

@@ -102 +102 @@
                                                              gint               n_chars,
                                                              GtkIMMulticontext *multicontext);
 
+static void     gtk_im_multicontext_clear_area_cb           (GtkIMContext      *slave,
+                                                             GdkRectangle      *osk_rect,
+                                                             GdkRectangle      *cursor_rect,
+                                                             GtkIMMulticontext *multicontext);
+
 static void propagate_purpose (GtkIMMulticontext *context);
 
 static const gchar *global_context_id = NULL;
@@ -197 +202 @@
       g_signal_handlers_disconnect_by_func (priv->slave,
                                             gtk_im_multicontext_commit_cb,
                                             multicontext);
+      g_signal_handlers_disconnect_by_func (priv->slave,
+                                            gtk_im_multicontext_clear_area_cb,
+                                            multicontext);
 
       g_object_unref (priv->slave);
       priv->slave = NULL;
@@ -231 +239 @@
       g_signal_connect (priv->slave, "delete-surrounding",
                         G_CALLBACK (gtk_im_multicontext_delete_surrounding_cb),
                         multicontext);
+      g_signal_connect (priv->slave, "clear-area",
+                        G_CALLBACK (gtk_im_multicontext_clear_area_cb),
+                        multicontext);
 
       if (!priv->use_preedit)   /* Default is TRUE */
         gtk_im_context_set_use_preedit (slave, FALSE);
@@ -553 +564 @@
 }
 
 static void
+gtk_im_multicontext_clear_area_cb (GtkIMContext      *slave,
+                                   GdkRectangle      *osk_rect,
+                                   GdkRectangle      *cursor_rect,
+                                   GtkIMMulticontext *multicontext)
+{
+  g_signal_emit_by_name (multicontext, "clear-area", osk_rect, cursor_rect);
+}
+
+static void
 activate_cb (GtkWidget         *menuitem,
              GtkIMMulticontext *context)
 {

gtk/gtkscrolledwindow.c

@@ -176 +176 @@
 
   gdouble                unclamped_hadj_value;
   gdouble                unclamped_vadj_value;
+  gdouble                clear_area_dy;
+  gdouble                focus_area_dy;
 };
 
 typedef struct
@@ -287 +289 @@
                                                                 gboolean           allow_overshooting,
                                                                 gboolean           snap_to_border);
 
+static gboolean gtk_scrolled_window_request_clear_area (GtkWidget             *widget,
+                                                        cairo_rectangle_int_t *clear_area,
+                                                        cairo_rectangle_int_t *cursor_area,
+                                                        gpointer               user_data);
+static gboolean gtk_scrolled_window_unset_clear_area   (GtkWidget             *widget,
+                                                         gboolean               snap_back,
+                                                        gpointer               user_data);
+
 static guint signals[LAST_SIGNAL] = {0};
 
 G_DEFINE_TYPE (GtkScrolledWindow, gtk_scrolled_window, GTK_TYPE_BIN)
@@ -597 +607 @@
   gtk_scrolled_window_update_real_placement (scrolled_window);
   priv->min_content_width = -1;
   priv->min_content_height = -1;
+  priv->focus_area_dy = 0;
+  priv->clear_area_dy = 0;
 
   gtk_scrolled_window_set_kinetic_scrolling (scrolled_window, TRUE);
   gtk_scrolled_window_set_capture_button_press (scrolled_window, TRUE);
+
+  g_signal_connect (scrolled_window, "request-clear-area",
+                    G_CALLBACK (gtk_scrolled_window_request_clear_area),
+                    NULL);
+  g_signal_connect (scrolled_window, "unset-clear-area",
+                    G_CALLBACK (gtk_scrolled_window_unset_clear_area),
+                    NULL);
 }
 
 /**
@@ -1823 +1842 @@
 
   if (priv->unclamped_vadj_value < lower)
     y = priv->unclamped_vadj_value - lower;
-  else if (priv->unclamped_vadj_value > upper)
-    y = priv->unclamped_vadj_value - upper;
+  else if (priv->unclamped_vadj_value + priv->focus_area_dy > upper)
+    y = priv->unclamped_vadj_value - upper + priv->focus_area_dy;
   else
     y = 0;
 
@@ -1878 +1897 @@
     window_allocation.x += -overshoot_x;
 
   if (overshoot_y < 0)
+  {
+    window_allocation.y -= priv->focus_area_dy;
     window_allocation.y += -overshoot_y;
+  }
 
   window_allocation.width -= ABS (overshoot_x);
   window_allocation.height -= ABS (overshoot_y);
@@ -2249 +2271 @@
     gtk_widget_hide (priv->vscrollbar);
 
   _gtk_scrolled_window_allocate_overshoot_window (scrolled_window);
+  _gtk_scrolled_window_set_adjustment_value (GTK_SCROLLED_WINDOW (widget),
+                                             gtk_range_get_adjustment (GTK_RANGE (priv->vscrollbar)),
+                                             priv->unclamped_vadj_value,
+                                             TRUE, FALSE);
 }
 
 static gboolean
@@ -2352 +2378 @@
                                            gboolean           snap_to_border)
 {
   GtkScrolledWindowPrivate *priv = scrolled_window->priv;
-  gdouble lower, upper, *prev_value;
+  gdouble lower, upper, *prev_value, diff = 0;
 
   lower = gtk_adjustment_get_lower (adjustment);
   upper = gtk_adjustment_get_upper (adjustment) -
@@ -2361 +2387 @@
   if (adjustment == gtk_range_get_adjustment (GTK_RANGE (priv->hscrollbar)))
     prev_value = &priv->unclamped_hadj_value;
   else if (adjustment == gtk_range_get_adjustment (GTK_RANGE (priv->vscrollbar)))
-    prev_value = &priv->unclamped_vadj_value;
+    {
+      diff = priv->focus_area_dy;
+      upper += priv->clear_area_dy;
+      prev_value = &priv->unclamped_vadj_value;
+    }
   else
     return FALSE;
 
+  value += diff;
+
   if (snap_to_border)
     {
       if (*prev_value < 0 && value > 0)
@@ -2379 +2411 @@
       upper += MAX_OVERSHOOT_DISTANCE;
     }
 
-  *prev_value = CLAMP (value, lower, upper);
   gtk_adjustment_set_value (adjustment, value);
+  *prev_value = CLAMP (value - diff, lower, upper);
 
-  return (*prev_value != value);
+  return (*prev_value != value - diff);
 }
 
 static gboolean
@@ -2457 +2489 @@
   else if (overshoot_x > 0)
     data->x_velocity -= OVERSHOOT_INVERSE_ACCELERATION * elapsed;
 
-  if (overshoot_y == 0)
+  if (overshoot_y >= 0 && overshoot_y <= priv->clear_area_dy)
     {
-      if (old_overshoot_y != 0)
+      if (old_overshoot_y < 0 || old_overshoot_y > priv->clear_area_dy)
         {
           /* Overshooting finished snapping back */
           data->y_velocity = 0;
@@ -2623 +2655 @@
 {
   GtkScrolledWindow *scrolled_window = GTK_SCROLLED_WINDOW (widget);
   GtkScrolledWindowPrivate *priv = scrolled_window->priv;
+  gint overshoot_x, overshoot_y;
   GtkWidget *child;
   gboolean overshoot;
   guint button;
@@ -2644 +2677 @@
       priv->release_timeout_id = 0;
     }
 
-  overshoot = _gtk_scrolled_window_get_overshoot (scrolled_window, NULL, NULL);
+  overshoot = _gtk_scrolled_window_get_overshoot (scrolled_window, &overshoot_x, &overshoot_y);
 
   if (priv->in_drag)
     gdk_device_ungrab (gdk_event_get_device (event), gdk_event_get_time (event));
@@ -2655 +2688 @@
        */
       gtk_scrolled_window_release_captured_event (scrolled_window);
 
-      if (!overshoot)
+      if (!overshoot ||
+          (overshoot_x == 0 && overshoot_y >= 0 &&
+           overshoot_y <= priv->clear_area_dy))
         return FALSE;
     }
   priv->in_drag = FALSE;
@@ -2763 +2798 @@
   vadjustment = gtk_range_get_adjustment (GTK_RANGE (priv->vscrollbar));
   if (vadjustment && priv->vscrollbar_visible)
     {
-      dy = (priv->last_motion_event_y_root - y_root) + priv->unclamped_vadj_value;
+      dy = (priv->last_motion_event_y_root - y_root) + priv->unclamped_vadj_value + priv->focus_area_dy;
       _gtk_scrolled_window_set_adjustment_value (scrolled_window, vadjustment,
                                                  dy, TRUE, FALSE);
     }
 
+  priv->focus_area_dy = 0;
   _gtk_scrolled_window_get_overshoot (scrolled_window,
                                       &new_overshoot_x, &new_overshoot_y);
 
@@ -3500 +3536 @@
     }
 }
 
+static gboolean
+gtk_scrolled_window_request_clear_area (GtkWidget             *widget,
+                                        cairo_rectangle_int_t *clear_area,
+                                        cairo_rectangle_int_t *cursor_area,
+                                        gpointer               user_data)
+{
+  GtkScrolledWindowPrivate *priv;
+  GtkAdjustment *adjustment;
+  GtkAllocation allocation;
+
+  priv = GTK_SCROLLED_WINDOW (widget)->priv;
+  adjustment = gtk_range_get_adjustment (GTK_RANGE (priv->vscrollbar));
+
+  gtk_widget_get_allocation (widget, &allocation);
+  gdk_window_get_root_coords (gtk_widget_get_window (widget),
+                              allocation.x, allocation.y,
+                              &allocation.x, &allocation.y);
+
+  priv->clear_area_dy = allocation.y + allocation.height - clear_area->y;
+  priv->focus_area_dy = cursor_area->y + cursor_area->height - clear_area->y;
+  _gtk_scrolled_window_set_adjustment_value (GTK_SCROLLED_WINDOW (widget),
+                                             adjustment, priv->unclamped_vadj_value,
+                                             TRUE, FALSE);
+  gtk_widget_queue_resize (widget);
+
+  return TRUE;
+}
+
+static gboolean
+gtk_scrolled_window_unset_clear_area (GtkWidget *widget,
+                                      gboolean   snap_back,
+                                      gpointer   user_data)
+{
+  GtkScrolledWindowPrivate *priv;
+
+  priv = GTK_SCROLLED_WINDOW (widget)->priv;
+
+  if (priv->clear_area_dy != 0 || priv->focus_area_dy != 0)
+    {
+      priv->clear_area_dy = 0;
+      priv->focus_area_dy = 0;
+
+      if (snap_back)
+        {
+          GtkAdjustment *adjustment;
+
+          adjustment = gtk_range_get_adjustment (GTK_RANGE (priv->vscrollbar));
+          _gtk_scrolled_window_set_adjustment_value (GTK_SCROLLED_WINDOW (widget),
+                                                     adjustment, priv->unclamped_vadj_value,
+                                                     FALSE, FALSE);
+          gtk_widget_queue_resize (widget);
+        }
+
+      return TRUE;
+    }
+
+  return FALSE;
+}
+
 /**
  * gtk_scrolled_window_get_min_content_width:
  * @scrolled_window: a #GtkScrolledWindow

gtk/gtkwidget.c

@@ -482 +482 @@
   DRAG_FAILED,
   STYLE_UPDATED,
   TOUCH_EVENT,
+  REQUEST_CLEAR_AREA,
+  UNSET_CLEAR_AREA,
   LAST_SIGNAL
 };
 
@@ -3116 +3118 @@
                   _gtk_marshal_BOOLEAN__UINT,
                   G_TYPE_BOOLEAN, 1, G_TYPE_UINT);
 
+  widget_signals[REQUEST_CLEAR_AREA] =
+    g_signal_new (I_("request-clear-area"),
+                  G_TYPE_FROM_CLASS (klass),
+                  G_SIGNAL_RUN_LAST, 0,
+                  g_signal_accumulator_true_handled, NULL,
+                  _gtk_marshal_BOOLEAN__BOXED_BOXED,
+                  G_TYPE_BOOLEAN, 2,
+                  CAIRO_GOBJECT_TYPE_RECTANGLE_INT,
+                  CAIRO_GOBJECT_TYPE_RECTANGLE_INT);
+  widget_signals[UNSET_CLEAR_AREA] =
+    g_signal_new (I_("unset-clear-area"),
+                  G_TYPE_FROM_CLASS (klass),
+                  G_SIGNAL_RUN_LAST, 0,
+                  g_signal_accumulator_true_handled, NULL,
+                  _gtk_marshal_BOOLEAN__BOOLEAN,
+                  G_TYPE_BOOLEAN, 1, G_TYPE_BOOLEAN);
+
   binding_set = gtk_binding_set_by_class (klass);
   gtk_binding_entry_add_signal (binding_set, GDK_KEY_F10, GDK_SHIFT_MASK,
                                 "popup-menu", 0);
@@ -14144 +14163 @@
   else
     g_action_muxer_remove (muxer, name);
 }
+
+gboolean
+gtk_widget_request_clear_area (GtkWidget             *widget,
+                               cairo_rectangle_int_t *clear_area,
+                               cairo_rectangle_int_t *cursor_position)
+{
+  gboolean handled = FALSE;
+  GtkWidget *cur;
+
+  g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
+  g_return_val_if_fail (cursor_position != NULL, FALSE);
+  g_return_val_if_fail (clear_area != NULL, FALSE);
+
+  if (!gtk_widget_has_focus (widget))
+    return FALSE;
+
+  if (cursor_position->x <= clear_area->x - cursor_position->width ||
+      cursor_position->x >= clear_area->x + clear_area->width ||
+      cursor_position->y <= clear_area->y - cursor_position->height ||
+      cursor_position->y >= clear_area->y + clear_area->height)
+    return FALSE;
+
+  cur = widget;
+
+  while (!handled && cur)
+    {
+      g_signal_emit (cur, widget_signals[REQUEST_CLEAR_AREA], 0,
+                     clear_area, cursor_position, &handled);
+
+      if (!handled)
+        cur = gtk_widget_get_parent (cur);
+    }
+
+  return handled;
+}
+
+gboolean
+gtk_widget_unset_clear_area (GtkWidget *widget,
+                             gboolean   snap_back)
+{
+  gboolean handled = FALSE;
+  GtkWidget *cur;
+
+  cur = widget;
+
+  while (!handled && cur)
+    {
+      g_signal_emit (cur, widget_signals[UNSET_CLEAR_AREA], 0,
+                     snap_back, &handled);
+
+      if (!handled)
+        cur = gtk_widget_get_parent (cur);
+    }
+
+  return handled;
+}

gtk/gtkwidget.h

@@ -887 +887 @@
 GdkModifierType   gtk_widget_get_modifier_mask (GtkWidget         *widget,
                                                 GdkModifierIntent  intent);
 
+gboolean gtk_widget_request_clear_area (GtkWidget             *widget,
+                                        cairo_rectangle_int_t *clear_area,
+                                        cairo_rectangle_int_t *cursor_position);
+gboolean gtk_widget_unset_clear_area   (GtkWidget             *widget,
+                                        gboolean               snap_back);
+
 GDK_AVAILABLE_IN_3_6
 void                    gtk_widget_insert_action_group                  (GtkWidget    *widget,
                                                                          const gchar  *name,