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

gtk/gtkimcontext.c

@@ -105 +105 @@
   COMMIT,
   RETRIEVE_SURROUNDING,
   DELETE_SURROUNDING,
+  CLEAR_AREA,
   LAST_SIGNAL
 };
 
@@ -121 +122 @@
 struct _GtkIMContextPrivate {
   GtkInputPurpose purpose;
   GtkInputHints hints;
+  GtkWidget *widget;
+
+  cairo_rectangle_int_t clear_area;
+  cairo_rectangle_int_t cursor_rect;
+  guint clear_area_signal_id;
+  guint clear_area_idle_id;
+  guint focused : 1;
+  guint need_position_update : 1;
 };
 
 static void     gtk_im_context_real_get_preedit_string (GtkIMContext   *context,
@@ -145 +154 @@
                                                         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 +223 @@
 
   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 +338 @@
                   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 +458 @@
   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->need_position_update = FALSE;
+      gtk_widget_unset_clear_area (priv->widget, TRUE);
+
+      if (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 (gtk_widget_get_window (priv->widget),
+                                      rect.x, rect.y, &rect.x, &rect.y);
+
+          gtk_widget_request_clear_area (priv->widget, &priv->clear_area, &rect);
+        }
+    }
+
+  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->focused)
+    return;
+
+  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->focused)
+    {
+      priv->need_position_update = TRUE;
+      return;
+    }
+
+  priv->clear_area = *clear_area;
+
+  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->clear_area = *clear_area;
+      priv->need_position_update = TRUE;
+    }
+}
+
 /**
  * gtk_im_context_set_client_window:
  * @context: a #GtkIMContext
@@ -454 +554 @@
                                   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->widget = window_data;
+        }
+    }
 }
 
 /**
@@ -531 +655 @@
 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);
+  priv->focused = TRUE;
 }
 
 /**
@@ -552 +680 @@
 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);
+
+  priv->focused = FALSE;
 }
 
 /**
@@ -575 +711 @@
   
   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 +733 @@
                                     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);
@@ -798 +949 @@
       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;
 };
 
 typedef struct
@@ -287 +288 @@
                                                                 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 +606 @@
   gtk_scrolled_window_update_real_placement (scrolled_window);
   priv->min_content_width = -1;
   priv->min_content_height = -1;
+  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);
 }
 
 /**
@@ -2249 +2266 @@
     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,
+                                             FALSE, FALSE);
 }
 
 static gboolean
@@ -2361 +2382 @@
   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;
+    {
+      upper += priv->clear_area_dy;
+      prev_value = &priv->unclamped_vadj_value;
+    }
   else
     return FALSE;
 
@@ -2379 +2403 @@
       upper += MAX_OVERSHOOT_DISTANCE;
     }
 
-  *prev_value = CLAMP (value, lower, upper);
   gtk_adjustment_set_value (adjustment, value);
+  *prev_value = CLAMP (value, lower, upper);
 
   return (*prev_value != value);
 }
@@ -3500 +3524 @@
     }
 }
 
+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;
+
+  priv = GTK_SCROLLED_WINDOW (widget)->priv;
+  adjustment = gtk_range_get_adjustment (GTK_RANGE (priv->vscrollbar));
+
+  priv->clear_area_dy = cursor_area->y + cursor_area->height - clear_area->y;
+  priv->unclamped_vadj_value += priv->clear_area_dy;
+  _gtk_scrolled_window_set_adjustment_value (GTK_SCROLLED_WINDOW (widget),
+                                             adjustment, priv->unclamped_vadj_value,
+                                             FALSE, 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->unclamped_vadj_value -= priv->clear_area_dy;
+      priv->clear_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 (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,