X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;ds=sidebyside;f=lib%2Fgtksheet%2Fgtksheet.c;h=8b25902c3b1cc2421c2e5e101b9dbeb77bc7aff8;hb=04bc6ee1d86faf2b0d42590dd31e8a984f7f0418;hp=3a965aec1f54faef2c634056bf8aa1d559dbf04f;hpb=d6f77c745fe3ebfffdab2cc47f7862ce379a7e9f;p=pspp

diff --git a/lib/gtksheet/gtksheet.c b/lib/gtksheet/gtksheet.c
index 3a965aec1f..8b25902c3b 100644
--- a/lib/gtksheet/gtksheet.c
+++ b/lib/gtksheet/gtksheet.c
@@ -1,6 +1,3 @@
-#define GLIB_DISABLE_DEPRECATED 1
-#define GDK_DISABLE_DEPRECATED 1
-#define GTK_DISABLE_DEPRECATED 1
 /*
  * Copyright (C) 2006, 2008 Free Software Foundation
  *
@@ -58,11 +55,12 @@
 #include "gtksheet.h"
 #include "gtkextra-marshal.h"
 #include "gsheetmodel.h"
+#include <libpspp/misc.h>
+#include <math.h>
 
 /* sheet flags */
 enum
   {
-    GTK_SHEET_REDRAW_PENDING = 1 << 0,
     GTK_SHEET_IN_XDRAG = 1 << 1,
     GTK_SHEET_IN_YDRAG = 1 << 2,
     GTK_SHEET_IN_DRAG = 1 << 3,
@@ -79,7 +77,6 @@ enum
 #define GTK_SHEET_IN_DRAG(sheet) (GTK_SHEET_FLAGS (sheet) & GTK_SHEET_IN_DRAG)
 #define GTK_SHEET_IN_SELECTION(sheet) (GTK_SHEET_FLAGS (sheet) & GTK_SHEET_IN_SELECTION)
 #define GTK_SHEET_IN_RESIZE(sheet) (GTK_SHEET_FLAGS (sheet) & GTK_SHEET_IN_RESIZE)
-#define GTK_SHEET_REDRAW_PENDING(sheet) (GTK_SHEET_FLAGS (sheet) & GTK_SHEET_REDRAW_PENDING)
 
 #define CELL_SPACING 1
 
@@ -87,11 +84,12 @@ enum
 #define COLUMN_MIN_WIDTH 10
 #define COLUMN_TITLES_HEIGHT 4
 #define DEFAULT_COLUMN_WIDTH 80
+#define DEFAULT_ROW_HEIGHT 25
 
 static void gtk_sheet_update_primary_selection (GtkSheet *sheet);
-static void gtk_sheet_column_title_button_draw (GtkSheet *sheet, gint column);
+static void draw_column_title_buttons_range (GtkSheet *sheet, gint first, gint n);
+static void draw_row_title_buttons_range (GtkSheet *sheet, gint first, gint n);
 
-static void gtk_sheet_row_title_button_draw (GtkSheet *sheet, gint row);
 
 static void gtk_sheet_set_row_height (GtkSheet *sheet,
 				      gint row,
@@ -115,67 +113,37 @@ dispose_string (const GtkSheet *sheet, gchar *text)
     g_free (text);
 }
 
-static guint
-default_row_height (const GtkSheet *sheet)
-{
-  GtkWidget *widget = GTK_WIDGET (sheet);
-
-  if (!widget->style->font_desc) return 25;
-  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_get_ascent (metrics);
-
-      pango_font_metrics_unref (metrics);
-
-      return PANGO_PIXELS (val) + 2 * COLUMN_TITLES_HEIGHT;
-    }
-}
-
-static
-guint STRING_WIDTH (GtkWidget *widget,
-		    const PangoFontDescription *font, const gchar *text)
-{
-  PangoRectangle rect;
-  PangoLayout *layout;
-
-  layout = gtk_widget_create_pango_layout (widget, text);
-  pango_layout_set_font_description (layout, font);
-
-  pango_layout_get_extents (layout, NULL, &rect);
-
-  g_object_unref (layout);
-  return PANGO_PIXELS (rect.width);
-}
-
 /* 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)
-    {
-      g_error ("This shouldnt happen");
-      return -1;
-    }
+  g_return_val_if_fail (y >= 0, -1);
 
   return g_sheet_row_pixel_to_row (geo, y);
 }
 
-
+/* Return the lowest row number which is wholly or partially on
+   the visible range of the sheet */
 static inline glong
 min_visible_row (const GtkSheet *sheet)
 {
   return yyy_row_ypixel_to_row (sheet, sheet->vadjustment->value);
 }
 
+static inline glong
+min_fully_visible_row (const GtkSheet *sheet)
+{
+  glong row = yyy_row_ypixel_to_row (sheet, sheet->vadjustment->value);
+
+  if ( g_sheet_row_start_pixel (sheet->row_geometry, row) < sheet->vadjustment->value)
+    row++;
+
+  return  row;
+}
+
+
 
 static inline glong
 max_visible_row (const GtkSheet *sheet)
@@ -186,36 +154,51 @@ max_visible_row (const GtkSheet *sheet)
 }
 
 
-/* returns the column index from a x pixel location */
-static inline gint
-column_from_xpixel (const GtkSheet *sheet, gint x)
+static inline glong
+max_fully_visible_row (const GtkSheet *sheet)
 {
-  gint i;
-  gint cx = 0;
+  glong row = max_visible_row (sheet);
 
-  if (x < 0) return -1;
-  for (i = 0;
-       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)))
-	return i;
+  if ( g_sheet_row_start_pixel (sheet->row_geometry, row)
+       +
+       g_sheet_row_get_height (sheet->row_geometry, row)
+       > sheet->vadjustment->value)
+    row--;
+
+  return row;
+}
 
-      cx += g_sheet_column_get_width (sheet->column_geometry, i);
-    }
 
-  /* no match */
-  return g_sheet_column_get_column_count (sheet->column_geometry) - 1;
+/* returns the column index from a pixel location */
+static inline gint
+column_from_xpixel (const GtkSheet *sheet, gint pixel)
+{
+  return psppire_axis_get_unit_at_pixel (sheet->haxis, pixel);
 }
 
 
+/* Returns the lowest column number which is wholly or partially
+   on the sheet */
 static inline glong
 min_visible_column (const GtkSheet *sheet)
 {
   return column_from_xpixel (sheet, sheet->hadjustment->value);
 }
 
+static inline glong
+min_fully_visible_column (const GtkSheet *sheet)
+{
+  glong col = min_visible_column (sheet);
 
+  if ( psppire_axis_pixel_start (sheet->haxis, col) < sheet->hadjustment->value)
+    col++;
+
+  return col;
+}
+
+
+/* Returns the highest column number which is wholly or partially
+   on the sheet */
 static inline glong
 max_visible_column (const GtkSheet *sheet)
 {
@@ -224,6 +207,21 @@ max_visible_column (const GtkSheet *sheet)
 			     sheet->hadjustment->page_size);
 }
 
+static inline glong
+max_fully_visible_column (const GtkSheet *sheet)
+{
+  glong col = max_visible_column (sheet);
+
+  if ( psppire_axis_pixel_start (sheet->haxis, col)
+       + 
+       psppire_axis_unit_size (sheet->haxis, col)
+       > sheet->hadjustment->value)
+    col--;
+
+  return col;
+}
+
+
 
 /* The size of the region (in pixels) around the row/column boundaries
    where the height/width may be grabbed to change size */
@@ -291,9 +289,9 @@ POSSIBLE_DRAG (const GtkSheet *sheet, gint x, gint y,
   *drag_column = column_from_xpixel (sheet, x);
   *drag_row = yyy_row_ypixel_to_row (sheet, y);
 
-  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)
+  if (x >= psppire_axis_pixel_start (sheet->haxis, sheet->range.col0) - DRAG_WIDTH / 2 &&
+      x <= psppire_axis_pixel_start (sheet->haxis, sheet->range.coli) +
+      psppire_axis_unit_size (sheet->haxis, sheet->range.coli) + DRAG_WIDTH / 2)
     {
       ydrag = g_sheet_row_start_pixel (sheet->row_geometry, sheet->range.row0);
       if (y >= ydrag - DRAG_WIDTH / 2 && y <= ydrag + DRAG_WIDTH / 2)
@@ -314,14 +312,14 @@ 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 = g_sheet_column_start_pixel (sheet->column_geometry, sheet->range.col0);
+      xdrag = psppire_axis_pixel_start (sheet->haxis, sheet->range.col0);
       if (x >= xdrag - DRAG_WIDTH / 2 && x <= xdrag + DRAG_WIDTH / 2)
 	{
 	  *drag_column = sheet->range.col0;
 	  return TRUE;
 	}
-      xdrag = g_sheet_column_start_pixel (sheet->column_geometry, sheet->range.coli) +
-	g_sheet_column_get_width (sheet->column_geometry, sheet->range.coli);
+      xdrag = psppire_axis_pixel_start (sheet->haxis, sheet->range.coli) +
+	psppire_axis_unit_size (sheet->haxis, sheet->range.coli);
       if (x >= xdrag - DRAG_WIDTH / 2 && x <= xdrag + DRAG_WIDTH / 2)
 	{
 	  *drag_column = sheet->range.coli;
@@ -343,8 +341,8 @@ POSSIBLE_RESIZE (const GtkSheet *sheet, gint x, gint y,
        sheet->range.col0 < 0 || sheet->range.coli < 0 )
     return FALSE;
 
-  xdrag = g_sheet_column_start_pixel (sheet->column_geometry, sheet->range.coli)+
-    g_sheet_column_get_width (sheet->column_geometry, sheet->range.coli);
+  xdrag = psppire_axis_pixel_start (sheet->haxis, sheet->range.coli)+
+    psppire_axis_unit_size (sheet->haxis, 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);
@@ -353,7 +351,7 @@ POSSIBLE_RESIZE (const GtkSheet *sheet, gint x, gint y,
     ydrag = g_sheet_row_start_pixel (sheet->row_geometry, min_visible_row (sheet));
 
   if (sheet->state == GTK_SHEET_ROW_SELECTED)
-    xdrag = g_sheet_column_start_pixel (sheet->column_geometry, min_visible_column (sheet));
+    xdrag = psppire_axis_pixel_start (sheet->haxis, min_visible_column (sheet));
 
   *drag_column = column_from_xpixel (sheet, x);
   *drag_row = yyy_row_ypixel_to_row (sheet, y);
@@ -371,22 +369,22 @@ rectangle_from_range (GtkSheet *sheet, const GtkSheetRange *range,
 {
   g_return_val_if_fail (range, FALSE);
 
-  r->x = g_sheet_column_start_pixel (sheet->column_geometry, range->col0);
-  r->x -= sheet->hadjustment->value;
+  r->x = psppire_axis_pixel_start (sheet->haxis, range->col0);
+  r->x -= round (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;
+  r->y -= round (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->width = psppire_axis_pixel_start (sheet->haxis, range->coli) -
+    psppire_axis_pixel_start (sheet->haxis, range->col0) +
+    psppire_axis_unit_size (sheet->haxis, range->coli);
 
   r->height = g_sheet_row_start_pixel (sheet->row_geometry, range->rowi) -
     g_sheet_row_start_pixel (sheet->row_geometry, range->row0) +
@@ -470,8 +468,6 @@ static void gtk_sheet_range_draw_selection	 (GtkSheet *sheet,
 
 /* Selection */
 
-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,
@@ -487,10 +483,9 @@ static void gtk_sheet_draw_border 		 (GtkSheet *sheet,
 
 static void gtk_sheet_entry_changed		 (GtkWidget *widget,
 						  gpointer data);
-static void gtk_sheet_deactivate_cell	 (GtkSheet *sheet);
 static void gtk_sheet_hide_active_cell		 (GtkSheet *sheet);
-static gboolean gtk_sheet_activate_cell		 (GtkSheet *sheet,
-						  gint row, gint col);
+static void change_active_cell		 (GtkSheet *sheet,
+					  gint row, gint col);
 static void gtk_sheet_draw_active_cell		 (GtkSheet *sheet);
 static void gtk_sheet_show_active_cell		 (GtkSheet *sheet);
 static gboolean gtk_sheet_click_cell		 (GtkSheet *sheet,
@@ -565,9 +560,7 @@ enum
     RESIZE_RANGE,
     MOVE_RANGE,
     TRAVERSE,
-    DEACTIVATE,
     ACTIVATE,
-    CHANGED,
     LAST_SIGNAL
   };
 
@@ -603,6 +596,8 @@ gtk_sheet_get_type ()
   return sheet_type;
 }
 
+
+
 static GtkSheetRange*
 gtk_sheet_range_copy (const GtkSheetRange *range)
 {
@@ -641,16 +636,51 @@ gtk_sheet_range_get_type (void)
   return sheet_range_type;
 }
 
+static GtkSheetCell*
+gtk_sheet_cell_copy (const GtkSheetCell *cell)
+{
+  GtkSheetCell *new_cell;
+
+  g_return_val_if_fail (cell != NULL, NULL);
+
+  new_cell = g_new (GtkSheetCell, 1);
+
+  *new_cell = *cell;
+
+  return new_cell;
+}
+
+static void
+gtk_sheet_cell_free (GtkSheetCell *cell)
+{
+  g_return_if_fail (cell != NULL);
+
+  g_free (cell);
+}
+
+GType
+gtk_sheet_cell_get_type (void)
+{
+  static GType sheet_cell_type = 0;
+
+  if (!sheet_cell_type)
+    {
+      sheet_cell_type =
+	g_boxed_type_register_static ("GtkSheetCell",
+				      (GBoxedCopyFunc) gtk_sheet_cell_copy,
+				      (GBoxedFreeFunc) gtk_sheet_cell_free);
+    }
 
-static void column_titles_changed (GtkWidget *w, gint first, gint n_columns,
-				   gpointer data);
+  return sheet_cell_type;
+}
+
 
 /* Properties */
 enum
   {
     PROP_0,
     PROP_ROW_GEO,
-    PROP_COL_GEO,
+    PROP_HAXIS,
     PROP_MODEL
   };
 
@@ -665,13 +695,15 @@ gtk_sheet_set_row_geometry (GtkSheet *sheet, GSheetRow *geo)
 }
 
 static void
-gtk_sheet_set_column_geometry (GtkSheet *sheet, GSheetColumn *geo)
+gtk_sheet_set_horizontal_axis (GtkSheet *sheet, PsppireAxis *a)
 {
-  if ( sheet->column_geometry ) g_object_unref (sheet->column_geometry);
+  if ( sheet->haxis )
+    g_object_unref (sheet->haxis);
 
-  sheet->column_geometry = geo;
+  sheet->haxis = a;
 
-  if ( sheet->column_geometry ) g_object_ref (sheet->column_geometry);
+  if ( sheet->haxis )
+    g_object_ref (sheet->haxis);
 }
 
 
@@ -689,11 +721,8 @@ gtk_sheet_set_property (GObject         *object,
     case PROP_ROW_GEO:
       gtk_sheet_set_row_geometry (sheet, g_value_get_pointer (value));
       break;
-    case PROP_COL_GEO:
-      gtk_sheet_set_column_geometry (sheet, g_value_get_pointer (value));
-      if ( sheet->column_geometry)
-	g_signal_connect (sheet->column_geometry, "columns_changed",
-			  G_CALLBACK (column_titles_changed), sheet);
+    case PROP_HAXIS:
+      gtk_sheet_set_horizontal_axis (sheet, g_value_get_pointer (value));
       break;
     case PROP_MODEL:
       gtk_sheet_set_model (sheet, g_value_get_pointer (value));
@@ -717,8 +746,8 @@ gtk_sheet_get_property (GObject         *object,
     case PROP_ROW_GEO:
       g_value_set_pointer (value, sheet->row_geometry);
       break;
-    case PROP_COL_GEO:
-      g_value_set_pointer (value, sheet->column_geometry);
+    case PROP_HAXIS:
+      g_value_set_pointer (value, sheet->haxis);
       break;
     case PROP_MODEL:
       g_value_set_pointer (value, sheet->model);
@@ -736,7 +765,7 @@ gtk_sheet_class_init (GtkSheetClass *klass)
   GObjectClass *object_class = G_OBJECT_CLASS (klass);
 
   GParamSpec *row_geo_spec ;
-  GParamSpec *col_geo_spec ;
+  GParamSpec *haxis_spec ;
   GParamSpec *model_spec ;
 
   GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
@@ -904,37 +933,22 @@ gtk_sheet_class_init (GtkSheetClass *klass)
 		  G_SIGNAL_RUN_LAST,
 		  offsetof (GtkSheetClass, traverse),
 		  NULL, NULL,
-		  gtkextra_BOOLEAN__INT_INT_POINTER_POINTER,
-		  G_TYPE_BOOLEAN, 4, G_TYPE_INT, G_TYPE_INT,
-		  G_TYPE_POINTER, G_TYPE_POINTER);
+		  gtkextra_BOOLEAN__BOXED_POINTER,
+		  G_TYPE_BOOLEAN, 2,
+		  GTK_TYPE_SHEET_CELL,
+		  G_TYPE_POINTER);
 
 
-  sheet_signals[DEACTIVATE] =
-    g_signal_new ("deactivate",
-		  G_TYPE_FROM_CLASS (object_class),
-		  G_SIGNAL_RUN_LAST,
-		  offsetof (GtkSheetClass, deactivate),
-		  NULL, NULL,
-		  gtkextra_VOID__INT_INT,
-		  G_TYPE_NONE, 2, G_TYPE_INT, G_TYPE_INT);
-
   sheet_signals[ACTIVATE] =
     g_signal_new ("activate",
 		  G_TYPE_FROM_CLASS (object_class),
 		  G_SIGNAL_RUN_LAST,
 		  offsetof (GtkSheetClass, activate),
 		  NULL, NULL,
-		  gtkextra_BOOLEAN__INT_INT,
-		  G_TYPE_BOOLEAN, 2, G_TYPE_INT, G_TYPE_INT);
-
-  sheet_signals[CHANGED] =
-    g_signal_new ("changed",
-		  G_TYPE_FROM_CLASS (object_class),
-		  G_SIGNAL_RUN_LAST,
-		  offsetof (GtkSheetClass, changed),
-		  NULL, NULL,
-		  gtkextra_VOID__INT_INT,
-		  G_TYPE_NONE, 2, G_TYPE_INT, G_TYPE_INT);
+		  gtkextra_VOID__INT_INT_INT_INT,
+		  G_TYPE_NONE, 4,
+		  G_TYPE_INT, G_TYPE_INT,
+		  G_TYPE_INT, G_TYPE_INT);
 
   widget_class->set_scroll_adjustments_signal =
     g_signal_new ("set-scroll-adjustments",
@@ -960,10 +974,10 @@ gtk_sheet_class_init (GtkSheetClass *klass)
 			  "A pointer to the model of the row geometry",
 			  G_PARAM_READABLE | G_PARAM_WRITABLE );
 
-  col_geo_spec =
-    g_param_spec_pointer ("column-geometry",
-			  "Column Geometry",
-			  "A pointer to the model of the column geometry",
+  haxis_spec =
+    g_param_spec_pointer ("horizontal-axis",
+			  "Horizontal Axis",
+			  "A pointer to the PsppireAxis object for the columns",
 			  G_PARAM_READABLE | G_PARAM_WRITABLE );
 
   model_spec =
@@ -981,8 +995,8 @@ gtk_sheet_class_init (GtkSheetClass *klass)
                                    row_geo_spec);
 
   g_object_class_install_property (object_class,
-                                   PROP_COL_GEO,
-                                   col_geo_spec);
+                                   PROP_HAXIS,
+                                   haxis_spec);
 
   g_object_class_install_property (object_class,
                                    PROP_MODEL,
@@ -1013,7 +1027,6 @@ gtk_sheet_class_init (GtkSheetClass *klass)
   klass->resize_range = NULL;
   klass->move_range = NULL;
   klass->traverse = NULL;
-  klass->deactivate = NULL;
   klass->activate = NULL;
   klass->changed = NULL;
 }
@@ -1022,7 +1035,7 @@ static void
 gtk_sheet_init (GtkSheet *sheet)
 {
   sheet->model = NULL;
-  sheet->column_geometry = NULL;
+  sheet->haxis = NULL;
   sheet->row_geometry = NULL;
 
   sheet->flags = 0;
@@ -1036,7 +1049,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 (sheet);
+  sheet->column_title_area.height = DEFAULT_ROW_HEIGHT;
 
   sheet->row_title_window = NULL;
   sheet->row_title_area.x = 0;
@@ -1060,6 +1073,7 @@ gtk_sheet_init (GtkSheet *sheet)
   sheet->sheet_window = NULL;
   sheet->entry_widget = NULL;
   sheet->entry_container = NULL;
+  sheet->entry_handler_id = 0;
   sheet->button = NULL;
 
   sheet->hadjustment = NULL;
@@ -1100,7 +1114,6 @@ columns_inserted_deleted_callback (GSheetModel *model, gint first_column,
 				   gint n_columns,
 				   gpointer data)
 {
-  gint i;
   GtkSheet *sheet = GTK_SHEET (data);
 
   GtkSheetRange range;
@@ -1112,16 +1125,16 @@ columns_inserted_deleted_callback (GSheetModel *model, gint first_column,
    */
   range.col0 = first_column;
   range.row0 = 0;
-  range.coli = g_sheet_column_get_column_count (sheet->column_geometry) - 1;
+  range.coli = psppire_axis_unit_count (sheet->haxis) - 1;
   range.rowi = g_sheet_row_get_row_count (sheet->row_geometry) - 1;
 
   adjust_scrollbars (sheet);
 
   if (sheet->active_cell.col >= model_columns)
-    gtk_sheet_activate_cell (sheet, sheet->active_cell.row, model_columns - 1);
+    change_active_cell (sheet, sheet->active_cell.row, model_columns - 1);
 
-  for (i = first_column; i <= max_visible_column (sheet); i++)
-    gtk_sheet_column_title_button_draw (sheet, i);
+  draw_column_title_buttons_range (sheet,
+				   first_column, max_visible_column (sheet));
 
   gtk_sheet_range_draw (sheet, &range);
 }
@@ -1132,7 +1145,6 @@ static void
 rows_inserted_deleted_callback (GSheetModel *model, gint first_row,
 				gint n_rows, gpointer data)
 {
-  gint i;
   GtkSheet *sheet = GTK_SHEET (data);
 
   GtkSheetRange range;
@@ -1145,15 +1157,14 @@ rows_inserted_deleted_callback (GSheetModel *model, gint first_row,
   range.row0 = first_row;
   range.col0 = 0;
   range.rowi = g_sheet_row_get_row_count (sheet->row_geometry) - 1;
-  range.coli = g_sheet_column_get_column_count (sheet->column_geometry) - 1;
+  range.coli = psppire_axis_unit_count (sheet->haxis) - 1;
 
   adjust_scrollbars (sheet);
 
   if (sheet->active_cell.row >= model_rows)
-    gtk_sheet_activate_cell (sheet, model_rows - 1, sheet->active_cell.col);
+    change_active_cell (sheet, model_rows - 1, sheet->active_cell.col);
 
-  for (i = first_row; i <= max_visible_row (sheet); i++)
-    gtk_sheet_row_title_button_draw (sheet, i);
+  draw_row_title_buttons_range (sheet, first_row, max_visible_row (sheet));
 
   gtk_sheet_range_draw (sheet, &range);
 }
@@ -1175,27 +1186,26 @@ range_update_callback (GSheetModel *m, gint row0, gint col0,
   range.rowi = rowi;
   range.coli = coli;
 
-  if ( max_visible_row (sheet) >
-       g_sheet_model_get_row_count (sheet->model)
+  if ( !GTK_WIDGET_REALIZED (GTK_WIDGET (sheet)))
+    return;
+
+  if ( max_visible_row (sheet) > g_sheet_model_get_row_count (sheet->model)
        ||
-       max_visible_column (sheet) >
-       g_sheet_model_get_column_count (sheet->model))
+       max_visible_column (sheet) > g_sheet_model_get_column_count (sheet->model))
     {
-      gtk_sheet_move_query (sheet, 0, 0);
+      gtk_sheet_moveto (sheet, 0, 0, 0, 0);
     }
 
   if ( ( row0 < 0 && col0 < 0 ) || ( rowi < 0 && coli < 0 ) )
     {
-      gint i;
       gtk_sheet_range_draw (sheet, NULL);
       adjust_scrollbars (sheet);
 
-      for (i = min_visible_row (sheet); i <= max_visible_row (sheet); i++)
-	gtk_sheet_row_title_button_draw (sheet, i);
+      draw_row_title_buttons_range (sheet, min_visible_row (sheet),
+				       max_visible_row (sheet));
 
-      for (i = min_visible_column (sheet);
-	   i <= max_visible_column (sheet); i++)
-	gtk_sheet_column_title_button_draw (sheet, i);
+      draw_column_title_buttons_range (sheet, min_visible_column (sheet),
+				       max_visible_column (sheet));
 
       return;
     }
@@ -1226,11 +1236,10 @@ range_update_callback (GSheetModel *m, gint row0, gint col0,
  * Returns: the new sheet widget
  */
 GtkWidget *
-gtk_sheet_new (GSheetRow *vgeo, GSheetColumn *hgeo, GSheetModel *model)
+gtk_sheet_new (GSheetRow *vgeo, void *hgeo, GSheetModel *model)
 {
   GtkWidget *widget = g_object_new (GTK_TYPE_SHEET,
 				    "row-geometry", vgeo,
-				    "column-geometry", hgeo,
 				    "model", model,
 				    NULL);
   return widget;
@@ -1276,37 +1285,6 @@ 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
-*/
-static void
-column_titles_changed (GtkWidget *w, gint first, gint n_columns, gpointer data)
-{
-  GtkSheet *sheet = GTK_SHEET (data);
-  gboolean extremity = FALSE;
-
-  if ( n_columns == -1 )
-    {
-      extremity = TRUE;
-      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);
-      }
-  }
-
-  if ( extremity)
-    gtk_sheet_column_title_button_draw (sheet, -1);
-
-}
-
 void
 gtk_sheet_change_entry (GtkSheet *sheet, GtkType entry_type)
 {
@@ -1327,11 +1305,8 @@ gtk_sheet_change_entry (GtkSheet *sheet, GtkType entry_type)
   if (state == GTK_SHEET_NORMAL)
     {
       gtk_sheet_show_active_cell (sheet);
-      g_signal_connect (gtk_sheet_get_entry (sheet),
-			"changed",
-			G_CALLBACK (gtk_sheet_entry_changed),
-			sheet);
     }
+
 }
 
 void
@@ -1362,7 +1337,7 @@ gtk_sheet_get_columns_count (GtkSheet *sheet)
   g_return_val_if_fail (sheet != NULL, 0);
   g_return_val_if_fail (GTK_IS_SHEET (sheet), 0);
 
-  return g_sheet_column_get_column_count (sheet->column_geometry);
+  return psppire_axis_unit_count (sheet->haxis);
 }
 
 static void
@@ -1371,43 +1346,6 @@ gtk_sheet_set_column_width (GtkSheet *sheet,
 			    guint width);
 
 
-static void
-gtk_sheet_autoresize_column (GtkSheet *sheet, gint column)
-{
-  gint text_width = 0;
-  gint row;
-
-  g_return_if_fail (sheet != NULL);
-  g_return_if_fail (GTK_IS_SHEET (sheet));
-  if (column >= g_sheet_column_get_column_count (sheet->column_geometry) || column < 0) return;
-
-  for (row = 0; row < g_sheet_row_get_row_count (sheet->row_geometry); row++)
-    {
-      gchar *text = gtk_sheet_cell_get_text (sheet, row, column);
-      if (text && strlen (text) > 0)
-	{
-	  GtkSheetCellAttr attributes;
-
-	  gtk_sheet_get_attributes (sheet, row, column, &attributes);
-	  if (attributes.is_visible)
-	    {
-	      gint width = STRING_WIDTH (GTK_WIDGET (sheet),
-					 attributes.font_desc,
-					 text)
-		+ 2 * COLUMN_TITLES_HEIGHT + attributes.border.width;
-	      text_width = MAX (text_width, width);
-	    }
-	}
-      dispose_string (sheet, text);
-    }
-
-  if (text_width > g_sheet_column_get_width (sheet->column_geometry, column) )
-    {
-      gtk_sheet_set_column_width (sheet, column, text_width);
-      GTK_SHEET_SET_FLAGS (sheet, GTK_SHEET_REDRAW_PENDING);
-    }
-}
-
 void
 gtk_sheet_show_column_titles (GtkSheet *sheet)
 {
@@ -1506,105 +1444,50 @@ gtk_sheet_hide_row_titles (GtkSheet *sheet)
 }
 
 
+/* Scroll the sheet so that the cell ROW, COLUMN is visible.
+   If {ROW,COL}_ALIGN is zero, then the cell will be placed
+   at the {top,left} of the sheet.  If it's 1, then it'll
+   be placed at the {bottom,right}.
+   ROW or COL may be -1, in which case scrolling in that dimension
+   does not occur.
+ */
 void
 gtk_sheet_moveto (GtkSheet *sheet,
 		  gint row,
-		  gint column,
+		  gint col,
 		  gfloat row_align,
 		  gfloat col_align)
 {
-  gint x, y;
   gint width, height;
-  gint adjust;
-  gint min_row, min_col;
-
-  g_return_if_fail (sheet != NULL);
-  g_return_if_fail (GTK_IS_SHEET (sheet));
-  g_return_if_fail (sheet->hadjustment != NULL);
-  g_return_if_fail (sheet->vadjustment != NULL);
 
-  if (row < 0 || row >= g_sheet_row_get_row_count (sheet->row_geometry))
-    return;
-  if (column < 0 || column >= g_sheet_column_get_column_count (sheet->column_geometry))
-    return;
+  g_return_if_fail (row_align >= 0);
+  g_return_if_fail (col_align >= 0);
 
-  gdk_drawable_get_size (sheet->sheet_window, &width, &height);
+  g_return_if_fail (row_align <= 1);
+  g_return_if_fail (col_align <= 1);
 
-  /* adjust vertical scrollbar */
-  if (row >= 0 && row_align >= 0.0)
-    {
-      y = g_sheet_row_start_pixel (sheet->row_geometry, row)
-	- (gint) ( row_align * height + (1.0 - row_align)
-		   * g_sheet_row_get_height (sheet->row_geometry, row));
-
-      /* This forces the sheet to scroll when you don't see the entire cell */
-      min_row = row;
-      adjust = 0;
-      if (row_align >= 1.0)
-	{
-	  while (min_row >= 0 && min_row > min_visible_row (sheet))
-	    {
-	      adjust += g_sheet_row_get_height (sheet->row_geometry, min_row);
+  g_return_if_fail (col <
+		    psppire_axis_unit_count (sheet->haxis));
+  g_return_if_fail (row <
+		    g_sheet_row_get_row_count (sheet->row_geometry));
 
-	      if (adjust >= height)
-		{
-		  break;
-		}
-	      min_row--;
-	    }
-	  min_row = MAX (min_row, 0);
-
-	  min_row ++;
-
-	  y = g_sheet_row_start_pixel (sheet->row_geometry, min_row) +
-	    g_sheet_row_get_height (sheet->row_geometry, min_row) - 1;
-	}
-
-      if (y < 0)
-	sheet->vadjustment->value = 0.0;
-      else
-	sheet->vadjustment->value = y;
+  gdk_drawable_get_size (sheet->sheet_window, &width, &height);
 
-      g_signal_emit_by_name (sheet->vadjustment,
-			     "value_changed");
 
-    }
+  if (row >= 0)
+  {
+    gint y =  g_sheet_row_start_pixel (sheet->row_geometry, row);
 
-  /* adjust horizontal scrollbar */
-  if (column >= 0 && col_align >= 0.0)
-    {
-      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));
-
-      /* This forces the sheet to scroll when you don't see the entire cell */
-      min_col = column;
-      adjust = 0;
-      if (col_align == 1.0)
-	{
-	  while (min_col >= 0 && min_col > min_visible_column (sheet))
-	    {
-	      adjust += g_sheet_column_get_width (sheet->column_geometry, min_col);
+    gtk_adjustment_set_value (sheet->vadjustment, y - height * row_align);
+  }
 
-	      if (adjust >= width)
-		{
-		  break;
-		}
-	      min_col--;
-	    }
-	  min_col = MAX (min_col, 0);
-	  x = g_sheet_column_start_pixel (sheet->column_geometry, min_col) +
-	    g_sheet_column_get_width (sheet->column_geometry, min_col) - 1;
-	}
 
-      if (x < 0)
-	sheet->hadjustment->value = 0.0;
-      else
-	sheet->hadjustment->value = x;
+  if (col >= 0)
+  {
+    gint x =  psppire_axis_pixel_start (sheet->haxis, col);
 
-      g_signal_emit_by_name (sheet->hadjustment,
-			     "value_changed");
-    }
+    gtk_adjustment_set_value (sheet->hadjustment, x - width * col_align);
+  }
 }
 
 
@@ -1639,14 +1522,12 @@ gtk_sheet_select_row (GtkSheet *sheet, gint row)
 
   if (sheet->state != GTK_SHEET_NORMAL)
     gtk_sheet_real_unselect_range (sheet, NULL);
-  else
-    gtk_sheet_deactivate_cell (sheet);
 
   sheet->state = GTK_SHEET_ROW_SELECTED;
   sheet->range.row0 = row;
   sheet->range.col0 = 0;
   sheet->range.rowi = row;
-  sheet->range.coli = g_sheet_column_get_column_count (sheet->column_geometry) - 1;
+  sheet->range.coli = psppire_axis_unit_count (sheet->haxis) - 1;
   sheet->active_cell.row = row;
   sheet->active_cell.col = 0;
 
@@ -1661,14 +1542,11 @@ gtk_sheet_select_column (GtkSheet *sheet, gint column)
   g_return_if_fail (sheet != NULL);
   g_return_if_fail (GTK_IS_SHEET (sheet));
 
-  if (column < 0 || column >= g_sheet_column_get_column_count (sheet->column_geometry))
+  if (column < 0 || column >= psppire_axis_unit_count (sheet->haxis))
     return;
 
   if (sheet->state != GTK_SHEET_NORMAL)
     gtk_sheet_real_unselect_range (sheet, NULL);
-  else
-    gtk_sheet_deactivate_cell (sheet);
-
 
   sheet->state = GTK_SHEET_COLUMN_SELECTED;
   sheet->range.row0 = 0;
@@ -1697,10 +1575,10 @@ gtk_sheet_range_isvisible (const GtkSheet *sheet,
   if (range.rowi < 0 || range.rowi >= g_sheet_row_get_row_count (sheet->row_geometry))
     return FALSE;
 
-  if (range.col0 < 0 || range.col0 >= g_sheet_column_get_column_count (sheet->column_geometry))
+  if (range.col0 < 0 || range.col0 >= psppire_axis_unit_count (sheet->haxis))
     return FALSE;
 
-  if (range.coli < 0 || range.coli >= g_sheet_column_get_column_count (sheet->column_geometry))
+  if (range.coli < 0 || range.coli >= psppire_axis_unit_count (sheet->haxis))
     return FALSE;
 
   if (range.rowi < min_visible_row (sheet))
@@ -1805,7 +1683,7 @@ gtk_sheet_dispose  (GObject *object)
 
   if (sheet->model) g_object_unref (sheet->model);
   if (sheet->row_geometry) g_object_unref (sheet->row_geometry);
-  if (sheet->column_geometry) g_object_unref (sheet->column_geometry);
+  if (sheet->haxis) g_object_unref (sheet->haxis);
 
   g_object_unref (sheet->entry_container);
   sheet->entry_container = NULL;
@@ -2126,9 +2004,9 @@ gtk_sheet_map (GtkWidget *widget)
 	  gtk_widget_map (GTK_BIN (sheet->button)->child);
 
       gtk_sheet_range_draw (sheet, NULL);
-      gtk_sheet_activate_cell (sheet,
-			       sheet->active_cell.row,
-			       sheet->active_cell.col);
+      change_active_cell (sheet,
+		     sheet->active_cell.row,
+		     sheet->active_cell.col);
     }
 }
 
@@ -2179,7 +2057,7 @@ gtk_sheet_cell_draw (GtkSheet *sheet, gint row, gint col)
     return;
 
   if (col < 0 ||
-      col >= g_sheet_column_get_column_count (sheet->column_geometry))
+      col >= psppire_axis_unit_count (sheet->haxis))
     return;
 
   gtk_sheet_get_attributes (sheet, row, col, &attributes);
@@ -2379,16 +2257,11 @@ gtk_sheet_range_draw_selection (GtkSheet *sheet, GtkSheetRange range)
   gtk_sheet_draw_border (sheet, sheet->range);
 }
 
-static void gtk_sheet_set_cell (GtkSheet *sheet, gint row, gint col,
-				GtkJustification justification,
-				const gchar *text);
-
-
 static inline gint
 safe_strcmp (const gchar *s1, const gchar *s2)
 {
   if ( !s1 && !s2) return 0;
-  if ( !s1) return - 1;
+  if ( !s1) return -1;
   if ( !s2) return +1;
   return strcmp (s1, s2);
 }
@@ -2399,13 +2272,12 @@ gtk_sheet_set_cell (GtkSheet *sheet, gint row, gint col,
 		    const gchar *text)
 {
   GSheetModel *model ;
-  gboolean changed = FALSE;
   gchar *old_text ;
 
   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)
+  if (col >= psppire_axis_unit_count (sheet->haxis)
       || row >= g_sheet_row_get_row_count (sheet->row_geometry))
     return;
 
@@ -2416,13 +2288,10 @@ gtk_sheet_set_cell (GtkSheet *sheet, gint row, gint col,
   old_text = g_sheet_model_get_string (model, row, col);
 
   if (0 != safe_strcmp (old_text, text))
-    changed = g_sheet_model_set_string (model, text, row, col);
+    g_sheet_model_set_string (model, text, row, col);
 
   if ( g_sheet_model_free_strings (model))
     g_free (old_text);
-
-  if ( changed )
-    g_signal_emit (sheet, sheet_signals[CHANGED], 0, row, col);
 }
 
 
@@ -2433,7 +2302,7 @@ gtk_sheet_cell_clear (GtkSheet *sheet, gint row, gint column)
 
   g_return_if_fail (sheet != NULL);
   g_return_if_fail (GTK_IS_SHEET (sheet));
-  if (column >= g_sheet_column_get_column_count (sheet->column_geometry) ||
+  if (column >= psppire_axis_unit_count (sheet->haxis) ||
       row >= g_sheet_row_get_row_count (sheet->row_geometry)) return;
 
   if (column < 0 || row < 0) return;
@@ -2470,7 +2339,7 @@ gtk_sheet_cell_get_text (const GtkSheet *sheet, gint row, gint col)
   g_return_val_if_fail (sheet != NULL, NULL);
   g_return_val_if_fail (GTK_IS_SHEET (sheet), NULL);
 
-  if (col >= g_sheet_column_get_column_count (sheet->column_geometry) || row >= g_sheet_row_get_row_count (sheet->row_geometry))
+  if (col >= psppire_axis_unit_count (sheet->haxis) || row >= g_sheet_row_get_row_count (sheet->row_geometry))
     return NULL;
   if (col < 0 || row < 0) return NULL;
 
@@ -2491,7 +2360,7 @@ gtk_sheet_cell_get_state (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 (col >= g_sheet_column_get_column_count (sheet->column_geometry) || row >= g_sheet_row_get_row_count (sheet->row_geometry)) return 0;
+  if (col >= psppire_axis_unit_count (sheet->haxis) || row >= g_sheet_row_get_row_count (sheet->row_geometry)) return 0;
   if (col < 0 || row < 0) return 0;
 
   state = sheet->state;
@@ -2574,7 +2443,7 @@ gtk_sheet_get_pixel_info (GtkSheet *sheet,
   else
     {
       tcol = column_from_xpixel (sheet, x);
-      if (tcol > g_sheet_column_get_column_count (sheet->column_geometry))
+      if (tcol > psppire_axis_unit_count (sheet->haxis))
 	return FALSE;
     }
 
@@ -2592,14 +2461,14 @@ gtk_sheet_get_cell_area (GtkSheet *sheet,
   g_return_val_if_fail (sheet != NULL, 0);
   g_return_val_if_fail (GTK_IS_SHEET (sheet), 0);
 
-  if (row >= g_sheet_row_get_row_count (sheet->row_geometry) || column >= g_sheet_column_get_column_count (sheet->column_geometry))
+  if (row >= g_sheet_row_get_row_count (sheet->row_geometry) || column >= psppire_axis_unit_count (sheet->haxis))
     return FALSE;
 
-  area->x = (column == -1) ? 0 : g_sheet_column_start_pixel (sheet->column_geometry, column);
+  area->x = (column == -1) ? 0 : psppire_axis_pixel_start (sheet->haxis, column);
   area->y = (row == -1)    ? 0 : g_sheet_row_start_pixel (sheet->row_geometry, row);
 
   area->width= (column == -1) ? sheet->row_title_area.width
-    : g_sheet_column_get_width (sheet->column_geometry, column);
+    : psppire_axis_unit_size (sheet->haxis, column);
 
   area->height= (row == -1) ? sheet->column_title_area.height
     : g_sheet_row_get_height (sheet->row_geometry, row);
@@ -2607,33 +2476,33 @@ gtk_sheet_get_cell_area (GtkSheet *sheet,
   return TRUE;
 }
 
-gboolean
+void
 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);
+  g_return_if_fail (sheet != NULL);
+  g_return_if_fail (GTK_IS_SHEET (sheet));
+
+  if (row < -1 || col < -1)
+    return;
 
-  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;
+      col >= psppire_axis_unit_count (sheet->haxis))
+    return;
 
   sheet->active_cell.row = row;
   sheet->active_cell.col = col;
 
   if (!GTK_WIDGET_REALIZED (GTK_WIDGET (sheet)))
-    return TRUE;
-
-  gtk_sheet_deactivate_cell (sheet);
+    return;
 
   if ( row == -1 || col == -1)
     {
       gtk_sheet_hide_active_cell (sheet);
-      return TRUE;
+      return;
     }
 
-  return gtk_sheet_activate_cell (sheet, row, col);
+  change_active_cell (sheet, row, col);
 }
 
 void
@@ -2673,6 +2542,8 @@ gtk_sheet_entry_changed (GtkWidget *widget, gpointer data)
 
   text = gtk_entry_get_text (GTK_ENTRY (gtk_sheet_get_entry (sheet)));
 
+
+
   if (text && strlen (text) > 0)
     {
       gtk_sheet_get_attributes (sheet, row, col, &attributes);
@@ -2685,54 +2556,6 @@ gtk_sheet_entry_changed (GtkWidget *widget, gpointer data)
 }
 
 
-static void
-gtk_sheet_deactivate_cell (GtkSheet *sheet)
-{
-  g_return_if_fail (sheet != NULL);
-  g_return_if_fail (GTK_IS_SHEET (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);
-
-
-  g_signal_handlers_disconnect_by_func (gtk_sheet_get_entry (sheet),
-					G_CALLBACK (gtk_sheet_entry_changed),
-					sheet);
-
-  gtk_sheet_hide_active_cell (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)
 {
@@ -2763,27 +2586,32 @@ gtk_sheet_hide_active_cell (GtkSheet *sheet)
   GTK_WIDGET_UNSET_FLAGS (GTK_WIDGET (sheet->entry_widget), GTK_VISIBLE);
 }
 
-static gboolean
-gtk_sheet_activate_cell (GtkSheet *sheet, gint row, gint col)
+static void
+change_active_cell (GtkSheet *sheet, gint row, gint col)
 {
-  gboolean veto = TRUE;
+  gint old_row, old_col;
+  glong old_handler_id = sheet->entry_handler_id;
 
-  g_return_val_if_fail (sheet != NULL, FALSE);
-  g_return_val_if_fail (GTK_IS_SHEET (sheet), FALSE);
+  g_return_if_fail (GTK_IS_SHEET (sheet));
 
-  if (row < 0 || col < 0) return FALSE;
+  if (row < 0 || col < 0)
+    return;
 
   if ( row > g_sheet_row_get_row_count (sheet->row_geometry)
-       || col > g_sheet_column_get_column_count (sheet->column_geometry))
-    return FALSE;
+       || col > psppire_axis_unit_count (sheet->haxis))
+    return;
 
-  if (!veto) return FALSE;
   if (sheet->state != GTK_SHEET_NORMAL)
     {
       sheet->state = GTK_SHEET_NORMAL;
       gtk_sheet_real_unselect_range (sheet, NULL);
     }
 
+  g_signal_handler_block   (sheet->entry_widget, sheet->entry_handler_id);
+
+  old_row = sheet->active_cell.row;
+  old_col = sheet->active_cell.col;
+
   sheet->range.row0 = row;
   sheet->range.col0 = col;
   sheet->range.rowi = row;
@@ -2797,14 +2625,12 @@ gtk_sheet_activate_cell (GtkSheet *sheet, gint row, gint col)
 
   gtk_sheet_show_active_cell (sheet);
 
-  g_signal_connect (gtk_sheet_get_entry (sheet),
-		    "changed",
-		    G_CALLBACK (gtk_sheet_entry_changed),
-		    sheet);
 
-   g_signal_emit (sheet, sheet_signals [ACTIVATE], 0, row, col, &veto);
+  g_signal_emit (sheet, sheet_signals [ACTIVATE], 0,
+		 row, col, old_row, old_col);
 
-  return TRUE;
+  if ( old_handler_id == sheet->entry_handler_id)
+    g_signal_handler_unblock   (sheet->entry_widget, sheet->entry_handler_id);
 }
 
 static void
@@ -2955,10 +2781,10 @@ gtk_sheet_new_selection (GtkSheet *sheet, GtkSheetRange *range)
 
 	      if (mask1 != mask2)
 		{
-		  x = g_sheet_column_start_pixel (sheet->column_geometry, j);
+		  x = psppire_axis_pixel_start (sheet->haxis, j);
 		  y = g_sheet_row_start_pixel (sheet->row_geometry, i);
-		  width = g_sheet_column_start_pixel (sheet->column_geometry, j)- x+
-		    g_sheet_column_get_width (sheet->column_geometry, j);
+		  width = psppire_axis_pixel_start (sheet->haxis, j)- x+
+		    psppire_axis_unit_size (sheet->haxis, 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)
@@ -2976,10 +2802,10 @@ gtk_sheet_new_selection (GtkSheet *sheet, GtkSheetRange *range)
 
 		  if (i != sheet->active_cell.row || j != sheet->active_cell.col)
 		    {
-		      x = g_sheet_column_start_pixel (sheet->column_geometry, j);
+		      x = psppire_axis_pixel_start (sheet->haxis, j);
 		      y = g_sheet_row_start_pixel (sheet->row_geometry, i);
-		      width = g_sheet_column_start_pixel (sheet->column_geometry, j)- x+
-			g_sheet_column_get_width (sheet->column_geometry, j);
+		      width = psppire_axis_pixel_start (sheet->haxis, j)- x+
+			psppire_axis_unit_size (sheet->haxis, j);
 
 		      height = g_sheet_row_start_pixel (sheet->row_geometry, i) - y + g_sheet_row_get_height (sheet->row_geometry, i);
 
@@ -3019,9 +2845,9 @@ gtk_sheet_new_selection (GtkSheet *sheet, GtkSheetRange *range)
 	  if (state == GTK_STATE_SELECTED && !selected)
 	    {
 
-	      x = g_sheet_column_start_pixel (sheet->column_geometry, j);
+	      x = psppire_axis_pixel_start (sheet->haxis, j);
 	      y = g_sheet_row_start_pixel (sheet->row_geometry, i);
-	      width = g_sheet_column_start_pixel (sheet->column_geometry, j) - x + g_sheet_column_get_width (sheet->column_geometry, j);
+	      width = psppire_axis_pixel_start (sheet->haxis, j) - x + psppire_axis_unit_size (sheet->haxis, 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)
@@ -3054,9 +2880,9 @@ gtk_sheet_new_selection (GtkSheet *sheet, GtkSheetRange *range)
 	      (i != sheet->active_cell.row || j != sheet->active_cell.col))
 	    {
 
-	      x = g_sheet_column_start_pixel (sheet->column_geometry, j);
+	      x = psppire_axis_pixel_start (sheet->haxis, j);
 	      y = g_sheet_row_start_pixel (sheet->row_geometry, i);
-	      width = g_sheet_column_start_pixel (sheet->column_geometry, j) - x + g_sheet_column_get_width (sheet->column_geometry, j);
+	      width = psppire_axis_pixel_start (sheet->haxis, j) - x + psppire_axis_unit_size (sheet->haxis, 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)
@@ -3100,9 +2926,9 @@ gtk_sheet_new_selection (GtkSheet *sheet, GtkSheetRange *range)
 	  mask2 = j == new_range.coli ? mask2 + 8 : mask2;
 	  if (mask2 != mask1 || (mask2 == mask1 && state != GTK_STATE_SELECTED))
 	    {
-	      x = g_sheet_column_start_pixel (sheet->column_geometry, j);
+	      x = psppire_axis_pixel_start (sheet->haxis, j);
 	      y = g_sheet_row_start_pixel (sheet->row_geometry, i);
-	      width = g_sheet_column_get_width (sheet->column_geometry, j);
+	      width = psppire_axis_unit_size (sheet->haxis, j);
 	      height = g_sheet_row_get_height (sheet->row_geometry, i);
 	      if (mask2 & 1)
 		gdk_draw_rectangle (sheet->sheet_window,
@@ -3213,8 +3039,6 @@ gtk_sheet_select_range (GtkSheet *sheet, const GtkSheetRange *range)
 
   if (sheet->state != GTK_SHEET_NORMAL)
     gtk_sheet_real_unselect_range (sheet, NULL);
-  else
-    gtk_sheet_deactivate_cell (sheet);
 
   sheet->range.row0 = range->row0;
   sheet->range.rowi = range->rowi;
@@ -3238,8 +3062,8 @@ gtk_sheet_unselect_range (GtkSheet *sheet)
   gtk_sheet_real_unselect_range (sheet, NULL);
   sheet->state = GTK_STATE_NORMAL;
 
-  gtk_sheet_activate_cell (sheet,
-			   sheet->active_cell.row, sheet->active_cell.col);
+  change_active_cell (sheet,
+		 sheet->active_cell.row, sheet->active_cell.col);
 }
 
 
@@ -3291,19 +3115,17 @@ gtk_sheet_expose (GtkWidget *widget,
   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);
+      draw_row_title_buttons_range (sheet,
+				    min_visible_row (sheet),
+				    max_visible_row (sheet));
     }
 
   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);
+      draw_column_title_buttons_range (sheet,
+				       min_visible_column (sheet),
+				       max_visible_column (sheet));
     }
 
 
@@ -3396,10 +3218,12 @@ gtk_sheet_button_press (GtkWidget *widget,
 		     sheet_signals[BUTTON_EVENT_COLUMN], 0,
 		     column, event);
 
-      if ( event->type == GDK_2BUTTON_PRESS && event->button == 1)
-	g_signal_emit (sheet,
-		       sheet_signals[DOUBLE_CLICK_COLUMN], 0, column);
-
+      if (g_sheet_model_get_column_sensitivity (sheet->model, column))
+	{
+	  if ( event->type == GDK_2BUTTON_PRESS && event->button == 1)
+	    g_signal_emit (sheet,
+			   sheet_signals[DOUBLE_CLICK_COLUMN], 0, column);
+	}
     }
   else if (event->window == sheet->row_title_window)
     {
@@ -3407,11 +3231,14 @@ gtk_sheet_button_press (GtkWidget *widget,
 		     sheet_signals[BUTTON_EVENT_ROW], 0,
 		     row, event);
 
-      if ( event->type == GDK_2BUTTON_PRESS && event->button == 1)
-	g_signal_emit (sheet,
-		       sheet_signals[DOUBLE_CLICK_ROW], 0, row);
-    }
 
+      if (g_sheet_row_get_sensitivity (sheet->row_geometry, row))
+	{
+	  if ( event->type == GDK_2BUTTON_PRESS && event->button == 1)
+	    g_signal_emit (sheet,
+			   sheet_signals[DOUBLE_CLICK_ROW], 0, row);
+	}
+    }
 
   gdk_window_get_pointer (widget->window, NULL, NULL, &mods);
 
@@ -3433,12 +3260,6 @@ gtk_sheet_button_press (GtkWidget *widget,
       if (on_column_boundary (sheet, sheet->x_drag, &sheet->drag_cell.col))
 	{
 	  guint req;
-	  if (event->type == GDK_2BUTTON_PRESS)
-	    {
-	      gtk_sheet_autoresize_column (sheet, sheet->drag_cell.col);
-	      GTK_SHEET_UNSET_FLAGS (sheet, GTK_SHEET_IN_XDRAG);
-	      return TRUE;
-	    }
 	  gtk_sheet_column_size_request (sheet, sheet->drag_cell.col, &req);
 	  GTK_SHEET_SET_FLAGS (sheet, GTK_SHEET_IN_XDRAG);
 	  gdk_pointer_grab (sheet->column_title_window, FALSE,
@@ -3502,7 +3323,6 @@ gtk_sheet_button_press (GtkWidget *widget,
 	    {
 	      row = sheet->active_cell.row;
 	      column = sheet->active_cell.col;
-	      gtk_sheet_deactivate_cell (sheet);
 	      sheet->active_cell.row = row;
 	      sheet->active_cell.col = column;
 	      sheet->drag_range = sheet->range;
@@ -3530,7 +3350,6 @@ gtk_sheet_button_press (GtkWidget *widget,
 	    {
 	      row = sheet->active_cell.row;
 	      column = sheet->active_cell.col;
-	      gtk_sheet_deactivate_cell (sheet);
 	      sheet->active_cell.row = row;
 	      sheet->active_cell.col = column;
 	      sheet->drag_range = sheet->range;
@@ -3566,7 +3385,7 @@ gtk_sheet_button_press (GtkWidget *widget,
 
       column = column_from_xpixel (sheet, x);
 
-      if (g_sheet_column_get_sensitivity (sheet->column_geometry, column))
+      if (g_sheet_model_get_column_sensitivity (sheet->model, column))
 	{
 	  veto = gtk_sheet_click_cell (sheet, -1, column);
 	  gtk_grab_add (GTK_WIDGET (sheet));
@@ -3599,17 +3418,22 @@ gtk_sheet_button_press (GtkWidget *widget,
 static gboolean
 gtk_sheet_click_cell (GtkSheet *sheet, gint row, gint column)
 {
+  GtkSheetCell cell;
   gboolean forbid_move;
 
+  cell.row = row;
+  cell.col = column;
+
   if (row >= g_sheet_row_get_row_count (sheet->row_geometry)
-      || column >= g_sheet_column_get_column_count (sheet->column_geometry))
+      || column >= psppire_axis_unit_count (sheet->haxis))
     {
       return FALSE;
     }
 
   g_signal_emit (sheet, sheet_signals[TRAVERSE], 0,
-		 sheet->active_cell.row, sheet->active_cell.col,
-		 &row, &column, &forbid_move);
+		 &sheet->active_cell,
+		 &cell,
+		 &forbid_move);
 
   if (forbid_move)
     {
@@ -3619,7 +3443,7 @@ gtk_sheet_click_cell (GtkSheet *sheet, gint row, gint column)
       row = sheet->active_cell.row;
       column = sheet->active_cell.col;
 
-      gtk_sheet_activate_cell (sheet, row, column);
+      change_active_cell (sheet, row, column);
       return FALSE;
     }
 
@@ -3641,7 +3465,7 @@ gtk_sheet_click_cell (GtkSheet *sheet, gint row, gint column)
       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;
+	psppire_axis_unit_count (sheet->haxis) - 1;
       sheet->active_cell.row = 0;
       sheet->active_cell.col = 0;
       gtk_sheet_select_range (sheet, NULL);
@@ -3655,8 +3479,7 @@ gtk_sheet_click_cell (GtkSheet *sheet, gint row, gint column)
     }
   else
     {
-      gtk_sheet_deactivate_cell (sheet);
-      gtk_sheet_activate_cell (sheet, row, column);
+      change_active_cell (sheet, row, column);
     }
 
   sheet->active_cell.row = row;
@@ -3774,7 +3597,7 @@ gtk_sheet_button_release (GtkWidget *widget,
     {
       GTK_SHEET_UNSET_FLAGS (sheet, GTK_SHEET_IN_SELECTION);
       gdk_display_pointer_ungrab (display, event->time);
-      gtk_sheet_activate_cell (sheet, sheet->active_cell.row,
+      change_active_cell (sheet, sheet->active_cell.row,
 			       sheet->active_cell.col);
     }
 
@@ -3913,9 +3736,7 @@ motion_timeout_callback (gpointer data)
       if (sheet->row_title_under)
 	{
 	  GSheetRow *row_geo = sheet->row_geometry;
-	  gchar *text;
-
-	  text = g_sheet_row_get_subtitle (row_geo, row);
+	  gchar *text = g_sheet_row_get_subtitle (row_geo, row);
 
 	  show_subtitle (sheet, row, -1, text);
 	  g_free (text);
@@ -3923,10 +3744,8 @@ motion_timeout_callback (gpointer data)
 
       if (sheet->column_title_under)
 	{
-	  GSheetColumn *col_geo = sheet->column_geometry;
-	  gchar *text;
-
-	  text = g_sheet_column_get_subtitle (col_geo, column);
+	  gchar *text = g_sheet_model_get_column_subtitle (sheet->model,
+							   column);
 
 	  show_subtitle (sheet, -1, column, text);
 
@@ -4124,7 +3943,7 @@ gtk_sheet_motion (GtkWidget *widget,  GdkEventMotion *event)
       sheet->y_drag = y;
       aux = sheet->range;
       if (aux.row0 + row >= 0 && aux.rowi + row < g_sheet_row_get_row_count (sheet->row_geometry) &&
-	  aux.col0 + column >= 0 && aux.coli + column < g_sheet_column_get_column_count (sheet->column_geometry))
+	  aux.col0 + column >= 0 && aux.coli + column < psppire_axis_unit_count (sheet->haxis))
 	{
 	  aux = sheet->drag_range;
 	  sheet->drag_range.row0 = sheet->range.row0 + row;
@@ -4146,7 +3965,7 @@ 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 - g_sheet_column_start_pixel (sheet->column_geometry, sheet->drag_cell.col)) >
+      if (abs (x - psppire_axis_pixel_start (sheet->haxis, 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);
@@ -4156,8 +3975,8 @@ gtk_sheet_motion (GtkWidget *widget,  GdkEventMotion *event)
 
       /*use half of column width resp. row height as threshold to
 	expand selection*/
-      col_threshold = g_sheet_column_start_pixel (sheet->column_geometry, current_col) +
-	g_sheet_column_get_width (sheet->column_geometry, current_col) / 2;
+      col_threshold = psppire_axis_pixel_start (sheet->haxis, current_col) +
+	psppire_axis_unit_size (sheet->haxis, current_col) / 2;
       if (column > 0)
 	{
 	  if (x < col_threshold)
@@ -4193,7 +4012,7 @@ gtk_sheet_motion (GtkWidget *widget,  GdkEventMotion *event)
 	row = 0;
 
       if (aux.row0 + row >= 0 && aux.rowi + row < g_sheet_row_get_row_count (sheet->row_geometry) &&
-	  aux.col0 + column >= 0 && aux.coli + column < g_sheet_column_get_column_count (sheet->column_geometry))
+	  aux.col0 + column >= 0 && aux.coli + column < psppire_axis_unit_count (sheet->haxis))
 	{
 	  aux = sheet->drag_range;
 	  sheet->drag_range = sheet->range;
@@ -4240,71 +4059,6 @@ gtk_sheet_crossing_notify (GtkWidget *widget,
   return TRUE;
 }
 
-
-static gboolean
-gtk_sheet_move_query (GtkSheet *sheet, gint row, gint column)
-{
-  gint height, width;
-  gint new_row = row;
-  gint new_col = column;
-
-  gint row_move = FALSE;
-  gint column_move = FALSE;
-  gfloat row_align = -1.0;
-  gfloat col_align = -1.0;
-
-  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)
-    {
-      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 &&
-	  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)
-	{
-	  row_move = FALSE;
-	  row_align = -1.;
-	}
-    }
-
-  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)
-    {
-      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) &&
-	  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)
-    {
-      col_align = 0.0;
-      column_move = TRUE;
-    }
-
-  if (row_move || column_move)
-    {
-      gtk_sheet_moveto (sheet, new_row, new_col, row_align, col_align);
-    }
-
-  return (row_move || column_move);
-}
-
 static void
 gtk_sheet_extend_selection (GtkSheet *sheet, gint row, gint column)
 {
@@ -4317,7 +4071,6 @@ gtk_sheet_extend_selection (GtkSheet *sheet, gint row, gint column)
 
   if (sheet->selection_mode == GTK_SELECTION_SINGLE) return;
 
-  gtk_sheet_move_query (sheet, row, column);
   gtk_widget_grab_focus (GTK_WIDGET (sheet));
 
   if (GTK_SHEET_IN_DRAG (sheet)) return;
@@ -4327,7 +4080,7 @@ gtk_sheet_extend_selection (GtkSheet *sheet, gint row, gint column)
   switch (sheet->state)
     {
     case GTK_SHEET_ROW_SELECTED:
-      column = g_sheet_column_get_column_count (sheet->column_geometry) - 1;
+      column = psppire_axis_unit_count (sheet->haxis) - 1;
       break;
     case GTK_SHEET_COLUMN_SELECTED:
       row = g_sheet_row_get_row_count (sheet->row_geometry) - 1;
@@ -4409,55 +4162,104 @@ page_vertical (GtkSheet *sheet, GtkScrollType dir)
 
   new_row =  yyy_row_ypixel_to_row (sheet, vpixel);
 
-  gtk_sheet_activate_cell (sheet, new_row,
+  change_active_cell (sheet, new_row,
 			   sheet->active_cell.col);
 }
 
 
 static void
-step_horizontal (GtkSheet *sheet, GtkScrollType dir)
+step_sheet (GtkSheet *sheet, GtkScrollType dir)
 {
+  gint current_row = sheet->active_cell.row;
+  gint current_col = sheet->active_cell.col;
+  GtkSheetCell new_cell ;
+  gboolean forbidden = FALSE;
+
+  new_cell.row = current_row;
+  new_cell.col = current_col;
+
   switch ( dir)
     {
+    case GTK_SCROLL_STEP_DOWN:
+      new_cell.row++;
+      break;
+    case GTK_SCROLL_STEP_UP:
+      new_cell.row--;
+      break;
     case GTK_SCROLL_STEP_RIGHT:
-
-      gtk_sheet_activate_cell (sheet,
-			       sheet->active_cell.row,
-			       sheet->active_cell.col + 1);
+      new_cell.col++;
       break;
     case GTK_SCROLL_STEP_LEFT:
-
-      gtk_sheet_activate_cell (sheet,
-			       sheet->active_cell.row,
-			       sheet->active_cell.col - 1);
+      new_cell.col--;
       break;
-
     default:
       g_assert_not_reached ();
       break;
     }
 
-  if ( sheet->active_cell.col >= max_visible_column (sheet))
+
+  maximize_int (&new_cell.row, 0);
+  maximize_int (&new_cell.col, 0);
+
+  minimize_int (&new_cell.row,
+		g_sheet_row_get_row_count (sheet->row_geometry) - 1);
+
+  minimize_int (&new_cell.col,
+		psppire_axis_unit_count (sheet->haxis) - 1);
+
+  g_signal_emit (sheet, sheet_signals[TRAVERSE], 0,
+		 &sheet->active_cell,
+		 &new_cell,
+		&forbidden);
+
+  if (forbidden)
+    return;
+
+  change_active_cell (sheet, new_cell.row, new_cell.col);
+
+  if ( new_cell.col > max_fully_visible_column (sheet))
     {
       glong hpos  =
-	g_sheet_column_start_pixel (sheet->column_geometry,
-				    sheet->active_cell.col + 1);
+	psppire_axis_pixel_start (sheet->haxis,
+				    new_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))
+  else if ( new_cell.col < min_fully_visible_column (sheet))
     {
       glong hpos  =
-	g_sheet_column_start_pixel (sheet->column_geometry,
-				    sheet->active_cell.col);
+	psppire_axis_pixel_start (sheet->haxis,
+				    new_cell.col);
 
       gtk_adjustment_set_value (sheet->hadjustment,
 				hpos);
     }
+
+
+  if ( new_cell.row > max_fully_visible_row (sheet))
+    {
+      glong vpos  =
+	g_sheet_row_start_pixel (sheet->row_geometry,
+				    new_cell.row + 1);
+      vpos -= sheet->vadjustment->page_size;
+
+      gtk_adjustment_set_value (sheet->vadjustment,
+				vpos);
+    }
+  else if ( new_cell.row < min_fully_visible_row (sheet))
+    {
+      glong vpos  =
+	g_sheet_row_start_pixel (sheet->row_geometry,
+				    new_cell.row);
+
+      gtk_adjustment_set_value (sheet->vadjustment,
+				vpos);
+    }
 }
 
+
 static gboolean
 gtk_sheet_key_press (GtkWidget *widget,
 		     GdkEventKey *key)
@@ -4470,33 +4272,18 @@ gtk_sheet_key_press (GtkWidget *widget,
     {
     case GDK_Tab:
     case GDK_Right:
-      step_horizontal (sheet, GTK_SCROLL_STEP_RIGHT);
+      step_sheet (sheet, GTK_SCROLL_STEP_RIGHT);
       break;
     case GDK_ISO_Left_Tab:
     case GDK_Left:
-      step_horizontal (sheet, GTK_SCROLL_STEP_LEFT);
+      step_sheet (sheet, GTK_SCROLL_STEP_LEFT);
       break;
-
     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);
+      step_sheet (sheet, GTK_SCROLL_STEP_DOWN);
       break;
     case GDK_Up:
-      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);
+      step_sheet (sheet, GTK_SCROLL_STEP_UP);
       break;
 
     case GDK_Page_Down:
@@ -4510,7 +4297,7 @@ gtk_sheet_key_press (GtkWidget *widget,
       gtk_adjustment_set_value (sheet->vadjustment,
 				sheet->vadjustment->lower);
 
-      gtk_sheet_activate_cell (sheet,  0,
+      change_active_cell (sheet,  0,
 			       sheet->active_cell.col);
 
       break;
@@ -4522,7 +4309,7 @@ gtk_sheet_key_press (GtkWidget *widget,
 				sheet->vadjustment->page_increment);
 
       /*
-	gtk_sheet_activate_cell (sheet,
+	change_active_cellx (sheet,
 	g_sheet_row_get_row_count (sheet->row_geometry) - 1,
 	sheet->active_cell.col);
       */
@@ -4551,7 +4338,7 @@ gtk_sheet_size_request (GtkWidget *widget,
   sheet = GTK_SHEET (widget);
 
   requisition->width = 3 * DEFAULT_COLUMN_WIDTH;
-  requisition->height = 3 * default_row_height (sheet);
+  requisition->height = 3 * DEFAULT_ROW_HEIGHT;
 
   /* compute the size of the column title area */
   if (sheet->column_titles_visible)
@@ -4626,9 +4413,6 @@ gtk_sheet_size_allocate (GtkWidget *widget,
 			    sheet->column_title_area.height);
 
 
-  /* column button allocation */
-  draw_column_title_buttons (sheet);
-
   /* position the window which holds the row title buttons */
   sheet->row_title_area.x = 0;
   sheet->row_title_area.y = 0;
@@ -4648,10 +4432,6 @@ gtk_sheet_size_allocate (GtkWidget *widget,
 			    sheet->row_title_area.height);
 
 
-  /* row button allocation */
-  draw_row_title_buttons (sheet);
-  draw_column_title_buttons (sheet);
-
   /* set the scrollbars adjustments */
   adjust_scrollbars (sheet);
 }
@@ -4659,7 +4439,6 @@ gtk_sheet_size_allocate (GtkWidget *widget,
 static void
 draw_column_title_buttons (GtkSheet *sheet)
 {
-  gint i;
   gint x, width;
 
   if (!sheet->column_titles_visible) return;
@@ -4686,7 +4465,7 @@ draw_column_title_buttons (GtkSheet *sheet)
     }
 
   if (max_visible_column (sheet) ==
-      g_sheet_column_get_column_count (sheet->column_geometry) - 1)
+      psppire_axis_unit_count (sheet->haxis) - 1)
     gdk_window_clear_area (sheet->column_title_window,
 			   0, 0,
 			   sheet->column_title_area.width,
@@ -4696,14 +4475,13 @@ draw_column_title_buttons (GtkSheet *sheet)
 
   size_allocate_global_button (sheet);
 
-  for (i = min_visible_column (sheet); i <= max_visible_column (sheet); i++)
-    gtk_sheet_column_title_button_draw (sheet, i);
+  draw_column_title_buttons_range (sheet, min_visible_column (sheet), 
+				   max_visible_column (sheet));
 }
 
 static void
 draw_row_title_buttons (GtkSheet *sheet)
 {
-  gint i;
   gint y = 0;
   gint height;
 
@@ -4739,12 +4517,9 @@ draw_row_title_buttons (GtkSheet *sheet)
 
   size_allocate_global_button (sheet);
 
-  for (i = min_visible_row (sheet); i <= max_visible_row (sheet); i++)
-    {
-      if ( i >= g_sheet_row_get_row_count (sheet->row_geometry))
-	break;
-      gtk_sheet_row_title_button_draw (sheet, i);
-    }
+
+  draw_row_title_buttons_range (sheet, min_visible_row (sheet),
+				max_visible_row (sheet));
 }
 
 
@@ -4838,6 +4613,12 @@ create_sheet_entry (GtkSheet *sheet)
 			    G_CALLBACK (gtk_sheet_entry_key_press),
 			    sheet);
 
+  sheet->entry_handler_id =
+    g_signal_connect (sheet->entry_widget,
+		      "changed",
+		      G_CALLBACK (gtk_sheet_entry_changed),
+		      sheet);
+
   gtk_widget_show (sheet->entry_widget);
 }
 
@@ -4894,7 +4675,7 @@ gtk_sheet_get_entry_widget (GtkSheet *sheet)
 
 
 static void
-gtk_sheet_button_draw (GtkSheet *sheet, GdkWindow *window,
+draw_button (GtkSheet *sheet, GdkWindow *window,
 		       GtkSheetButton *button, gboolean is_sensitive,
 		       GdkRectangle allocation)
 {
@@ -4905,8 +4686,6 @@ gtk_sheet_button_draw (GtkSheet *sheet, GdkWindow *window,
   gboolean rtl ;
 
   gint state = 0;
-  gint len = 0;
-  gchar *line = 0;
 
   g_return_if_fail (sheet != NULL);
   g_return_if_fail (button != NULL);
@@ -4943,8 +4722,7 @@ gtk_sheet_button_draw (GtkSheet *sheet, GdkWindow *window,
 
   if (button->label_visible)
     {
-
-      text_height = default_row_height (sheet) -
+      text_height = DEFAULT_ROW_HEIGHT -
 	2 * COLUMN_TITLES_HEIGHT;
 
       gdk_gc_set_clip_rectangle (GTK_WIDGET (sheet)->style->fg_gc[button->state],
@@ -4954,68 +4732,46 @@ gtk_sheet_button_draw (GtkSheet *sheet, GdkWindow *window,
 
       allocation.y += 2 * sheet->button->style->ythickness;
 
-
       if (button->label && strlen (button->label)>0)
 	{
-	  gchar *words = 0;
+	  PangoRectangle rect;
+	  gchar *line = button->label;
+
 	  PangoLayout *layout = NULL;
-	  gint real_x = allocation.x, real_y = allocation.y;
+	  gint real_x = allocation.x;
+	  gint real_y = allocation.y;
 
-	  words = button->label;
-	  line = g_new (gchar, 1);
-	  line[0]='\0';
+	  layout = gtk_widget_create_pango_layout (GTK_WIDGET (sheet), line);
+	  pango_layout_get_extents (layout, NULL, &rect);
 
-	  while (words && *words != '\0')
+	  text_width = PANGO_PIXELS (rect.width);
+	  switch (button->justification)
 	    {
-	      if (*words != '\n')
-		{
-		  len = strlen (line);
-		  line = g_realloc (line, len + 2);
-		  line[len]=*words;
-		  line[len + 1]='\0';
-		}
-	      if (*words == '\n' || * (words + 1) == '\0')
-		{
-		  text_width = STRING_WIDTH (GTK_WIDGET (sheet), GTK_WIDGET (sheet)->style->font_desc, line);
-
-		  layout = gtk_widget_create_pango_layout (GTK_WIDGET (sheet), line);
-		  switch (button->justification)
-		    {
-		    case GTK_JUSTIFY_LEFT:
-		      real_x = allocation.x + COLUMN_TITLES_HEIGHT;
-		      align = rtl ? PANGO_ALIGN_RIGHT : PANGO_ALIGN_LEFT;
-		      break;
-		    case GTK_JUSTIFY_RIGHT:
-		      real_x = allocation.x + allocation.width - text_width - COLUMN_TITLES_HEIGHT;
-		      align = rtl ? PANGO_ALIGN_LEFT : PANGO_ALIGN_RIGHT;
-		      break;
-		    case GTK_JUSTIFY_CENTER:
-		    default:
-		      real_x = allocation.x + (allocation.width - text_width)/2;
-		      align = rtl ? PANGO_ALIGN_RIGHT : PANGO_ALIGN_LEFT;
-		      pango_layout_set_justify (layout, TRUE);
-		    }
-		  pango_layout_set_alignment (layout, align);
-		  gtk_paint_layout (GTK_WIDGET (sheet)->style,
-				    window,
-				    state,
-				    FALSE,
-				    &allocation,
-				    GTK_WIDGET (sheet),
-				    "label",
-				    real_x, real_y,
-				    layout);
-		  g_object_unref (layout);
-
-		  real_y += text_height + 2;
-
-		  g_free (line);
-		  line = g_new (gchar, 1);
-		  line[0]='\0';
-		}
-	      words++;
+	    case GTK_JUSTIFY_LEFT:
+	      real_x = allocation.x + COLUMN_TITLES_HEIGHT;
+	      align = rtl ? PANGO_ALIGN_RIGHT : PANGO_ALIGN_LEFT;
+	      break;
+	    case GTK_JUSTIFY_RIGHT:
+	      real_x = allocation.x + allocation.width - text_width - COLUMN_TITLES_HEIGHT;
+	      align = rtl ? PANGO_ALIGN_LEFT : PANGO_ALIGN_RIGHT;
+	      break;
+	    case GTK_JUSTIFY_CENTER:
+	    default:
+	      real_x = allocation.x + (allocation.width - text_width)/2;
+	      align = rtl ? PANGO_ALIGN_RIGHT : PANGO_ALIGN_LEFT;
+	      pango_layout_set_justify (layout, TRUE);
 	    }
-	  g_free (line);
+	  pango_layout_set_alignment (layout, align);
+	  gtk_paint_layout (GTK_WIDGET (sheet)->style,
+			    window,
+			    state,
+			    FALSE,
+			    &allocation,
+			    GTK_WIDGET (sheet),
+			    "label",
+			    real_x, real_y,
+			    layout);
+	  g_object_unref (layout);
 	}
 
       gdk_gc_set_clip_rectangle (GTK_WIDGET (sheet)->style->fg_gc[button->state],
@@ -5027,60 +4783,90 @@ gtk_sheet_button_draw (GtkSheet *sheet, GdkWindow *window,
   gtk_sheet_button_free (button);
 }
 
+
+/* Draw the column title buttons FIRST through to LAST */
 static void
-gtk_sheet_column_title_button_draw (GtkSheet *sheet, gint column)
+draw_column_title_buttons_range (GtkSheet *sheet, gint first, gint last)
 {
-  GdkRectangle allocation;
-  GtkSheetButton *button = NULL;
-  gboolean is_sensitive = FALSE;
-
+  GdkRegion *region;
+  gint col;
   if (!GTK_WIDGET_REALIZED (GTK_WIDGET (sheet))) return;
 
   if (!sheet->column_titles_visible) return;
 
-  if (column < min_visible_column (sheet)) return;
-  if (column > max_visible_column (sheet)) return;
+  g_return_if_fail (first >= min_visible_column (sheet));
+  g_return_if_fail (last <= max_visible_column (sheet));
 
-  button = g_sheet_column_get_button (sheet->column_geometry, column);
-  allocation.y = 0;
-  allocation.x = g_sheet_column_start_pixel (sheet->column_geometry, column) + CELL_SPACING;
-  allocation.x -= sheet->hadjustment->value;
+  region =
+    gdk_drawable_get_visible_region (GDK_DRAWABLE (sheet->column_title_window));
 
-  allocation.height = sheet->column_title_area.height;
-  allocation.width = g_sheet_column_get_width (sheet->column_geometry, column);
-  is_sensitive = g_sheet_column_get_sensitivity (sheet->column_geometry, column);
+  gdk_window_begin_paint_region (sheet->column_title_window, region);
+
+  for (col = first ; col <= last ; ++col)
+    {
+      GdkRectangle allocation;
+      gboolean is_sensitive = FALSE;
 
-  gtk_sheet_button_draw (sheet, sheet->column_title_window,
-			 button, is_sensitive, allocation);
+      GtkSheetButton *
+	button = g_sheet_model_get_column_button (sheet->model, col);
+      allocation.y = 0;
+      allocation.x = psppire_axis_pixel_start (sheet->haxis, col)
+	+ CELL_SPACING;
+      allocation.x -= sheet->hadjustment->value;
+
+      allocation.height = sheet->column_title_area.height;
+      allocation.width = psppire_axis_unit_size (sheet->haxis, col);
+      is_sensitive = g_sheet_model_get_column_sensitivity (sheet->model, col);
+
+      draw_button (sheet, sheet->column_title_window,
+		   button, is_sensitive, allocation);
+    }
+
+  gdk_window_end_paint (sheet->column_title_window);
 }
 
 
 static void
-gtk_sheet_row_title_button_draw (GtkSheet *sheet, gint row)
+draw_row_title_buttons_range (GtkSheet *sheet, gint first, gint last)
 {
-  GdkRectangle allocation;
-  GtkSheetButton *button = NULL;
-  gboolean is_sensitive = FALSE;
-
-
+  GdkRegion *region;
+  gint row;
   if (!GTK_WIDGET_REALIZED (GTK_WIDGET (sheet))) return;
 
   if (!sheet->row_titles_visible) return;
 
-  if (row < min_visible_row (sheet)) return;
-  if (row > max_visible_row (sheet)) return;
+  g_return_if_fail (first >= min_visible_row (sheet));
+  g_return_if_fail (last <= max_visible_row (sheet));
 
-  button = g_sheet_row_get_button (sheet->row_geometry, row);
-  allocation.x = 0;
-  allocation.y = g_sheet_row_start_pixel (sheet->row_geometry, row) + CELL_SPACING;
-  allocation.y -= sheet->vadjustment->value;
 
-  allocation.width = sheet->row_title_area.width;
-  allocation.height = g_sheet_row_get_height (sheet->row_geometry, row);
-  is_sensitive = g_sheet_row_get_sensitivity (sheet->row_geometry, row);
+  region =
+    gdk_drawable_get_visible_region (GDK_DRAWABLE (sheet->row_title_window));
 
-  gtk_sheet_button_draw (sheet, sheet->row_title_window,
-			 button, is_sensitive, allocation);
+  gdk_window_begin_paint_region (sheet->row_title_window, region);
+
+
+  for (row = first; row <= last; ++row)
+    {
+      GdkRectangle allocation;
+
+      gboolean is_sensitive = FALSE;
+
+      GtkSheetButton *button =
+	g_sheet_row_get_button (sheet->row_geometry, row);
+      allocation.x = 0;
+      allocation.y = g_sheet_row_start_pixel (sheet->row_geometry, row)
+	+ CELL_SPACING;
+      allocation.y -= sheet->vadjustment->value;
+
+      allocation.width = sheet->row_title_area.width;
+      allocation.height = g_sheet_row_get_height (sheet->row_geometry, row);
+      is_sensitive = g_sheet_row_get_sensitivity (sheet->row_geometry, row);
+
+      draw_button (sheet, sheet->row_title_window,
+		   button, is_sensitive, allocation);
+    }
+
+  gdk_window_end_paint (sheet->row_title_window);
 }
 
 /* SCROLLBARS
@@ -5100,6 +4886,12 @@ adjust_scrollbars (GtkSheet *sheet)
 
   gdk_drawable_get_size (sheet->sheet_window, &width, &height);
 
+  if ( sheet->row_titles_visible)
+    width -= sheet->row_title_area.width;
+
+  if (sheet->column_titles_visible)
+    height -= sheet->column_title_area.height;
+
   if (sheet->vadjustment)
     {
       glong last_row = g_sheet_row_get_row_count (sheet->row_geometry) - 1;
@@ -5121,9 +4913,6 @@ adjust_scrollbars (GtkSheet *sheet)
 	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 = height;
 
@@ -5137,17 +4926,14 @@ adjust_scrollbars (GtkSheet *sheet)
 
       sheet->hadjustment->page_increment = width;
 
-      last_col = g_sheet_column_get_column_count (sheet->column_geometry) - 1;
+      last_col = psppire_axis_unit_count (sheet->haxis) - 1;
 
       sheet->hadjustment->upper =
-	g_sheet_column_start_pixel (sheet->column_geometry, last_col)
+	psppire_axis_pixel_start (sheet->haxis, last_col)
 	+
-	g_sheet_column_get_width (sheet->column_geometry, last_col)
+	psppire_axis_unit_size (sheet->haxis, last_col)
 	;
 
-      if (sheet->row_titles_visible)
-	sheet->hadjustment->upper += sheet->row_title_area.width;
-
       sheet->hadjustment->lower = 0;
       sheet->hadjustment->page_size = width;
 
@@ -5260,10 +5046,10 @@ draw_xor_rectangle (GtkSheet *sheet, GtkSheetRange range)
   GdkRectangle clip_area, area;
   GdkGCValues values;
 
-  area.x = g_sheet_column_start_pixel (sheet->column_geometry, range.col0);
+  area.x = psppire_axis_pixel_start (sheet->haxis, range.col0);
   area.y = g_sheet_row_start_pixel (sheet->row_geometry, range.row0);
-  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.width = psppire_axis_pixel_start (sheet->haxis, range.coli)- area.x+
+    psppire_axis_unit_size (sheet->haxis, 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);
 
@@ -5318,7 +5104,7 @@ draw_xor_rectangle (GtkSheet *sheet, GtkSheetRange range)
 static guint
 new_column_width (GtkSheet *sheet, gint column, gint *x)
 {
-  gint left_pos = g_sheet_column_start_pixel (sheet->column_geometry, column)
+  gint left_pos = psppire_axis_pixel_start (sheet->haxis, column)
     - sheet->hadjustment->value;
 
   gint width = *x - left_pos;
@@ -5329,7 +5115,9 @@ new_column_width (GtkSheet *sheet, gint column, gint *x)
       *x = left_pos + width;
     }
 
+#if AXIS_TRANSITION
   g_sheet_column_set_width (sheet->column_geometry, column, width);
+#endif
 
   draw_column_title_buttons (sheet);
 
@@ -5377,13 +5165,15 @@ gtk_sheet_set_column_width (GtkSheet *sheet,
   g_return_if_fail (sheet != NULL);
   g_return_if_fail (GTK_IS_SHEET (sheet));
 
-  if (column < 0 || column >= g_sheet_column_get_column_count (sheet->column_geometry))
+  if (column < 0 || column >= psppire_axis_unit_count (sheet->haxis))
     return;
 
   gtk_sheet_column_size_request (sheet, column, &min_width);
   if (width < min_width) return;
 
+#if AXIS_TRANSITION
   g_sheet_column_set_width (sheet->column_geometry, column, width);
+#endif
 
   if (GTK_WIDGET_REALIZED (GTK_WIDGET (sheet)))
     {
@@ -5392,8 +5182,6 @@ gtk_sheet_set_column_width (GtkSheet *sheet,
       gtk_sheet_size_allocate_entry (sheet);
       gtk_sheet_range_draw (sheet, NULL);
     }
-
-  g_signal_emit (sheet, sheet_signals[CHANGED], 0, -1, column);
 }
 
 
@@ -5423,8 +5211,6 @@ gtk_sheet_set_row_height (GtkSheet *sheet,
       gtk_sheet_size_allocate_entry (sheet);
       gtk_sheet_range_draw (sheet, NULL);
     }
-
-  g_signal_emit (sheet, sheet_signals[CHANGED], 0, row, - 1);
 }
 
 gboolean
@@ -5474,7 +5260,7 @@ gtk_sheet_get_attributes (const GtkSheet *sheet, gint row, gint col,
     }
 
   attr->justification =
-    g_sheet_column_get_justification (sheet->column_geometry, col);
+    g_sheet_model_get_column_justification (sheet->model, col);
 
   j = g_sheet_model_get_justification (sheet->model, row, col);
   if (j)
@@ -5498,10 +5284,10 @@ gtk_sheet_button_size_request	 (GtkSheet *sheet,
   GtkRequisition requisition;
   GtkRequisition label_requisition;
 
-  label_requisition.height = default_row_height (sheet);
+  label_requisition.height = DEFAULT_ROW_HEIGHT;
   label_requisition.width = COLUMN_MIN_WIDTH;
 
-  requisition.height = default_row_height (sheet);
+  requisition.height = DEFAULT_ROW_HEIGHT;
   requisition.width = COLUMN_MIN_WIDTH;
 
 
@@ -5534,7 +5320,7 @@ gtk_sheet_column_size_request (GtkSheet *sheet,
 {
   GtkRequisition button_requisition;
 
-  GtkSheetButton *button = g_sheet_column_get_button (sheet->column_geometry, col);
+  GtkSheetButton *button = g_sheet_model_get_column_button (sheet->model, col);
 
   gtk_sheet_button_size_request (sheet,
 				 button,
@@ -5598,7 +5384,6 @@ gtk_sheet_button_free (GtkSheetButton *button)
   g_free (button);
 }
 
-
 static void
 append_cell_text (GString *string, const GtkSheet *sheet, gint r, gint c)
 {