X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=lib%2Fgtksheet%2Fgtksheet.c;h=45ee30d762986f2af92c242536bb14e38f0ff1f6;hb=e59613aae24bbddcaba25415a67dcf2010ebb55c;hp=a1cfbc63f92fd6ae1b4e6d74095143fe698aaabd;hpb=cbf0c4ae2ee371b392a05945877f5e6f803c837e;p=pspp-builds.git

diff --git a/lib/gtksheet/gtksheet.c b/lib/gtksheet/gtksheet.c
index a1cfbc63..45ee30d7 100644
--- a/lib/gtksheet/gtksheet.c
+++ b/lib/gtksheet/gtksheet.c
@@ -113,60 +113,48 @@ dispose_string (const GtkSheet *sheet, gchar *text)
     g_free (text);
 }
 
-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);
+/* FIXME: Why bother with these two ? */
 
-  g_object_unref (layout);
-  return PANGO_PIXELS (rect.width);
+/* 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);
 }
 
-/* Return the row containing pixel Y */
-static gint
-yyy_row_ypixel_to_row (const GtkSheet *sheet, gint y)
+static inline gint
+row_from_ypixel (const GtkSheet *sheet, gint pixel)
 {
-  GSheetRow *geo = sheet->row_geometry;
-
-  g_return_val_if_fail (y >= 0, -1);
-
-  return g_sheet_row_pixel_to_row (geo, y);
+  return psppire_axis_get_unit_at_pixel (sheet->vaxis, pixel);
 }
 
+
 /* 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);
+  return row_from_ypixel (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);
+  glong row = min_visible_row (sheet);
 
-  if ( g_sheet_row_start_pixel (sheet->row_geometry, row) < sheet->vadjustment->value)
+  if ( psppire_axis_pixel_start (sheet->vaxis, row) < sheet->vadjustment->value)
     row++;
 
-  return  row;
+  return row;
 }
 
-
-
 static inline glong
 max_visible_row (const GtkSheet *sheet)
 {
-  return yyy_row_ypixel_to_row (sheet,
-			   sheet->vadjustment->value +
-			   sheet->vadjustment->page_size);
+  return row_from_ypixel (sheet,
+			  sheet->vadjustment->value +
+			  sheet->vadjustment->page_size);
 }
 
 
@@ -175,9 +163,9 @@ max_fully_visible_row (const GtkSheet *sheet)
 {
   glong row = max_visible_row (sheet);
 
-  if ( g_sheet_row_start_pixel (sheet->row_geometry, row)
-       + 
-       g_sheet_row_get_height (sheet->row_geometry, row)
+  if ( psppire_axis_pixel_start (sheet->vaxis, row)
+       +
+       psppire_axis_unit_size (sheet->vaxis, row)
        > sheet->vadjustment->value)
     row--;
 
@@ -185,29 +173,6 @@ max_fully_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)
-{
-  gint i;
-  gint cx = 0;
-
-  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;
-
-      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 lowest column number which is wholly or partially
    on the sheet */
 static inline glong
@@ -221,7 +186,7 @@ min_fully_visible_column (const GtkSheet *sheet)
 {
   glong col = min_visible_column (sheet);
 
-  if ( g_sheet_column_start_pixel (sheet->column_geometry, col) < sheet->hadjustment->value)
+  if ( psppire_axis_pixel_start (sheet->haxis, col) < sheet->hadjustment->value)
     col++;
 
   return col;
@@ -243,9 +208,9 @@ max_fully_visible_column (const GtkSheet *sheet)
 {
   glong col = max_visible_column (sheet);
 
-  if ( g_sheet_column_start_pixel (sheet->column_geometry, col)
+  if ( psppire_axis_pixel_start (sheet->haxis, col)
        + 
-       g_sheet_column_get_width (sheet->column_geometry, col)
+       psppire_axis_unit_size (sheet->haxis, col)
        > sheet->hadjustment->value)
     col--;
 
@@ -282,30 +247,6 @@ on_column_boundary (const GtkSheet *sheet, gint x, gint *column)
   return FALSE;
 }
 
-static inline gboolean
-POSSIBLE_YDRAG (const GtkSheet *sheet, gint y, gint *drag_row)
-{
-  gint row, ydrag;
-
-  y += sheet->vadjustment->value;
-  row = yyy_row_ypixel_to_row (sheet, y);
-  *drag_row = row;
-
-  ydrag = g_sheet_row_start_pixel (sheet->row_geometry, row) + CELL_SPACING;
-  if (y <= ydrag + DRAG_WIDTH / 2 && row != 0)
-    {
-      *drag_row = row - 1;
-      return g_sheet_row_get_sensitivity (sheet->row_geometry, row - 1);
-    }
-
-  ydrag += g_sheet_row_get_height (sheet->row_geometry, row);
-
-  if (y >= ydrag - DRAG_WIDTH / 2 && y <= ydrag + DRAG_WIDTH / 2)
-    return g_sheet_row_get_sensitivity (sheet->row_geometry, row);
-
-  return FALSE;
-}
-
 static inline gboolean
 POSSIBLE_DRAG (const GtkSheet *sheet, gint x, gint y,
 	       gint *drag_row, gint *drag_column)
@@ -318,20 +259,20 @@ POSSIBLE_DRAG (const GtkSheet *sheet, gint x, gint y,
     return FALSE;
 
   *drag_column = column_from_xpixel (sheet, x);
-  *drag_row = yyy_row_ypixel_to_row (sheet, y);
+  *drag_row = row_from_ypixel (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);
+      ydrag = psppire_axis_pixel_start (sheet->vaxis, sheet->range.row0);
       if (y >= ydrag - DRAG_WIDTH / 2 && y <= ydrag + DRAG_WIDTH / 2)
 	{
 	  *drag_row = sheet->range.row0;
 	  return TRUE;
 	}
-      ydrag = g_sheet_row_start_pixel (sheet->row_geometry, sheet->range.rowi) +
-	g_sheet_row_get_height (sheet->row_geometry, sheet->range.rowi);
+      ydrag = psppire_axis_pixel_start (sheet->vaxis, sheet->range.rowi) +
+	psppire_axis_unit_size (sheet->vaxis, sheet->range.rowi);
       if (y >= ydrag - DRAG_WIDTH / 2 && y <= ydrag + DRAG_WIDTH / 2)
 	{
 	  *drag_row = sheet->range.rowi;
@@ -339,18 +280,18 @@ POSSIBLE_DRAG (const GtkSheet *sheet, gint x, gint y,
 	}
     }
 
-  if (y >= g_sheet_row_start_pixel (sheet->row_geometry, sheet->range.row0) - DRAG_WIDTH / 2 &&
-      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)
+  if (y >= psppire_axis_pixel_start (sheet->vaxis, sheet->range.row0) - DRAG_WIDTH / 2 &&
+      y <= psppire_axis_pixel_start (sheet->vaxis, sheet->range.rowi) +
+      psppire_axis_unit_size (sheet->vaxis, 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;
@@ -372,20 +313,20 @@ 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);
+  ydrag = psppire_axis_pixel_start (sheet->vaxis, sheet->range.rowi) +
+    psppire_axis_unit_size (sheet->vaxis, sheet->range.rowi);
 
   if (sheet->state == GTK_SHEET_COLUMN_SELECTED)
-    ydrag = g_sheet_row_start_pixel (sheet->row_geometry, min_visible_row (sheet));
+    ydrag = psppire_axis_pixel_start (sheet->vaxis, 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);
+  *drag_row = row_from_ypixel (sheet, y);
 
   if (x >= xdrag - DRAG_WIDTH / 2 && x <= xdrag + DRAG_WIDTH / 2 &&
       y >= ydrag - DRAG_WIDTH / 2 && y <= ydrag + DRAG_WIDTH / 2) return TRUE;
@@ -400,26 +341,26 @@ 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 = 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 = psppire_axis_pixel_start (sheet->vaxis, range->row0);
   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) +
-    g_sheet_row_get_height (sheet->row_geometry, range->rowi);
+  r->height = psppire_axis_pixel_start (sheet->vaxis, range->rowi) -
+    psppire_axis_pixel_start (sheet->vaxis, range->row0) +
+    psppire_axis_unit_size (sheet->vaxis, range->rowi);
 
   return TRUE;
 }
@@ -710,29 +651,33 @@ gtk_sheet_cell_get_type (void)
 enum
   {
     PROP_0,
-    PROP_ROW_GEO,
-    PROP_COL_GEO,
+    PROP_VAXIS,
+    PROP_HAXIS,
     PROP_MODEL
   };
 
 static void
-gtk_sheet_set_row_geometry (GtkSheet *sheet, GSheetRow *geo)
+gtk_sheet_set_horizontal_axis (GtkSheet *sheet, PsppireAxis *a)
 {
-  if ( sheet->row_geometry ) g_object_unref (sheet->row_geometry);
+  if ( sheet->haxis )
+    g_object_unref (sheet->haxis);
 
-  sheet->row_geometry = geo;
+  sheet->haxis = a;
 
-  if ( sheet->row_geometry ) g_object_ref (sheet->row_geometry);
+  if ( sheet->haxis )
+    g_object_ref (sheet->haxis);
 }
 
 static void
-gtk_sheet_set_column_geometry (GtkSheet *sheet, GSheetColumn *geo)
+gtk_sheet_set_vertical_axis (GtkSheet *sheet, PsppireAxis *a)
 {
-  if ( sheet->column_geometry ) g_object_unref (sheet->column_geometry);
+  if ( sheet->vaxis )
+    g_object_unref (sheet->vaxis);
 
-  sheet->column_geometry = geo;
+  sheet->vaxis = a;
 
-  if ( sheet->column_geometry ) g_object_ref (sheet->column_geometry);
+  if ( sheet->vaxis )
+    g_object_ref (sheet->vaxis);
 }
 
 
@@ -747,11 +692,11 @@ gtk_sheet_set_property (GObject         *object,
 
   switch (prop_id)
     {
-    case PROP_ROW_GEO:
-      gtk_sheet_set_row_geometry (sheet, g_value_get_pointer (value));
+    case PROP_VAXIS:
+      gtk_sheet_set_vertical_axis (sheet, g_value_get_pointer (value));
       break;
-    case PROP_COL_GEO:
-      gtk_sheet_set_column_geometry (sheet, g_value_get_pointer (value));
+    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));
@@ -772,11 +717,11 @@ gtk_sheet_get_property (GObject         *object,
 
   switch (prop_id)
     {
-    case PROP_ROW_GEO:
-      g_value_set_pointer (value, sheet->row_geometry);
+    case PROP_VAXIS:
+      g_value_set_pointer (value, sheet->vaxis);
       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);
@@ -793,8 +738,8 @@ 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 *vaxis_spec ;
   GParamSpec *model_spec ;
 
   GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
@@ -997,16 +942,16 @@ gtk_sheet_class_init (GtkSheetClass *klass)
   object_class->finalize = gtk_sheet_finalize;
 
 
-  row_geo_spec =
-    g_param_spec_pointer ("row-geometry",
-			  "Row Geometry",
-			  "A pointer to the model of the row geometry",
+  vaxis_spec =
+    g_param_spec_pointer ("vertical-axis",
+			  "Vertical Axis",
+			  "A pointer to the PsppireAxis object for the rows",
 			  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 =
@@ -1020,12 +965,12 @@ gtk_sheet_class_init (GtkSheetClass *klass)
   object_class->get_property = gtk_sheet_get_property;
 
   g_object_class_install_property (object_class,
-                                   PROP_ROW_GEO,
-                                   row_geo_spec);
+                                   PROP_VAXIS,
+                                   vaxis_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,
@@ -1064,8 +1009,8 @@ static void
 gtk_sheet_init (GtkSheet *sheet)
 {
   sheet->model = NULL;
-  sheet->column_geometry = NULL;
-  sheet->row_geometry = NULL;
+  sheet->haxis = NULL;
+  sheet->vaxis = NULL;
 
   sheet->flags = 0;
   sheet->selection_mode = GTK_SELECTION_NONE;
@@ -1154,8 +1099,8 @@ 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.rowi = g_sheet_row_get_row_count (sheet->row_geometry) - 1;
+  range.coli = psppire_axis_unit_count (sheet->haxis) - 1;
+  range.rowi = psppire_axis_unit_count (sheet->vaxis) - 1;
 
   adjust_scrollbars (sheet);
 
@@ -1185,8 +1130,8 @@ 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.rowi = psppire_axis_unit_count (sheet->vaxis) - 1;
+  range.coli = psppire_axis_unit_count (sheet->haxis) - 1;
 
   adjust_scrollbars (sheet);
 
@@ -1265,11 +1210,9 @@ 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 (void *vgeo, void *hgeo, GSheetModel *model)
 {
   GtkWidget *widget = g_object_new (GTK_TYPE_SHEET,
-				    "row-geometry", vgeo,
-				    "column-geometry", hgeo,
 				    "model", model,
 				    NULL);
   return widget;
@@ -1367,7 +1310,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
@@ -1497,16 +1440,16 @@ gtk_sheet_moveto (GtkSheet *sheet,
   g_return_if_fail (col_align <= 1);
 
   g_return_if_fail (col <
-		    g_sheet_column_get_column_count (sheet->column_geometry));
+		    psppire_axis_unit_count (sheet->haxis));
   g_return_if_fail (row <
-		    g_sheet_row_get_row_count (sheet->row_geometry));
+		    psppire_axis_unit_count (sheet->vaxis));
 
   gdk_drawable_get_size (sheet->sheet_window, &width, &height);
 
 
   if (row >= 0)
   {
-    gint y =  g_sheet_row_start_pixel (sheet->row_geometry, row);
+    gint y =  psppire_axis_pixel_start (sheet->vaxis, row);
 
     gtk_adjustment_set_value (sheet->vadjustment, y - height * row_align);
   }
@@ -1514,7 +1457,7 @@ gtk_sheet_moveto (GtkSheet *sheet,
 
   if (col >= 0)
   {
-    gint x =  g_sheet_column_start_pixel (sheet->column_geometry, col);
+    gint x =  psppire_axis_pixel_start (sheet->haxis, col);
 
     gtk_adjustment_set_value (sheet->hadjustment, x - width * col_align);
   }
@@ -1547,7 +1490,7 @@ gtk_sheet_select_row (GtkSheet *sheet, gint row)
   g_return_if_fail (sheet != NULL);
   g_return_if_fail (GTK_IS_SHEET (sheet));
 
-  if (row < 0 || row >= g_sheet_row_get_row_count (sheet->row_geometry))
+  if (row < 0 || row >= psppire_axis_unit_count (sheet->vaxis))
     return;
 
   if (sheet->state != GTK_SHEET_NORMAL)
@@ -1557,7 +1500,7 @@ gtk_sheet_select_row (GtkSheet *sheet, gint row)
   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;
 
@@ -1572,7 +1515,7 @@ 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)
@@ -1581,7 +1524,7 @@ gtk_sheet_select_column (GtkSheet *sheet, gint column)
   sheet->state = GTK_SHEET_COLUMN_SELECTED;
   sheet->range.row0 = 0;
   sheet->range.col0 = column;
-  sheet->range.rowi = g_sheet_row_get_row_count (sheet->row_geometry) - 1;
+  sheet->range.rowi = psppire_axis_unit_count (sheet->vaxis) - 1;
   sheet->range.coli = column;
   sheet->active_cell.row = 0;
   sheet->active_cell.col = column;
@@ -1599,16 +1542,16 @@ gtk_sheet_range_isvisible (const GtkSheet *sheet,
 {
   g_return_val_if_fail (sheet != NULL, FALSE);
 
-  if (range.row0 < 0 || range.row0 >= g_sheet_row_get_row_count (sheet->row_geometry))
+  if (range.row0 < 0 || range.row0 >= psppire_axis_unit_count (sheet->vaxis))
     return FALSE;
 
-  if (range.rowi < 0 || range.rowi >= g_sheet_row_get_row_count (sheet->row_geometry))
+  if (range.rowi < 0 || range.rowi >= psppire_axis_unit_count (sheet->vaxis))
     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))
@@ -1712,8 +1655,8 @@ gtk_sheet_dispose  (GObject *object)
   sheet->dispose_has_run = TRUE;
 
   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->vaxis) g_object_unref (sheet->vaxis);
+  if (sheet->haxis) g_object_unref (sheet->haxis);
 
   g_object_unref (sheet->entry_container);
   sheet->entry_container = NULL;
@@ -2083,11 +2026,11 @@ gtk_sheet_cell_draw (GtkSheet *sheet, gint row, gint col)
   if (!GTK_WIDGET_DRAWABLE (sheet)) return;
 
   if (row < 0 ||
-      row >= g_sheet_row_get_row_count (sheet->row_geometry))
+      row >= psppire_axis_unit_count (sheet->vaxis))
     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);
@@ -2183,7 +2126,7 @@ gtk_sheet_range_draw (GtkSheet *sheet, const GtkSheetRange *range)
       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);
+				psppire_axis_unit_count (sheet->vaxis) - 1);
       drawing_range.coli = max_visible_column (sheet);
       gdk_drawable_get_size (sheet->sheet_window, &area.width, &area.height);
       area.x = area.y = 0;
@@ -2287,16 +2230,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);
 }
@@ -2312,8 +2250,8 @@ gtk_sheet_set_cell (GtkSheet *sheet, gint row, gint col,
   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))
+  if (col >= psppire_axis_unit_count (sheet->haxis)
+      || row >= psppire_axis_unit_count (sheet->vaxis))
     return;
 
   if (col < 0 || row < 0) return;
@@ -2322,6 +2260,9 @@ 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))
+    g_sheet_model_set_string (model, text, row, col);
+
   if ( g_sheet_model_free_strings (model))
     g_free (old_text);
 }
@@ -2334,8 +2275,8 @@ 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) ||
-      row >= g_sheet_row_get_row_count (sheet->row_geometry)) return;
+  if (column >= psppire_axis_unit_count (sheet->haxis) ||
+      row >= psppire_axis_unit_count (sheet->vaxis)) return;
 
   if (column < 0 || row < 0) return;
 
@@ -2371,7 +2312,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 >= psppire_axis_unit_count (sheet->vaxis))
     return NULL;
   if (col < 0 || row < 0) return NULL;
 
@@ -2392,7 +2333,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 >= psppire_axis_unit_count (sheet->vaxis)) return 0;
   if (col < 0 || row < 0) return 0;
 
   state = sheet->state;
@@ -2456,8 +2397,8 @@ gtk_sheet_get_pixel_info (GtkSheet *sheet,
     }
   else
     {
-      trow = yyy_row_ypixel_to_row (sheet, y);
-      if (trow > g_sheet_row_get_row_count (sheet->row_geometry))
+      trow = row_from_ypixel (sheet, y);
+      if (trow > psppire_axis_unit_count (sheet->vaxis))
 	return FALSE;
     }
 
@@ -2475,7 +2416,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;
     }
 
@@ -2493,17 +2434,17 @@ 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 >= psppire_axis_unit_count (sheet->vaxis) || column >= psppire_axis_unit_count (sheet->haxis))
     return FALSE;
 
-  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->x = (column == -1) ? 0 : psppire_axis_pixel_start (sheet->haxis, column);
+  area->y = (row == -1)    ? 0 : psppire_axis_pixel_start (sheet->vaxis, 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);
+    : psppire_axis_unit_size (sheet->vaxis, row);
 
   return TRUE;
 }
@@ -2517,9 +2458,9 @@ gtk_sheet_set_active_cell (GtkSheet *sheet, gint row, gint col)
   if (row < -1 || col < -1)
     return;
 
-  if (row >= g_sheet_row_get_row_count (sheet->row_geometry)
+  if (row >= psppire_axis_unit_count (sheet->vaxis)
       ||
-      col >= g_sheet_column_get_column_count (sheet->column_geometry))
+      col >= psppire_axis_unit_count (sheet->haxis))
     return;
 
   sheet->active_cell.row = row;
@@ -2574,6 +2515,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);
@@ -2627,8 +2570,8 @@ change_active_cell (GtkSheet *sheet, gint row, gint col)
   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))
+  if ( row > psppire_axis_unit_count (sheet->vaxis)
+       || col > psppire_axis_unit_count (sheet->haxis))
     return;
 
   if (sheet->state != GTK_SHEET_NORMAL)
@@ -2727,7 +2670,6 @@ gtk_sheet_show_active_cell (GtkSheet *sheet)
   gtk_widget_grab_focus (GTK_WIDGET (sheet_entry));
 
   dispose_string (sheet, text);
-
 }
 
 static void
@@ -2812,11 +2754,11 @@ gtk_sheet_new_selection (GtkSheet *sheet, GtkSheetRange *range)
 
 	      if (mask1 != mask2)
 		{
-		  x = g_sheet_column_start_pixel (sheet->column_geometry, 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);
-		  height = g_sheet_row_start_pixel (sheet->row_geometry, i) - y + g_sheet_row_get_height (sheet->row_geometry, i);
+		  x = psppire_axis_pixel_start (sheet->haxis, j);
+		  y = psppire_axis_pixel_start (sheet->vaxis, i);
+		  width = psppire_axis_pixel_start (sheet->haxis, j)- x+
+		    psppire_axis_unit_size (sheet->haxis, j);
+		  height = psppire_axis_pixel_start (sheet->vaxis, i) - y + psppire_axis_unit_size (sheet->vaxis, i);
 
 		  if (i == sheet->range.row0)
 		    {
@@ -2833,12 +2775,12 @@ 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);
-		      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);
+		      x = psppire_axis_pixel_start (sheet->haxis, j);
+		      y = psppire_axis_pixel_start (sheet->vaxis, i);
+		      width = psppire_axis_pixel_start (sheet->haxis, j)- x+
+			psppire_axis_unit_size (sheet->haxis, j);
 
-		      height = g_sheet_row_start_pixel (sheet->row_geometry, i) - y + g_sheet_row_get_height (sheet->row_geometry, i);
+		      height = psppire_axis_pixel_start (sheet->vaxis, i) - y + psppire_axis_unit_size (sheet->vaxis, i);
 
 		      if (i == new_range.row0)
 			{
@@ -2876,10 +2818,10 @@ gtk_sheet_new_selection (GtkSheet *sheet, GtkSheetRange *range)
 	  if (state == GTK_STATE_SELECTED && !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_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);
+	      x = psppire_axis_pixel_start (sheet->haxis, j);
+	      y = psppire_axis_pixel_start (sheet->vaxis, i);
+	      width = psppire_axis_pixel_start (sheet->haxis, j) - x + psppire_axis_unit_size (sheet->haxis, j);
+	      height = psppire_axis_pixel_start (sheet->vaxis, i) - y + psppire_axis_unit_size (sheet->vaxis, i);
 
 	      if (i == sheet->range.row0)
 		{
@@ -2911,10 +2853,10 @@ 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);
-	      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);
-	      height = g_sheet_row_start_pixel (sheet->row_geometry, i) - y + g_sheet_row_get_height (sheet->row_geometry, i);
+	      x = psppire_axis_pixel_start (sheet->haxis, j);
+	      y = psppire_axis_pixel_start (sheet->vaxis, i);
+	      width = psppire_axis_pixel_start (sheet->haxis, j) - x + psppire_axis_unit_size (sheet->haxis, j);
+	      height = psppire_axis_pixel_start (sheet->vaxis, i) - y + psppire_axis_unit_size (sheet->vaxis, i);
 
 	      if (i == new_range.row0)
 		{
@@ -2957,10 +2899,10 @@ 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);
-	      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);
+	      x = psppire_axis_pixel_start (sheet->haxis, j);
+	      y = psppire_axis_pixel_start (sheet->vaxis, i);
+	      width = psppire_axis_unit_size (sheet->haxis, j);
+	      height = psppire_axis_unit_size (sheet->vaxis, i);
 	      if (mask2 & 1)
 		gdk_draw_rectangle (sheet->sheet_window,
 				    sheet->xor_gc,
@@ -3161,12 +3103,12 @@ gtk_sheet_expose (GtkWidget *widget,
 
 
   range.row0 =
-    yyy_row_ypixel_to_row (sheet,
+    row_from_ypixel (sheet,
 			   event->area.y + sheet->vadjustment->value);
   range.row0--;
 
   range.rowi =
-    yyy_row_ypixel_to_row (sheet,
+    row_from_ypixel (sheet,
 			   event->area.y +
 			   event->area.height + sheet->vadjustment->value);
   range.rowi++;
@@ -3249,7 +3191,7 @@ gtk_sheet_button_press (GtkWidget *widget,
 		     sheet_signals[BUTTON_EVENT_COLUMN], 0,
 		     column, event);
 
-      if (g_sheet_column_get_sensitivity (sheet->column_geometry, column))
+      if (g_sheet_model_get_column_sensitivity (sheet->model, column))
 	{
 	  if ( event->type == GDK_2BUTTON_PRESS && event->button == 1)
 	    g_signal_emit (sheet,
@@ -3262,8 +3204,7 @@ gtk_sheet_button_press (GtkWidget *widget,
 		     sheet_signals[BUTTON_EVENT_ROW], 0,
 		     row, event);
 
-
-      if (g_sheet_row_get_sensitivity (sheet->row_geometry, row))
+      if (g_sheet_model_get_row_sensitivity (sheet->model, row))
 	{
 	  if ( event->type == GDK_2BUTTON_PRESS && event->button == 1)
 	    g_signal_emit (sheet,
@@ -3308,6 +3249,7 @@ gtk_sheet_button_press (GtkWidget *widget,
     {
       gtk_widget_get_pointer (widget, NULL, &sheet->y_drag);
 
+#if AXIS_TRANSITION
       if (POSSIBLE_YDRAG (sheet, sheet->y_drag, &sheet->drag_cell.row))
 	{
 	  guint req;
@@ -3322,6 +3264,7 @@ gtk_sheet_button_press (GtkWidget *widget,
 	  draw_xor_hline (sheet);
 	  return TRUE;
 	}
+#endif
     }
 
   /* the sheet itself does not handle other than single click events */
@@ -3416,7 +3359,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));
@@ -3433,8 +3376,8 @@ gtk_sheet_button_press (GtkWidget *widget,
 
       y += sheet->vadjustment->value;
 
-      row = yyy_row_ypixel_to_row (sheet, y);
-      if (g_sheet_row_get_sensitivity (sheet->row_geometry, row))
+      row = row_from_ypixel (sheet, y);
+      if (g_sheet_model_get_row_sensitivity (sheet->model, row))
 	{
 	  veto = gtk_sheet_click_cell (sheet, row, -1);
 	  gtk_grab_add (GTK_WIDGET (sheet));
@@ -3455,8 +3398,8 @@ gtk_sheet_click_cell (GtkSheet *sheet, gint row, gint column)
   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))
+  if (row >= psppire_axis_unit_count (sheet->vaxis)
+      || column >= psppire_axis_unit_count (sheet->haxis))
     {
       return FALSE;
     }
@@ -3494,9 +3437,9 @@ gtk_sheet_click_cell (GtkSheet *sheet, gint row, gint column)
     {
       sheet->range.row0 = 0;
       sheet->range.col0 = 0;
-      sheet->range.rowi = g_sheet_row_get_row_count (sheet->row_geometry) - 1;
+      sheet->range.rowi = psppire_axis_unit_count (sheet->vaxis) - 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);
@@ -3766,10 +3709,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_model_get_row_subtitle (sheet->model, row);
 
 	  show_subtitle (sheet, row, -1, text);
 	  g_free (text);
@@ -3777,10 +3717,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);
 
@@ -3868,6 +3806,7 @@ gtk_sheet_motion (GtkWidget *widget,  GdkEventMotion *event)
   if (event->window == sheet->row_title_window &&
       gtk_sheet_rows_resizable (sheet))
     {
+#if AXIS_TRANSITION
       if (!GTK_SHEET_IN_SELECTION (sheet) && POSSIBLE_YDRAG (sheet, y, &column))
 	{
 	  new_cursor = GDK_SB_V_DOUBLE_ARROW;
@@ -3879,6 +3818,7 @@ gtk_sheet_motion (GtkWidget *widget,  GdkEventMotion *event)
 	    }
 	}
       else
+#endif
 	{
 	  new_cursor = GDK_TOP_LEFT_ARROW;
 	  if (!GTK_SHEET_IN_YDRAG (sheet) &&
@@ -3971,14 +3911,14 @@ gtk_sheet_motion (GtkWidget *widget,  GdkEventMotion *event)
     {
       GtkSheetRange aux;
       column = column_from_xpixel (sheet, x)- sheet->drag_cell.col;
-      row = yyy_row_ypixel_to_row (sheet, y) - sheet->drag_cell.row;
+      row = row_from_ypixel (sheet, y) - sheet->drag_cell.row;
       if (sheet->state == GTK_SHEET_COLUMN_SELECTED) row = 0;
       if (sheet->state == GTK_SHEET_ROW_SELECTED) column = 0;
       sheet->x_drag = x;
       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))
+      if (aux.row0 + row >= 0 && aux.rowi + row < psppire_axis_unit_count (sheet->vaxis) &&
+	  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;
@@ -4000,18 +3940,18 @@ 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)) >
-	  abs (y - g_sheet_row_start_pixel (sheet->row_geometry, sheet->drag_cell.row))) v_h = 2;
+      if (abs (x - psppire_axis_pixel_start (sheet->haxis, sheet->drag_cell.col)) >
+	  abs (y - psppire_axis_pixel_start (sheet->vaxis, sheet->drag_cell.row))) v_h = 2;
 
       current_col = column_from_xpixel (sheet, x);
-      current_row = yyy_row_ypixel_to_row (sheet, y);
+      current_row = row_from_ypixel (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 = 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)
@@ -4022,8 +3962,8 @@ gtk_sheet_motion (GtkWidget *widget,  GdkEventMotion *event)
 	  if (x > col_threshold)
 	    column +=1;
 	}
-      row_threshold = g_sheet_row_start_pixel (sheet->row_geometry, current_row) +
-	g_sheet_row_get_height (sheet->row_geometry, current_row)/2;
+      row_threshold = psppire_axis_pixel_start (sheet->vaxis, current_row) +
+	psppire_axis_unit_size (sheet->vaxis, current_row)/2;
       if (row > 0)
 	{
 	  if (y < row_threshold)
@@ -4046,8 +3986,8 @@ gtk_sheet_motion (GtkWidget *widget,  GdkEventMotion *event)
       else
 	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))
+      if (aux.row0 + row >= 0 && aux.rowi + row < psppire_axis_unit_count (sheet->vaxis) &&
+	  aux.col0 + column >= 0 && aux.coli + column < psppire_axis_unit_count (sheet->haxis))
 	{
 	  aux = sheet->drag_range;
 	  sheet->drag_range = sheet->range;
@@ -4115,10 +4055,10 @@ 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;
+      row = psppire_axis_unit_count (sheet->vaxis) - 1;
       break;
     case GTK_SHEET_NORMAL:
       sheet->state = GTK_SHEET_RANGE_SELECTED;
@@ -4166,11 +4106,11 @@ static void
 page_vertical (GtkSheet *sheet, GtkScrollType dir)
 {
   gint old_row = sheet->active_cell.row ;
-  glong vpixel = g_sheet_row_start_pixel (sheet->row_geometry, old_row);
+  glong vpixel = psppire_axis_pixel_start (sheet->vaxis, old_row);
 
   gint new_row;
 
-  vpixel -= g_sheet_row_start_pixel (sheet->row_geometry,
+  vpixel -= psppire_axis_pixel_start (sheet->vaxis,
 				     min_visible_row (sheet));
 
   switch ( dir)
@@ -4192,10 +4132,10 @@ page_vertical (GtkSheet *sheet, GtkScrollType dir)
     }
 
 
-  vpixel += g_sheet_row_start_pixel (sheet->row_geometry,
+  vpixel += psppire_axis_pixel_start (sheet->vaxis,
 				     min_visible_row (sheet));
 
-  new_row =  yyy_row_ypixel_to_row (sheet, vpixel);
+  new_row =  row_from_ypixel (sheet, vpixel);
 
   change_active_cell (sheet, new_row,
 			   sheet->active_cell.col);
@@ -4237,10 +4177,10 @@ step_sheet (GtkSheet *sheet, GtkScrollType dir)
   maximize_int (&new_cell.col, 0);
 
   minimize_int (&new_cell.row,
-		g_sheet_row_get_row_count (sheet->row_geometry) - 1);
+		psppire_axis_unit_count (sheet->vaxis) - 1);
 
   minimize_int (&new_cell.col,
-		g_sheet_column_get_column_count (sheet->column_geometry) - 1);
+		psppire_axis_unit_count (sheet->haxis) - 1);
 
   g_signal_emit (sheet, sheet_signals[TRAVERSE], 0,
 		 &sheet->active_cell,
@@ -4255,7 +4195,7 @@ step_sheet (GtkSheet *sheet, GtkScrollType dir)
   if ( new_cell.col > max_fully_visible_column (sheet))
     {
       glong hpos  =
-	g_sheet_column_start_pixel (sheet->column_geometry,
+	psppire_axis_pixel_start (sheet->haxis,
 				    new_cell.col + 1);
       hpos -= sheet->hadjustment->page_size;
 
@@ -4265,7 +4205,7 @@ step_sheet (GtkSheet *sheet, GtkScrollType dir)
   else if ( new_cell.col < min_fully_visible_column (sheet))
     {
       glong hpos  =
-	g_sheet_column_start_pixel (sheet->column_geometry,
+	psppire_axis_pixel_start (sheet->haxis,
 				    new_cell.col);
 
       gtk_adjustment_set_value (sheet->hadjustment,
@@ -4276,7 +4216,7 @@ step_sheet (GtkSheet *sheet, GtkScrollType dir)
   if ( new_cell.row > max_fully_visible_row (sheet))
     {
       glong vpos  =
-	g_sheet_row_start_pixel (sheet->row_geometry,
+	psppire_axis_pixel_start (sheet->vaxis,
 				    new_cell.row + 1);
       vpos -= sheet->vadjustment->page_size;
 
@@ -4286,7 +4226,7 @@ step_sheet (GtkSheet *sheet, GtkScrollType dir)
   else if ( new_cell.row < min_fully_visible_row (sheet))
     {
       glong vpos  =
-	g_sheet_row_start_pixel (sheet->row_geometry,
+	psppire_axis_pixel_start (sheet->vaxis,
 				    new_cell.row);
 
       gtk_adjustment_set_value (sheet->vadjustment,
@@ -4345,7 +4285,7 @@ gtk_sheet_key_press (GtkWidget *widget,
 
       /*
 	change_active_cellx (sheet,
-	g_sheet_row_get_row_count (sheet->row_geometry) - 1,
+	psppire_axis_unit_count (sheet->vaxis) - 1,
 	sheet->active_cell.col);
       */
       break;
@@ -4431,13 +4371,19 @@ gtk_sheet_size_allocate (GtkWidget *widget,
   /* position the window which holds the column title buttons */
   sheet->column_title_area.x = 0;
   sheet->column_title_area.y = 0;
+  sheet->column_title_area.width = sheet_allocation.width ;
+
+
+  /* position the window which holds the row title buttons */
+  sheet->row_title_area.x = 0;
+  sheet->row_title_area.y = 0;
+  sheet->row_title_area.height = sheet_allocation.height;
 
   if (sheet->row_titles_visible)
-    {
-      sheet->column_title_area.x = sheet->row_title_area.width;
-    }
+    sheet->column_title_area.x += sheet->row_title_area.width;
 
-  sheet->column_title_area.width = sheet_allocation.width ;
+  if (sheet->column_titles_visible)
+    sheet->row_title_area.y += sheet->column_title_area.height;
 
 
   if (GTK_WIDGET_REALIZED (widget) && sheet->column_titles_visible)
@@ -4448,20 +4394,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;
-  if (sheet->column_titles_visible)
-    {
-      sheet->row_title_area.y = sheet->column_title_area.height;
-    }
-
-  sheet->row_title_area.height = sheet_allocation.height -
-    sheet->row_title_area.y;
-
   if (GTK_WIDGET_REALIZED (widget) && sheet->row_titles_visible)
     gdk_window_move_resize (sheet->row_title_window,
 			    sheet->row_title_area.x,
@@ -4469,10 +4401,31 @@ gtk_sheet_size_allocate (GtkWidget *widget,
 			    sheet->row_title_area.width,
 			    sheet->row_title_area.height);
 
+  if (sheet->haxis)
+    {
+      gint width = sheet->column_title_area.width;
+
+      if ( sheet->row_titles_visible)
+	width -= sheet->row_title_area.width;
+
+      g_object_set (sheet->haxis,
+		    "minimum-extent", width,
+		    NULL);
+    }
+
+
+  if (sheet->vaxis)
+    {
+      gint height = sheet->row_title_area.height;
+
+      if ( sheet->column_titles_visible)
+	height -= sheet->column_title_area.height;
+
+      g_object_set (sheet->vaxis,
+		    "minimum-extent", height,
+		    NULL);
+    }
 
-  /* row button allocation */
-  draw_row_title_buttons (sheet);
-  draw_column_title_buttons (sheet);
 
   /* set the scrollbars adjustments */
   adjust_scrollbars (sheet);
@@ -4507,7 +4460,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,
@@ -4549,7 +4502,7 @@ draw_row_title_buttons (GtkSheet *sheet)
 			      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) == psppire_axis_unit_count (sheet->vaxis) - 1)
     gdk_window_clear_area (sheet->row_title_window,
 			   0, 0,
 			   sheet->row_title_area.width,
@@ -4776,15 +4729,17 @@ draw_button (GtkSheet *sheet, GdkWindow *window,
 
       if (button->label && strlen (button->label)>0)
 	{
+	  PangoRectangle rect;
 	  gchar *line = button->label;
 
 	  PangoLayout *layout = NULL;
-	  gint real_x = allocation.x, real_y = allocation.y;
-
-
-	  text_width = STRING_WIDTH (GTK_WIDGET (sheet), GTK_WIDGET (sheet)->style->font_desc, line);
+	  gint real_x = allocation.x;
+	  gint real_y = allocation.y;
 
 	  layout = gtk_widget_create_pango_layout (GTK_WIDGET (sheet), line);
+	  pango_layout_get_extents (layout, NULL, &rect);
+
+	  text_width = PANGO_PIXELS (rect.width);
 	  switch (button->justification)
 	    {
 	    case GTK_JUSTIFY_LEFT:
@@ -4812,8 +4767,6 @@ draw_button (GtkSheet *sheet, GdkWindow *window,
 			    real_x, real_y,
 			    layout);
 	  g_object_unref (layout);
-
-	  real_y += text_height + 2;
 	}
 
       gdk_gc_set_clip_rectangle (GTK_WIDGET (sheet)->style->fg_gc[button->state],
@@ -4850,18 +4803,15 @@ draw_column_title_buttons_range (GtkSheet *sheet, gint first, gint last)
       gboolean is_sensitive = FALSE;
 
       GtkSheetButton *
-	button = g_sheet_column_get_button (sheet->column_geometry, col);
+	button = g_sheet_model_get_column_button (sheet->model, col);
       allocation.y = 0;
-      allocation.x =
-	g_sheet_column_start_pixel (sheet->column_geometry, col)
+      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 =
-	g_sheet_column_get_width (sheet->column_geometry, col);
-      is_sensitive =
-	g_sheet_column_get_sensitivity (sheet->column_geometry, col);
+      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);
@@ -4897,15 +4847,15 @@ draw_row_title_buttons_range (GtkSheet *sheet, gint first, gint last)
       gboolean is_sensitive = FALSE;
 
       GtkSheetButton *button =
-	g_sheet_row_get_button (sheet->row_geometry, row);
+	g_sheet_model_get_row_button (sheet->model, row);
       allocation.x = 0;
-      allocation.y = g_sheet_row_start_pixel (sheet->row_geometry, row)
+      allocation.y = psppire_axis_pixel_start (sheet->vaxis, 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);
+      allocation.height = psppire_axis_unit_size (sheet->vaxis, row);
+      is_sensitive = g_sheet_model_get_row_sensitivity (sheet->model, row);
 
       draw_button (sheet, sheet->row_title_window,
 		   button, is_sensitive, allocation);
@@ -4939,23 +4889,23 @@ adjust_scrollbars (GtkSheet *sheet)
 
   if (sheet->vadjustment)
     {
-      glong last_row = g_sheet_row_get_row_count (sheet->row_geometry) - 1;
+      glong last_row = psppire_axis_unit_count (sheet->vaxis) - 1;
 
       sheet->vadjustment->step_increment =
 	ROWS_PER_STEP *
-	g_sheet_row_get_height (sheet->row_geometry, last_row);
+	psppire_axis_unit_size (sheet->vaxis, last_row);
 
       sheet->vadjustment->page_increment =
 	height -
 	sheet->column_title_area.height -
-	g_sheet_row_get_height (sheet->row_geometry, last_row);
+	psppire_axis_unit_size (sheet->vaxis, last_row);
 
 
 
       sheet->vadjustment->upper =
-	g_sheet_row_start_pixel (sheet->row_geometry, last_row)
+	psppire_axis_pixel_start (sheet->vaxis, last_row)
 	+
-	g_sheet_row_get_height (sheet->row_geometry, last_row)
+	psppire_axis_unit_size (sheet->vaxis, last_row)
 	;
 
       sheet->vadjustment->lower = 0;
@@ -4971,12 +4921,12 @@ 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)
 	;
 
       sheet->hadjustment->lower = 0;
@@ -5091,12 +5041,12 @@ 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.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.height = g_sheet_row_start_pixel (sheet->row_geometry, range.rowi)- area.y +
-    g_sheet_row_get_height (sheet->row_geometry, range.rowi);
+  area.x = psppire_axis_pixel_start (sheet->haxis, range.col0);
+  area.y = psppire_axis_pixel_start (sheet->vaxis, range.row0);
+  area.width = psppire_axis_pixel_start (sheet->haxis, range.coli)- area.x+
+    psppire_axis_unit_size (sheet->haxis, range.coli);
+  area.height = psppire_axis_pixel_start (sheet->vaxis, range.rowi)- area.y +
+    psppire_axis_unit_size (sheet->vaxis, range.rowi);
 
   clip_area.x = sheet->row_title_area.width;
   clip_area.y = sheet->column_title_area.height;
@@ -5149,7 +5099,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;
@@ -5160,7 +5110,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);
 
@@ -5180,19 +5132,21 @@ new_row_height (GtkSheet *sheet, gint row, gint *y)
   min_height = sheet->row_requisition;
 
   /* you can't shrink a row to less than its minimum height */
-  if (cy < g_sheet_row_start_pixel (sheet->row_geometry, row) + min_height)
+  if (cy < psppire_axis_pixel_start (sheet->vaxis, row) + min_height)
 
     {
-      *y = cy = g_sheet_row_start_pixel (sheet->row_geometry, row) + min_height;
+      *y = cy = psppire_axis_pixel_start (sheet->vaxis, row) + min_height;
     }
 
   /* calculate new row height making sure it doesn't end up
    * less than the minimum height */
-  height = (cy - g_sheet_row_start_pixel (sheet->row_geometry, row));
+  height = (cy - psppire_axis_pixel_start (sheet->vaxis, row));
   if (height < min_height)
     height = min_height;
 
+#if AXIS_TRANSITION
   g_sheet_row_set_height (sheet->row_geometry, row, height);
+#endif
   draw_row_title_buttons (sheet);
 
   return height;
@@ -5208,13 +5162,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)))
     {
@@ -5237,13 +5193,15 @@ gtk_sheet_set_row_height (GtkSheet *sheet,
   g_return_if_fail (sheet != NULL);
   g_return_if_fail (GTK_IS_SHEET (sheet));
 
-  if (row < 0 || row >= g_sheet_row_get_row_count (sheet->row_geometry))
+  if (row < 0 || row >= psppire_axis_unit_count (sheet->vaxis))
     return;
 
   gtk_sheet_row_size_request (sheet, row, &min_height);
   if (height < min_height) return;
 
+#if AXIS_TRANSITION
   g_sheet_row_set_height (sheet->row_geometry, row, height);
+#endif
 
   if (GTK_WIDGET_REALIZED (GTK_WIDGET (sheet)) )
     {
@@ -5301,7 +5259,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)
@@ -5346,7 +5304,7 @@ gtk_sheet_row_size_request (GtkSheet *sheet,
   GtkRequisition button_requisition;
 
   gtk_sheet_button_size_request (sheet,
-				 g_sheet_row_get_button (sheet->row_geometry, row),
+				 g_sheet_model_get_row_button (sheet->model, row),
 				 &button_requisition);
 
   *requisition = button_requisition.height;
@@ -5361,7 +5319,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,
@@ -5425,7 +5383,6 @@ gtk_sheet_button_free (GtkSheetButton *button)
   g_free (button);
 }
 
-
 static void
 append_cell_text (GString *string, const GtkSheet *sheet, gint r, gint c)
 {