X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=lib%2Fgtksheet%2Fgtksheet.c;h=ec8e3840d6d0cc016954bf75060b1715534b216d;hb=c3ac5a8af9c449072c7e872ca70a78c1755ae309;hp=00978dd05abc3233e81aad11a0259cfb90c1d789;hpb=1f221ed321a915d7c9888fac08dcf34fde06cdc4;p=pspp-builds.git diff --git a/lib/gtksheet/gtksheet.c b/lib/gtksheet/gtksheet.c index 00978dd0..ec8e3840 100644 --- a/lib/gtksheet/gtksheet.c +++ b/lib/gtksheet/gtksheet.c @@ -1,5 +1,11 @@ -/* This version of GtkSheet has been *heavily* modified, for the specific - requirements of PSPPIRE. */ +/* + * Copyright (C) 2006, 2008 Free Software Foundation + * + * This version of GtkSheet has been *heavily* modified, for the specific + * requirements of PSPPIRE. The changes are copyright by the + * Free Software Foundation. The copyright notice for the original work is + * below. + */ /* GtkSheet widget for Gtk+. * Copyright (C) 1999-2001 Adrian E. Feiguin @@ -28,15 +34,8 @@ * * GtkSheet is a matrix widget for GTK+. It consists of an scrollable grid of * cells where you can allocate text. Cell contents can be edited interactively - * through a specially designed entry, GtkItemEntry. It is also a container - * subclass, allowing you to display buttons, curves, pixmaps and any other - * widgets in it. - * - * You can also set many attributes as: border, foreground and background color, - * text justification, and more. + * through a specially designed entry, GtkItemEntry. * - * The testgtksheet program shows how easy is to create a spreadsheet-like GUI - * using this widget. */ #include @@ -47,12 +46,8 @@ #include #include #include -#include #include #include -#include -#include -#include #include #include #include @@ -66,55 +61,45 @@ /* sheet flags */ enum { - GTK_SHEET_IS_LOCKED = 1 << 0, - GTK_SHEET_IS_FROZEN = 1 << 1, - GTK_SHEET_IN_XDRAG = 1 << 2, - GTK_SHEET_IN_YDRAG = 1 << 3, - GTK_SHEET_IN_DRAG = 1 << 4, - GTK_SHEET_IN_SELECTION = 1 << 5, - GTK_SHEET_IN_RESIZE = 1 << 6, - GTK_SHEET_IN_CLIP = 1 << 7, - GTK_SHEET_REDRAW_PENDING = 1 << 8, + GTK_SHEET_REDRAW_PENDING = 1 << 0, + GTK_SHEET_IN_XDRAG = 1 << 1, + GTK_SHEET_IN_YDRAG = 1 << 2, + GTK_SHEET_IN_DRAG = 1 << 3, + GTK_SHEET_IN_SELECTION = 1 << 4, + GTK_SHEET_IN_RESIZE = 1 << 5 }; #define GTK_SHEET_FLAGS(sheet) (GTK_SHEET (sheet)->flags) #define GTK_SHEET_SET_FLAGS(sheet,flag) (GTK_SHEET_FLAGS (sheet) |= (flag)) #define GTK_SHEET_UNSET_FLAGS(sheet,flag) (GTK_SHEET_FLAGS (sheet) &= ~ (flag)) -#define GTK_SHEET_IS_LOCKED(sheet) (GTK_SHEET_FLAGS (sheet) & GTK_SHEET_IS_LOCKED) - - -#define GTK_SHEET_IS_FROZEN(sheet) (GTK_SHEET_FLAGS (sheet) & GTK_SHEET_IS_FROZEN) #define GTK_SHEET_IN_XDRAG(sheet) (GTK_SHEET_FLAGS (sheet) & GTK_SHEET_IN_XDRAG) #define GTK_SHEET_IN_YDRAG(sheet) (GTK_SHEET_FLAGS (sheet) & GTK_SHEET_IN_YDRAG) #define GTK_SHEET_IN_DRAG(sheet) (GTK_SHEET_FLAGS (sheet) & GTK_SHEET_IN_DRAG) #define GTK_SHEET_IN_SELECTION(sheet) (GTK_SHEET_FLAGS (sheet) & GTK_SHEET_IN_SELECTION) #define GTK_SHEET_IN_RESIZE(sheet) (GTK_SHEET_FLAGS (sheet) & GTK_SHEET_IN_RESIZE) -#define GTK_SHEET_IN_CLIP(sheet) (GTK_SHEET_FLAGS (sheet) & GTK_SHEET_IN_CLIP) #define GTK_SHEET_REDRAW_PENDING(sheet) (GTK_SHEET_FLAGS (sheet) & GTK_SHEET_REDRAW_PENDING) #define CELL_SPACING 1 -#define DRAG_WIDTH 6 -#define TIMEOUT_FLASH 200 + #define TIMEOUT_HOVER 300 -#define TIME_INTERVAL 8 #define COLUMN_MIN_WIDTH 10 -#define MINROWS 1 -#define MINCOLS 1 -#define MAXLENGTH 30 -#define CELLOFFSET 4 +#define COLUMN_TITLES_HEIGHT 4 #define DEFAULT_COLUMN_WIDTH 80 - +static void gtk_sheet_update_primary_selection (GtkSheet *sheet); static void gtk_sheet_column_title_button_draw (GtkSheet *sheet, gint column); static void gtk_sheet_row_title_button_draw (GtkSheet *sheet, gint row); -static gboolean gtk_sheet_cell_empty (const GtkSheet *sheet, gint row, gint col); +static gboolean gtk_sheet_cell_empty (const GtkSheet *, gint, gint); -static inline -void dispose_string (const GtkSheet *sheet, gchar *text) +static void destroy_hover_window (GtkSheetHoverTitle *); +static GtkSheetHoverTitle *create_hover_window (void); + +static inline void +dispose_string (const GtkSheet *sheet, gchar *text) { GSheetModel *model = gtk_sheet_get_model (sheet); @@ -136,10 +121,13 @@ guint DEFAULT_ROW_HEIGHT (GtkWidget *widget) pango_context_get_metrics (context, widget->style->font_desc, pango_context_get_language (context)); + guint val = pango_font_metrics_get_descent (metrics) + pango_font_metrics_get_ascent (metrics); + pango_font_metrics_unref (metrics); - return PANGO_PIXELS (val)+2 * CELLOFFSET; + + return PANGO_PIXELS (val) + 2 * COLUMN_TITLES_HEIGHT; } } @@ -172,7 +160,7 @@ guint STRING_WIDTH (GtkWidget *widget, pango_layout_get_extents (layout, NULL, &rect); - g_object_unref (G_OBJECT (layout)); + g_object_unref (layout); return PANGO_PIXELS (rect.width); } @@ -194,306 +182,85 @@ guint DEFAULT_FONT_DESCENT (GtkWidget *widget) } -static gint -yyy_row_is_visible (const GtkSheet *sheet, gint row) -{ - GSheetRow *row_geo = sheet->row_geometry; - - return g_sheet_row_get_visibility (row_geo, row, 0); -} - - -static gint -yyy_row_is_sensitive (const GtkSheet *sheet, gint row) -{ - GSheetRow *row_geo = sheet->row_geometry; - - return g_sheet_row_get_sensitivity (row_geo, row, 0); -} - - - -static inline gint -yyy_row_count (const GtkSheet *sheet) -{ - GSheetRow *row_geo = sheet->row_geometry; - - return g_sheet_row_get_row_count (row_geo, 0); -} - -static inline gint -yyy_row_height (const GtkSheet *sheet, gint row) -{ - GSheetRow *row_geo = sheet->row_geometry; - - return g_sheet_row_get_height (row_geo, row, 0); -} - -static gint -yyy_row_top_ypixel (const GtkSheet *sheet, gint row) -{ - GSheetRow *geo = sheet->row_geometry; - - gint y = g_sheet_row_start_pixel (geo, row, 0); - - if ( sheet->column_titles_visible ) - y += sheet->column_title_area.height; - - return y; -} - - /* Return the row containing pixel Y */ static gint yyy_row_ypixel_to_row (const GtkSheet *sheet, gint y) { GSheetRow *geo = sheet->row_geometry; - gint cy = sheet->voffset; - - if (sheet->column_titles_visible) - cy += sheet->column_title_area.height; - - if (y < cy) return 0; - - return g_sheet_row_pixel_to_row (geo, y - cy, 0); -} - - -/* gives the top pixel of the given row in context of - * the sheet's voffset */ -static inline gint -ROW_TOP_YPIXEL (const GtkSheet *sheet, gint row) -{ - return (sheet->voffset + yyy_row_top_ypixel (sheet, row)); -} - - -/* returns the row index from a y pixel location in the - * context of the sheet's voffset */ -static inline gint -ROW_FROM_YPIXEL (const GtkSheet *sheet, gint y) -{ - return (yyy_row_ypixel_to_row (sheet, y)); -} - -static inline GtkSheetButton * -xxx_column_button (const GtkSheet *sheet, gint col) -{ - GSheetColumn *col_geo = sheet->column_geometry; - if ( col < 0 ) return NULL ; - - return g_sheet_column_get_button (col_geo, col); -} - - -static inline gint -xxx_column_left_xpixel (const GtkSheet *sheet, gint col) -{ - GSheetColumn *geo = sheet->column_geometry; - - gint x = g_sheet_column_start_pixel (geo, col); - - if ( sheet->row_titles_visible ) - x += sheet->row_title_area.width; - - return x; -} - -static inline gint -xxx_column_width (const GtkSheet *sheet, gint col) -{ - GSheetColumn *col_geo = sheet->column_geometry; - - return g_sheet_column_get_width (col_geo, col); -} - - -static inline void -xxx_set_column_width (GtkSheet *sheet, gint col, gint width) -{ - if ( sheet->column_geometry ) - g_sheet_column_set_width (sheet->column_geometry, col, width); -} - -static inline void -xxx_column_set_left_column (GtkSheet *sheet, gint col, gint i) -{ - GSheetColumn *col_geo = sheet->column_geometry; - - g_sheet_column_set_left_text_column (col_geo, col, i); -} - -static inline gint -xxx_column_left_column (const GtkSheet *sheet, gint col) -{ - GSheetColumn *col_geo = sheet->column_geometry; - - return g_sheet_column_get_left_text_column (col_geo, col); -} - -static inline void -xxx_column_set_right_column (GtkSheet *sheet, gint col, gint i) -{ - GSheetColumn *col_geo = sheet->column_geometry; - - g_sheet_column_set_right_text_column (col_geo, col, i); -} - -static inline gint -xxx_column_right_column (const GtkSheet *sheet, gint col) -{ - GSheetColumn *col_geo = sheet->column_geometry; - - return g_sheet_column_get_right_text_column (col_geo, col); -} - -static inline GtkJustification -xxx_column_justification (const GtkSheet *sheet, gint col) -{ - GSheetColumn *col_geo = sheet->column_geometry; + if (y < 0) return -1; - return g_sheet_column_get_justification (col_geo, col); + return g_sheet_row_pixel_to_row (geo, y); } -static inline gint -xxx_column_is_visible (const GtkSheet *sheet, gint col) -{ - GSheetColumn *col_geo = sheet->column_geometry; - - return g_sheet_column_get_visibility (col_geo, col); -} +#define MIN_VISIBLE_ROW(sheet) yyy_row_ypixel_to_row (sheet, sheet->vadjustment->value) -static inline gint -xxx_column_is_sensitive (const GtkSheet *sheet, gint col) -{ - GSheetColumn *col_geo = sheet->column_geometry; +#define MAX_VISIBLE_ROW(sheet) \ + yyy_row_ypixel_to_row (sheet, sheet->vadjustment->value + sheet->vadjustment->page_size) - return g_sheet_column_get_sensitivity (col_geo, col); -} +#define MIN_VISIBLE_COLUMN(sheet) COLUMN_FROM_XPIXEL (sheet, sheet->hadjustment->value) +#define MAX_VISIBLE_COLUMN(sheet) \ + COLUMN_FROM_XPIXEL (sheet, sheet->hadjustment->value + sheet->hadjustment->page_size) /* gives the left pixel of the given column in context of * the sheet's hoffset */ static inline gint COLUMN_LEFT_XPIXEL (const GtkSheet *sheet, gint ncol) { - return (sheet->hoffset + xxx_column_left_xpixel (sheet, ncol)); + return g_sheet_column_start_pixel (sheet->column_geometry, ncol); } -static inline gint -xxx_column_count (const GtkSheet *sheet) -{ - GSheetColumn *col_geo = sheet->column_geometry; - - return g_sheet_column_get_column_count (col_geo); -} -/* returns the column index from a x pixel location in the - * context of the sheet's hoffset */ +/* returns the column index from a x pixel location */ static inline gint -COLUMN_FROM_XPIXEL (const GtkSheet * sheet, - gint x) +COLUMN_FROM_XPIXEL (const GtkSheet *sheet, gint x) { - gint i, cx; - - cx = sheet->hoffset; - if ( sheet->row_titles_visible ) - cx += sheet->row_title_area.width; + gint i; + gint cx = 0; - if (x < cx) return 0; - for (i = 0; i < xxx_column_count (sheet); i++) + if (x < 0) return -1; + for (i = 0; + i < g_sheet_column_get_column_count (sheet->column_geometry); i++) { - if (x >= cx && x <= (cx + xxx_column_width (sheet, i)) && - xxx_column_is_visible (sheet, i)) + if (x >= cx && + x <= (cx + g_sheet_column_get_width (sheet->column_geometry, i)) && + g_sheet_column_get_visibility (sheet->column_geometry, i)) return i; - if ( xxx_column_is_visible (sheet, i)) - cx += xxx_column_width (sheet, i); + if ( g_sheet_column_get_visibility (sheet->column_geometry, i)) + cx += g_sheet_column_get_width (sheet->column_geometry, i); } /* no match */ - return xxx_column_count (sheet) - 1; -} - -/* returns the total height of the sheet */ -static inline gint SHEET_HEIGHT (GtkSheet *sheet) -{ - const gint n_rows = yyy_row_count (sheet); - - return yyy_row_top_ypixel (sheet, n_rows - 1) + - yyy_row_height (sheet, n_rows - 1); -} - - -static inline GtkSheetButton * -yyy_row_button (GtkSheet *sheet, gint row) -{ - GSheetRow *row_geo = sheet->row_geometry; - - return g_sheet_row_get_button (row_geo, row, sheet); + return g_sheet_column_get_column_count (sheet->column_geometry) - 1; } +/* The size of the region (in pixels) around the row/column boundaries + where the height/width may be grabbed to change size */ +#define DRAG_WIDTH 6 - - -static inline void -yyy_set_row_height (GtkSheet *sheet, gint row, gint height) +static gboolean +on_column_boundary (const GtkSheet *sheet, gint x, gint *column) { - if ( sheet->row_geometry ) - g_sheet_row_set_height (sheet->row_geometry, row, height, sheet); -} + gint col; + x += sheet->hadjustment->value; + col = COLUMN_FROM_XPIXEL (sheet, x); -/* returns the total width of the sheet */ -static inline gint SHEET_WIDTH (GtkSheet *sheet) + if ( COLUMN_FROM_XPIXEL (sheet, x - DRAG_WIDTH / 2) < col ) { - gint i,cx; - - cx = ( sheet->row_titles_visible ? sheet->row_title_area.width : 0); - - for (i = 0; i < xxx_column_count (sheet); i++) - if (xxx_column_is_visible (sheet, i)) - cx += xxx_column_width (sheet, i); - - return cx; + *column = col - 1; + return TRUE; } -#define MIN_VISIBLE_ROW(sheet) \ - ROW_FROM_YPIXEL (sheet, sheet->column_title_area.height + 1) - -#define MAX_VISIBLE_ROW(sheet) \ - ROW_FROM_YPIXEL (sheet, sheet->sheet_window_height - 1) - -#define MIN_VISIBLE_COLUMN(sheet) \ - COLUMN_FROM_XPIXEL (sheet, sheet->row_title_area.width + 1) - -#define MAX_VISIBLE_COLUMN(sheet) \ - COLUMN_FROM_XPIXEL (sheet, sheet->sheet_window_width) - - - -static inline gboolean -POSSIBLE_XDRAG (const GtkSheet *sheet, gint x, gint *drag_column) -{ - gint column, xdrag; - - column = COLUMN_FROM_XPIXEL (sheet, x); - *drag_column = column; - - xdrag = COLUMN_LEFT_XPIXEL (sheet, column) + CELL_SPACING; - if (x <= xdrag + DRAG_WIDTH / 2 && column != 0) + if ( COLUMN_FROM_XPIXEL (sheet, x + DRAG_WIDTH / 2) > col ) { - while (! xxx_column_is_visible (sheet, column - 1) && column > 0) column--; - *drag_column = column - 1; - return xxx_column_is_sensitive (sheet, column - 1); + *column = col; + return TRUE; } - xdrag += xxx_column_width (sheet, column); - if (x >= xdrag - DRAG_WIDTH / 2 && x <= xdrag + DRAG_WIDTH / 2) - return xxx_column_is_sensitive (sheet, column); - return FALSE; } @@ -501,22 +268,23 @@ static inline gboolean POSSIBLE_YDRAG (const GtkSheet *sheet, gint y, gint *drag_row) { gint row, ydrag; - row = ROW_FROM_YPIXEL (sheet, y); + + y += sheet->vadjustment->value; + row = yyy_row_ypixel_to_row (sheet, y); *drag_row = row; - ydrag = ROW_TOP_YPIXEL (sheet,row)+CELL_SPACING; + ydrag = g_sheet_row_start_pixel (sheet->row_geometry, row) + CELL_SPACING; if (y <= ydrag + DRAG_WIDTH / 2 && row != 0) { - while (!yyy_row_is_visible (sheet, row - 1) && row > 0) row--; + while (!g_sheet_row_get_visibility (sheet->row_geometry, row - 1) && row > 0) row--; *drag_row = row - 1; - return yyy_row_is_sensitive (sheet, row - 1); + return g_sheet_row_get_sensitivity (sheet->row_geometry, row - 1); } - ydrag +=yyy_row_height (sheet, row); + ydrag += g_sheet_row_get_height (sheet->row_geometry, row); if (y >= ydrag - DRAG_WIDTH / 2 && y <= ydrag + DRAG_WIDTH / 2) - return yyy_row_is_sensitive (sheet, row); - + return g_sheet_row_get_sensitivity (sheet->row_geometry, row); return FALSE; } @@ -533,20 +301,20 @@ POSSIBLE_DRAG (const GtkSheet *sheet, gint x, gint y, return FALSE; *drag_column = COLUMN_FROM_XPIXEL (sheet, x); - *drag_row = ROW_FROM_YPIXEL (sheet, y); + *drag_row = yyy_row_ypixel_to_row (sheet, y); if (x >= COLUMN_LEFT_XPIXEL (sheet, sheet->range.col0) - DRAG_WIDTH / 2 && x <= COLUMN_LEFT_XPIXEL (sheet, sheet->range.coli) + - xxx_column_width (sheet, sheet->range.coli) + DRAG_WIDTH / 2) + g_sheet_column_get_width (sheet->column_geometry, sheet->range.coli) + DRAG_WIDTH / 2) { - ydrag = ROW_TOP_YPIXEL (sheet,sheet->range.row0); + ydrag = g_sheet_row_start_pixel (sheet->row_geometry, sheet->range.row0); if (y >= ydrag - DRAG_WIDTH / 2 && y <= ydrag + DRAG_WIDTH / 2) { *drag_row = sheet->range.row0; return TRUE; } - ydrag = ROW_TOP_YPIXEL (sheet, sheet->range.rowi) + - yyy_row_height (sheet, sheet->range.rowi); + ydrag = g_sheet_row_start_pixel (sheet->row_geometry, sheet->range.rowi) + + g_sheet_row_get_height (sheet->row_geometry, sheet->range.rowi); if (y >= ydrag - DRAG_WIDTH / 2 && y <= ydrag + DRAG_WIDTH / 2) { *drag_row = sheet->range.rowi; @@ -554,9 +322,9 @@ POSSIBLE_DRAG (const GtkSheet *sheet, gint x, gint y, } } - if (y >= ROW_TOP_YPIXEL (sheet, sheet->range.row0) - DRAG_WIDTH / 2 && - y <= ROW_TOP_YPIXEL (sheet, sheet->range.rowi) + - yyy_row_height (sheet, sheet->range.rowi) + DRAG_WIDTH / 2) + 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) { xdrag = COLUMN_LEFT_XPIXEL (sheet, sheet->range.col0); if (x >= xdrag - DRAG_WIDTH / 2 && x <= xdrag + DRAG_WIDTH / 2) @@ -565,7 +333,7 @@ POSSIBLE_DRAG (const GtkSheet *sheet, gint x, gint y, return TRUE; } xdrag = COLUMN_LEFT_XPIXEL (sheet, sheet->range.coli) + - xxx_column_width (sheet, sheet->range.coli); + g_sheet_column_get_width (sheet->column_geometry, sheet->range.coli); if (x >= xdrag - DRAG_WIDTH / 2 && x <= xdrag + DRAG_WIDTH / 2) { *drag_column = sheet->range.coli; @@ -587,20 +355,20 @@ POSSIBLE_RESIZE (const GtkSheet *sheet, gint x, gint y, sheet->range.col0 < 0 || sheet->range.coli < 0 ) return FALSE; - xdrag = COLUMN_LEFT_XPIXEL (sheet,sheet->range.coli)+ - xxx_column_width (sheet, sheet->range.coli); + xdrag = COLUMN_LEFT_XPIXEL (sheet, sheet->range.coli)+ + g_sheet_column_get_width (sheet->column_geometry, sheet->range.coli); - ydrag = ROW_TOP_YPIXEL (sheet,sheet->range.rowi)+ - yyy_row_height (sheet, sheet->range.rowi); + ydrag = g_sheet_row_start_pixel (sheet->row_geometry, sheet->range.rowi) + + g_sheet_row_get_height (sheet->row_geometry, sheet->range.rowi); if (sheet->state == GTK_SHEET_COLUMN_SELECTED) - ydrag = ROW_TOP_YPIXEL (sheet, MIN_VISIBLE_ROW (sheet)); + ydrag = g_sheet_row_start_pixel (sheet->row_geometry, MIN_VISIBLE_ROW (sheet)); if (sheet->state == GTK_SHEET_ROW_SELECTED) xdrag = COLUMN_LEFT_XPIXEL (sheet, MIN_VISIBLE_COLUMN (sheet)); - *drag_column = COLUMN_FROM_XPIXEL (sheet,x); - *drag_row = ROW_FROM_YPIXEL (sheet,y); + *drag_column = COLUMN_FROM_XPIXEL (sheet, x); + *drag_row = yyy_row_ypixel_to_row (sheet, y); if (x >= xdrag - DRAG_WIDTH / 2 && x <= xdrag + DRAG_WIDTH / 2 && y >= ydrag - DRAG_WIDTH / 2 && y <= ydrag + DRAG_WIDTH / 2) return TRUE; @@ -610,7 +378,7 @@ POSSIBLE_RESIZE (const GtkSheet *sheet, gint x, gint y, static void gtk_sheet_class_init (GtkSheetClass * klass); static void gtk_sheet_init (GtkSheet * sheet); -static void gtk_sheet_destroy (GtkObject * object); +static void gtk_sheet_dispose (GObject * object); static void gtk_sheet_finalize (GObject * object); static void gtk_sheet_style_set (GtkWidget *widget, GtkStyle *previous_style); @@ -635,6 +403,8 @@ static gint gtk_sheet_button_release (GtkWidget * widget, GdkEventButton * event); static gint gtk_sheet_motion (GtkWidget * widget, GdkEventMotion * event); +static gboolean gtk_sheet_crossing_notify (GtkWidget *widget, + GdkEventCrossing *event); static gint gtk_sheet_entry_key_press (GtkWidget *widget, GdkEventKey *key); static gint gtk_sheet_key_press (GtkWidget *widget, @@ -646,14 +416,10 @@ static void gtk_sheet_size_allocate (GtkWidget * widget, /* Sheet queries */ -static gint gtk_sheet_range_isvisible (GtkSheet * sheet, - GtkSheetRange range); -static gint gtk_sheet_cell_isvisible (GtkSheet * sheet, - gint row, gint column); -/* Clipped Range */ - -static gint gtk_sheet_flash (gpointer data); - +static gboolean gtk_sheet_range_isvisible (const GtkSheet * sheet, + GtkSheetRange range); +static gboolean gtk_sheet_cell_isvisible (GtkSheet * sheet, + gint row, gint column); /* Drawing Routines */ /* draw cell background and frame */ @@ -686,15 +452,12 @@ static void gtk_sheet_new_selection (GtkSheet *sheet, GtkSheetRange *range); static void gtk_sheet_draw_border (GtkSheet *sheet, GtkSheetRange range); -static void gtk_sheet_draw_corners (GtkSheet *sheet, - GtkSheetRange range); - /* Active Cell handling */ static void gtk_sheet_entry_changed (GtkWidget *widget, gpointer data); -static gboolean gtk_sheet_deactivate_cell (GtkSheet *sheet); +static void gtk_sheet_deactivate_cell (GtkSheet *sheet); static void gtk_sheet_hide_active_cell (GtkSheet *sheet); static gboolean gtk_sheet_activate_cell (GtkSheet *sheet, gint row, gint col); @@ -707,8 +470,8 @@ static void gtk_sheet_click_cell (GtkSheet *sheet, /* Backing Pixmap */ -static void gtk_sheet_make_backing_pixmap (GtkSheet *sheet, - guint width, guint height); +static void gtk_sheet_make_backing_pixmap (GtkSheet *sheet); + static void gtk_sheet_draw_backing_pixmap (GtkSheet *sheet, GtkSheetRange range); /* Scrollbars */ @@ -724,8 +487,7 @@ static void draw_xor_vline (GtkSheet * sheet); static void draw_xor_hline (GtkSheet * sheet); static void draw_xor_rectangle (GtkSheet *sheet, GtkSheetRange range); -static void gtk_sheet_draw_flashing_range (GtkSheet *sheet, - GtkSheetRange range); + static guint new_column_width (GtkSheet * sheet, gint column, gint * x); @@ -755,7 +517,8 @@ static void gtk_sheet_button_size_request (GtkSheet *sheet, GtkRequisition *requisition); /* Attributes routines */ -static void init_attributes (const GtkSheet *sheet, gint col, +static void init_attributes (const GtkSheet *sheet, + gint col, GtkSheetCellAttr *attributes); @@ -768,16 +531,6 @@ static void gtk_sheet_real_cell_clear (GtkSheet *sheet, gint column); -/* Container Functions */ -static void gtk_sheet_remove (GtkContainer *container, - GtkWidget *widget); -static void gtk_sheet_realize_child (GtkSheet *sheet, - GtkSheetChild *child); -static void gtk_sheet_position_child (GtkSheet *sheet, - GtkSheetChild *child); -static void gtk_sheet_position_children (GtkSheet *sheet); -static void gtk_sheet_child_show (GtkSheetChild *child); -static void gtk_sheet_child_hide (GtkSheetChild *child); static void gtk_sheet_column_size_request (GtkSheet *sheet, gint col, guint *requisition); @@ -797,18 +550,15 @@ enum SELECT_COLUMN, DOUBLE_CLICK_ROW, DOUBLE_CLICK_COLUMN, + BUTTON_EVENT_ROW, + BUTTON_EVENT_COLUMN, SELECT_RANGE, - CLIP_RANGE, RESIZE_RANGE, MOVE_RANGE, TRAVERSE, DEACTIVATE, ACTIVATE, - SET_CELL, - CLEAR_CELL, CHANGED, - NEW_COL_WIDTH, - NEW_ROW_HEIGHT, LAST_SIGNAL }; @@ -836,8 +586,9 @@ gtk_sheet_get_type () (GInstanceInitFunc) gtk_sheet_init, NULL, }; + sheet_type = - g_type_register_static (GTK_TYPE_CONTAINER, "GtkSheet", + g_type_register_static (GTK_TYPE_BIN, "GtkSheet", &sheet_info, 0); } return sheet_type; @@ -881,17 +632,106 @@ gtk_sheet_range_get_type (void) return sheet_range_type; } + +static void column_titles_changed (GtkWidget *w, gint first, gint n_columns, + gpointer data); + +/* Properties */ +enum + { + PROP_0, + PROP_ROW_GEO, + PROP_COL_GEO, + PROP_MODEL + }; + +static void +gtk_sheet_set_row_geometry (GtkSheet *sheet, GSheetRow *geo) +{ + if ( sheet->row_geometry ) g_object_unref (sheet->row_geometry); + + sheet->row_geometry = geo; + + if ( sheet->row_geometry ) g_object_ref (sheet->row_geometry); +} + +static void +gtk_sheet_set_column_geometry (GtkSheet *sheet, GSheetColumn *geo) +{ + if ( sheet->column_geometry ) g_object_unref (sheet->column_geometry); + + sheet->column_geometry = geo; + + if ( sheet->column_geometry ) g_object_ref (sheet->column_geometry); +} + + +static void +gtk_sheet_set_property (GObject *object, + guint prop_id, + const GValue *value, + GParamSpec *pspec) + +{ + GtkSheet *sheet = GTK_SHEET (object); + + switch (prop_id) + { + case PROP_ROW_GEO: + gtk_sheet_set_row_geometry (sheet, g_value_get_pointer (value)); + break; + case PROP_COL_GEO: + gtk_sheet_set_column_geometry (sheet, g_value_get_pointer (value)); + if ( sheet->column_geometry) + g_signal_connect (sheet->column_geometry, "columns_changed", + G_CALLBACK (column_titles_changed), sheet); + break; + case PROP_MODEL: + gtk_sheet_set_model (sheet, g_value_get_pointer (value)); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + }; +} + +static void +gtk_sheet_get_property (GObject *object, + guint prop_id, + GValue *value, + GParamSpec *pspec) +{ + GtkSheet *sheet = GTK_SHEET (object); + + switch (prop_id) + { + case PROP_ROW_GEO: + g_value_set_pointer (value, sheet->row_geometry); + break; + case PROP_COL_GEO: + g_value_set_pointer (value, sheet->column_geometry); + break; + case PROP_MODEL: + g_value_set_pointer (value, sheet->model); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + }; +} + + static void gtk_sheet_class_init (GtkSheetClass * klass) { - GtkObjectClass *object_class; - GtkWidgetClass *widget_class; - GtkContainerClass *container_class; - GObjectClass *gobject_class = G_OBJECT_CLASS (klass); + GObjectClass *object_class = G_OBJECT_CLASS (klass); - object_class = (GtkObjectClass *) klass; - widget_class = (GtkWidgetClass *) klass; - container_class = (GtkContainerClass *) klass; + GParamSpec *row_geo_spec ; + GParamSpec *col_geo_spec ; + GParamSpec *model_spec ; + + GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass); + GtkContainerClass *container_class = GTK_CONTAINER_CLASS (klass); parent_class = g_type_class_peek_parent (klass); @@ -908,7 +748,7 @@ gtk_sheet_class_init (GtkSheetClass * klass) G_SIGNAL_RUN_LAST, offsetof (GtkSheetClass, select_row), NULL, NULL, - gtkextra_VOID__INT, + g_cclosure_marshal_VOID__INT, G_TYPE_NONE, 1, G_TYPE_INT); @@ -927,14 +767,14 @@ gtk_sheet_class_init (GtkSheetClass * klass) G_SIGNAL_RUN_LAST, offsetof (GtkSheetClass, select_column), NULL, NULL, - gtkextra_VOID__INT, + g_cclosure_marshal_VOID__INT, G_TYPE_NONE, 1, G_TYPE_INT); /** - * GtkSheet::double - click - row + * GtkSheet::double-click-row * @sheet: the sheet widget that emitted the signal * @row: the row that was double clicked. * @@ -946,14 +786,14 @@ gtk_sheet_class_init (GtkSheetClass * klass) G_SIGNAL_RUN_LAST, 0, NULL, NULL, - gtkextra_VOID__INT, + g_cclosure_marshal_VOID__INT, G_TYPE_NONE, 1, G_TYPE_INT); /** - * GtkSheet::double - click - column + * GtkSheet::double-click-column * @sheet: the sheet widget that emitted the signal * @column: the column that was double clicked. * @@ -965,35 +805,66 @@ gtk_sheet_class_init (GtkSheetClass * klass) G_SIGNAL_RUN_LAST, 0, NULL, NULL, - gtkextra_VOID__INT, + g_cclosure_marshal_VOID__INT, G_TYPE_NONE, 1, G_TYPE_INT); - sheet_signals[SELECT_RANGE] = - g_signal_new ("select-range", + /** + * GtkSheet::button-event-column + * @sheet: the sheet widget that emitted the signal + * @column: the column on which the event occured. + * + * A button event occured on a column title button + */ + sheet_signals[BUTTON_EVENT_COLUMN] = + g_signal_new ("button-event-column", G_TYPE_FROM_CLASS (object_class), G_SIGNAL_RUN_LAST, - offsetof (GtkSheetClass, select_range), + 0, NULL, NULL, - gtkextra_VOID__BOXED, + gtkextra_VOID__INT_POINTER, G_TYPE_NONE, - 1, - GTK_TYPE_SHEET_RANGE); + 2, + G_TYPE_INT, + G_TYPE_POINTER + ); + + + /** + * GtkSheet::button-event-row + * @sheet: the sheet widget that emitted the signal + * @column: the column on which the event occured. + * + * A button event occured on a row title button + */ + sheet_signals[BUTTON_EVENT_ROW] = + g_signal_new ("button-event-row", + G_TYPE_FROM_CLASS (object_class), + G_SIGNAL_RUN_LAST, + 0, + NULL, NULL, + gtkextra_VOID__INT_POINTER, + G_TYPE_NONE, + 2, + G_TYPE_INT, + G_TYPE_POINTER + ); - sheet_signals[CLIP_RANGE] = - g_signal_new ("clip-range", + sheet_signals[SELECT_RANGE] = + g_signal_new ("select-range", G_TYPE_FROM_CLASS (object_class), G_SIGNAL_RUN_LAST, - offsetof (GtkSheetClass, clip_range), + offsetof (GtkSheetClass, select_range), NULL, NULL, - gtkextra_VOID__BOXED, + g_cclosure_marshal_VOID__BOXED, G_TYPE_NONE, 1, GTK_TYPE_SHEET_RANGE); + sheet_signals[RESIZE_RANGE] = g_signal_new ("resize-range", G_TYPE_FROM_CLASS (object_class), @@ -1035,8 +906,8 @@ gtk_sheet_class_init (GtkSheetClass * klass) G_SIGNAL_RUN_LAST, offsetof (GtkSheetClass, deactivate), NULL, NULL, - gtkextra_BOOLEAN__INT_INT, - G_TYPE_BOOLEAN, 2, G_TYPE_INT, G_TYPE_INT); + gtkextra_VOID__INT_INT, + G_TYPE_NONE, 2, G_TYPE_INT, G_TYPE_INT); sheet_signals[ACTIVATE] = g_signal_new ("activate", @@ -1047,68 +918,67 @@ gtk_sheet_class_init (GtkSheetClass * klass) gtkextra_BOOLEAN__INT_INT, G_TYPE_BOOLEAN, 2, G_TYPE_INT, G_TYPE_INT); - sheet_signals[SET_CELL] = - g_signal_new ("set-cell", + sheet_signals[CHANGED] = + g_signal_new ("changed", G_TYPE_FROM_CLASS (object_class), G_SIGNAL_RUN_LAST, - offsetof (GtkSheetClass, set_cell), + offsetof (GtkSheetClass, changed), NULL, NULL, gtkextra_VOID__INT_INT, G_TYPE_NONE, 2, G_TYPE_INT, G_TYPE_INT); - - sheet_signals[CLEAR_CELL] = - g_signal_new ("clear-cell", + widget_class->set_scroll_adjustments_signal = + g_signal_new ("set-scroll-adjustments", G_TYPE_FROM_CLASS (object_class), G_SIGNAL_RUN_LAST, - offsetof (GtkSheetClass, clear_cell), + offsetof (GtkSheetClass, set_scroll_adjustments), NULL, NULL, - gtkextra_VOID__INT_INT, - G_TYPE_NONE, 2, G_TYPE_INT, G_TYPE_INT); + gtkextra_VOID__OBJECT_OBJECT, + G_TYPE_NONE, 2, GTK_TYPE_ADJUSTMENT, GTK_TYPE_ADJUSTMENT); - sheet_signals[CHANGED] = - g_signal_new ("changed", - G_TYPE_FROM_CLASS (object_class), - G_SIGNAL_RUN_LAST, - offsetof (GtkSheetClass, changed), - NULL, NULL, - gtkextra_VOID__INT_INT, - G_TYPE_NONE, 2, G_TYPE_INT, G_TYPE_INT); - sheet_signals[NEW_COL_WIDTH] = - g_signal_new ("new-column-width", - G_TYPE_FROM_CLASS (object_class), - G_SIGNAL_RUN_LAST, - offsetof (GtkSheetClass, new_column_width), /*!!!! */ - NULL, NULL, - gtkextra_VOID__INT_INT, - G_TYPE_NONE, 2, G_TYPE_INT, G_TYPE_INT); + container_class->add = NULL; + container_class->remove = NULL; + container_class->forall = gtk_sheet_forall; - sheet_signals[NEW_ROW_HEIGHT] = - g_signal_new ("new-row-height", - G_TYPE_FROM_CLASS (object_class), - G_SIGNAL_RUN_LAST, - offsetof (GtkSheetClass, new_row_height), /*!!!! */ - NULL, NULL, - gtkextra_VOID__INT_INT, - G_TYPE_NONE, 2, G_TYPE_INT, G_TYPE_INT); + object_class->dispose = gtk_sheet_dispose; + object_class->finalize = gtk_sheet_finalize; - widget_class->set_scroll_adjustments_signal = - g_signal_new ("set-scroll-adjustments", - G_TYPE_FROM_CLASS (object_class), - G_SIGNAL_RUN_LAST, - offsetof (GtkSheetClass, set_scroll_adjustments), - NULL, NULL, - gtkextra_VOID__OBJECT_OBJECT, - G_TYPE_NONE, 2, GTK_TYPE_ADJUSTMENT, GTK_TYPE_ADJUSTMENT); + row_geo_spec = + g_param_spec_pointer ("row-geometry", + "Row Geometry", + "A pointer to the model of the row geometry", + G_PARAM_READABLE | G_PARAM_WRITABLE ); - container_class->add = NULL; - container_class->remove = gtk_sheet_remove; - container_class->forall = gtk_sheet_forall; + col_geo_spec = + g_param_spec_pointer ("column-geometry", + "Column Geometry", + "A pointer to the model of the column geometry", + G_PARAM_READABLE | G_PARAM_WRITABLE ); + + model_spec = + g_param_spec_pointer ("model", + "Model", + "A pointer to the data model", + G_PARAM_READABLE | G_PARAM_WRITABLE ); + + + object_class->set_property = gtk_sheet_set_property; + object_class->get_property = gtk_sheet_get_property; + + g_object_class_install_property (object_class, + PROP_ROW_GEO, + row_geo_spec); + + g_object_class_install_property (object_class, + PROP_COL_GEO, + col_geo_spec); + + g_object_class_install_property (object_class, + PROP_MODEL, + model_spec); - object_class->destroy = gtk_sheet_destroy; - gobject_class->finalize = gtk_sheet_finalize; widget_class->realize = gtk_sheet_realize; widget_class->unrealize = gtk_sheet_unrealize; @@ -1118,6 +988,8 @@ gtk_sheet_class_init (GtkSheetClass * klass) widget_class->button_press_event = gtk_sheet_button_press; widget_class->button_release_event = gtk_sheet_button_release; widget_class->motion_notify_event = gtk_sheet_motion; + widget_class->enter_notify_event = gtk_sheet_crossing_notify; + widget_class->leave_notify_event = gtk_sheet_crossing_notify; widget_class->key_press_event = gtk_sheet_key_press; widget_class->expose_event = gtk_sheet_expose; widget_class->size_request = gtk_sheet_size_request; @@ -1129,28 +1001,23 @@ gtk_sheet_class_init (GtkSheetClass * klass) klass->select_row = NULL; klass->select_column = NULL; klass->select_range = NULL; - klass->clip_range = NULL; klass->resize_range = NULL; klass->move_range = NULL; klass->traverse = NULL; klass->deactivate = NULL; klass->activate = NULL; - klass->set_cell = NULL; - klass->clear_cell = NULL; klass->changed = NULL; } static void gtk_sheet_init (GtkSheet *sheet) { + sheet->model = NULL; sheet->column_geometry = NULL; sheet->row_geometry = NULL; - sheet->children = NULL; - sheet->flags = 0; sheet->selection_mode = GTK_SELECTION_NONE; - sheet->freeze_count = 0; sheet->state = GTK_SHEET_NORMAL; GTK_WIDGET_UNSET_FLAGS (sheet, GTK_NO_WINDOW); @@ -1174,7 +1041,6 @@ gtk_sheet_init (GtkSheet *sheet) sheet->selection_cell.row = 0; sheet->selection_cell.col = 0; - sheet->sheet_entry = NULL; sheet->pixmap = NULL; sheet->range.row0 = 0; @@ -1187,29 +1053,41 @@ gtk_sheet_init (GtkSheet *sheet) sheet->sheet_window = NULL; sheet->sheet_window_width = 0; sheet->sheet_window_height = 0; - sheet->sheet_entry = NULL; + sheet->entry_widget = NULL; + sheet->entry_container = NULL; sheet->button = NULL; - sheet->hoffset = 0; - sheet->voffset = 0; - sheet->hadjustment = NULL; sheet->vadjustment = NULL; - sheet->cursor_drag = gdk_cursor_new (GDK_PLUS); + sheet->cursor_drag = NULL; + sheet->xor_gc = NULL; sheet->fg_gc = NULL; sheet->bg_gc = NULL; sheet->x_drag = 0; sheet->y_drag = 0; - - gdk_color_parse ("white", &sheet->bg_color); - gdk_color_alloc (gdk_colormap_get_system (), &sheet->bg_color); - gdk_color_parse ("gray", &sheet->grid_color); - gdk_color_alloc (gdk_colormap_get_system (), &sheet->grid_color); sheet->show_grid = TRUE; - sheet->motion_events = 0; + 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; + + sheet->column_titles_visible = TRUE; + sheet->autoscroll = TRUE; + sheet->justify_entry = TRUE; + + + /* create sheet entry */ + sheet->entry_type = 0; + create_sheet_entry (sheet); + + /* create global selection button */ + create_global_button (sheet); } @@ -1231,8 +1109,8 @@ columns_inserted_deleted_callback (GSheetModel *model, gint first_column, */ range.col0 = first_column; range.row0 = 0; - range.coli = xxx_column_count (sheet) - 1; - range.rowi = yyy_row_count (sheet) - 1; + range.coli = g_sheet_column_get_column_count (sheet->column_geometry) - 1; + range.rowi = g_sheet_row_get_row_count (sheet->row_geometry) - 1; adjust_scrollbars (sheet); @@ -1263,8 +1141,8 @@ rows_inserted_deleted_callback (GSheetModel *model, gint first_row, */ range.row0 = first_row; range.col0 = 0; - range.rowi = yyy_row_count (sheet) - 1; - range.coli = xxx_column_count (sheet) - 1; + range.rowi = g_sheet_row_get_row_count (sheet->row_geometry) - 1; + range.coli = g_sheet_column_get_column_count (sheet->column_geometry) - 1; adjust_scrollbars (sheet); @@ -1294,6 +1172,15 @@ range_update_callback (GSheetModel *m, gint row0, gint col0, range.rowi = rowi; range.coli = coli; + if ( MAX_VISIBLE_ROW (sheet) > + g_sheet_model_get_row_count (sheet->model) + || + MAX_VISIBLE_COLUMN (sheet) > + g_sheet_model_get_column_count (sheet->model)) + { + gtk_sheet_move_query (sheet, 0, 0); + } + if ( ( row0 < 0 && col0 < 0 ) || ( rowi < 0 && coli < 0 ) ) { gint i; @@ -1324,12 +1211,6 @@ range_update_callback (GSheetModel *m, gint row0, gint col0, } -static void gtk_sheet_construct (GtkSheet *sheet, - GSheetRow *vgeo, - GSheetColumn *hgeo, - const gchar *title); - - /** * gtk_sheet_new: * @rows: initial number of rows @@ -1342,17 +1223,13 @@ static void gtk_sheet_construct (GtkSheet *sheet, * Returns: the new sheet widget */ GtkWidget * -gtk_sheet_new (GSheetRow *vgeo, GSheetColumn *hgeo, const gchar *title, - GSheetModel *model) +gtk_sheet_new (GSheetRow *vgeo, GSheetColumn *hgeo, GSheetModel *model) { - GtkWidget *widget = g_object_new (GTK_TYPE_SHEET, NULL); - - gtk_sheet_construct (GTK_SHEET (widget), vgeo, hgeo, title); - - if (model) - gtk_sheet_set_model (GTK_SHEET (widget), model); - - + GtkWidget *widget = g_object_new (GTK_TYPE_SHEET, + "row-geometry", vgeo, + "column-geometry", hgeo, + "model", model, + NULL); return widget; } @@ -1369,25 +1246,30 @@ void gtk_sheet_set_model (GtkSheet *sheet, GSheetModel *model) { g_return_if_fail (GTK_IS_SHEET (sheet)); - g_return_if_fail (G_IS_SHEET_MODEL (model)); + + if (sheet->model ) g_object_unref (sheet->model); sheet->model = model; - g_signal_connect (model, "range_changed", - G_CALLBACK (range_update_callback), sheet); + if ( model) + { + g_object_ref (model); - g_signal_connect (model, "rows_inserted", - G_CALLBACK (rows_inserted_deleted_callback), sheet); + g_signal_connect (model, "range_changed", + G_CALLBACK (range_update_callback), sheet); - g_signal_connect (model, "rows_deleted", - G_CALLBACK (rows_inserted_deleted_callback), sheet); + g_signal_connect (model, "rows_inserted", + G_CALLBACK (rows_inserted_deleted_callback), sheet); - g_signal_connect (model, "columns_inserted", - G_CALLBACK (columns_inserted_deleted_callback), sheet); + g_signal_connect (model, "rows_deleted", + G_CALLBACK (rows_inserted_deleted_callback), sheet); - g_signal_connect (model, "columns_deleted", - G_CALLBACK (columns_inserted_deleted_callback), sheet); + g_signal_connect (model, "columns_inserted", + G_CALLBACK (columns_inserted_deleted_callback), sheet); + g_signal_connect (model, "columns_deleted", + G_CALLBACK (columns_inserted_deleted_callback), sheet); + } } @@ -1405,16 +1287,15 @@ column_titles_changed (GtkWidget *w, gint first, gint n_columns, gpointer data) if ( n_columns == -1 ) { extremity = TRUE; - n_columns = xxx_column_count (sheet) - 1 ; + n_columns = g_sheet_column_get_column_count (sheet->column_geometry) - 1 ; } - if (!GTK_SHEET_IS_FROZEN (sheet)) { gint i; for ( i = first ; i <= first + n_columns ; ++i ) { gtk_sheet_column_title_button_draw (sheet, i); - g_signal_emit (G_OBJECT (sheet), sheet_signals[CHANGED], 0, -1, i); + g_signal_emit (sheet, sheet_signals[CHANGED], 0, -1, i); } } @@ -1423,73 +1304,6 @@ column_titles_changed (GtkWidget *w, gint first, gint n_columns, gpointer data) } -static void -gtk_sheet_construct (GtkSheet *sheet, - GSheetRow *vgeo, - GSheetColumn *hgeo, - const gchar *title) -{ - g_return_if_fail (G_IS_SHEET_COLUMN (hgeo)); - g_return_if_fail (G_IS_SHEET_ROW (vgeo)); - - sheet->column_geometry = hgeo; - sheet->row_geometry = vgeo; - - - sheet->columns_resizable = TRUE; - sheet->rows_resizable = TRUE; - - sheet->row_titles_visible = TRUE; - sheet->row_title_area.width = DEFAULT_COLUMN_WIDTH; - - sheet->column_titles_visible = TRUE; - sheet->autoscroll = TRUE; - sheet->justify_entry = TRUE; - - - /* create sheet entry */ - sheet->entry_type = 0; - create_sheet_entry (sheet); - - /* create global selection button */ - create_global_button (sheet); - - if (title) - sheet->name = g_strdup (title); - - g_signal_connect (sheet->column_geometry, "columns_changed", - G_CALLBACK (column_titles_changed), sheet); - -} - - -GtkWidget * -gtk_sheet_new_with_custom_entry (GSheetRow *rows, GSheetColumn *columns, - const gchar *title, GtkType entry_type) -{ - GtkWidget *widget = g_object_new (GTK_TYPE_SHEET, NULL); - - gtk_sheet_construct_with_custom_entry (GTK_SHEET (widget), - rows, columns, title, entry_type); - - return widget; -} - -void -gtk_sheet_construct_with_custom_entry (GtkSheet *sheet, - GSheetRow *vgeo, - GSheetColumn *hgeo, - const gchar *title, - GtkType entry_type) -{ - gtk_sheet_construct (sheet, vgeo, hgeo, title); - - sheet->entry_type = entry_type; - create_sheet_entry (sheet); -} - - - void gtk_sheet_change_entry (GtkSheet *sheet, GtkType entry_type) { @@ -1510,7 +1324,7 @@ gtk_sheet_change_entry (GtkSheet *sheet, GtkType entry_type) if (state == GTK_SHEET_NORMAL) { gtk_sheet_show_active_cell (sheet); - g_signal_connect (G_OBJECT (gtk_sheet_get_entry (sheet)), + g_signal_connect (gtk_sheet_get_entry (sheet), "changed", G_CALLBACK (gtk_sheet_entry_changed), sheet); @@ -1527,7 +1341,6 @@ gtk_sheet_show_grid (GtkSheet *sheet, gboolean show) sheet->show_grid = show; - if (!GTK_SHEET_IS_FROZEN (sheet)) gtk_sheet_range_draw (sheet, NULL); } @@ -1549,12 +1362,11 @@ gtk_sheet_set_background (GtkSheet *sheet, GdkColor *color) if (!color) { gdk_color_parse ("white", &sheet->bg_color); - gdk_color_alloc (gdk_colormap_get_system (), &sheet->bg_color); + gdk_colormap_alloc_color (gdk_colormap_get_system (), &sheet->bg_color, FALSE, TRUE); } else sheet->bg_color = *color; - if (!GTK_SHEET_IS_FROZEN (sheet)) gtk_sheet_range_draw (sheet, NULL); } @@ -1567,12 +1379,11 @@ gtk_sheet_set_grid (GtkSheet *sheet, GdkColor *color) if (!color) { gdk_color_parse ("black", &sheet->grid_color); - gdk_color_alloc (gdk_colormap_get_system (), &sheet->grid_color); + gdk_colormap_alloc_color (gdk_colormap_get_system (), &sheet->grid_color, FALSE, TRUE); } else sheet->grid_color = *color; - if (!GTK_SHEET_IS_FROZEN (sheet)) gtk_sheet_range_draw (sheet, NULL); } @@ -1582,7 +1393,7 @@ gtk_sheet_get_columns_count (GtkSheet *sheet) g_return_val_if_fail (sheet != NULL, 0); g_return_val_if_fail (GTK_IS_SHEET (sheet), 0); - return xxx_column_count (sheet); + return g_sheet_column_get_column_count (sheet->column_geometry); } guint @@ -1591,16 +1402,7 @@ gtk_sheet_get_rows_count (GtkSheet *sheet) g_return_val_if_fail (sheet != NULL, 0); g_return_val_if_fail (GTK_IS_SHEET (sheet), 0); - return yyy_row_count (sheet); -} - -gint -gtk_sheet_get_state (GtkSheet *sheet) -{ - g_return_val_if_fail (sheet != NULL, 0); - g_return_val_if_fail (GTK_IS_SHEET (sheet), 0); - - return (sheet->state); + return g_sheet_row_get_row_count (sheet->row_geometry); } void @@ -1647,9 +1449,9 @@ gtk_sheet_autoresize_column (GtkSheet *sheet, gint column) g_return_if_fail (sheet != NULL); g_return_if_fail (GTK_IS_SHEET (sheet)); - if (column >= xxx_column_count (sheet) || column < 0) return; + if (column >= g_sheet_column_get_column_count (sheet->column_geometry) || column < 0) return; - for (row = 0; row < yyy_row_count (sheet); row++) + for (row = 0; row < g_sheet_row_get_row_count (sheet->row_geometry); row++) { gchar *text = gtk_sheet_cell_get_text (sheet, row, column); if (text && strlen (text) > 0) @@ -1662,14 +1464,14 @@ gtk_sheet_autoresize_column (GtkSheet *sheet, gint column) gint width = STRING_WIDTH (GTK_WIDGET (sheet), attributes.font_desc, text) - + 2 * CELLOFFSET + attributes.border.width; + + 2 * COLUMN_TITLES_HEIGHT + attributes.border.width; text_width = MAX (text_width, width); } } dispose_string (sheet, text); } - if (text_width > xxx_column_width (sheet, column) ) + if (text_width > g_sheet_column_get_width (sheet->column_geometry, column) ) { gtk_sheet_set_column_width (sheet, column, text_width); GTK_SHEET_SET_FLAGS (sheet, GTK_SHEET_REDRAW_PENDING); @@ -1695,23 +1497,6 @@ gtk_sheet_autoscroll (GtkSheet *sheet) return sheet->autoscroll; } -void -gtk_sheet_set_clip_text (GtkSheet *sheet, gboolean clip_text) -{ - g_return_if_fail (sheet != NULL); - g_return_if_fail (GTK_IS_SHEET (sheet)); - - sheet->clip_text = clip_text; -} - -gboolean -gtk_sheet_clip_text (GtkSheet *sheet) -{ - g_return_val_if_fail (sheet != NULL, FALSE); - g_return_val_if_fail (GTK_IS_SHEET (sheet), FALSE); - - return sheet->clip_text; -} void gtk_sheet_set_justify_entry (GtkSheet *sheet, gboolean justify) @@ -1731,108 +1516,6 @@ gtk_sheet_justify_entry (GtkSheet *sheet) return sheet->justify_entry; } -void -gtk_sheet_set_locked (GtkSheet *sheet, gboolean locked) -{ - g_return_if_fail (sheet != NULL); - g_return_if_fail (GTK_IS_SHEET (sheet)); - - if ( locked ) - { - GTK_SHEET_SET_FLAGS (sheet,GTK_SHEET_IS_LOCKED); - gtk_widget_hide (sheet->sheet_entry); - gtk_widget_unmap (sheet->sheet_entry); - } - else - { - GTK_SHEET_UNSET_FLAGS (sheet,GTK_SHEET_IS_LOCKED); - if (GTK_WIDGET_MAPPED (GTK_WIDGET (sheet))) - { - gtk_widget_show (sheet->sheet_entry); - gtk_widget_map (sheet->sheet_entry); - } - } - - gtk_editable_set_editable (GTK_EDITABLE (sheet->sheet_entry), locked); - -} - -gboolean -gtk_sheet_locked (const GtkSheet *sheet) -{ - g_return_val_if_fail (sheet != NULL, FALSE); - g_return_val_if_fail (GTK_IS_SHEET (sheet), FALSE); - - return GTK_SHEET_IS_LOCKED (sheet); -} - -/* This routine has problems with gtk+- 1.2 related with the - label / button drawing - I think it's a bug in gtk+- 1.2 */ -void -gtk_sheet_set_title (GtkSheet *sheet, const gchar *title) -{ - GtkWidget *label; - - g_return_if_fail (sheet != NULL); - g_return_if_fail (title != NULL); - g_return_if_fail (GTK_IS_SHEET (sheet)); - - if (sheet->name) - g_free (sheet->name); - - sheet->name = g_strdup (title); - - if (!GTK_WIDGET_REALIZED (GTK_WIDGET (sheet)) || !title) return; - - if (GTK_BIN (sheet->button)->child) - label = GTK_BIN (sheet->button)->child; - - size_allocate_global_button (sheet); -} - -void -gtk_sheet_freeze (GtkSheet *sheet) -{ - g_return_if_fail (sheet != NULL); - g_return_if_fail (GTK_IS_SHEET (sheet)); - - sheet->freeze_count++; - GTK_SHEET_SET_FLAGS (sheet, GTK_SHEET_IS_FROZEN); -} - -void -gtk_sheet_thaw (GtkSheet *sheet) -{ - g_return_if_fail (sheet != NULL); - g_return_if_fail (GTK_IS_SHEET (sheet)); - - if (sheet->freeze_count == 0) return; - - sheet->freeze_count--; - if (sheet->freeze_count > 0) return; - - adjust_scrollbars (sheet); - - GTK_SHEET_UNSET_FLAGS (sheet, GTK_SHEET_IS_FROZEN); - - sheet->old_vadjustment = -1.; - sheet->old_hadjustment = -1.; - - if (sheet->hadjustment) - g_signal_emit_by_name (G_OBJECT (sheet->hadjustment), - "value_changed"); - if (sheet->vadjustment) - g_signal_emit_by_name (G_OBJECT (sheet->vadjustment), - "value_changed"); - - if (sheet->state == GTK_STATE_NORMAL) - if (sheet->sheet_entry && GTK_WIDGET_MAPPED (sheet->sheet_entry)) - { - gtk_sheet_activate_cell (sheet, sheet->active_cell.row, - sheet->active_cell.col); - } - -} void gtk_sheet_set_row_titles_width (GtkSheet *sheet, guint width) @@ -1843,9 +1526,8 @@ gtk_sheet_set_row_titles_width (GtkSheet *sheet, guint width) adjust_scrollbars (sheet); - sheet->old_hadjustment = -1.; if (sheet->hadjustment) - g_signal_emit_by_name (G_OBJECT (sheet->hadjustment), + g_signal_emit_by_name (sheet->hadjustment, "value_changed"); size_allocate_global_button (sheet); } @@ -1859,9 +1541,8 @@ gtk_sheet_set_column_titles_height (GtkSheet *sheet, guint height) adjust_scrollbars (sheet); - sheet->old_vadjustment = -1.; if (sheet->vadjustment) - g_signal_emit_by_name (G_OBJECT (sheet->vadjustment), + g_signal_emit_by_name (sheet->vadjustment, "value_changed"); size_allocate_global_button (sheet); } @@ -1869,15 +1550,13 @@ gtk_sheet_set_column_titles_height (GtkSheet *sheet, guint height) void gtk_sheet_show_column_titles (GtkSheet *sheet) { - gint col; - if (sheet->column_titles_visible) return; sheet->column_titles_visible = TRUE; + if (!GTK_WIDGET_REALIZED (GTK_WIDGET (sheet))) + return; - if (GTK_WIDGET_REALIZED (GTK_WIDGET (sheet))) - { gdk_window_show (sheet->column_title_window); gdk_window_move_resize (sheet->column_title_window, sheet->column_title_area.x, @@ -1885,22 +1564,10 @@ gtk_sheet_show_column_titles (GtkSheet *sheet) sheet->column_title_area.width, sheet->column_title_area.height); - for (col = MIN_VISIBLE_COLUMN (sheet); - col <= MAX_VISIBLE_COLUMN (sheet); - col++) - { - GtkSheetButton *button = xxx_column_button (sheet, col); - GtkSheetChild *child = button->child; - if (child) - gtk_sheet_child_show (child); - gtk_sheet_button_free (button); - } adjust_scrollbars (sheet); - } - sheet->old_vadjustment = -1.; if (sheet->vadjustment) - g_signal_emit_by_name (G_OBJECT (sheet->vadjustment), + g_signal_emit_by_name (sheet->vadjustment, "value_changed"); size_allocate_global_button (sheet); } @@ -1909,8 +1576,6 @@ gtk_sheet_show_column_titles (GtkSheet *sheet) void gtk_sheet_show_row_titles (GtkSheet *sheet) { - gint row; - if (sheet->row_titles_visible) return; sheet->row_titles_visible = TRUE; @@ -1925,24 +1590,11 @@ gtk_sheet_show_row_titles (GtkSheet *sheet) sheet->row_title_area.width, sheet->row_title_area.height); - for (row = MIN_VISIBLE_ROW (sheet); - row <= MAX_VISIBLE_ROW (sheet); - row++) - { - const GtkSheetButton *button = yyy_row_button (sheet, row); - GtkSheetChild *child = button->child; - - if (child) - { - gtk_sheet_child_show (child); - } - } adjust_scrollbars (sheet); } - sheet->old_hadjustment = -1.; if (sheet->hadjustment) - g_signal_emit_by_name (G_OBJECT (sheet->hadjustment), + g_signal_emit_by_name (sheet->hadjustment, "value_changed"); size_allocate_global_button (sheet); } @@ -1950,8 +1602,6 @@ gtk_sheet_show_row_titles (GtkSheet *sheet) void gtk_sheet_hide_column_titles (GtkSheet *sheet) { - gint col; - if (!sheet->column_titles_visible) return; sheet->column_titles_visible = FALSE; @@ -1963,75 +1613,37 @@ gtk_sheet_hide_column_titles (GtkSheet *sheet) if (GTK_WIDGET_VISIBLE (sheet->button)) gtk_widget_hide (sheet->button); - for (col = MIN_VISIBLE_COLUMN (sheet); - col <= MAX_VISIBLE_COLUMN (sheet); - col++) - { - GtkSheetButton *button = xxx_column_button (sheet, col); - GtkSheetChild *child = button->child; - if (child) - gtk_sheet_child_hide (child); - gtk_sheet_button_free (button); - } adjust_scrollbars (sheet); } - sheet->old_vadjustment = -1.; if (sheet->vadjustment) - g_signal_emit_by_name (G_OBJECT (sheet->vadjustment), + g_signal_emit_by_name (sheet->vadjustment, "value_changed"); } void gtk_sheet_hide_row_titles (GtkSheet *sheet) { - gint row; - if (!sheet->row_titles_visible) return; sheet->row_titles_visible = FALSE; - if (GTK_WIDGET_REALIZED (GTK_WIDGET (sheet))) { if (sheet->row_title_window) gdk_window_hide (sheet->row_title_window); + if (GTK_WIDGET_VISIBLE (sheet->button)) gtk_widget_hide (sheet->button); - for (row = MIN_VISIBLE_ROW (sheet); - row <= MAX_VISIBLE_ROW (sheet); - row++) - { - const GtkSheetButton *button = yyy_row_button (sheet, row); - GtkSheetChild *child = button->child; - if (child) - gtk_sheet_child_hide (child); - } adjust_scrollbars (sheet); } - sheet->old_hadjustment = -1.; if (sheet->hadjustment) - g_signal_emit_by_name (G_OBJECT (sheet->hadjustment), + g_signal_emit_by_name (sheet->hadjustment, "value_changed"); } -gboolean -gtk_sheet_column_titles_visible (GtkSheet *sheet) -{ - g_return_val_if_fail (sheet != NULL, FALSE); - g_return_val_if_fail (GTK_IS_SHEET (sheet), FALSE); - return sheet->column_titles_visible; -} - -gboolean -gtk_sheet_row_titles_visible (GtkSheet *sheet) -{ - g_return_val_if_fail (sheet != NULL, FALSE); - g_return_val_if_fail (GTK_IS_SHEET (sheet), FALSE); - return sheet->row_titles_visible; -} void gtk_sheet_moveto (GtkSheet *sheet, @@ -2050,30 +1662,31 @@ gtk_sheet_moveto (GtkSheet *sheet, g_return_if_fail (sheet->hadjustment != NULL); g_return_if_fail (sheet->vadjustment != NULL); - if (row < 0 || row >= yyy_row_count (sheet)) + if (row < 0 || row >= g_sheet_row_get_row_count (sheet->row_geometry)) return; - if (column < 0 || column >= xxx_column_count (sheet)) + if (column < 0 || column >= g_sheet_column_get_column_count (sheet->column_geometry)) return; height = sheet->sheet_window_height; width = sheet->sheet_window_width; /* adjust vertical scrollbar */ - if (row >= 0 && row_align >= 0.) + if (row >= 0 && row_align >= 0.0) { - y = ROW_TOP_YPIXEL (sheet, row) - sheet->voffset - - (gint) ( row_align*height + (1. - row_align) - * yyy_row_height (sheet, row)); + y = g_sheet_row_start_pixel (sheet->row_geometry, row) + - (gint) ( row_align * height + (1.0 - row_align) + * g_sheet_row_get_height (sheet->row_geometry, row)); /* This forces the sheet to scroll when you don't see the entire cell */ min_row = row; adjust = 0; - if (row_align == 1.) + if (row_align >= 1.0) { while (min_row >= 0 && min_row > MIN_VISIBLE_ROW (sheet)) { - if (yyy_row_is_visible (sheet, min_row)) - adjust += yyy_row_height (sheet, min_row); + if (g_sheet_row_get_visibility (sheet->row_geometry, min_row)) + adjust += g_sheet_row_get_height (sheet->row_geometry, min_row); + if (adjust >= height) { break; @@ -2081,8 +1694,11 @@ gtk_sheet_moveto (GtkSheet *sheet, min_row--; } min_row = MAX (min_row, 0); - y = ROW_TOP_YPIXEL (sheet, min_row) - sheet->voffset + - yyy_row_height (sheet, min_row) - 1; + + min_row ++; + + y = g_sheet_row_start_pixel (sheet->row_geometry, min_row) + + g_sheet_row_get_height (sheet->row_geometry, min_row) - 1; } if (y < 0) @@ -2090,29 +1706,27 @@ gtk_sheet_moveto (GtkSheet *sheet, else sheet->vadjustment->value = y; - sheet->old_vadjustment = -1.; - g_signal_emit_by_name (G_OBJECT (sheet->vadjustment), + g_signal_emit_by_name (sheet->vadjustment, "value_changed"); } /* adjust horizontal scrollbar */ - if (column >= 0 && col_align >= 0.) + if (column >= 0 && col_align >= 0.0) { - x = COLUMN_LEFT_XPIXEL (sheet, column) - sheet->hoffset - - (gint) ( col_align*width + (1.- col_align)* - xxx_column_width (sheet, column)); - + x = COLUMN_LEFT_XPIXEL (sheet, column) + - (gint) ( col_align*width + (1.0 - col_align)* + g_sheet_column_get_width (sheet->column_geometry, column)); /* This forces the sheet to scroll when you don't see the entire cell */ min_col = column; adjust = 0; - if (col_align == 1.) + if (col_align == 1.0) { while (min_col >= 0 && min_col > MIN_VISIBLE_COLUMN (sheet)) { - if (xxx_column_is_visible (sheet, min_col)) - adjust += xxx_column_width (sheet, min_col); + if (g_sheet_column_get_visibility (sheet->column_geometry, min_col)) + adjust += g_sheet_column_get_width (sheet->column_geometry, min_col); if (adjust >= width) { @@ -2121,8 +1735,8 @@ gtk_sheet_moveto (GtkSheet *sheet, min_col--; } min_col = MAX (min_col, 0); - x = COLUMN_LEFT_XPIXEL (sheet, min_col) - sheet->hoffset + - xxx_column_width (sheet, min_col) - 1; + x = COLUMN_LEFT_XPIXEL (sheet, min_col) + + g_sheet_column_get_width (sheet->column_geometry, min_col) - 1; } if (x < 0) @@ -2130,10 +1744,8 @@ gtk_sheet_moveto (GtkSheet *sheet, else sheet->hadjustment->value = x; - sheet->old_vadjustment = -1.; - g_signal_emit_by_name (G_OBJECT (sheet->hadjustment), + g_signal_emit_by_name (sheet->hadjustment, "value_changed"); - } } @@ -2177,33 +1789,28 @@ gtk_sheet_rows_resizable (GtkSheet *sheet) void -gtk_sheet_select_row (GtkSheet * sheet, - gint row) +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 >= yyy_row_count (sheet)) + if (row < 0 || row >= g_sheet_row_get_row_count (sheet->row_geometry)) return; if (sheet->state != GTK_SHEET_NORMAL) gtk_sheet_real_unselect_range (sheet, NULL); else - { - gboolean veto = TRUE; - veto = gtk_sheet_deactivate_cell (sheet); - if (!veto) return; - } + gtk_sheet_deactivate_cell (sheet); sheet->state = GTK_SHEET_ROW_SELECTED; sheet->range.row0 = row; sheet->range.col0 = 0; sheet->range.rowi = row; - sheet->range.coli = xxx_column_count (sheet) - 1; + sheet->range.coli = g_sheet_column_get_column_count (sheet->column_geometry) - 1; sheet->active_cell.row = row; sheet->active_cell.col = 0; - g_signal_emit (G_OBJECT (sheet), sheet_signals[SELECT_ROW], 0, row); + g_signal_emit (sheet, sheet_signals[SELECT_ROW], 0, row); gtk_sheet_real_select_range (sheet, NULL); } @@ -2214,227 +1821,46 @@ 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 >= xxx_column_count (sheet)) + if (column < 0 || column >= g_sheet_column_get_column_count (sheet->column_geometry)) return; if (sheet->state != GTK_SHEET_NORMAL) gtk_sheet_real_unselect_range (sheet, NULL); else - { - gboolean veto = TRUE; - veto = gtk_sheet_deactivate_cell (sheet); - if (!veto) return; - } + gtk_sheet_deactivate_cell (sheet); + sheet->state = GTK_SHEET_COLUMN_SELECTED; sheet->range.row0 = 0; sheet->range.col0 = column; - sheet->range.rowi = yyy_row_count (sheet) - 1; + sheet->range.rowi = g_sheet_row_get_row_count (sheet->row_geometry) - 1; sheet->range.coli = column; sheet->active_cell.row = 0; sheet->active_cell.col = column; - g_signal_emit (G_OBJECT (sheet), sheet_signals[SELECT_COLUMN], 0, column); + g_signal_emit (sheet, sheet_signals[SELECT_COLUMN], 0, column); gtk_sheet_real_select_range (sheet, NULL); } -void -gtk_sheet_clip_range (GtkSheet *sheet, const GtkSheetRange *range) + +static gboolean +gtk_sheet_range_isvisible (const GtkSheet * sheet, + GtkSheetRange range) { + g_return_val_if_fail (sheet != NULL, FALSE); - g_return_if_fail (sheet != NULL); - g_return_if_fail (GTK_IS_SHEET (sheet)); + if (range.row0 < 0 || range.row0 >= g_sheet_row_get_row_count (sheet->row_geometry)) + return FALSE; - if (GTK_SHEET_IN_CLIP (sheet)) return; + if (range.rowi < 0 || range.rowi >= g_sheet_row_get_row_count (sheet->row_geometry)) + return FALSE; - GTK_SHEET_SET_FLAGS (sheet, GTK_SHEET_IN_CLIP); + if (range.col0 < 0 || range.col0 >= g_sheet_column_get_column_count (sheet->column_geometry)) + return FALSE; - if (range == NULL) - sheet->clip_range = sheet->range; - else - sheet->clip_range=*range; - - sheet->interval = 0; - sheet->clip_timer = g_timeout_add (TIMEOUT_FLASH, gtk_sheet_flash, sheet); - - g_signal_emit (G_OBJECT (sheet), sheet_signals[CLIP_RANGE], 0, - &sheet->clip_range); -} - -void -gtk_sheet_unclip_range (GtkSheet *sheet) -{ - - g_return_if_fail (sheet != NULL); - g_return_if_fail (GTK_IS_SHEET (sheet)); - - if (!GTK_SHEET_IN_CLIP (sheet)) return; - - GTK_SHEET_UNSET_FLAGS (sheet, GTK_SHEET_IN_CLIP); - - g_source_remove (sheet->clip_timer); - gtk_sheet_range_draw (sheet, &sheet->clip_range); - - if (gtk_sheet_range_isvisible (sheet, sheet->range)) - gtk_sheet_range_draw (sheet, &sheet->range); -} - -gboolean -gtk_sheet_in_clip (GtkSheet *sheet) -{ - g_return_val_if_fail (sheet != NULL, FALSE); - g_return_val_if_fail (GTK_IS_SHEET (sheet), FALSE); - - return GTK_SHEET_IN_CLIP (sheet); -} - -static gint -gtk_sheet_flash (gpointer data) -{ - GtkSheet *sheet; - gint x,y,width,height; - GdkRectangle clip_area; - - sheet = GTK_SHEET (data); - - if (!GTK_WIDGET_REALIZED (GTK_WIDGET (sheet))) return TRUE; - if (!GTK_WIDGET_DRAWABLE (GTK_WIDGET (sheet))) return TRUE; - if (!gtk_sheet_range_isvisible (sheet, sheet->clip_range)) return TRUE; - if (GTK_SHEET_IN_XDRAG (sheet)) return TRUE; - if (GTK_SHEET_IN_YDRAG (sheet)) return TRUE; - - GDK_THREADS_ENTER (); - - x = COLUMN_LEFT_XPIXEL (sheet,sheet->clip_range.col0)+1; - y = ROW_TOP_YPIXEL (sheet,sheet->clip_range.row0)+1; - width = COLUMN_LEFT_XPIXEL (sheet,sheet->clip_range.coli)- x+ - xxx_column_width (sheet, sheet->clip_range.coli) - 1; - height = ROW_TOP_YPIXEL (sheet,sheet->clip_range.rowi)- y+ - yyy_row_height (sheet, sheet->clip_range.rowi)- 1; - - clip_area.x = COLUMN_LEFT_XPIXEL (sheet, MIN_VISIBLE_COLUMN (sheet)); - clip_area.y = ROW_TOP_YPIXEL (sheet, MIN_VISIBLE_ROW (sheet)); - clip_area.width = sheet->sheet_window_width; - clip_area.height = sheet->sheet_window_height; - - if (x < 0) - { - width += x + 1; - x =- 1; - } - if (width > clip_area.width) width = clip_area.width + 10; - if (y < 0) - { - height += y + 1; - y =- 1; - } - if (height > clip_area.height) height = clip_area.height + 10; - - gdk_draw_pixmap (sheet->sheet_window, - GTK_WIDGET (sheet)->style->fg_gc[GTK_STATE_NORMAL], - sheet->pixmap, - x, y, - x, y, - 1, height); - - gdk_draw_pixmap (sheet->sheet_window, - GTK_WIDGET (sheet)->style->fg_gc[GTK_STATE_NORMAL], - sheet->pixmap, - x, y, - x, y, - width, 1); - - gdk_draw_pixmap (sheet->sheet_window, - GTK_WIDGET (sheet)->style->fg_gc[GTK_STATE_NORMAL], - sheet->pixmap, - x, y + height, - x, y + height, - width, 1); - - gdk_draw_pixmap (sheet->sheet_window, - GTK_WIDGET (sheet)->style->fg_gc[GTK_STATE_NORMAL], - sheet->pixmap, - x + width, y, - x + width, y, - 1, height); - - - sheet->interval = sheet->interval + 1; - if (sheet->interval == TIME_INTERVAL) sheet->interval = 0; - - gdk_gc_set_dashes (sheet->xor_gc, sheet->interval, (gint8*)"\4\4", 2); - gtk_sheet_draw_flashing_range (sheet,sheet->clip_range); - gdk_gc_set_dashes (sheet->xor_gc, 0, (gint8*)"\4\4", 2); - - GDK_THREADS_LEAVE (); - - return TRUE; -} - -static void -gtk_sheet_draw_flashing_range (GtkSheet *sheet, GtkSheetRange range) -{ - GdkRectangle clip_area; - gint x,y,width,height; - - if (!gtk_sheet_range_isvisible (sheet, sheet->clip_range)) return; - - clip_area.x = COLUMN_LEFT_XPIXEL (sheet, MIN_VISIBLE_COLUMN (sheet)); - clip_area.y = ROW_TOP_YPIXEL (sheet, MIN_VISIBLE_ROW (sheet)); - clip_area.width = sheet->sheet_window_width; - clip_area.height = sheet->sheet_window_height; - - gdk_gc_set_clip_rectangle (sheet->xor_gc, &clip_area); - - x = COLUMN_LEFT_XPIXEL (sheet,sheet->clip_range.col0)+1; - y = ROW_TOP_YPIXEL (sheet,sheet->clip_range.row0)+1; - width = COLUMN_LEFT_XPIXEL (sheet,sheet->clip_range.coli)- x+ - xxx_column_width (sheet, sheet->clip_range.coli) - 1; - height = ROW_TOP_YPIXEL (sheet,sheet->clip_range.rowi)- y+ - yyy_row_height (sheet, sheet->clip_range.rowi)- 1; - - if (x < 0) - { - width += x + 1; - x =- 1; - } - if (width > clip_area.width) width = clip_area.width + 10; - if (y < 0) - { - height += y + 1; - y =- 1; - } - if (height > clip_area.height) height = clip_area.height + 10; - - gdk_gc_set_line_attributes (sheet->xor_gc, 1, 1, 0, 0 ); - - gdk_draw_rectangle (sheet->sheet_window, sheet->xor_gc, FALSE, - x, y, - width, height); - - gdk_gc_set_line_attributes (sheet->xor_gc, 1, 0, 0, 0); - - gdk_gc_set_clip_rectangle (sheet->xor_gc, NULL); -} - -static gint -gtk_sheet_range_isvisible (GtkSheet * sheet, - GtkSheetRange range) -{ - g_return_val_if_fail (sheet != NULL, FALSE); - - if (range.row0 < 0 || range.row0 >= yyy_row_count (sheet)) - return FALSE; - - if (range.rowi < 0 || range.rowi >= yyy_row_count (sheet)) - return FALSE; - - if (range.col0 < 0 || range.col0 >= xxx_column_count (sheet)) - return FALSE; - - if (range.coli < 0 || range.coli >= xxx_column_count (sheet)) + if (range.coli < 0 || range.coli >= g_sheet_column_get_column_count (sheet->column_geometry)) return FALSE; if (range.rowi < MIN_VISIBLE_ROW (sheet)) @@ -2452,7 +1878,7 @@ gtk_sheet_range_isvisible (GtkSheet * sheet, return TRUE; } -static gint +static gboolean gtk_sheet_cell_isvisible (GtkSheet * sheet, gint row, gint column) { @@ -2479,126 +1905,35 @@ gtk_sheet_get_visible_range (GtkSheet *sheet, GtkSheetRange *range) range->coli = MAX_VISIBLE_COLUMN (sheet); } -GtkAdjustment * -gtk_sheet_get_vadjustment (GtkSheet * sheet) -{ - g_return_val_if_fail (sheet != NULL, NULL); - g_return_val_if_fail (GTK_IS_SHEET (sheet), NULL); - - return sheet->vadjustment; -} -GtkAdjustment * -gtk_sheet_get_hadjustment (GtkSheet * sheet) +static void +gtk_sheet_set_scroll_adjustments (GtkSheet *sheet, + GtkAdjustment *hadjustment, + GtkAdjustment *vadjustment) { - g_return_val_if_fail (sheet != NULL, NULL); - g_return_val_if_fail (GTK_IS_SHEET (sheet), NULL); - - return sheet->hadjustment; -} - -void -gtk_sheet_set_vadjustment (GtkSheet *sheet, - GtkAdjustment *adjustment) + if ( sheet->vadjustment != vadjustment ) { - GtkAdjustment *old_adjustment; - - g_return_if_fail (sheet != NULL); - g_return_if_fail (GTK_IS_SHEET (sheet)); - if (adjustment) - g_return_if_fail (GTK_IS_ADJUSTMENT (adjustment)); - - if (sheet->vadjustment == adjustment) - return; - - old_adjustment = sheet->vadjustment; - - if (sheet->vadjustment) - { - g_signal_handlers_disconnect_matched (G_OBJECT (sheet->vadjustment), - G_SIGNAL_MATCH_DATA, - 0, 0, 0, 0, - sheet); - g_object_unref (G_OBJECT (sheet->vadjustment)); - } - - sheet->vadjustment = adjustment; - if (sheet->vadjustment) - { - g_object_ref (G_OBJECT (sheet->vadjustment)); - g_object_ref_sink (G_OBJECT (sheet->vadjustment)); + g_object_unref (sheet->vadjustment); + sheet->vadjustment = vadjustment; + g_object_ref (vadjustment); - g_signal_connect (G_OBJECT (sheet->vadjustment), "value_changed", + g_signal_connect (sheet->vadjustment, "value_changed", G_CALLBACK (vadjustment_value_changed), sheet); } - if (!sheet->vadjustment || !old_adjustment) - { - gtk_widget_queue_resize (GTK_WIDGET (sheet)); - return; - } - - sheet->old_vadjustment = sheet->vadjustment->value; -} - -void -gtk_sheet_set_hadjustment (GtkSheet *sheet, - GtkAdjustment *adjustment) + if ( sheet->hadjustment != hadjustment ) { - GtkAdjustment *old_adjustment; - - g_return_if_fail (sheet != NULL); - g_return_if_fail (GTK_IS_SHEET (sheet)); - if (adjustment) - g_return_if_fail (GTK_IS_ADJUSTMENT (adjustment)); - - if (sheet->hadjustment == adjustment) - return; - - old_adjustment = sheet->hadjustment; - - if (sheet->hadjustment) - { - g_signal_handlers_disconnect_matched (G_OBJECT (sheet->hadjustment), - G_SIGNAL_MATCH_DATA, - 0, 0, 0, 0, - sheet); - g_object_unref (G_OBJECT (sheet->hadjustment)); - } - - sheet->hadjustment = adjustment; - if (sheet->hadjustment) - { - g_object_ref (G_OBJECT (sheet->hadjustment)); - g_object_ref_sink (G_OBJECT (sheet->hadjustment)); + g_object_unref (sheet->hadjustment); + sheet->hadjustment = hadjustment; + g_object_ref (hadjustment); - g_signal_connect (G_OBJECT (sheet->hadjustment), "value_changed", + g_signal_connect (sheet->hadjustment, "value_changed", G_CALLBACK (hadjustment_value_changed), sheet); } - - if (!sheet->hadjustment || !old_adjustment) - { - gtk_widget_queue_resize (GTK_WIDGET (sheet)); - return; - } - - sheet->old_hadjustment = sheet->hadjustment->value; -} - -static void -gtk_sheet_set_scroll_adjustments (GtkSheet *sheet, - GtkAdjustment *hadjustment, - GtkAdjustment *vadjustment) -{ - if (sheet->hadjustment != hadjustment) - gtk_sheet_set_hadjustment (sheet, hadjustment); - - if (sheet->vadjustment != vadjustment) - gtk_sheet_set_vadjustment (sheet, vadjustment); } static void @@ -2611,83 +1946,59 @@ gtk_sheet_finalize (GObject * object) sheet = GTK_SHEET (object); - if (sheet->name) - { - g_free (sheet->name); - sheet->name = NULL; - } - if (G_OBJECT_CLASS (parent_class)->finalize) (*G_OBJECT_CLASS (parent_class)->finalize) (object); } static void -gtk_sheet_destroy (GtkObject * object) +gtk_sheet_dispose (GObject *object) { - GtkSheet *sheet; - GList *children; + GtkSheet *sheet = GTK_SHEET (object); g_return_if_fail (object != NULL); g_return_if_fail (GTK_IS_SHEET (object)); - sheet = GTK_SHEET (object); + if ( sheet->dispose_has_run ) + return ; - /* destroy the entry */ - if (sheet->sheet_entry && GTK_IS_WIDGET (sheet->sheet_entry)) - { - gtk_widget_destroy (sheet->sheet_entry); - sheet->sheet_entry = NULL; - } + sheet->dispose_has_run = TRUE; - /* destroy the global selection button */ - if (sheet->button && GTK_IS_WIDGET (sheet->button)) - { - gtk_widget_destroy (sheet->button); - sheet->button = NULL; - } + if (sheet->model) g_object_unref (sheet->model); + if (sheet->row_geometry) g_object_unref (sheet->row_geometry); + if (sheet->column_geometry) g_object_unref (sheet->column_geometry); - if (sheet->clip_timer) - { - g_source_remove (sheet->clip_timer); - sheet->clip_timer = 0; - } + g_object_unref (sheet->entry_container); + sheet->entry_container = NULL; + + g_object_unref (sheet->button); + sheet->button = NULL; /* unref adjustments */ if (sheet->hadjustment) { - g_signal_handlers_disconnect_matched (G_OBJECT (sheet->hadjustment), + g_signal_handlers_disconnect_matched (sheet->hadjustment, G_SIGNAL_MATCH_DATA, 0, 0, 0, 0, sheet); - g_object_unref (G_OBJECT (sheet->hadjustment)); + g_object_unref (sheet->hadjustment); sheet->hadjustment = NULL; } if (sheet->vadjustment) { - g_signal_handlers_disconnect_matched (G_OBJECT (sheet->vadjustment), + g_signal_handlers_disconnect_matched (sheet->vadjustment, G_SIGNAL_MATCH_DATA, 0, 0, 0, 0, sheet); - g_object_unref (G_OBJECT (sheet->vadjustment)); + g_object_unref (sheet->vadjustment); sheet->vadjustment = NULL; } - children = sheet->children; - while (children) - { - GtkSheetChild *child = (GtkSheetChild *)children->data; - if (child && child->widget) - gtk_sheet_remove (GTK_CONTAINER (sheet), child->widget); - children = sheet->children; - } - sheet->children = NULL; - - if (GTK_OBJECT_CLASS (parent_class)->destroy) - (*GTK_OBJECT_CLASS (parent_class)->destroy) (object); + if (G_OBJECT_CLASS (parent_class)->dispose) + (*G_OBJECT_CLASS (parent_class)->dispose) (object); } static void @@ -2719,9 +2030,6 @@ gtk_sheet_realize (GtkWidget * widget) gint attributes_mask; GdkGCValues values, auxvalues; GdkColormap *colormap; - gchar *name; - GtkSheetChild *child; - GList *children; g_return_if_fail (widget != NULL); g_return_if_fail (GTK_IS_SHEET (widget)); @@ -2745,6 +2053,8 @@ gtk_sheet_realize (GtkWidget * widget) GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_KEY_PRESS_MASK | + GDK_ENTER_NOTIFY_MASK | + GDK_LEAVE_NOTIFY_MASK | GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK); attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP | @@ -2761,39 +2071,49 @@ gtk_sheet_realize (GtkWidget * widget) gtk_style_set_background (widget->style, widget->window, GTK_STATE_NORMAL); + gdk_color_parse ("white", &sheet->bg_color); + gdk_colormap_alloc_color (gdk_colormap_get_system (), &sheet->bg_color, FALSE, + TRUE); + gdk_color_parse ("gray", &sheet->grid_color); + gdk_colormap_alloc_color (gdk_colormap_get_system (), &sheet->grid_color, FALSE, + TRUE); + attributes.x = 0; - if (sheet->row_titles_visible) - attributes.x = sheet->row_title_area.width; attributes.y = 0; attributes.width = sheet->column_title_area.width; attributes.height = sheet->column_title_area.height; + /* column - title window */ - sheet->column_title_window = gdk_window_new (widget->window, &attributes, attributes_mask); + sheet->column_title_window = + gdk_window_new (widget->window, &attributes, attributes_mask); gdk_window_set_user_data (sheet->column_title_window, sheet); - gtk_style_set_background (widget->style, sheet->column_title_window, GTK_STATE_NORMAL); + gtk_style_set_background (widget->style, sheet->column_title_window, + GTK_STATE_NORMAL); + attributes.x = 0; attributes.y = 0; - if (sheet->column_titles_visible) - attributes.y = sheet->column_title_area.height; attributes.width = sheet->row_title_area.width; attributes.height = sheet->row_title_area.height; /* row - title window */ - sheet->row_title_window = gdk_window_new (widget->window, &attributes, attributes_mask); + sheet->row_title_window = gdk_window_new (widget->window, + &attributes, attributes_mask); gdk_window_set_user_data (sheet->row_title_window, sheet); - gtk_style_set_background (widget->style, sheet->row_title_window, GTK_STATE_NORMAL); + gtk_style_set_background (widget->style, sheet->row_title_window, + GTK_STATE_NORMAL); /* sheet - window */ attributes.cursor = gdk_cursor_new (GDK_PLUS); attributes.x = 0; attributes.y = 0; - attributes.width = sheet->sheet_window_width, + attributes.width = sheet->sheet_window_width; attributes.height = sheet->sheet_window_height; - sheet->sheet_window = gdk_window_new (widget->window, &attributes, attributes_mask); + sheet->sheet_window = gdk_window_new (widget->window, + &attributes, attributes_mask); gdk_window_set_user_data (sheet->sheet_window, sheet); gdk_cursor_unref (attributes.cursor); @@ -2802,74 +2122,50 @@ gtk_sheet_realize (GtkWidget * widget) gdk_window_show (sheet->sheet_window); /* backing_pixmap */ - gtk_sheet_make_backing_pixmap (sheet, 0, 0); + gtk_sheet_make_backing_pixmap (sheet); /* GCs */ - if (sheet->fg_gc) - gdk_gc_unref (sheet->fg_gc); - if (sheet->bg_gc) - gdk_gc_unref (sheet->bg_gc); sheet->fg_gc = gdk_gc_new (widget->window); sheet->bg_gc = gdk_gc_new (widget->window); colormap = gtk_widget_get_colormap (widget); - gdk_color_white (colormap, &widget->style->white); - gdk_color_black (colormap, &widget->style->black); - gdk_gc_get_values (sheet->fg_gc, &auxvalues); values.foreground = widget->style->white; values.function = GDK_INVERT; values.subwindow_mode = GDK_INCLUDE_INFERIORS; - if (sheet->xor_gc) - gdk_gc_unref (sheet->xor_gc); + values.line_width = 3; + sheet->xor_gc = gdk_gc_new_with_values (widget->window, &values, GDK_GC_FOREGROUND | GDK_GC_FUNCTION | - GDK_GC_SUBWINDOW); + GDK_GC_SUBWINDOW | + GDK_GC_LINE_WIDTH + ); - if (sheet->sheet_entry->parent) - { - gtk_widget_ref (sheet->sheet_entry); - gtk_widget_unparent (sheet->sheet_entry); - } - gtk_widget_set_parent_window (sheet->sheet_entry, sheet->sheet_window); - gtk_widget_set_parent (sheet->sheet_entry, GTK_WIDGET (sheet)); - if (sheet->button && sheet->button->parent) - { - gtk_widget_ref (sheet->button); - gtk_widget_unparent (sheet->button); - } + gtk_widget_set_parent_window (sheet->entry_widget, sheet->sheet_window); + gtk_widget_set_parent (sheet->entry_widget, GTK_WIDGET (sheet)); + gtk_widget_set_parent_window (sheet->button, sheet->sheet_window); gtk_widget_set_parent (sheet->button, GTK_WIDGET (sheet)); - if (!sheet->cursor_drag) - sheet->cursor_drag = gdk_cursor_new (GDK_PLUS); + + sheet->cursor_drag = gdk_cursor_new (GDK_PLUS); if (sheet->column_titles_visible) gdk_window_show (sheet->column_title_window); if (sheet->row_titles_visible) gdk_window_show (sheet->row_title_window); + sheet->hover_window = create_hover_window (); + size_allocate_row_title_buttons (sheet); size_allocate_column_title_buttons (sheet); - name = g_strdup (sheet->name); - gtk_sheet_set_title (sheet, name); - - g_free (name); - - children = sheet->children; - while (children) - { - child = children->data; - children = children->next; - - gtk_sheet_realize_child (sheet, child); - } + gtk_sheet_update_primary_selection (sheet); } static void @@ -2877,7 +2173,9 @@ create_global_button (GtkSheet *sheet) { sheet->button = gtk_button_new_with_label (" "); - g_signal_connect (G_OBJECT (sheet->button), + g_object_ref_sink (sheet->button); + + g_signal_connect (sheet->button, "pressed", G_CALLBACK (global_button_clicked), sheet); @@ -2922,11 +2220,20 @@ gtk_sheet_unrealize (GtkWidget * widget) sheet = GTK_SHEET (widget); - gdk_cursor_destroy (sheet->cursor_drag); + gdk_cursor_unref (sheet->cursor_drag); + sheet->cursor_drag = NULL; + + gdk_colormap_free_colors (gdk_colormap_get_system (), + &sheet->bg_color, 1); - gdk_gc_destroy (sheet->xor_gc); - gdk_gc_destroy (sheet->fg_gc); - gdk_gc_destroy (sheet->bg_gc); + gdk_colormap_free_colors (gdk_colormap_get_system (), + &sheet->grid_color, 1); + + g_object_unref (sheet->xor_gc); + g_object_unref (sheet->fg_gc); + g_object_unref (sheet->bg_gc); + + destroy_hover_window (sheet->hover_window); gdk_window_destroy (sheet->sheet_window); gdk_window_destroy (sheet->column_title_window); @@ -2938,12 +2245,9 @@ gtk_sheet_unrealize (GtkWidget * widget) sheet->pixmap = NULL; } - sheet->column_title_window = NULL; - sheet->sheet_window = NULL; - sheet->cursor_drag = NULL; - sheet->xor_gc = NULL; - sheet->fg_gc = NULL; - sheet->bg_gc = NULL; + gtk_widget_unparent (sheet->entry_widget); + if (sheet->button != NULL) + gtk_widget_unparent (sheet->button); if (GTK_WIDGET_CLASS (parent_class)->unrealize) (* GTK_WIDGET_CLASS (parent_class)->unrealize) (widget); @@ -2952,23 +2256,16 @@ gtk_sheet_unrealize (GtkWidget * widget) static void gtk_sheet_map (GtkWidget * widget) { - GtkSheet *sheet; - GtkSheetChild *child; - GList *children; + GtkSheet *sheet = GTK_SHEET (widget); g_return_if_fail (widget != NULL); g_return_if_fail (GTK_IS_SHEET (widget)); - sheet = GTK_SHEET (widget); - if (!GTK_WIDGET_MAPPED (widget)) { GTK_WIDGET_SET_FLAGS (widget, GTK_MAPPED); - if (!sheet->cursor_drag) sheet->cursor_drag = gdk_cursor_new (GDK_PLUS); - gdk_window_show (widget->window); - gdk_window_show (sheet->sheet_window); if (sheet->column_titles_visible) @@ -2982,13 +2279,12 @@ gtk_sheet_map (GtkWidget * widget) gdk_window_show (sheet->row_title_window); } - if (!GTK_WIDGET_MAPPED (sheet->sheet_entry) - && ! gtk_sheet_locked (sheet) + if (!GTK_WIDGET_MAPPED (sheet->entry_widget) && sheet->active_cell.row >= 0 && sheet->active_cell.col >= 0 ) { - gtk_widget_show (sheet->sheet_entry); - gtk_widget_map (sheet->sheet_entry); + gtk_widget_show (sheet->entry_widget); + gtk_widget_map (sheet->entry_widget); } if (GTK_WIDGET_VISIBLE (sheet->button) && @@ -3007,38 +2303,17 @@ gtk_sheet_map (GtkWidget * widget) gtk_sheet_activate_cell (sheet, sheet->active_cell.row, sheet->active_cell.col); - - children = sheet->children; - while (children) - { - child = children->data; - children = children->next; - - if (GTK_WIDGET_VISIBLE (child->widget) && - !GTK_WIDGET_MAPPED (child->widget)) - { - gtk_widget_map (child->widget); - gtk_sheet_position_child (sheet, child); - } - } - } } static void gtk_sheet_unmap (GtkWidget * widget) { - GtkSheet *sheet; - GtkSheetChild *child; - GList *children; - - g_return_if_fail (widget != NULL); - g_return_if_fail (GTK_IS_SHEET (widget)); + GtkSheet *sheet = GTK_SHEET (widget); - sheet = GTK_SHEET (widget); + if (!GTK_WIDGET_MAPPED (widget)) + return; - if (GTK_WIDGET_MAPPED (widget)) - { GTK_WIDGET_UNSET_FLAGS (widget, GTK_MAPPED); gdk_window_hide (sheet->sheet_window); @@ -3048,33 +2323,17 @@ gtk_sheet_unmap (GtkWidget * widget) gdk_window_hide (sheet->row_title_window); gdk_window_hide (widget->window); - if (GTK_WIDGET_MAPPED (sheet->sheet_entry)) - gtk_widget_unmap (sheet->sheet_entry); + if (GTK_WIDGET_MAPPED (sheet->entry_widget)) + gtk_widget_unmap (sheet->entry_widget); if (GTK_WIDGET_MAPPED (sheet->button)) gtk_widget_unmap (sheet->button); - - children = sheet->children; - while (children) - { - child = children->data; - children = children->next; - - if (GTK_WIDGET_VISIBLE (child->widget) && - GTK_WIDGET_MAPPED (child->widget)) - { - gtk_widget_unmap (child->widget); - } - } - - } } static void gtk_sheet_cell_draw_default (GtkSheet *sheet, gint row, gint col) { - GtkWidget *widget; GdkGC *fg_gc, *bg_gc; GtkSheetCellAttr attributes; GdkRectangle area; @@ -3084,12 +2343,10 @@ gtk_sheet_cell_draw_default (GtkSheet *sheet, gint row, gint col) /* bail now if we arn't drawable yet */ if (!GTK_WIDGET_DRAWABLE (sheet)) return; - if (row < 0 || row >= yyy_row_count (sheet)) return; - if (col < 0 || col >= xxx_column_count (sheet)) return; - if (! xxx_column_is_visible (sheet, col)) return; - if (! yyy_row_is_visible (sheet, row)) return; - - widget = GTK_WIDGET (sheet); + if (row < 0 || row >= g_sheet_row_get_row_count (sheet->row_geometry)) return; + if (col < 0 || col >= g_sheet_column_get_column_count (sheet->column_geometry)) return; + if (! g_sheet_column_get_visibility (sheet->column_geometry, col)) return; + if (! g_sheet_row_get_visibility (sheet->row_geometry, row)) return; gtk_sheet_get_attributes (sheet, row, col, &attributes); @@ -3100,18 +2357,14 @@ gtk_sheet_cell_draw_default (GtkSheet *sheet, gint row, gint col) fg_gc = sheet->fg_gc; bg_gc = sheet->bg_gc; - area.x = COLUMN_LEFT_XPIXEL (sheet,col); - area.y = ROW_TOP_YPIXEL (sheet,row); - area.width= xxx_column_width (sheet, col); - area.height = yyy_row_height (sheet, row); + area.x = g_sheet_column_start_pixel (sheet->column_geometry, col); + area.x -= sheet->hadjustment->value; + + area.y = g_sheet_row_start_pixel (sheet->row_geometry, row); + area.y -= sheet->vadjustment->value; - gdk_draw_rectangle (sheet->pixmap, - bg_gc, - TRUE, - area.x, - area.y, - area.width, - area.height); + area.width= g_sheet_column_get_width (sheet->column_geometry, col); + area.height = g_sheet_row_get_height (sheet->row_geometry, row); gdk_gc_set_line_attributes (sheet->fg_gc, 1, 0, 0, 0); @@ -3127,11 +2380,12 @@ gtk_sheet_cell_draw_default (GtkSheet *sheet, gint row, gint col) } } + static void gtk_sheet_cell_draw_label (GtkSheet *sheet, gint row, gint col) { GtkWidget *widget; - GdkRectangle area, clip_area; + GdkRectangle area; gint i; gint text_width, text_height, y; gint xoffset = 0; @@ -3158,11 +2412,10 @@ gtk_sheet_cell_draw_label (GtkSheet *sheet, gint row, gint col) if (!label) return; - if (row < 0 || row >= yyy_row_count (sheet)) return; - if (col < 0 || col >= xxx_column_count (sheet)) return; - if (! xxx_column_is_visible (sheet, col)) return; - if (!yyy_row_is_visible (sheet, row)) return; - + if (row < 0 || row >= g_sheet_row_get_row_count (sheet->row_geometry)) return; + if (col < 0 || col >= g_sheet_column_get_column_count (sheet->column_geometry)) return; + if (! g_sheet_column_get_visibility (sheet->column_geometry, col)) return; + if (!g_sheet_row_get_visibility (sheet->row_geometry, row)) return; widget = GTK_WIDGET (sheet); @@ -3175,12 +2428,15 @@ gtk_sheet_cell_draw_label (GtkSheet *sheet, gint row, gint col) fg_gc = sheet->fg_gc; bg_gc = sheet->bg_gc; - area.x = COLUMN_LEFT_XPIXEL (sheet,col); - area.y = ROW_TOP_YPIXEL (sheet,row); - area.width = xxx_column_width (sheet, col); - area.height = yyy_row_height (sheet, row); + area.x = g_sheet_column_start_pixel (sheet->column_geometry, col); + area.x -= sheet->hadjustment->value; + + area.y = g_sheet_row_start_pixel (sheet->row_geometry, row); + area.y -= sheet->vadjustment->value; + + area.width = g_sheet_column_get_width (sheet->column_geometry, col); + area.height = g_sheet_row_get_height (sheet->row_geometry, row); - clip_area = area; layout = gtk_widget_create_pango_layout (GTK_WIDGET (sheet), label); dispose_string (sheet, label); @@ -3207,7 +2463,7 @@ gtk_sheet_cell_draw_label (GtkSheet *sheet, gint row, gint col) y_pos = area.height - logical_rect.height; if (logical_rect.height > area.height) - y_pos = (logical_rect.height - area.height - 2 * CELLOFFSET) / 2; + y_pos = (logical_rect.height - area.height - 2 * COLUMN_TITLES_HEIGHT) / 2; else if (y_pos < 0) y_pos = 0; else if (y_pos + logical_rect.height > area.height) @@ -3215,113 +2471,98 @@ gtk_sheet_cell_draw_label (GtkSheet *sheet, gint row, gint col) text_width = rect.width; text_height = rect.height; - y = area.y + y_pos - CELLOFFSET; + y = area.y + y_pos - COLUMN_TITLES_HEIGHT; switch (attributes.justification) { case GTK_JUSTIFY_RIGHT: size = area.width; area.x +=area.width; - if (!gtk_sheet_clip_text (sheet)) - { - for (i = col - 1; i >= MIN_VISIBLE_COLUMN (sheet); i--) - { - if ( !gtk_sheet_cell_empty (sheet, row, i)) break; - if (size >= text_width + CELLOFFSET) break; - size +=xxx_column_width (sheet, i); - xxx_column_set_right_column (sheet, i, - MAX (col, - xxx_column_right_column (sheet, i))); - } - area.width = size; - } + { + for (i = col - 1; i >= MIN_VISIBLE_COLUMN (sheet); i--) + { + if ( !gtk_sheet_cell_empty (sheet, row, i)) break; + if (size >= text_width + COLUMN_TITLES_HEIGHT) break; + size += g_sheet_column_get_width (sheet->column_geometry, i); + g_sheet_column_set_right_text_column (sheet->column_geometry, i, + MAX (col, + g_sheet_column_get_right_text_column (sheet->column_geometry, i))); + } + area.width = size; + } area.x -= size; - xoffset += area.width - text_width - 2 * CELLOFFSET - + xoffset += area.width - text_width - 2 * COLUMN_TITLES_HEIGHT - attributes.border.width / 2; break; case GTK_JUSTIFY_CENTER: sizel = area.width / 2; sizer = area.width / 2; area.x += area.width / 2; - if (!gtk_sheet_clip_text (sheet)) - { - for (i = col + 1; i <= MAX_VISIBLE_COLUMN (sheet); i++) - { - if ( ! gtk_sheet_cell_empty (sheet, row, i)) break; - if (sizer >= text_width / 2) break; - sizer += xxx_column_width (sheet, i); - xxx_column_set_left_column (sheet, i, - MIN ( - col, - xxx_column_left_column (sheet, i))); - } - for (i = col - 1; i >= MIN_VISIBLE_COLUMN (sheet); i--) - { - if ( ! gtk_sheet_cell_empty (sheet, row, i)) break; - if (sizel >= text_width / 2) break; - sizel +=xxx_column_width (sheet, i); - xxx_column_set_right_column (sheet, i, - MAX (col, - xxx_column_right_column (sheet, i))); - } - size = MIN (sizel, sizer); - } + { + for (i = col + 1; i <= MAX_VISIBLE_COLUMN (sheet); i++) + { + if ( ! gtk_sheet_cell_empty (sheet, row, i)) break; + if (sizer >= text_width / 2) break; + sizer += g_sheet_column_get_width (sheet->column_geometry, i); + g_sheet_column_set_left_text_column (sheet->column_geometry, i, + MIN ( + col, + g_sheet_column_get_left_text_column (sheet->column_geometry, i))); + } + for (i = col - 1; i >= MIN_VISIBLE_COLUMN (sheet); i--) + { + if ( ! gtk_sheet_cell_empty (sheet, row, i)) break; + if (sizel >= text_width / 2) break; + sizel += g_sheet_column_get_width (sheet->column_geometry, i); + g_sheet_column_set_right_text_column (sheet->column_geometry, i, + MAX (col, + g_sheet_column_get_right_text_column (sheet->column_geometry, i))); + } + size = MIN (sizel, sizer); + } area.x -= sizel; - xoffset += sizel - text_width / 2 - CELLOFFSET; + xoffset += sizel - text_width / 2 - COLUMN_TITLES_HEIGHT; area.width = sizel + sizer; break; case GTK_JUSTIFY_LEFT: default: size = area.width; - if (!gtk_sheet_clip_text (sheet)) - { - for (i = col + 1; i <= MAX_VISIBLE_COLUMN (sheet); i++) - { - if (! gtk_sheet_cell_empty (sheet, row, i)) break; - if (size >= text_width + CELLOFFSET) break; - size +=xxx_column_width (sheet, i); - xxx_column_set_left_column (sheet, i, - MIN ( - col, - xxx_column_left_column (sheet, i))); - - } - area.width = size; - } + { + for (i = col + 1; i <= MAX_VISIBLE_COLUMN (sheet); i++) + { + if (! gtk_sheet_cell_empty (sheet, row, i)) break; + if (size >= text_width + COLUMN_TITLES_HEIGHT) break; + size += g_sheet_column_get_width (sheet->column_geometry, i); + g_sheet_column_set_left_text_column (sheet->column_geometry, i, + MIN ( + col, + g_sheet_column_get_left_text_column (sheet->column_geometry, i))); + + } + area.width = size; + } xoffset += attributes.border.width / 2; break; } - if (!gtk_sheet_clip_text (sheet)) clip_area = area; - gdk_gc_set_clip_rectangle (fg_gc, &clip_area); + gdk_gc_set_clip_rectangle (fg_gc, &area); gdk_draw_layout (sheet->pixmap, fg_gc, - area.x + xoffset + CELLOFFSET, - y, + area.x + xoffset + COLUMN_TITLES_HEIGHT, + area.y, layout); gdk_gc_set_clip_rectangle (fg_gc, NULL); - g_object_unref (G_OBJECT (layout)); - - gdk_draw_pixmap (sheet->sheet_window, - GTK_WIDGET (sheet)->style->fg_gc[GTK_STATE_NORMAL], - sheet->pixmap, - area.x, - area.y, - area.x, - area.y, - area.width, - area.height); + g_object_unref (layout); } static void gtk_sheet_range_draw (GtkSheet *sheet, const GtkSheetRange *range) { - gint i,j; + gint i, j; GtkSheetRange drawing_range; - GdkRectangle area; g_return_if_fail (sheet != NULL); g_return_if_fail (GTK_SHEET (sheet)); @@ -3330,19 +2571,23 @@ gtk_sheet_range_draw (GtkSheet *sheet, const GtkSheetRange *range) if (!GTK_WIDGET_REALIZED (GTK_WIDGET (sheet))) return; if (!GTK_WIDGET_MAPPED (GTK_WIDGET (sheet))) return; + if (sheet->sheet_window_width <= 0) return; + if (sheet->sheet_window_height <=0) return; + + if (sheet->pixmap == NULL) return ; + if (range == NULL) { drawing_range.row0 = MIN_VISIBLE_ROW (sheet); drawing_range.col0 = MIN_VISIBLE_COLUMN (sheet); drawing_range.rowi = MIN (MAX_VISIBLE_ROW (sheet), - yyy_row_count (sheet) - 1); + g_sheet_row_get_row_count (sheet->row_geometry) - 1); drawing_range.coli = MAX_VISIBLE_COLUMN (sheet); - gdk_draw_rectangle (sheet->pixmap, GTK_WIDGET (sheet)->style->white_gc, TRUE, - 0,0, + 0, 0, sheet->sheet_window_width, sheet->sheet_window_height); } @@ -3354,61 +2599,6 @@ gtk_sheet_range_draw (GtkSheet *sheet, const GtkSheetRange *range) drawing_range.coli = MIN (range->coli, MAX_VISIBLE_COLUMN (sheet)); } - if (drawing_range.coli == xxx_column_count (sheet) - 1) - { - area.x = COLUMN_LEFT_XPIXEL (sheet, - xxx_column_count (sheet) - 1) + - xxx_column_width (sheet, xxx_column_count (sheet) - 1) + 1; - - area.y = 0; - - gdk_gc_set_foreground (sheet->fg_gc, &sheet->bg_color); - - gdk_draw_rectangle (sheet->pixmap, - sheet->fg_gc, - TRUE, - area.x,area.y, - sheet->sheet_window_width - area.x, - sheet->sheet_window_height); - - gdk_draw_pixmap (sheet->sheet_window, - GTK_WIDGET (sheet)->style->fg_gc[GTK_STATE_NORMAL], - sheet->pixmap, - area.x, - area.y, - area.x, - area.y, - sheet->sheet_window_width - area.x, - sheet->sheet_window_height); - } - - if (drawing_range.rowi == yyy_row_count (sheet) - 1) - { - area.x = 0; - area.y = ROW_TOP_YPIXEL (sheet, - yyy_row_count (sheet) - 1) + - yyy_row_height (sheet, yyy_row_count (sheet) - 1) + 1; - - gdk_gc_set_foreground (sheet->fg_gc, &sheet->bg_color); - - gdk_draw_rectangle (sheet->pixmap, - sheet->fg_gc, - TRUE, - area.x,area.y, - sheet->sheet_window_width, - sheet->sheet_window_height - area.y); - - gdk_draw_pixmap (sheet->sheet_window, - GTK_WIDGET (sheet)->style->fg_gc[GTK_STATE_NORMAL], - sheet->pixmap, - area.x, - area.y, - area.x, - area.y, - sheet->sheet_window_width, - sheet->sheet_window_height - area.y); - } - for (i = drawing_range.row0; i <= drawing_range.rowi; i++) for (j = drawing_range.col0; j <= drawing_range.coli; j++) { @@ -3434,7 +2624,7 @@ static void gtk_sheet_range_draw_selection (GtkSheet *sheet, GtkSheetRange range) { GdkRectangle area; - gint i,j; + gint i, j; GtkSheetRange aux; if (range.col0 > sheet->range.coli || range.coli < sheet->range.col0 || @@ -3462,13 +2652,23 @@ gtk_sheet_range_draw_selection (GtkSheet *sheet, GtkSheetRange range) { if (gtk_sheet_cell_get_state (sheet, i, j) == GTK_STATE_SELECTED && - xxx_column_is_visible (sheet, j) && yyy_row_is_visible (sheet, i)) + g_sheet_column_get_visibility (sheet->column_geometry, j) && g_sheet_row_get_visibility (sheet->row_geometry, i)) { + area.x = COLUMN_LEFT_XPIXEL (sheet, j); + if ( sheet->row_titles_visible) + area.x += sheet->row_title_area.width; + + area.x -= sheet->hadjustment->value; - area.x = COLUMN_LEFT_XPIXEL (sheet,j); - area.y = ROW_TOP_YPIXEL (sheet,i); - area.width= xxx_column_width (sheet, j); - area.height = yyy_row_height (sheet, i); + area.y = g_sheet_row_start_pixel (sheet->row_geometry, i); + if ( sheet->column_titles_visible) + area.y += sheet->column_title_area.height; + + area.y -= sheet->vadjustment->value; + + + area.width= g_sheet_column_get_width (sheet->column_geometry, j); + area.height = g_sheet_row_get_height (sheet->row_geometry, i); if (i == sheet->range.row0) { @@ -3488,8 +2688,8 @@ gtk_sheet_range_draw_selection (GtkSheet *sheet, GtkSheetRange range) gdk_draw_rectangle (sheet->sheet_window, sheet->xor_gc, TRUE, - area.x + 1,area.y + 1, - area.width,area.height); + area.x + 1, area.y + 1, + area.width, area.height); } } @@ -3502,73 +2702,27 @@ gtk_sheet_range_draw_selection (GtkSheet *sheet, GtkSheetRange range) static void gtk_sheet_draw_backing_pixmap (GtkSheet *sheet, GtkSheetRange range) { - gint x,y,width,height; + gint width, height; if (!GTK_WIDGET_REALIZED (GTK_WIDGET (sheet))) return; - x = COLUMN_LEFT_XPIXEL (sheet,range.col0); - y = ROW_TOP_YPIXEL (sheet, range.row0); - width = COLUMN_LEFT_XPIXEL (sheet, range.coli) - x + - xxx_column_width (sheet, range.coli); - - height = ROW_TOP_YPIXEL (sheet, range.rowi)- y + yyy_row_height (sheet, range.rowi); - - if (range.row0 == sheet->range.row0) - { - y = y - 5; - height = height + 5; - } - if (range.rowi == sheet->range.rowi) height = height + 5; - if (range.col0 == sheet->range.col0) - { - x = x - 5; - width = width + 5; - } - if (range.coli == sheet->range.coli) width = width + 5; - - width = MIN (width, sheet->sheet_window_width - x); - height = MIN (height, sheet->sheet_window_height - y); - - x--; - y--; - width +=2; - height +=2; - - x = (sheet->row_titles_visible) - ? MAX (x, sheet->row_title_area.width) : MAX (x, 0); - y = (sheet->column_titles_visible) - ? MAX (y, sheet->column_title_area.height) : MAX (y, 0); + if ( sheet->pixmap == NULL) return; - if (range.coli == xxx_column_count (sheet) - 1) - width = sheet->sheet_window_width - x; - if (range.rowi == yyy_row_count (sheet) - 1) - height = sheet->sheet_window_height - y; + gdk_drawable_get_size (sheet->pixmap, &width, &height); - gdk_draw_pixmap (sheet->sheet_window, + gdk_draw_drawable (sheet->sheet_window, GTK_WIDGET (sheet)->style->fg_gc[GTK_STATE_NORMAL], sheet->pixmap, - x, - y, - x, - y, - width + 1, - height + 1); + 0, 0, /* src */ + sheet->row_titles_visible ? sheet->row_title_area.width : 0, + sheet->column_titles_visible ? sheet->column_title_area.height : 0, + width, height); } +static void gtk_sheet_set_cell (GtkSheet *sheet, gint row, gint col, + GtkJustification justification, + const gchar *text); -void -gtk_sheet_set_cell_text (GtkSheet *sheet, gint row, gint col, const gchar *text) -{ - GtkSheetCellAttr attributes; - - g_return_if_fail (sheet != NULL); - g_return_if_fail (GTK_IS_SHEET (sheet)); - if (col >= xxx_column_count (sheet) || row >= yyy_row_count (sheet)) return; - if (col < 0 || row < 0) return; - - gtk_sheet_get_attributes (sheet, row, col, &attributes); - gtk_sheet_set_cell (sheet, row, col, attributes.justification, text); -} static inline gint safe_strcmp (const gchar *s1, const gchar *s2) @@ -3579,7 +2733,7 @@ safe_strcmp (const gchar *s1, const gchar *s2) return strcmp (s1, s2); } -void +static void gtk_sheet_set_cell (GtkSheet *sheet, gint row, gint col, GtkJustification justification, const gchar *text) @@ -3594,7 +2748,7 @@ 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 >= xxx_column_count (sheet) || row >= yyy_row_count (sheet)) return; + if (col >= g_sheet_column_get_column_count (sheet->column_geometry) || row >= g_sheet_row_get_row_count (sheet->row_geometry)) return; if (col < 0 || row < 0) return; gtk_sheet_get_attributes (sheet, row, col, &attributes); @@ -3631,20 +2785,19 @@ gtk_sheet_set_cell (GtkSheet *sheet, gint row, gint col, range.coli = MAX_VISIBLE_COLUMN (sheet); if (gtk_sheet_autoresize (sheet) && - text_width > xxx_column_width (sheet, col) - - 2 * CELLOFFSET- attributes.border.width) + text_width > g_sheet_column_get_width (sheet->column_geometry, col) - + 2 * COLUMN_TITLES_HEIGHT- attributes.border.width) { - gtk_sheet_set_column_width (sheet, col, text_width + 2 * CELLOFFSET + gtk_sheet_set_column_width (sheet, col, text_width + 2 * COLUMN_TITLES_HEIGHT + attributes.border.width); GTK_SHEET_SET_FLAGS (sheet, GTK_SHEET_REDRAW_PENDING); } else - if (!GTK_SHEET_IS_FROZEN (sheet)) gtk_sheet_range_draw (sheet, &range); } if ( changed ) - g_signal_emit (G_OBJECT (sheet), sheet_signals[CHANGED], 0, row, col); + g_signal_emit (sheet, sheet_signals[CHANGED], 0, row, col); } @@ -3656,8 +2809,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 >= xxx_column_count (sheet) || - row >= yyy_row_count (sheet)) return; + if (column >= g_sheet_column_get_column_count (sheet->column_geometry) || + row >= g_sheet_row_get_row_count (sheet->row_geometry)) return; if (column < 0 || row < 0) return; @@ -3668,11 +2821,8 @@ gtk_sheet_cell_clear (GtkSheet *sheet, gint row, gint column) gtk_sheet_real_cell_clear (sheet, row, column); - if (!GTK_SHEET_IS_FROZEN (sheet)) - { gtk_sheet_range_draw (sheet, &range); } -} static void gtk_sheet_real_cell_clear (GtkSheet *sheet, gint row, gint column) @@ -3684,10 +2834,6 @@ gtk_sheet_real_cell_clear (GtkSheet *sheet, gint row, gint column) if (old_text && strlen (old_text) > 0 ) { g_sheet_model_datum_clear (model, row, column); - - if (GTK_IS_OBJECT (sheet) && G_OBJECT (sheet)->ref_count > 0) - g_signal_emit (G_OBJECT (sheet), sheet_signals[CLEAR_CELL], 0, - row, column); } dispose_string (sheet, old_text); @@ -3711,17 +2857,17 @@ gtk_sheet_real_range_clear (GtkSheet *sheet, const GtkSheetRange *range) if (!range) { clear.row0 = 0; - clear.rowi = yyy_row_count (sheet) - 1; + clear.rowi = g_sheet_row_get_row_count (sheet->row_geometry) - 1; clear.col0 = 0; - clear.coli = xxx_column_count (sheet) - 1; + clear.coli = g_sheet_column_get_column_count (sheet->column_geometry) - 1; } else clear=*range; clear.row0 = MAX (clear.row0, 0); clear.col0 = MAX (clear.col0, 0); - clear.rowi = MIN (clear.rowi, yyy_row_count (sheet) - 1 ); - clear.coli = MIN (clear.coli, xxx_column_count (sheet) - 1 ); + clear.rowi = MIN (clear.rowi, g_sheet_row_get_row_count (sheet->row_geometry) - 1 ); + clear.coli = MIN (clear.coli, g_sheet_column_get_column_count (sheet->column_geometry) - 1 ); for (i = clear.row0; i <= clear.rowi; i++) for (j = clear.col0; j <= clear.coli; j++) @@ -3753,7 +2899,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 >= xxx_column_count (sheet) || row >= yyy_row_count (sheet)) + if (col >= g_sheet_column_get_column_count (sheet->column_geometry) || row >= g_sheet_row_get_row_count (sheet->row_geometry)) return NULL; if (col < 0 || row < 0) return NULL; @@ -3774,7 +2920,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 >= xxx_column_count (sheet) || row >= yyy_row_count (sheet)) return 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 < 0 || row < 0) return 0; state = sheet->state; @@ -3802,11 +2948,10 @@ gtk_sheet_cell_get_state (GtkSheet *sheet, gint row, gint col) return GTK_STATE_NORMAL; } -/* Convert X, Y (in pixels) to *ROW, *COLUMN (in cell coords) - -1 indicates the title buttons. +/* Convert X, Y (in pixels) to *ROW, *COLUMN If the function returns FALSE, then the results will be unreliable. */ -gboolean +static gboolean gtk_sheet_get_pixel_info (GtkSheet *sheet, gint x, gint y, @@ -3828,28 +2973,27 @@ gtk_sheet_get_pixel_info (GtkSheet *sheet, if (x < 0) return FALSE; - if ( y < sheet->column_title_area.height + sheet->column_title_area.y) - *row = -1; + if ( sheet->column_titles_visible) + y -= sheet->column_title_area.height; - else - { - trow = ROW_FROM_YPIXEL (sheet, y); - if (trow > yyy_row_count (sheet)) + y += sheet->vadjustment->value; + + trow = yyy_row_ypixel_to_row (sheet, y); + if (trow > g_sheet_row_get_row_count (sheet->row_geometry)) return FALSE; *row = trow; - } - if ( x < sheet->row_title_area.width + sheet->row_title_area.x) - *column = -1; - else - { + if ( sheet->row_titles_visible) + x -= sheet->row_title_area.width; + + x += sheet->hadjustment->value; + tcol = COLUMN_FROM_XPIXEL (sheet, x); - if (tcol > xxx_column_count (sheet)) + if (tcol > g_sheet_column_get_column_count (sheet->column_geometry)) return FALSE; *column = tcol; - } return TRUE; } @@ -3863,22 +3007,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 >= yyy_row_count (sheet) || column >= xxx_column_count (sheet)) + if (row >= g_sheet_row_get_row_count (sheet->row_geometry) || column >= g_sheet_column_get_column_count (sheet->column_geometry)) return FALSE; - area->x = (column == -1) ? 0 : (COLUMN_LEFT_XPIXEL (sheet, column) - - (sheet->row_titles_visible - ? sheet->row_title_area.width - : 0)); - area->y = (row == -1) ? 0 : (ROW_TOP_YPIXEL (sheet, row) - - (sheet->column_titles_visible - ? sheet->column_title_area.height - : 0)); + area->x = (column == -1) ? 0 : COLUMN_LEFT_XPIXEL (sheet, column); + area->y = (row == -1) ? 0 : g_sheet_row_start_pixel (sheet->row_geometry, row); + area->width= (column == -1) ? sheet->row_title_area.width - : xxx_column_width (sheet, column); + : g_sheet_column_get_width (sheet->column_geometry, column); area->height= (row == -1) ? sheet->column_title_area.height - : yyy_row_height (sheet, row); + : g_sheet_row_get_height (sheet->row_geometry, row); return TRUE; } @@ -3890,13 +3029,11 @@ gtk_sheet_set_active_cell (GtkSheet *sheet, gint row, gint column) g_return_val_if_fail (GTK_IS_SHEET (sheet), 0); if (row < - 1 || column < - 1) return FALSE; - if (row >= yyy_row_count (sheet) || column >= xxx_column_count (sheet)) + if (row >= g_sheet_row_get_row_count (sheet->row_geometry) || column >= g_sheet_column_get_column_count (sheet->column_geometry)) return FALSE; if (GTK_WIDGET_REALIZED (GTK_WIDGET (sheet))) - { - if (!gtk_sheet_deactivate_cell (sheet)) return FALSE; - } + gtk_sheet_deactivate_cell (sheet); sheet->active_cell.row = row; sheet->active_cell.col = column; @@ -3929,7 +3066,7 @@ static void gtk_sheet_entry_changed (GtkWidget *widget, gpointer data) { GtkSheet *sheet; - gint row,col; + gint row, col; const char *text; GtkJustification justification; GtkSheetCellAttr attributes; @@ -3947,13 +3084,11 @@ gtk_sheet_entry_changed (GtkWidget *widget, gpointer data) if (row < 0 || col < 0) return; - sheet->active_cell.row =- 1; - sheet->active_cell.col =- 1; + sheet->active_cell.row = -1; + sheet->active_cell.col = -1; text = gtk_entry_get_text (GTK_ENTRY (gtk_sheet_get_entry (sheet))); - GTK_SHEET_SET_FLAGS (sheet, GTK_SHEET_IS_FROZEN); - if (text && strlen (text) > 0) { gtk_sheet_get_attributes (sheet, row, col, &attributes); @@ -3961,35 +3096,29 @@ gtk_sheet_entry_changed (GtkWidget *widget, gpointer data) gtk_sheet_set_cell (sheet, row, col, justification, text); } - if (sheet->freeze_count == 0) - GTK_SHEET_UNSET_FLAGS (sheet, GTK_SHEET_IS_FROZEN); - sheet->active_cell.row = row;; sheet->active_cell.col = col; } -static gboolean +static void gtk_sheet_deactivate_cell (GtkSheet *sheet) { - gboolean veto = TRUE; - - g_return_val_if_fail (sheet != NULL, FALSE); - g_return_val_if_fail (GTK_IS_SHEET (sheet), FALSE); + g_return_if_fail (sheet != NULL); + g_return_if_fail (GTK_IS_SHEET (sheet)); - if (!GTK_WIDGET_REALIZED (GTK_WIDGET (sheet))) return FALSE; - if (sheet->state != GTK_SHEET_NORMAL) return FALSE; + if (!GTK_WIDGET_REALIZED (GTK_WIDGET (sheet))) return ; + if (sheet->state != GTK_SHEET_NORMAL) return ; - _gtkextra_signal_emit (GTK_OBJECT (sheet),sheet_signals[DEACTIVATE], - sheet->active_cell.row, - sheet->active_cell.col, &veto); + if ( sheet->active_cell.row == -1 || sheet->active_cell.col == -1 ) + return ; - if (!veto) return FALSE; + g_signal_emit (sheet, sheet_signals[DEACTIVATE], 0, + sheet->active_cell.row, + sheet->active_cell.col); - if ( sheet->active_cell.row == -1 || sheet->active_cell.col == -1 ) - return TRUE; - g_signal_handlers_disconnect_by_func (G_OBJECT (gtk_sheet_get_entry (sheet)), + g_signal_handlers_disconnect_by_func (gtk_sheet_get_entry (sheet), G_CALLBACK (gtk_sheet_entry_changed), sheet); @@ -4002,15 +3131,13 @@ gtk_sheet_deactivate_cell (GtkSheet *sheet) GTK_SHEET_UNSET_FLAGS (sheet, GTK_SHEET_REDRAW_PENDING); gtk_sheet_range_draw (sheet, NULL); } - - return TRUE; } static void gtk_sheet_hide_active_cell (GtkSheet *sheet) { const char *text; - gint row,col; + gint row, col; GtkJustification justification; GtkSheetCellAttr attributes; @@ -4021,45 +3148,20 @@ gtk_sheet_hide_active_cell (GtkSheet *sheet) if (row < 0 || col < 0) return; - if (sheet->freeze_count == 0) - GTK_SHEET_UNSET_FLAGS (sheet, GTK_SHEET_IS_FROZEN); - text = gtk_entry_get_text (GTK_ENTRY (gtk_sheet_get_entry (sheet))); gtk_sheet_get_attributes (sheet, row, col, &attributes); justification = attributes.justification; - if (text && strlen (text) != 0) - { - gtk_sheet_set_cell (sheet, row, col, justification, text); - g_signal_emit (G_OBJECT (sheet),sheet_signals[SET_CELL], 0, row, col); - } - else - { - gtk_sheet_cell_clear (sheet, row, col); - } - row = sheet->active_cell.row; col = sheet->active_cell.col; - gtk_widget_hide (sheet->sheet_entry); - gtk_widget_unmap (sheet->sheet_entry); - - if (row != -1 && col != -1) - gdk_draw_pixmap (sheet->sheet_window, - GTK_WIDGET (sheet)->style->fg_gc[GTK_STATE_NORMAL], - sheet->pixmap, - COLUMN_LEFT_XPIXEL (sheet,col)- 1, - ROW_TOP_YPIXEL (sheet,row)- 1, - COLUMN_LEFT_XPIXEL (sheet,col)- 1, - ROW_TOP_YPIXEL (sheet,row)- 1, - xxx_column_width (sheet, col) + 4, - yyy_row_height (sheet, row)+4); + gtk_widget_hide (sheet->entry_widget); + gtk_widget_unmap (sheet->entry_widget); gtk_widget_grab_focus (GTK_WIDGET (sheet)); - GTK_WIDGET_UNSET_FLAGS (GTK_WIDGET (sheet->sheet_entry), GTK_VISIBLE); - + GTK_WIDGET_UNSET_FLAGS (GTK_WIDGET (sheet->entry_widget), GTK_VISIBLE); } static gboolean @@ -4071,12 +3173,9 @@ gtk_sheet_activate_cell (GtkSheet *sheet, gint row, gint col) g_return_val_if_fail (GTK_IS_SHEET (sheet), FALSE); if (row < 0 || col < 0) return FALSE; - if (row >= yyy_row_count (sheet) || col >= xxx_column_count (sheet)) - return FALSE; - /* _gtkextra_signal_emit (GTK_OBJECT (sheet),sheet_signals[ACTIVATE], row, col, &veto); - if (!GTK_WIDGET_REALIZED (GTK_WIDGET (sheet))) return veto; - */ + if ( row > g_sheet_row_get_row_count (sheet->row_geometry) || col > g_sheet_column_get_column_count (sheet->column_geometry)) + return FALSE; if (!veto) return FALSE; if (sheet->state != GTK_SHEET_NORMAL) @@ -4096,15 +3195,16 @@ gtk_sheet_activate_cell (GtkSheet *sheet, gint row, gint col) GTK_SHEET_UNSET_FLAGS (sheet, GTK_SHEET_IN_SELECTION); - gtk_sheet_show_active_cell (sheet); - g_signal_connect (G_OBJECT (gtk_sheet_get_entry (sheet)), + gtk_sheet_show_active_cell (sheet); + + g_signal_connect (gtk_sheet_get_entry (sheet), "changed", G_CALLBACK (gtk_sheet_entry_changed), sheet); - _gtkextra_signal_emit (GTK_OBJECT (sheet),sheet_signals[ACTIVATE], row, col, &veto); + _gtkextra_signal_emit (GTK_OBJECT (sheet), sheet_signals [ACTIVATE], row, col, &veto); return TRUE; } @@ -4133,7 +3233,7 @@ gtk_sheet_show_active_cell (GtkSheet *sheet) if (sheet->state != GTK_SHEET_NORMAL) return; if (GTK_SHEET_IN_SELECTION (sheet)) return; - GTK_WIDGET_SET_FLAGS (GTK_WIDGET (sheet->sheet_entry), GTK_VISIBLE); + GTK_WIDGET_SET_FLAGS (GTK_WIDGET (sheet->entry_widget), GTK_VISIBLE); sheet_entry = GTK_ENTRY (gtk_sheet_get_entry (sheet)); @@ -4150,10 +3250,6 @@ gtk_sheet_show_active_cell (GtkSheet *sheet) gtk_entry_set_visibility (GTK_ENTRY (sheet_entry), attributes.is_visible); - if (gtk_sheet_locked (sheet) || !attributes.is_editable) - gtk_editable_set_editable (GTK_EDITABLE (sheet_entry), FALSE); - else - gtk_editable_set_editable (GTK_EDITABLE (sheet_entry), TRUE); /*** Added by John Gotts. Mar 25, 2005 *********/ old_text = gtk_entry_get_text (GTK_ENTRY (sheet_entry)); @@ -4168,7 +3264,7 @@ gtk_sheet_show_active_cell (GtkSheet *sheet) gtk_sheet_entry_set_max_size (sheet); gtk_sheet_size_allocate_entry (sheet); - gtk_widget_map (sheet->sheet_entry); + gtk_widget_map (sheet->entry_widget); gtk_widget_grab_focus (GTK_WIDGET (sheet_entry)); @@ -4179,6 +3275,7 @@ static void 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; @@ -4190,22 +3287,28 @@ gtk_sheet_draw_active_cell (GtkSheet *sheet) if (!gtk_sheet_cell_isvisible (sheet, row, col)) return; - gtk_sheet_draw_border (sheet, sheet->range); + range.col0 = range.coli = col; + range.row0 = range.rowi = row; + + gtk_sheet_draw_border (sheet, range); } + static void -gtk_sheet_make_backing_pixmap (GtkSheet *sheet, guint width, guint height) +gtk_sheet_make_backing_pixmap (GtkSheet *sheet) { gint pixmap_width, pixmap_height; + gint width, height; if (!GTK_WIDGET_REALIZED (GTK_WIDGET (sheet))) return; - if (width == 0 && height == 0) - { - width = sheet->sheet_window_width + 80; - height = sheet->sheet_window_height + 80; - } + width = sheet->sheet_window_width ; + height = sheet->sheet_window_height ; + + + if ( width <= 0) return; + if ( height <= 0) return; if (!sheet->pixmap) { @@ -4213,20 +3316,21 @@ gtk_sheet_make_backing_pixmap (GtkSheet *sheet, guint width, guint height) sheet->pixmap = gdk_pixmap_new (sheet->sheet_window, width, height, - 1); - if (!GTK_SHEET_IS_FROZEN (sheet)) gtk_sheet_range_draw (sheet, NULL); + + gtk_sheet_range_draw (sheet, NULL); } else { /* reallocate if sizes don't match */ - gdk_window_get_size (sheet->pixmap, - &pixmap_width, &pixmap_height); + gdk_drawable_get_size (sheet->pixmap, + &pixmap_width, &pixmap_height); if ( (pixmap_width != width) || (pixmap_height != height)) { g_object_unref (sheet->pixmap); sheet->pixmap = gdk_pixmap_new (sheet->sheet_window, width, height, - 1); - if (!GTK_SHEET_IS_FROZEN (sheet)) gtk_sheet_range_draw (sheet, NULL); + gtk_sheet_range_draw (sheet, NULL); } } } @@ -4234,9 +3338,9 @@ gtk_sheet_make_backing_pixmap (GtkSheet *sheet, guint width, guint height) static void gtk_sheet_new_selection (GtkSheet *sheet, GtkSheetRange *range) { - gint i,j, mask1, mask2; + gint i, j, mask1, mask2; gint state, selected; - gint x,y,width,height; + gint x, y, width, height; GtkSheetRange new_range, aux_range; g_return_if_fail (sheet != NULL); @@ -4270,7 +3374,7 @@ gtk_sheet_new_selection (GtkSheet *sheet, GtkSheetRange *range) j <= new_range.coli && j >= new_range.col0) ? TRUE : FALSE; if (state == GTK_STATE_SELECTED && selected && - xxx_column_is_visible (sheet, j) && yyy_row_is_visible (sheet, i) && + g_sheet_column_get_visibility (sheet->column_geometry, j) && g_sheet_row_get_visibility (sheet->row_geometry, i) && (i == sheet->range.row0 || i == sheet->range.rowi || j == sheet->range.col0 || j == sheet->range.coli || i == new_range.row0 || i == new_range.rowi || @@ -4289,11 +3393,11 @@ gtk_sheet_new_selection (GtkSheet *sheet, GtkSheetRange *range) if (mask1 != mask2) { - x = COLUMN_LEFT_XPIXEL (sheet,j); - y = ROW_TOP_YPIXEL (sheet, i); + x = COLUMN_LEFT_XPIXEL (sheet, j); + y = g_sheet_row_start_pixel (sheet->row_geometry, i); width = COLUMN_LEFT_XPIXEL (sheet, j)- x+ - xxx_column_width (sheet, j); - height = ROW_TOP_YPIXEL (sheet, i)- y + yyy_row_height (sheet, i); + g_sheet_column_get_width (sheet->column_geometry, j); + height = g_sheet_row_start_pixel (sheet->row_geometry, i) - y + g_sheet_row_get_height (sheet->row_geometry, i); if (i == sheet->range.row0) { @@ -4308,24 +3412,14 @@ gtk_sheet_new_selection (GtkSheet *sheet, GtkSheetRange *range) } if (j == sheet->range.coli) width = width + 3; - gdk_draw_pixmap (sheet->sheet_window, - GTK_WIDGET (sheet)->style->fg_gc[GTK_STATE_NORMAL], - sheet->pixmap, - x + 1, - y + 1, - x + 1, - y + 1, - width, - height); - if (i != sheet->active_cell.row || j != sheet->active_cell.col) { - x = COLUMN_LEFT_XPIXEL (sheet,j); - y = ROW_TOP_YPIXEL (sheet, i); + x = COLUMN_LEFT_XPIXEL (sheet, j); + y = g_sheet_row_start_pixel (sheet->row_geometry, i); width = COLUMN_LEFT_XPIXEL (sheet, j)- x+ - xxx_column_width (sheet, j); + g_sheet_column_get_width (sheet->column_geometry, j); - height = ROW_TOP_YPIXEL (sheet, i)- y + yyy_row_height (sheet, i); + height = g_sheet_row_start_pixel (sheet->row_geometry, i) - y + g_sheet_row_get_height (sheet->row_geometry, i); if (i == new_range.row0) { @@ -4343,8 +3437,8 @@ gtk_sheet_new_selection (GtkSheet *sheet, GtkSheetRange *range) gdk_draw_rectangle (sheet->sheet_window, sheet->xor_gc, TRUE, - x + 1,y + 1, - width,height); + x + 1, y + 1, + width, height); } } } @@ -4361,13 +3455,13 @@ gtk_sheet_new_selection (GtkSheet *sheet, GtkSheetRange *range) j <= new_range.coli && j >= new_range.col0) ? TRUE : FALSE; if (state == GTK_STATE_SELECTED && !selected && - xxx_column_is_visible (sheet, j) && yyy_row_is_visible (sheet, i)) + g_sheet_column_get_visibility (sheet->column_geometry, j) && g_sheet_row_get_visibility (sheet->row_geometry, i)) { - x = COLUMN_LEFT_XPIXEL (sheet,j); - y = ROW_TOP_YPIXEL (sheet, i); - width = COLUMN_LEFT_XPIXEL (sheet, j)- x+ xxx_column_width (sheet, j); - height = ROW_TOP_YPIXEL (sheet, i)- y + yyy_row_height (sheet, i); + x = COLUMN_LEFT_XPIXEL (sheet, j); + y = g_sheet_row_start_pixel (sheet->row_geometry, i); + width = COLUMN_LEFT_XPIXEL (sheet, j) - x + g_sheet_column_get_width (sheet->column_geometry, j); + height = g_sheet_row_start_pixel (sheet->row_geometry, i) - y + g_sheet_row_get_height (sheet->row_geometry, i); if (i == sheet->range.row0) { @@ -4382,15 +3476,6 @@ gtk_sheet_new_selection (GtkSheet *sheet, GtkSheetRange *range) } if (j == sheet->range.coli) width = width + 3; - gdk_draw_pixmap (sheet->sheet_window, - GTK_WIDGET (sheet)->style->fg_gc[GTK_STATE_NORMAL], - sheet->pixmap, - x + 1, - y + 1, - x + 1, - y + 1, - width, - height); } } } @@ -4405,14 +3490,14 @@ gtk_sheet_new_selection (GtkSheet *sheet, GtkSheetRange *range) j <= new_range.coli && j >= new_range.col0) ? TRUE : FALSE; if (state != GTK_STATE_SELECTED && selected && - xxx_column_is_visible (sheet, j) && yyy_row_is_visible (sheet, i) && + g_sheet_column_get_visibility (sheet->column_geometry, j) && g_sheet_row_get_visibility (sheet->row_geometry, i) && (i != sheet->active_cell.row || j != sheet->active_cell.col)) { - x = COLUMN_LEFT_XPIXEL (sheet,j); - y = ROW_TOP_YPIXEL (sheet, i); - width = COLUMN_LEFT_XPIXEL (sheet, j)- x+ xxx_column_width (sheet, j); - height = ROW_TOP_YPIXEL (sheet, i)- y + yyy_row_height (sheet, i); + x = COLUMN_LEFT_XPIXEL (sheet, j); + y = g_sheet_row_start_pixel (sheet->row_geometry, i); + width = COLUMN_LEFT_XPIXEL (sheet, j) - x + g_sheet_column_get_width (sheet->column_geometry, j); + height = g_sheet_row_start_pixel (sheet->row_geometry, i) - y + g_sheet_row_get_height (sheet->row_geometry, i); if (i == new_range.row0) { @@ -4430,8 +3515,8 @@ gtk_sheet_new_selection (GtkSheet *sheet, GtkSheetRange *range) gdk_draw_rectangle (sheet->sheet_window, sheet->xor_gc, TRUE, - x + 1,y + 1, - width,height); + x + 1, y + 1, + width, height); } @@ -4443,7 +3528,7 @@ gtk_sheet_new_selection (GtkSheet *sheet, GtkSheetRange *range) for (j = aux_range.col0; j <= aux_range.coli; j++) { - if (xxx_column_is_visible (sheet, j) && yyy_row_is_visible (sheet, i)) + if (g_sheet_column_get_visibility (sheet->column_geometry, j) && g_sheet_row_get_visibility (sheet->row_geometry, i)) { state = gtk_sheet_cell_get_state (sheet, i, j); @@ -4459,39 +3544,39 @@ 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 = COLUMN_LEFT_XPIXEL (sheet,j); - y = ROW_TOP_YPIXEL (sheet, i); - width = xxx_column_width (sheet, j); - height = yyy_row_height (sheet, i); + x = COLUMN_LEFT_XPIXEL (sheet, j); + y = g_sheet_row_start_pixel (sheet->row_geometry, i); + width = g_sheet_column_get_width (sheet->column_geometry, j); + height = g_sheet_row_get_height (sheet->row_geometry, i); if (mask2 & 1) gdk_draw_rectangle (sheet->sheet_window, sheet->xor_gc, TRUE, - x + 1,y - 1, - width,3); + x + 1, y - 1, + width, 3); if (mask2 & 2) gdk_draw_rectangle (sheet->sheet_window, sheet->xor_gc, TRUE, - x + 1,y + height - 1, - width,3); + x + 1, y + height - 1, + width, 3); if (mask2 & 4) gdk_draw_rectangle (sheet->sheet_window, sheet->xor_gc, TRUE, - x - 1,y + 1, - 3,height); + x - 1, y + 1, + 3, height); if (mask2 & 8) gdk_draw_rectangle (sheet->sheet_window, sheet->xor_gc, TRUE, - x + width - 1,y + 1, - 3,height); + x + width - 1, y + 1, + 3, height); @@ -4504,171 +3589,63 @@ gtk_sheet_new_selection (GtkSheet *sheet, GtkSheetRange *range) *range = new_range; - gtk_sheet_draw_corners (sheet, new_range); - } static void gtk_sheet_draw_border (GtkSheet *sheet, GtkSheetRange new_range) { - GtkWidget *widget; GdkRectangle area; - gint i; - gint x, y, width, height; + gint width, height; - widget = GTK_WIDGET (sheet); + gint x = COLUMN_LEFT_XPIXEL (sheet, new_range.col0); + gint y = g_sheet_row_start_pixel (sheet->row_geometry, new_range.row0); - x = COLUMN_LEFT_XPIXEL (sheet,new_range.col0); - y = ROW_TOP_YPIXEL (sheet,new_range.row0); - width = COLUMN_LEFT_XPIXEL (sheet, new_range.coli) - x + - xxx_column_width (sheet, new_range.coli); + if ( sheet->row_titles_visible) + x += sheet->row_title_area.width; - height = ROW_TOP_YPIXEL (sheet, new_range.rowi) - y + - yyy_row_height (sheet, new_range.rowi); + x -= sheet->hadjustment->value; - area.x = COLUMN_LEFT_XPIXEL (sheet, MIN_VISIBLE_COLUMN (sheet)); - area.y = ROW_TOP_YPIXEL (sheet, MIN_VISIBLE_ROW (sheet)); - area.width = sheet->sheet_window_width; - area.height = sheet->sheet_window_height; + if ( sheet->column_titles_visible) + y += sheet->column_title_area.height; - if (x < 0) - { - width = width + x; - x = 0; - } - if (width > area.width) width = area.width + 10; - if (y < 0) - { - height = height + y; - y = 0; - } - if (height > area.height) height = area.height + 10; + y -= sheet->vadjustment->value; - gdk_gc_set_clip_rectangle (sheet->xor_gc, &area); + width = COLUMN_LEFT_XPIXEL (sheet, new_range.coli) - + COLUMN_LEFT_XPIXEL (sheet, new_range.col0) + + + g_sheet_column_get_width (sheet->column_geometry, new_range.coli); - for (i =- 1; i <= 1; ++i) - gdk_draw_rectangle (sheet->sheet_window, - sheet->xor_gc, - FALSE, - x + i, - y + i, - width - 2 * i, - height - 2 * i); + height = g_sheet_row_start_pixel (sheet->row_geometry, new_range.rowi) - + g_sheet_row_start_pixel (sheet->row_geometry, new_range.row0) + + + g_sheet_row_get_height (sheet->row_geometry, new_range.rowi); - gdk_gc_set_clip_rectangle (sheet->xor_gc, NULL); + area.x = COLUMN_LEFT_XPIXEL (sheet, MIN_VISIBLE_COLUMN (sheet)); + if ( sheet->row_titles_visible) + area.x += sheet->row_title_area.width; + area.x -= sheet->hadjustment->value; - gtk_sheet_draw_corners (sheet, new_range); -} + area.y = g_sheet_row_start_pixel (sheet->row_geometry, MIN_VISIBLE_ROW (sheet)); + if ( sheet->column_titles_visible) + area.y += sheet->column_title_area.height; -static void -gtk_sheet_draw_corners (GtkSheet *sheet, GtkSheetRange range) -{ - gint x,y; - guint width = 1; - - if (gtk_sheet_cell_isvisible (sheet, range.row0, range.col0)) - { - x = COLUMN_LEFT_XPIXEL (sheet,range.col0); - y = ROW_TOP_YPIXEL (sheet,range.row0); - gdk_draw_pixmap (sheet->sheet_window, - GTK_WIDGET (sheet)->style->fg_gc[GTK_STATE_NORMAL], - sheet->pixmap, - x - 1, - y - 1, - x - 1, - y - 1, - 3, - 3); - gdk_draw_rectangle (sheet->sheet_window, - sheet->xor_gc, - TRUE, - x - 1,y - 1, - 3,3); - } + area.y -= sheet->vadjustment->value; - if (gtk_sheet_cell_isvisible (sheet, range.row0, range.coli) || - sheet->state == GTK_SHEET_COLUMN_SELECTED) - { - x = COLUMN_LEFT_XPIXEL (sheet,range.coli)+ - xxx_column_width (sheet, range.coli); - y = ROW_TOP_YPIXEL (sheet,range.row0); - width = 1; - if (sheet->state == GTK_SHEET_COLUMN_SELECTED) - { - y = ROW_TOP_YPIXEL (sheet, MIN_VISIBLE_ROW (sheet))+3; - width = 3; - } - gdk_draw_pixmap (sheet->sheet_window, - GTK_WIDGET (sheet)->style->fg_gc[GTK_STATE_NORMAL], - sheet->pixmap, - x - width, - y - width, - x - width, - y - width, - 2 * width + 1, - 2 * width + 1); - gdk_draw_rectangle (sheet->sheet_window, - sheet->xor_gc, - TRUE, - x - width + width / 2,y - width + width / 2, - 2 + width,2 + width); - } - if (gtk_sheet_cell_isvisible (sheet, range.rowi, range.col0) || - sheet->state == GTK_SHEET_ROW_SELECTED) - { - x = COLUMN_LEFT_XPIXEL (sheet,range.col0); - y = ROW_TOP_YPIXEL (sheet,range.rowi)+ - yyy_row_height (sheet, range.rowi); - width = 1; - if (sheet->state == GTK_SHEET_ROW_SELECTED) - { - x = COLUMN_LEFT_XPIXEL (sheet, MIN_VISIBLE_COLUMN (sheet))+3; - width = 3; - } - gdk_draw_pixmap (sheet->sheet_window, - GTK_WIDGET (sheet)->style->fg_gc[GTK_STATE_NORMAL], - sheet->pixmap, - x - width, - y - width, - x - width, - y - width, - 2 * width + 1, - 2 * width + 1); - gdk_draw_rectangle (sheet->sheet_window, - sheet->xor_gc, - TRUE, - x - width + width / 2,y - width + width / 2, - 2 + width,2 + width); - } - - if (gtk_sheet_cell_isvisible (sheet, range.rowi, range.coli)) - { - x = COLUMN_LEFT_XPIXEL (sheet,range.coli)+ - xxx_column_width (sheet, range.coli); - y = ROW_TOP_YPIXEL (sheet,range.rowi)+ - yyy_row_height (sheet, range.rowi); - width = 1; - if (sheet->state == GTK_SHEET_RANGE_SELECTED) width = 3; - if (sheet->state == GTK_SHEET_NORMAL) width = 3; - gdk_draw_pixmap (sheet->sheet_window, - GTK_WIDGET (sheet)->style->fg_gc[GTK_STATE_NORMAL], - sheet->pixmap, - x - width, - y - width, - x - width, - y - width, - 2 * width + 1, - 2 * width + 1); + area.width = sheet->sheet_window_width; + area.height = sheet->sheet_window_height; + + gdk_gc_set_clip_rectangle (sheet->xor_gc, &area); + gdk_draw_rectangle (sheet->sheet_window, sheet->xor_gc, - TRUE, - x - width + width / 2,y - width + width / 2, - 2 + width,2 + width); - - } + FALSE, + x, y, + width - 2, + height - 2); + gdk_gc_set_clip_rectangle (sheet->xor_gc, NULL); } @@ -4700,13 +3677,14 @@ gtk_sheet_real_select_range (GtkSheet * sheet, gtk_sheet_range_draw_selection (sheet, sheet->range); } - g_signal_emit (G_OBJECT (sheet), sheet_signals[SELECT_RANGE], 0, &sheet->range); + gtk_sheet_update_primary_selection (sheet); + + g_signal_emit (sheet, sheet_signals[SELECT_RANGE], 0, &sheet->range); } void -gtk_sheet_get_selected_range (GtkSheet *sheet, - GtkSheetRange *range) +gtk_sheet_get_selected_range (GtkSheet *sheet, GtkSheetRange *range) { g_return_if_fail (sheet != NULL); *range = sheet->range; @@ -4724,16 +3702,10 @@ gtk_sheet_select_range (GtkSheet * sheet, const GtkSheetRange *range) if (range->col0 < 0 || range->coli < 0) return; - if ( gtk_sheet_locked (sheet)) return ; - if (sheet->state != GTK_SHEET_NORMAL) gtk_sheet_real_unselect_range (sheet, NULL); else - { - gboolean veto = TRUE; - veto = gtk_sheet_deactivate_cell (sheet); - if (!veto) return; - } + gtk_sheet_deactivate_cell (sheet); sheet->range.row0 = range->row0; sheet->range.rowi = range->rowi; @@ -4746,14 +3718,17 @@ gtk_sheet_select_range (GtkSheet * sheet, const GtkSheetRange *range) sheet->state = GTK_SHEET_RANGE_SELECTED; gtk_sheet_real_select_range (sheet, NULL); - } void gtk_sheet_unselect_range (GtkSheet * sheet) { + if (! GTK_WIDGET_REALIZED (GTK_WIDGET (sheet))) + return; + gtk_sheet_real_unselect_range (sheet, NULL); sheet->state = GTK_STATE_NORMAL; + gtk_sheet_activate_cell (sheet, sheet->active_cell.row, sheet->active_cell.col); } @@ -4772,6 +3747,9 @@ gtk_sheet_real_unselect_range (GtkSheet * sheet, if (range->row0 < 0 || range->rowi < 0) return; if (range->col0 < 0 || range->coli < 0) return; + g_signal_emit (sheet, sheet_signals[SELECT_COLUMN], 0, -1); + g_signal_emit (sheet, sheet_signals[SELECT_ROW], 0, -1); + if (gtk_sheet_range_isvisible (sheet, *range)) gtk_sheet_draw_backing_pixmap (sheet, *range); @@ -4779,8 +3757,6 @@ gtk_sheet_real_unselect_range (GtkSheet * sheet, sheet->range.rowi = -1; sheet->range.col0 = -1; sheet->range.coli = -1; - - gtk_sheet_position_children (sheet); } @@ -4795,15 +3771,23 @@ gtk_sheet_expose (GtkWidget * widget, g_return_val_if_fail (GTK_IS_SHEET (widget), FALSE); g_return_val_if_fail (event != NULL, FALSE); + g_print ("%s %p\n", __FUNCTION__, widget); sheet = GTK_SHEET (widget); if (GTK_WIDGET_DRAWABLE (widget)) { - range.row0 = ROW_FROM_YPIXEL (sheet, event->area.y); + range.row0 = yyy_row_ypixel_to_row (sheet, event->area.y); range.col0 = COLUMN_FROM_XPIXEL (sheet, event->area.x); - range.rowi = ROW_FROM_YPIXEL (sheet, event->area.y + event->area.height); - range.coli = COLUMN_FROM_XPIXEL (sheet, event->area.x + event->area.width); + range.rowi = yyy_row_ypixel_to_row (sheet, + event->area.y + event->area.height); + + range.coli = COLUMN_FROM_XPIXEL (sheet, + event->area.x + event->area.width); + + g_print ("Redrawing rows %d--%d, columns %d--%d\n", + range.row0, range.rowi, range.col0, range.coli); + /* exposure events on the sheet */ if (event->window == sheet->row_title_window && @@ -4818,7 +3802,9 @@ gtk_sheet_expose (GtkWidget * widget, sheet->column_titles_visible) { gint i; - for (i = MIN_VISIBLE_COLUMN (sheet); i <= MAX_VISIBLE_COLUMN (sheet); i++) + for (i = MIN_VISIBLE_COLUMN (sheet); + i <= MAX_VISIBLE_COLUMN (sheet); + ++i) gtk_sheet_column_title_button_draw (sheet, i); } @@ -4842,11 +3828,7 @@ gtk_sheet_expose (GtkWidget * widget, if ((!GTK_SHEET_IN_XDRAG (sheet)) && (!GTK_SHEET_IN_YDRAG (sheet))) { if (sheet->state == GTK_SHEET_NORMAL) - { - gtk_sheet_draw_active_cell (sheet); - if (!GTK_SHEET_IN_SELECTION (sheet)) - gtk_widget_queue_draw (sheet->sheet_entry); - } + gtk_sheet_draw_active_cell (sheet); } } } @@ -4875,21 +3857,37 @@ gtk_sheet_button_press (GtkWidget * widget, sheet = GTK_SHEET (widget); - if ( event->type == GDK_2BUTTON_PRESS) + /* Cancel any pending tooltips */ + if (sheet->motion_timer) { - gtk_widget_get_pointer (widget, &x, &y); - gtk_sheet_get_pixel_info (sheet, x, y, &row, &column); + g_source_remove (sheet->motion_timer); + sheet->motion_timer = 0; + } - if (event->window == sheet->column_title_window) - { - g_signal_emit (G_OBJECT (sheet), - sheet_signals[DOUBLE_CLICK_COLUMN], 0, column); - } - else if (event->window == sheet->row_title_window) - { - g_signal_emit (G_OBJECT (sheet), - sheet_signals[DOUBLE_CLICK_ROW], 0, row); - } + gtk_widget_get_pointer (widget, &x, &y); + gtk_sheet_get_pixel_info (sheet, x, y, &row, &column); + + + if (event->window == sheet->column_title_window) + { + g_signal_emit (sheet, + sheet_signals[BUTTON_EVENT_COLUMN], 0, + column, event); + + if ( event->type == GDK_2BUTTON_PRESS && event->button == 1) + g_signal_emit (sheet, + sheet_signals[DOUBLE_CLICK_COLUMN], 0, column); + + } + else if (event->window == sheet->row_title_window) + { + g_signal_emit (sheet, + sheet_signals[BUTTON_EVENT_ROW], 0, + row, event); + + if ( event->type == GDK_2BUTTON_PRESS && event->button == 1) + g_signal_emit (sheet, + sheet_signals[DOUBLE_CLICK_ROW], 0, row); } @@ -4902,8 +3900,15 @@ gtk_sheet_button_press (GtkWidget * widget, if (event->window == sheet->column_title_window && gtk_sheet_columns_resizable (sheet)) { +#if 0 gtk_widget_get_pointer (widget, &sheet->x_drag, NULL); - if (POSSIBLE_XDRAG (sheet, sheet->x_drag, &sheet->drag_cell.col)) + 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; if (event->type == GDK_2BUTTON_PRESS) @@ -4975,7 +3980,7 @@ gtk_sheet_button_press (GtkWidget * widget, { row = sheet->active_cell.row; column = sheet->active_cell.col; - if (!gtk_sheet_deactivate_cell (sheet)) return FALSE; + gtk_sheet_deactivate_cell (sheet); sheet->active_cell.row = row; sheet->active_cell.col = column; sheet->drag_range = sheet->range; @@ -4995,7 +4000,6 @@ gtk_sheet_button_press (GtkWidget * widget, else if (sheet->cursor_drag->type == GDK_TOP_LEFT_ARROW && !GTK_SHEET_IN_SELECTION (sheet) && ! GTK_SHEET_IN_DRAG (sheet) - && ! gtk_sheet_locked (sheet) && sheet->active_cell.row >= 0 && sheet->active_cell.col >= 0 ) @@ -5004,7 +4008,7 @@ gtk_sheet_button_press (GtkWidget * widget, { row = sheet->active_cell.row; column = sheet->active_cell.col; - if (!gtk_sheet_deactivate_cell (sheet)) return FALSE; + gtk_sheet_deactivate_cell (sheet); sheet->active_cell.row = row; sheet->active_cell.col = column; sheet->drag_range = sheet->range; @@ -5033,9 +4037,14 @@ gtk_sheet_button_press (GtkWidget * widget, if (event->window == sheet->column_title_window) { gtk_widget_get_pointer (widget, &x, &y); + if ( sheet->row_titles_visible) + x -= sheet->row_title_area.width; + + x += sheet->hadjustment->value; + column = COLUMN_FROM_XPIXEL (sheet, x); - if (xxx_column_is_sensitive (sheet, column)) + if (g_sheet_column_get_sensitivity (sheet->column_geometry, column)) { gtk_sheet_click_cell (sheet, - 1, column, &veto); gtk_grab_add (GTK_WIDGET (sheet)); @@ -5047,8 +4056,13 @@ gtk_sheet_button_press (GtkWidget * widget, if (event->window == sheet->row_title_window) { gtk_widget_get_pointer (widget, &x, &y); - row = ROW_FROM_YPIXEL (sheet, y); - if (yyy_row_is_sensitive (sheet, row)) + if ( sheet->column_titles_visible) + y -= sheet->column_title_area.height; + + y += sheet->vadjustment->value; + + row = yyy_row_ypixel_to_row (sheet, y); + if (g_sheet_row_get_sensitivity (sheet->row_geometry, row)) { gtk_sheet_click_cell (sheet, row, - 1, &veto); gtk_grab_add (GTK_WIDGET (sheet)); @@ -5060,55 +4074,26 @@ gtk_sheet_button_press (GtkWidget * widget, return TRUE; } -#if 0 -static gint -gtk_sheet_scroll (gpointer data) -{ - GtkSheet *sheet; - gint x,y,row,column; - gint move; - - sheet = GTK_SHEET (data); - - GDK_THREADS_ENTER (); - - gtk_widget_get_pointer (GTK_WIDGET (sheet), &x, &y); - gtk_sheet_get_pixel_info (sheet, x, y, &row, &column); - - move = TRUE; - - if (GTK_SHEET_IN_SELECTION (sheet)) - gtk_sheet_extend_selection (sheet, row, column); - - if (GTK_SHEET_IN_DRAG (sheet) || GTK_SHEET_IN_RESIZE (sheet)) - { - move = gtk_sheet_move_query (sheet, row, column); - if (move) draw_xor_rectangle (sheet, sheet->drag_range); - } - - GDK_THREADS_LEAVE (); - - return TRUE; -} -#endif - static void gtk_sheet_click_cell (GtkSheet *sheet, gint row, gint column, gboolean *veto) { *veto = TRUE; - if (row >= yyy_row_count (sheet) || column >= xxx_column_count (sheet)) + if (row >= g_sheet_row_get_row_count (sheet->row_geometry) || column >= g_sheet_column_get_column_count (sheet->column_geometry)) { *veto = FALSE; return; } if (column >= 0 && row >= 0) - if (! xxx_column_is_visible (sheet, column) || !yyy_row_is_visible (sheet, row)) + { + if (! g_sheet_column_get_visibility (sheet->column_geometry, column) + || !g_sheet_row_get_visibility (sheet->row_geometry, row)) { *veto = FALSE; return; } + } _gtkextra_signal_emit (GTK_OBJECT (sheet), sheet_signals[TRAVERSE], sheet->active_cell.row, sheet->active_cell.col, @@ -5144,8 +4129,8 @@ gtk_sheet_click_cell (GtkSheet *sheet, gint row, gint column, gboolean *veto) { sheet->range.row0 = 0; sheet->range.col0 = 0; - sheet->range.rowi = yyy_row_count (sheet) - 1; - sheet->range.coli = xxx_column_count (sheet) - 1; + sheet->range.rowi = g_sheet_row_get_row_count (sheet->row_geometry) - 1; + sheet->range.coli = g_sheet_column_get_column_count (sheet->column_geometry) - 1; sheet->active_cell.row = 0; sheet->active_cell.col = 0; gtk_sheet_select_range (sheet, NULL); @@ -5161,11 +4146,8 @@ gtk_sheet_click_cell (GtkSheet *sheet, gint row, gint column, gboolean *veto) } else { - if (!gtk_sheet_deactivate_cell (sheet)) - { - *veto = FALSE; - return; - } + gtk_sheet_deactivate_cell (sheet); + gtk_sheet_activate_cell (sheet, row, column); } if (gtk_sheet_autoscroll (sheet)) @@ -5193,24 +4175,24 @@ static gint gtk_sheet_button_release (GtkWidget * widget, GdkEventButton * event) { - GtkSheet *sheet; - gint x,y; + gint y; - sheet = GTK_SHEET (widget); + GtkSheet *sheet = GTK_SHEET (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); - gtk_widget_get_pointer (widget, &x, NULL); + gdk_pointer_ungrab (event->time); draw_xor_vline (sheet); - gtk_sheet_set_column_width (sheet, sheet->drag_cell.col, - new_column_width (sheet, sheet->drag_cell.col, &x)); - sheet->old_hadjustment = -1.; - g_signal_emit_by_name (G_OBJECT (sheet->hadjustment), "value_changed"); + width = new_column_width (sheet, sheet->drag_cell.col, &xpos); + + gtk_sheet_set_column_width (sheet, sheet->drag_cell.col, width); return TRUE; } @@ -5222,9 +4204,9 @@ gtk_sheet_button_release (GtkWidget * widget, gdk_pointer_ungrab (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)); - sheet->old_vadjustment = -1.; - g_signal_emit_by_name (G_OBJECT (sheet->vadjustment), "value_changed"); + 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"); return TRUE; } @@ -5249,7 +4231,7 @@ gtk_sheet_button_release (GtkWidget * widget, old_range = sheet->range; sheet->range = sheet->drag_range; sheet->drag_range = old_range; - g_signal_emit (G_OBJECT (sheet), sheet_signals[MOVE_RANGE], 0, + g_signal_emit (sheet, sheet_signals[MOVE_RANGE], 0, &sheet->drag_range, &sheet->range); gtk_sheet_select_range (sheet, &sheet->range); } @@ -5280,7 +4262,7 @@ gtk_sheet_button_release (GtkWidget * widget, sheet->drag_range = old_range; if (sheet->state == GTK_STATE_NORMAL) sheet->state = GTK_SHEET_RANGE_SELECTED; - g_signal_emit (G_OBJECT (sheet), sheet_signals[RESIZE_RANGE], 0, + g_signal_emit (sheet, sheet_signals[RESIZE_RANGE], 0, &sheet->drag_range, &sheet->range); gtk_sheet_select_range (sheet, &sheet->range); } @@ -5302,6 +4284,9 @@ gtk_sheet_button_release (GtkWidget * widget, return TRUE; } + + + /* Shamelessly lifted from gtktooltips */ static gboolean gtk_sheet_subtitle_paint_window (GtkWidget *tip_window) @@ -5317,10 +4302,17 @@ gtk_sheet_subtitle_paint_window (GtkWidget *tip_window) return FALSE; } +static void +destroy_hover_window (GtkSheetHoverTitle *h) +{ + gtk_widget_destroy (h->window); + g_free (h); +} + static GtkSheetHoverTitle * create_hover_window (void) { - GtkSheetHoverTitle *hw = malloc (sizeof (*hw)); + GtkSheetHoverTitle *hw = g_malloc (sizeof (*hw)); hw->window = gtk_window_new (GTK_WINDOW_POPUP); @@ -5369,16 +4361,6 @@ show_subtitle (GtkSheet *sheet, gint row, gint column, const gchar *subtitle) if ( ! subtitle ) return; - if ( ! sheet->hover_window) - { - sheet->hover_window = create_hover_window (); - gtk_widget_add_events (GTK_WIDGET (sheet), GDK_LEAVE_NOTIFY_MASK); - - g_signal_connect_swapped (sheet, "leave-notify-event", - G_CALLBACK (gtk_widget_hide), - sheet->hover_window->window); - } - gtk_label_set_text (GTK_LABEL (sheet->hover_window->label), subtitle); @@ -5418,48 +4400,41 @@ static gboolean motion_timeout_callback (gpointer data) { GtkSheet *sheet = GTK_SHEET (data); - if ( --sheet->motion_events == 0 ) - { - gint x, y; - gint row, column; - gtk_widget_get_pointer (GTK_WIDGET (sheet), &x, &y); + gint x, y; + gint row, column; + gtk_widget_get_pointer (GTK_WIDGET (sheet), &x, &y); - if ( gtk_sheet_get_pixel_info (sheet, x, y, &row, &column) ) + if ( gtk_sheet_get_pixel_info (sheet, x, y, &row, &column) ) + { + if (sheet->row_title_under) { - if ( column == -1 && row == -1 ) - return FALSE; - - if ( column == -1) - { - GSheetRow *row_geo = sheet->row_geometry; - gchar *text; + GSheetRow *row_geo = sheet->row_geometry; + gchar *text; - text = g_sheet_row_get_subtitle (row_geo, row); + text = g_sheet_row_get_subtitle (row_geo, row); - show_subtitle (sheet, row, column, text); - g_free (text); - } + show_subtitle (sheet, row, -1, text); + g_free (text); + } - if ( row == -1) - { - GSheetColumn *col_geo = sheet->column_geometry; - gchar *text; + if (sheet->column_title_under) + { + GSheetColumn *col_geo = sheet->column_geometry; + gchar *text; - text = g_sheet_column_get_subtitle (col_geo, column); + text = g_sheet_column_get_subtitle (col_geo, column); - show_subtitle (sheet, row, column, text ); + show_subtitle (sheet, -1, column, text ); - g_free (text); - } + g_free (text); } } return FALSE; } -static gint -gtk_sheet_motion (GtkWidget * widget, - GdkEventMotion * event) +static gboolean +gtk_sheet_motion (GtkWidget *widget, GdkEventMotion *event) { GtkSheet *sheet; GdkModifierType mods; @@ -5477,10 +4452,12 @@ gtk_sheet_motion (GtkWidget * widget, x = event->x; y = event->y; - if (!sheet->hover_window || ! GTK_WIDGET_VISIBLE (sheet->hover_window->window)) + if (!GTK_WIDGET_VISIBLE (sheet->hover_window->window)) { - sheet->motion_events++; - g_timeout_add (TIMEOUT_HOVER, motion_timeout_callback, sheet); + if ( sheet->motion_timer > 0 ) + g_source_remove (sheet->motion_timer); + sheet->motion_timer = + g_timeout_add (TIMEOUT_HOVER, motion_timeout_callback, sheet); } else { @@ -5500,14 +4477,13 @@ gtk_sheet_motion (GtkWidget * widget, if (event->window == sheet->column_title_window && gtk_sheet_columns_resizable (sheet)) { - gtk_widget_get_pointer (widget, &x, &y); if (!GTK_SHEET_IN_SELECTION (sheet) && - POSSIBLE_XDRAG (sheet, x, &column)) + on_column_boundary (sheet, x, &column)) { new_cursor = GDK_SB_H_DOUBLE_ARROW; if (new_cursor != sheet->cursor_drag->type) { - gdk_cursor_destroy (sheet->cursor_drag); + gdk_cursor_unref (sheet->cursor_drag); sheet->cursor_drag = gdk_cursor_new (GDK_SB_H_DOUBLE_ARROW); gdk_window_set_cursor (sheet->column_title_window, sheet->cursor_drag); @@ -5519,7 +4495,7 @@ gtk_sheet_motion (GtkWidget * widget, if (!GTK_SHEET_IN_XDRAG (sheet) && new_cursor != sheet->cursor_drag->type) { - gdk_cursor_destroy (sheet->cursor_drag); + gdk_cursor_unref (sheet->cursor_drag); sheet->cursor_drag = gdk_cursor_new (GDK_TOP_LEFT_ARROW); gdk_window_set_cursor (sheet->column_title_window, sheet->cursor_drag); @@ -5530,13 +4506,12 @@ gtk_sheet_motion (GtkWidget * widget, if (event->window == sheet->row_title_window && gtk_sheet_rows_resizable (sheet)) { - gtk_widget_get_pointer (widget, &x, &y); - if (!GTK_SHEET_IN_SELECTION (sheet) && POSSIBLE_YDRAG (sheet,y, &column)) + if (!GTK_SHEET_IN_SELECTION (sheet) && POSSIBLE_YDRAG (sheet, y, &column)) { new_cursor = GDK_SB_V_DOUBLE_ARROW; if (new_cursor != sheet->cursor_drag->type) { - gdk_cursor_destroy (sheet->cursor_drag); + gdk_cursor_unref (sheet->cursor_drag); sheet->cursor_drag = gdk_cursor_new (GDK_SB_V_DOUBLE_ARROW); gdk_window_set_cursor (sheet->row_title_window, sheet->cursor_drag); } @@ -5547,7 +4522,7 @@ gtk_sheet_motion (GtkWidget * widget, if (!GTK_SHEET_IN_YDRAG (sheet) && new_cursor != sheet->cursor_drag->type) { - gdk_cursor_destroy (sheet->cursor_drag); + gdk_cursor_unref (sheet->cursor_drag); sheet->cursor_drag = gdk_cursor_new (GDK_TOP_LEFT_ARROW); gdk_window_set_cursor (sheet->row_title_window, sheet->cursor_drag); } @@ -5562,20 +4537,22 @@ gtk_sheet_motion (GtkWidget * widget, !GTK_SHEET_IN_RESIZE (sheet) && new_cursor != sheet->cursor_drag->type) { - gdk_cursor_destroy (sheet->cursor_drag); + gdk_cursor_unref (sheet->cursor_drag); sheet->cursor_drag = gdk_cursor_new (GDK_PLUS); gdk_window_set_cursor (sheet->sheet_window, sheet->cursor_drag); } new_cursor = GDK_TOP_LEFT_ARROW; if ( event->window == sheet->sheet_window && - ! (POSSIBLE_RESIZE (sheet,x,y,&row,&column) || GTK_SHEET_IN_RESIZE (sheet)) && (POSSIBLE_DRAG (sheet, x,y,&row,&column) || GTK_SHEET_IN_DRAG (sheet)) && - + ! (POSSIBLE_RESIZE (sheet, x, y, &row, &column) || + GTK_SHEET_IN_RESIZE (sheet)) && + (POSSIBLE_DRAG (sheet, x, y, &row, &column) || + GTK_SHEET_IN_DRAG (sheet)) && new_cursor != sheet->cursor_drag->type) { - gdk_cursor_destroy (sheet->cursor_drag); + gdk_cursor_unref (sheet->cursor_drag); sheet->cursor_drag = gdk_cursor_new (GDK_TOP_LEFT_ARROW); - gdk_window_set_cursor (sheet->sheet_window,sheet->cursor_drag); + gdk_window_set_cursor (sheet->sheet_window, sheet->cursor_drag); } new_cursor = GDK_SIZING; @@ -5586,9 +4563,9 @@ gtk_sheet_motion (GtkWidget * widget, GTK_SHEET_IN_RESIZE (sheet)) && new_cursor != sheet->cursor_drag->type) { - gdk_cursor_destroy (sheet->cursor_drag); + gdk_cursor_unref (sheet->cursor_drag); sheet->cursor_drag = gdk_cursor_new (GDK_SIZING); - gdk_window_set_cursor (sheet->sheet_window,sheet->cursor_drag); + gdk_window_set_cursor (sheet->sheet_window, sheet->cursor_drag); } @@ -5597,18 +4574,17 @@ gtk_sheet_motion (GtkWidget * widget, if (GTK_SHEET_IN_XDRAG (sheet)) { - if (event->is_hint || event->window != widget->window) - gtk_widget_get_pointer (widget, &x, NULL); - else x = event->x; new_column_width (sheet, sheet->drag_cell.col, &x); +#if 0 if (x != sheet->x_drag) { draw_xor_vline (sheet); sheet->x_drag = x; draw_xor_vline (sheet); } +#endif return TRUE; } @@ -5632,15 +4608,15 @@ gtk_sheet_motion (GtkWidget * widget, if (GTK_SHEET_IN_DRAG (sheet)) { GtkSheetRange aux; - column = COLUMN_FROM_XPIXEL (sheet,x)- sheet->drag_cell.col; - row = ROW_FROM_YPIXEL (sheet,y)- sheet->drag_cell.row; + column = COLUMN_FROM_XPIXEL (sheet, x)- sheet->drag_cell.col; + row = yyy_row_ypixel_to_row (sheet, y) - sheet->drag_cell.row; if (sheet->state == GTK_SHEET_COLUMN_SELECTED) row = 0; if (sheet->state == GTK_SHEET_ROW_SELECTED) column = 0; sheet->x_drag = x; sheet->y_drag = y; aux = sheet->range; - if (aux.row0 + row >= 0 && aux.rowi + row < yyy_row_count (sheet) && - aux.col0 + column >= 0 && aux.coli + column < xxx_column_count (sheet)) + if (aux.row0 + row >= 0 && aux.rowi + row < g_sheet_row_get_row_count (sheet->row_geometry) && + aux.col0 + column >= 0 && aux.coli + column < g_sheet_column_get_column_count (sheet->column_geometry)) { aux = sheet->drag_range; sheet->drag_range.row0 = sheet->range.row0 + row; @@ -5662,19 +4638,18 @@ gtk_sheet_motion (GtkWidget * widget, GtkSheetRange aux; gint v_h, current_col, current_row, col_threshold, row_threshold; v_h = 1; + if (abs (x - COLUMN_LEFT_XPIXEL (sheet, sheet->drag_cell.col)) > + abs (y - g_sheet_row_start_pixel (sheet->row_geometry, sheet->drag_cell.row))) v_h = 2; - if (abs (x - COLUMN_LEFT_XPIXEL (sheet,sheet->drag_cell.col)) > - abs (y - ROW_TOP_YPIXEL (sheet,sheet->drag_cell.row))) v_h = 2; - - current_col = COLUMN_FROM_XPIXEL (sheet,x); - current_row = ROW_FROM_YPIXEL (sheet,y); + current_col = COLUMN_FROM_XPIXEL (sheet, x); + current_row = yyy_row_ypixel_to_row (sheet, y); column = current_col - sheet->drag_cell.col; row = current_row - sheet->drag_cell.row; /*use half of column width resp. row height as threshold to expand selection*/ - col_threshold = COLUMN_LEFT_XPIXEL (sheet,current_col) + - xxx_column_width (sheet,current_col) / 2; + col_threshold = COLUMN_LEFT_XPIXEL (sheet, current_col) + + g_sheet_column_get_width (sheet->column_geometry, current_col) / 2; if (column > 0) { if (x < col_threshold) @@ -5685,8 +4660,8 @@ gtk_sheet_motion (GtkWidget * widget, if (x > col_threshold) column +=1; } - row_threshold = ROW_TOP_YPIXEL (sheet,current_row) + - yyy_row_height (sheet, current_row)/2; + row_threshold = g_sheet_row_start_pixel (sheet->row_geometry, current_row) + + g_sheet_row_get_height (sheet->row_geometry, current_row)/2; if (row > 0) { if (y < row_threshold) @@ -5709,8 +4684,8 @@ gtk_sheet_motion (GtkWidget * widget, else row = 0; - if (aux.row0 + row >= 0 && aux.rowi + row < yyy_row_count (sheet) && - aux.col0 + column >= 0 && aux.coli + column < xxx_column_count (sheet)) + if (aux.row0 + row >= 0 && aux.rowi + row < g_sheet_row_get_row_count (sheet->row_geometry) && + aux.col0 + column >= 0 && aux.coli + column < g_sheet_column_get_column_count (sheet->column_geometry)) { aux = sheet->drag_range; sheet->drag_range = sheet->range; @@ -5743,19 +4718,32 @@ gtk_sheet_motion (GtkWidget * widget, return TRUE; } +static gboolean +gtk_sheet_crossing_notify (GtkWidget *widget, + GdkEventCrossing *event) +{ + GtkSheet *sheet = GTK_SHEET (widget); + + if (event->window == sheet->column_title_window) + sheet->column_title_under = event->type == GDK_ENTER_NOTIFY; + else if (event->window == sheet->row_title_window) + sheet->row_title_under = event->type == GDK_ENTER_NOTIFY; + + return TRUE; +} + + static gboolean gtk_sheet_move_query (GtkSheet *sheet, gint row, gint column) { - gint row_move, column_move; - gfloat row_align, col_align; guint height, width; gint new_row = row; gint new_col = column; - row_move = FALSE; - column_move = FALSE; - row_align =- 1.; - col_align =- 1.; + gint row_move = FALSE; + gint column_move = FALSE; + gfloat row_align = -1.0; + gfloat col_align = -1.0; height = sheet->sheet_window_height; width = sheet->sheet_window_width; @@ -5763,11 +4751,11 @@ gtk_sheet_move_query (GtkSheet *sheet, gint row, gint column) if (row >= MAX_VISIBLE_ROW (sheet) && sheet->state != GTK_SHEET_COLUMN_SELECTED) { row_align = 1.; - new_row = MIN (yyy_row_count (sheet), row + 1); + new_row = MIN (g_sheet_row_get_row_count (sheet->row_geometry) - 1, row + 1); row_move = TRUE; - if (MAX_VISIBLE_ROW (sheet) == yyy_row_count (sheet) - 1 && - ROW_TOP_YPIXEL (sheet, yyy_row_count (sheet)- 1) + - yyy_row_height (sheet, yyy_row_count (sheet)- 1) < height) + if (MAX_VISIBLE_ROW (sheet) == g_sheet_row_get_row_count (sheet->row_geometry) - 1 && + g_sheet_row_start_pixel (sheet->row_geometry, g_sheet_row_get_row_count (sheet->row_geometry) - 1) + + g_sheet_row_get_height (sheet->row_geometry, g_sheet_row_get_row_count (sheet->row_geometry) - 1) < height) { row_move = FALSE; row_align = -1.; @@ -5781,11 +4769,11 @@ gtk_sheet_move_query (GtkSheet *sheet, gint row, gint column) if (column >= MAX_VISIBLE_COLUMN (sheet) && sheet->state != GTK_SHEET_ROW_SELECTED) { col_align = 1.; - new_col = MIN (xxx_column_count (sheet) - 1, column + 1); + new_col = MIN (g_sheet_column_get_column_count (sheet->column_geometry) - 1, column + 1); column_move = TRUE; - if (MAX_VISIBLE_COLUMN (sheet) == (xxx_column_count (sheet) - 1) && - COLUMN_LEFT_XPIXEL (sheet, xxx_column_count (sheet) - 1) + - xxx_column_width (sheet, xxx_column_count (sheet) - 1) < width) + if (MAX_VISIBLE_COLUMN (sheet) == (g_sheet_column_get_column_count (sheet->column_geometry) - 1) && + COLUMN_LEFT_XPIXEL (sheet, g_sheet_column_get_column_count (sheet->column_geometry) - 1) + + g_sheet_column_get_width (sheet->column_geometry, g_sheet_column_get_column_count (sheet->column_geometry) - 1) < width) { column_move = FALSE; col_align = -1.; @@ -5793,7 +4781,7 @@ gtk_sheet_move_query (GtkSheet *sheet, gint row, gint column) } if (column < MIN_VISIBLE_COLUMN (sheet) && sheet->state != GTK_SHEET_ROW_SELECTED) { - col_align = 0.; + col_align = 0.0; column_move = TRUE; } @@ -5810,7 +4798,7 @@ gtk_sheet_extend_selection (GtkSheet *sheet, gint row, gint column) { GtkSheetRange range; gint state; - gint r,c; + gint r, c; if (row == sheet->selection_cell.row && column == sheet->selection_cell.col) return; @@ -5827,10 +4815,10 @@ gtk_sheet_extend_selection (GtkSheet *sheet, gint row, gint column) switch (sheet->state) { case GTK_SHEET_ROW_SELECTED: - column = xxx_column_count (sheet) - 1; + column = g_sheet_column_get_column_count (sheet->column_geometry) - 1; break; case GTK_SHEET_COLUMN_SELECTED: - row = yyy_row_count (sheet) - 1; + row = g_sheet_row_get_row_count (sheet->row_geometry) - 1; break; case GTK_SHEET_NORMAL: sheet->state = GTK_SHEET_RANGE_SELECTED; @@ -5840,15 +4828,6 @@ gtk_sheet_extend_selection (GtkSheet *sheet, gint row, gint column) sheet->range.row0 = r; sheet->range.coli = c; sheet->range.rowi = r; - gdk_draw_pixmap (sheet->sheet_window, - GTK_WIDGET (sheet)->style->fg_gc[GTK_STATE_NORMAL], - sheet->pixmap, - COLUMN_LEFT_XPIXEL (sheet,c)- 1, - ROW_TOP_YPIXEL (sheet,r)- 1, - COLUMN_LEFT_XPIXEL (sheet,c)- 1, - ROW_TOP_YPIXEL (sheet,r)- 1, - xxx_column_width (sheet, c)+4, - yyy_row_height (sheet, r)+4); gtk_sheet_range_draw_selection (sheet, sheet->range); case GTK_SHEET_RANGE_SELECTED: sheet->state = GTK_SHEET_RANGE_SELECTED; @@ -5857,10 +4836,10 @@ gtk_sheet_extend_selection (GtkSheet *sheet, gint row, gint column) sheet->selection_cell.row = row; sheet->selection_cell.col = column; - range.col0 = MIN (column,sheet->active_cell.col); - range.coli = MAX (column,sheet->active_cell.col); - range.row0 = MIN (row,sheet->active_cell.row); - range.rowi = MAX (row,sheet->active_cell.row); + range.col0 = MIN (column, sheet->active_cell.col); + range.coli = MAX (column, sheet->active_cell.col); + range.row0 = MIN (row, sheet->active_cell.row); + range.rowi = MAX (row, sheet->active_cell.row); if (range.row0 != sheet->range.row0 || range.rowi != sheet->range.rowi || range.col0 != sheet->range.col0 || range.coli != sheet->range.coli || @@ -5874,7 +4853,7 @@ gtk_sheet_entry_key_press (GtkWidget *widget, GdkEventKey *key) { gboolean focus; - g_signal_emit_by_name (G_OBJECT (widget), "key_press_event", key, &focus); + g_signal_emit_by_name (widget, "key_press_event", key, &focus); return focus; } @@ -5909,17 +4888,17 @@ gtk_sheet_key_press (GtkWidget *widget, if (sheet->state == GTK_SHEET_NORMAL && !GTK_SHEET_IN_SELECTION (sheet)) g_signal_stop_emission_by_name (gtk_sheet_get_entry (sheet), - "key-press-event"); + "key-press-event"); row = sheet->active_cell.row; col = sheet->active_cell.col; if (sheet->state == GTK_SHEET_COLUMN_SELECTED) row = MIN_VISIBLE_ROW (sheet)- 1; if (sheet->state == GTK_SHEET_ROW_SELECTED) col = MIN_VISIBLE_COLUMN (sheet); - if (row < yyy_row_count (sheet) - 1) + if (row < g_sheet_row_get_row_count (sheet->row_geometry) - 1) { row = row + scroll; - while (!yyy_row_is_visible (sheet, row) && row < yyy_row_count (sheet)- 1) + while (!g_sheet_row_get_visibility (sheet->row_geometry, row) && row < g_sheet_row_get_row_count (sheet->row_geometry) - 1) row++; } gtk_sheet_click_cell (sheet, row, col, &veto); @@ -5935,7 +4914,7 @@ gtk_sheet_key_press (GtkWidget *widget, if (col > 0) { col = col - scroll; - while (! xxx_column_is_visible (sheet, col) && col > 0) col--; + while (! g_sheet_column_get_visibility (sheet->column_geometry, col) && col > 0) col--; col = MAX (0, col); } gtk_sheet_click_cell (sheet, row, col, &veto); @@ -5948,11 +4927,11 @@ gtk_sheet_key_press (GtkWidget *widget, col = MIN_VISIBLE_COLUMN (sheet)- 1; if (sheet->state == GTK_SHEET_COLUMN_SELECTED) row = MIN_VISIBLE_ROW (sheet); - if (col < xxx_column_count (sheet) - 1) + if (col < g_sheet_column_get_column_count (sheet->column_geometry) - 1) { col = col + scroll; - while (! xxx_column_is_visible (sheet, col) && - col < xxx_column_count (sheet) - 1) + while (! g_sheet_column_get_visibility (sheet->column_geometry, col) && + col < g_sheet_column_get_column_count (sheet->column_geometry) - 1) col++; } gtk_sheet_click_cell (sheet, row, col, &veto); @@ -5973,7 +4952,7 @@ gtk_sheet_key_press (GtkWidget *widget, if (sheet->selection_cell.row > 0) { row = sheet->selection_cell.row - scroll; - while (!yyy_row_is_visible (sheet, row) && row > 0) row--; + while (!g_sheet_row_get_visibility (sheet->row_geometry, row) && row > 0) row--; row = MAX (0, row); gtk_sheet_extend_selection (sheet, row, sheet->selection_cell.col); } @@ -5986,8 +4965,8 @@ gtk_sheet_key_press (GtkWidget *widget, if (state == GTK_SHEET_ROW_SELECTED) col = MIN_VISIBLE_COLUMN (sheet); row = row - scroll; - while (!yyy_row_is_visible (sheet, row) && row > 0) row--; - row = MAX (0,row); + while (!g_sheet_row_get_visibility (sheet->row_geometry, row) && row > 0) row--; + row = MAX (0, row); gtk_sheet_click_cell (sheet, row, col, &veto); extend_selection = FALSE; break; @@ -6003,26 +4982,26 @@ gtk_sheet_key_press (GtkWidget *widget, gtk_sheet_click_cell (sheet, row, col, &veto); if (!veto) break; } - if (sheet->selection_cell.row < yyy_row_count (sheet)- 1) + if (sheet->selection_cell.row < g_sheet_row_get_row_count (sheet->row_geometry) - 1) { row = sheet->selection_cell.row + scroll; - while (!yyy_row_is_visible (sheet, row) && row < yyy_row_count (sheet)- 1) row++; - row = MIN (yyy_row_count (sheet)- 1, row); + while (!g_sheet_row_get_visibility (sheet->row_geometry, row) && row < g_sheet_row_get_row_count (sheet->row_geometry) - 1) row++; + row = MIN (g_sheet_row_get_row_count (sheet->row_geometry) - 1, row); gtk_sheet_extend_selection (sheet, row, sheet->selection_cell.col); } return TRUE; } col = sheet->active_cell.col; row = sheet->active_cell.row; - if (sheet->active_cell.row < yyy_row_count (sheet)- 1) + if (sheet->active_cell.row < g_sheet_row_get_row_count (sheet->row_geometry) - 1) { if (state == GTK_SHEET_COLUMN_SELECTED) row = MIN_VISIBLE_ROW (sheet)- 1; if (state == GTK_SHEET_ROW_SELECTED) col = MIN_VISIBLE_COLUMN (sheet); row = row + scroll; - while (!yyy_row_is_visible (sheet, row) && row < yyy_row_count (sheet)- 1) row++; - row = MIN (yyy_row_count (sheet)- 1, row); + while (!g_sheet_row_get_visibility (sheet->row_geometry, row) && row < g_sheet_row_get_row_count (sheet->row_geometry) - 1) row++; + row = MIN (g_sheet_row_get_row_count (sheet->row_geometry) - 1, row); } gtk_sheet_click_cell (sheet, row, col, &veto); extend_selection = FALSE; @@ -6037,10 +5016,10 @@ gtk_sheet_key_press (GtkWidget *widget, gtk_sheet_click_cell (sheet, row, col, &veto); if (!veto) break; } - if (sheet->selection_cell.col < xxx_column_count (sheet) - 1) + if (sheet->selection_cell.col < g_sheet_column_get_column_count (sheet->column_geometry) - 1) { col = sheet->selection_cell.col + 1; - while (! xxx_column_is_visible (sheet, col) && col < xxx_column_count (sheet) - 1) + while (! g_sheet_column_get_visibility (sheet->column_geometry, col) && col < g_sheet_column_get_column_count (sheet->column_geometry) - 1) col++; gtk_sheet_extend_selection (sheet, sheet->selection_cell.row, col); } @@ -6048,14 +5027,14 @@ gtk_sheet_key_press (GtkWidget *widget, } col = sheet->active_cell.col; row = sheet->active_cell.row; - if (sheet->active_cell.col < xxx_column_count (sheet) - 1) + if (sheet->active_cell.col < g_sheet_column_get_column_count (sheet->column_geometry) - 1) { col ++; if (state == GTK_SHEET_ROW_SELECTED) col = MIN_VISIBLE_COLUMN (sheet)- 1; if (state == GTK_SHEET_COLUMN_SELECTED) row = MIN_VISIBLE_ROW (sheet); - while (! xxx_column_is_visible (sheet, col) && col < xxx_column_count (sheet) - 1) col++; + while (! g_sheet_column_get_visibility (sheet->column_geometry, col) && col < g_sheet_column_get_column_count (sheet->column_geometry) - 1) col++; if (strlen (gtk_entry_get_text (GTK_ENTRY (gtk_sheet_get_entry (sheet)))) == 0 || force_move) { @@ -6079,7 +5058,7 @@ gtk_sheet_key_press (GtkWidget *widget, if (sheet->selection_cell.col > 0) { col = sheet->selection_cell.col - 1; - while (! xxx_column_is_visible (sheet, col) && col > 0) col--; + while (! g_sheet_column_get_visibility (sheet->column_geometry, col) && col > 0) col--; gtk_sheet_extend_selection (sheet, sheet->selection_cell.row, col); } return TRUE; @@ -6090,7 +5069,7 @@ gtk_sheet_key_press (GtkWidget *widget, col = MIN_VISIBLE_COLUMN (sheet)- 1; if (state == GTK_SHEET_COLUMN_SELECTED) row = MIN_VISIBLE_ROW (sheet); - while (! xxx_column_is_visible (sheet, col) && col > 0) col--; + while (! g_sheet_column_get_visibility (sheet->column_geometry, col) && col > 0) col--; col = MAX (0, col); if (strlen (gtk_entry_get_text (GTK_ENTRY (gtk_sheet_get_entry (sheet)))) == 0 @@ -6104,13 +5083,13 @@ gtk_sheet_key_press (GtkWidget *widget, break; case GDK_Home: row = 0; - while (!yyy_row_is_visible (sheet, row) && row < yyy_row_count (sheet)- 1) row++; + while (!g_sheet_row_get_visibility (sheet->row_geometry, row) && row < g_sheet_row_get_row_count (sheet->row_geometry) - 1) row++; gtk_sheet_click_cell (sheet, row, sheet->active_cell.col, &veto); extend_selection = FALSE; break; case GDK_End: - row = yyy_row_count (sheet)- 1; - while (!yyy_row_is_visible (sheet, row) && row > 0) row--; + row = g_sheet_row_get_row_count (sheet->row_geometry) - 1; + while (!g_sheet_row_get_visibility (sheet->row_geometry, row) && row > 0) row--; gtk_sheet_click_cell (sheet, row, sheet->active_cell.col, &veto); extend_selection = FALSE; break; @@ -6140,9 +5119,6 @@ gtk_sheet_size_request (GtkWidget * widget, GtkRequisition * requisition) { GtkSheet *sheet; - GList *children; - GtkSheetChild *child; - GtkRequisition child_requisition; g_return_if_fail (widget != NULL); g_return_if_fail (GTK_IS_SHEET (widget)); @@ -6160,15 +5136,6 @@ gtk_sheet_size_request (GtkWidget * widget, /* compute the size of the row title area */ if (sheet->row_titles_visible) requisition->width += sheet->row_title_area.width; - - children = sheet->children; - while (children) - { - child = children->data; - children = children->next; - - gtk_widget_size_request (child->widget, &child_requisition); - } } @@ -6221,10 +5188,16 @@ 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; + if (sheet->row_titles_visible) + { sheet->column_title_area.x = sheet->row_title_area.width; - sheet->column_title_area.width = sheet_allocation.width - - sheet->column_title_area.x; + sheet->sheet_window_width -= sheet->row_title_area.width; + } + + sheet->column_title_area.width = sheet_allocation.width ; + + if (GTK_WIDGET_REALIZED (widget) && sheet->column_titles_visible) gdk_window_move_resize (sheet->column_title_window, sheet->column_title_area.x, @@ -6232,8 +5205,6 @@ gtk_sheet_size_allocate (GtkWidget * widget, sheet->column_title_area.width, sheet->column_title_area.height); - sheet->sheet_window_width = sheet_allocation.width; - sheet->sheet_window_height = sheet_allocation.height; /* column button allocation */ size_allocate_column_title_buttons (sheet); @@ -6242,7 +5213,11 @@ gtk_sheet_size_allocate (GtkWidget * widget, 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->sheet_window_height -= sheet->column_title_area.height; + } + sheet->row_title_area.height = sheet_allocation.height - sheet->row_title_area.y; @@ -6259,8 +5234,7 @@ gtk_sheet_size_allocate (GtkWidget * widget, size_allocate_column_title_buttons (sheet); /* re - scale backing pixmap */ - gtk_sheet_make_backing_pixmap (sheet, 0, 0); - gtk_sheet_position_children (sheet); + gtk_sheet_make_backing_pixmap (sheet); /* set the scrollbars adjustments */ adjust_scrollbars (sheet); @@ -6270,18 +5244,18 @@ static void size_allocate_column_title_buttons (GtkSheet * sheet) { gint i; - gint x,width; + gint x, width; if (!sheet->column_titles_visible) return; if (!GTK_WIDGET_REALIZED (sheet)) return; + width = sheet->sheet_window_width; x = 0; if (sheet->row_titles_visible) { - width -= sheet->row_title_area.width; x = sheet->row_title_area.width; } @@ -6296,15 +5270,16 @@ size_allocate_column_title_buttons (GtkSheet * sheet) sheet->column_title_area.height); } - - if (MAX_VISIBLE_COLUMN (sheet) == xxx_column_count (sheet) - 1) + if (MAX_VISIBLE_COLUMN (sheet) == g_sheet_column_get_column_count (sheet->column_geometry) - 1) gdk_window_clear_area (sheet->column_title_window, - 0,0, + 0, 0, sheet->column_title_area.width, sheet->column_title_area.height); if (!GTK_WIDGET_DRAWABLE (sheet)) return; + size_allocate_global_button (sheet); + for (i = MIN_VISIBLE_COLUMN (sheet); i <= MAX_VISIBLE_COLUMN (sheet); i++) gtk_sheet_column_title_button_draw (sheet, i); } @@ -6324,7 +5299,6 @@ size_allocate_row_title_buttons (GtkSheet * sheet) if (sheet->column_titles_visible) { - height -= sheet->column_title_area.height; y = sheet->column_title_area.height; } @@ -6338,17 +5312,19 @@ size_allocate_row_title_buttons (GtkSheet * sheet) sheet->row_title_area.width, sheet->row_title_area.height); } - if (MAX_VISIBLE_ROW (sheet) == yyy_row_count (sheet)- 1) + if (MAX_VISIBLE_ROW (sheet) == g_sheet_row_get_row_count (sheet->row_geometry) - 1) gdk_window_clear_area (sheet->row_title_window, - 0,0, + 0, 0, sheet->row_title_area.width, sheet->row_title_area.height); if (!GTK_WIDGET_DRAWABLE (sheet)) return; + size_allocate_global_button (sheet); + for (i = MIN_VISIBLE_ROW (sheet); i <= MAX_VISIBLE_ROW (sheet); i++) { - if ( i >= yyy_row_count (sheet)) + if ( i >= g_sheet_row_get_row_count (sheet->row_geometry)) break; gtk_sheet_row_title_button_draw (sheet, i); } @@ -6376,7 +5352,7 @@ gtk_sheet_size_allocate_entry (GtkSheet *sheet) &attributes) ) return ; - if ( GTK_WIDGET_REALIZED (sheet->sheet_entry) ) + if ( GTK_WIDGET_REALIZED (sheet->entry_widget) ) { if (!GTK_WIDGET (sheet_entry)->style) gtk_widget_ensure_style (GTK_WIDGET (sheet_entry)); @@ -6396,12 +5372,12 @@ gtk_sheet_size_allocate_entry (GtkSheet *sheet) style->font_desc = pango_font_description_copy (attributes.font_desc); GTK_WIDGET (sheet_entry)->style = style; - gtk_widget_size_request (sheet->sheet_entry, NULL); + gtk_widget_size_request (sheet->entry_widget, NULL); GTK_WIDGET (sheet_entry)->style = previous_style; if (style != previous_style) { - if (!GTK_IS_ITEM_ENTRY (sheet->sheet_entry)) + if (!GTK_IS_ITEM_ENTRY (sheet->entry_widget)) { style->bg[GTK_STATE_NORMAL] = previous_style->bg[GTK_STATE_NORMAL]; style->fg[GTK_STATE_NORMAL] = previous_style->fg[GTK_STATE_NORMAL]; @@ -6409,6 +5385,7 @@ gtk_sheet_size_allocate_entry (GtkSheet *sheet) style->fg[GTK_STATE_ACTIVE] = previous_style->fg[GTK_STATE_ACTIVE]; } gtk_widget_set_style (GTK_WIDGET (sheet_entry), style); + g_object_unref (style); } } @@ -6422,27 +5399,34 @@ gtk_sheet_size_allocate_entry (GtkSheet *sheet) if (text && strlen (text) > 0) text_size = STRING_WIDTH (GTK_WIDGET (sheet), attributes.font_desc, text); - column_width = xxx_column_width (sheet, sheet->active_cell.col); + column_width = g_sheet_column_get_width (sheet->column_geometry, sheet->active_cell.col); size = MIN (text_size, max_size); - size = MAX (size,column_width - 2 * CELLOFFSET); + size = MAX (size, column_width - 2 * COLUMN_TITLES_HEIGHT); row = sheet->active_cell.row; col = sheet->active_cell.col; - shentry_allocation.x = COLUMN_LEFT_XPIXEL (sheet,sheet->active_cell.col); - shentry_allocation.y = ROW_TOP_YPIXEL (sheet,sheet->active_cell.row); + shentry_allocation.x = COLUMN_LEFT_XPIXEL (sheet, sheet->active_cell.col); + shentry_allocation.y = g_sheet_row_start_pixel (sheet->row_geometry, sheet->active_cell.row); + if ( sheet->column_titles_visible) + shentry_allocation.y += sheet->column_title_area.height; + + shentry_allocation.y -= sheet->vadjustment->value; + + if ( sheet->row_titles_visible) + shentry_allocation.x += sheet->row_title_area.width; + + shentry_allocation.x -= sheet->hadjustment->value; + shentry_allocation.width = column_width; - shentry_allocation.height = yyy_row_height (sheet, sheet->active_cell.row); + shentry_allocation.height = g_sheet_row_get_height (sheet->row_geometry, sheet->active_cell.row); - if (GTK_IS_ITEM_ENTRY (sheet->sheet_entry)) + if (GTK_IS_ITEM_ENTRY (sheet->entry_widget)) { - shentry_allocation.height -= 2 * CELLOFFSET; - shentry_allocation.y += CELLOFFSET; - if (gtk_sheet_clip_text (sheet)) - shentry_allocation.width = column_width - 2 * CELLOFFSET; - else - shentry_allocation.width = size; + shentry_allocation.height -= 2 * COLUMN_TITLES_HEIGHT; + shentry_allocation.y += COLUMN_TITLES_HEIGHT; + shentry_allocation.width = size; switch (GTK_ITEM_ENTRY (sheet_entry)->justification) { @@ -6450,16 +5434,16 @@ gtk_sheet_size_allocate_entry (GtkSheet *sheet) shentry_allocation.x += column_width / 2 - size / 2; break; case GTK_JUSTIFY_RIGHT: - shentry_allocation.x += column_width - size - CELLOFFSET; + shentry_allocation.x += column_width - size - COLUMN_TITLES_HEIGHT; break; case GTK_JUSTIFY_LEFT: case GTK_JUSTIFY_FILL: - shentry_allocation.x += CELLOFFSET; + shentry_allocation.x += COLUMN_TITLES_HEIGHT; break; } } - if (!GTK_IS_ITEM_ENTRY (sheet->sheet_entry)) + if (!GTK_IS_ITEM_ENTRY (sheet->entry_widget)) { shentry_allocation.x += 2; shentry_allocation.y += 2; @@ -6467,7 +5451,7 @@ gtk_sheet_size_allocate_entry (GtkSheet *sheet) shentry_allocation.height -= MIN (shentry_allocation.height, 3); } - gtk_widget_size_allocate (sheet->sheet_entry, &shentry_allocation); + gtk_widget_size_allocate (sheet->entry_widget, &shentry_allocation); if (previous_style == style) g_object_unref (previous_style); } @@ -6478,17 +5462,17 @@ gtk_sheet_entry_set_max_size (GtkSheet *sheet) gint i; gint size = 0; gint sizel = 0, sizer = 0; - gint row,col; + gint row, col; GtkJustification justification; gchar *s = NULL; row = sheet->active_cell.row; col = sheet->active_cell.col; - if ( ! GTK_IS_ITEM_ENTRY (sheet->sheet_entry) || gtk_sheet_clip_text (sheet)) + if ( ! GTK_IS_ITEM_ENTRY (sheet->entry_widget) ) return; - justification = GTK_ITEM_ENTRY (sheet->sheet_entry)->justification; + justification = GTK_ITEM_ENTRY (sheet->entry_widget)->justification; switch (justification) { @@ -6501,7 +5485,7 @@ gtk_sheet_entry_set_max_size (GtkSheet *sheet) g_free (s); break; } - size +=xxx_column_width (sheet, i); + size +=g_sheet_column_get_width (sheet->column_geometry, i); } size = MIN (size, sheet->sheet_window_width - COLUMN_LEFT_XPIXEL (sheet, col)); break; @@ -6513,13 +5497,13 @@ gtk_sheet_entry_set_max_size (GtkSheet *sheet) g_free (s); break; } - size +=xxx_column_width (sheet, i); + size +=g_sheet_column_get_width (sheet->column_geometry, i); } break; case GTK_JUSTIFY_CENTER: for (i = col + 1; i <= MAX_VISIBLE_COLUMN (sheet); i++) { - sizer += xxx_column_width (sheet, i); + sizer += g_sheet_column_get_width (sheet->column_geometry, i); } for (i = col - 1; i >= MIN_VISIBLE_COLUMN (sheet); i--) { @@ -6528,84 +5512,64 @@ gtk_sheet_entry_set_max_size (GtkSheet *sheet) g_free (s); break; } - sizel +=xxx_column_width (sheet, i); + sizel +=g_sheet_column_get_width (sheet->column_geometry, i); } size = 2 * MIN (sizel, sizer); break; } if (size != 0) - size += xxx_column_width (sheet, col); - GTK_ITEM_ENTRY (sheet->sheet_entry)->text_max_size = size; + size += g_sheet_column_get_width (sheet->column_geometry, col); + GTK_ITEM_ENTRY (sheet->entry_widget)->text_max_size = size; } static void create_sheet_entry (GtkSheet *sheet) { - GtkWidget *widget; - GtkWidget *parent; - GtkWidget *entry; - gint found_entry = FALSE; - - widget = GTK_WIDGET (sheet); - - if (sheet->sheet_entry) + if (sheet->entry_widget) { - /* avoids warnings */ - gtk_widget_ref (sheet->sheet_entry); - gtk_widget_unparent (sheet->sheet_entry); - gtk_widget_destroy (sheet->sheet_entry); + gtk_widget_unparent (sheet->entry_widget); } if (sheet->entry_type) { - if (!g_type_is_a (sheet->entry_type, GTK_TYPE_ENTRY)) - { - parent = g_object_new (sheet->entry_type, NULL); + 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->sheet_entry = parent; - - entry = gtk_sheet_get_entry (sheet); - if (GTK_IS_ENTRY (entry)) - found_entry = TRUE; - } - else + if ( NULL == sheet->entry_widget) { - parent = g_object_new (sheet->entry_type, NULL); - entry = parent; - found_entry = TRUE; + 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_item_entry_new (); } - - if (!found_entry) + else { - g_warning ("Entry type must be GtkEntry subclass, using default"); - entry = gtk_item_entry_new (); - sheet->sheet_entry = entry; + sheet->entry_widget = sheet->entry_container ; } - else - sheet->sheet_entry = parent; } else { - entry = gtk_item_entry_new (); - sheet->sheet_entry = entry; + sheet->entry_widget = sheet->entry_container = gtk_item_entry_new (); + g_object_ref_sink (sheet->entry_container); } - gtk_widget_size_request (sheet->sheet_entry, NULL); + gtk_widget_size_request (sheet->entry_widget, NULL); if (GTK_WIDGET_REALIZED (sheet)) { - gtk_widget_set_parent_window (sheet->sheet_entry, sheet->sheet_window); - gtk_widget_set_parent (sheet->sheet_entry, GTK_WIDGET (sheet)); - gtk_widget_realize (sheet->sheet_entry); + gtk_widget_set_parent_window (sheet->entry_widget, sheet->sheet_window); + gtk_widget_set_parent (sheet->entry_widget, GTK_WIDGET (sheet)); + gtk_widget_realize (sheet->entry_widget); } - g_signal_connect_swapped (G_OBJECT (entry), "key_press_event", + g_signal_connect_swapped (sheet->entry_widget, "key_press_event", G_CALLBACK (gtk_sheet_entry_key_press), sheet); - gtk_widget_show (sheet->sheet_entry); + gtk_widget_show (sheet->entry_widget); } @@ -6625,20 +5589,15 @@ gtk_sheet_get_entry (GtkSheet *sheet) { GtkWidget *parent; GtkWidget *entry = NULL; - GtkTableChild *table_child; - GtkBoxChild *box_child; - GList *children = NULL; g_return_val_if_fail (sheet != NULL, NULL); g_return_val_if_fail (GTK_IS_SHEET (sheet), NULL); - g_return_val_if_fail (sheet->sheet_entry != NULL, NULL); + g_return_val_if_fail (sheet->entry_widget != NULL, NULL); - if (GTK_IS_ENTRY (sheet->sheet_entry)) return (sheet->sheet_entry); + if (GTK_IS_ENTRY (sheet->entry_container)) + return (sheet->entry_container); - parent = GTK_WIDGET (sheet->sheet_entry); - - if (GTK_IS_TABLE (parent)) children = GTK_TABLE (parent)->children; - if (GTK_IS_BOX (parent)) children = GTK_BOX (parent)->children; + parent = sheet->entry_container; if (GTK_IS_CONTAINER (parent)) { @@ -6648,27 +5607,6 @@ gtk_sheet_get_entry (GtkSheet *sheet) return entry; } - if (!children) return NULL; - - while (children) - { - if (GTK_IS_TABLE (parent)) - { - table_child = children->data; - entry = table_child->widget; - } - if (GTK_IS_BOX (parent)) - { - box_child = children->data; - entry = box_child->widget; - } - - if (GTK_IS_ENTRY (entry)) - break; - children = children->next; - } - - if (!GTK_IS_ENTRY (entry)) return NULL; return (entry); @@ -6680,9 +5618,9 @@ 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->sheet_entry != NULL, NULL); + g_return_val_if_fail (sheet->entry_widget != NULL, NULL); - return (sheet->sheet_entry); + return (sheet->entry_widget); } @@ -6693,7 +5631,6 @@ gtk_sheet_button_draw (GtkSheet *sheet, GdkWindow *window, { GtkShadowType shadow_type; gint text_width = 0, text_height = 0; - GtkSheetChild *child = NULL; PangoAlignment align = PANGO_ALIGN_LEFT; gboolean rtl ; @@ -6705,6 +5642,7 @@ gtk_sheet_button_draw (GtkSheet *sheet, GdkWindow *window, g_return_if_fail (sheet != NULL); g_return_if_fail (button != NULL); + rtl = gtk_widget_get_direction (GTK_WIDGET (sheet)) == GTK_TEXT_DIR_RTL; gdk_window_clear_area (window, @@ -6737,11 +5675,13 @@ gtk_sheet_button_draw (GtkSheet *sheet, GdkWindow *window, if (button->label_visible) { - text_height = DEFAULT_ROW_HEIGHT (GTK_WIDGET (sheet))- 2 * CELLOFFSET; + text_height = DEFAULT_ROW_HEIGHT (GTK_WIDGET (sheet)) - + 2 * COLUMN_TITLES_HEIGHT; gdk_gc_set_clip_rectangle (GTK_WIDGET (sheet)->style->fg_gc[button->state], &allocation); - gdk_gc_set_clip_rectangle (GTK_WIDGET (sheet)->style->white_gc, &allocation); + gdk_gc_set_clip_rectangle (GTK_WIDGET (sheet)->style->white_gc, + &allocation); allocation.y += 2 * sheet->button->style->ythickness; @@ -6773,11 +5713,11 @@ gtk_sheet_button_draw (GtkSheet *sheet, GdkWindow *window, switch (button->justification) { case GTK_JUSTIFY_LEFT: - real_x = allocation.x + CELLOFFSET; + real_x = allocation.x + COLUMN_TITLES_HEIGHT; align = rtl ? PANGO_ALIGN_RIGHT : PANGO_ALIGN_LEFT; break; case GTK_JUSTIFY_RIGHT: - real_x = allocation.x + allocation.width - text_width - CELLOFFSET; + real_x = allocation.x + allocation.width - text_width - COLUMN_TITLES_HEIGHT; align = rtl ? PANGO_ALIGN_LEFT : PANGO_ALIGN_RIGHT; break; case GTK_JUSTIFY_CENTER: @@ -6796,7 +5736,7 @@ gtk_sheet_button_draw (GtkSheet *sheet, GdkWindow *window, "label", real_x, real_y, layout); - g_object_unref (G_OBJECT (layout)); + g_object_unref (layout); real_y += text_height + 2; @@ -6815,89 +5755,41 @@ gtk_sheet_button_draw (GtkSheet *sheet, GdkWindow *window, } - if ((child = button->child) && (child->widget)) - { - child->x = allocation.x; - child->y = allocation.y; - - child->x += (allocation.width - child->widget->requisition.width) / 2; - child->y += (allocation.height - child->widget->requisition.height) / 2; - allocation.x = child->x; - allocation.y = child->y; - allocation.width = child->widget->requisition.width; - allocation.height = child->widget->requisition.height; - - allocation.x = child->x; - allocation.y = child->y; - - gtk_widget_set_state (child->widget, button->state); - - if (GTK_WIDGET_REALIZED (GTK_WIDGET (sheet)) && - GTK_WIDGET_MAPPED (child->widget)) - { - gtk_widget_size_allocate (child->widget, - &allocation); - gtk_widget_queue_draw (child->widget); - } - } - gtk_sheet_button_free (button); } - -/* COLUMN value of - 1 indicates that the area to the right of the rightmost - button should be redrawn */ static void gtk_sheet_column_title_button_draw (GtkSheet *sheet, gint column) { - GdkWindow *window = NULL; GdkRectangle allocation; GtkSheetButton *button = NULL; gboolean is_sensitive = FALSE; if (!GTK_WIDGET_REALIZED (GTK_WIDGET (sheet))) return; - if (column >= 0 && ! xxx_column_is_visible (sheet, column)) return; - if (column >= 0 && !sheet->column_titles_visible) return; - if (column >= 0 && column < MIN_VISIBLE_COLUMN (sheet)) return; - if (column >= 0 && column > MAX_VISIBLE_COLUMN (sheet)) return; - - window = sheet->column_title_window; - allocation.y = 0; - allocation.height = sheet->column_title_area.height; + if (!sheet->column_titles_visible) return; + if (!g_sheet_column_get_visibility (sheet->column_geometry, column)) return; - if ( column == -1 ) - { - const gint cols = xxx_column_count (sheet) ; - allocation.x = COLUMN_LEFT_XPIXEL (sheet, cols - 1) - ; - allocation.width = sheet->column_title_area.width - + sheet->column_title_area.x - - allocation.x; + if (column < MIN_VISIBLE_COLUMN (sheet)) return; + if (column > MAX_VISIBLE_COLUMN (sheet)) return; - gdk_window_clear_area (window, - allocation.x, allocation.y, - allocation.width, allocation.height); - } - else - { - button = xxx_column_button (sheet, column); + button = g_sheet_column_get_button (sheet->column_geometry, column); + allocation.y = 0; allocation.x = COLUMN_LEFT_XPIXEL (sheet, column) + CELL_SPACING; - if (sheet->row_titles_visible) - allocation.x -= sheet->row_title_area.width; + allocation.x -= sheet->hadjustment->value; - allocation.width = xxx_column_width (sheet, column); + allocation.height = sheet->column_title_area.height; + allocation.width = g_sheet_column_get_width (sheet->column_geometry, column); + is_sensitive = g_sheet_column_get_sensitivity (sheet->column_geometry, column); - is_sensitive = xxx_column_is_sensitive (sheet, column); - gtk_sheet_button_draw (sheet, window, button, - is_sensitive, allocation); + gtk_sheet_button_draw (sheet, sheet->column_title_window, + button, is_sensitive, allocation); } -} + static void gtk_sheet_row_title_button_draw (GtkSheet *sheet, gint row) { - GdkWindow *window = NULL; GdkRectangle allocation; GtkSheetButton *button = NULL; gboolean is_sensitive = FALSE; @@ -6905,23 +5797,23 @@ gtk_sheet_row_title_button_draw (GtkSheet *sheet, gint row) if (!GTK_WIDGET_REALIZED (GTK_WIDGET (sheet))) return; - if (row >= 0 && !yyy_row_is_visible (sheet, row)) return; - if (row >= 0 && !sheet->row_titles_visible) return; - if (row >= 0 && row < MIN_VISIBLE_ROW (sheet)) return; - if (row >= 0 && row > MAX_VISIBLE_ROW (sheet)) return; + if (!sheet->row_titles_visible) return; + if (!g_sheet_row_get_visibility (sheet->row_geometry, row)) return; + if (row < MIN_VISIBLE_ROW (sheet)) return; + if (row > MAX_VISIBLE_ROW (sheet)) return; - window = sheet->row_title_window; - button = yyy_row_button (sheet, row); + button = g_sheet_row_get_button (sheet->row_geometry, row); allocation.x = 0; - allocation.y = ROW_TOP_YPIXEL (sheet, row) + CELL_SPACING; - if (sheet->column_titles_visible) - allocation.y -= sheet->column_title_area.height; + allocation.y = g_sheet_row_start_pixel (sheet->row_geometry, row) + CELL_SPACING; + allocation.y -= sheet->vadjustment->value; + allocation.width = sheet->row_title_area.width; - allocation.height = yyy_row_height (sheet, row); - is_sensitive = yyy_row_is_sensitive (sheet, row); + allocation.height = g_sheet_row_get_height (sheet->row_geometry, row); + is_sensitive = g_sheet_row_get_sensitivity (sheet->row_geometry, row); - gtk_sheet_button_draw (sheet, window, button, is_sensitive, allocation); + gtk_sheet_button_draw (sheet, sheet->row_title_window, + button, is_sensitive, allocation); } /* SCROLLBARS @@ -6936,24 +5828,41 @@ adjust_scrollbars (GtkSheet * sheet) { if (sheet->vadjustment) { - sheet->vadjustment->page_size = sheet->sheet_window_height; - sheet->vadjustment->page_increment = sheet->sheet_window_height / 2; - sheet->vadjustment->step_increment = DEFAULT_ROW_HEIGHT (GTK_WIDGET (sheet)); + sheet->vadjustment->step_increment = + 1 ; // DEFAULT_ROW_HEIGHT (GTK_WIDGET (sheet)); + + sheet->vadjustment->page_increment = + sheet->sheet_window_height - DEFAULT_ROW_HEIGHT (GTK_WIDGET (sheet)); + + sheet->vadjustment->upper = DEFAULT_ROW_HEIGHT (GTK_WIDGET (sheet)) + * g_sheet_row_get_row_count (sheet->row_geometry); + + sheet->vadjustment->lower = 0; - sheet->vadjustment->upper = SHEET_HEIGHT (sheet) + 80; - g_signal_emit_by_name (G_OBJECT (sheet->vadjustment), "changed"); + sheet->vadjustment->page_size = sheet->sheet_window_height; + g_signal_emit_by_name (sheet->vadjustment, "changed"); } if (sheet->hadjustment) { - sheet->hadjustment->page_size = sheet->sheet_window_width; - sheet->hadjustment->page_increment = sheet->sheet_window_width / 2; - sheet->hadjustment->step_increment = DEFAULT_COLUMN_WIDTH; + gint last_col; + sheet->hadjustment->step_increment = 1 ; //DEFAULT_COLUMN_WIDTH; + + sheet->hadjustment->page_increment = sheet->sheet_window_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) + + + g_sheet_column_get_width (sheet->column_geometry, last_col) + ; + sheet->hadjustment->lower = 0; - sheet->hadjustment->upper = SHEET_WIDTH (sheet)+ 80; - g_signal_emit_by_name (G_OBJECT (sheet->hadjustment), "changed"); + sheet->hadjustment->page_size = sheet->sheet_window_width; + g_signal_emit_by_name (sheet->hadjustment, "changed"); } } @@ -6961,210 +5870,33 @@ static void vadjustment_value_changed (GtkAdjustment * adjustment, gpointer data) { - GtkSheet *sheet; - gint diff, value, old_value; - gint row, new_row; - gint y = 0; + GtkSheet *sheet = GTK_SHEET (data); g_return_if_fail (adjustment != NULL); - g_return_if_fail (data != NULL); - g_return_if_fail (GTK_IS_SHEET (data)); - - sheet = GTK_SHEET (data); - - if (GTK_SHEET_IS_FROZEN (sheet)) return; - - row = ROW_FROM_YPIXEL (sheet,sheet->column_title_area.height + CELL_SPACING); - if (!sheet->column_titles_visible) - row = ROW_FROM_YPIXEL (sheet, CELL_SPACING); - - old_value = - sheet->voffset; - - new_row = g_sheet_row_pixel_to_row (sheet->row_geometry, - adjustment->value,sheet); - - y = g_sheet_row_start_pixel (sheet->row_geometry, new_row, sheet); - - if (adjustment->value > sheet->old_vadjustment && sheet->old_vadjustment > 0. && - yyy_row_height (sheet, row) > sheet->vadjustment->step_increment) - { - /* This avoids embarrassing twitching */ - if (row == new_row && row != yyy_row_count (sheet) - 1 && - adjustment->value - sheet->old_vadjustment >= - sheet->vadjustment->step_increment && - new_row + 1 != MIN_VISIBLE_ROW (sheet)) - { - new_row +=1; - y = y+yyy_row_height (sheet, row); - } - } - - /* Negative old_adjustment enforces the redraw, otherwise avoid - spureous redraw */ - if (sheet->old_vadjustment >= 0. && row == new_row) - { - sheet->old_vadjustment = sheet->vadjustment->value; - return; - } - - sheet->old_vadjustment = sheet->vadjustment->value; - adjustment->value = y; - - - if (new_row == 0) - { - sheet->vadjustment->step_increment = yyy_row_height (sheet, 0); - } - else - { - sheet->vadjustment->step_increment = - MIN (yyy_row_height (sheet, new_row), yyy_row_height (sheet, new_row - 1)); - } - - sheet->vadjustment->value = adjustment->value; - - value = adjustment->value; - - if (value >= - sheet->voffset) - { - /* scroll down */ - diff = value + sheet->voffset; - } - else - { - /* scroll up */ - diff = - sheet->voffset - value; - } - - sheet->voffset = - value; - - if (GTK_WIDGET_REALIZED (sheet->sheet_entry) && - sheet->state == GTK_SHEET_NORMAL && - sheet->active_cell.row >= 0 && sheet->active_cell.col >= 0 && - !gtk_sheet_cell_isvisible (sheet, sheet->active_cell.row, - sheet->active_cell.col)) - { - const gchar *text; - - text = gtk_entry_get_text (GTK_ENTRY (gtk_sheet_get_entry (sheet))); - - if (!text || strlen (text) == 0) - gtk_sheet_cell_clear (sheet, - sheet->active_cell.row, - sheet->active_cell.col); - gtk_widget_unmap (sheet->sheet_entry); - } - gtk_sheet_position_children (sheet); + if ( ! GTK_WIDGET_REALIZED (sheet)) return; + gtk_widget_hide (sheet->entry_widget); gtk_sheet_range_draw (sheet, NULL); size_allocate_row_title_buttons (sheet); - size_allocate_global_button (sheet); + // size_allocate_global_button (sheet); } + static void hadjustment_value_changed (GtkAdjustment * adjustment, gpointer data) { - GtkSheet *sheet; - gint i, diff, value, old_value; - gint column, new_column; - gint x = 0; + GtkSheet *sheet = GTK_SHEET (data); g_return_if_fail (adjustment != NULL); - g_return_if_fail (data != NULL); - g_return_if_fail (GTK_IS_SHEET (data)); - - sheet = GTK_SHEET (data); - - if (GTK_SHEET_IS_FROZEN (sheet)) return; - - column = COLUMN_FROM_XPIXEL (sheet,sheet->row_title_area.width + CELL_SPACING); - if (!sheet->row_titles_visible) - column = COLUMN_FROM_XPIXEL (sheet, CELL_SPACING); - - old_value = - sheet->hoffset; - - for (i = 0; i < xxx_column_count (sheet); i++) - { - if (xxx_column_is_visible (sheet, i)) x += xxx_column_width (sheet, i); - if (x > adjustment->value) break; - } - x -= xxx_column_width (sheet, i); - new_column = i; - - if (adjustment->value > sheet->old_hadjustment && sheet->old_hadjustment > 0 && - xxx_column_width (sheet, i) > sheet->hadjustment->step_increment) - { - /* This avoids embarrassing twitching */ - if (column == new_column && column != xxx_column_count (sheet) - 1 && - adjustment->value - sheet->old_hadjustment >= - sheet->hadjustment->step_increment && - new_column + 1 != MIN_VISIBLE_COLUMN (sheet)) - { - new_column += 1; - x += xxx_column_width (sheet, column); - } - } - - /* Negative old_adjustment enforces the redraw, otherwise avoid spureous redraw */ - if (sheet->old_hadjustment >= 0. && new_column == column) - { - sheet->old_hadjustment = sheet->hadjustment->value; - return; - } - - sheet->old_hadjustment = sheet->hadjustment->value; - adjustment->value = x; - - if (new_column == 0) - { - sheet->hadjustment->step_increment = xxx_column_width (sheet, 0); - } - else - { - sheet->hadjustment->step_increment = - MIN (xxx_column_width (sheet, new_column), xxx_column_width (sheet, new_column - 1)); - } - - - sheet->hadjustment->value = adjustment->value; - value = adjustment->value; - - if (value >= - sheet->hoffset) - { - /* scroll right */ - diff = value + sheet->hoffset; - } - else - { - /* scroll left */ - diff = - sheet->hoffset - value; - } - - sheet->hoffset = - value; - if (GTK_WIDGET_REALIZED (sheet->sheet_entry) && - sheet->state == GTK_SHEET_NORMAL && - sheet->active_cell.row >= 0 && sheet->active_cell.col >= 0 && - !gtk_sheet_cell_isvisible (sheet, sheet->active_cell.row, - sheet->active_cell.col)) - { - const gchar *text; - - text = gtk_entry_get_text (GTK_ENTRY (gtk_sheet_get_entry (sheet))); - if (!text || strlen (text) == 0) - gtk_sheet_cell_clear (sheet, - sheet->active_cell.row, - sheet->active_cell.col); - - gtk_widget_unmap (sheet->sheet_entry); - } - - gtk_sheet_position_children (sheet); + if ( ! GTK_WIDGET_REALIZED (sheet)) return; + gtk_widget_hide (sheet->entry_widget); gtk_sheet_range_draw (sheet, NULL); size_allocate_column_title_buttons (sheet); + // size_allocate_global_button (sheet); } @@ -7172,51 +5904,49 @@ hadjustment_value_changed (GtkAdjustment * adjustment, static void draw_xor_vline (GtkSheet * sheet) { - GtkWidget *widget; - - g_return_if_fail (sheet != NULL); + gint xpos = sheet->x_drag; - widget = GTK_WIDGET (sheet); + if (sheet->row_titles_visible) + xpos += sheet->row_title_area.width; - gdk_draw_line (widget->window, sheet->xor_gc, - sheet->x_drag, + gdk_draw_line (GTK_WIDGET (sheet)->window, sheet->xor_gc, + xpos, sheet->column_title_area.height, - sheet->x_drag, - sheet->sheet_window_height + 1); + xpos, + sheet->sheet_window_height + CELL_SPACING); } /* ROW RESIZING */ static void draw_xor_hline (GtkSheet * sheet) -{ - GtkWidget *widget; - g_return_if_fail (sheet != NULL); +{ + gint ypos = sheet->y_drag; - widget = GTK_WIDGET (sheet); + if (sheet->column_titles_visible) + ypos += sheet->column_title_area.height; - gdk_draw_line (widget->window, sheet->xor_gc, + gdk_draw_line (GTK_WIDGET (sheet)->window, sheet->xor_gc, sheet->row_title_area.width, - sheet->y_drag, - - sheet->sheet_window_width + 1, - sheet->y_drag); + ypos, + sheet->sheet_window_width + CELL_SPACING, + ypos); } /* SELECTED RANGE */ static void draw_xor_rectangle (GtkSheet *sheet, GtkSheetRange range) { - gint i; + gint i = 0; GdkRectangle clip_area, area; GdkGCValues values; area.x = COLUMN_LEFT_XPIXEL (sheet, range.col0); - area.y = ROW_TOP_YPIXEL (sheet, range.row0); + area.y = g_sheet_row_start_pixel (sheet->row_geometry, range.row0); area.width = COLUMN_LEFT_XPIXEL (sheet, range.coli)- area.x+ - xxx_column_width (sheet, range.coli); - area.height = ROW_TOP_YPIXEL (sheet, range.rowi)- area.y+ - yyy_row_height (sheet, range.rowi); + g_sheet_column_get_width (sheet->column_geometry, range.coli); + area.height = g_sheet_row_start_pixel (sheet->row_geometry, range.rowi)- area.y + + g_sheet_row_get_height (sheet->row_geometry, range.rowi); clip_area.x = sheet->row_title_area.width; clip_area.y = sheet->column_title_area.height; @@ -7248,7 +5978,6 @@ draw_xor_rectangle (GtkSheet *sheet, GtkSheetRange range) gdk_gc_set_clip_rectangle (sheet->xor_gc, &clip_area); - for (i =- 1; i <= 1; ++i) gdk_draw_rectangle (sheet->sheet_window, sheet->xor_gc, FALSE, @@ -7259,38 +5988,29 @@ draw_xor_rectangle (GtkSheet *sheet, GtkSheetRange range) gdk_gc_set_clip_rectangle (sheet->xor_gc, NULL); gdk_gc_set_foreground (sheet->xor_gc, &values.foreground); - } /* 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 beyond min / max limits */ + * 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) +new_column_width (GtkSheet *sheet, gint column, gint *x) { - gint cx, width; - guint min_width; - - cx = *x; + gint left_pos = COLUMN_LEFT_XPIXEL (sheet, column) + - sheet->hadjustment->value; - min_width = sheet->column_requisition; + gint width = *x - left_pos; - /* you can't shrink a column to less than its minimum width */ - if (cx < COLUMN_LEFT_XPIXEL (sheet, column) + min_width) + if ( width < sheet->column_requisition) { - *x = cx = COLUMN_LEFT_XPIXEL (sheet, column) + min_width; + width = sheet->column_requisition; + *x = left_pos + width; } - /* calculate new column width making sure it doesn't end up - * less than the minimum width */ - width = cx - COLUMN_LEFT_XPIXEL (sheet, column); - if (width < min_width) - width = min_width; + g_sheet_column_set_width (sheet->column_geometry, column, width); - xxx_set_column_width (sheet, column, width); size_allocate_column_title_buttons (sheet); return width; @@ -7300,30 +6020,28 @@ new_column_width (GtkSheet * sheet, * 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) +new_row_height (GtkSheet *sheet, gint row, gint *y) { - gint cy, height; + gint height; guint min_height; - cy = *y; + gint cy = *y; min_height = sheet->row_requisition; /* you can't shrink a row to less than its minimum height */ - if (cy < ROW_TOP_YPIXEL (sheet, row) + min_height) + if (cy < g_sheet_row_start_pixel (sheet->row_geometry, row) + min_height) { - *y = cy = ROW_TOP_YPIXEL (sheet, 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 - ROW_TOP_YPIXEL (sheet, row)); + height = (cy - g_sheet_row_start_pixel (sheet->row_geometry, row)); if (height < min_height) height = min_height; - yyy_set_row_height (sheet, row, height); + g_sheet_row_set_height (sheet->row_geometry, row, height); size_allocate_row_title_buttons (sheet); return height; @@ -7339,15 +6057,15 @@ gtk_sheet_set_column_width (GtkSheet * sheet, g_return_if_fail (sheet != NULL); g_return_if_fail (GTK_IS_SHEET (sheet)); - if (column < 0 || column >= xxx_column_count (sheet)) + if (column < 0 || column >= g_sheet_column_get_column_count (sheet->column_geometry)) return; gtk_sheet_column_size_request (sheet, column, &min_width); if (width < min_width) return; - xxx_set_column_width (sheet, column, width); + g_sheet_column_set_width (sheet->column_geometry, column, width); - if (GTK_WIDGET_REALIZED (GTK_WIDGET (sheet)) && !GTK_SHEET_IS_FROZEN (sheet)) + if (GTK_WIDGET_REALIZED (GTK_WIDGET (sheet))) { size_allocate_column_title_buttons (sheet); adjust_scrollbars (sheet); @@ -7355,9 +6073,7 @@ gtk_sheet_set_column_width (GtkSheet * sheet, gtk_sheet_range_draw (sheet, NULL); } - g_signal_emit (G_OBJECT (sheet), sheet_signals[CHANGED], 0, -1, column); - g_signal_emit (G_OBJECT (sheet), sheet_signals[NEW_COL_WIDTH], 0, - column, width); + g_signal_emit (sheet, sheet_signals[CHANGED], 0, -1, column); } @@ -7372,15 +6088,15 @@ gtk_sheet_set_row_height (GtkSheet * sheet, g_return_if_fail (sheet != NULL); g_return_if_fail (GTK_IS_SHEET (sheet)); - if (row < 0 || row >= yyy_row_count (sheet)) + if (row < 0 || row >= g_sheet_row_get_row_count (sheet->row_geometry)) return; gtk_sheet_row_size_request (sheet, row, &min_height); if (height < min_height) return; - yyy_set_row_height (sheet, row, height); + g_sheet_row_set_height (sheet->row_geometry, row, height); - if (GTK_WIDGET_REALIZED (GTK_WIDGET (sheet)) && !GTK_SHEET_IS_FROZEN (sheet)) + if (GTK_WIDGET_REALIZED (GTK_WIDGET (sheet)) ) { size_allocate_row_title_buttons (sheet); adjust_scrollbars (sheet); @@ -7388,13 +6104,8 @@ gtk_sheet_set_row_height (GtkSheet * sheet, gtk_sheet_range_draw (sheet, NULL); } - g_signal_emit (G_OBJECT (sheet), sheet_signals[CHANGED], 0, row, - 1); - g_signal_emit (G_OBJECT (sheet), sheet_signals[NEW_ROW_HEIGHT], 0, - row, height); - + g_signal_emit (sheet, sheet_signals[CHANGED], 0, row, - 1); } - - gboolean gtk_sheet_get_attributes (const GtkSheet *sheet, gint row, gint col, GtkSheetCellAttr *attributes) @@ -7448,10 +6159,9 @@ init_attributes (const GtkSheet *sheet, gint col, GtkSheetCellAttr *attributes) { GdkColormap *colormap; colormap = gdk_colormap_get_system (); - gdk_color_black (colormap, &attributes->foreground); attributes->background = sheet->bg_color; } - attributes->justification = xxx_column_justification (sheet, col); + attributes->justification = g_sheet_column_get_justification (sheet->column_geometry, col); attributes->border.width = 0; attributes->border.line_style = GDK_LINE_SOLID; attributes->border.cap_style = GDK_CAP_NOT_LAST; @@ -7463,228 +6173,13 @@ init_attributes (const GtkSheet *sheet, gint col, GtkSheetCellAttr *attributes) attributes->font_desc = GTK_WIDGET (sheet)->style->font_desc; } - -/******************************************************************** - * Container Functions: - * gtk_sheet_add - * gtk_sheet_put - * gtk_sheet_attach - * gtk_sheet_remove - * gtk_sheet_move_child - * gtk_sheet_position_child - * gtk_sheet_position_children - * gtk_sheet_realize_child - * gtk_sheet_get_child_at - ********************************************************************/ - -GtkSheetChild * -gtk_sheet_put (GtkSheet *sheet, GtkWidget *child, gint x, gint y) -{ - GtkRequisition child_requisition; - GtkSheetChild *child_info; - - g_return_val_if_fail (sheet != NULL, NULL); - g_return_val_if_fail (GTK_IS_SHEET (sheet), NULL); - g_return_val_if_fail (child != NULL, NULL); - g_return_val_if_fail (child->parent == NULL, NULL); - - child_info = g_new (GtkSheetChild, 1); - child_info->widget = child; - child_info->x = x; - child_info->y = y; - child_info->attached_to_cell = FALSE; - child_info->floating = TRUE; - child_info->xpadding = child_info->ypadding = 0; - child_info->xexpand = child_info->yexpand = FALSE; - child_info->xshrink = child_info->yshrink = FALSE; - child_info->xfill = child_info->yfill = FALSE; - - sheet->children = g_list_append (sheet->children, child_info); - - gtk_widget_set_parent (child, GTK_WIDGET (sheet)); - - gtk_widget_size_request (child, &child_requisition); - - if (GTK_WIDGET_VISIBLE (GTK_WIDGET (sheet))) - { - if (GTK_WIDGET_REALIZED (GTK_WIDGET (sheet)) && - (!GTK_WIDGET_REALIZED (child) || GTK_WIDGET_NO_WINDOW (child))) - gtk_sheet_realize_child (sheet, child_info); - - if (GTK_WIDGET_MAPPED (GTK_WIDGET (sheet)) && - !GTK_WIDGET_MAPPED (child)) - gtk_widget_map (child); - } - - gtk_sheet_position_child (sheet, child_info); - - /* This will avoid drawing on the titles */ - - if (GTK_WIDGET_REALIZED (GTK_WIDGET (sheet))) - { - if (sheet->row_titles_visible) - gdk_window_show (sheet->row_title_window); - if (sheet->column_titles_visible) - gdk_window_show (sheet->column_title_window); - } - - return (child_info); -} - -void -gtk_sheet_attach_floating (GtkSheet *sheet, - GtkWidget *widget, - gint row, gint col) -{ - GdkRectangle area; - GtkSheetChild *child; - - if (row < 0 || col < 0) - { - gtk_sheet_button_attach (sheet, widget, row, col); - return; - } - - gtk_sheet_get_cell_area (sheet, row, col, &area); - child = gtk_sheet_put (sheet, widget, area.x, area.y); - child->attached_to_cell = TRUE; - child->row = row; - child->col = col; -} - -void -gtk_sheet_attach_default (GtkSheet *sheet, - GtkWidget *widget, - gint row, gint col) -{ - if (row < 0 || col < 0) - { - gtk_sheet_button_attach (sheet, widget, row, col); - return; - } - - gtk_sheet_attach (sheet, widget, row, col, - GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0); -} - -void -gtk_sheet_attach (GtkSheet *sheet, - GtkWidget *widget, - gint row, gint col, - gint xoptions, - gint yoptions, - gint xpadding, - gint ypadding) -{ - GdkRectangle area; - GtkSheetChild *child = NULL; - - if (row < 0 || col < 0) - { - gtk_sheet_button_attach (sheet, widget, row, col); - return; - } - - child = g_new0 (GtkSheetChild, 1); - child->attached_to_cell = TRUE; - child->floating = FALSE; - child->widget = widget; - child->row = row; - child->col = col; - child->xpadding = xpadding; - child->ypadding = ypadding; - child->xexpand = (xoptions & GTK_EXPAND) != 0; - child->yexpand = (yoptions & GTK_EXPAND) != 0; - child->xshrink = (xoptions & GTK_SHRINK) != 0; - child->yshrink = (yoptions & GTK_SHRINK) != 0; - child->xfill = (xoptions & GTK_FILL) != 0; - child->yfill = (yoptions & GTK_FILL) != 0; - - sheet->children = g_list_append (sheet->children, child); - - gtk_sheet_get_cell_area (sheet, row, col, &area); - - child->x = area.x + child->xpadding; - child->y = area.y + child->ypadding; - - if (GTK_WIDGET_VISIBLE (GTK_WIDGET (sheet))) - { - if (GTK_WIDGET_REALIZED (GTK_WIDGET (sheet)) && - (!GTK_WIDGET_REALIZED (widget) || GTK_WIDGET_NO_WINDOW (widget))) - gtk_sheet_realize_child (sheet, child); - - if (GTK_WIDGET_MAPPED (GTK_WIDGET (sheet)) && - !GTK_WIDGET_MAPPED (widget)) - gtk_widget_map (widget); - } - - gtk_sheet_position_child (sheet, child); - - /* This will avoid drawing on the titles */ - - if (GTK_WIDGET_REALIZED (GTK_WIDGET (sheet))) - { - if (GTK_SHEET_ROW_TITLES_VISIBLE (sheet)) - gdk_window_show (sheet->row_title_window); - if (GTK_SHEET_COL_TITLES_VISIBLE (sheet)) - gdk_window_show (sheet->column_title_window); - } - -} - -void -gtk_sheet_button_attach (GtkSheet *sheet, - GtkWidget *widget, - gint row, gint col) -{ - GtkSheetButton *button = 0; - GtkSheetChild *child; - GtkRequisition button_requisition; - - if (row >= 0 && col >= 0) return; - if (row < 0 && col < 0) return; - - child = g_new (GtkSheetChild, 1); - child->widget = widget; - child->x = 0; - child->y = 0; - child->attached_to_cell = TRUE; - child->floating = FALSE; - child->row = row; - child->col = col; - child->xpadding = child->ypadding = 0; - child->xshrink = child->yshrink = FALSE; - child->xfill = child->yfill = FALSE; - - - sheet->children = g_list_append (sheet->children, child); - - gtk_sheet_button_size_request (sheet, button, &button_requisition); - - - if (GTK_WIDGET_VISIBLE (GTK_WIDGET (sheet))) - { - if (GTK_WIDGET_REALIZED (GTK_WIDGET (sheet)) && - (!GTK_WIDGET_REALIZED (widget) || GTK_WIDGET_NO_WINDOW (widget))) - gtk_sheet_realize_child (sheet, child); - - if (GTK_WIDGET_MAPPED (GTK_WIDGET (sheet)) && - !GTK_WIDGET_MAPPED (widget)) - gtk_widget_map (widget); - } - - if (row == -1) size_allocate_column_title_buttons (sheet); - if (col == -1) size_allocate_row_title_buttons (sheet); - -} - static void label_size_request (GtkSheet *sheet, gchar *label, GtkRequisition *req) { gchar *words; gchar word[1000]; gint n = 0; - gint row_height = DEFAULT_ROW_HEIGHT (GTK_WIDGET (sheet)) - 2 * CELLOFFSET + 2; + gint row_height = DEFAULT_ROW_HEIGHT (GTK_WIDGET (sheet)) - 2 * COLUMN_TITLES_HEIGHT + 2; req->height = 0; req->width = 0; @@ -7721,8 +6216,8 @@ gtk_sheet_button_size_request (GtkSheet *sheet, if (gtk_sheet_autoresize (sheet) && button->label && strlen (button->label) > 0) { label_size_request (sheet, button->label, &label_requisition); - label_requisition.width += 2 * CELLOFFSET; - label_requisition.height += 2 * CELLOFFSET; + label_requisition.width += 2 * COLUMN_TITLES_HEIGHT; + label_requisition.height += 2 * COLUMN_TITLES_HEIGHT; } else { @@ -7730,19 +6225,9 @@ gtk_sheet_button_size_request (GtkSheet *sheet, label_requisition.width = COLUMN_MIN_WIDTH; } - if (button->child) - { - gtk_widget_size_request (button->child->widget, &requisition); - requisition.width += 2 * button->child->xpadding; - requisition.height += 2 * button->child->ypadding; - requisition.width += 2 * sheet->button->style->xthickness; - requisition.height += 2 * sheet->button->style->ythickness; - } - else - { requisition.height = DEFAULT_ROW_HEIGHT (GTK_WIDGET (sheet)); requisition.width = COLUMN_MIN_WIDTH; - } + *button_requisition = requisition; button_requisition->width = MAX (requisition.width, label_requisition.width); @@ -7756,30 +6241,13 @@ gtk_sheet_row_size_request (GtkSheet *sheet, guint *requisition) { GtkRequisition button_requisition; - GList *children; gtk_sheet_button_size_request (sheet, - yyy_row_button (sheet, row), + g_sheet_row_get_button (sheet->row_geometry, row), &button_requisition); *requisition = button_requisition.height; - children = sheet->children; - while (children) - { - GtkSheetChild *child = (GtkSheetChild *)children->data; - GtkRequisition child_requisition; - - if (child->attached_to_cell && child->row == row && child->col != -1 && !child->floating && !child->yshrink) - { - gtk_widget_get_child_requisition (child->widget, &child_requisition); - - if (child_requisition.height + 2 * child->ypadding > *requisition) - *requisition = child_requisition.height + 2 * child->ypadding; - } - children = children->next; - } - sheet->row_requisition = * requisition; } @@ -7789,165 +6257,20 @@ gtk_sheet_column_size_request (GtkSheet *sheet, guint *requisition) { GtkRequisition button_requisition; - GList *children; + + GtkSheetButton *button = g_sheet_column_get_button (sheet->column_geometry, col); gtk_sheet_button_size_request (sheet, - xxx_column_button (sheet, col), + button, &button_requisition); - *requisition = button_requisition.width; - - children = sheet->children; - while (children) - { - GtkSheetChild *child = (GtkSheetChild *)children->data; - GtkRequisition child_requisition; - - if (child->attached_to_cell && child->col == col && child->row != -1 && !child->floating && !child->xshrink) - { - gtk_widget_get_child_requisition (child->widget, &child_requisition); + gtk_sheet_button_free (button); - if (child_requisition.width + 2 * child->xpadding > *requisition) - *requisition = child_requisition.width + 2 * child->xpadding; - } - children = children->next; - } + *requisition = button_requisition.width; sheet->column_requisition = *requisition; } -void -gtk_sheet_move_child (GtkSheet *sheet, GtkWidget *widget, gint x, gint y) -{ - GtkSheetChild *child; - GList *children; - - g_return_if_fail (sheet != NULL); - g_return_if_fail (GTK_IS_SHEET (sheet)); - - children = sheet->children; - while (children) - { - child = children->data; - - if (child->widget == widget) - { - child->x = x; - child->y = y; - child->row = ROW_FROM_YPIXEL (sheet, y); - child->col = COLUMN_FROM_XPIXEL (sheet, x); - gtk_sheet_position_child (sheet, child); - return; - } - - children = children->next; - } - - g_warning ("Widget must be a GtkSheet child"); - -} - -static void -gtk_sheet_position_child (GtkSheet *sheet, GtkSheetChild *child) -{ - GtkRequisition child_requisition; - GtkAllocation child_allocation; - gint xoffset = 0; - gint yoffset = 0; - gint x = 0, y = 0; - GdkRectangle area; - - gtk_widget_get_child_requisition (child->widget, &child_requisition); - - if (sheet->column_titles_visible) - yoffset = sheet->column_title_area.height; - - if (sheet->row_titles_visible) - xoffset = sheet->row_title_area.width; - - if (child->attached_to_cell) - { - gtk_sheet_get_cell_area (sheet, child->row, child->col, &area); - child->x = area.x + child->xpadding; - child->y = area.y + child->ypadding; - - if (!child->floating) - { - if (child_requisition.width + 2 * child->xpadding <= xxx_column_width (sheet, child->col)) - { - if (child->xfill) - { - child_requisition.width = child_allocation.width = xxx_column_width (sheet, child->col) - 2 * child->xpadding; - } - else - { - if (child->xexpand) - { - child->x = area.x + xxx_column_width (sheet, child->col) / 2 - - child_requisition.width / 2; - } - child_allocation.width = child_requisition.width; - } - } - else - { - if (!child->xshrink) - { - gtk_sheet_set_column_width (sheet, child->col, child_requisition.width + 2 * child->xpadding); - } - child_allocation.width = xxx_column_width (sheet, child->col) - 2 * child->xpadding; - } - - if (child_requisition.height + - 2 * child->ypadding <= yyy_row_height (sheet, child->row)) - { - if (child->yfill) - { - child_requisition.height = child_allocation.height = - yyy_row_height (sheet, child->row) - 2 * child->ypadding; - } - else - { - if (child->yexpand) - { - child->y = area.y + yyy_row_height (sheet, child->row) / 2 - - child_requisition.height / 2; - } - child_allocation.height = child_requisition.height; - } - } - else - { - if (!child->yshrink) - { - gtk_sheet_set_row_height (sheet, child->row, child_requisition.height + 2 * child->ypadding); - } - child_allocation.height = yyy_row_height (sheet, child->row) - - 2 * child->ypadding; - } - } - else - { - child_allocation.width = child_requisition.width; - child_allocation.height = child_requisition.height; - } - - x = child_allocation.x = child->x + xoffset; - y = child_allocation.y = child->y + yoffset; - } - else - { - x = child_allocation.x = child->x + sheet->hoffset + xoffset; - x = child_allocation.x = child->x + xoffset; - y = child_allocation.y = child->y + sheet->voffset + yoffset; - y = child_allocation.y = child->y + yoffset; - child_allocation.width = child_requisition.width; - child_allocation.height = child_requisition.height; - } - - gtk_widget_size_allocate (child->widget, &child_allocation); - gtk_widget_queue_draw (child->widget); -} static void gtk_sheet_forall (GtkContainer *container, @@ -7955,192 +6278,198 @@ gtk_sheet_forall (GtkContainer *container, GtkCallback callback, gpointer callback_data) { - GtkSheet *sheet; - GtkSheetChild *child; - GList *children; + GtkSheet *sheet = GTK_SHEET (container); - g_return_if_fail (GTK_IS_SHEET (container)); g_return_if_fail (callback != NULL); - sheet = GTK_SHEET (container); - children = sheet->children; - while (children) - { - child = children->data; - children = children->next; - - (* callback) (child->widget, callback_data); - } - if (sheet->button) + if (sheet->button && sheet->button->parent) (* callback) (sheet->button, callback_data); - if (sheet->sheet_entry) - (* callback) (sheet->sheet_entry, callback_data); + + if (sheet->entry_container && GTK_IS_CONTAINER (sheet->entry_container)) + (* callback) (sheet->entry_container, callback_data); } -static void -gtk_sheet_position_children (GtkSheet *sheet) +GSheetModel * +gtk_sheet_get_model (const GtkSheet *sheet) { - GList *children; - GtkSheetChild *child; - - children = sheet->children; - - while (children) - { - child = (GtkSheetChild *)children->data; - - if (child->col != -1 && child->row != -1) - gtk_sheet_position_child (sheet, child); - - if (child->row == -1) - { - if (child->col < MIN_VISIBLE_COLUMN (sheet) || - child->col > MAX_VISIBLE_COLUMN (sheet)) - gtk_sheet_child_hide (child); - else - gtk_sheet_child_show (child); - } - if (child->col == -1) - { - if (child->row < MIN_VISIBLE_ROW (sheet) || - child->row > MAX_VISIBLE_ROW (sheet)) - gtk_sheet_child_hide (child); - else - gtk_sheet_child_show (child); - } + g_return_val_if_fail (GTK_IS_SHEET (sheet), NULL); - children = children->next; - } + return sheet->model; } -static void -gtk_sheet_remove (GtkContainer *container, GtkWidget *widget) + +GtkSheetButton * +gtk_sheet_button_new (void) { - GtkSheet *sheet; - GList *children; - GtkSheetChild *child = 0; + GtkSheetButton *button = g_malloc (sizeof (GtkSheetButton)); - g_return_if_fail (container != NULL); - g_return_if_fail (GTK_IS_SHEET (container)); + button->state = GTK_STATE_NORMAL; + button->label = NULL; + button->label_visible = TRUE; + button->justification = GTK_JUSTIFY_FILL; - sheet = GTK_SHEET (container); + return button; +} - children = sheet->children; - while (children) - { - child = (GtkSheetChild *)children->data; +void +gtk_sheet_button_free (GtkSheetButton *button) +{ + if (!button) return ; - if (child->widget == widget) break; + g_free (button->label); + g_free (button); +} - children = children->next; - } - if (children) - { - gtk_widget_unparent (widget); - child->widget = NULL; +static void +append_cell_text (GString *string, const GtkSheet *sheet, gint r, gint c) +{ + gchar *celltext = gtk_sheet_cell_get_text (sheet, r, c); - sheet->children = g_list_remove_link (sheet->children, children); - g_list_free_1 (children); - g_free (child); - } + if ( NULL == celltext) + return; + g_string_append (string, celltext); + g_free (celltext); } -static void -gtk_sheet_realize_child (GtkSheet *sheet, GtkSheetChild *child) + +static GString * +range_to_text (const GtkSheet *sheet) { - GtkWidget *widget; + gint r, c; + GString *string; - widget = GTK_WIDGET (sheet); + if ( !gtk_sheet_range_isvisible (sheet, sheet->range)) + return NULL; - if (GTK_WIDGET_REALIZED (widget)) + string = g_string_sized_new (80); + + for (r = sheet->range.row0; r <= sheet->range.rowi; ++r) { - if (child->row == -1) - gtk_widget_set_parent_window (child->widget, sheet->column_title_window); - else if (child->col == -1) - gtk_widget_set_parent_window (child->widget, sheet->row_title_window); - else - gtk_widget_set_parent_window (child->widget, sheet->sheet_window); + for (c = sheet->range.col0; c < sheet->range.coli; ++c) + { + append_cell_text (string, sheet, r, c); + g_string_append (string, "\t"); + } + append_cell_text (string, sheet, r, c); + if ( r < sheet->range.rowi) + g_string_append (string, "\n"); } - gtk_widget_set_parent (child->widget, widget); + return string; } - - -GtkSheetChild * -gtk_sheet_get_child_at (GtkSheet *sheet, gint row, gint col) +static GString * +range_to_html (const GtkSheet *sheet) { - GList *children; - GtkSheetChild *child = 0; + gint r, c; + GString *string; - g_return_val_if_fail (sheet != NULL, NULL); - g_return_val_if_fail (GTK_IS_SHEET (sheet), NULL); + if ( !gtk_sheet_range_isvisible (sheet, sheet->range)) + return NULL; - children = sheet->children; + string = g_string_sized_new (480); - while (children) + g_string_append (string, "\n"); + g_string_append (string, "\n"); + g_string_append (string, "\n"); + for (r = sheet->range.row0; r <= sheet->range.rowi; ++r) { - child = (GtkSheetChild *)children->data; - - if (child->attached_to_cell) - if (child->row == row && child->col == col) break; - - children = children->next; + g_string_append (string, "\n"); + for (c = sheet->range.col0; c <= sheet->range.coli; ++c) + { + g_string_append (string, "\n"); + } + g_string_append (string, "\n"); } + g_string_append (string, "
"); + append_cell_text (string, sheet, r, c); + g_string_append (string, "
\n"); + g_string_append (string, "\n"); + g_string_append (string, "\n"); - if (children) return child; - - return NULL; + return string; } -static void -gtk_sheet_child_hide (GtkSheetChild *child) -{ - g_return_if_fail (child != NULL); - gtk_widget_hide (child->widget); -} +enum { + SELECT_FMT_NULL, + SELECT_FMT_TEXT, + SELECT_FMT_HTML +}; static void -gtk_sheet_child_show (GtkSheetChild *child) +primary_get_cb (GtkClipboard *clipboard, + GtkSelectionData *selection_data, + guint info, + gpointer data) { - g_return_if_fail (child != NULL); + GtkSheet *sheet = GTK_SHEET (data); + GString *string = NULL; + + switch (info) + { + case SELECT_FMT_TEXT: + string = range_to_text (sheet); + break; + case SELECT_FMT_HTML: + string = range_to_html (sheet); + break; + default: + g_assert_not_reached (); + } - gtk_widget_show (child->widget); + gtk_selection_data_set (selection_data, selection_data->target, + 8, + (const guchar *) string->str, string->len); + g_string_free (string, TRUE); } -GSheetModel * -gtk_sheet_get_model (const GtkSheet *sheet) +static void +primary_clear_cb (GtkClipboard *clipboard, + gpointer data) { - g_return_val_if_fail (GTK_IS_SHEET (sheet), NULL); + GtkSheet *sheet = GTK_SHEET (data); + if ( ! GTK_WIDGET_REALIZED (GTK_WIDGET (sheet))) + return; - return sheet->model; + gtk_sheet_real_unselect_range (sheet, NULL); } +static void +gtk_sheet_update_primary_selection (GtkSheet *sheet) +{ + static const GtkTargetEntry targets[] = { + { "UTF8_STRING", 0, SELECT_FMT_TEXT }, + { "STRING", 0, SELECT_FMT_TEXT }, + { "TEXT", 0, SELECT_FMT_TEXT }, + { "COMPOUND_TEXT", 0, SELECT_FMT_TEXT }, + { "text/plain;charset=utf-8", 0, SELECT_FMT_TEXT }, + { "text/plain", 0, SELECT_FMT_TEXT }, + { "text/html", 0, SELECT_FMT_HTML } + }; -GtkSheetButton * -gtk_sheet_button_new (void) -{ - GtkSheetButton *button = g_malloc (sizeof (GtkSheetButton)); - - button->state = GTK_STATE_NORMAL; - button->label = NULL; - button->label_visible = TRUE; - button->child = NULL; - button->justification = GTK_JUSTIFY_FILL; - - return button; -} + GtkClipboard *clipboard; + if (!GTK_WIDGET_REALIZED (sheet)) + return; -inline void -gtk_sheet_button_free (GtkSheetButton *button) -{ - if (!button) return ; + clipboard = gtk_widget_get_clipboard (GTK_WIDGET (sheet), + GDK_SELECTION_PRIMARY); - g_free (button->label); - g_free (button); + if (gtk_sheet_range_isvisible (sheet, sheet->range)) + { + if (!gtk_clipboard_set_with_owner (clipboard, targets, + G_N_ELEMENTS (targets), + primary_get_cb, primary_clear_cb, + G_OBJECT (sheet))) + primary_clear_cb (clipboard, sheet); + } + else + { + if (gtk_clipboard_get_owner (clipboard) == G_OBJECT (sheet)) + gtk_clipboard_clear (clipboard); + } }