[gimp/gtk3-port: 110/235] app: port GimpSpinScale to GTK+ 3.0

[Michael Natterer <mitch src gnome org>]

commit 9dc4524c3ee215f1919e1d190fbfbb2d74e941cf
Author: Michael Natterer <mitch gimp org>
Date:   Fri Nov 19 15:23:21 2010 +0100

    app: port GimpSpinScale to GTK+ 3.0

 app/widgets/gimpspinscale.c |  253 ++++++++++++++++++++++++++-----------------
 1 files changed, 153 insertions(+), 100 deletions(-)
---
diff --git a/app/widgets/gimpspinscale.c b/app/widgets/gimpspinscale.c
index 6a19b27..9534117 100644
--- a/app/widgets/gimpspinscale.c
+++ b/app/widgets/gimpspinscale.c
@@ -41,7 +41,8 @@ typedef enum
 {
   TARGET_NUMBER,
   TARGET_UPPER,
-  TARGET_LOWER
+  TARGET_LOWER,
+  TARGET_NONE
 } SpinScaleTarget;
 
 
@@ -80,8 +81,8 @@ static void       gimp_spin_scale_get_property   (GObject          *object,
 
 static void       gimp_spin_scale_style_set      (GtkWidget        *widget,
                                                   GtkStyle         *prev_style);
-static gboolean   gimp_spin_scale_expose         (GtkWidget        *widget,
-                                                  GdkEventExpose   *event);
+static gboolean   gimp_spin_scale_draw           (GtkWidget        *widget,
+                                                  cairo_t          *cr);
 static gboolean   gimp_spin_scale_button_press   (GtkWidget        *widget,
                                                   GdkEventButton   *event);
 static gboolean   gimp_spin_scale_button_release (GtkWidget        *widget,
@@ -112,7 +113,7 @@ gimp_spin_scale_class_init (GimpSpinScaleClass *klass)
   object_class->get_property         = gimp_spin_scale_get_property;
 
   widget_class->style_set            = gimp_spin_scale_style_set;
-  widget_class->expose_event         = gimp_spin_scale_expose;
+  widget_class->draw                 = gimp_spin_scale_draw;
   widget_class->button_press_event   = gimp_spin_scale_button_press;
   widget_class->button_release_event = gimp_spin_scale_button_release;
   widget_class->motion_notify_event  = gimp_spin_scale_motion_notify;
@@ -241,65 +242,31 @@ gimp_spin_scale_style_set (GtkWidget *widget,
 }
 
 static gboolean
-gimp_spin_scale_expose (GtkWidget      *widget,
-                        GdkEventExpose *event)
+gimp_spin_scale_draw (GtkWidget *widget,
+                      cairo_t   *cr)
 {
   GimpSpinScalePrivate *private = GET_PRIVATE (widget);
   GtkStyle             *style   = gtk_widget_get_style (widget);
-  cairo_t              *cr;
+  GtkAllocation         allocation;
   gboolean              rtl;
-  gint                  w, h;
 
-  GTK_WIDGET_CLASS (parent_class)->expose_event (widget, event);
-
-  cr = gdk_cairo_create (event->window);
-  gdk_cairo_region (cr, event->region);
-  cairo_clip (cr);
+  cairo_save (cr);
+  GTK_WIDGET_CLASS (parent_class)->draw (widget, cr);
+  cairo_restore (cr);
 
   rtl = (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL);
 
-  w = gdk_window_get_width (event->window);
-  h = gdk_window_get_height (event->window);
+  gtk_widget_get_allocation (widget, &allocation);
 
   cairo_set_line_width (cr, 1.0);
 
-  if (event->window == gtk_entry_get_text_window (GTK_ENTRY (widget)))
-    {
-      /* let spinbutton-side line of rectangle disappear */
-      if (rtl)
-        cairo_rectangle (cr, -0.5, 0.5, w, h - 1.0);
-      else
-        cairo_rectangle (cr, 0.5, 0.5, w, h - 1.0);
-
-      gdk_cairo_set_source_color (cr,
-                                  &style->text[gtk_widget_get_state (widget)]);
-      cairo_stroke (cr);
-    }
-  else
-    {
-      /* let text-box-side line of rectangle disappear */
-      if (rtl)
-        cairo_rectangle (cr, 0.5, 0.5, w, h - 1.0);
-      else
-        cairo_rectangle (cr, -0.5, 0.5, w, h - 1.0);
-
-      gdk_cairo_set_source_color (cr,
-                                  &style->text[gtk_widget_get_state (widget)]);
-      cairo_stroke (cr);
-
-      if (rtl)
-        cairo_rectangle (cr, 1.5, 1.5, w - 2.0, h - 3.0);
-      else
-        cairo_rectangle (cr, 0.5, 1.5, w - 2.0, h - 3.0);
+  cairo_rectangle (cr, 0.5, 0.5,
+                   allocation.width - 1.0, allocation.height - 1.0);
+  gdk_cairo_set_source_color (cr,
+                              &style->text[gtk_widget_get_state (widget)]);
+  cairo_stroke (cr);
 
-      gdk_cairo_set_source_color (cr,
-                                  &style->base[gtk_widget_get_state (widget)]);
-      cairo_stroke (cr);
-    }
-
-  if (private->label &&
-      gtk_widget_is_drawable (widget) &&
-      event->window == gtk_entry_get_text_window (GTK_ENTRY (widget)))
+  if (private->label)
     {
       const GtkBorder *border;
       gint             layout_width;
@@ -315,10 +282,10 @@ gimp_spin_scale_expose (GtkWidget      *widget,
       if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL)
         {
           if (border)
-            cairo_move_to (cr, w - layout_width - border->right,
+            cairo_move_to (cr, allocation.width - layout_width - border->right,
                            border->right /* sic! */);
           else
-            cairo_move_to (cr, w - layout_width - 2, 2);
+            cairo_move_to (cr, allocation.width - layout_width - 2, 2);
         }
       else
         {
@@ -334,33 +301,103 @@ gimp_spin_scale_expose (GtkWidget      *widget,
       pango_cairo_show_layout (cr, private->layout);
     }
 
-  cairo_destroy (cr);
-
   return FALSE;
 }
 
+/* Returns TRUE if a translation should be done */
+static gboolean
+gtk_widget_get_translation_to_window (GtkWidget *widget,
+                                      GdkWindow *window,
+                                      int       *x,
+                                      int       *y)
+{
+  GdkWindow *w, *widget_window;
+
+  if (!gtk_widget_get_has_window (widget))
+    {
+      GtkAllocation allocation;
+
+      gtk_widget_get_allocation (widget, &allocation);
+
+      *x = -allocation.x;
+      *y = -allocation.y;
+    }
+  else
+    {
+      *x = 0;
+      *y = 0;
+    }
+
+  widget_window = gtk_widget_get_window (widget);
+
+  for (w = window; w && w != widget_window; w = gdk_window_get_parent (w))
+    {
+      int wx, wy;
+      gdk_window_get_position (w, &wx, &wy);
+      *x += wx;
+      *y += wy;
+    }
+
+  if (w == NULL)
+    {
+      *x = 0;
+      *y = 0;
+      return FALSE;
+    }
+
+  return TRUE;
+}
+
+static void
+gimp_spin_scale_event_to_widget_coords (GtkWidget *widget,
+                                        GdkWindow *window,
+                                        gdouble    event_x,
+                                        gdouble    event_y,
+                                        gint      *widget_x,
+                                        gint      *widget_y)
+{
+  gint tx, ty;
+
+  if (gtk_widget_get_translation_to_window (widget, window, &tx, &ty))
+    {
+      event_x += tx;
+      event_y += ty;
+    }
+
+  *widget_x = event_x;
+  *widget_y = event_y;
+}
+
 static SpinScaleTarget
 gimp_spin_scale_get_target (GtkWidget *widget,
                             gdouble    x,
                             gdouble    y)
 {
-  GtkAllocation allocation;
-  gint          layout_x;
-  gint          layout_y;
+  GdkRectangle text_area;
 
-  gtk_widget_get_allocation (widget, &allocation);
-  gtk_entry_get_layout_offsets (GTK_ENTRY (widget), &layout_x, &layout_y);
+  gtk_entry_get_text_area (GTK_ENTRY (widget), &text_area);
 
-  if (x > layout_x && y > layout_y)
+  if (x >= text_area.x && x < text_area.width &&
+      y >= text_area.y && y < text_area.height)
     {
-      return TARGET_NUMBER;
-    }
-  else if (y > allocation.height / 2)
-    {
-      return TARGET_LOWER;
+      gint layout_x;
+      gint layout_y;
+
+      gtk_entry_get_layout_offsets (GTK_ENTRY (widget), &layout_x, &layout_y);
+
+      if (x > layout_x && y > layout_y)
+        {
+          return TARGET_NUMBER;
+        }
+      else if (y > text_area.height / 2)
+        {
+          return TARGET_LOWER;
+        }
+
+      return TARGET_UPPER;
     }
 
-  return TARGET_UPPER;
+  return TARGET_NONE;
 }
 
 static void
@@ -392,28 +429,27 @@ gimp_spin_scale_change_value (GtkWidget *widget,
   GimpSpinScalePrivate *private     = GET_PRIVATE (widget);
   GtkSpinButton        *spin_button = GTK_SPIN_BUTTON (widget);
   GtkAdjustment        *adjustment  = gtk_spin_button_get_adjustment (spin_button);
-  GdkWindow            *text_window = gtk_entry_get_text_window (GTK_ENTRY (widget));
+  GdkRectangle          text_area;
   gdouble               lower;
   gdouble               upper;
-  gint                  width;
   gdouble               value;
 
-  gimp_spin_scale_get_limits (GIMP_SPIN_SCALE (widget), &lower, &upper);
+  gtk_entry_get_text_area (GTK_ENTRY (widget), &text_area);
 
-  width = gdk_window_get_width (text_window);
+  gimp_spin_scale_get_limits (GIMP_SPIN_SCALE (widget), &lower, &upper);
 
   if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL)
-    x = width - x;
+    x = text_area.width - x;
 
   if (private->relative_change)
     {
       gdouble diff;
       gdouble step;
 
-      step = (upper - lower) / width / 10.0;
+      step = (upper - lower) / text_area.width / 10.0;
 
       if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL)
-        diff = x - (width - private->start_x);
+        diff = x - (text_area.width - private->start_x);
       else
         diff = x - private->start_x;
 
@@ -423,7 +459,7 @@ gimp_spin_scale_change_value (GtkWidget *widget,
     {
       gdouble fraction;
 
-      fraction = x / (gdouble) width;
+      fraction = x / (gdouble) text_area.width;
 
       value = fraction * (upper - lower) + lower;
     }
@@ -436,37 +472,39 @@ gimp_spin_scale_button_press (GtkWidget      *widget,
                               GdkEventButton *event)
 {
   GimpSpinScalePrivate *private = GET_PRIVATE (widget);
+  gint                  x, y;
 
   private->changing_value  = FALSE;
   private->relative_change = FALSE;
 
-  if (event->window == gtk_entry_get_text_window (GTK_ENTRY (widget)))
+  gimp_spin_scale_event_to_widget_coords (widget, event->window,
+                                          event->x, event->y,
+                                          &x, &y);
+
+  switch (gimp_spin_scale_get_target (widget, x, y))
     {
-      switch (gimp_spin_scale_get_target (widget, event->x, event->y))
-        {
-        case TARGET_UPPER:
-          private->changing_value = TRUE;
+    case TARGET_UPPER:
+      private->changing_value = TRUE;
 
-          gtk_widget_grab_focus (widget);
+      gtk_widget_grab_focus (widget);
 
-          gimp_spin_scale_change_value (widget, event->x);
+      gimp_spin_scale_change_value (widget, x);
 
-          return TRUE;
+      return TRUE;
 
-        case TARGET_LOWER:
-          private->changing_value = TRUE;
+    case TARGET_LOWER:
+      private->changing_value = TRUE;
 
-          gtk_widget_grab_focus (widget);
+      gtk_widget_grab_focus (widget);
 
-          private->relative_change = TRUE;
-          private->start_x = event->x;
-          private->start_value = gtk_adjustment_get_value (gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (widget)));
+      private->relative_change = TRUE;
+      private->start_x = x;
+      private->start_value = gtk_adjustment_get_value (gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (widget)));
 
-          return TRUE;
+      return TRUE;
 
-        default:
-          break;
-        }
+    default:
+      break;
     }
 
   return GTK_WIDGET_CLASS (parent_class)->button_press_event (widget, event);
@@ -477,12 +515,17 @@ gimp_spin_scale_button_release (GtkWidget      *widget,
                                 GdkEventButton *event)
 {
   GimpSpinScalePrivate *private = GET_PRIVATE (widget);
+  gint                  x, y;
+
+  gimp_spin_scale_event_to_widget_coords (widget, event->window,
+                                          event->x, event->y,
+                                          &x, &y);
 
   if (private->changing_value)
     {
       private->changing_value = FALSE;
 
-      gimp_spin_scale_change_value (widget, event->x);
+      gimp_spin_scale_change_value (widget, x);
 
       return TRUE;
     }
@@ -495,10 +538,15 @@ gimp_spin_scale_motion_notify (GtkWidget      *widget,
                                GdkEventMotion *event)
 {
   GimpSpinScalePrivate *private = GET_PRIVATE (widget);
+  gint                  x, y;
+
+  gimp_spin_scale_event_to_widget_coords (widget, event->window,
+                                          event->x, event->y,
+                                          &x, &y);
 
   if (private->changing_value)
     {
-      gimp_spin_scale_change_value (widget, event->x);
+      gimp_spin_scale_change_value (widget, x);
 
       return TRUE;
     }
@@ -506,13 +554,12 @@ gimp_spin_scale_motion_notify (GtkWidget      *widget,
   GTK_WIDGET_CLASS (parent_class)->motion_notify_event (widget, event);
 
   if (! (event->state &
-         (GDK_BUTTON1_MASK | GDK_BUTTON2_MASK | GDK_BUTTON3_MASK)) &&
-      event->window == gtk_entry_get_text_window (GTK_ENTRY (widget)))
+         (GDK_BUTTON1_MASK | GDK_BUTTON2_MASK | GDK_BUTTON3_MASK)))
     {
       GdkDisplay *display = gtk_widget_get_display (widget);
       GdkCursor  *cursor  = NULL;
 
-      switch (gimp_spin_scale_get_target (widget, event->x, event->y))
+      switch (gimp_spin_scale_get_target (widget, x, y))
         {
         case TARGET_NUMBER:
           cursor = gdk_cursor_new_for_display (display, GDK_XTERM);
@@ -525,10 +572,16 @@ gimp_spin_scale_motion_notify (GtkWidget      *widget,
         case TARGET_LOWER:
           cursor = gdk_cursor_new_for_display (display, GDK_SB_H_DOUBLE_ARROW);
           break;
+
+        default:
+          break;
         }
 
-      gdk_window_set_cursor (event->window, cursor);
-      gdk_cursor_unref (cursor);
+      if (cursor)
+        {
+          gdk_window_set_cursor (event->window, cursor);
+          g_object_unref (cursor);
+        }
     }
 
   return FALSE;