X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;ds=sidebyside;f=lib%2Fgtksheet%2Fgtksheet.c;h=9f26115cecf19b01609a72b804cd8da8374f9aaf;hb=5e1469fde0a9b5bd3fefe52d7d8379b7379a618b;hp=b43f6c47af5cdc03712f4a2f6cdd0dbd0c56db3d;hpb=d6e7bc1cc6bdab22fe4e51df5cfe759628936e31;p=pspp-builds.git

diff --git a/lib/gtksheet/gtksheet.c b/lib/gtksheet/gtksheet.c
index b43f6c47..9f26115c 100644
--- a/lib/gtksheet/gtksheet.c
+++ b/lib/gtksheet/gtksheet.c
@@ -1,3 +1,7 @@
+#define GDK_MULTIHEAD_SAFE 1
+#define GLIB_DISABLE_DEPRECATED 1
+#define GDK_DISABLE_DEPRECATED 1
+#define GTK_DISABLE_DEPRECATED 1
 /*
  * Copyright (C) 2006, 2008 Free Software Foundation
  *
@@ -51,7 +55,6 @@
 #include <gtk/gtktypeutils.h>
 #include <gtk/gtkentry.h>
 #include <gtk/gtkcontainer.h>
-#include <gtk/gtkpixmap.h>
 #include <pango/pango.h>
 #include "gtkitementry.h"
 #include "gtksheet.h"
@@ -92,12 +95,16 @@ static void gtk_sheet_column_title_button_draw (GtkSheet *sheet, gint column);
 
 static void gtk_sheet_row_title_button_draw (GtkSheet *sheet, gint row);
 
-
-static gboolean gtk_sheet_cell_empty (const GtkSheet *, gint, gint);
+static void gtk_sheet_set_row_height (GtkSheet *sheet,
+				      gint row,
+				      guint height);
 
 static void destroy_hover_window (GtkSheetHoverTitle *);
 static GtkSheetHoverTitle *create_hover_window (void);
 
+static GtkStateType gtk_sheet_cell_get_state (GtkSheet *sheet, gint row, gint col);
+
+
 static inline  void
 dispose_string (const GtkSheet *sheet, gchar *text)
 {
@@ -110,10 +117,12 @@ dispose_string (const GtkSheet *sheet, gchar *text)
     g_free (text);
 }
 
-static inline
-guint DEFAULT_ROW_HEIGHT (GtkWidget *widget)
+static guint
+default_row_height (const GtkSheet *sheet)
 {
-  if (!widget->style->font_desc) return 24;
+  GtkWidget *widget = GTK_WIDGET (sheet);
+
+  if (!widget->style->font_desc) return 25;
   else
     {
       PangoContext *context = gtk_widget_get_pango_context (widget);
@@ -131,24 +140,7 @@ guint DEFAULT_ROW_HEIGHT (GtkWidget *widget)
     }
 }
 
-static inline
-guint DEFAULT_FONT_ASCENT (GtkWidget *widget)
-{
-  if (!widget->style->font_desc) return 12;
-  else
-    {
-      PangoContext *context = gtk_widget_get_pango_context (widget);
-      PangoFontMetrics *metrics =
-	pango_context_get_metrics (context,
-				   widget->style->font_desc,
-				   pango_context_get_language (context));
-      guint val = pango_font_metrics_get_ascent (metrics);
-      pango_font_metrics_unref (metrics);
-      return PANGO_PIXELS (val);
-    }
-}
-
-static inline
+static
 guint STRING_WIDTH (GtkWidget *widget,
 		    const PangoFontDescription *font, const gchar *text)
 {
@@ -164,58 +156,41 @@ guint STRING_WIDTH (GtkWidget *widget,
   return PANGO_PIXELS (rect.width);
 }
 
-static inline
-guint DEFAULT_FONT_DESCENT (GtkWidget *widget)
-{
-  if (!widget->style->font_desc) return 12;
-  else
-    {
-      PangoContext *context = gtk_widget_get_pango_context (widget);
-      PangoFontMetrics *metrics =
-	pango_context_get_metrics (context,
-				   widget->style->font_desc,
-				   pango_context_get_language (context));
-      guint val = pango_font_metrics_get_descent (metrics);
-      pango_font_metrics_unref (metrics);
-      return PANGO_PIXELS (val);
-    }
-}
-
-
 /* Return the row containing pixel Y */
 static gint
 yyy_row_ypixel_to_row (const GtkSheet *sheet, gint y)
 {
   GSheetRow *geo = sheet->row_geometry;
 
-  if (y < 0) return -1;
+  if (y < 0)
+    {
+      g_error ("This shouldnt happen");
+      return -1;
+    }
 
   return g_sheet_row_pixel_to_row (geo, y);
 }
 
 
-#define MIN_VISIBLE_ROW(sheet) yyy_row_ypixel_to_row (sheet, sheet->vadjustment->value)
-
-#define MAX_VISIBLE_ROW(sheet) \
-    yyy_row_ypixel_to_row (sheet, sheet->vadjustment->value + sheet->vadjustment->page_size)
-
-#define MIN_VISIBLE_COLUMN(sheet) COLUMN_FROM_XPIXEL (sheet, sheet->hadjustment->value)
+static inline glong
+min_visible_row (const GtkSheet *sheet)
+{
+  return yyy_row_ypixel_to_row (sheet, sheet->vadjustment->value);
+}
 
-#define MAX_VISIBLE_COLUMN(sheet) \
-    COLUMN_FROM_XPIXEL (sheet, sheet->hadjustment->value + sheet->hadjustment->page_size)
 
-/* gives the left pixel of the given column in context of
- * the sheet's hoffset */
-static inline gint
-COLUMN_LEFT_XPIXEL (const GtkSheet *sheet, gint ncol)
+static inline glong
+max_visible_row (const GtkSheet *sheet)
 {
-  return g_sheet_column_start_pixel (sheet->column_geometry, ncol);
+  return yyy_row_ypixel_to_row (sheet,
+			   sheet->vadjustment->value +
+			   sheet->vadjustment->page_size);
 }
 
 
 /* returns the column index from a x pixel location */
 static inline gint
-COLUMN_FROM_XPIXEL (const GtkSheet *sheet, gint x)
+column_from_xpixel (const GtkSheet *sheet, gint x)
 {
   gint i;
   gint cx = 0;
@@ -225,17 +200,33 @@ COLUMN_FROM_XPIXEL (const GtkSheet *sheet, gint x)
        i < g_sheet_column_get_column_count (sheet->column_geometry); i++)
     {
       if (x >= cx &&
-	  x <= (cx + g_sheet_column_get_width (sheet->column_geometry, i)) &&
-	  g_sheet_column_get_visibility (sheet->column_geometry, i))
+	  x <= (cx + g_sheet_column_get_width (sheet->column_geometry, i)))
 	return i;
-      if ( g_sheet_column_get_visibility (sheet->column_geometry, i))
-	cx += g_sheet_column_get_width (sheet->column_geometry, i);
+
+      cx += g_sheet_column_get_width (sheet->column_geometry, i);
     }
 
   /* no match */
   return g_sheet_column_get_column_count (sheet->column_geometry) - 1;
 }
 
+
+static inline glong
+min_visible_column (const GtkSheet *sheet)
+{
+  return column_from_xpixel (sheet, sheet->hadjustment->value);
+}
+
+
+static inline glong
+max_visible_column (const GtkSheet *sheet)
+{
+  return column_from_xpixel (sheet,
+			     sheet->hadjustment->value +
+			     sheet->hadjustment->page_size);
+}
+
+
 /* The size of the region (in pixels) around the row/column boundaries
    where the height/width may be grabbed to change size */
 #define DRAG_WIDTH 6
@@ -247,15 +238,15 @@ on_column_boundary (const GtkSheet *sheet, gint x, gint *column)
 
   x += sheet->hadjustment->value;
 
-  col = COLUMN_FROM_XPIXEL (sheet, x);
+  col = column_from_xpixel (sheet, x);
 
-  if ( COLUMN_FROM_XPIXEL (sheet, x - DRAG_WIDTH / 2) < col )
-{
+  if ( column_from_xpixel (sheet, x - DRAG_WIDTH / 2) < col )
+    {
       *column = col - 1;
       return TRUE;
-}
+    }
 
-  if  ( COLUMN_FROM_XPIXEL (sheet, x + DRAG_WIDTH / 2) > col )
+  if  ( column_from_xpixel (sheet, x + DRAG_WIDTH / 2) > col )
     {
       *column = col;
       return TRUE;
@@ -276,7 +267,6 @@ POSSIBLE_YDRAG (const GtkSheet *sheet, gint y, gint *drag_row)
   ydrag = g_sheet_row_start_pixel (sheet->row_geometry, row) + CELL_SPACING;
   if (y <= ydrag + DRAG_WIDTH / 2 && row != 0)
     {
-      while (!g_sheet_row_get_visibility (sheet->row_geometry, row - 1) && row > 0) row--;
       *drag_row = row - 1;
       return g_sheet_row_get_sensitivity (sheet->row_geometry, row - 1);
     }
@@ -300,11 +290,11 @@ POSSIBLE_DRAG (const GtkSheet *sheet, gint x, gint y,
        sheet->range.col0 < 0 || sheet->range.coli < 0 )
     return FALSE;
 
-  *drag_column = COLUMN_FROM_XPIXEL (sheet, x);
+  *drag_column = column_from_xpixel (sheet, x);
   *drag_row = yyy_row_ypixel_to_row (sheet, y);
 
-  if (x >= COLUMN_LEFT_XPIXEL (sheet, sheet->range.col0) - DRAG_WIDTH / 2 &&
-      x <= COLUMN_LEFT_XPIXEL (sheet, sheet->range.coli) +
+  if (x >= g_sheet_column_start_pixel (sheet->column_geometry, sheet->range.col0) - DRAG_WIDTH / 2 &&
+      x <= g_sheet_column_start_pixel (sheet->column_geometry, sheet->range.coli) +
       g_sheet_column_get_width (sheet->column_geometry, sheet->range.coli) + DRAG_WIDTH / 2)
     {
       ydrag = g_sheet_row_start_pixel (sheet->row_geometry, sheet->range.row0);
@@ -326,13 +316,13 @@ POSSIBLE_DRAG (const GtkSheet *sheet, gint x, gint y,
       y <= g_sheet_row_start_pixel (sheet->row_geometry, sheet->range.rowi) +
       g_sheet_row_get_height (sheet->row_geometry, sheet->range.rowi) + DRAG_WIDTH / 2)
     {
-      xdrag = COLUMN_LEFT_XPIXEL (sheet, sheet->range.col0);
+      xdrag = g_sheet_column_start_pixel (sheet->column_geometry, sheet->range.col0);
       if (x >= xdrag - DRAG_WIDTH / 2 && x <= xdrag + DRAG_WIDTH / 2)
 	{
 	  *drag_column = sheet->range.col0;
 	  return TRUE;
 	}
-      xdrag = COLUMN_LEFT_XPIXEL (sheet, sheet->range.coli) +
+      xdrag = g_sheet_column_start_pixel (sheet->column_geometry, sheet->range.coli) +
 	g_sheet_column_get_width (sheet->column_geometry, sheet->range.coli);
       if (x >= xdrag - DRAG_WIDTH / 2 && x <= xdrag + DRAG_WIDTH / 2)
 	{
@@ -355,19 +345,19 @@ POSSIBLE_RESIZE (const GtkSheet *sheet, gint x, gint y,
        sheet->range.col0 < 0 || sheet->range.coli < 0 )
     return FALSE;
 
-  xdrag = COLUMN_LEFT_XPIXEL (sheet, sheet->range.coli)+
+  xdrag = g_sheet_column_start_pixel (sheet->column_geometry, sheet->range.coli)+
     g_sheet_column_get_width (sheet->column_geometry, sheet->range.coli);
 
   ydrag = g_sheet_row_start_pixel (sheet->row_geometry, sheet->range.rowi) +
     g_sheet_row_get_height (sheet->row_geometry, sheet->range.rowi);
 
   if (sheet->state == GTK_SHEET_COLUMN_SELECTED)
-    ydrag = g_sheet_row_start_pixel (sheet->row_geometry, MIN_VISIBLE_ROW (sheet));
+    ydrag = g_sheet_row_start_pixel (sheet->row_geometry, min_visible_row (sheet));
 
   if (sheet->state == GTK_SHEET_ROW_SELECTED)
-    xdrag = COLUMN_LEFT_XPIXEL (sheet, MIN_VISIBLE_COLUMN (sheet));
+    xdrag = g_sheet_column_start_pixel (sheet->column_geometry, min_visible_column (sheet));
 
-  *drag_column = COLUMN_FROM_XPIXEL (sheet, x);
+  *drag_column = column_from_xpixel (sheet, x);
   *drag_row = yyy_row_ypixel_to_row (sheet, y);
 
   if (x >= xdrag - DRAG_WIDTH / 2 && x <= xdrag + DRAG_WIDTH / 2 &&
@@ -376,18 +366,64 @@ POSSIBLE_RESIZE (const GtkSheet *sheet, gint x, gint y,
   return FALSE;
 }
 
-static void gtk_sheet_class_init 		 (GtkSheetClass * klass);
-static void gtk_sheet_init 			 (GtkSheet * sheet);
-static void gtk_sheet_dispose 			 (GObject * object);
-static void gtk_sheet_finalize 			 (GObject * object);
+
+static gboolean
+rectangle_from_range (GtkSheet *sheet, const GtkSheetRange *range,
+		      GdkRectangle *r)
+{
+  g_return_val_if_fail (range, FALSE);
+
+  r->x = g_sheet_column_start_pixel (sheet->column_geometry, range->col0);
+  r->x -= sheet->hadjustment->value;
+
+  if ( sheet->row_titles_visible)
+    r->x += sheet->row_title_area.width;
+
+
+  r->y = g_sheet_row_start_pixel (sheet->row_geometry, range->row0);
+  r->y -= sheet->vadjustment->value;
+
+  if ( sheet->column_titles_visible)
+    r->y += sheet->column_title_area.height;
+
+  r->width = g_sheet_column_start_pixel (sheet->column_geometry, range->coli) -
+    g_sheet_column_start_pixel (sheet->column_geometry, range->col0) +
+    g_sheet_column_get_width (sheet->column_geometry, range->coli);
+
+  r->height = g_sheet_row_start_pixel (sheet->row_geometry, range->rowi) -
+    g_sheet_row_start_pixel (sheet->row_geometry, range->row0) +
+    g_sheet_row_get_height (sheet->row_geometry, range->rowi);
+
+  return TRUE;
+}
+
+static gboolean
+rectangle_from_cell (GtkSheet *sheet, gint row, gint col,
+		     GdkRectangle *r)
+{
+  GtkSheetRange range;
+  g_return_val_if_fail (row >= 0, FALSE);
+  g_return_val_if_fail (col >= 0, FALSE);
+
+  range.row0 = range.rowi = row;
+  range.col0 = range.coli = col;
+
+  return rectangle_from_range (sheet, &range, r);
+}
+
+
+static void gtk_sheet_class_init 		 (GtkSheetClass *klass);
+static void gtk_sheet_init 			 (GtkSheet *sheet);
+static void gtk_sheet_dispose 			 (GObject *object);
+static void gtk_sheet_finalize 			 (GObject *object);
 static void gtk_sheet_style_set 		 (GtkWidget *widget,
 						  GtkStyle *previous_style);
-static void gtk_sheet_realize 			 (GtkWidget * widget);
-static void gtk_sheet_unrealize 		 (GtkWidget * widget);
-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_realize 			 (GtkWidget *widget);
+static void gtk_sheet_unrealize 		 (GtkWidget *widget);
+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,
@@ -397,33 +433,33 @@ static void gtk_sheet_set_scroll_adjustments	 (GtkSheet *sheet,
 						  GtkAdjustment *hadjustment,
 						  GtkAdjustment *vadjustment);
 
-static gint gtk_sheet_button_press 		 (GtkWidget * widget,
-						  GdkEventButton * event);
-static gint gtk_sheet_button_release 		 (GtkWidget * widget,
-						  GdkEventButton * event);
-static gint gtk_sheet_motion 			 (GtkWidget * widget,
-						  GdkEventMotion * event);
+static gint gtk_sheet_button_press 		 (GtkWidget *widget,
+						  GdkEventButton *event);
+static gint gtk_sheet_button_release 		 (GtkWidget *widget,
+						  GdkEventButton *event);
+static gint gtk_sheet_motion 			 (GtkWidget *widget,
+						  GdkEventMotion *event);
 static gboolean gtk_sheet_crossing_notify           (GtkWidget *widget,
 						     GdkEventCrossing *event);
 static gint gtk_sheet_entry_key_press		 (GtkWidget *widget,
 						  GdkEventKey *key);
-static gint gtk_sheet_key_press			 (GtkWidget *widget,
+static gboolean gtk_sheet_key_press		 (GtkWidget *widget,
 						  GdkEventKey *key);
-static void gtk_sheet_size_request 		 (GtkWidget * widget,
-						  GtkRequisition * requisition);
-static void gtk_sheet_size_allocate 		 (GtkWidget * widget,
-						  GtkAllocation * allocation);
+static void gtk_sheet_size_request 		 (GtkWidget *widget,
+						  GtkRequisition *requisition);
+static void gtk_sheet_size_allocate 		 (GtkWidget *widget,
+						  GtkAllocation *allocation);
 
 /* Sheet queries */
 
-static gboolean gtk_sheet_range_isvisible (const GtkSheet * sheet,
+static gboolean gtk_sheet_range_isvisible (const GtkSheet *sheet,
 					   GtkSheetRange range);
-static gboolean gtk_sheet_cell_isvisible  (GtkSheet * sheet,
+static gboolean gtk_sheet_cell_isvisible  (GtkSheet *sheet,
 					   gint row, gint column);
 /* Drawing Routines */
 
 /* draw cell background and frame */
-static void gtk_sheet_cell_draw_default 	 (GtkSheet *sheet,
+static void gtk_sheet_cell_draw_bg 	 (GtkSheet *sheet,
 						  gint row, gint column);
 
 /* draw cell contents */
@@ -431,8 +467,8 @@ static void gtk_sheet_cell_draw_label 		 (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);
+static void gtk_sheet_range_draw (GtkSheet *sheet,
+				  const GtkSheetRange *range);
 
 /* highlight the visible part of the selected range */
 static void gtk_sheet_range_draw_selection	 (GtkSheet *sheet,
@@ -442,10 +478,10 @@ static void gtk_sheet_range_draw_selection	 (GtkSheet *sheet,
 
 static gboolean gtk_sheet_move_query   		 (GtkSheet *sheet,
 						  gint row, gint column);
-static void gtk_sheet_real_select_range 	 (GtkSheet * sheet,
-						  const GtkSheetRange * range);
-static void gtk_sheet_real_unselect_range 	 (GtkSheet * sheet,
-						  const GtkSheetRange * range);
+static void gtk_sheet_real_select_range 	 (GtkSheet *sheet,
+						  const GtkSheetRange *range);
+static void gtk_sheet_real_unselect_range 	 (GtkSheet *sheet,
+						  const GtkSheetRange *range);
 static void gtk_sheet_extend_selection		 (GtkSheet *sheet,
 						  gint row, gint column);
 static void gtk_sheet_new_selection		 (GtkSheet *sheet,
@@ -463,37 +499,31 @@ static gboolean gtk_sheet_activate_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 void gtk_sheet_click_cell		 (GtkSheet *sheet,
+static gboolean gtk_sheet_click_cell		 (GtkSheet *sheet,
 						  gint row,
-						  gint column,
-						  gboolean *veto);
-
-/* Backing Pixmap */
+						  gint column);
 
-static void gtk_sheet_make_backing_pixmap 	 (GtkSheet *sheet);
 
-static void gtk_sheet_draw_backing_pixmap	 (GtkSheet *sheet,
-						  GtkSheetRange range);
 /* Scrollbars */
 
-static void adjust_scrollbars 			 (GtkSheet * sheet);
-static void vadjustment_value_changed 		 (GtkAdjustment * adjustment,
+static void adjust_scrollbars 			 (GtkSheet *sheet);
+static void vadjustment_value_changed 		 (GtkAdjustment *adjustment,
 						  gpointer data);
-static void hadjustment_value_changed 		 (GtkAdjustment * adjustment,
+static void hadjustment_value_changed 		 (GtkAdjustment *adjustment,
 						  gpointer data);
 
 
-static void draw_xor_vline 			 (GtkSheet * sheet);
-static void draw_xor_hline 			 (GtkSheet * sheet);
+static void draw_xor_vline 			 (GtkSheet *sheet);
+static void draw_xor_hline 			 (GtkSheet *sheet);
 static void draw_xor_rectangle			 (GtkSheet *sheet,
 						  GtkSheetRange range);
 
-static guint new_column_width 			 (GtkSheet * sheet,
+static guint new_column_width 			 (GtkSheet *sheet,
 						  gint column,
-						  gint * x);
-static guint new_row_height 			 (GtkSheet * sheet,
+						  gint *x);
+static guint new_row_height 			 (GtkSheet *sheet,
 						  gint row,
-						  gint * y);
+						  gint *y);
 /* Sheet Button */
 
 static void create_global_button		 (GtkSheet *sheet);
@@ -507,8 +537,8 @@ static void gtk_sheet_entry_set_max_size	 (GtkSheet *sheet);
 
 /* Sheet button gadgets */
 
-static void size_allocate_column_title_buttons 	 (GtkSheet * sheet);
-static void size_allocate_row_title_buttons 	 (GtkSheet * sheet);
+static void size_allocate_column_title_buttons 	 (GtkSheet *sheet);
+static void size_allocate_row_title_buttons 	 (GtkSheet *sheet);
 
 
 static void size_allocate_global_button 	 (GtkSheet *sheet);
@@ -516,16 +546,6 @@ static void gtk_sheet_button_size_request	 (GtkSheet *sheet,
 						  const GtkSheetButton *button,
 						  GtkRequisition *requisition);
 
-/* Attributes routines */
-static void init_attributes			 (const GtkSheet *sheet,
-						  gint col,
-						  GtkSheetCellAttr *attributes);
-
-
-/* Memory allocation routines */
-static void gtk_sheet_real_range_clear 		 (GtkSheet *sheet,
-						  const GtkSheetRange *range);
-
 static void gtk_sheet_real_cell_clear 		 (GtkSheet *sheet,
 						  gint row,
 						  gint column);
@@ -540,10 +560,6 @@ static void gtk_sheet_row_size_request (GtkSheet *sheet,
 
 
 /* Signals */
-
-extern void
-_gtkextra_signal_emit (GtkObject *object, guint signal_id, ...);
-
 enum
   {
     SELECT_ROW,
@@ -722,7 +738,7 @@ gtk_sheet_get_property (GObject         *object,
 
 
 static void
-gtk_sheet_class_init (GtkSheetClass * klass)
+gtk_sheet_class_init (GtkSheetClass *klass)
 {
   GObjectClass *object_class = G_OBJECT_CLASS (klass);
 
@@ -1027,7 +1043,7 @@ gtk_sheet_init (GtkSheet *sheet)
   sheet->column_title_area.x = 0;
   sheet->column_title_area.y = 0;
   sheet->column_title_area.width = 0;
-  sheet->column_title_area.height = DEFAULT_ROW_HEIGHT (GTK_WIDGET (sheet));
+  sheet->column_title_area.height = default_row_height (sheet);
 
   sheet->row_title_window = NULL;
   sheet->row_title_area.x = 0;
@@ -1041,8 +1057,6 @@ gtk_sheet_init (GtkSheet *sheet)
   sheet->selection_cell.row = 0;
   sheet->selection_cell.col = 0;
 
-  sheet->pixmap = NULL;
-
   sheet->range.row0 = 0;
   sheet->range.rowi = 0;
   sheet->range.col0 = 0;
@@ -1051,8 +1065,6 @@ gtk_sheet_init (GtkSheet *sheet)
   sheet->state = GTK_SHEET_NORMAL;
 
   sheet->sheet_window = NULL;
-  sheet->sheet_window_width = 0;
-  sheet->sheet_window_height = 0;
   sheet->entry_widget = NULL;
   sheet->entry_container = NULL;
   sheet->button = NULL;
@@ -1078,8 +1090,6 @@ gtk_sheet_init (GtkSheet *sheet)
   sheet->row_title_area.width = DEFAULT_COLUMN_WIDTH;
 
   sheet->column_titles_visible = TRUE;
-  sheet->autoscroll = TRUE;
-  sheet->justify_entry = TRUE;
 
 
   /* create sheet entry */
@@ -1117,7 +1127,7 @@ columns_inserted_deleted_callback (GSheetModel *model, gint first_column,
   if (sheet->active_cell.col >= model_columns)
     gtk_sheet_activate_cell (sheet, sheet->active_cell.row, model_columns - 1);
 
-  for (i = first_column; i <= MAX_VISIBLE_COLUMN (sheet); i++)
+  for (i = first_column; i <= max_visible_column (sheet); i++)
     gtk_sheet_column_title_button_draw (sheet, i);
 
   gtk_sheet_range_draw (sheet, &range);
@@ -1149,7 +1159,7 @@ rows_inserted_deleted_callback (GSheetModel *model, gint first_row,
   if (sheet->active_cell.row >= model_rows)
     gtk_sheet_activate_cell (sheet, model_rows - 1, sheet->active_cell.col);
 
-  for (i = first_row; i <= MAX_VISIBLE_ROW (sheet); i++)
+  for (i = first_row; i <= max_visible_row (sheet); i++)
     gtk_sheet_row_title_button_draw (sheet, i);
 
   gtk_sheet_range_draw (sheet, &range);
@@ -1172,10 +1182,10 @@ range_update_callback (GSheetModel *m, gint row0, gint col0,
   range.rowi = rowi;
   range.coli = coli;
 
-  if ( MAX_VISIBLE_ROW (sheet) >
+  if ( max_visible_row (sheet) >
        g_sheet_model_get_row_count (sheet->model)
        ||
-       MAX_VISIBLE_COLUMN (sheet) >
+       max_visible_column (sheet) >
        g_sheet_model_get_column_count (sheet->model))
     {
       gtk_sheet_move_query (sheet, 0, 0);
@@ -1187,24 +1197,24 @@ range_update_callback (GSheetModel *m, gint row0, gint col0,
       gtk_sheet_range_draw (sheet, NULL);
       adjust_scrollbars (sheet);
 
-      for (i = MIN_VISIBLE_ROW (sheet); i <= MAX_VISIBLE_ROW (sheet); i++)
+      for (i = min_visible_row (sheet); i <= max_visible_row (sheet); i++)
 	gtk_sheet_row_title_button_draw (sheet, i);
 
-      for (i = MIN_VISIBLE_COLUMN (sheet);
-	   i <= MAX_VISIBLE_COLUMN (sheet); i++)
+      for (i = min_visible_column (sheet);
+	   i <= max_visible_column (sheet); i++)
 	gtk_sheet_column_title_button_draw (sheet, i);
 
       return;
     }
   else if ( row0 < 0 || rowi < 0 )
     {
-      range.row0 = MIN_VISIBLE_ROW (sheet);
-      range.rowi = MAX_VISIBLE_ROW (sheet);
+      range.row0 = min_visible_row (sheet);
+      range.rowi = max_visible_row (sheet);
     }
   else if ( col0 < 0 || coli < 0 )
     {
-      range.col0 = MIN_VISIBLE_COLUMN (sheet);
-      range.coli = MAX_VISIBLE_COLUMN (sheet);
+      range.col0 = min_visible_column (sheet);
+      range.coli = max_visible_column (sheet);
     }
 
   gtk_sheet_range_draw (sheet, &range);
@@ -1275,8 +1285,8 @@ gtk_sheet_set_model (GtkSheet *sheet, GSheetModel *model)
 
 /* Call back for when the column titles have changed.
    FIRST is the first column changed.
-   N_COLUMNS is the number of columns which have changed, or - 1, which
-   indicates that the column has changed to its right - most extremity
+   N_COLUMNS is the number of columns which have changed, or -1, which
+   indicates that the column has changed to its right-most extremity
 */
 static void
 column_titles_changed (GtkWidget *w, gint first, gint n_columns, gpointer data)
@@ -1290,14 +1300,14 @@ column_titles_changed (GtkWidget *w, gint first, gint n_columns, gpointer data)
       n_columns = g_sheet_column_get_column_count (sheet->column_geometry) - 1 ;
     }
 
-    {
-      gint i;
-      for ( i = first ; i <= first + n_columns ; ++i )
-	{
-	  gtk_sheet_column_title_button_draw (sheet, i);
-	  g_signal_emit (sheet, sheet_signals[CHANGED], 0, -1, i);
-	}
-    }
+  {
+    gint i;
+    for ( i = first ; i <= first + n_columns ; ++i )
+      {
+	gtk_sheet_column_title_button_draw (sheet, i);
+	g_signal_emit (sheet, sheet_signals[CHANGED], 0, -1, i);
+      }
+  }
 
   if ( extremity)
     gtk_sheet_column_title_button_draw (sheet, -1);
@@ -1341,7 +1351,7 @@ gtk_sheet_show_grid (GtkSheet *sheet, gboolean show)
 
   sheet->show_grid = show;
 
-    gtk_sheet_range_draw (sheet, NULL);
+  gtk_sheet_range_draw (sheet, NULL);
 }
 
 gboolean
@@ -1362,47 +1372,8 @@ gtk_sheet_get_columns_count (GtkSheet *sheet)
   return g_sheet_column_get_column_count (sheet->column_geometry);
 }
 
-guint
-gtk_sheet_get_rows_count (GtkSheet *sheet)
-{
-  g_return_val_if_fail (sheet != NULL, 0);
-  g_return_val_if_fail (GTK_IS_SHEET (sheet), 0);
-
-  return g_sheet_row_get_row_count (sheet->row_geometry);
-}
-
-void
-gtk_sheet_set_selection_mode (GtkSheet *sheet, gint mode)
-{
-  g_return_if_fail (sheet != NULL);
-  g_return_if_fail (GTK_IS_SHEET (sheet));
-
-  if (GTK_WIDGET_REALIZED (sheet))
-    gtk_sheet_real_unselect_range (sheet, NULL);
-
-  sheet->selection_mode = mode;
-}
-
-void
-gtk_sheet_set_autoresize (GtkSheet *sheet, gboolean autoresize)
-{
-  g_return_if_fail (sheet != NULL);
-  g_return_if_fail (GTK_IS_SHEET (sheet));
-
-  sheet->autoresize = autoresize;
-}
-
-gboolean
-gtk_sheet_autoresize (GtkSheet *sheet)
-{
-  g_return_val_if_fail (sheet != NULL, FALSE);
-  g_return_val_if_fail (GTK_IS_SHEET (sheet), FALSE);
-
-  return sheet->autoresize;
-}
-
 static void
-gtk_sheet_set_column_width (GtkSheet * sheet,
+gtk_sheet_set_column_width (GtkSheet *sheet,
 			    gint column,
 			    guint width);
 
@@ -1444,75 +1415,6 @@ gtk_sheet_autoresize_column (GtkSheet *sheet, gint column)
     }
 }
 
-
-void
-gtk_sheet_set_autoscroll (GtkSheet *sheet, gboolean autoscroll)
-{
-  g_return_if_fail (sheet != NULL);
-  g_return_if_fail (GTK_IS_SHEET (sheet));
-
-  sheet->autoscroll = autoscroll;
-}
-
-gboolean
-gtk_sheet_autoscroll (GtkSheet *sheet)
-{
-  g_return_val_if_fail (sheet != NULL, FALSE);
-  g_return_val_if_fail (GTK_IS_SHEET (sheet), FALSE);
-
-  return sheet->autoscroll;
-}
-
-
-void
-gtk_sheet_set_justify_entry (GtkSheet *sheet, gboolean justify)
-{
-  g_return_if_fail (sheet != NULL);
-  g_return_if_fail (GTK_IS_SHEET (sheet));
-
-  sheet->justify_entry = justify;
-}
-
-gboolean
-gtk_sheet_justify_entry (GtkSheet *sheet)
-{
-  g_return_val_if_fail (sheet != NULL, FALSE);
-  g_return_val_if_fail (GTK_IS_SHEET (sheet), FALSE);
-
-  return sheet->justify_entry;
-}
-
-
-void
-gtk_sheet_set_row_titles_width (GtkSheet *sheet, guint width)
-{
-  if (width < COLUMN_MIN_WIDTH) return;
-
-  sheet->row_title_area.width = width;
-
-  adjust_scrollbars (sheet);
-
-  if (sheet->hadjustment)
-    g_signal_emit_by_name (sheet->hadjustment,
-			   "value_changed");
-  size_allocate_global_button (sheet);
-}
-
-void
-gtk_sheet_set_column_titles_height (GtkSheet *sheet, guint height)
-{
-  if (height < DEFAULT_ROW_HEIGHT (GTK_WIDGET (sheet))) return;
-
-  sheet->column_title_area.height = height;
-
-  adjust_scrollbars (sheet);
-
-  if (sheet->vadjustment)
-    g_signal_emit_by_name (sheet->vadjustment,
-			   "value_changed");
-  size_allocate_global_button (sheet);
-}
-
 void
 gtk_sheet_show_column_titles (GtkSheet *sheet)
 {
@@ -1523,14 +1425,14 @@ gtk_sheet_show_column_titles (GtkSheet *sheet)
   if (!GTK_WIDGET_REALIZED (GTK_WIDGET (sheet)))
     return;
 
-      gdk_window_show (sheet->column_title_window);
-      gdk_window_move_resize (sheet->column_title_window,
-			      sheet->column_title_area.x,
-			      sheet->column_title_area.y,
-			      sheet->column_title_area.width,
-			      sheet->column_title_area.height);
+  gdk_window_show (sheet->column_title_window);
+  gdk_window_move_resize (sheet->column_title_window,
+			  sheet->column_title_area.x,
+			  sheet->column_title_area.y,
+			  sheet->column_title_area.width,
+			  sheet->column_title_area.height);
 
-      adjust_scrollbars (sheet);
+  adjust_scrollbars (sheet);
 
   if (sheet->vadjustment)
     g_signal_emit_by_name (sheet->vadjustment,
@@ -1619,7 +1521,7 @@ gtk_sheet_moveto (GtkSheet *sheet,
 		  gfloat col_align)
 {
   gint x, y;
-  guint width, height;
+  gint width, height;
   gint adjust;
   gint min_row, min_col;
 
@@ -1633,8 +1535,7 @@ gtk_sheet_moveto (GtkSheet *sheet,
   if (column < 0 || column >= g_sheet_column_get_column_count (sheet->column_geometry))
     return;
 
-  height = sheet->sheet_window_height;
-  width = sheet->sheet_window_width;
+  gdk_drawable_get_size (sheet->sheet_window, &width, &height);
 
   /* adjust vertical scrollbar */
   if (row >= 0 && row_align >= 0.0)
@@ -1648,10 +1549,9 @@ gtk_sheet_moveto (GtkSheet *sheet,
       adjust = 0;
       if (row_align >= 1.0)
 	{
-	  while (min_row >= 0 && min_row > MIN_VISIBLE_ROW (sheet))
+	  while (min_row >= 0 && min_row > min_visible_row (sheet))
 	    {
-	      if (g_sheet_row_get_visibility (sheet->row_geometry, min_row))
-		adjust += g_sheet_row_get_height (sheet->row_geometry, min_row);
+	      adjust += g_sheet_row_get_height (sheet->row_geometry, min_row);
 
 	      if (adjust >= height)
 		{
@@ -1680,7 +1580,7 @@ gtk_sheet_moveto (GtkSheet *sheet,
   /* adjust horizontal scrollbar */
   if (column >= 0 && col_align >= 0.0)
     {
-      x = COLUMN_LEFT_XPIXEL (sheet, column)
+      x = g_sheet_column_start_pixel (sheet->column_geometry, column)
 	- (gint) ( col_align*width + (1.0 - col_align)*
 		   g_sheet_column_get_width (sheet->column_geometry, column));
 
@@ -1689,10 +1589,9 @@ gtk_sheet_moveto (GtkSheet *sheet,
       adjust = 0;
       if (col_align == 1.0)
 	{
-	  while (min_col >= 0 && min_col > MIN_VISIBLE_COLUMN (sheet))
+	  while (min_col >= 0 && min_col > min_visible_column (sheet))
 	    {
-	      if (g_sheet_column_get_visibility (sheet->column_geometry, min_col))
-		adjust += g_sheet_column_get_width (sheet->column_geometry, min_col);
+	      adjust += g_sheet_column_get_width (sheet->column_geometry, min_col);
 
 	      if (adjust >= width)
 		{
@@ -1701,7 +1600,7 @@ gtk_sheet_moveto (GtkSheet *sheet,
 	      min_col--;
 	    }
 	  min_col = MAX (min_col, 0);
-	  x = COLUMN_LEFT_XPIXEL (sheet, min_col) +
+	  x = g_sheet_column_start_pixel (sheet->column_geometry, min_col) +
 	    g_sheet_column_get_width (sheet->column_geometry, min_col) - 1;
 	}
 
@@ -1716,16 +1615,7 @@ gtk_sheet_moveto (GtkSheet *sheet,
 }
 
 
-void
-gtk_sheet_columns_set_resizable (GtkSheet *sheet, gboolean resizable)
-{
-  g_return_if_fail (sheet != NULL);
-  g_return_if_fail (GTK_IS_SHEET (sheet));
-
-  sheet->columns_resizable = resizable;
-}
-
-gboolean
+static gboolean
 gtk_sheet_columns_resizable (GtkSheet *sheet)
 {
   g_return_val_if_fail (sheet != NULL, FALSE);
@@ -1735,16 +1625,7 @@ gtk_sheet_columns_resizable (GtkSheet *sheet)
 }
 
 
-void
-gtk_sheet_rows_set_resizable (GtkSheet *sheet, gboolean resizable)
-{
-  g_return_if_fail (sheet != NULL);
-  g_return_if_fail (GTK_IS_SHEET (sheet));
-
-  sheet->rows_resizable = resizable;
-}
-
-gboolean
+static gboolean
 gtk_sheet_rows_resizable (GtkSheet *sheet)
 {
   g_return_val_if_fail (sheet != NULL, FALSE);
@@ -1782,7 +1663,7 @@ gtk_sheet_select_row (GtkSheet *sheet, gint row)
 
 
 void
-gtk_sheet_select_column (GtkSheet * sheet, gint column)
+gtk_sheet_select_column (GtkSheet *sheet, gint column)
 {
   g_return_if_fail (sheet != NULL);
   g_return_if_fail (GTK_IS_SHEET (sheet));
@@ -1812,7 +1693,7 @@ gtk_sheet_select_column (GtkSheet * sheet, gint column)
 
 
 static gboolean
-gtk_sheet_range_isvisible (const GtkSheet * sheet,
+gtk_sheet_range_isvisible (const GtkSheet *sheet,
 			   GtkSheetRange range)
 {
   g_return_val_if_fail (sheet != NULL, FALSE);
@@ -1829,23 +1710,23 @@ gtk_sheet_range_isvisible (const GtkSheet * sheet,
   if (range.coli < 0 || range.coli >= g_sheet_column_get_column_count (sheet->column_geometry))
     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;
 }
 
 static gboolean
-gtk_sheet_cell_isvisible (GtkSheet * sheet,
+gtk_sheet_cell_isvisible (GtkSheet *sheet,
 			  gint row, gint column)
 {
   GtkSheetRange range;
@@ -1865,10 +1746,10 @@ gtk_sheet_get_visible_range (GtkSheet *sheet, GtkSheetRange *range)
   g_return_if_fail (GTK_IS_SHEET (sheet)) ;
   g_return_if_fail (range != NULL);
 
-  range->row0 = MIN_VISIBLE_ROW (sheet);
-  range->col0 = MIN_VISIBLE_COLUMN (sheet);
-  range->rowi = MAX_VISIBLE_ROW (sheet);
-  range->coli = MAX_VISIBLE_COLUMN (sheet);
+  range->row0 = min_visible_row (sheet);
+  range->col0 = min_visible_column (sheet);
+  range->rowi = max_visible_row (sheet);
+  range->coli = max_visible_column (sheet);
 }
 
 
@@ -1878,9 +1759,9 @@ gtk_sheet_set_scroll_adjustments (GtkSheet *sheet,
 				  GtkAdjustment *vadjustment)
 {
   if ( sheet->vadjustment != vadjustment )
-{
-  if (sheet->vadjustment)
-      g_object_unref (sheet->vadjustment);
+    {
+      if (sheet->vadjustment)
+	g_object_unref (sheet->vadjustment);
       sheet->vadjustment = vadjustment;
       g_object_ref (vadjustment);
 
@@ -1890,9 +1771,9 @@ gtk_sheet_set_scroll_adjustments (GtkSheet *sheet,
     }
 
   if ( sheet->hadjustment != hadjustment )
-{
-  if (sheet->hadjustment)
-      g_object_unref (sheet->hadjustment);
+    {
+      if (sheet->hadjustment)
+	g_object_unref (sheet->hadjustment);
       sheet->hadjustment = hadjustment;
       g_object_ref (hadjustment);
 
@@ -1903,7 +1784,7 @@ gtk_sheet_set_scroll_adjustments (GtkSheet *sheet,
 }
 
 static void
-gtk_sheet_finalize (GObject * object)
+gtk_sheet_finalize (GObject *object)
 {
   GtkSheet *sheet;
 
@@ -1989,13 +1870,16 @@ gtk_sheet_style_set (GtkWidget *widget,
 }
 
 static void
-gtk_sheet_realize (GtkWidget * widget)
+gtk_sheet_realize (GtkWidget *widget)
 {
   GtkSheet *sheet;
   GdkWindowAttr attributes;
-  gint attributes_mask;
+  const gint attributes_mask =
+    GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP | GDK_WA_CURSOR;
+
   GdkGCValues values, auxvalues;
   GdkColormap *colormap;
+  GdkDisplay *display;
 
   g_return_if_fail (widget != NULL);
   g_return_if_fail (GTK_IS_SHEET (widget));
@@ -2005,6 +1889,7 @@ gtk_sheet_realize (GtkWidget * widget)
   GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
 
   colormap = gtk_widget_get_colormap (widget);
+  display = gtk_widget_get_display (widget);
 
   attributes.window_type = GDK_WINDOW_CHILD;
   attributes.x = widget->allocation.x;
@@ -2025,10 +1910,8 @@ gtk_sheet_realize (GtkWidget * widget)
 			    GDK_LEAVE_NOTIFY_MASK |
 			    GDK_POINTER_MOTION_MASK |
 			    GDK_POINTER_MOTION_HINT_MASK);
-  attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP |
-    GDK_WA_CURSOR;
 
-  attributes.cursor = gdk_cursor_new (GDK_TOP_LEFT_ARROW);
+  attributes.cursor = gdk_cursor_new_for_display (display, GDK_TOP_LEFT_ARROW);
 
   /* main window */
   widget->window = gdk_window_new (gtk_widget_get_parent_window (widget), &attributes, attributes_mask);
@@ -2073,12 +1956,10 @@ gtk_sheet_realize (GtkWidget * widget)
 			    GTK_STATE_NORMAL);
 
   /* sheet - window */
-  attributes.cursor = gdk_cursor_new (GDK_PLUS);
+  attributes.cursor = gdk_cursor_new_for_display (display, GDK_PLUS);
 
   attributes.x = 0;
   attributes.y = 0;
-  attributes.width = sheet->sheet_window_width;
-    attributes.height = sheet->sheet_window_height;
 
   sheet->sheet_window = gdk_window_new (widget->window,
 					&attributes, attributes_mask);
@@ -2089,15 +1970,10 @@ gtk_sheet_realize (GtkWidget * widget)
   gdk_window_set_background (sheet->sheet_window, &widget->style->white);
   gdk_window_show (sheet->sheet_window);
 
-  /* backing_pixmap */
-  gtk_sheet_make_backing_pixmap (sheet);
-
   /* GCs */
   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;
@@ -2121,7 +1997,7 @@ gtk_sheet_realize (GtkWidget * widget)
   gtk_widget_set_parent (sheet->button, GTK_WIDGET (sheet));
 
 
-  sheet->cursor_drag = gdk_cursor_new (GDK_PLUS);
+  sheet->cursor_drag = gdk_cursor_new_for_display (display, GDK_PLUS);
 
   if (sheet->column_titles_visible)
     gdk_window_show (sheet->column_title_window);
@@ -2171,9 +2047,7 @@ size_allocate_global_button (GtkSheet *sheet)
 static void
 global_button_clicked (GtkWidget *widget, gpointer data)
 {
-  gboolean veto;
-
-  gtk_sheet_click_cell (GTK_SHEET (data), - 1, - 1, &veto);
+  gtk_sheet_click_cell (GTK_SHEET (data), -1, -1);
   gtk_widget_grab_focus (GTK_WIDGET (data));
 }
 
@@ -2204,12 +2078,6 @@ gtk_sheet_unrealize (GtkWidget *widget)
   gdk_window_destroy (sheet->column_title_window);
   gdk_window_destroy (sheet->row_title_window);
 
-  if (sheet->pixmap)
-    {
-      g_object_unref (sheet->pixmap);
-      sheet->pixmap = NULL;
-    }
-
   gtk_widget_unparent (sheet->entry_widget);
   if (sheet->button != NULL)
     gtk_widget_unparent (sheet->button);
@@ -2219,7 +2087,7 @@ gtk_sheet_unrealize (GtkWidget *widget)
 }
 
 static void
-gtk_sheet_map (GtkWidget * widget)
+gtk_sheet_map (GtkWidget *widget)
 {
   GtkSheet *sheet = GTK_SHEET (widget);
 
@@ -2272,46 +2140,48 @@ gtk_sheet_map (GtkWidget * widget)
 }
 
 static void
-gtk_sheet_unmap (GtkWidget * widget)
+gtk_sheet_unmap (GtkWidget *widget)
 {
   GtkSheet *sheet = GTK_SHEET (widget);
 
   if (!GTK_WIDGET_MAPPED (widget))
     return;
 
-      GTK_WIDGET_UNSET_FLAGS (widget, GTK_MAPPED);
+  GTK_WIDGET_UNSET_FLAGS (widget, GTK_MAPPED);
 
-      gdk_window_hide (sheet->sheet_window);
-      if (sheet->column_titles_visible)
-	gdk_window_hide (sheet->column_title_window);
-      if (sheet->row_titles_visible)
-	gdk_window_hide (sheet->row_title_window);
-      gdk_window_hide (widget->window);
+  gdk_window_hide (sheet->sheet_window);
+  if (sheet->column_titles_visible)
+    gdk_window_hide (sheet->column_title_window);
+  if (sheet->row_titles_visible)
+    gdk_window_hide (sheet->row_title_window);
+  gdk_window_hide (widget->window);
 
-      if (GTK_WIDGET_MAPPED (sheet->entry_widget))
-	gtk_widget_unmap (sheet->entry_widget);
+  if (GTK_WIDGET_MAPPED (sheet->entry_widget))
+    gtk_widget_unmap (sheet->entry_widget);
 
-      if (GTK_WIDGET_MAPPED (sheet->button))
-	gtk_widget_unmap (sheet->button);
+  if (GTK_WIDGET_MAPPED (sheet->button))
+    gtk_widget_unmap (sheet->button);
 }
 
 
 static void
-gtk_sheet_cell_draw_default (GtkSheet *sheet, gint row, gint col)
+gtk_sheet_cell_draw_bg (GtkSheet *sheet, gint row, gint col)
 {
-  GdkGC *fg_gc, *bg_gc;
   GtkSheetCellAttr attributes;
   GdkRectangle area;
 
   g_return_if_fail (sheet != NULL);
 
-  /* bail now if we arn't drawable yet */
+  /* bail now if we aren't yet drawable */
   if (!GTK_WIDGET_DRAWABLE (sheet)) return;
 
-  if (row < 0 || row >= g_sheet_row_get_row_count (sheet->row_geometry)) return;
-  if (col < 0 || col >= g_sheet_column_get_column_count (sheet->column_geometry)) return;
-  if (! g_sheet_column_get_visibility (sheet->column_geometry, col)) return;
-  if (! g_sheet_row_get_visibility (sheet->row_geometry, row)) return;
+  if (row < 0 ||
+      row >= g_sheet_row_get_row_count (sheet->row_geometry))
+    return;
+
+  if (col < 0 ||
+      col >= g_sheet_column_get_column_count (sheet->column_geometry))
+    return;
 
   gtk_sheet_get_attributes (sheet, row, col, &attributes);
 
@@ -2319,17 +2189,7 @@ gtk_sheet_cell_draw_default (GtkSheet *sheet, gint row, gint col)
   gdk_gc_set_foreground (sheet->fg_gc, &attributes.foreground);
   gdk_gc_set_foreground (sheet->bg_gc, &attributes.background);
 
-  fg_gc = sheet->fg_gc;
-  bg_gc = sheet->bg_gc;
-
-  area.x = g_sheet_column_start_pixel (sheet->column_geometry, col);
-  area.x -= sheet->hadjustment->value;
-
-  area.y = g_sheet_row_start_pixel (sheet->row_geometry, row);
-  area.y -= sheet->vadjustment->value;
-
-  area.width= g_sheet_column_get_width (sheet->column_geometry, col);
-  area.height = g_sheet_row_get_height (sheet->row_geometry, row);
+  rectangle_from_cell (sheet, row, col, &area);
 
   gdk_gc_set_line_attributes (sheet->fg_gc, 1, 0, 0, 0);
 
@@ -2337,7 +2197,7 @@ gtk_sheet_cell_draw_default (GtkSheet *sheet, gint row, gint col)
     {
       gdk_gc_set_foreground (sheet->bg_gc, &sheet->color[GRID_COLOR]);
 
-      gdk_draw_rectangle (sheet->pixmap,
+      gdk_draw_rectangle (sheet->sheet_window,
 			  sheet->bg_gc,
 			  FALSE,
 			  area.x, area.y,
@@ -2351,25 +2211,15 @@ gtk_sheet_cell_draw_label (GtkSheet *sheet, gint row, gint col)
 {
   GtkWidget *widget;
   GdkRectangle area;
-  gint i;
-  gint text_width, text_height, y;
-  gint xoffset = 0;
-  gint size, sizel, sizer;
-  GdkGC *fg_gc, *bg_gc;
   GtkSheetCellAttr attributes;
   PangoLayout *layout;
-  PangoRectangle rect;
-  PangoRectangle logical_rect;
-  PangoLayoutLine *line;
-  PangoFontMetrics *metrics;
-  PangoContext *context = gtk_widget_get_pango_context (GTK_WIDGET (sheet));
-  gint ascent, descent, y_pos;
+  PangoRectangle text;
+  gint font_height;
 
   gchar *label;
 
   g_return_if_fail (sheet != NULL);
 
-  /* bail now if we aren't drawable yet */
   if (!GTK_WIDGET_DRAWABLE (sheet))
     return;
 
@@ -2377,10 +2227,12 @@ gtk_sheet_cell_draw_label (GtkSheet *sheet, gint row, gint col)
   if (!label)
     return;
 
-  if (row < 0 || row >= g_sheet_row_get_row_count (sheet->row_geometry)) return;
-  if (col < 0 || col >= g_sheet_column_get_column_count (sheet->column_geometry)) return;
-  if (! g_sheet_column_get_visibility (sheet->column_geometry, col)) return;
-  if (!g_sheet_row_get_visibility (sheet->row_geometry, row)) return;
+  if (row < 0 || row >= g_sheet_row_get_row_count (sheet->row_geometry))
+    return;
+
+  if (col < 0 ||
+      col >= g_sheet_column_get_column_count (sheet->column_geometry))
+    return;
 
   widget = GTK_WIDGET (sheet);
 
@@ -2390,143 +2242,56 @@ gtk_sheet_cell_draw_label (GtkSheet *sheet, gint row, gint col)
   gdk_gc_set_foreground (sheet->fg_gc, &attributes.foreground);
   gdk_gc_set_foreground (sheet->bg_gc, &attributes.background);
 
-  fg_gc = sheet->fg_gc;
-  bg_gc = sheet->bg_gc;
-
-  area.x = g_sheet_column_start_pixel (sheet->column_geometry, col);
-  area.x -= sheet->hadjustment->value;
-
-  area.y = g_sheet_row_start_pixel (sheet->row_geometry, row);
-  area.y -= sheet->vadjustment->value;
-
-  area.width = g_sheet_column_get_width (sheet->column_geometry, col);
-  area.height = g_sheet_row_get_height (sheet->row_geometry, row);
-
+  rectangle_from_cell (sheet, row, col, &area);
 
   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_get_pixel_extents (layout, NULL, &rect);
-
-  line = pango_layout_get_lines (layout)->data;
-  pango_layout_line_get_extents (line, NULL, &logical_rect);
 
-  metrics = pango_context_get_metrics (context,
-				       attributes.font_desc,
-				       pango_context_get_language (context));
+  pango_layout_get_pixel_extents (layout, NULL, &text);
 
-  ascent = pango_font_metrics_get_ascent (metrics) / PANGO_SCALE;
-  descent = pango_font_metrics_get_descent (metrics) / PANGO_SCALE;
+  gdk_gc_set_clip_rectangle (sheet->fg_gc, &area);
 
-  pango_font_metrics_unref (metrics);
+  font_height = pango_font_description_get_size (attributes.font_desc);
+  if ( !pango_font_description_get_size_is_absolute (attributes.font_desc))
+    font_height /= PANGO_SCALE;
 
-  /* Align primarily for locale's ascent / descent */
-
-  logical_rect.height /= PANGO_SCALE;
-  logical_rect.y /= PANGO_SCALE;
-  y_pos = area.height - logical_rect.height;
-
-  if (logical_rect.height > area.height)
-    y_pos = (logical_rect.height - area.height - 2 * COLUMN_TITLES_HEIGHT) / 2;
-  else if (y_pos < 0)
-    y_pos = 0;
-  else if (y_pos + logical_rect.height > area.height)
-    y_pos = area.height - logical_rect.height;
-
-  text_width = rect.width;
-  text_height = rect.height;
-  y = area.y + y_pos - COLUMN_TITLES_HEIGHT;
+  /* Centre the text vertically */
+  area.y += (area.height - font_height) / 2.0;
 
   switch (attributes.justification)
     {
     case GTK_JUSTIFY_RIGHT:
-      size = area.width;
-      area.x +=area.width;
-      {
-	for (i = col - 1; i >= MIN_VISIBLE_COLUMN (sheet); i--)
-	  {
-	    if ( !gtk_sheet_cell_empty (sheet, row, i)) break;
-	    if (size >= text_width + COLUMN_TITLES_HEIGHT) break;
-	    size += g_sheet_column_get_width (sheet->column_geometry, i);
-	    g_sheet_column_set_right_text_column (sheet->column_geometry, i,
-					 MAX (col,
-						       g_sheet_column_get_right_text_column (sheet->column_geometry, i)));
-	  }
-	area.width = size;
-      }
-      area.x -= size;
-      xoffset += area.width - text_width - 2 * COLUMN_TITLES_HEIGHT -
-	attributes.border.width / 2;
+      area.x += area.width - text.width;
       break;
     case GTK_JUSTIFY_CENTER:
-      sizel = area.width / 2;
-      sizer = area.width / 2;
-      area.x += area.width / 2;
-      {
-	for (i = col + 1; i <= MAX_VISIBLE_COLUMN (sheet); i++)
-	  {
-	    if ( ! gtk_sheet_cell_empty (sheet, row, i)) break;
-	    if (sizer >= text_width / 2) break;
-	    sizer += g_sheet_column_get_width (sheet->column_geometry, i);
-	    g_sheet_column_set_left_text_column (sheet->column_geometry, i,
-					MIN (
-					     col,
-						      g_sheet_column_get_left_text_column (sheet->column_geometry, i)));
-	  }
-	for (i = col - 1; i >= MIN_VISIBLE_COLUMN (sheet); i--)
-	  {
-	    if ( ! gtk_sheet_cell_empty (sheet, row, i)) break;
-	    if (sizel >= text_width / 2) break;
-	    sizel += g_sheet_column_get_width (sheet->column_geometry, i);
-	    g_sheet_column_set_right_text_column (sheet->column_geometry, i,
-					 MAX (col,
-						       g_sheet_column_get_right_text_column (sheet->column_geometry, i)));
-	  }
-	size = MIN (sizel, sizer);
-      }
-      area.x -= sizel;
-      xoffset += sizel - text_width / 2 - COLUMN_TITLES_HEIGHT;
-      area.width = sizel + sizer;
+      area.x += (area.width - text.width) / 2.0;
       break;
     case GTK_JUSTIFY_LEFT:
+      /* Do nothing */
+      break;
     default:
-      size = area.width;
-      {
-	for (i = col + 1; i <= MAX_VISIBLE_COLUMN (sheet); i++)
-	  {
-	    if (! gtk_sheet_cell_empty (sheet, row, i)) break;
-	    if (size >= text_width + COLUMN_TITLES_HEIGHT) break;
-	    size += g_sheet_column_get_width (sheet->column_geometry, i);
-	    g_sheet_column_set_left_text_column (sheet->column_geometry, i,
-					MIN (
-					     col,
-						      g_sheet_column_get_left_text_column (sheet->column_geometry, i)));
-
-	  }
-	area.width = size;
-      }
-      xoffset += attributes.border.width / 2;
+      g_critical ("Unhandled justification %d in column %d\n",
+		 attributes.justification, col);
       break;
     }
 
-  gdk_gc_set_clip_rectangle (fg_gc, &area);
-
-
-  gdk_draw_layout (sheet->pixmap, fg_gc,
-		   area.x + xoffset + COLUMN_TITLES_HEIGHT,
+  gdk_draw_layout (sheet->sheet_window, sheet->fg_gc,
+		   area.x,
 		   area.y,
 		   layout);
 
-  gdk_gc_set_clip_rectangle (fg_gc, NULL);
+  gdk_gc_set_clip_rectangle (sheet->fg_gc, NULL);
   g_object_unref (layout);
-
 }
 
 static void
 gtk_sheet_range_draw (GtkSheet *sheet, const GtkSheetRange *range)
 {
   gint i, j;
+
+  GdkRectangle area;
   GtkSheetRange drawing_range;
 
   g_return_if_fail (sheet != NULL);
@@ -2536,43 +2301,40 @@ 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 (sheet->sheet_window_width <= 0) return;
-  if (sheet->sheet_window_height <=0) return;
-
-  if (sheet->pixmap == NULL) 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),
+      drawing_range.row0 = min_visible_row (sheet);
+      drawing_range.col0 = min_visible_column (sheet);
+      drawing_range.rowi = MIN (max_visible_row (sheet),
 				g_sheet_row_get_row_count (sheet->row_geometry) - 1);
-      drawing_range.coli = MAX_VISIBLE_COLUMN (sheet);
-
-      gdk_draw_rectangle (sheet->pixmap,
-			  GTK_WIDGET (sheet)->style->white_gc,
-			  TRUE,
-			  0, 0,
-			  sheet->sheet_window_width,
-			  sheet->sheet_window_height);
+      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);
+
   for (i = drawing_range.row0; i <= drawing_range.rowi; i++)
     for (j = drawing_range.col0; j <= drawing_range.coli; j++)
       {
-	gtk_sheet_cell_draw_default (sheet, i, j);
+	gtk_sheet_cell_draw_bg (sheet, i, j);
 	gtk_sheet_cell_draw_label (sheet, i, j);
       }
 
-  gtk_sheet_draw_backing_pixmap (sheet, drawing_range);
-
   if (sheet->state != GTK_SHEET_NORMAL &&
       gtk_sheet_range_isvisible (sheet, sheet->range))
     gtk_sheet_range_draw_selection (sheet, drawing_range);
@@ -2606,34 +2368,18 @@ gtk_sheet_range_draw_selection (GtkSheet *sheet, GtkSheetRange range)
   range.row0 = MAX (sheet->range.row0, range.row0);
   range.rowi = MIN (sheet->range.rowi, range.rowi);
 
-  range.col0 = MAX (range.col0, MIN_VISIBLE_COLUMN (sheet));
-  range.coli = MIN (range.coli, MAX_VISIBLE_COLUMN (sheet));
-  range.row0 = MAX (range.row0, MIN_VISIBLE_ROW (sheet));
-  range.rowi = MIN (range.rowi, MAX_VISIBLE_ROW (sheet));
+  range.col0 = MAX (range.col0, min_visible_column (sheet));
+  range.coli = MIN (range.coli, max_visible_column (sheet));
+  range.row0 = MAX (range.row0, min_visible_row (sheet));
+  range.rowi = MIN (range.rowi, max_visible_row (sheet));
 
   for (i = range.row0; i <= range.rowi; i++)
     {
       for (j = range.col0; j <= range.coli; j++)
 	{
-
-	  if (gtk_sheet_cell_get_state (sheet, i, j) == GTK_STATE_SELECTED &&
-	      g_sheet_column_get_visibility (sheet->column_geometry, j) && g_sheet_row_get_visibility (sheet->row_geometry, i))
+	  if (gtk_sheet_cell_get_state (sheet, i, j) == GTK_STATE_SELECTED)
 	    {
-	      area.x = COLUMN_LEFT_XPIXEL (sheet, j);
-	      if ( sheet->row_titles_visible)
-		area.x += sheet->row_title_area.width;
-
-	      area.x -= sheet->hadjustment->value;
-
-	      area.y = g_sheet_row_start_pixel (sheet->row_geometry, i);
-	      if ( sheet->column_titles_visible)
-		area.y += sheet->column_title_area.height;
-
-	      area.y -= sheet->vadjustment->value;
-
-
-	      area.width= g_sheet_column_get_width (sheet->column_geometry, j);
-	      area.height = g_sheet_row_get_height (sheet->row_geometry, i);
+	      rectangle_from_cell (sheet, i, j, &area);
 
 	      if (i == sheet->range.row0)
 		{
@@ -2664,26 +2410,6 @@ gtk_sheet_range_draw_selection (GtkSheet *sheet, GtkSheetRange range)
   gtk_sheet_draw_border (sheet, sheet->range);
 }
 
-static void
-gtk_sheet_draw_backing_pixmap (GtkSheet *sheet, GtkSheetRange range)
-{
-  gint width, height;
-
-  if (!GTK_WIDGET_REALIZED (GTK_WIDGET (sheet))) return;
-
-  if ( sheet->pixmap == NULL) return;
-
-  gdk_drawable_get_size (sheet->pixmap, &width, &height);
-
-  gdk_draw_drawable (sheet->sheet_window,
-		   GTK_WIDGET (sheet)->style->fg_gc[GTK_STATE_NORMAL],
-		   sheet->pixmap,
-		     0, 0, /* src */
-		     sheet->row_titles_visible ? sheet->row_title_area.width : 0,
-		     sheet->column_titles_visible ? sheet->column_title_area.height : 0,
-		     width, height);
-}
-
 static void gtk_sheet_set_cell (GtkSheet *sheet, gint row, gint col,
 				GtkJustification justification,
 				const gchar *text);
@@ -2704,66 +2430,30 @@ gtk_sheet_set_cell (GtkSheet *sheet, gint row, gint col,
 		    const gchar *text)
 {
   GSheetModel *model ;
-  gboolean changed ;
+  gboolean changed = FALSE;
   gchar *old_text ;
 
-  GtkSheetRange range;
-  gint text_width;
-  GtkSheetCellAttr attributes;
-
   g_return_if_fail (sheet != NULL);
   g_return_if_fail (GTK_IS_SHEET (sheet));
-  if (col >= g_sheet_column_get_column_count (sheet->column_geometry) || row >= g_sheet_row_get_row_count (sheet->row_geometry)) return;
-  if (col < 0 || row < 0) return;
 
-  gtk_sheet_get_attributes (sheet, row, col, &attributes);
+  if (col >= g_sheet_column_get_column_count (sheet->column_geometry)
+      || row >= g_sheet_row_get_row_count (sheet->row_geometry))
+    return;
 
-  attributes.justification = justification;
+  if (col < 0 || row < 0) return;
 
   model = gtk_sheet_get_model (sheet);
 
   old_text = g_sheet_model_get_string (model, row, col);
 
-  changed = FALSE;
-
   if (0 != safe_strcmp (old_text, text))
     changed = g_sheet_model_set_string (model, text, row, col);
 
   if ( g_sheet_model_free_strings (model))
     g_free (old_text);
 
-
-  if (changed && attributes.is_visible)
-    {
-      gchar *s = gtk_sheet_cell_get_text (sheet, row, col);
-      text_width = 0;
-      if (s && strlen (s) > 0)
-	{
-	  text_width = STRING_WIDTH (GTK_WIDGET (sheet),
-				     attributes.font_desc, text);
-	}
-      dispose_string (sheet, s);
-
-      range.row0 = row;
-      range.rowi = row;
-      range.col0 = MIN_VISIBLE_COLUMN (sheet);
-      range.coli = MAX_VISIBLE_COLUMN (sheet);
-
-      if (gtk_sheet_autoresize (sheet) &&
-	  text_width > g_sheet_column_get_width (sheet->column_geometry, col) -
-	  2 * COLUMN_TITLES_HEIGHT- attributes.border.width)
-	{
-	  gtk_sheet_set_column_width (sheet, col, text_width + 2 * COLUMN_TITLES_HEIGHT
-				      + attributes.border.width);
-	  GTK_SHEET_SET_FLAGS (sheet, GTK_SHEET_REDRAW_PENDING);
-	}
-      else
-	  gtk_sheet_range_draw (sheet, &range);
-    }
-
   if ( changed )
     g_signal_emit (sheet, sheet_signals[CHANGED], 0, row, col);
-
 }
 
 
@@ -2781,13 +2471,13 @@ gtk_sheet_cell_clear (GtkSheet *sheet, gint row, gint column)
 
   range.row0 = row;
   range.rowi = row;
-  range.col0 = MIN_VISIBLE_COLUMN (sheet);
-  range.coli = MAX_VISIBLE_COLUMN (sheet);
+  range.col0 = min_visible_column (sheet);
+  range.coli = max_visible_column (sheet);
 
   gtk_sheet_real_cell_clear (sheet, row, column);
 
-      gtk_sheet_range_draw (sheet, &range);
-    }
+  gtk_sheet_range_draw (sheet, &range);
+}
 
 static void
 gtk_sheet_real_cell_clear (GtkSheet *sheet, gint row, gint column)
@@ -2804,59 +2494,6 @@ gtk_sheet_real_cell_clear (GtkSheet *sheet, gint row, gint column)
   dispose_string (sheet, old_text);
 }
 
-void
-gtk_sheet_range_clear (GtkSheet *sheet, const GtkSheetRange *range)
-{
-  g_return_if_fail (sheet != NULL);
-  g_return_if_fail (GTK_IS_SHEET (sheet));
-
-  gtk_sheet_real_range_clear (sheet, range);
-}
-
-static void
-gtk_sheet_real_range_clear (GtkSheet *sheet, const GtkSheetRange *range)
-{
-  gint i, j;
-  GtkSheetRange clear;
-
-  if (!range)
-    {
-      clear.row0 = 0;
-      clear.rowi = g_sheet_row_get_row_count (sheet->row_geometry) - 1;
-      clear.col0 = 0;
-      clear.coli = g_sheet_column_get_column_count (sheet->column_geometry) - 1;
-    }
-  else
-    clear=*range;
-
-  clear.row0 = MAX (clear.row0, 0);
-  clear.col0 = MAX (clear.col0, 0);
-  clear.rowi = MIN (clear.rowi, g_sheet_row_get_row_count (sheet->row_geometry) - 1 );
-  clear.coli = MIN (clear.coli, g_sheet_column_get_column_count (sheet->column_geometry) - 1 );
-
-  for (i = clear.row0; i <= clear.rowi; i++)
-    for (j = clear.col0; j <= clear.coli; j++)
-      {
-	gtk_sheet_real_cell_clear (sheet, i, j);
-      }
-
-  gtk_sheet_range_draw (sheet, NULL);
-}
-
-
-static gboolean
-gtk_sheet_cell_empty (const GtkSheet *sheet, gint row, gint col)
-{
-  gboolean empty;
-  char *text = gtk_sheet_cell_get_text (sheet, row, col);
-  empty = (text == NULL );
-
-  dispose_string (sheet, text);
-
-  return empty;
-}
-
-
 gchar *
 gtk_sheet_cell_get_text (const GtkSheet *sheet, gint row, gint col)
 {
@@ -2877,7 +2514,7 @@ gtk_sheet_cell_get_text (const GtkSheet *sheet, gint row, gint col)
 }
 
 
-GtkStateType
+static GtkStateType
 gtk_sheet_cell_get_state (GtkSheet *sheet, gint row, gint col)
 {
   gint state;
@@ -2943,28 +2580,42 @@ gtk_sheet_get_pixel_info (GtkSheet *sheet,
 
   y += sheet->vadjustment->value;
 
-  trow = yyy_row_ypixel_to_row (sheet, y);
-  if (trow > g_sheet_row_get_row_count (sheet->row_geometry))
+  if ( y < 0 && sheet->column_titles_visible)
+    {
+      trow = -1;
+    }
+  else
+    {
+      trow = yyy_row_ypixel_to_row (sheet, y);
+      if (trow > g_sheet_row_get_row_count (sheet->row_geometry))
 	return FALSE;
+    }
 
-      *row = trow;
+  *row = trow;
 
   if ( sheet->row_titles_visible)
     x -= sheet->row_title_area.width;
 
   x += sheet->hadjustment->value;
 
-      tcol = COLUMN_FROM_XPIXEL (sheet, x);
-  if (tcol > g_sheet_column_get_column_count (sheet->column_geometry))
+  if ( x < 0 && sheet->row_titles_visible)
+    {
+      tcol = -1;
+    }
+  else
+    {
+      tcol = column_from_xpixel (sheet, x);
+      if (tcol > g_sheet_column_get_column_count (sheet->column_geometry))
 	return FALSE;
+    }
 
-      *column = tcol;
+  *column = tcol;
 
   return TRUE;
 }
 
 gboolean
-gtk_sheet_get_cell_area (GtkSheet * sheet,
+gtk_sheet_get_cell_area (GtkSheet *sheet,
 			 gint row,
 			 gint column,
 			 GdkRectangle *area)
@@ -2975,7 +2626,7 @@ gtk_sheet_get_cell_area (GtkSheet * sheet,
   if (row >= g_sheet_row_get_row_count (sheet->row_geometry) || column >= g_sheet_column_get_column_count (sheet->column_geometry))
     return FALSE;
 
-  area->x = (column == -1) ? 0 : COLUMN_LEFT_XPIXEL (sheet, column);
+  area->x = (column == -1) ? 0 : g_sheet_column_start_pixel (sheet->column_geometry, column);
   area->y = (row == -1)    ? 0 : g_sheet_row_start_pixel (sheet->row_geometry, row);
 
   area->width= (column == -1) ? sheet->row_title_area.width
@@ -2988,33 +2639,32 @@ gtk_sheet_get_cell_area (GtkSheet * sheet,
 }
 
 gboolean
-gtk_sheet_set_active_cell (GtkSheet *sheet, gint row, gint column)
+gtk_sheet_set_active_cell (GtkSheet *sheet, gint row, gint col)
 {
   g_return_val_if_fail (sheet != NULL, 0);
   g_return_val_if_fail (GTK_IS_SHEET (sheet), 0);
 
-  if (row < - 1 || column < - 1) return FALSE;
-  if (row >= g_sheet_row_get_row_count (sheet->row_geometry) || column >= g_sheet_column_get_column_count (sheet->column_geometry))
+  if (row < -1 || col < -1) return FALSE;
+  if (row >= g_sheet_row_get_row_count (sheet->row_geometry)
+      ||
+      col >= g_sheet_column_get_column_count (sheet->column_geometry))
     return FALSE;
 
-  if (GTK_WIDGET_REALIZED (GTK_WIDGET (sheet)))
-    gtk_sheet_deactivate_cell (sheet);
-
   sheet->active_cell.row = row;
-  sheet->active_cell.col = column;
+  sheet->active_cell.col = col;
+
+  if (!GTK_WIDGET_REALIZED (GTK_WIDGET (sheet)))
+    return TRUE;
+
+  gtk_sheet_deactivate_cell (sheet);
 
-  if ( row == -1 || column == -1)
+  if ( row == -1 || col == -1)
     {
       gtk_sheet_hide_active_cell (sheet);
       return TRUE;
     }
 
-  if (!gtk_sheet_activate_cell (sheet, row, column)) return FALSE;
-
-  if (gtk_sheet_autoscroll (sheet))
-    gtk_sheet_move_query (sheet, row, column);
-
-  return TRUE;
+  return gtk_sheet_activate_cell (sheet, row, col);
 }
 
 void
@@ -3075,9 +2725,21 @@ gtk_sheet_deactivate_cell (GtkSheet *sheet)
   if (!GTK_WIDGET_REALIZED (GTK_WIDGET (sheet))) return ;
   if (sheet->state != GTK_SHEET_NORMAL) return ;
 
+
   if ( sheet->active_cell.row == -1 || sheet->active_cell.col == -1 )
     return ;
 
+  /*
+  g_print ("%s\n", __FUNCTION__);
+
+
+  GtkSheetRange r;
+  r.col0 = r.coli = sheet->active_cell.col;
+  r.row0 = r.rowi = sheet->active_cell.row;
+  gtk_sheet_range_draw (sheet, &r);
+  */
+
+
   g_signal_emit (sheet, sheet_signals[DEACTIVATE], 0,
 		 sheet->active_cell.row,
 		 sheet->active_cell.col);
@@ -3091,40 +2753,46 @@ gtk_sheet_deactivate_cell (GtkSheet *sheet)
   sheet->active_cell.row = -1;
   sheet->active_cell.col = -1;
 
+#if 0
   if (GTK_SHEET_REDRAW_PENDING (sheet))
     {
       GTK_SHEET_UNSET_FLAGS (sheet, GTK_SHEET_REDRAW_PENDING);
       gtk_sheet_range_draw (sheet, NULL);
     }
+#endif
 }
 
+
+
 static void
 gtk_sheet_hide_active_cell (GtkSheet *sheet)
 {
-  const char *text;
-  gint row, col;
-  GtkJustification justification;
-  GtkSheetCellAttr attributes;
-
-  if (!GTK_WIDGET_REALIZED (GTK_WIDGET (sheet))) return;
+  GdkRectangle area;
 
-  row = sheet->active_cell.row;
-  col = sheet->active_cell.col;
+  if (!GTK_WIDGET_REALIZED (GTK_WIDGET (sheet)))
+    return;
 
-  if (row < 0 || col < 0) return;
+  if (sheet->active_cell.row < 0 ||
+      sheet->active_cell.col < 0) return;
 
-  text = gtk_entry_get_text (GTK_ENTRY (gtk_sheet_get_entry (sheet)));
+  gtk_widget_hide (sheet->entry_widget);
+  gtk_widget_unmap (sheet->entry_widget);
 
-  gtk_sheet_get_attributes (sheet, row, col, &attributes);
-  justification = attributes.justification;
+  rectangle_from_cell (sheet,
+		       sheet->active_cell.row, sheet->active_cell.col,
+		       &area);
 
-  row = sheet->active_cell.row;
-  col = sheet->active_cell.col;
+  gdk_draw_rectangle (sheet->sheet_window,
+		      GTK_WIDGET (sheet)->style->white_gc,
+		      TRUE,
+		      area.x, area.y,
+		      area.width, area.height);
 
-  gtk_widget_hide (sheet->entry_widget);
-  gtk_widget_unmap (sheet->entry_widget);
+  gtk_sheet_cell_draw_bg (sheet, sheet->active_cell.row,
+			       sheet->active_cell.col);
 
-  gtk_widget_grab_focus (GTK_WIDGET (sheet));
+  gtk_sheet_cell_draw_label (sheet, sheet->active_cell.row,
+			     sheet->active_cell.col);
 
   GTK_WIDGET_UNSET_FLAGS (GTK_WIDGET (sheet->entry_widget), GTK_VISIBLE);
 }
@@ -3139,7 +2807,8 @@ gtk_sheet_activate_cell (GtkSheet *sheet, gint row, gint col)
 
   if (row < 0 || col < 0) return FALSE;
 
-  if ( row > g_sheet_row_get_row_count (sheet->row_geometry) || col > g_sheet_column_get_column_count (sheet->column_geometry))
+  if ( row > g_sheet_row_get_row_count (sheet->row_geometry)
+       || col > g_sheet_column_get_column_count (sheet->column_geometry))
     return FALSE;
 
   if (!veto) return FALSE;
@@ -3160,8 +2829,6 @@ gtk_sheet_activate_cell (GtkSheet *sheet, gint row, gint col)
 
   GTK_SHEET_UNSET_FLAGS (sheet, GTK_SHEET_IN_SELECTION);
 
-
-
   gtk_sheet_show_active_cell (sheet);
 
   g_signal_connect (gtk_sheet_get_entry (sheet),
@@ -3169,7 +2836,7 @@ gtk_sheet_activate_cell (GtkSheet *sheet, gint row, gint col)
 		    G_CALLBACK (gtk_sheet_entry_changed),
 		    sheet);
 
-  _gtkextra_signal_emit (GTK_OBJECT (sheet), sheet_signals [ACTIVATE], row, col, &veto);
+   g_signal_emit (sheet, sheet_signals [ACTIVATE], 0, row, col, &veto);
 
   return TRUE;
 }
@@ -3206,8 +2873,6 @@ gtk_sheet_show_active_cell (GtkSheet *sheet)
 
   justification = GTK_JUSTIFY_LEFT;
 
-  if (gtk_sheet_justify_entry (sheet))
-    justification = attributes.justification;
 
   text = gtk_sheet_cell_get_text (sheet, row, col);
   if ( ! text )
@@ -3250,7 +2915,8 @@ gtk_sheet_draw_active_cell (GtkSheet *sheet)
 
   if (row < 0 || col < 0) return;
 
-  if (!gtk_sheet_cell_isvisible (sheet, row, col)) return;
+  if (!gtk_sheet_cell_isvisible (sheet, row, col))
+    return;
 
   range.col0 = range.coli = col;
   range.row0 = range.rowi = row;
@@ -3260,46 +2926,6 @@ gtk_sheet_draw_active_cell (GtkSheet *sheet)
 
 
 
-static void
-gtk_sheet_make_backing_pixmap (GtkSheet *sheet)
-{
-  gint pixmap_width, pixmap_height;
-  gint width, height;
-
-  if (!GTK_WIDGET_REALIZED (GTK_WIDGET (sheet))) return;
-
-  width = sheet->sheet_window_width ;
-  height = sheet->sheet_window_height ;
-
-
-  if ( width <= 0) return;
-  if ( height <= 0) return;
-
-  if (!sheet->pixmap)
-    {
-      /* allocate */
-      sheet->pixmap = gdk_pixmap_new (sheet->sheet_window,
-				      width, height,
-				      - 1);
-
-      gtk_sheet_range_draw (sheet, NULL);
-    }
-  else
-    {
-      /* reallocate if sizes don't match */
-      gdk_drawable_get_size (sheet->pixmap,
-			     &pixmap_width, &pixmap_height);
-      if ( (pixmap_width != width) || (pixmap_height != height))
-	{
-	  g_object_unref (sheet->pixmap);
-	  sheet->pixmap = gdk_pixmap_new (sheet->sheet_window,
-					  width, height,
-					  - 1);
-	  gtk_sheet_range_draw (sheet, NULL);
-	}
-    }
-}
-
 static void
 gtk_sheet_new_selection (GtkSheet *sheet, GtkSheetRange *range)
 {
@@ -3319,15 +2945,15 @@ gtk_sheet_new_selection (GtkSheet *sheet, GtkSheetRange *range)
   range->col0 = MIN (range->col0, sheet->range.col0);
   range->coli = MAX (range->coli, sheet->range.coli);
 
-  range->row0 = MAX (range->row0, MIN_VISIBLE_ROW (sheet));
-  range->rowi = MIN (range->rowi, MAX_VISIBLE_ROW (sheet));
-  range->col0 = MAX (range->col0, MIN_VISIBLE_COLUMN (sheet));
-  range->coli = MIN (range->coli, MAX_VISIBLE_COLUMN (sheet));
+  range->row0 = MAX (range->row0, min_visible_row (sheet));
+  range->rowi = MIN (range->rowi, max_visible_row (sheet));
+  range->col0 = MAX (range->col0, min_visible_column (sheet));
+  range->coli = MIN (range->coli, max_visible_column (sheet));
 
-  aux_range.row0 = MAX (new_range.row0, MIN_VISIBLE_ROW (sheet));
-  aux_range.rowi = MIN (new_range.rowi, MAX_VISIBLE_ROW (sheet));
-  aux_range.col0 = MAX (new_range.col0, MIN_VISIBLE_COLUMN (sheet));
-  aux_range.coli = MIN (new_range.coli, MAX_VISIBLE_COLUMN (sheet));
+  aux_range.row0 = MAX (new_range.row0, min_visible_row (sheet));
+  aux_range.rowi = MIN (new_range.rowi, max_visible_row (sheet));
+  aux_range.col0 = MAX (new_range.col0, min_visible_column (sheet));
+  aux_range.coli = MIN (new_range.coli, max_visible_column (sheet));
 
   for (i = range->row0; i <= range->rowi; i++)
     {
@@ -3339,7 +2965,6 @@ gtk_sheet_new_selection (GtkSheet *sheet, GtkSheetRange *range)
 		     j <= new_range.coli && j >= new_range.col0) ? TRUE : FALSE;
 
 	  if (state == GTK_STATE_SELECTED && selected &&
-	      g_sheet_column_get_visibility (sheet->column_geometry, j) && g_sheet_row_get_visibility (sheet->row_geometry, i) &&
 	      (i == sheet->range.row0 || i == sheet->range.rowi ||
 	       j == sheet->range.col0 || j == sheet->range.coli ||
 	       i == new_range.row0 || i == new_range.rowi ||
@@ -3358,9 +2983,9 @@ gtk_sheet_new_selection (GtkSheet *sheet, GtkSheetRange *range)
 
 	      if (mask1 != mask2)
 		{
-		  x = COLUMN_LEFT_XPIXEL (sheet, j);
+		  x = g_sheet_column_start_pixel (sheet->column_geometry, j);
 		  y = g_sheet_row_start_pixel (sheet->row_geometry, i);
-		  width = COLUMN_LEFT_XPIXEL (sheet, j)- x+
+		  width = g_sheet_column_start_pixel (sheet->column_geometry, j)- x+
 		    g_sheet_column_get_width (sheet->column_geometry, j);
 		  height = g_sheet_row_start_pixel (sheet->row_geometry, i) - y + g_sheet_row_get_height (sheet->row_geometry, i);
 
@@ -3379,9 +3004,9 @@ gtk_sheet_new_selection (GtkSheet *sheet, GtkSheetRange *range)
 
 		  if (i != sheet->active_cell.row || j != sheet->active_cell.col)
 		    {
-		      x = COLUMN_LEFT_XPIXEL (sheet, j);
+		      x = g_sheet_column_start_pixel (sheet->column_geometry, j);
 		      y = g_sheet_row_start_pixel (sheet->row_geometry, i);
-		      width = COLUMN_LEFT_XPIXEL (sheet, j)- x+
+		      width = g_sheet_column_start_pixel (sheet->column_geometry, j)- x+
 			g_sheet_column_get_width (sheet->column_geometry, j);
 
 		      height = g_sheet_row_start_pixel (sheet->row_geometry, i) - y + g_sheet_row_get_height (sheet->row_geometry, i);
@@ -3419,13 +3044,12 @@ gtk_sheet_new_selection (GtkSheet *sheet, GtkSheetRange *range)
 	  selected= (i <= new_range.rowi && i >= new_range.row0 &&
 		     j <= new_range.coli && j >= new_range.col0) ? TRUE : FALSE;
 
-	  if (state == GTK_STATE_SELECTED && !selected &&
-	      g_sheet_column_get_visibility (sheet->column_geometry, j) && g_sheet_row_get_visibility (sheet->row_geometry, i))
+	  if (state == GTK_STATE_SELECTED && !selected)
 	    {
 
-	      x = COLUMN_LEFT_XPIXEL (sheet, j);
+	      x = g_sheet_column_start_pixel (sheet->column_geometry, j);
 	      y = g_sheet_row_start_pixel (sheet->row_geometry, i);
-	      width = COLUMN_LEFT_XPIXEL (sheet, j) - x + g_sheet_column_get_width (sheet->column_geometry, j);
+	      width = g_sheet_column_start_pixel (sheet->column_geometry, j) - x + g_sheet_column_get_width (sheet->column_geometry, j);
 	      height = g_sheet_row_start_pixel (sheet->row_geometry, i) - y + g_sheet_row_get_height (sheet->row_geometry, i);
 
 	      if (i == sheet->range.row0)
@@ -3455,13 +3079,12 @@ gtk_sheet_new_selection (GtkSheet *sheet, GtkSheetRange *range)
 		     j <= new_range.coli && j >= new_range.col0) ? TRUE : FALSE;
 
 	  if (state != GTK_STATE_SELECTED && selected &&
-	      g_sheet_column_get_visibility (sheet->column_geometry, j) && g_sheet_row_get_visibility (sheet->row_geometry, i) &&
 	      (i != sheet->active_cell.row || j != sheet->active_cell.col))
 	    {
 
-	      x = COLUMN_LEFT_XPIXEL (sheet, j);
+	      x = g_sheet_column_start_pixel (sheet->column_geometry, j);
 	      y = g_sheet_row_start_pixel (sheet->row_geometry, i);
-	      width = COLUMN_LEFT_XPIXEL (sheet, j) - x + g_sheet_column_get_width (sheet->column_geometry, j);
+	      width = g_sheet_column_start_pixel (sheet->column_geometry, j) - x + g_sheet_column_get_width (sheet->column_geometry, j);
 	      height = g_sheet_row_start_pixel (sheet->row_geometry, i) - y + g_sheet_row_get_height (sheet->row_geometry, i);
 
 	      if (i == new_range.row0)
@@ -3492,67 +3115,56 @@ gtk_sheet_new_selection (GtkSheet *sheet, GtkSheetRange *range)
     {
       for (j = aux_range.col0; j <= aux_range.coli; j++)
 	{
+	  state = gtk_sheet_cell_get_state (sheet, i, j);
 
-	  if (g_sheet_column_get_visibility (sheet->column_geometry, j) && g_sheet_row_get_visibility (sheet->row_geometry, i))
-	    {
-
-	      state = gtk_sheet_cell_get_state (sheet, i, j);
-
-	      mask1 = i == sheet->range.row0 ? 1 : 0;
-	      mask1 = i == sheet->range.rowi ? mask1 + 2 : mask1;
-	      mask1 = j == sheet->range.col0 ? mask1 + 4 : mask1;
-	      mask1 = j == sheet->range.coli ? mask1 + 8 : mask1;
-
-	      mask2 = i == new_range.row0 ? 1 : 0;
-	      mask2 = i == new_range.rowi ? mask2 + 2 : mask2;
-	      mask2 = j == new_range.col0 ? mask2 + 4 : mask2;
-	      mask2 = j == new_range.coli ? mask2 + 8 : mask2;
-	      if (mask2 != mask1 || (mask2 == mask1 && state != GTK_STATE_SELECTED))
-		{
-		  x = COLUMN_LEFT_XPIXEL (sheet, j);
-		  y = g_sheet_row_start_pixel (sheet->row_geometry, i);
-		  width = g_sheet_column_get_width (sheet->column_geometry, j);
-		  height = g_sheet_row_get_height (sheet->row_geometry, i);
-		  if (mask2 & 1)
-		    gdk_draw_rectangle (sheet->sheet_window,
-					sheet->xor_gc,
-					TRUE,
-					x + 1, y - 1,
-					width, 3);
-
-
-		  if (mask2 & 2)
-		    gdk_draw_rectangle (sheet->sheet_window,
-					sheet->xor_gc,
-					TRUE,
-					x + 1, y + height - 1,
-					width, 3);
-
-		  if (mask2 & 4)
-		    gdk_draw_rectangle (sheet->sheet_window,
-					sheet->xor_gc,
-					TRUE,
-					x - 1, y + 1,
-					3, height);
-
-
-		  if (mask2 & 8)
-		    gdk_draw_rectangle (sheet->sheet_window,
-					sheet->xor_gc,
-					TRUE,
-					x + width - 1, y + 1,
-					3, height);
-
-
-
-		}
+	  mask1 = i == sheet->range.row0 ? 1 : 0;
+	  mask1 = i == sheet->range.rowi ? mask1 + 2 : mask1;
+	  mask1 = j == sheet->range.col0 ? mask1 + 4 : mask1;
+	  mask1 = j == sheet->range.coli ? mask1 + 8 : mask1;
 
+	  mask2 = i == new_range.row0 ? 1 : 0;
+	  mask2 = i == new_range.rowi ? mask2 + 2 : mask2;
+	  mask2 = j == new_range.col0 ? mask2 + 4 : mask2;
+	  mask2 = j == new_range.coli ? mask2 + 8 : mask2;
+	  if (mask2 != mask1 || (mask2 == mask1 && state != GTK_STATE_SELECTED))
+	    {
+	      x = g_sheet_column_start_pixel (sheet->column_geometry, j);
+	      y = g_sheet_row_start_pixel (sheet->row_geometry, i);
+	      width = g_sheet_column_get_width (sheet->column_geometry, j);
+	      height = g_sheet_row_get_height (sheet->row_geometry, i);
+	      if (mask2 & 1)
+		gdk_draw_rectangle (sheet->sheet_window,
+				    sheet->xor_gc,
+				    TRUE,
+				    x + 1, y - 1,
+				    width, 3);
+
+
+	      if (mask2 & 2)
+		gdk_draw_rectangle (sheet->sheet_window,
+				    sheet->xor_gc,
+				    TRUE,
+				    x + 1, y + height - 1,
+				    width, 3);
+
+	      if (mask2 & 4)
+		gdk_draw_rectangle (sheet->sheet_window,
+				    sheet->xor_gc,
+				    TRUE,
+				    x - 1, y + 1,
+				    3, height);
+
+
+	      if (mask2 & 8)
+		gdk_draw_rectangle (sheet->sheet_window,
+				    sheet->xor_gc,
+				    TRUE,
+				    x + width - 1, y + 1,
+				    3, height);
 	    }
-
 	}
     }
 
-
   *range = new_range;
 }
 
@@ -3560,63 +3172,22 @@ static void
 gtk_sheet_draw_border (GtkSheet *sheet, GtkSheetRange new_range)
 {
   GdkRectangle area;
-  gint width, height;
-
-  gint x = COLUMN_LEFT_XPIXEL (sheet, new_range.col0);
-  gint y = g_sheet_row_start_pixel (sheet->row_geometry, new_range.row0);
-
-  if ( sheet->row_titles_visible)
-    x += sheet->row_title_area.width;
-
-  x -= sheet->hadjustment->value;
-
-  if ( sheet->column_titles_visible)
-    y += sheet->column_title_area.height;
-
-  y -= sheet->vadjustment->value;
-
-  width = COLUMN_LEFT_XPIXEL (sheet, new_range.coli) -
-    COLUMN_LEFT_XPIXEL (sheet, new_range.col0)
-    +
-    g_sheet_column_get_width (sheet->column_geometry, new_range.coli);
-
-  height = g_sheet_row_start_pixel (sheet->row_geometry, new_range.rowi) -
-    g_sheet_row_start_pixel (sheet->row_geometry, new_range.row0)
-    +
-    g_sheet_row_get_height (sheet->row_geometry, new_range.rowi);
-
-  area.x = COLUMN_LEFT_XPIXEL (sheet, MIN_VISIBLE_COLUMN (sheet));
-  if ( sheet->row_titles_visible)
-    area.x += sheet->row_title_area.width;
-
-  area.x -= sheet->hadjustment->value;
-
-  area.y = g_sheet_row_start_pixel (sheet->row_geometry, MIN_VISIBLE_ROW (sheet));
-  if ( sheet->column_titles_visible)
-    area.y += sheet->column_title_area.height;
-
-  area.y -= sheet->vadjustment->value;
 
+  rectangle_from_range (sheet, &new_range, &area);
 
-  area.width = sheet->sheet_window_width;
-  area.height = sheet->sheet_window_height;
-
-  gdk_gc_set_clip_rectangle (sheet->xor_gc, &area);
-
-      gdk_draw_rectangle (sheet->sheet_window,
-			  sheet->xor_gc,
+  gdk_draw_rectangle (sheet->sheet_window,
+		      sheet->xor_gc,
 		      FALSE,
-		      x, y,
-		      width - 2,
-		      height - 2);
-
-  gdk_gc_set_clip_rectangle (sheet->xor_gc, NULL);
+		      area.x + 1,
+		      area.y + 1,
+		      area.width - 2,
+		      area.height - 2);
 }
 
 
 static void
-gtk_sheet_real_select_range (GtkSheet * sheet,
-			     const GtkSheetRange * range)
+gtk_sheet_real_select_range (GtkSheet *sheet,
+			     const GtkSheetRange *range)
 {
   gint state;
 
@@ -3631,6 +3202,7 @@ gtk_sheet_real_select_range (GtkSheet * sheet,
 
   state = sheet->state;
 
+#if 0
   if (range->coli != sheet->range.coli || range->col0 != sheet->range.col0 ||
       range->rowi != sheet->range.rowi || range->row0 != sheet->range.row0)
     {
@@ -3638,9 +3210,9 @@ gtk_sheet_real_select_range (GtkSheet * sheet,
     }
   else
     {
-      gtk_sheet_draw_backing_pixmap (sheet, sheet->range);
       gtk_sheet_range_draw_selection (sheet, sheet->range);
     }
+#endif
 
   gtk_sheet_update_primary_selection (sheet);
 
@@ -3657,7 +3229,7 @@ gtk_sheet_get_selected_range (GtkSheet *sheet, GtkSheetRange *range)
 
 
 void
-gtk_sheet_select_range (GtkSheet * sheet, const GtkSheetRange *range)
+gtk_sheet_select_range (GtkSheet *sheet, const GtkSheetRange *range)
 {
   g_return_if_fail (sheet != NULL);
 
@@ -3686,7 +3258,7 @@ gtk_sheet_select_range (GtkSheet * sheet, const GtkSheetRange *range)
 }
 
 void
-gtk_sheet_unselect_range (GtkSheet * sheet)
+gtk_sheet_unselect_range (GtkSheet *sheet)
 {
   if (! GTK_WIDGET_REALIZED (GTK_WIDGET (sheet)))
     return;
@@ -3700,7 +3272,7 @@ gtk_sheet_unselect_range (GtkSheet * sheet)
 
 
 static void
-gtk_sheet_real_unselect_range (GtkSheet * sheet,
+gtk_sheet_real_unselect_range (GtkSheet *sheet,
 			       const GtkSheetRange *range)
 {
   g_return_if_fail (sheet != NULL);
@@ -3715,8 +3287,10 @@ 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;
@@ -3726,8 +3300,8 @@ gtk_sheet_real_unselect_range (GtkSheet * sheet,
 
 
 static gint
-gtk_sheet_expose (GtkWidget * widget,
-		  GdkEventExpose * event)
+gtk_sheet_expose (GtkWidget *widget,
+		  GdkEventExpose *event)
 {
   GtkSheet *sheet;
   GtkSheetRange range;
@@ -3736,65 +3310,75 @@ gtk_sheet_expose (GtkWidget * widget,
   g_return_val_if_fail (GTK_IS_SHEET (widget), FALSE);
   g_return_val_if_fail (event != NULL, FALSE);
 
-  g_print ("%s %p\n", __FUNCTION__, widget);
-
   sheet = GTK_SHEET (widget);
 
-  if (GTK_WIDGET_DRAWABLE (widget))
+  if (!GTK_WIDGET_DRAWABLE (widget))
+    return FALSE;
+
+  /* exposure events on the sheet */
+  if (event->window == sheet->row_title_window &&
+      sheet->row_titles_visible)
     {
-      range.row0 = yyy_row_ypixel_to_row (sheet, event->area.y);
-      range.col0 = COLUMN_FROM_XPIXEL (sheet, event->area.x);
-      range.rowi = yyy_row_ypixel_to_row (sheet,
-					  event->area.y + event->area.height);
+      gint i;
+      for (i = min_visible_row (sheet); i <= max_visible_row (sheet); i++)
+	gtk_sheet_row_title_button_draw (sheet, i);
+    }
 
-      range.coli = COLUMN_FROM_XPIXEL (sheet,
-				       event->area.x + event->area.width);
+  if (event->window == sheet->column_title_window &&
+      sheet->column_titles_visible)
+    {
+      gint i;
+      for (i = min_visible_column (sheet);
+	   i <= max_visible_column (sheet);
+	   ++i)
+	gtk_sheet_column_title_button_draw (sheet, i);
+    }
 
-      g_print ("Redrawing rows %ld--%ld, columns %ld--%ld\n",
-	       range.row0, range.rowi, range.col0, range.coli);
 
+  range.row0 =
+    yyy_row_ypixel_to_row (sheet,
+			   event->area.y + sheet->vadjustment->value);
+  range.row0--;
 
-      /* exposure events on the sheet */
-      if (event->window == sheet->row_title_window &&
-	  sheet->row_titles_visible)
-	{
-	  gint i;
-	  for (i = MIN_VISIBLE_ROW (sheet); i <= MAX_VISIBLE_ROW (sheet); i++)
-	    gtk_sheet_row_title_button_draw (sheet, i);
-	}
+  range.rowi =
+    yyy_row_ypixel_to_row (sheet,
+			   event->area.y +
+			   event->area.height + sheet->vadjustment->value);
+  range.rowi++;
 
-      if (event->window == sheet->column_title_window &&
-	  sheet->column_titles_visible)
-	{
-	  gint i;
-	  for (i = MIN_VISIBLE_COLUMN (sheet);
-	       i <= MAX_VISIBLE_COLUMN (sheet);
-	       ++i)
-	    gtk_sheet_column_title_button_draw (sheet, i);
-	}
+  range.col0 =
+    column_from_xpixel (sheet,
+			event->area.x + sheet->hadjustment->value);
+  range.col0--;
 
-      if (event->window == sheet->sheet_window)
+  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);
+
+      if (sheet->state != GTK_SHEET_NORMAL)
 	{
-	  gtk_sheet_draw_backing_pixmap (sheet, range);
+	  if (gtk_sheet_range_isvisible (sheet, sheet->range))
+	    gtk_sheet_range_draw (sheet, &sheet->range);
 
-	  if (sheet->state != GTK_SHEET_NORMAL)
-	    {
-	      if (gtk_sheet_range_isvisible (sheet, sheet->range))
-		gtk_sheet_draw_backing_pixmap (sheet, sheet->range);
-	      if (GTK_SHEET_IN_RESIZE (sheet) || GTK_SHEET_IN_DRAG (sheet))
-		gtk_sheet_draw_backing_pixmap (sheet, sheet->drag_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);
-	    }
+	  if (GTK_SHEET_IN_RESIZE (sheet) || GTK_SHEET_IN_DRAG (sheet))
+	    gtk_sheet_range_draw (sheet, &sheet->drag_range);
 
-	  if ((!GTK_SHEET_IN_XDRAG (sheet)) && (!GTK_SHEET_IN_YDRAG (sheet)))
-	    {
-	      if (sheet->state == GTK_SHEET_NORMAL)
-		gtk_sheet_draw_active_cell (sheet);
-	    }
+	  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);
+	}
+
+      if ((!GTK_SHEET_IN_XDRAG (sheet)) && (!GTK_SHEET_IN_YDRAG (sheet)))
+	{
+	  if (sheet->state == GTK_SHEET_NORMAL)
+	    gtk_sheet_draw_active_cell (sheet);
 	}
     }
 
@@ -3808,12 +3392,13 @@ gtk_sheet_expose (GtkWidget * widget,
 
 
 static gboolean
-gtk_sheet_button_press (GtkWidget * widget,
-			GdkEventButton * event)
+gtk_sheet_button_press (GtkWidget *widget,
+			GdkEventButton *event)
 {
   GtkSheet *sheet;
   GdkModifierType mods;
-  gint x, y, row, column;
+  gint x, y;
+  gint  row, column;
   gboolean veto;
 
   g_return_val_if_fail (widget != NULL, FALSE);
@@ -3994,7 +3579,7 @@ gtk_sheet_button_press (GtkWidget * widget,
 	}
       else
 	{
-	  gtk_sheet_click_cell (sheet, row, column, &veto);
+	  veto = gtk_sheet_click_cell (sheet, row, column);
 	  if (veto) GTK_SHEET_SET_FLAGS (sheet, GTK_SHEET_IN_SELECTION);
 	}
     }
@@ -4007,11 +3592,11 @@ gtk_sheet_button_press (GtkWidget * widget,
 
       x += sheet->hadjustment->value;
 
-      column = COLUMN_FROM_XPIXEL (sheet, x);
+      column = column_from_xpixel (sheet, x);
 
       if (g_sheet_column_get_sensitivity (sheet->column_geometry, column))
 	{
-	  gtk_sheet_click_cell (sheet, - 1, column, &veto);
+	  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);
@@ -4029,7 +3614,7 @@ gtk_sheet_button_press (GtkWidget * widget,
       row = yyy_row_ypixel_to_row (sheet, y);
       if (g_sheet_row_get_sensitivity (sheet->row_geometry, row))
 	{
-	  gtk_sheet_click_cell (sheet, row, - 1, &veto);
+	  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);
@@ -4039,108 +3624,89 @@ gtk_sheet_button_press (GtkWidget * widget,
   return TRUE;
 }
 
-static void
-gtk_sheet_click_cell (GtkSheet *sheet, gint row, gint column, gboolean *veto)
+static gboolean
+gtk_sheet_click_cell (GtkSheet *sheet, gint row, gint column)
 {
-  *veto = TRUE;
-
-  if (row >= g_sheet_row_get_row_count (sheet->row_geometry) || column >= g_sheet_column_get_column_count (sheet->column_geometry))
-    {
-      *veto = FALSE;
-      return;
-    }
+  gboolean forbid_move;
 
-  if (column >= 0 && row >= 0)
+  if (row >= g_sheet_row_get_row_count (sheet->row_geometry)
+      || column >= g_sheet_column_get_column_count (sheet->column_geometry))
     {
-      if (! g_sheet_column_get_visibility (sheet->column_geometry, column)
-	  || !g_sheet_row_get_visibility (sheet->row_geometry, row))
-      {
-	*veto = FALSE;
-	return;
-      }
+      return FALSE;
     }
 
-  _gtkextra_signal_emit (GTK_OBJECT (sheet), sheet_signals[TRAVERSE],
-			 sheet->active_cell.row, sheet->active_cell.col,
-			 &row, &column, veto);
+  g_signal_emit (sheet, sheet_signals[TRAVERSE], 0,
+		 sheet->active_cell.row, sheet->active_cell.col,
+		 &row, &column, &forbid_move);
 
-  if (!*veto)
+  if (forbid_move)
     {
-      if (sheet->state == GTK_STATE_NORMAL) return;
+      if (sheet->state == GTK_STATE_NORMAL)
+	return FALSE;
 
       row = sheet->active_cell.row;
       column = sheet->active_cell.col;
 
       gtk_sheet_activate_cell (sheet, row, column);
-      return;
+      return FALSE;
     }
 
   if (row == -1 && column >= 0)
     {
-      if (gtk_sheet_autoscroll (sheet))
-	gtk_sheet_move_query (sheet, row, column);
       gtk_sheet_select_column (sheet, column);
-      return;
+      return TRUE;
     }
+
   if (column == -1 && row >= 0)
     {
-      if (gtk_sheet_autoscroll (sheet))
-	gtk_sheet_move_query (sheet, row, column);
       gtk_sheet_select_row (sheet, row);
-      return;
+      return TRUE;
     }
 
-  if (row == - 1 && column == - 1)
+  if (row == -1 && column == -1)
     {
       sheet->range.row0 = 0;
       sheet->range.col0 = 0;
       sheet->range.rowi = g_sheet_row_get_row_count (sheet->row_geometry) - 1;
-      sheet->range.coli = g_sheet_column_get_column_count (sheet->column_geometry) - 1;
-      sheet->active_cell.row = 0;
-      sheet->active_cell.col = 0;
-      gtk_sheet_select_range (sheet, NULL);
-      return;
-    }
-
-  if (row != -1 && column != -1)
-    {
-      if (sheet->state != GTK_SHEET_NORMAL)
-	{
-	  sheet->state = GTK_SHEET_NORMAL;
-	  gtk_sheet_real_unselect_range (sheet, NULL);
-	}
-      else
-	{
-	  gtk_sheet_deactivate_cell (sheet);
-	  gtk_sheet_activate_cell (sheet, row, column);
-	}
+      sheet->range.coli =
+	g_sheet_column_get_column_count (sheet->column_geometry) - 1;
+      sheet->active_cell.row = 0;
+      sheet->active_cell.col = 0;
+      gtk_sheet_select_range (sheet, NULL);
+      return TRUE;
+    }
 
-      if (gtk_sheet_autoscroll (sheet))
-	gtk_sheet_move_query (sheet, row, column);
-      sheet->active_cell.row = row;
-      sheet->active_cell.col = column;
-      sheet->selection_cell.row = row;
-      sheet->selection_cell.col = column;
-      sheet->range.row0 = row;
-      sheet->range.col0 = column;
-      sheet->range.rowi = row;
-      sheet->range.coli = column;
+  if (sheet->state != GTK_SHEET_NORMAL)
+    {
       sheet->state = GTK_SHEET_NORMAL;
-      GTK_SHEET_SET_FLAGS (sheet, GTK_SHEET_IN_SELECTION);
-      gtk_sheet_draw_active_cell (sheet);
-      return;
+      gtk_sheet_real_unselect_range (sheet, NULL);
+    }
+  else
+    {
+      gtk_sheet_deactivate_cell (sheet);
+      gtk_sheet_activate_cell (sheet, row, column);
     }
 
-  g_assert_not_reached ();
-  gtk_sheet_activate_cell (sheet, sheet->active_cell.row,
-			   sheet->active_cell.col);
+  sheet->active_cell.row = row;
+  sheet->active_cell.col = column;
+  sheet->selection_cell.row = row;
+  sheet->selection_cell.col = column;
+  sheet->range.row0 = row;
+  sheet->range.col0 = column;
+  sheet->range.rowi = row;
+  sheet->range.coli = column;
+  sheet->state = GTK_SHEET_NORMAL;
+  GTK_SHEET_SET_FLAGS (sheet, GTK_SHEET_IN_SELECTION);
+  gtk_sheet_draw_active_cell (sheet);
+  return TRUE;
 }
 
 static gint
-gtk_sheet_button_release (GtkWidget * widget,
-			  GdkEventButton * event)
+gtk_sheet_button_release (GtkWidget *widget,
+			  GdkEventButton *event)
 {
   gint y;
+  GdkDisplay *display = gtk_widget_get_display (widget);
 
   GtkSheet *sheet = GTK_SHEET (widget);
 
@@ -4152,7 +3718,7 @@ gtk_sheet_button_release (GtkWidget * widget,
       GTK_SHEET_UNSET_FLAGS (sheet, GTK_SHEET_IN_XDRAG);
       GTK_SHEET_UNSET_FLAGS (sheet, GTK_SHEET_IN_SELECTION);
 
-      gdk_pointer_ungrab (event->time);
+      gdk_display_pointer_ungrab (display, event->time);
       draw_xor_vline (sheet);
 
       width = new_column_width (sheet, sheet->drag_cell.col, &xpos);
@@ -4166,7 +3732,7 @@ gtk_sheet_button_release (GtkWidget * widget,
       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_pointer_ungrab (event->time);
+      gdk_display_pointer_ungrab (display, event->time);
       draw_xor_hline (sheet);
 
       gtk_sheet_set_row_height (sheet, sheet->drag_cell.row,
@@ -4181,7 +3747,7 @@ gtk_sheet_button_release (GtkWidget * widget,
       GtkSheetRange old_range;
       draw_xor_rectangle (sheet, sheet->drag_range);
       GTK_SHEET_UNSET_FLAGS (sheet, GTK_SHEET_IN_DRAG);
-      gdk_pointer_ungrab (event->time);
+      gdk_display_pointer_ungrab (display, event->time);
 
       gtk_sheet_real_unselect_range (sheet, NULL);
 
@@ -4206,7 +3772,7 @@ gtk_sheet_button_release (GtkWidget * widget,
       GtkSheetRange old_range;
       draw_xor_rectangle (sheet, sheet->drag_range);
       GTK_SHEET_UNSET_FLAGS (sheet, GTK_SHEET_IN_RESIZE);
-      gdk_pointer_ungrab (event->time);
+      gdk_display_pointer_ungrab (display, event->time);
 
       gtk_sheet_real_unselect_range (sheet, NULL);
 
@@ -4235,13 +3801,13 @@ gtk_sheet_button_release (GtkWidget * widget,
   if (sheet->state == GTK_SHEET_NORMAL && GTK_SHEET_IN_SELECTION (sheet))
     {
       GTK_SHEET_UNSET_FLAGS (sheet, GTK_SHEET_IN_SELECTION);
-      gdk_pointer_ungrab (event->time);
+      gdk_display_pointer_ungrab (display, event->time);
       gtk_sheet_activate_cell (sheet, sheet->active_cell.row,
 			       sheet->active_cell.col);
     }
 
   if (GTK_SHEET_IN_SELECTION)
-    gdk_pointer_ungrab (event->time);
+    gdk_display_pointer_ungrab (display, event->time);
   gtk_grab_remove (GTK_WIDGET (sheet));
 
   GTK_SHEET_UNSET_FLAGS (sheet, GTK_SHEET_IN_SELECTION);
@@ -4252,6 +3818,7 @@ gtk_sheet_button_release (GtkWidget * widget,
 
 
 
+
 /* Shamelessly lifted from gtktooltips */
 static gboolean
 gtk_sheet_subtitle_paint_window (GtkWidget *tip_window)
@@ -4389,7 +3956,7 @@ motion_timeout_callback (gpointer data)
 
 	  text = g_sheet_column_get_subtitle (col_geo, column);
 
-	  show_subtitle (sheet, -1, column, text );
+	  show_subtitle (sheet, -1, column, text);
 
 	  g_free (text);
 	}
@@ -4406,6 +3973,7 @@ gtk_sheet_motion (GtkWidget *widget,  GdkEventMotion *event)
   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);
@@ -4413,6 +3981,8 @@ gtk_sheet_motion (GtkWidget *widget,  GdkEventMotion *event)
 
   sheet = GTK_SHEET (widget);
 
+  display = gtk_widget_get_display (widget);
+
   /* selections on the sheet */
   x = event->x;
   y = event->y;
@@ -4432,7 +4002,8 @@ gtk_sheet_motion (GtkWidget *widget,  GdkEventMotion *event)
 
       if ( gtk_sheet_get_pixel_info (sheet, wx, wy, &row, &column) )
 	{
-	  if ( row != sheet->hover_window->row || column != sheet->hover_window->column)
+	  if ( row != sheet->hover_window->row ||
+	       column != sheet->hover_window->column)
 	    {
 	      gtk_widget_hide (sheet->hover_window->window);
 	    }
@@ -4449,7 +4020,7 @@ 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 (GDK_SB_H_DOUBLE_ARROW);
+	      sheet->cursor_drag = gdk_cursor_new_for_display (display, GDK_SB_H_DOUBLE_ARROW);
 	      gdk_window_set_cursor (sheet->column_title_window,
 				     sheet->cursor_drag);
 	    }
@@ -4461,7 +4032,7 @@ 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 (GDK_TOP_LEFT_ARROW);
+	      sheet->cursor_drag = gdk_cursor_new_for_display (display, GDK_TOP_LEFT_ARROW);
 	      gdk_window_set_cursor (sheet->column_title_window,
 				     sheet->cursor_drag);
 	    }
@@ -4477,7 +4048,7 @@ 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 (GDK_SB_V_DOUBLE_ARROW);
+	      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);
 	    }
 	}
@@ -4488,7 +4059,7 @@ 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 (GDK_TOP_LEFT_ARROW);
+	      sheet->cursor_drag = gdk_cursor_new_for_display (display, GDK_TOP_LEFT_ARROW);
 	      gdk_window_set_cursor (sheet->row_title_window, sheet->cursor_drag);
 	    }
 	}
@@ -4503,7 +4074,7 @@ 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 (GDK_PLUS);
+      sheet->cursor_drag = gdk_cursor_new_for_display (display, GDK_PLUS);
       gdk_window_set_cursor (sheet->sheet_window, sheet->cursor_drag);
     }
 
@@ -4516,7 +4087,7 @@ 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 (GDK_TOP_LEFT_ARROW);
+      sheet->cursor_drag = gdk_cursor_new_for_display (display, GDK_TOP_LEFT_ARROW);
       gdk_window_set_cursor (sheet->sheet_window, sheet->cursor_drag);
     }
 
@@ -4529,7 +4100,7 @@ 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 (GDK_SIZING);
+      sheet->cursor_drag = gdk_cursor_new_for_display (display, GDK_SIZING);
       gdk_window_set_cursor (sheet->sheet_window, sheet->cursor_drag);
     }
 
@@ -4539,7 +4110,7 @@ gtk_sheet_motion (GtkWidget *widget,  GdkEventMotion *event)
 
   if (GTK_SHEET_IN_XDRAG (sheet))
     {
-	x = event->x;
+      x = event->x;
 
       new_column_width (sheet, sheet->drag_cell.col, &x);
 #if 0
@@ -4573,7 +4144,7 @@ gtk_sheet_motion (GtkWidget *widget,  GdkEventMotion *event)
   if (GTK_SHEET_IN_DRAG (sheet))
     {
       GtkSheetRange aux;
-      column = COLUMN_FROM_XPIXEL (sheet, x)- sheet->drag_cell.col;
+      column = column_from_xpixel (sheet, x)- sheet->drag_cell.col;
       row = yyy_row_ypixel_to_row (sheet, y) - sheet->drag_cell.row;
       if (sheet->state == GTK_SHEET_COLUMN_SELECTED) row = 0;
       if (sheet->state == GTK_SHEET_ROW_SELECTED) column = 0;
@@ -4603,17 +4174,17 @@ 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 - COLUMN_LEFT_XPIXEL (sheet, sheet->drag_cell.col)) >
+      if (abs (x - g_sheet_column_start_pixel (sheet->column_geometry, sheet->drag_cell.col)) >
 	  abs (y - g_sheet_row_start_pixel (sheet->row_geometry, sheet->drag_cell.row))) v_h = 2;
 
-      current_col = COLUMN_FROM_XPIXEL (sheet, x);
+      current_col = column_from_xpixel (sheet, x);
       current_row = yyy_row_ypixel_to_row (sheet, y);
       column = current_col - sheet->drag_cell.col;
       row = current_row - sheet->drag_cell.row;
 
       /*use half of column width resp. row height as threshold to
 	expand selection*/
-      col_threshold = COLUMN_LEFT_XPIXEL (sheet, current_col) +
+      col_threshold = g_sheet_column_start_pixel (sheet->column_geometry, current_col) +
 	g_sheet_column_get_width (sheet->column_geometry, current_col) / 2;
       if (column > 0)
 	{
@@ -4701,7 +4272,7 @@ gtk_sheet_crossing_notify (GtkWidget *widget,
 static gboolean
 gtk_sheet_move_query (GtkSheet *sheet, gint row, gint column)
 {
-  guint height, width;
+  gint height, width;
   gint new_row = row;
   gint new_col = column;
 
@@ -4710,15 +4281,18 @@ gtk_sheet_move_query (GtkSheet *sheet, gint row, gint column)
   gfloat row_align = -1.0;
   gfloat col_align = -1.0;
 
-  height = sheet->sheet_window_height;
-  width = sheet->sheet_window_width;
+  if (!GTK_WIDGET_REALIZED (GTK_WIDGET (sheet)))
+    return FALSE;
+
+  gdk_drawable_get_size (sheet->sheet_window, &width, &height);
 
-  if (row >= MAX_VISIBLE_ROW (sheet) && sheet->state != GTK_SHEET_COLUMN_SELECTED)
+  if (row >= max_visible_row (sheet) &&
+      sheet->state != GTK_SHEET_COLUMN_SELECTED)
     {
       row_align = 1.;
       new_row = MIN (g_sheet_row_get_row_count (sheet->row_geometry) - 1, row + 1);
       row_move = TRUE;
-      if (MAX_VISIBLE_ROW (sheet) == g_sheet_row_get_row_count (sheet->row_geometry) - 1 &&
+      if (max_visible_row (sheet) == g_sheet_row_get_row_count (sheet->row_geometry) - 1 &&
 	  g_sheet_row_start_pixel (sheet->row_geometry, g_sheet_row_get_row_count (sheet->row_geometry) - 1) +
 	  g_sheet_row_get_height (sheet->row_geometry, g_sheet_row_get_row_count (sheet->row_geometry) - 1) < height)
 	{
@@ -4726,25 +4300,26 @@ gtk_sheet_move_query (GtkSheet *sheet, gint row, gint column)
 	  row_align = -1.;
 	}
     }
-  if (row < MIN_VISIBLE_ROW (sheet) && sheet->state != GTK_SHEET_COLUMN_SELECTED)
+
+  if (row < min_visible_row (sheet) && sheet->state != GTK_SHEET_COLUMN_SELECTED)
     {
       row_align= 0.;
       row_move = TRUE;
     }
-  if (column >= MAX_VISIBLE_COLUMN (sheet) && sheet->state != GTK_SHEET_ROW_SELECTED)
+  if (column >= max_visible_column (sheet) && sheet->state != GTK_SHEET_ROW_SELECTED)
     {
       col_align = 1.;
       new_col = MIN (g_sheet_column_get_column_count (sheet->column_geometry) - 1, column + 1);
       column_move = TRUE;
-      if (MAX_VISIBLE_COLUMN (sheet) == (g_sheet_column_get_column_count (sheet->column_geometry) - 1) &&
-	  COLUMN_LEFT_XPIXEL (sheet, g_sheet_column_get_column_count (sheet->column_geometry) - 1) +
+      if (max_visible_column (sheet) == (g_sheet_column_get_column_count (sheet->column_geometry) - 1) &&
+	  g_sheet_column_start_pixel (sheet->column_geometry, g_sheet_column_get_column_count (sheet->column_geometry) - 1) +
 	  g_sheet_column_get_width (sheet->column_geometry, g_sheet_column_get_column_count (sheet->column_geometry) - 1) < width)
 	{
 	  column_move = FALSE;
 	  col_align = -1.;
 	}
     }
-  if (column < MIN_VISIBLE_COLUMN (sheet) && sheet->state != GTK_SHEET_ROW_SELECTED)
+  if (column < min_visible_column (sheet) && sheet->state != GTK_SHEET_ROW_SELECTED)
     {
       col_align = 0.0;
       column_move = TRUE;
@@ -4822,266 +4397,178 @@ gtk_sheet_entry_key_press (GtkWidget *widget,
   return focus;
 }
 
-static gint
-gtk_sheet_key_press (GtkWidget *widget,
-		     GdkEventKey *key)
+
+/* Number of rows in a step-increment */
+#define ROWS_PER_STEP 1
+
+
+static void
+page_vertical (GtkSheet *sheet, GtkScrollType dir)
 {
-  GtkSheet *sheet;
-  gint row, col;
-  gint state;
-  gboolean extend_selection = FALSE;
-  gboolean force_move = FALSE;
-  gboolean in_selection = FALSE;
-  gboolean veto = TRUE;
-  gint scroll = 1;
+  gint old_row = sheet->active_cell.row ;
+  glong vpixel = g_sheet_row_start_pixel (sheet->row_geometry, old_row);
 
-  sheet = GTK_SHEET (widget);
+  gint new_row;
 
-  if (key->state & GDK_CONTROL_MASK || key->keyval == GDK_Control_L ||
-      key->keyval == GDK_Control_R) return FALSE;
+  vpixel -= g_sheet_row_start_pixel (sheet->row_geometry,
+				     min_visible_row (sheet));
 
-  extend_selection = (key->state & GDK_SHIFT_MASK) || key->keyval == GDK_Shift_L
-    || key->keyval == GDK_Shift_R;
+  switch ( dir)
+    {
+    case GTK_SCROLL_PAGE_DOWN:
+      gtk_adjustment_set_value (sheet->vadjustment,
+				sheet->vadjustment->value +
+				sheet->vadjustment->page_increment);
+      break;
+    case GTK_SCROLL_PAGE_UP:
+      gtk_adjustment_set_value (sheet->vadjustment,
+				sheet->vadjustment->value -
+				sheet->vadjustment->page_increment);
+
+      break;
+    default:
+      g_assert_not_reached ();
+      break;
+    }
+
+
+  vpixel += g_sheet_row_start_pixel (sheet->row_geometry,
+				     min_visible_row (sheet));
+
+  new_row =  yyy_row_ypixel_to_row (sheet, vpixel);
+
+  gtk_sheet_activate_cell (sheet, new_row,
+			   sheet->active_cell.col);
+}
+
+
+static void
+step_horizontal (GtkSheet *sheet, GtkScrollType dir)
+{
+  switch ( dir)
+    {
+    case GTK_SCROLL_STEP_RIGHT:
+
+      gtk_sheet_activate_cell (sheet,
+			       sheet->active_cell.row,
+			       sheet->active_cell.col + 1);
+      break;
+    case GTK_SCROLL_STEP_LEFT:
+
+      gtk_sheet_activate_cell (sheet,
+			       sheet->active_cell.row,
+			       sheet->active_cell.col - 1);
+      break;
+
+    default:
+      g_assert_not_reached ();
+      break;
+    }
+
+  if ( sheet->active_cell.col >= max_visible_column (sheet))
+    {
+      glong hpos  =
+	g_sheet_column_start_pixel (sheet->column_geometry,
+				    sheet->active_cell.col + 1);
+      hpos -= sheet->hadjustment->page_size;
+
+      gtk_adjustment_set_value (sheet->hadjustment,
+				hpos);
+    }
+  else if ( sheet->active_cell.col <= min_visible_column (sheet))
+    {
+      glong hpos  =
+	g_sheet_column_start_pixel (sheet->column_geometry,
+				    sheet->active_cell.col);
+
+      gtk_adjustment_set_value (sheet->hadjustment,
+				hpos);
+    }
+}
+
+static gboolean
+gtk_sheet_key_press (GtkWidget *widget,
+		     GdkEventKey *key)
+{
+  GtkSheet *sheet = GTK_SHEET (widget);
 
-  state = sheet->state;
-  in_selection = GTK_SHEET_IN_SELECTION (sheet);
   GTK_SHEET_UNSET_FLAGS (sheet, GTK_SHEET_IN_SELECTION);
 
   switch (key->keyval)
     {
-    case GDK_Return: case GDK_KP_Enter:
-      if (sheet->state == GTK_SHEET_NORMAL &&
-	  !GTK_SHEET_IN_SELECTION (sheet))
-	g_signal_stop_emission_by_name (gtk_sheet_get_entry (sheet),
-					"key-press-event");
-      row = sheet->active_cell.row;
-      col = sheet->active_cell.col;
-      if (sheet->state == GTK_SHEET_COLUMN_SELECTED)
-	row = MIN_VISIBLE_ROW (sheet)- 1;
-      if (sheet->state == GTK_SHEET_ROW_SELECTED)
-	col = MIN_VISIBLE_COLUMN (sheet);
-      if (row < g_sheet_row_get_row_count (sheet->row_geometry) - 1)
-	{
-	  row = row + scroll;
-	  while (!g_sheet_row_get_visibility (sheet->row_geometry, row) && row < g_sheet_row_get_row_count (sheet->row_geometry) - 1)
-	    row++;
-	}
-      gtk_sheet_click_cell (sheet, row, col, &veto);
-      extend_selection = FALSE;
+    case GDK_Tab:
+    case GDK_Right:
+      step_horizontal (sheet, GTK_SCROLL_STEP_RIGHT);
       break;
     case GDK_ISO_Left_Tab:
-      row = sheet->active_cell.row;
-      col = sheet->active_cell.col;
-      if (sheet->state == GTK_SHEET_ROW_SELECTED)
-	col = MIN_VISIBLE_COLUMN (sheet)- 1;
-      if (sheet->state == GTK_SHEET_COLUMN_SELECTED)
-	row = MIN_VISIBLE_ROW (sheet);
-      if (col > 0)
-	{
-	  col = col - scroll;
-	  while (! g_sheet_column_get_visibility (sheet->column_geometry, col) && col > 0) col--;
-	  col = MAX (0, col);
-	}
-      gtk_sheet_click_cell (sheet, row, col, &veto);
-      extend_selection = FALSE;
+    case GDK_Left:
+      step_horizontal (sheet, GTK_SCROLL_STEP_LEFT);
       break;
-    case GDK_Tab:
-      row = sheet->active_cell.row;
-      col = sheet->active_cell.col;
-      if (sheet->state == GTK_SHEET_ROW_SELECTED)
-	col = MIN_VISIBLE_COLUMN (sheet)- 1;
-      if (sheet->state == GTK_SHEET_COLUMN_SELECTED)
-	row = MIN_VISIBLE_ROW (sheet);
-      if (col < g_sheet_column_get_column_count (sheet->column_geometry) - 1)
-	{
-	  col = col + scroll;
-	  while (! g_sheet_column_get_visibility (sheet->column_geometry, col) &&
-		 col < g_sheet_column_get_column_count (sheet->column_geometry) - 1)
-	    col++;
-	}
-      gtk_sheet_click_cell (sheet, row, col, &veto);
-      extend_selection = FALSE;
+
+    case GDK_Return:
+    case GDK_Down:
+      gtk_sheet_activate_cell (sheet,
+			       sheet->active_cell.row + ROWS_PER_STEP,
+			       sheet->active_cell.col);
+
+      if ( sheet->active_cell.row >= max_visible_row (sheet))
+	gtk_adjustment_set_value (sheet->vadjustment,
+				  sheet->vadjustment->value +
+				  sheet->vadjustment->step_increment);
       break;
-    case GDK_Page_Up:
-      scroll = MAX_VISIBLE_ROW (sheet)- MIN_VISIBLE_ROW (sheet)+1;
     case GDK_Up:
-      if (extend_selection)
-	{
-	  if (state == GTK_STATE_NORMAL)
-	    {
-	      row = sheet->active_cell.row;
-	      col = sheet->active_cell.col;
-	      gtk_sheet_click_cell (sheet, row, col, &veto);
-	      if (!veto) break;
-	    }
-	  if (sheet->selection_cell.row > 0)
-	    {
-	      row = sheet->selection_cell.row - scroll;
-	      while (!g_sheet_row_get_visibility (sheet->row_geometry, row) && row > 0) row--;
-	      row = MAX (0, row);
-	      gtk_sheet_extend_selection (sheet, row, sheet->selection_cell.col);
-	    }
-	  return TRUE;
-	}
-      col = sheet->active_cell.col;
-      row = sheet->active_cell.row;
-      if (state == GTK_SHEET_COLUMN_SELECTED)
-	row = MIN_VISIBLE_ROW (sheet);
-      if (state == GTK_SHEET_ROW_SELECTED)
-	col = MIN_VISIBLE_COLUMN (sheet);
-      row = row - scroll;
-      while (!g_sheet_row_get_visibility (sheet->row_geometry, row) && row > 0) row--;
-      row = MAX (0, row);
-      gtk_sheet_click_cell (sheet, row, col, &veto);
-      extend_selection = FALSE;
+      gtk_sheet_activate_cell (sheet,
+			       sheet->active_cell.row - ROWS_PER_STEP,
+			       sheet->active_cell.col);
+
+      if ( sheet->active_cell.row < min_visible_row (sheet))
+	gtk_adjustment_set_value (sheet->vadjustment,
+				  sheet->vadjustment->value -
+				  sheet->vadjustment->step_increment);
       break;
+
     case GDK_Page_Down:
-      scroll = MAX_VISIBLE_ROW (sheet)- MIN_VISIBLE_ROW (sheet)+1;
-    case GDK_Down:
-      if (extend_selection)
-	{
-	  if (state == GTK_STATE_NORMAL)
-	    {
-	      row = sheet->active_cell.row;
-	      col = sheet->active_cell.col;
-	      gtk_sheet_click_cell (sheet, row, col, &veto);
-	      if (!veto) break;
-	    }
-	  if (sheet->selection_cell.row < g_sheet_row_get_row_count (sheet->row_geometry) - 1)
-	    {
-	      row = sheet->selection_cell.row + scroll;
-	      while (!g_sheet_row_get_visibility (sheet->row_geometry, row) && row < g_sheet_row_get_row_count (sheet->row_geometry) - 1) row++;
-	      row = MIN (g_sheet_row_get_row_count (sheet->row_geometry) - 1, row);
-	      gtk_sheet_extend_selection (sheet, row, sheet->selection_cell.col);
-	    }
-	  return TRUE;
-	}
-      col = sheet->active_cell.col;
-      row = sheet->active_cell.row;
-      if (sheet->active_cell.row < g_sheet_row_get_row_count (sheet->row_geometry) - 1)
-	{
-	  if (state == GTK_SHEET_COLUMN_SELECTED)
-	    row = MIN_VISIBLE_ROW (sheet)- 1;
-	  if (state == GTK_SHEET_ROW_SELECTED)
-	    col = MIN_VISIBLE_COLUMN (sheet);
-	  row = row + scroll;
-	  while (!g_sheet_row_get_visibility (sheet->row_geometry, row) && row < g_sheet_row_get_row_count (sheet->row_geometry) - 1) row++;
-	  row = MIN (g_sheet_row_get_row_count (sheet->row_geometry) - 1, row);
-	}
-      gtk_sheet_click_cell (sheet, row, col, &veto);
-      extend_selection = FALSE;
-      break;
-    case GDK_Right:
-      if (extend_selection)
-	{
-	  if (state == GTK_STATE_NORMAL)
-	    {
-	      row = sheet->active_cell.row;
-	      col = sheet->active_cell.col;
-	      gtk_sheet_click_cell (sheet, row, col, &veto);
-	      if (!veto) break;
-	    }
-	  if (sheet->selection_cell.col < g_sheet_column_get_column_count (sheet->column_geometry) - 1)
-	    {
-	      col = sheet->selection_cell.col + 1;
-	      while (! g_sheet_column_get_visibility (sheet->column_geometry, col) && col < g_sheet_column_get_column_count (sheet->column_geometry) - 1)
-		col++;
-	      gtk_sheet_extend_selection (sheet, sheet->selection_cell.row, col);
-	    }
-	  return TRUE;
-	}
-      col = sheet->active_cell.col;
-      row = sheet->active_cell.row;
-      if (sheet->active_cell.col < g_sheet_column_get_column_count (sheet->column_geometry) - 1)
-	{
-	  col ++;
-	  if (state == GTK_SHEET_ROW_SELECTED)
-	    col = MIN_VISIBLE_COLUMN (sheet)- 1;
-	  if (state == GTK_SHEET_COLUMN_SELECTED)
-	    row = MIN_VISIBLE_ROW (sheet);
-	  while (! g_sheet_column_get_visibility (sheet->column_geometry, col) && col < g_sheet_column_get_column_count (sheet->column_geometry) - 1) col++;
-	  if (strlen (gtk_entry_get_text (GTK_ENTRY (gtk_sheet_get_entry (sheet)))) == 0
-	      || force_move)
-	    {
-	      gtk_sheet_click_cell (sheet, row, col, &veto);
-	    }
-	  else
-	    return FALSE;
-	}
-      extend_selection = FALSE;
+      page_vertical (sheet, GTK_SCROLL_PAGE_DOWN);
       break;
-    case GDK_Left:
-      if (extend_selection)
-	{
-	  if (state == GTK_STATE_NORMAL)
-	    {
-	      row = sheet->active_cell.row;
-	      col = sheet->active_cell.col;
-	      gtk_sheet_click_cell (sheet, row, col, &veto);
-	      if (!veto) break;
-	    }
-	  if (sheet->selection_cell.col > 0)
-	    {
-	      col = sheet->selection_cell.col - 1;
-	      while (! g_sheet_column_get_visibility (sheet->column_geometry, col) && col > 0) col--;
-	      gtk_sheet_extend_selection (sheet, sheet->selection_cell.row, col);
-	    }
-	  return TRUE;
-	}
-      col = sheet->active_cell.col - 1;
-      row = sheet->active_cell.row;
-      if (state == GTK_SHEET_ROW_SELECTED)
-	col = MIN_VISIBLE_COLUMN (sheet)- 1;
-      if (state == GTK_SHEET_COLUMN_SELECTED)
-	row = MIN_VISIBLE_ROW (sheet);
-      while (! g_sheet_column_get_visibility (sheet->column_geometry, col) && col > 0) col--;
-      col = MAX (0, col);
-
-      if (strlen (gtk_entry_get_text (GTK_ENTRY (gtk_sheet_get_entry (sheet)))) == 0
-	  || force_move)
-	{
-	  gtk_sheet_click_cell (sheet, row, col, &veto);
-	}
-      else
-	return FALSE;
-      extend_selection = FALSE;
+    case GDK_Page_Up:
+      page_vertical (sheet, GTK_SCROLL_PAGE_UP);
       break;
+
     case GDK_Home:
-      row = 0;
-      while (!g_sheet_row_get_visibility (sheet->row_geometry, row) && row < g_sheet_row_get_row_count (sheet->row_geometry) - 1) row++;
-      gtk_sheet_click_cell (sheet, row, sheet->active_cell.col, &veto);
-      extend_selection = FALSE;
+      gtk_adjustment_set_value (sheet->vadjustment,
+				sheet->vadjustment->lower);
+
+      gtk_sheet_activate_cell (sheet,  0,
+			       sheet->active_cell.col);
+
       break;
+
     case GDK_End:
-      row = g_sheet_row_get_row_count (sheet->row_geometry) - 1;
-      while (!g_sheet_row_get_visibility (sheet->row_geometry, row) && row > 0) row--;
-      gtk_sheet_click_cell (sheet, row, sheet->active_cell.col, &veto);
-      extend_selection = FALSE;
+      gtk_adjustment_set_value (sheet->vadjustment,
+				sheet->vadjustment->upper -
+				sheet->vadjustment->page_size -
+				sheet->vadjustment->page_increment);
+
+      /*
+	gtk_sheet_activate_cell (sheet,
+	g_sheet_row_get_row_count (sheet->row_geometry) - 1,
+	sheet->active_cell.col);
+      */
+      break;
+    case GDK_Delete:
+      gtk_sheet_real_cell_clear (sheet, sheet->active_cell.row, sheet->active_cell.col);
       break;
     default:
-      if (in_selection)
-	{
-	  GTK_SHEET_SET_FLAGS (sheet, GTK_SHEET_IN_SELECTION);
-	  if (extend_selection) return TRUE;
-	}
-      if (state == GTK_SHEET_ROW_SELECTED)
-	sheet->active_cell.col = MIN_VISIBLE_COLUMN (sheet);
-      if (state == GTK_SHEET_COLUMN_SELECTED)
-	sheet->active_cell.row = MIN_VISIBLE_ROW (sheet);
       return FALSE;
+      break;
     }
 
-  if (extend_selection) return TRUE;
-
-  gtk_sheet_activate_cell (sheet, sheet->active_cell.row,
-			   sheet->active_cell.col);
-
   return TRUE;
 }
 
 static void
-gtk_sheet_size_request (GtkWidget * widget,
-			GtkRequisition * requisition)
+gtk_sheet_size_request (GtkWidget *widget,
+			GtkRequisition *requisition)
 {
   GtkSheet *sheet;
 
@@ -5091,8 +4578,8 @@ gtk_sheet_size_request (GtkWidget * widget,
 
   sheet = GTK_SHEET (widget);
 
-  requisition->width = 3*DEFAULT_COLUMN_WIDTH;
-  requisition->height = 3*DEFAULT_ROW_HEIGHT (widget);
+  requisition->width = 3 * DEFAULT_COLUMN_WIDTH;
+  requisition->height = 3 * default_row_height (sheet);
 
   /* compute the size of the column title area */
   if (sheet->column_titles_visible)
@@ -5105,8 +4592,8 @@ gtk_sheet_size_request (GtkWidget * widget,
 
 
 static void
-gtk_sheet_size_allocate (GtkWidget * widget,
-			 GtkAllocation * allocation)
+gtk_sheet_size_allocate (GtkWidget *widget,
+			 GtkAllocation *allocation)
 {
   GtkSheet *sheet;
   GtkAllocation sheet_allocation;
@@ -5140,9 +4627,6 @@ gtk_sheet_size_allocate (GtkWidget * widget,
   sheet_allocation.width = allocation->width - 2 * border_width;
   sheet_allocation.height = allocation->height - 2 * border_width;
 
-  sheet->sheet_window_width = sheet_allocation.width;
-  sheet->sheet_window_height = sheet_allocation.height;
-
   if (GTK_WIDGET_REALIZED (widget))
     gdk_window_move_resize (sheet->sheet_window,
 			    sheet_allocation.x,
@@ -5156,8 +4640,7 @@ gtk_sheet_size_allocate (GtkWidget * widget,
 
   if (sheet->row_titles_visible)
     {
-    sheet->column_title_area.x = sheet->row_title_area.width;
-      sheet->sheet_window_width -= sheet->row_title_area.width;
+      sheet->column_title_area.x = sheet->row_title_area.width;
     }
 
   sheet->column_title_area.width = sheet_allocation.width ;
@@ -5179,8 +4662,7 @@ gtk_sheet_size_allocate (GtkWidget * widget,
   sheet->row_title_area.y = 0;
   if (sheet->column_titles_visible)
     {
-    sheet->row_title_area.y = sheet->column_title_area.height;
-      sheet->sheet_window_height -= sheet->column_title_area.height;
+      sheet->row_title_area.y = sheet->column_title_area.height;
     }
 
   sheet->row_title_area.height = sheet_allocation.height -
@@ -5198,15 +4680,12 @@ gtk_sheet_size_allocate (GtkWidget * widget,
   size_allocate_row_title_buttons (sheet);
   size_allocate_column_title_buttons (sheet);
 
-  /* re - scale backing pixmap */
-  gtk_sheet_make_backing_pixmap (sheet);
-
   /* set the scrollbars adjustments */
   adjust_scrollbars (sheet);
 }
 
 static void
-size_allocate_column_title_buttons (GtkSheet * sheet)
+size_allocate_column_title_buttons (GtkSheet *sheet)
 {
   gint i;
   gint x, width;
@@ -5215,8 +4694,7 @@ size_allocate_column_title_buttons (GtkSheet * sheet)
   if (!GTK_WIDGET_REALIZED (sheet))
     return;
 
-
-  width = sheet->sheet_window_width;
+  gdk_drawable_get_size (sheet->sheet_window, &width, NULL);
   x = 0;
 
   if (sheet->row_titles_visible)
@@ -5235,7 +4713,8 @@ size_allocate_column_title_buttons (GtkSheet * sheet)
 			      sheet->column_title_area.height);
     }
 
-  if (MAX_VISIBLE_COLUMN (sheet) == g_sheet_column_get_column_count (sheet->column_geometry) - 1)
+  if (max_visible_column (sheet) ==
+      g_sheet_column_get_column_count (sheet->column_geometry) - 1)
     gdk_window_clear_area (sheet->column_title_window,
 			   0, 0,
 			   sheet->column_title_area.width,
@@ -5245,22 +4724,22 @@ size_allocate_column_title_buttons (GtkSheet * sheet)
 
   size_allocate_global_button (sheet);
 
-  for (i = MIN_VISIBLE_COLUMN (sheet); i <= MAX_VISIBLE_COLUMN (sheet); i++)
+  for (i = min_visible_column (sheet); i <= max_visible_column (sheet); i++)
     gtk_sheet_column_title_button_draw (sheet, i);
 }
 
 static void
-size_allocate_row_title_buttons (GtkSheet * sheet)
+size_allocate_row_title_buttons (GtkSheet *sheet)
 {
   gint i;
-  gint y, height;
+  gint y = 0;
+  gint height;
 
   if (!sheet->row_titles_visible) return;
   if (!GTK_WIDGET_REALIZED (sheet))
     return;
 
-  height = sheet->sheet_window_height;
-  y = 0;
+  gdk_drawable_get_size (sheet->sheet_window, NULL, &height);
 
   if (sheet->column_titles_visible)
     {
@@ -5277,7 +4756,8 @@ size_allocate_row_title_buttons (GtkSheet * sheet)
 			      sheet->row_title_area.width,
 			      sheet->row_title_area.height);
     }
-  if (MAX_VISIBLE_ROW (sheet) == g_sheet_row_get_row_count (sheet->row_geometry) - 1)
+
+  if (max_visible_row (sheet) == g_sheet_row_get_row_count (sheet->row_geometry) - 1)
     gdk_window_clear_area (sheet->row_title_window,
 			   0, 0,
 			   sheet->row_title_area.width,
@@ -5287,7 +4767,7 @@ size_allocate_row_title_buttons (GtkSheet * sheet)
 
   size_allocate_global_button (sheet);
 
-  for (i = MIN_VISIBLE_ROW (sheet); i <= MAX_VISIBLE_ROW (sheet); i++)
+  for (i = min_visible_row (sheet); i <= max_visible_row (sheet); i++)
     {
       if ( i >= g_sheet_row_get_row_count (sheet->row_geometry))
 	break;
@@ -5304,7 +4784,7 @@ gtk_sheet_size_allocate_entry (GtkSheet *sheet)
   GtkEntry *sheet_entry;
   GtkStyle *style = NULL, *previous_style = NULL;
   gint row, col;
-  gint size, max_size, text_size, column_width;
+  gint size, max_size, text_size;
   const gchar *text;
 
   if (!GTK_WIDGET_REALIZED (GTK_WIDGET (sheet))) return;
@@ -5364,28 +4844,14 @@ gtk_sheet_size_allocate_entry (GtkSheet *sheet)
   if (text && strlen (text) > 0)
     text_size = STRING_WIDTH (GTK_WIDGET (sheet), attributes.font_desc, text);
 
-  column_width = g_sheet_column_get_width (sheet->column_geometry, sheet->active_cell.col);
-
-  size = MIN (text_size, max_size);
-  size = MAX (size, column_width - 2 * COLUMN_TITLES_HEIGHT);
-
   row = sheet->active_cell.row;
   col = sheet->active_cell.col;
 
-  shentry_allocation.x = COLUMN_LEFT_XPIXEL (sheet, sheet->active_cell.col);
-  shentry_allocation.y = g_sheet_row_start_pixel (sheet->row_geometry, sheet->active_cell.row);
-  if ( sheet->column_titles_visible)
-    shentry_allocation.y += sheet->column_title_area.height;
-
-  shentry_allocation.y -= sheet->vadjustment->value;
 
-  if ( sheet->row_titles_visible)
-    shentry_allocation.x += sheet->row_title_area.width;
-
-  shentry_allocation.x -= sheet->hadjustment->value;
+  rectangle_from_cell (sheet, row, col, &shentry_allocation);
 
-  shentry_allocation.width = column_width;
-  shentry_allocation.height = g_sheet_row_get_height (sheet->row_geometry, sheet->active_cell.row);
+  size = MIN (text_size, max_size);
+  size = MAX (size, shentry_allocation.width - 2 * COLUMN_TITLES_HEIGHT);
 
   if (GTK_IS_ITEM_ENTRY (sheet->entry_widget))
     {
@@ -5396,10 +4862,10 @@ gtk_sheet_size_allocate_entry (GtkSheet *sheet)
       switch (GTK_ITEM_ENTRY (sheet_entry)->justification)
 	{
 	case GTK_JUSTIFY_CENTER:
-	  shentry_allocation.x += column_width / 2 - size / 2;
+	  shentry_allocation.x += shentry_allocation.width / 2 - size / 2;
 	  break;
 	case GTK_JUSTIFY_RIGHT:
-	  shentry_allocation.x += column_width - size - COLUMN_TITLES_HEIGHT;
+	  shentry_allocation.x += shentry_allocation.width - size - COLUMN_TITLES_HEIGHT;
 	  break;
 	case GTK_JUSTIFY_LEFT:
 	case GTK_JUSTIFY_FILL:
@@ -5430,6 +4896,7 @@ gtk_sheet_entry_set_max_size (GtkSheet *sheet)
   gint row, col;
   GtkJustification justification;
   gchar *s = NULL;
+  gint width;
 
   row = sheet->active_cell.row;
   col = sheet->active_cell.col;
@@ -5439,45 +4906,49 @@ gtk_sheet_entry_set_max_size (GtkSheet *sheet)
 
   justification = GTK_ITEM_ENTRY (sheet->entry_widget)->justification;
 
+  gdk_drawable_get_size (sheet->sheet_window, &width, NULL);
+
   switch (justification)
     {
     case GTK_JUSTIFY_FILL:
     case GTK_JUSTIFY_LEFT:
-      for (i = col + 1; i <= MAX_VISIBLE_COLUMN (sheet); i++)
+      for (i = col + 1; i <= max_visible_column (sheet); i++)
 	{
 	  if ((s = gtk_sheet_cell_get_text (sheet, row, i)))
 	    {
 	      g_free (s);
 	      break;
 	    }
-	  size +=g_sheet_column_get_width (sheet->column_geometry, i);
+	  size += g_sheet_column_get_width (sheet->column_geometry, i);
 	}
-      size = MIN (size, sheet->sheet_window_width - COLUMN_LEFT_XPIXEL (sheet, col));
+
+      size = MIN (size, width -
+		  g_sheet_column_start_pixel (sheet->column_geometry, col));
       break;
     case GTK_JUSTIFY_RIGHT:
-      for (i = col - 1; i >= MIN_VISIBLE_COLUMN (sheet); i--)
+      for (i = col - 1; i >= min_visible_column (sheet); i--)
 	{
 	  if ((s = gtk_sheet_cell_get_text (sheet, row, i)))
 	    {
 	      g_free (s);
 	      break;
 	    }
-	  size +=g_sheet_column_get_width (sheet->column_geometry, i);
+	  size += g_sheet_column_get_width (sheet->column_geometry, i);
 	}
       break;
     case GTK_JUSTIFY_CENTER:
-      for (i = col + 1; i <= MAX_VISIBLE_COLUMN (sheet); i++)
+      for (i = col + 1; i <= max_visible_column (sheet); i++)
 	{
 	  sizer += g_sheet_column_get_width (sheet->column_geometry, i);
 	}
-      for (i = col - 1; i >= MIN_VISIBLE_COLUMN (sheet); i--)
+      for (i = col - 1; i >= min_visible_column (sheet); i--)
 	{
 	  if ((s = gtk_sheet_cell_get_text (sheet, row, i)))
 	    {
 	      g_free (s);
 	      break;
 	    }
-	  sizel +=g_sheet_column_get_width (sheet->column_geometry, i);
+	  sizel += g_sheet_column_get_width (sheet->column_geometry, i);
 	}
       size = 2 * MIN (sizel, sizer);
       break;
@@ -5640,7 +5111,7 @@ gtk_sheet_button_draw (GtkSheet *sheet, GdkWindow *window,
   if (button->label_visible)
     {
 
-      text_height = DEFAULT_ROW_HEIGHT (GTK_WIDGET (sheet)) -
+      text_height = default_row_height (sheet) -
 	2 * COLUMN_TITLES_HEIGHT;
 
       gdk_gc_set_clip_rectangle (GTK_WIDGET (sheet)->style->fg_gc[button->state],
@@ -5733,14 +5204,13 @@ gtk_sheet_column_title_button_draw (GtkSheet *sheet, gint column)
   if (!GTK_WIDGET_REALIZED (GTK_WIDGET (sheet))) return;
 
   if (!sheet->column_titles_visible) return;
-  if (!g_sheet_column_get_visibility (sheet->column_geometry, column)) return;
 
-  if (column < MIN_VISIBLE_COLUMN (sheet)) return;
-  if (column > MAX_VISIBLE_COLUMN (sheet)) return;
+  if (column < min_visible_column (sheet)) return;
+  if (column > max_visible_column (sheet)) return;
 
   button = g_sheet_column_get_button (sheet->column_geometry, column);
   allocation.y = 0;
-      allocation.x = COLUMN_LEFT_XPIXEL (sheet, column) + CELL_SPACING;
+  allocation.x = g_sheet_column_start_pixel (sheet->column_geometry, column) + CELL_SPACING;
   allocation.x -= sheet->hadjustment->value;
 
   allocation.height = sheet->column_title_area.height;
@@ -5749,7 +5219,7 @@ gtk_sheet_column_title_button_draw (GtkSheet *sheet, gint column)
 
   gtk_sheet_button_draw (sheet, sheet->column_title_window,
 			 button, is_sensitive, allocation);
-    }
+}
 
 
 static void
@@ -5763,10 +5233,9 @@ gtk_sheet_row_title_button_draw (GtkSheet *sheet, gint row)
   if (!GTK_WIDGET_REALIZED (GTK_WIDGET (sheet))) return;
 
   if (!sheet->row_titles_visible) return;
-  if (!g_sheet_row_get_visibility (sheet->row_geometry, row)) return;
 
-  if (row < MIN_VISIBLE_ROW (sheet)) return;
-  if (row > MAX_VISIBLE_ROW (sheet)) return;
+  if (row < min_visible_row (sheet)) return;
+  if (row > max_visible_row (sheet)) return;
 
   button = g_sheet_row_get_button (sheet->row_geometry, row);
   allocation.x = 0;
@@ -5789,22 +5258,41 @@ gtk_sheet_row_title_button_draw (GtkSheet *sheet, gint row)
  * hadjustment_value_changed */
 
 static void
-adjust_scrollbars (GtkSheet * sheet)
+adjust_scrollbars (GtkSheet *sheet)
 {
+  gint width, height;
+
+  if (!GTK_WIDGET_REALIZED (GTK_WIDGET (sheet)))
+    return;
+
+  gdk_drawable_get_size (sheet->sheet_window, &width, &height);
+
   if (sheet->vadjustment)
     {
+      glong last_row = g_sheet_row_get_row_count (sheet->row_geometry) - 1;
+
       sheet->vadjustment->step_increment =
-	1 ; // DEFAULT_ROW_HEIGHT (GTK_WIDGET (sheet));
+	ROWS_PER_STEP *
+	g_sheet_row_get_height (sheet->row_geometry, last_row);
 
       sheet->vadjustment->page_increment =
-	sheet->sheet_window_height - DEFAULT_ROW_HEIGHT (GTK_WIDGET (sheet));
+	height -
+	sheet->column_title_area.height -
+	g_sheet_row_get_height (sheet->row_geometry, last_row);
+
 
-      sheet->vadjustment->upper = DEFAULT_ROW_HEIGHT (GTK_WIDGET (sheet))
-	* g_sheet_row_get_row_count (sheet->row_geometry);
 
+      sheet->vadjustment->upper =
+	g_sheet_row_start_pixel (sheet->row_geometry, last_row)
+	+
+	g_sheet_row_get_height (sheet->row_geometry, last_row)
+	;
+
+      if (sheet->column_titles_visible)
+	sheet->vadjustment->upper += sheet->column_title_area.height;
 
       sheet->vadjustment->lower = 0;
-      sheet->vadjustment->page_size = sheet->sheet_window_height;
+      sheet->vadjustment->page_size = height;
 
       g_signal_emit_by_name (sheet->vadjustment, "changed");
     }
@@ -5814,7 +5302,7 @@ adjust_scrollbars (GtkSheet * sheet)
       gint last_col;
       sheet->hadjustment->step_increment = 1 ; //DEFAULT_COLUMN_WIDTH;
 
-      sheet->hadjustment->page_increment = sheet->sheet_window_width ;
+      sheet->hadjustment->page_increment = width;
 
       last_col = g_sheet_column_get_column_count (sheet->column_geometry) - 1;
 
@@ -5824,15 +5312,18 @@ adjust_scrollbars (GtkSheet * sheet)
 	g_sheet_column_get_width (sheet->column_geometry, last_col)
 	;
 
+      if (sheet->row_titles_visible)
+	sheet->hadjustment->upper += sheet->row_title_area.width;
+
       sheet->hadjustment->lower = 0;
-      sheet->hadjustment->page_size = sheet->sheet_window_width;
+      sheet->hadjustment->page_size = width;
 
       g_signal_emit_by_name (sheet->hadjustment, "changed");
     }
 }
 
 static void
-vadjustment_value_changed (GtkAdjustment * adjustment,
+vadjustment_value_changed (GtkAdjustment *adjustment,
 			   gpointer data)
 {
   GtkSheet *sheet = GTK_SHEET (data);
@@ -5849,7 +5340,7 @@ vadjustment_value_changed (GtkAdjustment * adjustment,
 
 
 static void
-hadjustment_value_changed (GtkAdjustment * adjustment,
+hadjustment_value_changed (GtkAdjustment *adjustment,
 			   gpointer data)
 {
   GtkSheet *sheet = GTK_SHEET (data);
@@ -5867,9 +5358,13 @@ hadjustment_value_changed (GtkAdjustment * adjustment,
 
 /* COLUMN RESIZING */
 static void
-draw_xor_vline (GtkSheet * sheet)
+draw_xor_vline (GtkSheet *sheet)
 {
+  gint height;
   gint xpos = sheet->x_drag;
+  gdk_drawable_get_size (sheet->sheet_window,
+			 NULL, &height);
+
 
   if (sheet->row_titles_visible)
     xpos += sheet->row_title_area.width;
@@ -5878,23 +5373,28 @@ draw_xor_vline (GtkSheet * sheet)
 		 xpos,
 		 sheet->column_title_area.height,
 		 xpos,
-		 sheet->sheet_window_height + CELL_SPACING);
+		 height + CELL_SPACING);
 }
 
 /* ROW RESIZING */
 static void
-draw_xor_hline (GtkSheet * sheet)
+draw_xor_hline (GtkSheet *sheet)
 
 {
+  gint width;
   gint ypos = sheet->y_drag;
 
+  gdk_drawable_get_size (sheet->sheet_window,
+			 &width, NULL);
+
+
   if (sheet->column_titles_visible)
     ypos += sheet->column_title_area.height;
 
   gdk_draw_line (GTK_WIDGET (sheet)->window, sheet->xor_gc,
 		 sheet->row_title_area.width,
 		 ypos,
-		 sheet->sheet_window_width + CELL_SPACING,
+		 width + CELL_SPACING,
 		 ypos);
 }
 
@@ -5906,17 +5406,18 @@ draw_xor_rectangle (GtkSheet *sheet, GtkSheetRange range)
   GdkRectangle clip_area, area;
   GdkGCValues values;
 
-  area.x = COLUMN_LEFT_XPIXEL (sheet, range.col0);
+  area.x = g_sheet_column_start_pixel (sheet->column_geometry, range.col0);
   area.y = g_sheet_row_start_pixel (sheet->row_geometry, range.row0);
-  area.width = COLUMN_LEFT_XPIXEL (sheet, range.coli)- area.x+
+  area.width = g_sheet_column_start_pixel (sheet->column_geometry, range.coli)- area.x+
     g_sheet_column_get_width (sheet->column_geometry, range.coli);
   area.height = g_sheet_row_start_pixel (sheet->row_geometry, range.rowi)- area.y +
     g_sheet_row_get_height (sheet->row_geometry, range.rowi);
 
   clip_area.x = sheet->row_title_area.width;
   clip_area.y = sheet->column_title_area.height;
-  clip_area.width = sheet->sheet_window_width;
-  clip_area.height = sheet->sheet_window_height;
+
+  gdk_drawable_get_size (sheet->sheet_window,
+			 &clip_area.width, &clip_area.height);
 
   if (!sheet->row_titles_visible) clip_area.x = 0;
   if (!sheet->column_titles_visible) clip_area.y = 0;
@@ -5943,11 +5444,11 @@ draw_xor_rectangle (GtkSheet *sheet, GtkSheetRange range)
 
   gdk_gc_set_clip_rectangle (sheet->xor_gc, &clip_area);
 
-    gdk_draw_rectangle (sheet->sheet_window,
-			sheet->xor_gc,
-			FALSE,
-			area.x + i, area.y + i,
-			area.width - 2 * i, area.height - 2 * i);
+  gdk_draw_rectangle (sheet->sheet_window,
+		      sheet->xor_gc,
+		      FALSE,
+		      area.x + i, area.y + i,
+		      area.width - 2 * i, area.height - 2 * i);
 
 
   gdk_gc_set_clip_rectangle (sheet->xor_gc, NULL);
@@ -5963,7 +5464,7 @@ draw_xor_rectangle (GtkSheet *sheet, GtkSheetRange range)
 static guint
 new_column_width (GtkSheet *sheet, gint column, gint *x)
 {
-  gint left_pos = COLUMN_LEFT_XPIXEL (sheet, column)
+  gint left_pos = g_sheet_column_start_pixel (sheet->column_geometry, column)
     - sheet->hadjustment->value;
 
   gint width = *x - left_pos;
@@ -6013,7 +5514,7 @@ new_row_height (GtkSheet *sheet, gint row, gint *y)
 }
 
 static void
-gtk_sheet_set_column_width (GtkSheet * sheet,
+gtk_sheet_set_column_width (GtkSheet *sheet,
 			    gint column,
 			    guint width)
 {
@@ -6043,8 +5544,8 @@ gtk_sheet_set_column_width (GtkSheet * sheet,
 
 
 
-void
-gtk_sheet_set_row_height (GtkSheet * sheet,
+static void
+gtk_sheet_set_row_height (GtkSheet *sheet,
 			  gint row,
 			  guint height)
 {
@@ -6071,103 +5572,70 @@ gtk_sheet_set_row_height (GtkSheet * sheet,
 
   g_signal_emit (sheet, sheet_signals[CHANGED], 0, row, - 1);
 }
+
 gboolean
 gtk_sheet_get_attributes (const GtkSheet *sheet, gint row, gint col,
-			  GtkSheetCellAttr *attributes)
+			  GtkSheetCellAttr *attr)
 {
-  const GdkColor *fg, *bg;
+  GdkColor *fg, *bg;
   const GtkJustification *j ;
   const PangoFontDescription *font_desc ;
   const GtkSheetCellBorder *border ;
+  GdkColormap *colormap;
 
   g_return_val_if_fail (sheet != NULL, FALSE);
   g_return_val_if_fail (GTK_IS_SHEET (sheet), FALSE);
 
   if (row < 0 || col < 0) return FALSE;
 
-  init_attributes (sheet, col, attributes);
 
-  if ( !sheet->model)
-    return FALSE;
+  attr->foreground = GTK_WIDGET (sheet)->style->black;
+  attr->background = sheet->color[BG_COLOR];
+
+  attr->border.width = 0;
+  attr->border.line_style = GDK_LINE_SOLID;
+  attr->border.cap_style = GDK_CAP_NOT_LAST;
+  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);
 
-  attributes->is_editable = g_sheet_model_is_editable (sheet->model, row, col);
-  attributes->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);
   if ( fg )
-    attributes->foreground = *fg;
+    {
+      gdk_colormap_alloc_color (colormap, fg, TRUE, TRUE);
+      attr->foreground = *fg;
+    }
 
   bg = g_sheet_model_get_background (sheet->model, row, col);
   if ( bg )
-    attributes->background = *bg;
+    {
+      gdk_colormap_alloc_color (colormap, bg, TRUE, TRUE);
+      attr->background = *bg;
+    }
+
+  attr->justification =
+    g_sheet_column_get_justification (sheet->column_geometry, col);
 
   j = g_sheet_model_get_justification (sheet->model, row, col);
-  if (j) attributes->justification = *j;
+  if (j)
+    attr->justification = *j;
 
   font_desc = g_sheet_model_get_font_desc (sheet->model, row, col);
-  if ( font_desc ) attributes->font_desc = font_desc;
+  if ( font_desc ) attr->font_desc = font_desc;
 
   border = g_sheet_model_get_cell_border (sheet->model, row, col);
 
-  if ( border ) attributes->border = *border;
+  if ( border ) attr->border = *border;
 
   return TRUE;
 }
 
-static void
-init_attributes (const GtkSheet *sheet, gint col, GtkSheetCellAttr *attributes)
-{
-  /* DEFAULT VALUES */
-  attributes->foreground = GTK_WIDGET (sheet)->style->black;
-  attributes->background = sheet->color[BG_COLOR];
-  if (!GTK_WIDGET_REALIZED (GTK_WIDGET (sheet)))
-    {
-      attributes->background = sheet->color[BG_COLOR];
-    }
-  attributes->justification = g_sheet_column_get_justification (sheet->column_geometry, col);
-  attributes->border.width = 0;
-  attributes->border.line_style = GDK_LINE_SOLID;
-  attributes->border.cap_style = GDK_CAP_NOT_LAST;
-  attributes->border.join_style = GDK_JOIN_MITER;
-  attributes->border.mask = 0;
-  attributes->border.color = GTK_WIDGET (sheet)->style->black;
-  attributes->is_editable = TRUE;
-  attributes->is_visible = TRUE;
-  attributes->font_desc = GTK_WIDGET (sheet)->style->font_desc;
-}
-
-static void
-label_size_request (GtkSheet *sheet, gchar *label, GtkRequisition *req)
-{
-  gchar *words;
-  gchar word[1000];
-  gint n = 0;
-  gint row_height = DEFAULT_ROW_HEIGHT (GTK_WIDGET (sheet)) - 2 * COLUMN_TITLES_HEIGHT + 2;
-
-  req->height = 0;
-  req->width = 0;
-  words = label;
-
-  while (words && *words != '\0')
-    {
-      if (*words == '\n' || * (words + 1) == '\0')
-	{
-	  req->height += row_height;
-
-	  word[n] = '\0';
-	  req->width = MAX (req->width, STRING_WIDTH (GTK_WIDGET (sheet), GTK_WIDGET (sheet)->style->font_desc, word));
-	  n = 0;
-	}
-      else
-	{
-	  word[n++] = *words;
-	}
-      words++;
-    }
-
-  if (n > 0) req->height -= 2;
-}
-
 static void
 gtk_sheet_button_size_request	 (GtkSheet *sheet,
 				  const GtkSheetButton *button,
@@ -6176,20 +5644,11 @@ gtk_sheet_button_size_request	 (GtkSheet *sheet,
   GtkRequisition requisition;
   GtkRequisition label_requisition;
 
-  if (gtk_sheet_autoresize (sheet) && button->label && strlen (button->label) > 0)
-    {
-      label_size_request (sheet, button->label, &label_requisition);
-      label_requisition.width += 2 * COLUMN_TITLES_HEIGHT;
-      label_requisition.height += 2 * COLUMN_TITLES_HEIGHT;
-    }
-  else
-    {
-      label_requisition.height = DEFAULT_ROW_HEIGHT (GTK_WIDGET (sheet));
-      label_requisition.width = COLUMN_MIN_WIDTH;
-    }
+  label_requisition.height = default_row_height (sheet);
+  label_requisition.width = COLUMN_MIN_WIDTH;
 
-      requisition.height = DEFAULT_ROW_HEIGHT (GTK_WIDGET (sheet));
-      requisition.width = COLUMN_MIN_WIDTH;
+  requisition.height = default_row_height (sheet);
+  requisition.width = COLUMN_MIN_WIDTH;
 
 
   *button_requisition = requisition;
@@ -6211,7 +5670,7 @@ gtk_sheet_row_size_request (GtkSheet *sheet,
 
   *requisition = button_requisition.height;
 
-  sheet->row_requisition = * requisition;
+  sheet->row_requisition = *requisition;
 }
 
 static void