X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;ds=inline;f=lib%2Fgtksheet%2Fgtksheet.c;h=fd60dbd186f2f1fdfff4298cb504c0fbb94e7dfc;hb=c29e05c50e21d5be8365ffdd990d558b95725d71;hp=fbd63046baa248c9b9c5d90cf0265fff555faa0b;hpb=e3ed16d6f22eb58d277af46b3c77993920faa0dc;p=pspp-builds.git

diff --git a/lib/gtksheet/gtksheet.c b/lib/gtksheet/gtksheet.c
index fbd63046..fd60dbd1 100644
--- a/lib/gtksheet/gtksheet.c
+++ b/lib/gtksheet/gtksheet.c
@@ -53,7 +53,7 @@
 #include <gtk/gtkcontainer.h>
 #include <pango/pango.h>
 #include "gtksheet.h"
-#include "gtkextra-marshal.h"
+#include <gtksheet/psppire-marshal.h>
 #include "gsheetmodel.h"
 #include <libpspp/misc.h>
 #include <math.h>
@@ -86,14 +86,16 @@ enum
 #define DEFAULT_COLUMN_WIDTH 80
 #define DEFAULT_ROW_HEIGHT 25
 
+static void set_entry_widget_font (GtkSheet *sheet);
+
 static void gtk_sheet_update_primary_selection (GtkSheet *sheet);
 static void draw_column_title_buttons_range (GtkSheet *sheet, gint first, gint n);
 static void draw_row_title_buttons_range (GtkSheet *sheet, gint first, gint n);
 
 
-static void gtk_sheet_set_row_height (GtkSheet *sheet,
-				      gint row,
-				      guint height);
+static void set_row_height (GtkSheet *sheet,
+			    gint row,
+			    gint height);
 
 static void destroy_hover_window (GtkSheetHoverTitle *);
 static GtkSheetHoverTitle *create_hover_window (void);
@@ -120,13 +122,13 @@ dispose_string (const GtkSheet *sheet, gchar *text)
 static inline gint
 column_from_xpixel (const GtkSheet *sheet, gint pixel)
 {
-  return psppire_axis_get_unit_at_pixel (sheet->haxis, pixel);
+  return psppire_axis_unit_at_pixel (sheet->haxis, pixel);
 }
 
 static inline gint
 row_from_ypixel (const GtkSheet *sheet, gint pixel)
 {
-  return psppire_axis_get_unit_at_pixel (sheet->vaxis, pixel);
+  return psppire_axis_unit_at_pixel (sheet->vaxis, pixel);
 }
 
 
@@ -143,7 +145,7 @@ min_fully_visible_row (const GtkSheet *sheet)
 {
   glong row = min_visible_row (sheet);
 
-  if ( psppire_axis_pixel_start (sheet->vaxis, row) < sheet->vadjustment->value)
+  if ( psppire_axis_start_pixel (sheet->vaxis, row) < sheet->vadjustment->value)
     row++;
 
   return row;
@@ -152,9 +154,7 @@ min_fully_visible_row (const GtkSheet *sheet)
 static inline glong
 max_visible_row (const GtkSheet *sheet)
 {
-  return row_from_ypixel (sheet,
-			  sheet->vadjustment->value +
-			  sheet->vadjustment->page_size);
+  return row_from_ypixel (sheet, sheet->vadjustment->value + sheet->vadjustment->page_size);
 }
 
 
@@ -163,7 +163,7 @@ max_fully_visible_row (const GtkSheet *sheet)
 {
   glong row = max_visible_row (sheet);
 
-  if ( psppire_axis_pixel_start (sheet->vaxis, row)
+  if ( psppire_axis_start_pixel (sheet->vaxis, row)
        +
        psppire_axis_unit_size (sheet->vaxis, row)
        > sheet->vadjustment->value)
@@ -186,7 +186,7 @@ min_fully_visible_column (const GtkSheet *sheet)
 {
   glong col = min_visible_column (sheet);
 
-  if ( psppire_axis_pixel_start (sheet->haxis, col) < sheet->hadjustment->value)
+  if ( psppire_axis_start_pixel (sheet->haxis, col) < sheet->hadjustment->value)
     col++;
 
   return col;
@@ -198,9 +198,7 @@ min_fully_visible_column (const GtkSheet *sheet)
 static inline glong
 max_visible_column (const GtkSheet *sheet)
 {
-  return column_from_xpixel (sheet,
-			     sheet->hadjustment->value +
-			     sheet->hadjustment->page_size);
+  return column_from_xpixel (sheet, sheet->hadjustment->value + sheet->hadjustment->page_size);
 }
 
 static inline glong
@@ -208,8 +206,8 @@ max_fully_visible_column (const GtkSheet *sheet)
 {
   glong col = max_visible_column (sheet);
 
-  if ( psppire_axis_pixel_start (sheet->haxis, col)
-       + 
+  if ( psppire_axis_start_pixel (sheet->haxis, col)
+       +
        psppire_axis_unit_size (sheet->haxis, col)
        > sheet->hadjustment->value)
     col--;
@@ -247,6 +245,31 @@ on_column_boundary (const GtkSheet *sheet, gint x, gint *column)
   return FALSE;
 }
 
+static gboolean
+on_row_boundary (const GtkSheet *sheet, gint y, gint *row)
+{
+  gint r;
+
+  y += sheet->vadjustment->value;
+
+  r = row_from_ypixel (sheet, y);
+
+  if ( row_from_ypixel (sheet, y - DRAG_WIDTH / 2) < r )
+    {
+      *row = r - 1;
+      return TRUE;
+    }
+
+  if  ( row_from_ypixel (sheet, y + DRAG_WIDTH / 2) > r )
+    {
+      *row = r;
+      return TRUE;
+    }
+
+  return FALSE;
+}
+
+
 static inline gboolean
 POSSIBLE_DRAG (const GtkSheet *sheet, gint x, gint y,
 	       gint *drag_row, gint *drag_column)
@@ -261,17 +284,17 @@ POSSIBLE_DRAG (const GtkSheet *sheet, gint x, gint y,
   *drag_column = column_from_xpixel (sheet, x);
   *drag_row = row_from_ypixel (sheet, y);
 
-  if (x >= psppire_axis_pixel_start (sheet->haxis, sheet->range.col0) - DRAG_WIDTH / 2 &&
-      x <= psppire_axis_pixel_start (sheet->haxis, sheet->range.coli) +
+  if (x >= psppire_axis_start_pixel (sheet->haxis, sheet->range.col0) - DRAG_WIDTH / 2 &&
+      x <= psppire_axis_start_pixel (sheet->haxis, sheet->range.coli) +
       psppire_axis_unit_size (sheet->haxis, sheet->range.coli) + DRAG_WIDTH / 2)
     {
-      ydrag = psppire_axis_pixel_start (sheet->vaxis, sheet->range.row0);
+      ydrag = psppire_axis_start_pixel (sheet->vaxis, sheet->range.row0);
       if (y >= ydrag - DRAG_WIDTH / 2 && y <= ydrag + DRAG_WIDTH / 2)
 	{
 	  *drag_row = sheet->range.row0;
 	  return TRUE;
 	}
-      ydrag = psppire_axis_pixel_start (sheet->vaxis, sheet->range.rowi) +
+      ydrag = psppire_axis_start_pixel (sheet->vaxis, sheet->range.rowi) +
 	psppire_axis_unit_size (sheet->vaxis, sheet->range.rowi);
       if (y >= ydrag - DRAG_WIDTH / 2 && y <= ydrag + DRAG_WIDTH / 2)
 	{
@@ -280,17 +303,17 @@ POSSIBLE_DRAG (const GtkSheet *sheet, gint x, gint y,
 	}
     }
 
-  if (y >= psppire_axis_pixel_start (sheet->vaxis, sheet->range.row0) - DRAG_WIDTH / 2 &&
-      y <= psppire_axis_pixel_start (sheet->vaxis, sheet->range.rowi) +
+  if (y >= psppire_axis_start_pixel (sheet->vaxis, sheet->range.row0) - DRAG_WIDTH / 2 &&
+      y <= psppire_axis_start_pixel (sheet->vaxis, sheet->range.rowi) +
       psppire_axis_unit_size (sheet->vaxis, sheet->range.rowi) + DRAG_WIDTH / 2)
     {
-      xdrag = psppire_axis_pixel_start (sheet->haxis, sheet->range.col0);
+      xdrag = psppire_axis_start_pixel (sheet->haxis, sheet->range.col0);
       if (x >= xdrag - DRAG_WIDTH / 2 && x <= xdrag + DRAG_WIDTH / 2)
 	{
 	  *drag_column = sheet->range.col0;
 	  return TRUE;
 	}
-      xdrag = psppire_axis_pixel_start (sheet->haxis, sheet->range.coli) +
+      xdrag = psppire_axis_start_pixel (sheet->haxis, sheet->range.coli) +
 	psppire_axis_unit_size (sheet->haxis, sheet->range.coli);
       if (x >= xdrag - DRAG_WIDTH / 2 && x <= xdrag + DRAG_WIDTH / 2)
 	{
@@ -313,17 +336,17 @@ POSSIBLE_RESIZE (const GtkSheet *sheet, gint x, gint y,
        sheet->range.col0 < 0 || sheet->range.coli < 0 )
     return FALSE;
 
-  xdrag = psppire_axis_pixel_start (sheet->haxis, sheet->range.coli)+
+  xdrag = psppire_axis_start_pixel (sheet->haxis, sheet->range.coli)+
     psppire_axis_unit_size (sheet->haxis, sheet->range.coli);
 
-  ydrag = psppire_axis_pixel_start (sheet->vaxis, sheet->range.rowi) +
+  ydrag = psppire_axis_start_pixel (sheet->vaxis, sheet->range.rowi) +
     psppire_axis_unit_size (sheet->vaxis, sheet->range.rowi);
 
   if (sheet->state == GTK_SHEET_COLUMN_SELECTED)
-    ydrag = psppire_axis_pixel_start (sheet->vaxis, min_visible_row (sheet));
+    ydrag = psppire_axis_start_pixel (sheet->vaxis, min_visible_row (sheet));
 
   if (sheet->state == GTK_SHEET_ROW_SELECTED)
-    xdrag = psppire_axis_pixel_start (sheet->haxis, min_visible_column (sheet));
+    xdrag = psppire_axis_start_pixel (sheet->haxis, min_visible_column (sheet));
 
   *drag_column = column_from_xpixel (sheet, x);
   *drag_row = row_from_ypixel (sheet, y);
@@ -341,25 +364,25 @@ rectangle_from_range (GtkSheet *sheet, const GtkSheetRange *range,
 {
   g_return_val_if_fail (range, FALSE);
 
-  r->x = psppire_axis_pixel_start (sheet->haxis, range->col0);
+  r->x = psppire_axis_start_pixel (sheet->haxis, range->col0);
   r->x -= round (sheet->hadjustment->value);
 
   if ( sheet->row_titles_visible)
     r->x += sheet->row_title_area.width;
 
 
-  r->y = psppire_axis_pixel_start (sheet->vaxis, range->row0);
+  r->y = psppire_axis_start_pixel (sheet->vaxis, range->row0);
   r->y -= round (sheet->vadjustment->value);
 
   if ( sheet->column_titles_visible)
     r->y += sheet->column_title_area.height;
 
-  r->width = psppire_axis_pixel_start (sheet->haxis, range->coli) -
-    psppire_axis_pixel_start (sheet->haxis, range->col0) +
+  r->width = psppire_axis_start_pixel (sheet->haxis, range->coli) -
+    psppire_axis_start_pixel (sheet->haxis, range->col0) +
     psppire_axis_unit_size (sheet->haxis, range->coli);
 
-  r->height = psppire_axis_pixel_start (sheet->vaxis, range->rowi) -
-    psppire_axis_pixel_start (sheet->vaxis, range->row0) +
+  r->height = psppire_axis_start_pixel (sheet->vaxis, range->rowi) -
+    psppire_axis_start_pixel (sheet->vaxis, range->row0) +
     psppire_axis_unit_size (sheet->vaxis, range->rowi);
 
   return TRUE;
@@ -392,6 +415,7 @@ static void gtk_sheet_map 			 (GtkWidget *widget);
 static void gtk_sheet_unmap 			 (GtkWidget *widget);
 static gint gtk_sheet_expose 			 (GtkWidget *widget,
 						  GdkEventExpose *event);
+
 static void gtk_sheet_forall 			 (GtkContainer *container,
 						  gboolean include_internals,
 						  GtkCallback callback,
@@ -421,7 +445,7 @@ static void gtk_sheet_size_allocate 		 (GtkWidget *widget,
 /* Sheet queries */
 
 static gboolean gtk_sheet_range_isvisible (const GtkSheet *sheet,
-					   GtkSheetRange range);
+					   const GtkSheetRange *range);
 static gboolean gtk_sheet_cell_isvisible  (GtkSheet *sheet,
 					   gint row, gint column);
 /* Drawing Routines */
@@ -430,9 +454,9 @@ static gboolean gtk_sheet_cell_isvisible  (GtkSheet *sheet,
 static void gtk_sheet_cell_draw (GtkSheet *sheet, gint row, gint column);
 
 
-/* draw visible part of range. If range == NULL then draw the whole screen */
-static void gtk_sheet_range_draw (GtkSheet *sheet,
-				  const GtkSheetRange *range);
+/* draw visible part of range. */
+static void draw_sheet_region (GtkSheet *sheet, GdkRegion *region);
+
 
 /* highlight the visible part of the selected range */
 static void gtk_sheet_range_draw_selection	 (GtkSheet *sheet,
@@ -455,11 +479,11 @@ static void gtk_sheet_draw_border 		 (GtkSheet *sheet,
 
 static void gtk_sheet_entry_changed		 (GtkWidget *widget,
 						  gpointer data);
-static void gtk_sheet_hide_active_cell		 (GtkSheet *sheet);
+static void gtk_sheet_hide_entry_widget		 (GtkSheet *sheet);
 static void change_active_cell		 (GtkSheet *sheet,
 					  gint row, gint col);
-static void gtk_sheet_draw_active_cell		 (GtkSheet *sheet);
-static void gtk_sheet_show_active_cell		 (GtkSheet *sheet);
+static gboolean gtk_sheet_draw_active_cell		 (GtkSheet *sheet);
+static void gtk_sheet_show_entry_widget		 (GtkSheet *sheet);
 static gboolean gtk_sheet_click_cell		 (GtkSheet *sheet,
 						  gint row,
 						  gint column);
@@ -479,12 +503,6 @@ static void draw_xor_hline 			 (GtkSheet *sheet);
 static void draw_xor_rectangle			 (GtkSheet *sheet,
 						  GtkSheetRange range);
 
-static guint new_column_width 			 (GtkSheet *sheet,
-						  gint column,
-						  gint *x);
-static guint new_row_height 			 (GtkSheet *sheet,
-						  gint row,
-						  gint *y);
 /* Sheet Button */
 
 static void create_global_button		 (GtkSheet *sheet);
@@ -511,9 +529,6 @@ static void gtk_sheet_real_cell_clear 		 (GtkSheet *sheet,
 						  gint column);
 
 
-static void gtk_sheet_column_size_request (GtkSheet *sheet,
-					   gint col,
-					   guint *requisition);
 static void gtk_sheet_row_size_request (GtkSheet *sheet,
 					gint row,
 					guint *requisition);
@@ -836,7 +851,7 @@ gtk_sheet_class_init (GtkSheetClass *klass)
 		  G_SIGNAL_RUN_LAST,
 		  0,
 		  NULL, NULL,
-		  gtkextra_VOID__INT_POINTER,
+		  psppire_marshal_VOID__INT_POINTER,
 		  G_TYPE_NONE,
 		  2,
 		  G_TYPE_INT,
@@ -857,7 +872,7 @@ gtk_sheet_class_init (GtkSheetClass *klass)
 		  G_SIGNAL_RUN_LAST,
 		  0,
 		  NULL, NULL,
-		  gtkextra_VOID__INT_POINTER,
+		  psppire_marshal_VOID__INT_POINTER,
 		  G_TYPE_NONE,
 		  2,
 		  G_TYPE_INT,
@@ -883,7 +898,7 @@ gtk_sheet_class_init (GtkSheetClass *klass)
 		  G_SIGNAL_RUN_LAST,
 		  offsetof (GtkSheetClass, resize_range),
 		  NULL, NULL,
-		  gtkextra_VOID__BOXED_BOXED,
+		  psppire_marshal_VOID__BOXED_BOXED,
 		  G_TYPE_NONE,
 		  2,
 		  GTK_TYPE_SHEET_RANGE, GTK_TYPE_SHEET_RANGE
@@ -895,7 +910,7 @@ gtk_sheet_class_init (GtkSheetClass *klass)
 		  G_SIGNAL_RUN_LAST,
 		  offsetof (GtkSheetClass, move_range),
 		  NULL, NULL,
-		  gtkextra_VOID__BOXED_BOXED,
+		  psppire_marshal_VOID__BOXED_BOXED,
 		  G_TYPE_NONE,
 		  2,
 		  GTK_TYPE_SHEET_RANGE, GTK_TYPE_SHEET_RANGE
@@ -907,7 +922,7 @@ gtk_sheet_class_init (GtkSheetClass *klass)
 		  G_SIGNAL_RUN_LAST,
 		  offsetof (GtkSheetClass, traverse),
 		  NULL, NULL,
-		  gtkextra_BOOLEAN__BOXED_POINTER,
+		  psppire_marshal_BOOLEAN__BOXED_POINTER,
 		  G_TYPE_BOOLEAN, 2,
 		  GTK_TYPE_SHEET_CELL,
 		  G_TYPE_POINTER);
@@ -919,7 +934,7 @@ gtk_sheet_class_init (GtkSheetClass *klass)
 		  G_SIGNAL_RUN_LAST,
 		  offsetof (GtkSheetClass, activate),
 		  NULL, NULL,
-		  gtkextra_VOID__INT_INT_INT_INT,
+		  psppire_marshal_VOID__INT_INT_INT_INT,
 		  G_TYPE_NONE, 4,
 		  G_TYPE_INT, G_TYPE_INT,
 		  G_TYPE_INT, G_TYPE_INT);
@@ -930,7 +945,7 @@ gtk_sheet_class_init (GtkSheetClass *klass)
 		  G_SIGNAL_RUN_LAST,
 		  offsetof (GtkSheetClass, set_scroll_adjustments),
 		  NULL, NULL,
-		  gtkextra_VOID__OBJECT_OBJECT,
+		  psppire_marshal_VOID__OBJECT_OBJECT,
 		  G_TYPE_NONE, 2, GTK_TYPE_ADJUSTMENT, GTK_TYPE_ADJUSTMENT);
 
 
@@ -1046,8 +1061,6 @@ gtk_sheet_init (GtkSheet *sheet)
 
   sheet->sheet_window = NULL;
   sheet->entry_widget = NULL;
-  sheet->entry_container = NULL;
-  sheet->entry_handler_id = 0;
   sheet->button = NULL;
 
   sheet->hadjustment = NULL;
@@ -1064,9 +1077,6 @@ gtk_sheet_init (GtkSheet *sheet)
 
   sheet->motion_timer = 0;
 
-  sheet->columns_resizable = TRUE;
-  sheet->rows_resizable = TRUE;
-
   sheet->row_titles_visible = TRUE;
   sheet->row_title_area.width = DEFAULT_COLUMN_WIDTH;
 
@@ -1074,7 +1084,7 @@ gtk_sheet_init (GtkSheet *sheet)
 
 
   /* create sheet entry */
-  sheet->entry_type = 0;
+  sheet->entry_type = GTK_TYPE_ENTRY;
   create_sheet_entry (sheet);
 
   /* create global selection button */
@@ -1082,6 +1092,29 @@ gtk_sheet_init (GtkSheet *sheet)
 }
 
 
+/* Cause RANGE to be redrawn. If RANGE is null, then the
+   entire visible range will be redrawn.
+ */
+static void
+redraw_range (GtkSheet *sheet, GtkSheetRange *range)
+{
+  GdkRectangle rect;
+ 
+  if ( ! GTK_WIDGET_REALIZED (sheet))
+    return;
+
+  if ( NULL != range )
+    rectangle_from_range (sheet, range, &rect);
+  else
+    {
+      GdkRegion *r = gdk_drawable_get_visible_region (sheet->sheet_window);
+      gdk_region_get_clipbox (r, &rect);
+    }
+
+  gdk_window_invalidate_rect (sheet->sheet_window, &rect, FALSE);
+}
+
+
 /* Callback which occurs whenever columns are inserted / deleted in the model */
 static void
 columns_inserted_deleted_callback (GSheetModel *model, gint first_column,
@@ -1110,10 +1143,13 @@ columns_inserted_deleted_callback (GSheetModel *model, gint first_column,
   draw_column_title_buttons_range (sheet,
 				   first_column, max_visible_column (sheet));
 
-  gtk_sheet_range_draw (sheet, &range);
+
+  redraw_range (sheet, &range);
 }
 
 
+
+
 /* Callback which occurs whenever rows are inserted / deleted in the model */
 static void
 rows_inserted_deleted_callback (GSheetModel *model, gint first_row,
@@ -1140,7 +1176,7 @@ rows_inserted_deleted_callback (GSheetModel *model, gint first_row,
 
   draw_row_title_buttons_range (sheet, first_row, max_visible_row (sheet));
 
-  gtk_sheet_range_draw (sheet, &range);
+  redraw_range (sheet, &range);
 }
 
 /*
@@ -1163,16 +1199,9 @@ range_update_callback (GSheetModel *m, gint row0, gint col0,
   if ( !GTK_WIDGET_REALIZED (GTK_WIDGET (sheet)))
     return;
 
-  if ( max_visible_row (sheet) > g_sheet_model_get_row_count (sheet->model)
-       ||
-       max_visible_column (sheet) > g_sheet_model_get_column_count (sheet->model))
-    {
-      gtk_sheet_moveto (sheet, 0, 0, 0, 0);
-    }
-
   if ( ( row0 < 0 && col0 < 0 ) || ( rowi < 0 && coli < 0 ) )
     {
-      gtk_sheet_range_draw (sheet, NULL);
+      redraw_range (sheet, NULL);
       adjust_scrollbars (sheet);
 
       draw_row_title_buttons_range (sheet, min_visible_row (sheet),
@@ -1194,7 +1223,7 @@ range_update_callback (GSheetModel *m, gint row0, gint col0,
       range.coli = max_visible_column (sheet);
     }
 
-  gtk_sheet_range_draw (sheet, &range);
+  redraw_range (sheet, &range);
 }
 
 
@@ -1210,7 +1239,7 @@ range_update_callback (GSheetModel *m, gint row0, gint col0,
  * Returns: the new sheet widget
  */
 GtkWidget *
-gtk_sheet_new (void *vgeo, void *hgeo, GSheetModel *model)
+gtk_sheet_new (GSheetModel *model)
 {
   GtkWidget *widget = g_object_new (GTK_TYPE_SHEET,
 				    "model", model,
@@ -1269,7 +1298,7 @@ gtk_sheet_change_entry (GtkSheet *sheet, GtkType entry_type)
   state = sheet->state;
 
   if (sheet->state == GTK_SHEET_NORMAL)
-    gtk_sheet_hide_active_cell (sheet);
+    gtk_sheet_hide_entry_widget (sheet);
 
   sheet->entry_type = entry_type;
 
@@ -1277,7 +1306,7 @@ gtk_sheet_change_entry (GtkSheet *sheet, GtkType entry_type)
 
   if (state == GTK_SHEET_NORMAL)
     {
-      gtk_sheet_show_active_cell (sheet);
+      gtk_sheet_show_entry_widget (sheet);
     }
 
 }
@@ -1292,7 +1321,7 @@ gtk_sheet_show_grid (GtkSheet *sheet, gboolean show)
 
   sheet->show_grid = show;
 
-  gtk_sheet_range_draw (sheet, NULL);
+  redraw_range (sheet, NULL);
 }
 
 gboolean
@@ -1313,10 +1342,9 @@ gtk_sheet_get_columns_count (GtkSheet *sheet)
   return psppire_axis_unit_count (sheet->haxis);
 }
 
-static void
-gtk_sheet_set_column_width (GtkSheet *sheet,
-			    gint column,
-			    guint width);
+static void set_column_width (GtkSheet *sheet,
+			      gint column,
+			      gint width);
 
 
 void
@@ -1449,7 +1477,7 @@ gtk_sheet_moveto (GtkSheet *sheet,
 
   if (row >= 0)
   {
-    gint y =  psppire_axis_pixel_start (sheet->vaxis, row);
+    gint y =  psppire_axis_start_pixel (sheet->vaxis, row);
 
     gtk_adjustment_set_value (sheet->vadjustment, y - height * row_align);
   }
@@ -1457,33 +1485,13 @@ gtk_sheet_moveto (GtkSheet *sheet,
 
   if (col >= 0)
   {
-    gint x =  psppire_axis_pixel_start (sheet->haxis, col);
+    gint x =  psppire_axis_start_pixel (sheet->haxis, col);
 
     gtk_adjustment_set_value (sheet->hadjustment, x - width * col_align);
   }
 }
 
 
-static gboolean
-gtk_sheet_columns_resizable (GtkSheet *sheet)
-{
-  g_return_val_if_fail (sheet != NULL, FALSE);
-  g_return_val_if_fail (GTK_IS_SHEET (sheet), FALSE);
-
-  return sheet->columns_resizable;
-}
-
-
-static gboolean
-gtk_sheet_rows_resizable (GtkSheet *sheet)
-{
-  g_return_val_if_fail (sheet != NULL, FALSE);
-  g_return_val_if_fail (GTK_IS_SHEET (sheet), FALSE);
-
-  return sheet->rows_resizable;
-}
-
-
 void
 gtk_sheet_select_row (GtkSheet *sheet, gint row)
 {
@@ -1538,32 +1546,32 @@ gtk_sheet_select_column (GtkSheet *sheet, gint column)
 
 static gboolean
 gtk_sheet_range_isvisible (const GtkSheet *sheet,
-			   GtkSheetRange range)
+			   const GtkSheetRange *range)
 {
   g_return_val_if_fail (sheet != NULL, FALSE);
 
-  if (range.row0 < 0 || range.row0 >= psppire_axis_unit_count (sheet->vaxis))
+  if (range->row0 < 0 || range->row0 >= psppire_axis_unit_count (sheet->vaxis))
     return FALSE;
 
-  if (range.rowi < 0 || range.rowi >= psppire_axis_unit_count (sheet->vaxis))
+  if (range->rowi < 0 || range->rowi >= psppire_axis_unit_count (sheet->vaxis))
     return FALSE;
 
-  if (range.col0 < 0 || range.col0 >= psppire_axis_unit_count (sheet->haxis))
+  if (range->col0 < 0 || range->col0 >= psppire_axis_unit_count (sheet->haxis))
     return FALSE;
 
-  if (range.coli < 0 || range.coli >= psppire_axis_unit_count (sheet->haxis))
+  if (range->coli < 0 || range->coli >= psppire_axis_unit_count (sheet->haxis))
     return FALSE;
 
-  if (range.rowi < min_visible_row (sheet))
+  if (range->rowi < min_visible_row (sheet))
     return FALSE;
 
-  if (range.row0 > max_visible_row (sheet))
+  if (range->row0 > max_visible_row (sheet))
     return FALSE;
 
-  if (range.coli < min_visible_column (sheet))
+  if (range->coli < min_visible_column (sheet))
     return FALSE;
 
-  if (range.col0 > max_visible_column (sheet))
+  if (range->col0 > max_visible_column (sheet))
     return FALSE;
 
   return TRUE;
@@ -1580,7 +1588,7 @@ gtk_sheet_cell_isvisible (GtkSheet *sheet,
   range.rowi = row;
   range.coli = column;
 
-  return gtk_sheet_range_isvisible (sheet, range);
+  return gtk_sheet_range_isvisible (sheet, &range);
 }
 
 void
@@ -1658,9 +1666,6 @@ gtk_sheet_dispose  (GObject *object)
   if (sheet->vaxis) g_object_unref (sheet->vaxis);
   if (sheet->haxis) g_object_unref (sheet->haxis);
 
-  g_object_unref (sheet->entry_container);
-  sheet->entry_container = NULL;
-
   g_object_unref (sheet->button);
   sheet->button = NULL;
 
@@ -1711,8 +1716,11 @@ gtk_sheet_style_set (GtkWidget *widget,
       gtk_style_set_background (widget->style, widget->window, widget->state);
     }
 
+  set_entry_widget_font (sheet);
 }
 
+#define BORDER_WIDTH 3
+
 static void
 gtk_sheet_realize (GtkWidget *widget)
 {
@@ -1721,7 +1729,7 @@ gtk_sheet_realize (GtkWidget *widget)
   const gint attributes_mask =
     GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP | GDK_WA_CURSOR;
 
-  GdkGCValues values, auxvalues;
+  GdkGCValues values;
   GdkColormap *colormap;
   GdkDisplay *display;
 
@@ -1818,12 +1826,10 @@ gtk_sheet_realize (GtkWidget *widget)
   sheet->fg_gc = gdk_gc_new (widget->window);
   sheet->bg_gc = gdk_gc_new (widget->window);
 
-  gdk_gc_get_values (sheet->fg_gc, &auxvalues);
-
   values.foreground = widget->style->white;
   values.function = GDK_INVERT;
   values.subwindow_mode = GDK_INCLUDE_INFERIORS;
-  values.line_width = 3;
+  values.line_width = BORDER_WIDTH;
 
   sheet->xor_gc = gdk_gc_new_with_values (widget->window,
 					  &values,
@@ -1892,7 +1898,6 @@ static void
 global_button_clicked (GtkWidget *widget, gpointer data)
 {
   gtk_sheet_click_cell (GTK_SHEET (data), -1, -1);
-  gtk_widget_grab_focus (GTK_WIDGET (data));
 }
 
 
@@ -1976,7 +1981,7 @@ gtk_sheet_map (GtkWidget *widget)
 	    !GTK_WIDGET_MAPPED (GTK_BIN (sheet->button)->child))
 	  gtk_widget_map (GTK_BIN (sheet->button)->child);
 
-      gtk_sheet_range_draw (sheet, NULL);
+      redraw_range (sheet, NULL);
       change_active_cell (sheet,
 		     sheet->active_cell.row,
 		     sheet->active_cell.col);
@@ -2013,6 +2018,7 @@ gtk_sheet_cell_draw (GtkSheet *sheet, gint row, gint col)
 {
   PangoLayout *layout;
   PangoRectangle text;
+  PangoFontDescription *font_desc = GTK_WIDGET (sheet)->style->font_desc;
   gint font_height;
 
   gchar *label;
@@ -2062,15 +2068,16 @@ gtk_sheet_cell_draw (GtkSheet *sheet, gint row, gint col)
 
   layout = gtk_widget_create_pango_layout (GTK_WIDGET (sheet), label);
   dispose_string (sheet, label);
-  pango_layout_set_font_description (layout, attributes.font_desc);
 
 
+  pango_layout_set_font_description (layout, font_desc);
+
   pango_layout_get_pixel_extents (layout, NULL, &text);
 
   gdk_gc_set_clip_rectangle (sheet->fg_gc, &area);
 
-  font_height = pango_font_description_get_size (attributes.font_desc);
-  if ( !pango_font_description_get_size_is_absolute (attributes.font_desc))
+  font_height = pango_font_description_get_size (font_desc);
+  if ( !pango_font_description_get_size_is_absolute (font_desc))
     font_height /= PANGO_SCALE;
 
   /* Centre the text vertically */
@@ -2103,15 +2110,36 @@ gtk_sheet_cell_draw (GtkSheet *sheet, gint row, gint col)
 }
 
 
-
 static void
-gtk_sheet_range_draw (GtkSheet *sheet, const GtkSheetRange *range)
+draw_sheet_region (GtkSheet *sheet, GdkRegion *region)
 {
+  GtkSheetRange range;
+  GdkRectangle area;
+  gint y, x;
   gint i, j;
 
-  GdkRectangle area;
   GtkSheetRange drawing_range;
 
+  gdk_region_get_clipbox (region, &area);
+
+  y = area.y + sheet->vadjustment->value;
+  x = area.x + sheet->hadjustment->value;
+
+  if ( sheet->column_titles_visible)
+    y -= sheet->column_title_area.height;
+
+  if ( sheet->row_titles_visible)
+    x -= sheet->row_title_area.width;
+
+  maximize_int (&x, 0);
+  maximize_int (&y, 0);
+
+  range.row0 = row_from_ypixel (sheet, y);
+  range.rowi = row_from_ypixel (sheet, y + area.height);
+
+  range.col0 = column_from_xpixel (sheet, x);
+  range.coli = column_from_xpixel (sheet, x + area.width);
+
   g_return_if_fail (sheet != NULL);
   g_return_if_fail (GTK_SHEET (sheet));
 
@@ -2119,52 +2147,35 @@ gtk_sheet_range_draw (GtkSheet *sheet, const GtkSheetRange *range)
   if (!GTK_WIDGET_REALIZED (GTK_WIDGET (sheet))) return;
   if (!GTK_WIDGET_MAPPED (GTK_WIDGET (sheet))) return;
 
-  if (range == NULL)
-    {
-      drawing_range.row0 = min_visible_row (sheet);
-      drawing_range.col0 = min_visible_column (sheet);
-      drawing_range.rowi = MIN (max_visible_row (sheet),
-				psppire_axis_unit_count (sheet->vaxis) - 1);
-      drawing_range.coli = max_visible_column (sheet);
-      gdk_drawable_get_size (sheet->sheet_window, &area.width, &area.height);
-      area.x = area.y = 0;
-    }
-  else
-    {
-      drawing_range.row0 = MAX (range->row0, min_visible_row (sheet));
-      drawing_range.col0 = MAX (range->col0, min_visible_column (sheet));
-      drawing_range.rowi = MIN (range->rowi, max_visible_row (sheet));
-      drawing_range.coli = MIN (range->coli, max_visible_column (sheet));
 
+  drawing_range.row0 = MAX (range.row0, min_visible_row (sheet));
+  drawing_range.col0 = MAX (range.col0, min_visible_column (sheet));
+  drawing_range.rowi = MIN (range.rowi, max_visible_row (sheet));
+  drawing_range.coli = MIN (range.coli, max_visible_column (sheet));
 
-      rectangle_from_range (sheet, &drawing_range, &area);
-    }
-
-
-  gdk_draw_rectangle (sheet->sheet_window,
-		      GTK_WIDGET (sheet)->style->white_gc,
-		      TRUE,
-		      area.x, area.y,
-		      area.width, area.height);
+  g_return_if_fail (drawing_range.rowi >= drawing_range.row0);
+  g_return_if_fail (drawing_range.coli >= drawing_range.col0);
 
   for (i = drawing_range.row0; i <= drawing_range.rowi; i++)
-    for (j = drawing_range.col0; j <= drawing_range.coli; j++)
-      {
+    {
+      for (j = drawing_range.col0; j <= drawing_range.coli; j++)
 	gtk_sheet_cell_draw (sheet, i, j);
-      }
+    }
 
   if (sheet->state != GTK_SHEET_NORMAL &&
-      gtk_sheet_range_isvisible (sheet, sheet->range))
+      gtk_sheet_range_isvisible (sheet, &sheet->range))
     gtk_sheet_range_draw_selection (sheet, drawing_range);
 
+
   if (sheet->state == GTK_STATE_NORMAL &&
       sheet->active_cell.row >= drawing_range.row0 &&
       sheet->active_cell.row <= drawing_range.rowi &&
       sheet->active_cell.col >= drawing_range.col0 &&
       sheet->active_cell.col <= drawing_range.coli)
-    gtk_sheet_show_active_cell (sheet);
+    gtk_sheet_show_entry_widget (sheet);
 }
 
+
 static void
 gtk_sheet_range_draw_selection (GtkSheet *sheet, GtkSheetRange range)
 {
@@ -2176,7 +2187,7 @@ gtk_sheet_range_draw_selection (GtkSheet *sheet, GtkSheetRange range)
       range.row0 > sheet->range.rowi || range.rowi < sheet->range.row0)
     return;
 
-  if (!gtk_sheet_range_isvisible (sheet, range)) return;
+  if (!gtk_sheet_range_isvisible (sheet, &range)) return;
   if (!GTK_WIDGET_REALIZED (GTK_WIDGET (sheet))) return;
 
   aux = range;
@@ -2285,7 +2296,7 @@ gtk_sheet_cell_clear (GtkSheet *sheet, gint row, gint column)
 
   gtk_sheet_real_cell_clear (sheet, row, column);
 
-  gtk_sheet_range_draw (sheet, &range);
+  redraw_range (sheet, &range);
 }
 
 static void
@@ -2435,8 +2446,8 @@ gtk_sheet_get_cell_area (GtkSheet *sheet,
   if (row >= psppire_axis_unit_count (sheet->vaxis) || column >= psppire_axis_unit_count (sheet->haxis))
     return FALSE;
 
-  area->x = (column == -1) ? 0 : psppire_axis_pixel_start (sheet->haxis, column);
-  area->y = (row == -1)    ? 0 : psppire_axis_pixel_start (sheet->vaxis, row);
+  area->x = (column == -1) ? 0 : psppire_axis_start_pixel (sheet->haxis, column);
+  area->y = (row == -1)    ? 0 : psppire_axis_start_pixel (sheet->vaxis, row);
 
   area->width= (column == -1) ? sheet->row_title_area.width
     : psppire_axis_unit_size (sheet->haxis, column);
@@ -2469,7 +2480,7 @@ gtk_sheet_set_active_cell (GtkSheet *sheet, gint row, gint col)
 
   if ( row == -1 || col == -1)
     {
-      gtk_sheet_hide_active_cell (sheet);
+      gtk_sheet_hide_entry_widget (sheet);
       return;
     }
 
@@ -2489,16 +2500,12 @@ gtk_sheet_get_active_cell (GtkSheet *sheet, gint *row, gint *column)
 static void
 gtk_sheet_entry_changed (GtkWidget *widget, gpointer data)
 {
-  GtkSheet *sheet;
+  GtkSheet *sheet = GTK_SHEET (data);
   gint row, col;
   const char *text;
   GtkJustification justification;
   GtkSheetCellAttr attributes;
 
-  g_return_if_fail (data != NULL);
-  g_return_if_fail (GTK_IS_SHEET (data));
-
-  sheet = GTK_SHEET (data);
 
   if (!GTK_WIDGET_VISIBLE (widget)) return;
   if (sheet->state != GTK_STATE_NORMAL) return;
@@ -2511,9 +2518,7 @@ gtk_sheet_entry_changed (GtkWidget *widget, gpointer data)
   sheet->active_cell.row = -1;
   sheet->active_cell.col = -1;
 
-  text = gtk_entry_get_text (GTK_ENTRY (gtk_sheet_get_entry (sheet)));
-
-
+  text = gtk_entry_get_text (gtk_sheet_get_entry (sheet));
 
   if (text && strlen (text) > 0)
     {
@@ -2528,10 +2533,8 @@ gtk_sheet_entry_changed (GtkWidget *widget, gpointer data)
 
 
 static void
-gtk_sheet_hide_active_cell (GtkSheet *sheet)
+gtk_sheet_hide_entry_widget (GtkSheet *sheet)
 {
-  GdkRectangle area;
-
   if (!GTK_WIDGET_REALIZED (GTK_WIDGET (sheet)))
     return;
 
@@ -2541,19 +2544,6 @@ gtk_sheet_hide_active_cell (GtkSheet *sheet)
   gtk_widget_hide (sheet->entry_widget);
   gtk_widget_unmap (sheet->entry_widget);
 
-  rectangle_from_cell (sheet,
-		       sheet->active_cell.row, sheet->active_cell.col,
-		       &area);
-
-  gdk_draw_rectangle (sheet->sheet_window,
-		      GTK_WIDGET (sheet)->style->white_gc,
-		      TRUE,
-		      area.x, area.y,
-		      area.width, area.height);
-
-  gtk_sheet_cell_draw (sheet, sheet->active_cell.row,
-			       sheet->active_cell.col);
-
   GTK_WIDGET_UNSET_FLAGS (GTK_WIDGET (sheet->entry_widget), GTK_VISIBLE);
 }
 
@@ -2561,7 +2551,6 @@ static void
 change_active_cell (GtkSheet *sheet, gint row, gint col)
 {
   gint old_row, old_col;
-  glong old_handler_id = sheet->entry_handler_id;
 
   g_return_if_fail (GTK_IS_SHEET (sheet));
 
@@ -2578,11 +2567,12 @@ change_active_cell (GtkSheet *sheet, gint row, gint col)
       gtk_sheet_real_unselect_range (sheet, NULL);
     }
 
-  g_signal_handler_block   (sheet->entry_widget, sheet->entry_handler_id);
-
   old_row = sheet->active_cell.row;
   old_col = sheet->active_cell.col;
 
+  /* Erase the old cell */
+  gtk_sheet_draw_active_cell (sheet);
+
   sheet->range.row0 = row;
   sheet->range.col0 = col;
   sheet->range.rowi = row;
@@ -2594,25 +2584,25 @@ change_active_cell (GtkSheet *sheet, gint row, gint col)
 
   GTK_SHEET_UNSET_FLAGS (sheet, GTK_SHEET_IN_SELECTION);
 
-  gtk_sheet_show_active_cell (sheet);
+  GTK_WIDGET_UNSET_FLAGS (sheet->entry_widget, GTK_HAS_FOCUS);
 
+  gtk_sheet_draw_active_cell (sheet);
+  gtk_sheet_show_entry_widget (sheet);
+  GTK_WIDGET_SET_FLAGS (sheet->entry_widget, GTK_HAS_FOCUS);
 
   g_signal_emit (sheet, sheet_signals [ACTIVATE], 0,
 		 row, col, old_row, old_col);
 
-  if ( old_handler_id == sheet->entry_handler_id)
-    g_signal_handler_unblock   (sheet->entry_widget, sheet->entry_handler_id);
 }
 
 static void
-gtk_sheet_show_active_cell (GtkSheet *sheet)
+gtk_sheet_show_entry_widget (GtkSheet *sheet)
 {
   GtkEntry *sheet_entry;
   GtkSheetCellAttr attributes;
-  gchar *text = NULL;
+
   gint row, col;
 
-  g_return_if_fail (sheet != NULL);
   g_return_if_fail (GTK_IS_SHEET (sheet));
 
   row = sheet->active_cell.row;
@@ -2628,23 +2618,20 @@ gtk_sheet_show_active_cell (GtkSheet *sheet)
 
   GTK_WIDGET_SET_FLAGS (GTK_WIDGET (sheet->entry_widget), GTK_VISIBLE);
 
-  sheet_entry = GTK_ENTRY (gtk_sheet_get_entry (sheet));
+  sheet_entry = gtk_sheet_get_entry (sheet);
 
   gtk_sheet_get_attributes (sheet, row, col, &attributes);
 
-
-  text = gtk_sheet_cell_get_text (sheet, row, col);
-  if ( ! text )
-    text = g_strdup ("");
-
-  gtk_entry_set_visibility (GTK_ENTRY (sheet_entry), attributes.is_visible);
-
-
-  if ( GTK_IS_ENTRY (sheet_entry))
+  if (GTK_IS_ENTRY (sheet_entry) && !GTK_WIDGET_HAS_FOCUS (sheet_entry))
     {
+      gchar *text = gtk_sheet_cell_get_text (sheet, row, col);
       const gchar *old_text = gtk_entry_get_text (GTK_ENTRY (sheet_entry));
+
+      if ( ! text )
+	text = g_strdup ("");
+
       if (strcmp (old_text, text) != 0)
-	gtk_entry_set_text (GTK_ENTRY (sheet_entry), text);
+	gtk_entry_set_text (sheet_entry, text);
 
       switch (attributes.justification)
 	{
@@ -2659,38 +2646,37 @@ gtk_sheet_show_active_cell (GtkSheet *sheet)
 	  gtk_entry_set_alignment (GTK_ENTRY (sheet_entry), 0.0);
 	  break;
 	}
+      dispose_string (sheet, text);
     }
 
   gtk_sheet_size_allocate_entry (sheet);
 
+  gtk_widget_set_sensitive (GTK_WIDGET (sheet_entry),
+			    g_sheet_model_is_editable (sheet->model,
+						       row, col));
   gtk_widget_map (sheet->entry_widget);
-
-  gtk_widget_grab_focus (GTK_WIDGET (sheet_entry));
-
-  dispose_string (sheet, text);
 }
 
-static void
+static gboolean
 gtk_sheet_draw_active_cell (GtkSheet *sheet)
 {
   gint row, col;
   GtkSheetRange range;
 
-  if (!GTK_WIDGET_DRAWABLE (GTK_WIDGET (sheet))) return;
-  if (!GTK_WIDGET_REALIZED (GTK_WIDGET (sheet))) return;
-
   row = sheet->active_cell.row;
   col = sheet->active_cell.col;
 
-  if (row < 0 || col < 0) return;
+  if (row < 0 || col < 0) return FALSE;
 
   if (!gtk_sheet_cell_isvisible (sheet, row, col))
-    return;
+    return FALSE;
 
   range.col0 = range.coli = col;
   range.row0 = range.rowi = row;
 
   gtk_sheet_draw_border (sheet, range);
+
+  return FALSE;
 }
 
 
@@ -2752,11 +2738,11 @@ gtk_sheet_new_selection (GtkSheet *sheet, GtkSheetRange *range)
 
 	      if (mask1 != mask2)
 		{
-		  x = psppire_axis_pixel_start (sheet->haxis, j);
-		  y = psppire_axis_pixel_start (sheet->vaxis, i);
-		  width = psppire_axis_pixel_start (sheet->haxis, j)- x+
+		  x = psppire_axis_start_pixel (sheet->haxis, j);
+		  y = psppire_axis_start_pixel (sheet->vaxis, i);
+		  width = psppire_axis_start_pixel (sheet->haxis, j)- x+
 		    psppire_axis_unit_size (sheet->haxis, j);
-		  height = psppire_axis_pixel_start (sheet->vaxis, i) - y + psppire_axis_unit_size (sheet->vaxis, i);
+		  height = psppire_axis_start_pixel (sheet->vaxis, i) - y + psppire_axis_unit_size (sheet->vaxis, i);
 
 		  if (i == sheet->range.row0)
 		    {
@@ -2773,12 +2759,12 @@ gtk_sheet_new_selection (GtkSheet *sheet, GtkSheetRange *range)
 
 		  if (i != sheet->active_cell.row || j != sheet->active_cell.col)
 		    {
-		      x = psppire_axis_pixel_start (sheet->haxis, j);
-		      y = psppire_axis_pixel_start (sheet->vaxis, i);
-		      width = psppire_axis_pixel_start (sheet->haxis, j)- x+
+		      x = psppire_axis_start_pixel (sheet->haxis, j);
+		      y = psppire_axis_start_pixel (sheet->vaxis, i);
+		      width = psppire_axis_start_pixel (sheet->haxis, j)- x+
 			psppire_axis_unit_size (sheet->haxis, j);
 
-		      height = psppire_axis_pixel_start (sheet->vaxis, i) - y + psppire_axis_unit_size (sheet->vaxis, i);
+		      height = psppire_axis_start_pixel (sheet->vaxis, i) - y + psppire_axis_unit_size (sheet->vaxis, i);
 
 		      if (i == new_range.row0)
 			{
@@ -2816,10 +2802,10 @@ gtk_sheet_new_selection (GtkSheet *sheet, GtkSheetRange *range)
 	  if (state == GTK_STATE_SELECTED && !selected)
 	    {
 
-	      x = psppire_axis_pixel_start (sheet->haxis, j);
-	      y = psppire_axis_pixel_start (sheet->vaxis, i);
-	      width = psppire_axis_pixel_start (sheet->haxis, j) - x + psppire_axis_unit_size (sheet->haxis, j);
-	      height = psppire_axis_pixel_start (sheet->vaxis, i) - y + psppire_axis_unit_size (sheet->vaxis, i);
+	      x = psppire_axis_start_pixel (sheet->haxis, j);
+	      y = psppire_axis_start_pixel (sheet->vaxis, i);
+	      width = psppire_axis_start_pixel (sheet->haxis, j) - x + psppire_axis_unit_size (sheet->haxis, j);
+	      height = psppire_axis_start_pixel (sheet->vaxis, i) - y + psppire_axis_unit_size (sheet->vaxis, i);
 
 	      if (i == sheet->range.row0)
 		{
@@ -2851,10 +2837,10 @@ gtk_sheet_new_selection (GtkSheet *sheet, GtkSheetRange *range)
 	      (i != sheet->active_cell.row || j != sheet->active_cell.col))
 	    {
 
-	      x = psppire_axis_pixel_start (sheet->haxis, j);
-	      y = psppire_axis_pixel_start (sheet->vaxis, i);
-	      width = psppire_axis_pixel_start (sheet->haxis, j) - x + psppire_axis_unit_size (sheet->haxis, j);
-	      height = psppire_axis_pixel_start (sheet->vaxis, i) - y + psppire_axis_unit_size (sheet->vaxis, i);
+	      x = psppire_axis_start_pixel (sheet->haxis, j);
+	      y = psppire_axis_start_pixel (sheet->vaxis, i);
+	      width = psppire_axis_start_pixel (sheet->haxis, j) - x + psppire_axis_unit_size (sheet->haxis, j);
+	      height = psppire_axis_start_pixel (sheet->vaxis, i) - y + psppire_axis_unit_size (sheet->vaxis, i);
 
 	      if (i == new_range.row0)
 		{
@@ -2897,8 +2883,8 @@ gtk_sheet_new_selection (GtkSheet *sheet, GtkSheetRange *range)
 	  mask2 = j == new_range.coli ? mask2 + 8 : mask2;
 	  if (mask2 != mask1 || (mask2 == mask1 && state != GTK_STATE_SELECTED))
 	    {
-	      x = psppire_axis_pixel_start (sheet->haxis, j);
-	      y = psppire_axis_pixel_start (sheet->vaxis, i);
+	      x = psppire_axis_start_pixel (sheet->haxis, j);
+	      y = psppire_axis_start_pixel (sheet->vaxis, i);
 	      width = psppire_axis_unit_size (sheet->haxis, j);
 	      height = psppire_axis_unit_size (sheet->vaxis, i);
 	      if (mask2 & 1)
@@ -2937,6 +2923,8 @@ gtk_sheet_new_selection (GtkSheet *sheet, GtkSheetRange *range)
   *range = new_range;
 }
 
+
+
 static void
 gtk_sheet_draw_border (GtkSheet *sheet, GtkSheetRange new_range)
 {
@@ -2947,10 +2935,8 @@ gtk_sheet_draw_border (GtkSheet *sheet, GtkSheetRange new_range)
   gdk_draw_rectangle (sheet->sheet_window,
 		      sheet->xor_gc,
 		      FALSE,
-		      area.x + 1,
-		      area.y + 1,
-		      area.width - 2,
-		      area.height - 2);
+		      area.x, area.y,
+		      area.width, area.height);
 }
 
 
@@ -3054,11 +3040,6 @@ gtk_sheet_real_unselect_range (GtkSheet *sheet,
   g_signal_emit (sheet, sheet_signals[SELECT_COLUMN], 0, -1);
   g_signal_emit (sheet, sheet_signals[SELECT_ROW], 0, -1);
 
-#if 0
-  if (gtk_sheet_range_isvisible (sheet, *range))
-    gtk_sheet_draw_backing_pixmap (sheet, *range);
-#endif
-
   sheet->range.row0 = -1;
   sheet->range.rowi = -1;
   sheet->range.col0 = -1;
@@ -3070,15 +3051,10 @@ static gint
 gtk_sheet_expose (GtkWidget *widget,
 		  GdkEventExpose *event)
 {
-  GtkSheet *sheet;
-  GtkSheetRange range;
+  GtkSheet *sheet = GTK_SHEET (widget);
 
-  g_return_val_if_fail (widget != NULL, FALSE);
-  g_return_val_if_fail (GTK_IS_SHEET (widget), FALSE);
   g_return_val_if_fail (event != NULL, FALSE);
 
-  sheet = GTK_SHEET (widget);
-
   if (!GTK_WIDGET_DRAWABLE (widget))
     return FALSE;
 
@@ -3099,56 +3075,43 @@ gtk_sheet_expose (GtkWidget *widget,
 				       max_visible_column (sheet));
     }
 
-
-  range.row0 =
-    row_from_ypixel (sheet,
-			   event->area.y + sheet->vadjustment->value);
-  range.row0--;
-
-  range.rowi =
-    row_from_ypixel (sheet,
-			   event->area.y +
-			   event->area.height + sheet->vadjustment->value);
-  range.rowi++;
-
-  range.col0 =
-    column_from_xpixel (sheet,
-			event->area.x + sheet->hadjustment->value);
-  range.col0--;
-
-  range.coli =
-    column_from_xpixel (sheet,
-			event->area.x + event->area.width +
-			sheet->hadjustment->value);
-  range.coli++;
-
   if (event->window == sheet->sheet_window)
     {
-      gtk_sheet_range_draw (sheet, &range);
+      draw_sheet_region (sheet, event->region);
 
+#if 0
       if (sheet->state != GTK_SHEET_NORMAL)
 	{
-	  if (gtk_sheet_range_isvisible (sheet, sheet->range))
+	  if (gtk_sheet_range_isvisible (sheet, &sheet->range))
 	    gtk_sheet_range_draw (sheet, &sheet->range);
 
 	  if (GTK_SHEET_IN_RESIZE (sheet) || GTK_SHEET_IN_DRAG (sheet))
 	    gtk_sheet_range_draw (sheet, &sheet->drag_range);
 
-	  if (gtk_sheet_range_isvisible (sheet, sheet->range))
+	  if (gtk_sheet_range_isvisible (sheet, &sheet->range))
 	    gtk_sheet_range_draw_selection (sheet, sheet->range);
 	  if (GTK_SHEET_IN_RESIZE (sheet) || GTK_SHEET_IN_DRAG (sheet))
 	    draw_xor_rectangle (sheet, sheet->drag_range);
 	}
+#endif
 
       if ((!GTK_SHEET_IN_XDRAG (sheet)) && (!GTK_SHEET_IN_YDRAG (sheet)))
 	{
-	  if (sheet->state == GTK_SHEET_NORMAL)
-	    gtk_sheet_draw_active_cell (sheet);
+	  GdkRectangle rect;
+	  GtkSheetRange range;
+	  range.row0 = range.rowi =  sheet->active_cell.row;
+	  range.col0 = range.coli =  sheet->active_cell.col;
+
+	  rectangle_from_range (sheet, &range, &rect);
+
+	  if (GDK_OVERLAP_RECTANGLE_OUT !=
+	      gdk_region_rect_in (event->region, &rect))
+	    {
+	      gtk_sheet_draw_active_cell (sheet);
+	    }
 	}
-    }
 
-  if (sheet->state != GTK_SHEET_NORMAL && GTK_SHEET_IN_SELECTION (sheet))
-    gtk_widget_grab_focus (GTK_WIDGET (sheet));
+    }
 
   (* GTK_WIDGET_CLASS (parent_class)->expose_event) (widget, event);
 
@@ -3185,6 +3148,7 @@ gtk_sheet_button_press (GtkWidget *widget,
 
   if (event->window == sheet->column_title_window)
     {
+      sheet->x_drag = event->x;
       g_signal_emit (sheet,
 		     sheet_signals[BUTTON_EVENT_COLUMN], 0,
 		     column, event);
@@ -3216,21 +3180,12 @@ gtk_sheet_button_press (GtkWidget *widget,
 
 
   /* press on resize windows */
-  if (event->window == sheet->column_title_window &&
-      gtk_sheet_columns_resizable (sheet))
+  if (event->window == sheet->column_title_window)
     {
-#if 0
-      gtk_widget_get_pointer (widget, &sheet->x_drag, NULL);
-      if ( sheet->row_titles_visible)
-	sheet->x_drag -= sheet->row_title_area.width;
-#endif
-
       sheet->x_drag = event->x;
 
       if (on_column_boundary (sheet, sheet->x_drag, &sheet->drag_cell.col))
 	{
-	  guint req;
-	  gtk_sheet_column_size_request (sheet, sheet->drag_cell.col, &req);
 	  GTK_SHEET_SET_FLAGS (sheet, GTK_SHEET_IN_XDRAG);
 	  gdk_pointer_grab (sheet->column_title_window, FALSE,
 			    GDK_POINTER_MOTION_HINT_MASK |
@@ -3243,15 +3198,12 @@ gtk_sheet_button_press (GtkWidget *widget,
 	}
     }
 
-  if (event->window == sheet->row_title_window && gtk_sheet_rows_resizable (sheet))
+  if (event->window == sheet->row_title_window)
     {
-      gtk_widget_get_pointer (widget, NULL, &sheet->y_drag);
+      sheet->y_drag = event->y;
 
-#if AXIS_TRANSITION
-      if (POSSIBLE_YDRAG (sheet, sheet->y_drag, &sheet->drag_cell.row))
+      if (on_row_boundary (sheet, sheet->y_drag, &sheet->drag_cell.row))
 	{
-	  guint req;
-	  gtk_sheet_row_size_request (sheet, sheet->drag_cell.row, &req);
 	  GTK_SHEET_SET_FLAGS (sheet, GTK_SHEET_IN_YDRAG);
 	  gdk_pointer_grab (sheet->row_title_window, FALSE,
 			    GDK_POINTER_MOTION_HINT_MASK |
@@ -3262,7 +3214,6 @@ gtk_sheet_button_press (GtkWidget *widget,
 	  draw_xor_hline (sheet);
 	  return TRUE;
 	}
-#endif
     }
 
   /* the sheet itself does not handle other than single click events */
@@ -3280,12 +3231,6 @@ gtk_sheet_button_press (GtkWidget *widget,
 			NULL, NULL, event->time);
       gtk_grab_add (GTK_WIDGET (sheet));
 
-      /* This seems to be a kludge to work around a problem where the sheet
-	 scrolls to another position.  The timeout scrolls it back to its
-	 original posn. 	 JMD 3 July 2007
-      */
-      gtk_widget_grab_focus (GTK_WIDGET (sheet));
-
       if (sheet->selection_mode != GTK_SELECTION_SINGLE &&
 	  sheet->selection_mode != GTK_SELECTION_NONE &&
 	  sheet->cursor_drag->type == GDK_SIZING &&
@@ -3361,7 +3306,6 @@ gtk_sheet_button_press (GtkWidget *widget,
 	{
 	  veto = gtk_sheet_click_cell (sheet, -1, column);
 	  gtk_grab_add (GTK_WIDGET (sheet));
-	  gtk_widget_grab_focus (GTK_WIDGET (sheet));
 	  GTK_SHEET_SET_FLAGS (sheet, GTK_SHEET_IN_SELECTION);
 	}
     }
@@ -3379,7 +3323,6 @@ gtk_sheet_button_press (GtkWidget *widget,
 	{
 	  veto = gtk_sheet_click_cell (sheet, row, -1);
 	  gtk_grab_add (GTK_WIDGET (sheet));
-	  gtk_widget_grab_focus (GTK_WIDGET (sheet));
 	  GTK_SHEET_SET_FLAGS (sheet, GTK_SHEET_IN_SELECTION);
 	}
     }
@@ -3464,7 +3407,9 @@ gtk_sheet_click_cell (GtkSheet *sheet, gint row, gint column)
   sheet->range.coli = column;
   sheet->state = GTK_SHEET_NORMAL;
   GTK_SHEET_SET_FLAGS (sheet, GTK_SHEET_IN_SELECTION);
-  gtk_sheet_draw_active_cell (sheet);
+
+  gtk_widget_grab_focus (GTK_WIDGET (sheet->entry_widget));
+
   return TRUE;
 }
 
@@ -3472,7 +3417,6 @@ static gint
 gtk_sheet_button_release (GtkWidget *widget,
 			  GdkEventButton *event)
 {
-  gint y;
   GdkDisplay *display = gtk_widget_get_display (widget);
 
   GtkSheet *sheet = GTK_SHEET (widget);
@@ -3480,7 +3424,6 @@ gtk_sheet_button_release (GtkWidget *widget,
   /* release on resize windows */
   if (GTK_SHEET_IN_XDRAG (sheet))
     {
-      gint xpos = event->x;
       gint width;
       GTK_SHEET_UNSET_FLAGS (sheet, GTK_SHEET_IN_XDRAG);
       GTK_SHEET_UNSET_FLAGS (sheet, GTK_SHEET_IN_SELECTION);
@@ -3488,27 +3431,33 @@ gtk_sheet_button_release (GtkWidget *widget,
       gdk_display_pointer_ungrab (display, event->time);
       draw_xor_vline (sheet);
 
-      width = new_column_width (sheet, sheet->drag_cell.col, &xpos);
+      width = event->x -
+	psppire_axis_start_pixel (sheet->haxis, sheet->drag_cell.col)
+	+ sheet->hadjustment->value;
+
+      set_column_width (sheet, sheet->drag_cell.col, width);
 
-      gtk_sheet_set_column_width (sheet, sheet->drag_cell.col, width);
       return TRUE;
     }
 
   if (GTK_SHEET_IN_YDRAG (sheet))
     {
+      gint height;
       GTK_SHEET_UNSET_FLAGS (sheet, GTK_SHEET_IN_YDRAG);
       GTK_SHEET_UNSET_FLAGS (sheet, GTK_SHEET_IN_SELECTION);
-      gtk_widget_get_pointer (widget, NULL, &y);
+
       gdk_display_pointer_ungrab (display, event->time);
       draw_xor_hline (sheet);
 
-      gtk_sheet_set_row_height (sheet, sheet->drag_cell.row,
-				new_row_height (sheet, sheet->drag_cell.row, &y));
-      g_signal_emit_by_name (sheet->vadjustment, "value_changed");
+      height = event->y -
+	psppire_axis_start_pixel (sheet->vaxis, sheet->drag_cell.row) +
+	sheet->vadjustment->value;
+
+      set_row_height (sheet, sheet->drag_cell.row, height);
+
       return TRUE;
     }
 
-
   if (GTK_SHEET_IN_DRAG (sheet))
     {
       GtkSheetRange old_range;
@@ -3730,19 +3679,15 @@ motion_timeout_callback (gpointer data)
 static gboolean
 gtk_sheet_motion (GtkWidget *widget,  GdkEventMotion *event)
 {
-  GtkSheet *sheet;
+  GtkSheet *sheet = GTK_SHEET (widget);
   GdkModifierType mods;
   GdkCursorType new_cursor;
   gint x, y;
   gint row, column;
   GdkDisplay *display;
 
-  g_return_val_if_fail (widget != NULL, FALSE);
-  g_return_val_if_fail (GTK_IS_SHEET (widget), FALSE);
   g_return_val_if_fail (event != NULL, FALSE);
 
-  sheet = GTK_SHEET (widget);
-
   display = gtk_widget_get_display (widget);
 
   /* selections on the sheet */
@@ -3772,8 +3717,7 @@ gtk_sheet_motion (GtkWidget *widget,  GdkEventMotion *event)
 	}
     }
 
-  if (event->window == sheet->column_title_window &&
-      gtk_sheet_columns_resizable (sheet))
+  if (event->window == sheet->column_title_window)
     {
       if (!GTK_SHEET_IN_SELECTION (sheet) &&
 	  on_column_boundary (sheet, x, &column))
@@ -3782,7 +3726,9 @@ gtk_sheet_motion (GtkWidget *widget,  GdkEventMotion *event)
 	  if (new_cursor != sheet->cursor_drag->type)
 	    {
 	      gdk_cursor_unref (sheet->cursor_drag);
-	      sheet->cursor_drag = gdk_cursor_new_for_display (display, GDK_SB_H_DOUBLE_ARROW);
+	      sheet->cursor_drag =
+		gdk_cursor_new_for_display (display, new_cursor);
+
 	      gdk_window_set_cursor (sheet->column_title_window,
 				     sheet->cursor_drag);
 	    }
@@ -3794,37 +3740,39 @@ gtk_sheet_motion (GtkWidget *widget,  GdkEventMotion *event)
 	      new_cursor != sheet->cursor_drag->type)
 	    {
 	      gdk_cursor_unref (sheet->cursor_drag);
-	      sheet->cursor_drag = gdk_cursor_new_for_display (display, GDK_TOP_LEFT_ARROW);
+	      sheet->cursor_drag =
+		gdk_cursor_new_for_display (display, new_cursor);
 	      gdk_window_set_cursor (sheet->column_title_window,
 				     sheet->cursor_drag);
 	    }
 	}
     }
-
-  if (event->window == sheet->row_title_window &&
-      gtk_sheet_rows_resizable (sheet))
+  else if (event->window == sheet->row_title_window)
     {
-#if AXIS_TRANSITION
-      if (!GTK_SHEET_IN_SELECTION (sheet) && POSSIBLE_YDRAG (sheet, y, &column))
+      if (!GTK_SHEET_IN_SELECTION (sheet) &&
+	  on_row_boundary (sheet, y, &row))
 	{
 	  new_cursor = GDK_SB_V_DOUBLE_ARROW;
 	  if (new_cursor != sheet->cursor_drag->type)
 	    {
 	      gdk_cursor_unref (sheet->cursor_drag);
-	      sheet->cursor_drag = gdk_cursor_new_for_display (display, GDK_SB_V_DOUBLE_ARROW);
-	      gdk_window_set_cursor (sheet->row_title_window, sheet->cursor_drag);
+	      sheet->cursor_drag =
+		gdk_cursor_new_for_display (display, new_cursor);
+	      gdk_window_set_cursor (sheet->row_title_window,
+				     sheet->cursor_drag);
 	    }
 	}
       else
-#endif
 	{
 	  new_cursor = GDK_TOP_LEFT_ARROW;
 	  if (!GTK_SHEET_IN_YDRAG (sheet) &&
 	      new_cursor != sheet->cursor_drag->type)
 	    {
 	      gdk_cursor_unref (sheet->cursor_drag);
-	      sheet->cursor_drag = gdk_cursor_new_for_display (display, GDK_TOP_LEFT_ARROW);
-	      gdk_window_set_cursor (sheet->row_title_window, sheet->cursor_drag);
+	      sheet->cursor_drag =
+		gdk_cursor_new_for_display (display, new_cursor);
+	      gdk_window_set_cursor (sheet->row_title_window,
+				     sheet->cursor_drag);
 	    }
 	}
     }
@@ -3874,34 +3822,25 @@ gtk_sheet_motion (GtkWidget *widget,  GdkEventMotion *event)
 
   if (GTK_SHEET_IN_XDRAG (sheet))
     {
-      x = event->x;
-
-      new_column_width (sheet, sheet->drag_cell.col, &x);
-#if 0
-      if (x != sheet->x_drag)
+      if (event->x != sheet->x_drag)
 	{
 	  draw_xor_vline (sheet);
-	  sheet->x_drag = x;
+	  sheet->x_drag = event->x;
 	  draw_xor_vline (sheet);
 	}
-#endif
+
       return TRUE;
     }
 
   if (GTK_SHEET_IN_YDRAG (sheet))
     {
-      if (event->is_hint || event->window != widget->window)
-	gtk_widget_get_pointer (widget, NULL, &y);
-      else
-	y = event->y;
-
-      new_row_height (sheet, sheet->drag_cell.row, &y);
-      if (y != sheet->y_drag)
+      if (event->y != sheet->y_drag)
 	{
 	  draw_xor_hline (sheet);
-	  sheet->y_drag = y;
+	  sheet->y_drag = event->y;
 	  draw_xor_hline (sheet);
 	}
+
       return TRUE;
     }
 
@@ -3938,8 +3877,8 @@ gtk_sheet_motion (GtkWidget *widget,  GdkEventMotion *event)
       GtkSheetRange aux;
       gint v_h, current_col, current_row, col_threshold, row_threshold;
       v_h = 1;
-      if (abs (x - psppire_axis_pixel_start (sheet->haxis, sheet->drag_cell.col)) >
-	  abs (y - psppire_axis_pixel_start (sheet->vaxis, sheet->drag_cell.row))) v_h = 2;
+      if (abs (x - psppire_axis_start_pixel (sheet->haxis, sheet->drag_cell.col)) >
+	  abs (y - psppire_axis_start_pixel (sheet->vaxis, sheet->drag_cell.row))) v_h = 2;
 
       current_col = column_from_xpixel (sheet, x);
       current_row = row_from_ypixel (sheet, y);
@@ -3948,7 +3887,7 @@ gtk_sheet_motion (GtkWidget *widget,  GdkEventMotion *event)
 
       /*use half of column width resp. row height as threshold to
 	expand selection*/
-      col_threshold = psppire_axis_pixel_start (sheet->haxis, current_col) +
+      col_threshold = psppire_axis_start_pixel (sheet->haxis, current_col) +
 	psppire_axis_unit_size (sheet->haxis, current_col) / 2;
       if (column > 0)
 	{
@@ -3960,7 +3899,7 @@ gtk_sheet_motion (GtkWidget *widget,  GdkEventMotion *event)
 	  if (x > col_threshold)
 	    column +=1;
 	}
-      row_threshold = psppire_axis_pixel_start (sheet->vaxis, current_row) +
+      row_threshold = psppire_axis_start_pixel (sheet->vaxis, current_row) +
 	psppire_axis_unit_size (sheet->vaxis, current_row)/2;
       if (row > 0)
 	{
@@ -4104,11 +4043,11 @@ static void
 page_vertical (GtkSheet *sheet, GtkScrollType dir)
 {
   gint old_row = sheet->active_cell.row ;
-  glong vpixel = psppire_axis_pixel_start (sheet->vaxis, old_row);
+  glong vpixel = psppire_axis_start_pixel (sheet->vaxis, old_row);
 
   gint new_row;
 
-  vpixel -= psppire_axis_pixel_start (sheet->vaxis,
+  vpixel -= psppire_axis_start_pixel (sheet->vaxis,
 				     min_visible_row (sheet));
 
   switch ( dir)
@@ -4130,7 +4069,7 @@ page_vertical (GtkSheet *sheet, GtkScrollType dir)
     }
 
 
-  vpixel += psppire_axis_pixel_start (sheet->vaxis,
+  vpixel += psppire_axis_start_pixel (sheet->vaxis,
 				     min_visible_row (sheet));
 
   new_row =  row_from_ypixel (sheet, vpixel);
@@ -4171,6 +4110,15 @@ step_sheet (GtkSheet *sheet, GtkScrollType dir)
     }
 
 
+  g_signal_emit (sheet, sheet_signals[TRAVERSE], 0,
+		 &sheet->active_cell,
+		 &new_cell,
+		 &forbidden);
+
+  if (forbidden)
+    return;
+
+
   maximize_int (&new_cell.row, 0);
   maximize_int (&new_cell.col, 0);
 
@@ -4180,20 +4128,13 @@ step_sheet (GtkSheet *sheet, GtkScrollType dir)
   minimize_int (&new_cell.col,
 		psppire_axis_unit_count (sheet->haxis) - 1);
 
-  g_signal_emit (sheet, sheet_signals[TRAVERSE], 0,
-		 &sheet->active_cell,
-		 &new_cell,
-		&forbidden);
-
-  if (forbidden)
-    return;
-
   change_active_cell (sheet, new_cell.row, new_cell.col);
 
+
   if ( new_cell.col > max_fully_visible_column (sheet))
     {
       glong hpos  =
-	psppire_axis_pixel_start (sheet->haxis,
+	psppire_axis_start_pixel (sheet->haxis,
 				    new_cell.col + 1);
       hpos -= sheet->hadjustment->page_size;
 
@@ -4203,7 +4144,7 @@ step_sheet (GtkSheet *sheet, GtkScrollType dir)
   else if ( new_cell.col < min_fully_visible_column (sheet))
     {
       glong hpos  =
-	psppire_axis_pixel_start (sheet->haxis,
+	psppire_axis_start_pixel (sheet->haxis,
 				    new_cell.col);
 
       gtk_adjustment_set_value (sheet->hadjustment,
@@ -4214,7 +4155,7 @@ step_sheet (GtkSheet *sheet, GtkScrollType dir)
   if ( new_cell.row > max_fully_visible_row (sheet))
     {
       glong vpos  =
-	psppire_axis_pixel_start (sheet->vaxis,
+	psppire_axis_start_pixel (sheet->vaxis,
 				    new_cell.row + 1);
       vpos -= sheet->vadjustment->page_size;
 
@@ -4224,12 +4165,14 @@ step_sheet (GtkSheet *sheet, GtkScrollType dir)
   else if ( new_cell.row < min_fully_visible_row (sheet))
     {
       glong vpos  =
-	psppire_axis_pixel_start (sheet->vaxis,
+	psppire_axis_start_pixel (sheet->vaxis,
 				    new_cell.row);
 
       gtk_adjustment_set_value (sheet->vadjustment,
 				vpos);
     }
+
+  gtk_widget_grab_focus (GTK_WIDGET (sheet->entry_widget));
 }
 
 
@@ -4346,14 +4289,6 @@ gtk_sheet_size_allocate (GtkWidget *widget,
 			    allocation->width - 2 * border_width,
 			    allocation->height - 2 * border_width);
 
-  /* use internal allocation structure for all the math
-   * because it's easier than always subtracting the container
-   * border width */
-  sheet->internal_allocation.x = 0;
-  sheet->internal_allocation.y = 0;
-  sheet->internal_allocation.width = allocation->width - 2 * border_width;
-  sheet->internal_allocation.height = allocation->height - 2 * border_width;
-
   sheet_allocation.x = 0;
   sheet_allocation.y = 0;
   sheet_allocation.width = allocation->width - 2 * border_width;
@@ -4526,7 +4461,7 @@ gtk_sheet_size_allocate_entry (GtkSheet *sheet)
   if (!GTK_WIDGET_REALIZED (GTK_WIDGET (sheet))) return;
   if (!GTK_WIDGET_MAPPED (GTK_WIDGET (sheet))) return;
 
-  sheet_entry = GTK_ENTRY (gtk_sheet_get_entry (sheet));
+  sheet_entry = gtk_sheet_get_entry (sheet);
 
   if ( ! gtk_sheet_get_attributes (sheet, sheet->active_cell.row,
 				   sheet->active_cell.col,
@@ -4548,12 +4483,32 @@ gtk_sheet_size_allocate_entry (GtkSheet *sheet)
   rectangle_from_cell (sheet, sheet->active_cell.row,
 		       sheet->active_cell.col, &entry_alloc);
 
+  entry_alloc.width -= BORDER_WIDTH ;
+  entry_alloc.height -= BORDER_WIDTH ;
+  entry_alloc.x += DIV_RND_UP (BORDER_WIDTH, 2);
+  entry_alloc.y += DIV_RND_UP (BORDER_WIDTH, 2);
+
+
   gtk_widget_set_size_request (sheet->entry_widget, entry_alloc.width,
 			       entry_alloc.height);
   gtk_widget_size_allocate (sheet->entry_widget, &entry_alloc);
 }
 
 
+/* Copy the sheet's font to the entry widget */
+static void
+set_entry_widget_font (GtkSheet *sheet)
+{
+  GtkRcStyle *style = gtk_widget_get_modifier_style (sheet->entry_widget);
+
+  pango_font_description_free (style->font_desc);
+  style->font_desc = pango_font_description_copy (GTK_WIDGET (sheet)->style->font_desc);
+
+  gtk_widget_modify_style (sheet->entry_widget, style);
+}
+
+
+
 static void
 create_sheet_entry (GtkSheet *sheet)
 {
@@ -4562,32 +4517,18 @@ create_sheet_entry (GtkSheet *sheet)
       gtk_widget_unparent (sheet->entry_widget);
     }
 
-  if (sheet->entry_type)
-    {
-      sheet->entry_container = g_object_new (sheet->entry_type, NULL);
-      g_object_ref_sink (sheet->entry_container);
-      sheet->entry_widget = gtk_sheet_get_entry (sheet);
+  sheet->entry_widget = g_object_new (sheet->entry_type, NULL);
+  g_object_ref_sink (sheet->entry_widget);
 
-      if  ( NULL == sheet->entry_widget)
-	{
-	  g_warning ("Entry type is %s. It must be GtkEntry subclass, or a widget containing one. "
-		     "Using default", g_type_name (sheet->entry_type));
-	  g_object_unref (sheet->entry_container);
-	  sheet->entry_widget = sheet->entry_container = gtk_entry_new ();
-	}
-      else
-	{
-	  sheet->entry_widget = sheet->entry_container ;
-	}
-    }
-  else
+  gtk_widget_size_request (sheet->entry_widget, NULL);
+
+  if ( GTK_IS_ENTRY (sheet->entry_widget))
     {
-      sheet->entry_widget = sheet->entry_container = gtk_entry_new ();
-      g_object_ref_sink (sheet->entry_container);
+      g_object_set (sheet->entry_widget,
+		    "has-frame", FALSE,
+		    NULL);
     }
 
-  gtk_widget_size_request (sheet->entry_widget, NULL);
-
   if (GTK_WIDGET_REALIZED (sheet))
     {
       gtk_widget_set_parent_window (sheet->entry_widget, sheet->sheet_window);
@@ -4599,12 +4540,13 @@ create_sheet_entry (GtkSheet *sheet)
 			    G_CALLBACK (gtk_sheet_entry_key_press),
 			    sheet);
 
-  sheet->entry_handler_id =
-    g_signal_connect (sheet->entry_widget,
+  g_signal_connect (sheet->entry_widget,
 		      "changed",
 		      G_CALLBACK (gtk_sheet_entry_changed),
 		      sheet);
 
+  set_entry_widget_font (sheet);
+
   gtk_widget_show (sheet->entry_widget);
 }
 
@@ -4620,43 +4562,32 @@ find_entry (GtkWidget *w, gpointer user_data)
     }
 }
 
-GtkWidget *
+
+GtkEntry *
 gtk_sheet_get_entry (GtkSheet *sheet)
 {
-  GtkWidget *parent;
-  GtkWidget *entry = NULL;
+  GtkWidget *w = sheet->entry_widget;
 
   g_return_val_if_fail (sheet != NULL, NULL);
   g_return_val_if_fail (GTK_IS_SHEET (sheet), NULL);
   g_return_val_if_fail (sheet->entry_widget != NULL, NULL);
 
-  if (GTK_IS_ENTRY (sheet->entry_container))
-    return (sheet->entry_container);
-
-  parent = sheet->entry_container;
-
-  if (GTK_IS_CONTAINER (parent))
+  while (! GTK_IS_ENTRY (w))
     {
-      gtk_container_forall (GTK_CONTAINER (parent), find_entry, &entry);
+      GtkWidget *entry = NULL;
 
-      if (GTK_IS_ENTRY (entry))
-	return entry;
-    }
-
-  if (!GTK_IS_ENTRY (entry)) return NULL;
+      if (GTK_IS_CONTAINER (w))
+	{
+	  gtk_container_forall (GTK_CONTAINER (w), find_entry, &entry);
 
-  return (entry);
+	  if (NULL == entry)
+	    break;
 
-}
-
-GtkWidget *
-gtk_sheet_get_entry_widget (GtkSheet *sheet)
-{
-  g_return_val_if_fail (sheet != NULL, NULL);
-  g_return_val_if_fail (GTK_IS_SHEET (sheet), NULL);
-  g_return_val_if_fail (sheet->entry_widget != NULL, NULL);
+	  w = entry;
+	}
+    }
 
-  return (sheet->entry_widget);
+  return GTK_ENTRY (w);
 }
 
 
@@ -4718,7 +4649,7 @@ draw_button (GtkSheet *sheet, GdkWindow *window,
 
       allocation.y += 2 * sheet->button->style->ythickness;
 
-      if (button->label && strlen (button->label)>0)
+      if (button->label && strlen (button->label) > 0)
 	{
 	  PangoRectangle rect;
 	  gchar *line = button->label;
@@ -4774,7 +4705,7 @@ draw_button (GtkSheet *sheet, GdkWindow *window,
 static void
 draw_column_title_buttons_range (GtkSheet *sheet, gint first, gint last)
 {
-  GdkRegion *region;
+  GdkRectangle rect;
   gint col;
   if (!GTK_WIDGET_REALIZED (GTK_WIDGET (sheet))) return;
 
@@ -4783,10 +4714,18 @@ draw_column_title_buttons_range (GtkSheet *sheet, gint first, gint last)
   g_return_if_fail (first >= min_visible_column (sheet));
   g_return_if_fail (last <= max_visible_column (sheet));
 
-  region =
-    gdk_drawable_get_visible_region (GDK_DRAWABLE (sheet->column_title_window));
+  rect.y = 0;
+  rect.height = sheet->column_title_area.height;
+  rect.x = psppire_axis_start_pixel (sheet->haxis, first) + CELL_SPACING;
+  rect.width = psppire_axis_start_pixel (sheet->haxis, last) + CELL_SPACING
+    + psppire_axis_unit_size (sheet->haxis, last);
+
+  rect.x -= sheet->hadjustment->value;
 
-  gdk_window_begin_paint_region (sheet->column_title_window, region);
+  minimize_int (&rect.width, sheet->column_title_area.width);
+  maximize_int (&rect.x, 0);
+
+  gdk_window_begin_paint_rect (sheet->column_title_window, &rect);
 
   for (col = first ; col <= last ; ++col)
     {
@@ -4796,7 +4735,7 @@ draw_column_title_buttons_range (GtkSheet *sheet, gint first, gint last)
       GtkSheetButton *
 	button = g_sheet_model_get_column_button (sheet->model, col);
       allocation.y = 0;
-      allocation.x = psppire_axis_pixel_start (sheet->haxis, col)
+      allocation.x = psppire_axis_start_pixel (sheet->haxis, col)
 	+ CELL_SPACING;
       allocation.x -= sheet->hadjustment->value;
 
@@ -4815,7 +4754,7 @@ draw_column_title_buttons_range (GtkSheet *sheet, gint first, gint last)
 static void
 draw_row_title_buttons_range (GtkSheet *sheet, gint first, gint last)
 {
-  GdkRegion *region;
+  GdkRectangle rect;
   gint row;
   if (!GTK_WIDGET_REALIZED (GTK_WIDGET (sheet))) return;
 
@@ -4824,13 +4763,18 @@ draw_row_title_buttons_range (GtkSheet *sheet, gint first, gint last)
   g_return_if_fail (first >= min_visible_row (sheet));
   g_return_if_fail (last <= max_visible_row (sheet));
 
+  rect.x = 0;
+  rect.width = sheet->row_title_area.width;
+  rect.y = psppire_axis_start_pixel (sheet->vaxis, first) + CELL_SPACING;
+  rect.height = psppire_axis_start_pixel (sheet->vaxis, last) + CELL_SPACING
+    + psppire_axis_unit_size (sheet->vaxis, last);
 
-  region =
-    gdk_drawable_get_visible_region (GDK_DRAWABLE (sheet->row_title_window));
-
-  gdk_window_begin_paint_region (sheet->row_title_window, region);
+  rect.y -= sheet->vadjustment->value;
 
+  minimize_int (&rect.height, sheet->row_title_area.height);
+  maximize_int (&rect.y, 0);
 
+  gdk_window_begin_paint_rect (sheet->row_title_window, &rect);
   for (row = first; row <= last; ++row)
     {
       GdkRectangle allocation;
@@ -4840,7 +4784,7 @@ draw_row_title_buttons_range (GtkSheet *sheet, gint first, gint last)
       GtkSheetButton *button =
 	g_sheet_model_get_row_button (sheet->model, row);
       allocation.x = 0;
-      allocation.y = psppire_axis_pixel_start (sheet->vaxis, row)
+      allocation.y = psppire_axis_start_pixel (sheet->vaxis, row)
 	+ CELL_SPACING;
       allocation.y -= sheet->vadjustment->value;
 
@@ -4862,6 +4806,40 @@ draw_row_title_buttons_range (GtkSheet *sheet, gint first, gint last)
  * vadjustment_value_changed
  * hadjustment_value_changed */
 
+
+static void
+update_adjustment (GtkAdjustment *adj, PsppireAxis *axis, gint page_size)
+{
+  double position =
+    (adj->value + adj->page_size)
+    /
+    (adj->upper - adj->lower);
+
+  const glong last_item = psppire_axis_unit_count (axis) - 1;
+
+  if (isnan (position) || position < 0)
+    position = 0;
+
+  adj->upper =
+    psppire_axis_start_pixel (axis, last_item)
+    +
+    psppire_axis_unit_size (axis, last_item)
+    ;
+
+  adj->lower = 0;
+  adj->page_size = page_size;
+
+#if 0
+  adj->value = position * (adj->upper - adj->lower) - adj->page_size;
+
+  if ( adj->value < adj->lower)
+    adj->value = adj->lower;
+#endif
+
+  gtk_adjustment_changed (adj);
+}
+
+
 static void
 adjust_scrollbars (GtkSheet *sheet)
 {
@@ -4891,39 +4869,23 @@ adjust_scrollbars (GtkSheet *sheet)
 	sheet->column_title_area.height -
 	psppire_axis_unit_size (sheet->vaxis, last_row);
 
-
-
-      sheet->vadjustment->upper =
-	psppire_axis_pixel_start (sheet->vaxis, last_row)
-	+
-	psppire_axis_unit_size (sheet->vaxis, last_row)
-	;
-
-      sheet->vadjustment->lower = 0;
-      sheet->vadjustment->page_size = height;
-
-      g_signal_emit_by_name (sheet->vadjustment, "changed");
+      update_adjustment (sheet->vadjustment, sheet->vaxis, height);
     }
 
   if (sheet->hadjustment)
     {
-      gint last_col;
+      gint last_col = psppire_axis_unit_count (sheet->haxis) - 1;
       sheet->hadjustment->step_increment = 1;
 
       sheet->hadjustment->page_increment = width;
 
-      last_col = psppire_axis_unit_count (sheet->haxis) - 1;
-
       sheet->hadjustment->upper =
-	psppire_axis_pixel_start (sheet->haxis, last_col)
+	psppire_axis_start_pixel (sheet->haxis, last_col)
 	+
 	psppire_axis_unit_size (sheet->haxis, last_col)
 	;
 
-      sheet->hadjustment->lower = 0;
-      sheet->hadjustment->page_size = width;
-
-      g_signal_emit_by_name (sheet->hadjustment, "changed");
+      update_adjustment (sheet->hadjustment, sheet->haxis, width);
     }
 }
 
@@ -4938,7 +4900,6 @@ vadjustment_value_changed (GtkAdjustment *adjustment,
 
   if ( ! GTK_WIDGET_REALIZED (sheet)) return;
 
-
   gtk_widget_hide (sheet->entry_widget);
 
   region =
@@ -4946,12 +4907,14 @@ vadjustment_value_changed (GtkAdjustment *adjustment,
 
   gdk_window_begin_paint_region (sheet->sheet_window, region);
 
+  draw_sheet_region (sheet, region);
 
-  gtk_sheet_range_draw (sheet, NULL);
   draw_row_title_buttons (sheet);
   //  size_allocate_global_button (sheet);
+  gtk_sheet_draw_active_cell (sheet);
 
   gdk_window_end_paint (sheet->sheet_window);
+  gdk_region_destroy (region);
 }
 
 
@@ -4974,11 +4937,16 @@ hadjustment_value_changed (GtkAdjustment *adjustment,
 
   gdk_window_begin_paint_region (sheet->sheet_window, region);
 
-  gtk_sheet_range_draw (sheet, NULL);
+  draw_sheet_region (sheet, region);
+
   draw_column_title_buttons (sheet);
   //  size_allocate_global_button (sheet);
 
+  gtk_sheet_draw_active_cell (sheet);
+
   gdk_window_end_paint (sheet->sheet_window);
+
+  gdk_region_destroy (region);
 }
 
 
@@ -4991,7 +4959,6 @@ draw_xor_vline (GtkSheet *sheet)
   gdk_drawable_get_size (sheet->sheet_window,
 			 NULL, &height);
 
-
   if (sheet->row_titles_visible)
     xpos += sheet->row_title_area.width;
 
@@ -5032,11 +4999,11 @@ draw_xor_rectangle (GtkSheet *sheet, GtkSheetRange range)
   GdkRectangle clip_area, area;
   GdkGCValues values;
 
-  area.x = psppire_axis_pixel_start (sheet->haxis, range.col0);
-  area.y = psppire_axis_pixel_start (sheet->vaxis, range.row0);
-  area.width = psppire_axis_pixel_start (sheet->haxis, range.coli)- area.x+
+  area.x = psppire_axis_start_pixel (sheet->haxis, range.col0);
+  area.y = psppire_axis_start_pixel (sheet->vaxis, range.row0);
+  area.width = psppire_axis_start_pixel (sheet->haxis, range.coli)- area.x+
     psppire_axis_unit_size (sheet->haxis, range.coli);
-  area.height = psppire_axis_pixel_start (sheet->vaxis, range.rowi)- area.y +
+  area.height = psppire_axis_start_pixel (sheet->vaxis, range.rowi)- area.y +
     psppire_axis_unit_size (sheet->vaxis, range.rowi);
 
   clip_area.x = sheet->row_title_area.width;
@@ -5083,123 +5050,47 @@ draw_xor_rectangle (GtkSheet *sheet, GtkSheetRange range)
 }
 
 
-/* this function returns the new width of the column being resized given
- * the COLUMN and X position of the cursor; the x cursor position is passed
- * in as a pointer and automaticaly corrected if it's outside the acceptable
- * range */
-static guint
-new_column_width (GtkSheet *sheet, gint column, gint *x)
-{
-  gint left_pos = psppire_axis_pixel_start (sheet->haxis, column)
-    - sheet->hadjustment->value;
-
-  gint width = *x - left_pos;
-
-  if ( width < sheet->column_requisition)
-    {
-      width = sheet->column_requisition;
-      *x = left_pos + width;
-    }
-
-#if AXIS_TRANSITION
-  g_sheet_column_set_width (sheet->column_geometry, column, width);
-#endif
-
-  draw_column_title_buttons (sheet);
-
-  return width;
-}
-
-/* this function returns the new height of the row being resized given
- * the row and y position of the cursor; the y cursor position is passed
- * in as a pointer and automaticaly corrected if it's beyond min / max limits */
-static guint
-new_row_height (GtkSheet *sheet, gint row, gint *y)
-{
-  gint height;
-  guint min_height;
-
-  gint cy = *y;
-  min_height = sheet->row_requisition;
-
-  /* you can't shrink a row to less than its minimum height */
-  if (cy < psppire_axis_pixel_start (sheet->vaxis, row) + min_height)
-
-    {
-      *y = cy = psppire_axis_pixel_start (sheet->vaxis, row) + min_height;
-    }
-
-  /* calculate new row height making sure it doesn't end up
-   * less than the minimum height */
-  height = (cy - psppire_axis_pixel_start (sheet->vaxis, row));
-  if (height < min_height)
-    height = min_height;
-
-#if AXIS_TRANSITION
-  g_sheet_row_set_height (sheet->row_geometry, row, height);
-#endif
-  draw_row_title_buttons (sheet);
-
-  return height;
-}
-
 static void
-gtk_sheet_set_column_width (GtkSheet *sheet,
-			    gint column,
-			    guint width)
+set_column_width (GtkSheet *sheet,
+		  gint column,
+		  gint width)
 {
-  guint min_width;
-
   g_return_if_fail (sheet != NULL);
   g_return_if_fail (GTK_IS_SHEET (sheet));
 
   if (column < 0 || column >= psppire_axis_unit_count (sheet->haxis))
     return;
 
-  gtk_sheet_column_size_request (sheet, column, &min_width);
-  if (width < min_width) return;
-
-#if AXIS_TRANSITION
-  g_sheet_column_set_width (sheet->column_geometry, column, width);
-#endif
+  psppire_axis_resize (sheet->haxis, column, width);
 
   if (GTK_WIDGET_REALIZED (GTK_WIDGET (sheet)))
     {
       draw_column_title_buttons (sheet);
       adjust_scrollbars (sheet);
       gtk_sheet_size_allocate_entry (sheet);
-      gtk_sheet_range_draw (sheet, NULL);
+      redraw_range (sheet, NULL);
     }
 }
 
-
-
 static void
-gtk_sheet_set_row_height (GtkSheet *sheet,
-			  gint row,
-			  guint height)
+set_row_height (GtkSheet *sheet,
+		gint row,
+		gint height)
 {
-  guint min_height;
-
   g_return_if_fail (sheet != NULL);
   g_return_if_fail (GTK_IS_SHEET (sheet));
 
   if (row < 0 || row >= psppire_axis_unit_count (sheet->vaxis))
     return;
 
-  gtk_sheet_row_size_request (sheet, row, &min_height);
-  if (height < min_height) return;
-
-#if AXIS_TRANSITION
-  g_sheet_row_set_height (sheet->row_geometry, row, height);
-#endif
+  psppire_axis_resize (sheet->vaxis, row, height);
 
   if (GTK_WIDGET_REALIZED (GTK_WIDGET (sheet)) )
     {
       draw_row_title_buttons (sheet);
       adjust_scrollbars (sheet);
       gtk_sheet_size_allocate_entry (sheet);
-      gtk_sheet_range_draw (sheet, NULL);
+      redraw_range (sheet, NULL);
     }
 }
 
@@ -5209,8 +5100,6 @@ gtk_sheet_get_attributes (const GtkSheet *sheet, gint row, gint col,
 {
   GdkColor *fg, *bg;
   const GtkJustification *j ;
-  const PangoFontDescription *font_desc ;
-  const GtkSheetCellBorder *border ;
   GdkColormap *colormap;
 
   g_return_val_if_fail (sheet != NULL, FALSE);
@@ -5227,11 +5116,8 @@ gtk_sheet_get_attributes (const GtkSheet *sheet, gint row, gint col,
   attr->border.join_style = GDK_JOIN_MITER;
   attr->border.mask = 0;
   attr->border.color = GTK_WIDGET (sheet)->style->black;
-  attr->font_desc = GTK_WIDGET (sheet)->style->font_desc;
 
   attr->is_editable = g_sheet_model_is_editable (sheet->model, row, col);
-  attr->is_visible = g_sheet_model_is_visible (sheet->model, row, col);
-
 
   colormap = gtk_widget_get_colormap (GTK_WIDGET (sheet));
   fg = g_sheet_model_get_foreground (sheet->model, row, col);
@@ -5255,13 +5141,6 @@ gtk_sheet_get_attributes (const GtkSheet *sheet, gint row, gint col,
   if (j)
     attr->justification = *j;
 
-  font_desc = g_sheet_model_get_font_desc (sheet->model, row, col);
-  if ( font_desc ) attr->font_desc = font_desc;
-
-  border = g_sheet_model_get_cell_border (sheet->model, row, col);
-
-  if ( border ) attr->border = *border;
-
   return TRUE;
 }
 
@@ -5286,43 +5165,6 @@ gtk_sheet_button_size_request	 (GtkSheet *sheet,
 
 }
 
-static void
-gtk_sheet_row_size_request (GtkSheet *sheet,
-			    gint row,
-			    guint *requisition)
-{
-  GtkRequisition button_requisition;
-
-  gtk_sheet_button_size_request (sheet,
-				 g_sheet_model_get_row_button (sheet->model, row),
-				 &button_requisition);
-
-  *requisition = button_requisition.height;
-
-  sheet->row_requisition = *requisition;
-}
-
-static void
-gtk_sheet_column_size_request (GtkSheet *sheet,
-			       gint col,
-			       guint *requisition)
-{
-  GtkRequisition button_requisition;
-
-  GtkSheetButton *button = g_sheet_model_get_column_button (sheet->model, col);
-
-  gtk_sheet_button_size_request (sheet,
-				 button,
-				 &button_requisition);
-
-  gtk_sheet_button_free (button);
-
-  *requisition = button_requisition.width;
-
-  sheet->column_requisition = *requisition;
-}
-
-
 static void
 gtk_sheet_forall (GtkContainer *container,
 		  gboolean include_internals,
@@ -5336,8 +5178,8 @@ gtk_sheet_forall (GtkContainer *container,
   if (sheet->button && sheet->button->parent)
     (* callback) (sheet->button, callback_data);
 
-  if (sheet->entry_container && GTK_IS_CONTAINER (sheet->entry_container))
-    (* callback) (sheet->entry_container, callback_data);
+  if (sheet->entry_widget && GTK_IS_CONTAINER (sheet->entry_widget))
+    (* callback) (sheet->entry_widget, callback_data);
 }
 
 
@@ -5392,7 +5234,7 @@ range_to_text (const GtkSheet *sheet)
   gint r, c;
   GString *string;
 
-  if ( !gtk_sheet_range_isvisible (sheet, sheet->range))
+  if ( !gtk_sheet_range_isvisible (sheet, &sheet->range))
     return NULL;
 
   string = g_string_sized_new (80);
@@ -5418,7 +5260,7 @@ range_to_html (const GtkSheet *sheet)
   gint r, c;
   GString *string;
 
-  if ( !gtk_sheet_range_isvisible (sheet, sheet->range))
+  if ( !gtk_sheet_range_isvisible (sheet, &sheet->range))
     return NULL;
 
   string = g_string_sized_new (480);
@@ -5509,7 +5351,7 @@ gtk_sheet_update_primary_selection (GtkSheet *sheet)
   clipboard = gtk_widget_get_clipboard (GTK_WIDGET (sheet),
 					GDK_SELECTION_PRIMARY);
 
-  if (gtk_sheet_range_isvisible (sheet, sheet->range))
+  if (gtk_sheet_range_isvisible (sheet, &sheet->range))
     {
       if (!gtk_clipboard_set_with_owner (clipboard, targets,
 					 G_N_ELEMENTS (targets),