X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=lib%2Fgtksheet%2Fgtksheet.c;h=fd60dbd186f2f1fdfff4298cb504c0fbb94e7dfc;hb=c29e05c50e21d5be8365ffdd990d558b95725d71;hp=e38b389553d33d694189cb7cd4af56d7dd44157e;hpb=bfa3bb62acfb1496a028c4baa800b2d2c5b543f5;p=pspp diff --git a/lib/gtksheet/gtksheet.c b/lib/gtksheet/gtksheet.c index e38b389553..fd60dbd186 100644 --- a/lib/gtksheet/gtksheet.c +++ b/lib/gtksheet/gtksheet.c @@ -53,7 +53,7 @@ #include #include #include "gtksheet.h" -#include "gtkextra-marshal.h" +#include #include "gsheetmodel.h" #include #include @@ -86,14 +86,16 @@ enum #define DEFAULT_COLUMN_WIDTH 80 #define DEFAULT_ROW_HEIGHT 25 +static void set_entry_widget_font (GtkSheet *sheet); + static void gtk_sheet_update_primary_selection (GtkSheet *sheet); static void draw_column_title_buttons_range (GtkSheet *sheet, gint first, gint n); static void draw_row_title_buttons_range (GtkSheet *sheet, gint first, gint n); -static void gtk_sheet_set_row_height (GtkSheet *sheet, - gint row, - guint height); +static void set_row_height (GtkSheet *sheet, + gint row, + gint height); static void destroy_hover_window (GtkSheetHoverTitle *); static GtkSheetHoverTitle *create_hover_window (void); @@ -113,44 +115,46 @@ dispose_string (const GtkSheet *sheet, gchar *text) g_free (text); } -/* Return the row containing pixel Y */ -static gint -yyy_row_ypixel_to_row (const GtkSheet *sheet, gint y) -{ - GSheetRow *geo = sheet->row_geometry; - g_return_val_if_fail (y >= 0, -1); +/* FIXME: Why bother with these two ? */ - return g_sheet_row_pixel_to_row (geo, y); +/* returns the column index from a pixel location */ +static inline gint +column_from_xpixel (const GtkSheet *sheet, gint pixel) +{ + return psppire_axis_unit_at_pixel (sheet->haxis, pixel); } +static inline gint +row_from_ypixel (const GtkSheet *sheet, gint pixel) +{ + return psppire_axis_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_start_pixel (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); } @@ -159,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_start_pixel (sheet->vaxis, row) + + + psppire_axis_unit_size (sheet->vaxis, row) > sheet->vadjustment->value) row--; @@ -169,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 @@ -205,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_start_pixel (sheet->haxis, col) < sheet->hadjustment->value) col++; return col; @@ -217,9 +198,7 @@ min_fully_visible_column (const GtkSheet *sheet) static inline glong max_visible_column (const GtkSheet *sheet) { - return column_from_xpixel (sheet, - sheet->hadjustment->value + - sheet->hadjustment->page_size); + return column_from_xpixel (sheet, sheet->hadjustment->value + sheet->hadjustment->page_size); } static inline glong @@ -227,9 +206,9 @@ max_fully_visible_column (const GtkSheet *sheet) { glong col = max_visible_column (sheet); - if ( g_sheet_column_start_pixel (sheet->column_geometry, col) - + - g_sheet_column_get_width (sheet->column_geometry, col) + if ( psppire_axis_start_pixel (sheet->haxis, col) + + + psppire_axis_unit_size (sheet->haxis, col) > sheet->hadjustment->value) col--; @@ -266,30 +245,31 @@ 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) +static gboolean +on_row_boundary (const GtkSheet *sheet, gint y, gint *row) { - gint row, ydrag; + gint r; 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) + r = row_from_ypixel (sheet, y); + + if ( row_from_ypixel (sheet, y - DRAG_WIDTH / 2) < r ) { - *drag_row = row - 1; - return g_sheet_row_get_sensitivity (sheet->row_geometry, row - 1); + *row = r - 1; + return TRUE; } - 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); + if ( row_from_ypixel (sheet, y + DRAG_WIDTH / 2) > r ) + { + *row = r; + return TRUE; + } return FALSE; } + static inline gboolean POSSIBLE_DRAG (const GtkSheet *sheet, gint x, gint y, gint *drag_row, gint *drag_column) @@ -302,20 +282,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_start_pixel (sheet->haxis, sheet->range.col0) - DRAG_WIDTH / 2 && + x <= psppire_axis_start_pixel (sheet->haxis, sheet->range.coli) + + psppire_axis_unit_size (sheet->haxis, sheet->range.coli) + DRAG_WIDTH / 2) { - ydrag = g_sheet_row_start_pixel (sheet->row_geometry, sheet->range.row0); + ydrag = psppire_axis_start_pixel (sheet->vaxis, sheet->range.row0); if (y >= ydrag - DRAG_WIDTH / 2 && y <= ydrag + DRAG_WIDTH / 2) { *drag_row = sheet->range.row0; return TRUE; } - ydrag = 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_start_pixel (sheet->vaxis, sheet->range.rowi) + + psppire_axis_unit_size (sheet->vaxis, sheet->range.rowi); if (y >= ydrag - DRAG_WIDTH / 2 && y <= ydrag + DRAG_WIDTH / 2) { *drag_row = sheet->range.rowi; @@ -323,18 +303,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_start_pixel (sheet->vaxis, sheet->range.row0) - DRAG_WIDTH / 2 && + y <= psppire_axis_start_pixel (sheet->vaxis, sheet->range.rowi) + + psppire_axis_unit_size (sheet->vaxis, sheet->range.rowi) + DRAG_WIDTH / 2) { - xdrag = g_sheet_column_start_pixel (sheet->column_geometry, sheet->range.col0); + xdrag = psppire_axis_start_pixel (sheet->haxis, sheet->range.col0); if (x >= xdrag - DRAG_WIDTH / 2 && x <= xdrag + DRAG_WIDTH / 2) { *drag_column = sheet->range.col0; return TRUE; } - xdrag = 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_start_pixel (sheet->haxis, sheet->range.coli) + + psppire_axis_unit_size (sheet->haxis, sheet->range.coli); if (x >= xdrag - DRAG_WIDTH / 2 && x <= xdrag + DRAG_WIDTH / 2) { *drag_column = sheet->range.coli; @@ -356,20 +336,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_start_pixel (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_start_pixel (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_start_pixel (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_start_pixel (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; @@ -384,26 +364,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_start_pixel (sheet->haxis, range->col0); r->x -= round (sheet->hadjustment->value); if ( sheet->row_titles_visible) r->x += sheet->row_title_area.width; - r->y = g_sheet_row_start_pixel (sheet->row_geometry, range->row0); + r->y = psppire_axis_start_pixel (sheet->vaxis, range->row0); r->y -= round (sheet->vadjustment->value); if ( sheet->column_titles_visible) r->y += sheet->column_title_area.height; - r->width = 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_start_pixel (sheet->haxis, range->coli) - + psppire_axis_start_pixel (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_start_pixel (sheet->vaxis, range->rowi) - + psppire_axis_start_pixel (sheet->vaxis, range->row0) + + psppire_axis_unit_size (sheet->vaxis, range->rowi); return TRUE; } @@ -435,6 +415,7 @@ static void gtk_sheet_map (GtkWidget *widget); static void gtk_sheet_unmap (GtkWidget *widget); static gint gtk_sheet_expose (GtkWidget *widget, GdkEventExpose *event); + static void gtk_sheet_forall (GtkContainer *container, gboolean include_internals, GtkCallback callback, @@ -464,7 +445,7 @@ static void gtk_sheet_size_allocate (GtkWidget *widget, /* Sheet queries */ static gboolean gtk_sheet_range_isvisible (const GtkSheet *sheet, - GtkSheetRange range); + const GtkSheetRange *range); static gboolean gtk_sheet_cell_isvisible (GtkSheet *sheet, gint row, gint column); /* Drawing Routines */ @@ -473,9 +454,9 @@ static gboolean gtk_sheet_cell_isvisible (GtkSheet *sheet, static void gtk_sheet_cell_draw (GtkSheet *sheet, gint row, gint column); -/* draw visible part of range. If range == NULL then draw the whole screen */ -static void gtk_sheet_range_draw (GtkSheet *sheet, - const GtkSheetRange *range); +/* draw visible part of range. */ +static void draw_sheet_region (GtkSheet *sheet, GdkRegion *region); + /* highlight the visible part of the selected range */ static void gtk_sheet_range_draw_selection (GtkSheet *sheet, @@ -498,11 +479,11 @@ static void gtk_sheet_draw_border (GtkSheet *sheet, static void gtk_sheet_entry_changed (GtkWidget *widget, gpointer data); -static void gtk_sheet_hide_active_cell (GtkSheet *sheet); +static void gtk_sheet_hide_entry_widget (GtkSheet *sheet); static void change_active_cell (GtkSheet *sheet, gint row, gint col); -static void gtk_sheet_draw_active_cell (GtkSheet *sheet); -static void gtk_sheet_show_active_cell (GtkSheet *sheet); +static gboolean gtk_sheet_draw_active_cell (GtkSheet *sheet); +static void gtk_sheet_show_entry_widget (GtkSheet *sheet); static gboolean gtk_sheet_click_cell (GtkSheet *sheet, gint row, gint column); @@ -522,12 +503,6 @@ static void draw_xor_hline (GtkSheet *sheet); static void draw_xor_rectangle (GtkSheet *sheet, GtkSheetRange range); -static guint new_column_width (GtkSheet *sheet, - gint column, - gint *x); -static guint new_row_height (GtkSheet *sheet, - gint row, - gint *y); /* Sheet Button */ static void create_global_button (GtkSheet *sheet); @@ -554,9 +529,6 @@ static void gtk_sheet_real_cell_clear (GtkSheet *sheet, gint column); -static void gtk_sheet_column_size_request (GtkSheet *sheet, - gint col, - guint *requisition); static void gtk_sheet_row_size_request (GtkSheet *sheet, gint row, guint *requisition); @@ -694,29 +666,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); } @@ -731,11 +707,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)); @@ -756,11 +732,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); @@ -777,8 +753,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); @@ -875,7 +851,7 @@ gtk_sheet_class_init (GtkSheetClass *klass) G_SIGNAL_RUN_LAST, 0, NULL, NULL, - gtkextra_VOID__INT_POINTER, + psppire_marshal_VOID__INT_POINTER, G_TYPE_NONE, 2, G_TYPE_INT, @@ -896,7 +872,7 @@ gtk_sheet_class_init (GtkSheetClass *klass) G_SIGNAL_RUN_LAST, 0, NULL, NULL, - gtkextra_VOID__INT_POINTER, + psppire_marshal_VOID__INT_POINTER, G_TYPE_NONE, 2, G_TYPE_INT, @@ -922,7 +898,7 @@ gtk_sheet_class_init (GtkSheetClass *klass) G_SIGNAL_RUN_LAST, offsetof (GtkSheetClass, resize_range), NULL, NULL, - gtkextra_VOID__BOXED_BOXED, + psppire_marshal_VOID__BOXED_BOXED, G_TYPE_NONE, 2, GTK_TYPE_SHEET_RANGE, GTK_TYPE_SHEET_RANGE @@ -934,7 +910,7 @@ gtk_sheet_class_init (GtkSheetClass *klass) G_SIGNAL_RUN_LAST, offsetof (GtkSheetClass, move_range), NULL, NULL, - gtkextra_VOID__BOXED_BOXED, + psppire_marshal_VOID__BOXED_BOXED, G_TYPE_NONE, 2, GTK_TYPE_SHEET_RANGE, GTK_TYPE_SHEET_RANGE @@ -946,7 +922,7 @@ gtk_sheet_class_init (GtkSheetClass *klass) G_SIGNAL_RUN_LAST, offsetof (GtkSheetClass, traverse), NULL, NULL, - gtkextra_BOOLEAN__BOXED_POINTER, + psppire_marshal_BOOLEAN__BOXED_POINTER, G_TYPE_BOOLEAN, 2, GTK_TYPE_SHEET_CELL, G_TYPE_POINTER); @@ -958,7 +934,7 @@ gtk_sheet_class_init (GtkSheetClass *klass) G_SIGNAL_RUN_LAST, offsetof (GtkSheetClass, activate), NULL, NULL, - gtkextra_VOID__INT_INT_INT_INT, + psppire_marshal_VOID__INT_INT_INT_INT, G_TYPE_NONE, 4, G_TYPE_INT, G_TYPE_INT, G_TYPE_INT, G_TYPE_INT); @@ -969,7 +945,7 @@ gtk_sheet_class_init (GtkSheetClass *klass) G_SIGNAL_RUN_LAST, offsetof (GtkSheetClass, set_scroll_adjustments), NULL, NULL, - gtkextra_VOID__OBJECT_OBJECT, + psppire_marshal_VOID__OBJECT_OBJECT, G_TYPE_NONE, 2, GTK_TYPE_ADJUSTMENT, GTK_TYPE_ADJUSTMENT); @@ -981,16 +957,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 = @@ -1004,12 +980,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, @@ -1048,8 +1024,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; @@ -1085,8 +1061,6 @@ gtk_sheet_init (GtkSheet *sheet) sheet->sheet_window = NULL; sheet->entry_widget = NULL; - sheet->entry_container = NULL; - sheet->entry_handler_id = 0; sheet->button = NULL; sheet->hadjustment = NULL; @@ -1103,9 +1077,6 @@ gtk_sheet_init (GtkSheet *sheet) sheet->motion_timer = 0; - sheet->columns_resizable = TRUE; - sheet->rows_resizable = TRUE; - sheet->row_titles_visible = TRUE; sheet->row_title_area.width = DEFAULT_COLUMN_WIDTH; @@ -1113,7 +1084,7 @@ gtk_sheet_init (GtkSheet *sheet) /* create sheet entry */ - sheet->entry_type = 0; + sheet->entry_type = GTK_TYPE_ENTRY; create_sheet_entry (sheet); /* create global selection button */ @@ -1121,6 +1092,29 @@ gtk_sheet_init (GtkSheet *sheet) } +/* Cause RANGE to be redrawn. If RANGE is null, then the + entire visible range will be redrawn. + */ +static void +redraw_range (GtkSheet *sheet, GtkSheetRange *range) +{ + GdkRectangle rect; + + if ( ! GTK_WIDGET_REALIZED (sheet)) + return; + + if ( NULL != range ) + rectangle_from_range (sheet, range, &rect); + else + { + GdkRegion *r = gdk_drawable_get_visible_region (sheet->sheet_window); + gdk_region_get_clipbox (r, &rect); + } + + gdk_window_invalidate_rect (sheet->sheet_window, &rect, FALSE); +} + + /* Callback which occurs whenever columns are inserted / deleted in the model */ static void columns_inserted_deleted_callback (GSheetModel *model, gint first_column, @@ -1138,8 +1132,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); @@ -1149,10 +1143,13 @@ columns_inserted_deleted_callback (GSheetModel *model, gint first_column, draw_column_title_buttons_range (sheet, first_column, max_visible_column (sheet)); - gtk_sheet_range_draw (sheet, &range); + + redraw_range (sheet, &range); } + + /* Callback which occurs whenever rows are inserted / deleted in the model */ static void rows_inserted_deleted_callback (GSheetModel *model, gint first_row, @@ -1169,8 +1166,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); @@ -1179,7 +1176,7 @@ rows_inserted_deleted_callback (GSheetModel *model, gint first_row, draw_row_title_buttons_range (sheet, first_row, max_visible_row (sheet)); - gtk_sheet_range_draw (sheet, &range); + redraw_range (sheet, &range); } /* @@ -1202,16 +1199,9 @@ range_update_callback (GSheetModel *m, gint row0, gint col0, if ( !GTK_WIDGET_REALIZED (GTK_WIDGET (sheet))) return; - if ( max_visible_row (sheet) > g_sheet_model_get_row_count (sheet->model) - || - max_visible_column (sheet) > g_sheet_model_get_column_count (sheet->model)) - { - gtk_sheet_moveto (sheet, 0, 0, 0, 0); - } - if ( ( row0 < 0 && col0 < 0 ) || ( rowi < 0 && coli < 0 ) ) { - gtk_sheet_range_draw (sheet, NULL); + redraw_range (sheet, NULL); adjust_scrollbars (sheet); draw_row_title_buttons_range (sheet, min_visible_row (sheet), @@ -1233,7 +1223,7 @@ range_update_callback (GSheetModel *m, gint row0, gint col0, range.coli = max_visible_column (sheet); } - gtk_sheet_range_draw (sheet, &range); + redraw_range (sheet, &range); } @@ -1249,11 +1239,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 (GSheetModel *model) { GtkWidget *widget = g_object_new (GTK_TYPE_SHEET, - "row-geometry", vgeo, - "column-geometry", hgeo, "model", model, NULL); return widget; @@ -1310,7 +1298,7 @@ gtk_sheet_change_entry (GtkSheet *sheet, GtkType entry_type) state = sheet->state; if (sheet->state == GTK_SHEET_NORMAL) - gtk_sheet_hide_active_cell (sheet); + gtk_sheet_hide_entry_widget (sheet); sheet->entry_type = entry_type; @@ -1318,7 +1306,7 @@ gtk_sheet_change_entry (GtkSheet *sheet, GtkType entry_type) if (state == GTK_SHEET_NORMAL) { - gtk_sheet_show_active_cell (sheet); + gtk_sheet_show_entry_widget (sheet); } } @@ -1333,7 +1321,7 @@ gtk_sheet_show_grid (GtkSheet *sheet, gboolean show) sheet->show_grid = show; - gtk_sheet_range_draw (sheet, NULL); + redraw_range (sheet, NULL); } gboolean @@ -1351,13 +1339,12 @@ 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 -gtk_sheet_set_column_width (GtkSheet *sheet, - gint column, - guint width); +static void set_column_width (GtkSheet *sheet, + gint column, + gint width); void @@ -1481,16 +1468,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_start_pixel (sheet->vaxis, row); gtk_adjustment_set_value (sheet->vadjustment, y - height * row_align); } @@ -1498,40 +1485,20 @@ gtk_sheet_moveto (GtkSheet *sheet, if (col >= 0) { - gint x = g_sheet_column_start_pixel (sheet->column_geometry, col); + gint x = psppire_axis_start_pixel (sheet->haxis, col); gtk_adjustment_set_value (sheet->hadjustment, x - width * col_align); } } -static gboolean -gtk_sheet_columns_resizable (GtkSheet *sheet) -{ - g_return_val_if_fail (sheet != NULL, FALSE); - g_return_val_if_fail (GTK_IS_SHEET (sheet), FALSE); - - return sheet->columns_resizable; -} - - -static gboolean -gtk_sheet_rows_resizable (GtkSheet *sheet) -{ - g_return_val_if_fail (sheet != NULL, FALSE); - g_return_val_if_fail (GTK_IS_SHEET (sheet), FALSE); - - return sheet->rows_resizable; -} - - void gtk_sheet_select_row (GtkSheet *sheet, gint row) { 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) @@ -1541,7 +1508,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; @@ -1556,7 +1523,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) @@ -1565,7 +1532,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; @@ -1579,32 +1546,32 @@ gtk_sheet_select_column (GtkSheet *sheet, gint column) static gboolean gtk_sheet_range_isvisible (const GtkSheet *sheet, - GtkSheetRange range) + const GtkSheetRange *range) { g_return_val_if_fail (sheet != NULL, FALSE); - if (range.row0 < 0 || range.row0 >= 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)) + if (range->rowi < min_visible_row (sheet)) return FALSE; - if (range.row0 > max_visible_row (sheet)) + if (range->row0 > max_visible_row (sheet)) return FALSE; - if (range.coli < min_visible_column (sheet)) + if (range->coli < min_visible_column (sheet)) return FALSE; - if (range.col0 > max_visible_column (sheet)) + if (range->col0 > max_visible_column (sheet)) return FALSE; return TRUE; @@ -1621,7 +1588,7 @@ gtk_sheet_cell_isvisible (GtkSheet *sheet, range.rowi = row; range.coli = column; - return gtk_sheet_range_isvisible (sheet, range); + return gtk_sheet_range_isvisible (sheet, &range); } void @@ -1696,11 +1663,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); - - g_object_unref (sheet->entry_container); - sheet->entry_container = NULL; + if (sheet->vaxis) g_object_unref (sheet->vaxis); + if (sheet->haxis) g_object_unref (sheet->haxis); g_object_unref (sheet->button); sheet->button = NULL; @@ -1752,8 +1716,11 @@ gtk_sheet_style_set (GtkWidget *widget, gtk_style_set_background (widget->style, widget->window, widget->state); } + set_entry_widget_font (sheet); } +#define BORDER_WIDTH 3 + static void gtk_sheet_realize (GtkWidget *widget) { @@ -1762,7 +1729,7 @@ gtk_sheet_realize (GtkWidget *widget) const gint attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP | GDK_WA_CURSOR; - GdkGCValues values, auxvalues; + GdkGCValues values; GdkColormap *colormap; GdkDisplay *display; @@ -1859,12 +1826,10 @@ gtk_sheet_realize (GtkWidget *widget) sheet->fg_gc = gdk_gc_new (widget->window); sheet->bg_gc = gdk_gc_new (widget->window); - gdk_gc_get_values (sheet->fg_gc, &auxvalues); - values.foreground = widget->style->white; values.function = GDK_INVERT; values.subwindow_mode = GDK_INCLUDE_INFERIORS; - values.line_width = 3; + values.line_width = BORDER_WIDTH; sheet->xor_gc = gdk_gc_new_with_values (widget->window, &values, @@ -1933,7 +1898,6 @@ static void global_button_clicked (GtkWidget *widget, gpointer data) { gtk_sheet_click_cell (GTK_SHEET (data), -1, -1); - gtk_widget_grab_focus (GTK_WIDGET (data)); } @@ -2017,7 +1981,7 @@ gtk_sheet_map (GtkWidget *widget) !GTK_WIDGET_MAPPED (GTK_BIN (sheet->button)->child)) gtk_widget_map (GTK_BIN (sheet->button)->child); - gtk_sheet_range_draw (sheet, NULL); + redraw_range (sheet, NULL); change_active_cell (sheet, sheet->active_cell.row, sheet->active_cell.col); @@ -2054,6 +2018,7 @@ gtk_sheet_cell_draw (GtkSheet *sheet, gint row, gint col) { PangoLayout *layout; PangoRectangle text; + PangoFontDescription *font_desc = GTK_WIDGET (sheet)->style->font_desc; gint font_height; gchar *label; @@ -2067,11 +2032,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); @@ -2095,8 +2060,6 @@ gtk_sheet_cell_draw (GtkSheet *sheet, gint row, gint col) area.width, area.height); } - // gtk_sheet_cell_draw_label (sheet, row, col); - label = gtk_sheet_cell_get_text (sheet, row, col); if (NULL == label) @@ -2105,15 +2068,16 @@ gtk_sheet_cell_draw (GtkSheet *sheet, gint row, gint col) layout = gtk_widget_create_pango_layout (GTK_WIDGET (sheet), label); dispose_string (sheet, label); - pango_layout_set_font_description (layout, attributes.font_desc); + pango_layout_set_font_description (layout, font_desc); + pango_layout_get_pixel_extents (layout, NULL, &text); gdk_gc_set_clip_rectangle (sheet->fg_gc, &area); - font_height = pango_font_description_get_size (attributes.font_desc); - if ( !pango_font_description_get_size_is_absolute (attributes.font_desc)) + font_height = pango_font_description_get_size (font_desc); + if ( !pango_font_description_get_size_is_absolute (font_desc)) font_height /= PANGO_SCALE; /* Centre the text vertically */ @@ -2146,15 +2110,36 @@ gtk_sheet_cell_draw (GtkSheet *sheet, gint row, gint col) } - static void -gtk_sheet_range_draw (GtkSheet *sheet, const GtkSheetRange *range) +draw_sheet_region (GtkSheet *sheet, GdkRegion *region) { + GtkSheetRange range; + GdkRectangle area; + gint y, x; gint i, j; - GdkRectangle area; GtkSheetRange drawing_range; + gdk_region_get_clipbox (region, &area); + + y = area.y + sheet->vadjustment->value; + x = area.x + sheet->hadjustment->value; + + if ( sheet->column_titles_visible) + y -= sheet->column_title_area.height; + + if ( sheet->row_titles_visible) + x -= sheet->row_title_area.width; + + maximize_int (&x, 0); + maximize_int (&y, 0); + + range.row0 = row_from_ypixel (sheet, y); + range.rowi = row_from_ypixel (sheet, y + area.height); + + range.col0 = column_from_xpixel (sheet, x); + range.coli = column_from_xpixel (sheet, x + area.width); + g_return_if_fail (sheet != NULL); g_return_if_fail (GTK_SHEET (sheet)); @@ -2162,52 +2147,35 @@ gtk_sheet_range_draw (GtkSheet *sheet, const GtkSheetRange *range) if (!GTK_WIDGET_REALIZED (GTK_WIDGET (sheet))) return; if (!GTK_WIDGET_MAPPED (GTK_WIDGET (sheet))) return; - if (range == NULL) - { - drawing_range.row0 = min_visible_row (sheet); - drawing_range.col0 = min_visible_column (sheet); - drawing_range.rowi = MIN (max_visible_row (sheet), - g_sheet_row_get_row_count (sheet->row_geometry) - 1); - drawing_range.coli = max_visible_column (sheet); - gdk_drawable_get_size (sheet->sheet_window, &area.width, &area.height); - area.x = area.y = 0; - } - else - { - drawing_range.row0 = MAX (range->row0, min_visible_row (sheet)); - drawing_range.col0 = MAX (range->col0, min_visible_column (sheet)); - drawing_range.rowi = MIN (range->rowi, max_visible_row (sheet)); - drawing_range.coli = MIN (range->coli, max_visible_column (sheet)); - - rectangle_from_range (sheet, &drawing_range, &area); - } + drawing_range.row0 = MAX (range.row0, min_visible_row (sheet)); + drawing_range.col0 = MAX (range.col0, min_visible_column (sheet)); + drawing_range.rowi = MIN (range.rowi, max_visible_row (sheet)); + drawing_range.coli = MIN (range.coli, max_visible_column (sheet)); - - gdk_draw_rectangle (sheet->sheet_window, - GTK_WIDGET (sheet)->style->white_gc, - TRUE, - area.x, area.y, - area.width, area.height); + g_return_if_fail (drawing_range.rowi >= drawing_range.row0); + g_return_if_fail (drawing_range.coli >= drawing_range.col0); for (i = drawing_range.row0; i <= drawing_range.rowi; i++) - for (j = drawing_range.col0; j <= drawing_range.coli; j++) - { + { + for (j = drawing_range.col0; j <= drawing_range.coli; j++) gtk_sheet_cell_draw (sheet, i, j); - } + } if (sheet->state != GTK_SHEET_NORMAL && - gtk_sheet_range_isvisible (sheet, sheet->range)) + gtk_sheet_range_isvisible (sheet, &sheet->range)) gtk_sheet_range_draw_selection (sheet, drawing_range); + if (sheet->state == GTK_STATE_NORMAL && sheet->active_cell.row >= drawing_range.row0 && sheet->active_cell.row <= drawing_range.rowi && sheet->active_cell.col >= drawing_range.col0 && sheet->active_cell.col <= drawing_range.coli) - gtk_sheet_show_active_cell (sheet); + gtk_sheet_show_entry_widget (sheet); } + static void gtk_sheet_range_draw_selection (GtkSheet *sheet, GtkSheetRange range) { @@ -2219,7 +2187,7 @@ gtk_sheet_range_draw_selection (GtkSheet *sheet, GtkSheetRange range) range.row0 > sheet->range.rowi || range.rowi < sheet->range.row0) return; - if (!gtk_sheet_range_isvisible (sheet, range)) return; + if (!gtk_sheet_range_isvisible (sheet, &range)) return; if (!GTK_WIDGET_REALIZED (GTK_WIDGET (sheet))) return; aux = range; @@ -2271,16 +2239,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); } @@ -2296,8 +2259,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; @@ -2306,6 +2269,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); } @@ -2318,8 +2284,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; @@ -2330,7 +2296,7 @@ gtk_sheet_cell_clear (GtkSheet *sheet, gint row, gint column) gtk_sheet_real_cell_clear (sheet, row, column); - gtk_sheet_range_draw (sheet, &range); + redraw_range (sheet, &range); } static void @@ -2355,7 +2321,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; @@ -2376,7 +2342,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; @@ -2440,8 +2406,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; } @@ -2459,7 +2425,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; } @@ -2477,17 +2443,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_start_pixel (sheet->haxis, column); + area->y = (row == -1) ? 0 : psppire_axis_start_pixel (sheet->vaxis, row); area->width= (column == -1) ? sheet->row_title_area.width - : 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; } @@ -2501,9 +2467,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; @@ -2514,7 +2480,7 @@ gtk_sheet_set_active_cell (GtkSheet *sheet, gint row, gint col) if ( row == -1 || col == -1) { - gtk_sheet_hide_active_cell (sheet); + gtk_sheet_hide_entry_widget (sheet); return; } @@ -2534,16 +2500,12 @@ gtk_sheet_get_active_cell (GtkSheet *sheet, gint *row, gint *column) static void gtk_sheet_entry_changed (GtkWidget *widget, gpointer data) { - GtkSheet *sheet; + GtkSheet *sheet = GTK_SHEET (data); gint row, col; const char *text; GtkJustification justification; GtkSheetCellAttr attributes; - g_return_if_fail (data != NULL); - g_return_if_fail (GTK_IS_SHEET (data)); - - sheet = GTK_SHEET (data); if (!GTK_WIDGET_VISIBLE (widget)) return; if (sheet->state != GTK_STATE_NORMAL) return; @@ -2556,7 +2518,7 @@ gtk_sheet_entry_changed (GtkWidget *widget, gpointer data) sheet->active_cell.row = -1; sheet->active_cell.col = -1; - text = gtk_entry_get_text (GTK_ENTRY (gtk_sheet_get_entry (sheet))); + text = gtk_entry_get_text (gtk_sheet_get_entry (sheet)); if (text && strlen (text) > 0) { @@ -2571,10 +2533,8 @@ gtk_sheet_entry_changed (GtkWidget *widget, gpointer data) static void -gtk_sheet_hide_active_cell (GtkSheet *sheet) +gtk_sheet_hide_entry_widget (GtkSheet *sheet) { - GdkRectangle area; - if (!GTK_WIDGET_REALIZED (GTK_WIDGET (sheet))) return; @@ -2584,19 +2544,6 @@ gtk_sheet_hide_active_cell (GtkSheet *sheet) gtk_widget_hide (sheet->entry_widget); gtk_widget_unmap (sheet->entry_widget); - rectangle_from_cell (sheet, - sheet->active_cell.row, sheet->active_cell.col, - &area); - - gdk_draw_rectangle (sheet->sheet_window, - GTK_WIDGET (sheet)->style->white_gc, - TRUE, - area.x, area.y, - area.width, area.height); - - gtk_sheet_cell_draw (sheet, sheet->active_cell.row, - sheet->active_cell.col); - GTK_WIDGET_UNSET_FLAGS (GTK_WIDGET (sheet->entry_widget), GTK_VISIBLE); } @@ -2604,15 +2551,14 @@ static void change_active_cell (GtkSheet *sheet, gint row, gint col) { gint old_row, old_col; - glong old_handler_id = sheet->entry_handler_id; g_return_if_fail (GTK_IS_SHEET (sheet)); 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) @@ -2621,11 +2567,12 @@ change_active_cell (GtkSheet *sheet, gint row, gint col) gtk_sheet_real_unselect_range (sheet, NULL); } - g_signal_handler_block (sheet->entry_widget, sheet->entry_handler_id); - old_row = sheet->active_cell.row; old_col = sheet->active_cell.col; + /* Erase the old cell */ + gtk_sheet_draw_active_cell (sheet); + sheet->range.row0 = row; sheet->range.col0 = col; sheet->range.rowi = row; @@ -2637,25 +2584,25 @@ change_active_cell (GtkSheet *sheet, gint row, gint col) GTK_SHEET_UNSET_FLAGS (sheet, GTK_SHEET_IN_SELECTION); - gtk_sheet_show_active_cell (sheet); + GTK_WIDGET_UNSET_FLAGS (sheet->entry_widget, GTK_HAS_FOCUS); + gtk_sheet_draw_active_cell (sheet); + gtk_sheet_show_entry_widget (sheet); + GTK_WIDGET_SET_FLAGS (sheet->entry_widget, GTK_HAS_FOCUS); g_signal_emit (sheet, sheet_signals [ACTIVATE], 0, row, col, old_row, old_col); - if ( old_handler_id == sheet->entry_handler_id) - g_signal_handler_unblock (sheet->entry_widget, sheet->entry_handler_id); } static void -gtk_sheet_show_active_cell (GtkSheet *sheet) +gtk_sheet_show_entry_widget (GtkSheet *sheet) { GtkEntry *sheet_entry; GtkSheetCellAttr attributes; - gchar *text = NULL; + gint row, col; - g_return_if_fail (sheet != NULL); g_return_if_fail (GTK_IS_SHEET (sheet)); row = sheet->active_cell.row; @@ -2671,23 +2618,20 @@ gtk_sheet_show_active_cell (GtkSheet *sheet) GTK_WIDGET_SET_FLAGS (GTK_WIDGET (sheet->entry_widget), GTK_VISIBLE); - sheet_entry = GTK_ENTRY (gtk_sheet_get_entry (sheet)); + sheet_entry = gtk_sheet_get_entry (sheet); gtk_sheet_get_attributes (sheet, row, col, &attributes); - - text = gtk_sheet_cell_get_text (sheet, row, col); - if ( ! text ) - text = g_strdup (""); - - gtk_entry_set_visibility (GTK_ENTRY (sheet_entry), attributes.is_visible); - - - if ( GTK_IS_ENTRY (sheet_entry)) + if (GTK_IS_ENTRY (sheet_entry) && !GTK_WIDGET_HAS_FOCUS (sheet_entry)) { + gchar *text = gtk_sheet_cell_get_text (sheet, row, col); const gchar *old_text = gtk_entry_get_text (GTK_ENTRY (sheet_entry)); + + if ( ! text ) + text = g_strdup (""); + if (strcmp (old_text, text) != 0) - gtk_entry_set_text (GTK_ENTRY (sheet_entry), text); + gtk_entry_set_text (sheet_entry, text); switch (attributes.justification) { @@ -2702,38 +2646,37 @@ gtk_sheet_show_active_cell (GtkSheet *sheet) gtk_entry_set_alignment (GTK_ENTRY (sheet_entry), 0.0); break; } + dispose_string (sheet, text); } gtk_sheet_size_allocate_entry (sheet); + gtk_widget_set_sensitive (GTK_WIDGET (sheet_entry), + g_sheet_model_is_editable (sheet->model, + row, col)); gtk_widget_map (sheet->entry_widget); - - gtk_widget_grab_focus (GTK_WIDGET (sheet_entry)); - - dispose_string (sheet, text); } -static void +static gboolean gtk_sheet_draw_active_cell (GtkSheet *sheet) { gint row, col; GtkSheetRange range; - if (!GTK_WIDGET_DRAWABLE (GTK_WIDGET (sheet))) return; - if (!GTK_WIDGET_REALIZED (GTK_WIDGET (sheet))) return; - row = sheet->active_cell.row; col = sheet->active_cell.col; - if (row < 0 || col < 0) return; + if (row < 0 || col < 0) return FALSE; if (!gtk_sheet_cell_isvisible (sheet, row, col)) - return; + return FALSE; range.col0 = range.coli = col; range.row0 = range.rowi = row; gtk_sheet_draw_border (sheet, range); + + return FALSE; } @@ -2795,11 +2738,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_start_pixel (sheet->haxis, j); + y = psppire_axis_start_pixel (sheet->vaxis, i); + width = psppire_axis_start_pixel (sheet->haxis, j)- x+ + psppire_axis_unit_size (sheet->haxis, j); + height = psppire_axis_start_pixel (sheet->vaxis, i) - y + psppire_axis_unit_size (sheet->vaxis, i); if (i == sheet->range.row0) { @@ -2816,12 +2759,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_start_pixel (sheet->haxis, j); + y = psppire_axis_start_pixel (sheet->vaxis, i); + width = psppire_axis_start_pixel (sheet->haxis, j)- x+ + psppire_axis_unit_size (sheet->haxis, j); - height = g_sheet_row_start_pixel (sheet->row_geometry, i) - y + g_sheet_row_get_height (sheet->row_geometry, i); + height = psppire_axis_start_pixel (sheet->vaxis, i) - y + psppire_axis_unit_size (sheet->vaxis, i); if (i == new_range.row0) { @@ -2859,10 +2802,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_start_pixel (sheet->haxis, j); + y = psppire_axis_start_pixel (sheet->vaxis, i); + width = psppire_axis_start_pixel (sheet->haxis, j) - x + psppire_axis_unit_size (sheet->haxis, j); + height = psppire_axis_start_pixel (sheet->vaxis, i) - y + psppire_axis_unit_size (sheet->vaxis, i); if (i == sheet->range.row0) { @@ -2894,10 +2837,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_start_pixel (sheet->haxis, j); + y = psppire_axis_start_pixel (sheet->vaxis, i); + width = psppire_axis_start_pixel (sheet->haxis, j) - x + psppire_axis_unit_size (sheet->haxis, j); + height = psppire_axis_start_pixel (sheet->vaxis, i) - y + psppire_axis_unit_size (sheet->vaxis, i); if (i == new_range.row0) { @@ -2940,10 +2883,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_start_pixel (sheet->haxis, j); + y = psppire_axis_start_pixel (sheet->vaxis, i); + width = psppire_axis_unit_size (sheet->haxis, j); + height = psppire_axis_unit_size (sheet->vaxis, i); if (mask2 & 1) gdk_draw_rectangle (sheet->sheet_window, sheet->xor_gc, @@ -2980,6 +2923,8 @@ gtk_sheet_new_selection (GtkSheet *sheet, GtkSheetRange *range) *range = new_range; } + + static void gtk_sheet_draw_border (GtkSheet *sheet, GtkSheetRange new_range) { @@ -2990,10 +2935,8 @@ gtk_sheet_draw_border (GtkSheet *sheet, GtkSheetRange new_range) gdk_draw_rectangle (sheet->sheet_window, sheet->xor_gc, FALSE, - area.x + 1, - area.y + 1, - area.width - 2, - area.height - 2); + area.x, area.y, + area.width, area.height); } @@ -3097,11 +3040,6 @@ gtk_sheet_real_unselect_range (GtkSheet *sheet, g_signal_emit (sheet, sheet_signals[SELECT_COLUMN], 0, -1); g_signal_emit (sheet, sheet_signals[SELECT_ROW], 0, -1); -#if 0 - if (gtk_sheet_range_isvisible (sheet, *range)) - gtk_sheet_draw_backing_pixmap (sheet, *range); -#endif - sheet->range.row0 = -1; sheet->range.rowi = -1; sheet->range.col0 = -1; @@ -3113,15 +3051,10 @@ static gint gtk_sheet_expose (GtkWidget *widget, GdkEventExpose *event) { - GtkSheet *sheet; - GtkSheetRange range; + GtkSheet *sheet = GTK_SHEET (widget); - g_return_val_if_fail (widget != NULL, FALSE); - g_return_val_if_fail (GTK_IS_SHEET (widget), FALSE); g_return_val_if_fail (event != NULL, FALSE); - sheet = GTK_SHEET (widget); - if (!GTK_WIDGET_DRAWABLE (widget)) return FALSE; @@ -3142,56 +3075,43 @@ gtk_sheet_expose (GtkWidget *widget, max_visible_column (sheet)); } - - range.row0 = - yyy_row_ypixel_to_row (sheet, - event->area.y + sheet->vadjustment->value); - range.row0--; - - range.rowi = - yyy_row_ypixel_to_row (sheet, - event->area.y + - event->area.height + sheet->vadjustment->value); - range.rowi++; - - range.col0 = - column_from_xpixel (sheet, - event->area.x + sheet->hadjustment->value); - range.col0--; - - range.coli = - column_from_xpixel (sheet, - event->area.x + event->area.width + - sheet->hadjustment->value); - range.coli++; - if (event->window == sheet->sheet_window) { - gtk_sheet_range_draw (sheet, &range); + draw_sheet_region (sheet, event->region); +#if 0 if (sheet->state != GTK_SHEET_NORMAL) { - if (gtk_sheet_range_isvisible (sheet, sheet->range)) + if (gtk_sheet_range_isvisible (sheet, &sheet->range)) gtk_sheet_range_draw (sheet, &sheet->range); if (GTK_SHEET_IN_RESIZE (sheet) || GTK_SHEET_IN_DRAG (sheet)) gtk_sheet_range_draw (sheet, &sheet->drag_range); - if (gtk_sheet_range_isvisible (sheet, sheet->range)) + if (gtk_sheet_range_isvisible (sheet, &sheet->range)) gtk_sheet_range_draw_selection (sheet, sheet->range); if (GTK_SHEET_IN_RESIZE (sheet) || GTK_SHEET_IN_DRAG (sheet)) draw_xor_rectangle (sheet, sheet->drag_range); } +#endif if ((!GTK_SHEET_IN_XDRAG (sheet)) && (!GTK_SHEET_IN_YDRAG (sheet))) { - if (sheet->state == GTK_SHEET_NORMAL) - gtk_sheet_draw_active_cell (sheet); + GdkRectangle rect; + GtkSheetRange range; + range.row0 = range.rowi = sheet->active_cell.row; + range.col0 = range.coli = sheet->active_cell.col; + + rectangle_from_range (sheet, &range, &rect); + + if (GDK_OVERLAP_RECTANGLE_OUT != + gdk_region_rect_in (event->region, &rect)) + { + gtk_sheet_draw_active_cell (sheet); + } } - } - if (sheet->state != GTK_SHEET_NORMAL && GTK_SHEET_IN_SELECTION (sheet)) - gtk_widget_grab_focus (GTK_WIDGET (sheet)); + } (* GTK_WIDGET_CLASS (parent_class)->expose_event) (widget, event); @@ -3228,11 +3148,12 @@ gtk_sheet_button_press (GtkWidget *widget, if (event->window == sheet->column_title_window) { + sheet->x_drag = event->x; g_signal_emit (sheet, sheet_signals[BUTTON_EVENT_COLUMN], 0, column, event); - 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, @@ -3245,8 +3166,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, @@ -3260,21 +3180,12 @@ gtk_sheet_button_press (GtkWidget *widget, /* press on resize windows */ - if (event->window == sheet->column_title_window && - gtk_sheet_columns_resizable (sheet)) + if (event->window == sheet->column_title_window) { -#if 0 - gtk_widget_get_pointer (widget, &sheet->x_drag, NULL); - if ( sheet->row_titles_visible) - sheet->x_drag -= sheet->row_title_area.width; -#endif - sheet->x_drag = event->x; if (on_column_boundary (sheet, sheet->x_drag, &sheet->drag_cell.col)) { - guint req; - gtk_sheet_column_size_request (sheet, sheet->drag_cell.col, &req); GTK_SHEET_SET_FLAGS (sheet, GTK_SHEET_IN_XDRAG); gdk_pointer_grab (sheet->column_title_window, FALSE, GDK_POINTER_MOTION_HINT_MASK | @@ -3287,14 +3198,12 @@ gtk_sheet_button_press (GtkWidget *widget, } } - if (event->window == sheet->row_title_window && gtk_sheet_rows_resizable (sheet)) + if (event->window == sheet->row_title_window) { - gtk_widget_get_pointer (widget, NULL, &sheet->y_drag); + sheet->y_drag = event->y; - if (POSSIBLE_YDRAG (sheet, sheet->y_drag, &sheet->drag_cell.row)) + if (on_row_boundary (sheet, sheet->y_drag, &sheet->drag_cell.row)) { - guint req; - gtk_sheet_row_size_request (sheet, sheet->drag_cell.row, &req); GTK_SHEET_SET_FLAGS (sheet, GTK_SHEET_IN_YDRAG); gdk_pointer_grab (sheet->row_title_window, FALSE, GDK_POINTER_MOTION_HINT_MASK | @@ -3322,12 +3231,6 @@ gtk_sheet_button_press (GtkWidget *widget, NULL, NULL, event->time); gtk_grab_add (GTK_WIDGET (sheet)); - /* This seems to be a kludge to work around a problem where the sheet - scrolls to another position. The timeout scrolls it back to its - original posn. JMD 3 July 2007 - */ - gtk_widget_grab_focus (GTK_WIDGET (sheet)); - if (sheet->selection_mode != GTK_SELECTION_SINGLE && sheet->selection_mode != GTK_SELECTION_NONE && sheet->cursor_drag->type == GDK_SIZING && @@ -3399,11 +3302,10 @@ 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)); - gtk_widget_grab_focus (GTK_WIDGET (sheet)); GTK_SHEET_SET_FLAGS (sheet, GTK_SHEET_IN_SELECTION); } } @@ -3416,12 +3318,11 @@ 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)); - gtk_widget_grab_focus (GTK_WIDGET (sheet)); GTK_SHEET_SET_FLAGS (sheet, GTK_SHEET_IN_SELECTION); } } @@ -3438,8 +3339,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; } @@ -3477,9 +3378,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); @@ -3506,7 +3407,9 @@ gtk_sheet_click_cell (GtkSheet *sheet, gint row, gint column) sheet->range.coli = column; sheet->state = GTK_SHEET_NORMAL; GTK_SHEET_SET_FLAGS (sheet, GTK_SHEET_IN_SELECTION); - gtk_sheet_draw_active_cell (sheet); + + gtk_widget_grab_focus (GTK_WIDGET (sheet->entry_widget)); + return TRUE; } @@ -3514,7 +3417,6 @@ static gint gtk_sheet_button_release (GtkWidget *widget, GdkEventButton *event) { - gint y; GdkDisplay *display = gtk_widget_get_display (widget); GtkSheet *sheet = GTK_SHEET (widget); @@ -3522,7 +3424,6 @@ gtk_sheet_button_release (GtkWidget *widget, /* release on resize windows */ if (GTK_SHEET_IN_XDRAG (sheet)) { - gint xpos = event->x; gint width; GTK_SHEET_UNSET_FLAGS (sheet, GTK_SHEET_IN_XDRAG); GTK_SHEET_UNSET_FLAGS (sheet, GTK_SHEET_IN_SELECTION); @@ -3530,27 +3431,33 @@ gtk_sheet_button_release (GtkWidget *widget, gdk_display_pointer_ungrab (display, event->time); draw_xor_vline (sheet); - width = new_column_width (sheet, sheet->drag_cell.col, &xpos); + width = event->x - + psppire_axis_start_pixel (sheet->haxis, sheet->drag_cell.col) + + sheet->hadjustment->value; + + set_column_width (sheet, sheet->drag_cell.col, width); - gtk_sheet_set_column_width (sheet, sheet->drag_cell.col, width); return TRUE; } if (GTK_SHEET_IN_YDRAG (sheet)) { + gint height; GTK_SHEET_UNSET_FLAGS (sheet, GTK_SHEET_IN_YDRAG); GTK_SHEET_UNSET_FLAGS (sheet, GTK_SHEET_IN_SELECTION); - gtk_widget_get_pointer (widget, NULL, &y); + gdk_display_pointer_ungrab (display, event->time); draw_xor_hline (sheet); - gtk_sheet_set_row_height (sheet, sheet->drag_cell.row, - new_row_height (sheet, sheet->drag_cell.row, &y)); - g_signal_emit_by_name (sheet->vadjustment, "value_changed"); + height = event->y - + psppire_axis_start_pixel (sheet->vaxis, sheet->drag_cell.row) + + sheet->vadjustment->value; + + set_row_height (sheet, sheet->drag_cell.row, height); + return TRUE; } - if (GTK_SHEET_IN_DRAG (sheet)) { GtkSheetRange old_range; @@ -3749,10 +3656,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); @@ -3760,10 +3664,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); @@ -3777,19 +3679,15 @@ motion_timeout_callback (gpointer data) static gboolean gtk_sheet_motion (GtkWidget *widget, GdkEventMotion *event) { - GtkSheet *sheet; + GtkSheet *sheet = GTK_SHEET (widget); GdkModifierType mods; GdkCursorType new_cursor; gint x, y; gint row, column; GdkDisplay *display; - g_return_val_if_fail (widget != NULL, FALSE); - g_return_val_if_fail (GTK_IS_SHEET (widget), FALSE); g_return_val_if_fail (event != NULL, FALSE); - sheet = GTK_SHEET (widget); - display = gtk_widget_get_display (widget); /* selections on the sheet */ @@ -3819,8 +3717,7 @@ gtk_sheet_motion (GtkWidget *widget, GdkEventMotion *event) } } - if (event->window == sheet->column_title_window && - gtk_sheet_columns_resizable (sheet)) + if (event->window == sheet->column_title_window) { if (!GTK_SHEET_IN_SELECTION (sheet) && on_column_boundary (sheet, x, &column)) @@ -3829,7 +3726,9 @@ gtk_sheet_motion (GtkWidget *widget, GdkEventMotion *event) if (new_cursor != sheet->cursor_drag->type) { gdk_cursor_unref (sheet->cursor_drag); - sheet->cursor_drag = gdk_cursor_new_for_display (display, GDK_SB_H_DOUBLE_ARROW); + sheet->cursor_drag = + gdk_cursor_new_for_display (display, new_cursor); + gdk_window_set_cursor (sheet->column_title_window, sheet->cursor_drag); } @@ -3841,24 +3740,26 @@ gtk_sheet_motion (GtkWidget *widget, GdkEventMotion *event) new_cursor != sheet->cursor_drag->type) { gdk_cursor_unref (sheet->cursor_drag); - sheet->cursor_drag = gdk_cursor_new_for_display (display, GDK_TOP_LEFT_ARROW); + sheet->cursor_drag = + gdk_cursor_new_for_display (display, new_cursor); gdk_window_set_cursor (sheet->column_title_window, sheet->cursor_drag); } } } - - if (event->window == sheet->row_title_window && - gtk_sheet_rows_resizable (sheet)) + else if (event->window == sheet->row_title_window) { - if (!GTK_SHEET_IN_SELECTION (sheet) && POSSIBLE_YDRAG (sheet, y, &column)) + if (!GTK_SHEET_IN_SELECTION (sheet) && + on_row_boundary (sheet, y, &row)) { new_cursor = GDK_SB_V_DOUBLE_ARROW; if (new_cursor != sheet->cursor_drag->type) { gdk_cursor_unref (sheet->cursor_drag); - sheet->cursor_drag = gdk_cursor_new_for_display (display, GDK_SB_V_DOUBLE_ARROW); - gdk_window_set_cursor (sheet->row_title_window, sheet->cursor_drag); + sheet->cursor_drag = + gdk_cursor_new_for_display (display, new_cursor); + gdk_window_set_cursor (sheet->row_title_window, + sheet->cursor_drag); } } else @@ -3868,8 +3769,10 @@ gtk_sheet_motion (GtkWidget *widget, GdkEventMotion *event) new_cursor != sheet->cursor_drag->type) { gdk_cursor_unref (sheet->cursor_drag); - sheet->cursor_drag = gdk_cursor_new_for_display (display, GDK_TOP_LEFT_ARROW); - gdk_window_set_cursor (sheet->row_title_window, sheet->cursor_drag); + sheet->cursor_drag = + gdk_cursor_new_for_display (display, new_cursor); + gdk_window_set_cursor (sheet->row_title_window, + sheet->cursor_drag); } } } @@ -3919,34 +3822,25 @@ gtk_sheet_motion (GtkWidget *widget, GdkEventMotion *event) if (GTK_SHEET_IN_XDRAG (sheet)) { - x = event->x; - - new_column_width (sheet, sheet->drag_cell.col, &x); -#if 0 - if (x != sheet->x_drag) + if (event->x != sheet->x_drag) { draw_xor_vline (sheet); - sheet->x_drag = x; + sheet->x_drag = event->x; draw_xor_vline (sheet); } -#endif + return TRUE; } if (GTK_SHEET_IN_YDRAG (sheet)) { - if (event->is_hint || event->window != widget->window) - gtk_widget_get_pointer (widget, NULL, &y); - else - y = event->y; - - new_row_height (sheet, sheet->drag_cell.row, &y); - if (y != sheet->y_drag) + if (event->y != sheet->y_drag) { draw_xor_hline (sheet); - sheet->y_drag = y; + sheet->y_drag = event->y; draw_xor_hline (sheet); } + return TRUE; } @@ -3954,14 +3848,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; @@ -3983,18 +3877,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_start_pixel (sheet->haxis, sheet->drag_cell.col)) > + abs (y - psppire_axis_start_pixel (sheet->vaxis, sheet->drag_cell.row))) v_h = 2; current_col = column_from_xpixel (sheet, x); - current_row = 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_start_pixel (sheet->haxis, current_col) + + psppire_axis_unit_size (sheet->haxis, current_col) / 2; if (column > 0) { if (x < col_threshold) @@ -4005,8 +3899,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_start_pixel (sheet->vaxis, current_row) + + psppire_axis_unit_size (sheet->vaxis, current_row)/2; if (row > 0) { if (y < row_threshold) @@ -4029,8 +3923,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; @@ -4098,10 +3992,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; @@ -4149,11 +4043,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_start_pixel (sheet->vaxis, old_row); gint new_row; - vpixel -= g_sheet_row_start_pixel (sheet->row_geometry, + vpixel -= psppire_axis_start_pixel (sheet->vaxis, min_visible_row (sheet)); switch ( dir) @@ -4175,10 +4069,10 @@ page_vertical (GtkSheet *sheet, GtkScrollType dir) } - vpixel += g_sheet_row_start_pixel (sheet->row_geometry, + vpixel += psppire_axis_start_pixel (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); @@ -4216,29 +4110,31 @@ step_sheet (GtkSheet *sheet, GtkScrollType dir) } - 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, - g_sheet_column_get_column_count (sheet->column_geometry) - 1); - g_signal_emit (sheet, sheet_signals[TRAVERSE], 0, &sheet->active_cell, &new_cell, - &forbidden); + &forbidden); if (forbidden) return; + + maximize_int (&new_cell.row, 0); + maximize_int (&new_cell.col, 0); + + minimize_int (&new_cell.row, + psppire_axis_unit_count (sheet->vaxis) - 1); + + minimize_int (&new_cell.col, + psppire_axis_unit_count (sheet->haxis) - 1); + 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, + psppire_axis_start_pixel (sheet->haxis, new_cell.col + 1); hpos -= sheet->hadjustment->page_size; @@ -4248,7 +4144,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_start_pixel (sheet->haxis, new_cell.col); gtk_adjustment_set_value (sheet->hadjustment, @@ -4259,7 +4155,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_start_pixel (sheet->vaxis, new_cell.row + 1); vpos -= sheet->vadjustment->page_size; @@ -4269,12 +4165,14 @@ 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_start_pixel (sheet->vaxis, new_cell.row); gtk_adjustment_set_value (sheet->vadjustment, vpos); } + + gtk_widget_grab_focus (GTK_WIDGET (sheet->entry_widget)); } @@ -4328,7 +4226,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; @@ -4391,14 +4289,6 @@ gtk_sheet_size_allocate (GtkWidget *widget, allocation->width - 2 * border_width, allocation->height - 2 * border_width); - /* use internal allocation structure for all the math - * because it's easier than always subtracting the container - * border width */ - sheet->internal_allocation.x = 0; - sheet->internal_allocation.y = 0; - sheet->internal_allocation.width = allocation->width - 2 * border_width; - sheet->internal_allocation.height = allocation->height - 2 * border_width; - sheet_allocation.x = 0; sheet_allocation.y = 0; sheet_allocation.width = allocation->width - 2 * border_width; @@ -4414,13 +4304,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) @@ -4431,17 +4327,6 @@ gtk_sheet_size_allocate (GtkWidget *widget, sheet->column_title_area.height); - /* 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, @@ -4449,6 +4334,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); + } + /* set the scrollbars adjustments */ adjust_scrollbars (sheet); @@ -4483,7 +4393,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, @@ -4525,7 +4435,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, @@ -4548,19 +4458,16 @@ gtk_sheet_size_allocate_entry (GtkSheet *sheet) GtkSheetCellAttr attributes = { 0 }; GtkEntry *sheet_entry; - if (!GTK_WIDGET_REALIZED (GTK_WIDGET (sheet))) return; if (!GTK_WIDGET_MAPPED (GTK_WIDGET (sheet))) return; - sheet_entry = GTK_ENTRY (gtk_sheet_get_entry (sheet)); + sheet_entry = gtk_sheet_get_entry (sheet); if ( ! gtk_sheet_get_attributes (sheet, sheet->active_cell.row, sheet->active_cell.col, &attributes) ) return ; - gtk_widget_ensure_style (GTK_WIDGET (sheet_entry)); - if ( GTK_WIDGET_REALIZED (sheet->entry_widget) ) { GtkStyle *style = GTK_WIDGET (sheet_entry)->style; @@ -4571,21 +4478,37 @@ gtk_sheet_size_allocate_entry (GtkSheet *sheet) style->bg[GTK_STATE_ACTIVE] = attributes.background; style->fg[GTK_STATE_ACTIVE] = attributes.foreground; style->text[GTK_STATE_ACTIVE] = attributes.foreground; - - pango_font_description_free (style->font_desc); - g_assert (attributes.font_desc); - style->font_desc = pango_font_description_copy (attributes.font_desc); } rectangle_from_cell (sheet, sheet->active_cell.row, sheet->active_cell.col, &entry_alloc); + entry_alloc.width -= BORDER_WIDTH ; + entry_alloc.height -= BORDER_WIDTH ; + entry_alloc.x += DIV_RND_UP (BORDER_WIDTH, 2); + entry_alloc.y += DIV_RND_UP (BORDER_WIDTH, 2); + + gtk_widget_set_size_request (sheet->entry_widget, entry_alloc.width, entry_alloc.height); gtk_widget_size_allocate (sheet->entry_widget, &entry_alloc); } +/* Copy the sheet's font to the entry widget */ +static void +set_entry_widget_font (GtkSheet *sheet) +{ + GtkRcStyle *style = gtk_widget_get_modifier_style (sheet->entry_widget); + + pango_font_description_free (style->font_desc); + style->font_desc = pango_font_description_copy (GTK_WIDGET (sheet)->style->font_desc); + + gtk_widget_modify_style (sheet->entry_widget, style); +} + + + static void create_sheet_entry (GtkSheet *sheet) { @@ -4594,32 +4517,18 @@ create_sheet_entry (GtkSheet *sheet) gtk_widget_unparent (sheet->entry_widget); } - if (sheet->entry_type) - { - sheet->entry_container = g_object_new (sheet->entry_type, NULL); - g_object_ref_sink (sheet->entry_container); - sheet->entry_widget = gtk_sheet_get_entry (sheet); + sheet->entry_widget = g_object_new (sheet->entry_type, NULL); + g_object_ref_sink (sheet->entry_widget); - if ( NULL == sheet->entry_widget) - { - g_warning ("Entry type is %s. It must be GtkEntry subclass, or a widget containing one. " - "Using default", g_type_name (sheet->entry_type)); - g_object_unref (sheet->entry_container); - sheet->entry_widget = sheet->entry_container = gtk_entry_new (); - } - else - { - sheet->entry_widget = sheet->entry_container ; - } - } - else + gtk_widget_size_request (sheet->entry_widget, NULL); + + if ( GTK_IS_ENTRY (sheet->entry_widget)) { - sheet->entry_widget = sheet->entry_container = gtk_entry_new (); - g_object_ref_sink (sheet->entry_container); + g_object_set (sheet->entry_widget, + "has-frame", FALSE, + NULL); } - gtk_widget_size_request (sheet->entry_widget, NULL); - if (GTK_WIDGET_REALIZED (sheet)) { gtk_widget_set_parent_window (sheet->entry_widget, sheet->sheet_window); @@ -4631,12 +4540,13 @@ create_sheet_entry (GtkSheet *sheet) G_CALLBACK (gtk_sheet_entry_key_press), sheet); - sheet->entry_handler_id = - g_signal_connect (sheet->entry_widget, + g_signal_connect (sheet->entry_widget, "changed", G_CALLBACK (gtk_sheet_entry_changed), sheet); + set_entry_widget_font (sheet); + gtk_widget_show (sheet->entry_widget); } @@ -4652,43 +4562,32 @@ find_entry (GtkWidget *w, gpointer user_data) } } -GtkWidget * + +GtkEntry * gtk_sheet_get_entry (GtkSheet *sheet) { - GtkWidget *parent; - GtkWidget *entry = NULL; + GtkWidget *w = sheet->entry_widget; g_return_val_if_fail (sheet != NULL, NULL); g_return_val_if_fail (GTK_IS_SHEET (sheet), NULL); g_return_val_if_fail (sheet->entry_widget != NULL, NULL); - if (GTK_IS_ENTRY (sheet->entry_container)) - return (sheet->entry_container); - - parent = sheet->entry_container; - - if (GTK_IS_CONTAINER (parent)) + while (! GTK_IS_ENTRY (w)) { - gtk_container_forall (GTK_CONTAINER (parent), find_entry, &entry); - - if (GTK_IS_ENTRY (entry)) - return entry; - } - - if (!GTK_IS_ENTRY (entry)) return NULL; + GtkWidget *entry = NULL; - return (entry); + if (GTK_IS_CONTAINER (w)) + { + gtk_container_forall (GTK_CONTAINER (w), find_entry, &entry); -} + if (NULL == entry) + break; -GtkWidget * -gtk_sheet_get_entry_widget (GtkSheet *sheet) -{ - g_return_val_if_fail (sheet != NULL, NULL); - g_return_val_if_fail (GTK_IS_SHEET (sheet), NULL); - g_return_val_if_fail (sheet->entry_widget != NULL, NULL); + w = entry; + } + } - return (sheet->entry_widget); + return GTK_ENTRY (w); } @@ -4750,7 +4649,7 @@ draw_button (GtkSheet *sheet, GdkWindow *window, allocation.y += 2 * sheet->button->style->ythickness; - if (button->label && strlen (button->label)>0) + if (button->label && strlen (button->label) > 0) { PangoRectangle rect; gchar *line = button->label; @@ -4806,7 +4705,7 @@ draw_button (GtkSheet *sheet, GdkWindow *window, static void draw_column_title_buttons_range (GtkSheet *sheet, gint first, gint last) { - GdkRegion *region; + GdkRectangle rect; gint col; if (!GTK_WIDGET_REALIZED (GTK_WIDGET (sheet))) return; @@ -4815,10 +4714,18 @@ draw_column_title_buttons_range (GtkSheet *sheet, gint first, gint last) g_return_if_fail (first >= min_visible_column (sheet)); g_return_if_fail (last <= max_visible_column (sheet)); - region = - gdk_drawable_get_visible_region (GDK_DRAWABLE (sheet->column_title_window)); + rect.y = 0; + rect.height = sheet->column_title_area.height; + rect.x = psppire_axis_start_pixel (sheet->haxis, first) + CELL_SPACING; + rect.width = psppire_axis_start_pixel (sheet->haxis, last) + CELL_SPACING + + psppire_axis_unit_size (sheet->haxis, last); + + rect.x -= sheet->hadjustment->value; + + minimize_int (&rect.width, sheet->column_title_area.width); + maximize_int (&rect.x, 0); - gdk_window_begin_paint_region (sheet->column_title_window, region); + gdk_window_begin_paint_rect (sheet->column_title_window, &rect); for (col = first ; col <= last ; ++col) { @@ -4826,18 +4733,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_start_pixel (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); @@ -4850,7 +4754,7 @@ draw_column_title_buttons_range (GtkSheet *sheet, gint first, gint last) static void draw_row_title_buttons_range (GtkSheet *sheet, gint first, gint last) { - GdkRegion *region; + GdkRectangle rect; gint row; if (!GTK_WIDGET_REALIZED (GTK_WIDGET (sheet))) return; @@ -4859,13 +4763,18 @@ draw_row_title_buttons_range (GtkSheet *sheet, gint first, gint last) g_return_if_fail (first >= min_visible_row (sheet)); g_return_if_fail (last <= max_visible_row (sheet)); + rect.x = 0; + rect.width = sheet->row_title_area.width; + rect.y = psppire_axis_start_pixel (sheet->vaxis, first) + CELL_SPACING; + rect.height = psppire_axis_start_pixel (sheet->vaxis, last) + CELL_SPACING + + psppire_axis_unit_size (sheet->vaxis, last); - region = - gdk_drawable_get_visible_region (GDK_DRAWABLE (sheet->row_title_window)); - - gdk_window_begin_paint_region (sheet->row_title_window, region); + rect.y -= sheet->vadjustment->value; + minimize_int (&rect.height, sheet->row_title_area.height); + maximize_int (&rect.y, 0); + gdk_window_begin_paint_rect (sheet->row_title_window, &rect); for (row = first; row <= last; ++row) { GdkRectangle allocation; @@ -4873,15 +4782,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_start_pixel (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); @@ -4897,6 +4806,40 @@ draw_row_title_buttons_range (GtkSheet *sheet, gint first, gint last) * vadjustment_value_changed * hadjustment_value_changed */ + +static void +update_adjustment (GtkAdjustment *adj, PsppireAxis *axis, gint page_size) +{ + double position = + (adj->value + adj->page_size) + / + (adj->upper - adj->lower); + + const glong last_item = psppire_axis_unit_count (axis) - 1; + + if (isnan (position) || position < 0) + position = 0; + + adj->upper = + psppire_axis_start_pixel (axis, last_item) + + + psppire_axis_unit_size (axis, last_item) + ; + + adj->lower = 0; + adj->page_size = page_size; + +#if 0 + adj->value = position * (adj->upper - adj->lower) - adj->page_size; + + if ( adj->value < adj->lower) + adj->value = adj->lower; +#endif + + gtk_adjustment_changed (adj); +} + + static void adjust_scrollbars (GtkSheet *sheet) { @@ -4915,50 +4858,34 @@ 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) - + - g_sheet_row_get_height (sheet->row_geometry, last_row) - ; - - sheet->vadjustment->lower = 0; - sheet->vadjustment->page_size = height; - - g_signal_emit_by_name (sheet->vadjustment, "changed"); + update_adjustment (sheet->vadjustment, sheet->vaxis, height); } if (sheet->hadjustment) { - gint last_col; + gint last_col = psppire_axis_unit_count (sheet->haxis) - 1; sheet->hadjustment->step_increment = 1; sheet->hadjustment->page_increment = width; - last_col = g_sheet_column_get_column_count (sheet->column_geometry) - 1; - sheet->hadjustment->upper = - g_sheet_column_start_pixel (sheet->column_geometry, last_col) + psppire_axis_start_pixel (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; - sheet->hadjustment->page_size = width; - - g_signal_emit_by_name (sheet->hadjustment, "changed"); + update_adjustment (sheet->hadjustment, sheet->haxis, width); } } @@ -4973,7 +4900,6 @@ vadjustment_value_changed (GtkAdjustment *adjustment, if ( ! GTK_WIDGET_REALIZED (sheet)) return; - gtk_widget_hide (sheet->entry_widget); region = @@ -4981,12 +4907,14 @@ vadjustment_value_changed (GtkAdjustment *adjustment, gdk_window_begin_paint_region (sheet->sheet_window, region); + draw_sheet_region (sheet, region); - gtk_sheet_range_draw (sheet, NULL); draw_row_title_buttons (sheet); // size_allocate_global_button (sheet); + gtk_sheet_draw_active_cell (sheet); gdk_window_end_paint (sheet->sheet_window); + gdk_region_destroy (region); } @@ -5009,11 +4937,16 @@ hadjustment_value_changed (GtkAdjustment *adjustment, gdk_window_begin_paint_region (sheet->sheet_window, region); - gtk_sheet_range_draw (sheet, NULL); + draw_sheet_region (sheet, region); + draw_column_title_buttons (sheet); // size_allocate_global_button (sheet); + gtk_sheet_draw_active_cell (sheet); + gdk_window_end_paint (sheet->sheet_window); + + gdk_region_destroy (region); } @@ -5026,7 +4959,6 @@ draw_xor_vline (GtkSheet *sheet) gdk_drawable_get_size (sheet->sheet_window, NULL, &height); - if (sheet->row_titles_visible) xpos += sheet->row_title_area.width; @@ -5067,12 +4999,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_start_pixel (sheet->haxis, range.col0); + area.y = psppire_axis_start_pixel (sheet->vaxis, range.row0); + area.width = psppire_axis_start_pixel (sheet->haxis, range.coli)- area.x+ + psppire_axis_unit_size (sheet->haxis, range.coli); + area.height = psppire_axis_start_pixel (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; @@ -5118,115 +5050,47 @@ draw_xor_rectangle (GtkSheet *sheet, GtkSheetRange range) } -/* this function returns the new width of the column being resized given - * the COLUMN and X position of the cursor; the x cursor position is passed - * in as a pointer and automaticaly corrected if it's outside the acceptable - * range */ -static guint -new_column_width (GtkSheet *sheet, gint column, gint *x) -{ - gint left_pos = g_sheet_column_start_pixel (sheet->column_geometry, column) - - sheet->hadjustment->value; - - gint width = *x - left_pos; - - if ( width < sheet->column_requisition) - { - width = sheet->column_requisition; - *x = left_pos + width; - } - - g_sheet_column_set_width (sheet->column_geometry, column, width); - - draw_column_title_buttons (sheet); - - return width; -} - -/* this function returns the new height of the row being resized given - * the row and y position of the cursor; the y cursor position is passed - * in as a pointer and automaticaly corrected if it's beyond min / max limits */ -static guint -new_row_height (GtkSheet *sheet, gint row, gint *y) -{ - gint height; - guint min_height; - - gint cy = *y; - min_height = sheet->row_requisition; - - /* you can't shrink a row to less than its minimum height */ - if (cy < g_sheet_row_start_pixel (sheet->row_geometry, row) + min_height) - - { - *y = cy = g_sheet_row_start_pixel (sheet->row_geometry, 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)); - if (height < min_height) - height = min_height; - - g_sheet_row_set_height (sheet->row_geometry, row, height); - draw_row_title_buttons (sheet); - - return height; -} - static void -gtk_sheet_set_column_width (GtkSheet *sheet, - gint column, - guint width) +set_column_width (GtkSheet *sheet, + gint column, + gint width) { - guint min_width; - g_return_if_fail (sheet != NULL); g_return_if_fail (GTK_IS_SHEET (sheet)); - if (column < 0 || column >= 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; - - g_sheet_column_set_width (sheet->column_geometry, column, width); + psppire_axis_resize (sheet->haxis, column, width); if (GTK_WIDGET_REALIZED (GTK_WIDGET (sheet))) { draw_column_title_buttons (sheet); adjust_scrollbars (sheet); gtk_sheet_size_allocate_entry (sheet); - gtk_sheet_range_draw (sheet, NULL); + redraw_range (sheet, NULL); } } - - static void -gtk_sheet_set_row_height (GtkSheet *sheet, - gint row, - guint height) +set_row_height (GtkSheet *sheet, + gint row, + gint height) { - guint min_height; - g_return_if_fail (sheet != NULL); g_return_if_fail (GTK_IS_SHEET (sheet)); - if (row < 0 || row >= 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; - - g_sheet_row_set_height (sheet->row_geometry, row, height); + psppire_axis_resize (sheet->vaxis, row, height); if (GTK_WIDGET_REALIZED (GTK_WIDGET (sheet)) ) { draw_row_title_buttons (sheet); adjust_scrollbars (sheet); gtk_sheet_size_allocate_entry (sheet); - gtk_sheet_range_draw (sheet, NULL); + redraw_range (sheet, NULL); } } @@ -5236,8 +5100,6 @@ gtk_sheet_get_attributes (const GtkSheet *sheet, gint row, gint col, { GdkColor *fg, *bg; const GtkJustification *j ; - const PangoFontDescription *font_desc ; - const GtkSheetCellBorder *border ; GdkColormap *colormap; g_return_val_if_fail (sheet != NULL, FALSE); @@ -5245,7 +5107,6 @@ gtk_sheet_get_attributes (const GtkSheet *sheet, gint row, gint col, if (row < 0 || col < 0) return FALSE; - attr->foreground = GTK_WIDGET (sheet)->style->black; attr->background = sheet->color[BG_COLOR]; @@ -5255,11 +5116,8 @@ gtk_sheet_get_attributes (const GtkSheet *sheet, gint row, gint col, attr->border.join_style = GDK_JOIN_MITER; attr->border.mask = 0; attr->border.color = GTK_WIDGET (sheet)->style->black; - attr->font_desc = GTK_WIDGET (sheet)->style->font_desc; attr->is_editable = g_sheet_model_is_editable (sheet->model, row, col); - attr->is_visible = g_sheet_model_is_visible (sheet->model, row, col); - colormap = gtk_widget_get_colormap (GTK_WIDGET (sheet)); fg = g_sheet_model_get_foreground (sheet->model, row, col); @@ -5277,19 +5135,12 @@ 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) attr->justification = *j; - font_desc = g_sheet_model_get_font_desc (sheet->model, row, col); - if ( font_desc ) attr->font_desc = font_desc; - - border = g_sheet_model_get_cell_border (sheet->model, row, col); - - if ( border ) attr->border = *border; - return TRUE; } @@ -5314,43 +5165,6 @@ gtk_sheet_button_size_request (GtkSheet *sheet, } -static void -gtk_sheet_row_size_request (GtkSheet *sheet, - gint row, - guint *requisition) -{ - GtkRequisition button_requisition; - - gtk_sheet_button_size_request (sheet, - g_sheet_row_get_button (sheet->row_geometry, row), - &button_requisition); - - *requisition = button_requisition.height; - - sheet->row_requisition = *requisition; -} - -static void -gtk_sheet_column_size_request (GtkSheet *sheet, - gint col, - guint *requisition) -{ - GtkRequisition button_requisition; - - GtkSheetButton *button = g_sheet_column_get_button (sheet->column_geometry, col); - - gtk_sheet_button_size_request (sheet, - button, - &button_requisition); - - gtk_sheet_button_free (button); - - *requisition = button_requisition.width; - - sheet->column_requisition = *requisition; -} - - static void gtk_sheet_forall (GtkContainer *container, gboolean include_internals, @@ -5364,8 +5178,8 @@ gtk_sheet_forall (GtkContainer *container, if (sheet->button && sheet->button->parent) (* callback) (sheet->button, callback_data); - if (sheet->entry_container && GTK_IS_CONTAINER (sheet->entry_container)) - (* callback) (sheet->entry_container, callback_data); + if (sheet->entry_widget && GTK_IS_CONTAINER (sheet->entry_widget)) + (* callback) (sheet->entry_widget, callback_data); } @@ -5401,7 +5215,6 @@ gtk_sheet_button_free (GtkSheetButton *button) g_free (button); } - static void append_cell_text (GString *string, const GtkSheet *sheet, gint r, gint c) { @@ -5421,7 +5234,7 @@ range_to_text (const GtkSheet *sheet) gint r, c; GString *string; - if ( !gtk_sheet_range_isvisible (sheet, sheet->range)) + if ( !gtk_sheet_range_isvisible (sheet, &sheet->range)) return NULL; string = g_string_sized_new (80); @@ -5447,7 +5260,7 @@ range_to_html (const GtkSheet *sheet) gint r, c; GString *string; - if ( !gtk_sheet_range_isvisible (sheet, sheet->range)) + if ( !gtk_sheet_range_isvisible (sheet, &sheet->range)) return NULL; string = g_string_sized_new (480); @@ -5538,7 +5351,7 @@ gtk_sheet_update_primary_selection (GtkSheet *sheet) clipboard = gtk_widget_get_clipboard (GTK_WIDGET (sheet), GDK_SELECTION_PRIMARY); - if (gtk_sheet_range_isvisible (sheet, sheet->range)) + if (gtk_sheet_range_isvisible (sheet, &sheet->range)) { if (!gtk_clipboard_set_with_owner (clipboard, targets, G_N_ELEMENTS (targets),