2 Copyright (C) 2006, 2008, 2009 Free Software Foundation
4 This program is free software: you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation, either version 3 of the License, or
7 (at your option) any later version.
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
14 You should have received a copy of the GNU General Public License
15 along with this program. If not, see <http://www.gnu.org/licenses/>.
18 This file is derived from the gtksheet.c and extensively modified for the
19 requirements of PSPPIRE. The changes are copyright by the
20 Free Software Foundation. The copyright notice for the original work is
24 /* GtkSheet widget for Gtk+.
25 * Copyright (C) 1999-2001 Adrian E. Feiguin <adrian@ifir.ifir.edu.ar>
27 * Based on GtkClist widget by Jay Painter, but major changes.
28 * Memory allocation routines inspired on SC (Spreadsheet Calculator)
30 * This library is free software; you can redistribute it and/or
31 * modify it under the terms of the GNU Lesser General Public
32 * License as published by the Free Software Foundation; either
33 * version 2.1 of the License, or (at your option) any later version.
35 * This library is distributed in the hope that it will be useful,
36 * but WITHOUT ANY WARRANTY; without even the implied warranty of
37 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
38 * Lesser General Public License for more details.
40 * You should have received a copy of the GNU Lesser General Public
41 * License along with this library; if not, write to the Free Software
42 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
46 * SECTION:psppiresheet
47 * @short_description: spreadsheet widget for gtk2
49 * PsppireSheet is a matrix widget for GTK+. It consists of an scrollable grid of
50 * cells where you can allocate text. Cell contents can be edited interactively
51 * through a specially designed entry, GtkItemEntry.
59 #include <gdk/gdkkeysyms.h>
60 #include <gtk/gtksignal.h>
61 #include <gtk/gtkbutton.h>
62 #include <gtk/gtkadjustment.h>
63 #include <gtk/gtktypeutils.h>
64 #include <gtk/gtkentry.h>
65 #include <gtk/gtkcontainer.h>
66 #include <pango/pango.h>
67 #include "psppire-sheet.h"
68 #include <ui/gui/psppire-marshal.h>
69 #include <ui/gui/sheet/psppire-sheetmodel.h>
70 #include <ui/gui/sheet/psppire-axis.h>
71 #include <libpspp/misc.h>
76 PSPPIRE_SHEET_IN_XDRAG = 1 << 1,
77 PSPPIRE_SHEET_IN_YDRAG = 1 << 2,
78 PSPPIRE_SHEET_IN_DRAG = 1 << 3,
80 /* This flag is set when the user is actually in the process
81 of making a selection - ie while the mouse button is
84 PSPPIRE_SHEET_IN_SELECTION = 1 << 4
87 #define PSPPIRE_SHEET_FLAGS(sheet) (PSPPIRE_SHEET (sheet)->flags)
88 #define PSPPIRE_SHEET_SET_FLAGS(sheet,flag) (PSPPIRE_SHEET_FLAGS (sheet) |= (flag))
89 #define PSPPIRE_SHEET_UNSET_FLAGS(sheet,flag) (PSPPIRE_SHEET_FLAGS (sheet) &= ~ (flag))
91 #define PSPPIRE_SHEET_IN_XDRAG(sheet) (PSPPIRE_SHEET_FLAGS (sheet) & PSPPIRE_SHEET_IN_XDRAG)
92 #define PSPPIRE_SHEET_IN_YDRAG(sheet) (PSPPIRE_SHEET_FLAGS (sheet) & PSPPIRE_SHEET_IN_YDRAG)
93 #define PSPPIRE_SHEET_IN_DRAG(sheet) (PSPPIRE_SHEET_FLAGS (sheet) & PSPPIRE_SHEET_IN_DRAG)
94 #define PSPPIRE_SHEET_IN_SELECTION(sheet) (PSPPIRE_SHEET_FLAGS (sheet) & PSPPIRE_SHEET_IN_SELECTION)
96 #define CELL_SPACING 1
98 #define TIMEOUT_HOVER 300
99 #define COLUMN_MIN_WIDTH 10
100 #define COLUMN_TITLES_HEIGHT 4
101 #define DEFAULT_COLUMN_WIDTH 80
102 #define DEFAULT_ROW_HEIGHT 25
104 static void set_entry_widget_font (PsppireSheet *sheet);
106 static void psppire_sheet_update_primary_selection (PsppireSheet *sheet);
107 static void draw_column_title_buttons_range (PsppireSheet *sheet, gint first, gint n);
108 static void draw_row_title_buttons_range (PsppireSheet *sheet, gint first, gint n);
109 static void redraw_range (PsppireSheet *sheet, PsppireSheetRange *range);
112 static void set_row_height (PsppireSheet *sheet,
116 static void destroy_hover_window (PsppireSheetHoverTitle *);
117 static PsppireSheetHoverTitle *create_hover_window (void);
120 dispose_string (const PsppireSheet *sheet, gchar *text)
122 PsppireSheetModel *model = psppire_sheet_get_model (sheet);
127 if (psppire_sheet_model_free_strings (model))
132 /* FIXME: Why bother with these two ? */
134 /* returns the column index from a pixel location */
136 column_from_xpixel (const PsppireSheet *sheet, gint pixel)
138 return psppire_axis_unit_at_pixel (sheet->haxis, pixel);
142 row_from_ypixel (const PsppireSheet *sheet, gint pixel)
144 return psppire_axis_unit_at_pixel (sheet->vaxis, pixel);
148 /* Return the lowest row number which is wholly or partially on
149 the visible range of the sheet */
151 min_visible_row (const PsppireSheet *sheet)
153 return row_from_ypixel (sheet, sheet->vadjustment->value);
157 min_fully_visible_row (const PsppireSheet *sheet)
159 glong row = min_visible_row (sheet);
161 if ( psppire_axis_start_pixel (sheet->vaxis, row) < sheet->vadjustment->value)
168 max_visible_row (const PsppireSheet *sheet)
170 return row_from_ypixel (sheet, sheet->vadjustment->value + sheet->vadjustment->page_size);
175 max_fully_visible_row (const PsppireSheet *sheet)
177 glong row = max_visible_row (sheet);
179 if ( psppire_axis_start_pixel (sheet->vaxis, row)
181 psppire_axis_unit_size (sheet->vaxis, row)
182 > sheet->vadjustment->value)
189 /* Returns the lowest column number which is wholly or partially
192 min_visible_column (const PsppireSheet *sheet)
194 return column_from_xpixel (sheet, sheet->hadjustment->value);
198 min_fully_visible_column (const PsppireSheet *sheet)
200 glong col = min_visible_column (sheet);
202 if ( psppire_axis_start_pixel (sheet->haxis, col) < sheet->hadjustment->value)
209 /* Returns the highest column number which is wholly or partially
212 max_visible_column (const PsppireSheet *sheet)
214 return column_from_xpixel (sheet, sheet->hadjustment->value + sheet->hadjustment->page_size);
218 max_fully_visible_column (const PsppireSheet *sheet)
220 glong col = max_visible_column (sheet);
222 if ( psppire_axis_start_pixel (sheet->haxis, col)
224 psppire_axis_unit_size (sheet->haxis, col)
225 > sheet->hadjustment->value)
233 /* The size of the region (in pixels) around the row/column boundaries
234 where the height/width may be grabbed to change size */
238 on_column_boundary (const PsppireSheet *sheet, gint x, gint *column)
243 x += sheet->hadjustment->value;
248 col = column_from_xpixel (sheet, x);
250 pixel = x - DRAG_WIDTH / 2;
254 if ( column_from_xpixel (sheet, pixel) < col )
260 if ( column_from_xpixel (sheet, x + DRAG_WIDTH / 2) > col )
270 on_row_boundary (const PsppireSheet *sheet, gint y, gint *row)
275 y += sheet->vadjustment->value;
280 r = row_from_ypixel (sheet, y);
282 pixel = y - DRAG_WIDTH / 2;
286 if ( row_from_ypixel (sheet, pixel) < r )
292 if ( row_from_ypixel (sheet, y + DRAG_WIDTH / 2) > r )
302 static inline gboolean
303 POSSIBLE_DRAG (const PsppireSheet *sheet, gint x, gint y,
304 gint *drag_row, gint *drag_column)
308 /* Can't drag if nothing is selected */
309 if ( sheet->range.row0 < 0 || sheet->range.rowi < 0 ||
310 sheet->range.col0 < 0 || sheet->range.coli < 0 )
313 *drag_column = column_from_xpixel (sheet, x);
314 *drag_row = row_from_ypixel (sheet, y);
316 if (x >= psppire_axis_start_pixel (sheet->haxis, sheet->range.col0) - DRAG_WIDTH / 2 &&
317 x <= psppire_axis_start_pixel (sheet->haxis, sheet->range.coli) +
318 psppire_axis_unit_size (sheet->haxis, sheet->range.coli) + DRAG_WIDTH / 2)
320 ydrag = psppire_axis_start_pixel (sheet->vaxis, sheet->range.row0);
321 if (y >= ydrag - DRAG_WIDTH / 2 && y <= ydrag + DRAG_WIDTH / 2)
323 *drag_row = sheet->range.row0;
326 ydrag = psppire_axis_start_pixel (sheet->vaxis, sheet->range.rowi) +
327 psppire_axis_unit_size (sheet->vaxis, sheet->range.rowi);
328 if (y >= ydrag - DRAG_WIDTH / 2 && y <= ydrag + DRAG_WIDTH / 2)
330 *drag_row = sheet->range.rowi;
335 if (y >= psppire_axis_start_pixel (sheet->vaxis, sheet->range.row0) - DRAG_WIDTH / 2 &&
336 y <= psppire_axis_start_pixel (sheet->vaxis, sheet->range.rowi) +
337 psppire_axis_unit_size (sheet->vaxis, sheet->range.rowi) + DRAG_WIDTH / 2)
339 xdrag = psppire_axis_start_pixel (sheet->haxis, sheet->range.col0);
340 if (x >= xdrag - DRAG_WIDTH / 2 && x <= xdrag + DRAG_WIDTH / 2)
342 *drag_column = sheet->range.col0;
345 xdrag = psppire_axis_start_pixel (sheet->haxis, sheet->range.coli) +
346 psppire_axis_unit_size (sheet->haxis, sheet->range.coli);
347 if (x >= xdrag - DRAG_WIDTH / 2 && x <= xdrag + DRAG_WIDTH / 2)
349 *drag_column = sheet->range.coli;
357 static inline gboolean
358 POSSIBLE_RESIZE (const PsppireSheet *sheet, gint x, gint y,
359 gint *drag_row, gint *drag_column)
363 /* Can't drag if nothing is selected */
364 if ( sheet->range.row0 < 0 || sheet->range.rowi < 0 ||
365 sheet->range.col0 < 0 || sheet->range.coli < 0 )
368 xdrag = psppire_axis_start_pixel (sheet->haxis, sheet->range.coli)+
369 psppire_axis_unit_size (sheet->haxis, sheet->range.coli);
371 ydrag = psppire_axis_start_pixel (sheet->vaxis, sheet->range.rowi) +
372 psppire_axis_unit_size (sheet->vaxis, sheet->range.rowi);
374 if (sheet->select_status == PSPPIRE_SHEET_COLUMN_SELECTED)
375 ydrag = psppire_axis_start_pixel (sheet->vaxis, min_visible_row (sheet));
377 if (sheet->select_status == PSPPIRE_SHEET_ROW_SELECTED)
378 xdrag = psppire_axis_start_pixel (sheet->haxis, min_visible_column (sheet));
380 *drag_column = column_from_xpixel (sheet, x);
381 *drag_row = row_from_ypixel (sheet, y);
383 if (x >= xdrag - DRAG_WIDTH / 2 && x <= xdrag + DRAG_WIDTH / 2 &&
384 y >= ydrag - DRAG_WIDTH / 2 && y <= ydrag + DRAG_WIDTH / 2) return TRUE;
391 rectangle_from_range (PsppireSheet *sheet, const PsppireSheetRange *range,
394 gint col0 = MIN (range->col0, range->coli);
395 gint coli = MAX (range->col0, range->coli);
396 gint row0 = MIN (range->row0, range->rowi);
397 gint rowi = MAX (range->row0, range->rowi);
399 if ( row0 == -1 ) row0 = min_visible_row (sheet);
400 if ( rowi == -1 ) rowi = max_visible_row (sheet);
401 if ( col0 == -1 ) col0 = min_visible_column (sheet);
402 if ( coli == -1 ) coli = max_visible_column (sheet);
404 r->x = psppire_axis_start_pixel (sheet->haxis, col0);
405 r->x -= round (sheet->hadjustment->value);
407 r->y = psppire_axis_start_pixel (sheet->vaxis, row0);
408 r->y -= round (sheet->vadjustment->value);
410 r->width = psppire_axis_start_pixel (sheet->haxis, coli) -
411 psppire_axis_start_pixel (sheet->haxis, col0) +
412 psppire_axis_unit_size (sheet->haxis, coli);
414 r->height = psppire_axis_start_pixel (sheet->vaxis, rowi) -
415 psppire_axis_start_pixel (sheet->vaxis, row0) +
416 psppire_axis_unit_size (sheet->vaxis, rowi);
418 if ( sheet->column_titles_visible)
420 r->y += sheet->column_title_area.height;
423 if ( sheet->row_titles_visible)
425 r->x += sheet->row_title_area.width;
430 rectangle_from_cell (PsppireSheet *sheet, gint row, gint col,
433 PsppireSheetRange range;
434 g_return_if_fail (row >= 0);
435 g_return_if_fail (col >= 0);
437 range.row0 = range.rowi = row;
438 range.col0 = range.coli = col;
440 rectangle_from_range (sheet, &range, r);
444 static void psppire_sheet_class_init (PsppireSheetClass *klass);
445 static void psppire_sheet_init (PsppireSheet *sheet);
446 static void psppire_sheet_dispose (GObject *object);
447 static void psppire_sheet_finalize (GObject *object);
448 static void psppire_sheet_style_set (GtkWidget *widget,
449 GtkStyle *previous_style);
450 static void psppire_sheet_realize (GtkWidget *widget);
451 static void psppire_sheet_unrealize (GtkWidget *widget);
452 static void psppire_sheet_map (GtkWidget *widget);
453 static void psppire_sheet_unmap (GtkWidget *widget);
454 static gint psppire_sheet_expose (GtkWidget *widget,
455 GdkEventExpose *event);
457 static void psppire_sheet_forall (GtkContainer *container,
458 gboolean include_internals,
459 GtkCallback callback,
460 gpointer callback_data);
462 static gboolean psppire_sheet_set_scroll_adjustments (PsppireSheet *sheet,
463 GtkAdjustment *hadjustment,
464 GtkAdjustment *vadjustment);
466 static gint psppire_sheet_button_press (GtkWidget *widget,
467 GdkEventButton *event);
468 static gint psppire_sheet_button_release (GtkWidget *widget,
469 GdkEventButton *event);
470 static gint psppire_sheet_motion (GtkWidget *widget,
471 GdkEventMotion *event);
472 static gboolean psppire_sheet_crossing_notify (GtkWidget *widget,
473 GdkEventCrossing *event);
474 static gint psppire_sheet_entry_key_press (GtkWidget *widget,
476 static gboolean psppire_sheet_key_press (GtkWidget *widget,
478 static void psppire_sheet_size_request (GtkWidget *widget,
479 GtkRequisition *requisition);
480 static void psppire_sheet_size_allocate (GtkWidget *widget,
481 GtkAllocation *allocation);
483 static gboolean psppire_sheet_focus_in (GtkWidget *widget,
484 GdkEventFocus *event);
488 static gboolean psppire_sheet_range_isvisible (const PsppireSheet *sheet,
489 const PsppireSheetRange *range);
490 static gboolean psppire_sheet_cell_isvisible (PsppireSheet *sheet,
491 gint row, gint column);
492 /* Drawing Routines */
495 static void psppire_sheet_cell_draw (PsppireSheet *sheet, gint row, gint column);
498 /* draw visible part of range. */
499 static void draw_sheet_region (PsppireSheet *sheet, GdkRegion *region);
503 static void psppire_sheet_draw_border (PsppireSheet *sheet,
504 PsppireSheetRange range);
506 /* Active Cell handling */
508 static void psppire_sheet_hide_entry_widget (PsppireSheet *sheet);
509 static void change_active_cell (PsppireSheet *sheet, gint row, gint col);
510 static gboolean psppire_sheet_draw_active_cell (PsppireSheet *sheet);
511 static void psppire_sheet_show_entry_widget (PsppireSheet *sheet);
512 static gboolean psppire_sheet_click_cell (PsppireSheet *sheet,
519 static void adjust_scrollbars (PsppireSheet *sheet);
520 static void vadjustment_value_changed (GtkAdjustment *adjustment,
522 static void hadjustment_value_changed (GtkAdjustment *adjustment,
526 static void draw_xor_vline (PsppireSheet *sheet);
527 static void draw_xor_hline (PsppireSheet *sheet);
528 static void draw_xor_rectangle (PsppireSheet *sheet,
529 PsppireSheetRange range);
533 static void create_global_button (PsppireSheet *sheet);
534 static void global_button_clicked (GtkWidget *widget,
538 static void create_sheet_entry (PsppireSheet *sheet);
539 static void psppire_sheet_size_allocate_entry (PsppireSheet *sheet);
541 /* Sheet button gadgets */
543 static void draw_column_title_buttons (PsppireSheet *sheet);
544 static void draw_row_title_buttons (PsppireSheet *sheet);
547 static void size_allocate_global_button (PsppireSheet *sheet);
548 static void psppire_sheet_button_size_request (PsppireSheet *sheet,
549 const PsppireSheetButton *button,
550 GtkRequisition *requisition);
552 static void psppire_sheet_real_cell_clear (PsppireSheet *sheet,
574 static GtkContainerClass *parent_class = NULL;
575 static guint sheet_signals[LAST_SIGNAL] = { 0 };
579 psppire_sheet_get_type ()
581 static GType sheet_type = 0;
585 static const GTypeInfo sheet_info =
587 sizeof (PsppireSheetClass),
590 (GClassInitFunc) psppire_sheet_class_init,
593 sizeof (PsppireSheet),
595 (GInstanceInitFunc) psppire_sheet_init,
600 g_type_register_static (GTK_TYPE_BIN, "PsppireSheet",
608 static PsppireSheetRange*
609 psppire_sheet_range_copy (const PsppireSheetRange *range)
611 PsppireSheetRange *new_range;
613 g_return_val_if_fail (range != NULL, NULL);
615 new_range = g_new (PsppireSheetRange, 1);
623 psppire_sheet_range_free (PsppireSheetRange *range)
625 g_return_if_fail (range != NULL);
631 psppire_sheet_range_get_type (void)
633 static GType sheet_range_type = 0;
635 if (!sheet_range_type)
638 g_boxed_type_register_static ("PsppireSheetRange",
639 (GBoxedCopyFunc) psppire_sheet_range_copy,
640 (GBoxedFreeFunc) psppire_sheet_range_free);
643 return sheet_range_type;
646 static PsppireSheetCell*
647 psppire_sheet_cell_copy (const PsppireSheetCell *cell)
649 PsppireSheetCell *new_cell;
651 g_return_val_if_fail (cell != NULL, NULL);
653 new_cell = g_new (PsppireSheetCell, 1);
661 psppire_sheet_cell_free (PsppireSheetCell *cell)
663 g_return_if_fail (cell != NULL);
669 psppire_sheet_cell_get_type (void)
671 static GType sheet_cell_type = 0;
673 if (!sheet_cell_type)
676 g_boxed_type_register_static ("PsppireSheetCell",
677 (GBoxedCopyFunc) psppire_sheet_cell_copy,
678 (GBoxedFreeFunc) psppire_sheet_cell_free);
681 return sheet_cell_type;
696 resize_column (PsppireSheet *sheet, gint unit, glong size)
698 PsppireSheetRange range;
700 range.coli = max_visible_column (sheet);
701 range.row0 = min_visible_row (sheet);
702 range.rowi = max_visible_row (sheet);
704 redraw_range (sheet, &range);
706 draw_column_title_buttons_range (sheet, range.col0, range.coli);
711 psppire_sheet_set_horizontal_axis (PsppireSheet *sheet, PsppireAxis *a)
714 g_object_unref (sheet->haxis);
717 g_signal_connect_swapped (a, "resize-unit", G_CALLBACK (resize_column), sheet);
720 g_object_ref (sheet->haxis);
724 resize_row (PsppireSheet *sheet, gint unit, glong size)
726 PsppireSheetRange range;
727 range.col0 = min_visible_column (sheet);
728 range.coli = max_visible_column (sheet);
730 range.rowi = max_visible_row (sheet);
732 redraw_range (sheet, &range);
734 draw_row_title_buttons_range (sheet, range.row0, range.rowi);
738 psppire_sheet_set_vertical_axis (PsppireSheet *sheet, PsppireAxis *a)
741 g_object_unref (sheet->vaxis);
745 g_signal_connect_swapped (a, "resize-unit", G_CALLBACK (resize_row), sheet);
748 g_object_ref (sheet->vaxis);
751 static const GtkBorder default_cell_padding = {3, 3, 3, 3};
754 psppire_sheet_set_property (GObject *object,
760 PsppireSheet *sheet = PSPPIRE_SHEET (object);
764 case PROP_CELL_PADDING:
765 if ( sheet->cell_padding)
766 g_boxed_free (GTK_TYPE_BORDER, sheet->cell_padding);
768 sheet->cell_padding = g_value_dup_boxed (value);
770 if (NULL == sheet->cell_padding)
771 sheet->cell_padding = g_boxed_copy (GTK_TYPE_BORDER,
772 &default_cell_padding);
775 g_object_set (sheet->vaxis, "padding",
776 sheet->cell_padding->top + sheet->cell_padding->bottom,
780 g_object_set (sheet->haxis, "padding",
781 sheet->cell_padding->left + sheet->cell_padding->right,
785 psppire_sheet_set_vertical_axis (sheet, g_value_get_pointer (value));
786 g_object_set (sheet->vaxis, "padding",
787 sheet->cell_padding->top + sheet->cell_padding->bottom,
791 psppire_sheet_set_horizontal_axis (sheet, g_value_get_pointer (value));
792 g_object_set (sheet->haxis, "padding",
793 sheet->cell_padding->left + sheet->cell_padding->right,
797 psppire_sheet_set_model (sheet, g_value_get_pointer (value));
800 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
806 psppire_sheet_get_property (GObject *object,
811 PsppireSheet *sheet = PSPPIRE_SHEET (object);
815 case PROP_CELL_PADDING:
816 g_value_set_boxed (value, sheet->cell_padding);
819 g_value_set_pointer (value, sheet->vaxis);
822 g_value_set_pointer (value, sheet->haxis);
825 g_value_set_pointer (value, sheet->model);
828 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
835 psppire_sheet_class_init (PsppireSheetClass *klass)
837 GObjectClass *object_class = G_OBJECT_CLASS (klass);
839 GParamSpec *haxis_spec ;
840 GParamSpec *vaxis_spec ;
841 GParamSpec *model_spec ;
842 GParamSpec *cell_padding_spec ;
844 GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
845 GtkContainerClass *container_class = GTK_CONTAINER_CLASS (klass);
847 parent_class = g_type_class_peek_parent (klass);
850 * PsppireSheet::select-row
851 * @sheet: the sheet widget that emitted the signal
852 * @row: the newly selected row index, or -1 if no row is selected.
854 * A row has been selected.
856 sheet_signals[SELECT_ROW] =
857 g_signal_new ("select-row",
858 G_TYPE_FROM_CLASS (object_class),
860 offsetof (PsppireSheetClass, select_row),
862 g_cclosure_marshal_VOID__INT,
869 * PsppireSheet::select - column
870 * @sheet: the sheet widget that emitted the signal
871 * @column: the newly selected column index, or -1 if no column is selected.
873 * A column has been selected.
875 sheet_signals[SELECT_COLUMN] =
876 g_signal_new ("select-column",
877 G_TYPE_FROM_CLASS (object_class),
879 offsetof (PsppireSheetClass, select_column),
881 g_cclosure_marshal_VOID__INT,
888 * PsppireSheet::double-click-row
889 * @sheet: the sheet widget that emitted the signal
890 * @row: the row that was double clicked.
892 * A row's title button has been double clicked
894 sheet_signals[DOUBLE_CLICK_ROW] =
895 g_signal_new ("double-click-row",
896 G_TYPE_FROM_CLASS (object_class),
900 g_cclosure_marshal_VOID__INT,
907 * PsppireSheet::double-click-column
908 * @sheet: the sheet widget that emitted the signal
909 * @column: the column that was double clicked.
911 * A column's title button has been double clicked
913 sheet_signals[DOUBLE_CLICK_COLUMN] =
914 g_signal_new ("double-click-column",
915 G_TYPE_FROM_CLASS (object_class),
919 g_cclosure_marshal_VOID__INT,
926 * PsppireSheet::button-event-column
927 * @sheet: the sheet widget that emitted the signal
928 * @column: the column on which the event occured.
930 * A button event occured on a column title button
932 sheet_signals[BUTTON_EVENT_COLUMN] =
933 g_signal_new ("button-event-column",
934 G_TYPE_FROM_CLASS (object_class),
938 psppire_marshal_VOID__INT_POINTER,
947 * PsppireSheet::button-event-row
948 * @sheet: the sheet widget that emitted the signal
949 * @column: the column on which the event occured.
951 * A button event occured on a row title button
953 sheet_signals[BUTTON_EVENT_ROW] =
954 g_signal_new ("button-event-row",
955 G_TYPE_FROM_CLASS (object_class),
959 psppire_marshal_VOID__INT_POINTER,
967 sheet_signals[SELECT_RANGE] =
968 g_signal_new ("select-range",
969 G_TYPE_FROM_CLASS (object_class),
971 offsetof (PsppireSheetClass, select_range),
973 g_cclosure_marshal_VOID__BOXED,
976 PSPPIRE_TYPE_SHEET_RANGE);
979 sheet_signals[RESIZE_RANGE] =
980 g_signal_new ("resize-range",
981 G_TYPE_FROM_CLASS (object_class),
983 offsetof (PsppireSheetClass, resize_range),
985 psppire_marshal_VOID__BOXED_BOXED,
988 PSPPIRE_TYPE_SHEET_RANGE, PSPPIRE_TYPE_SHEET_RANGE
991 sheet_signals[MOVE_RANGE] =
992 g_signal_new ("move-range",
993 G_TYPE_FROM_CLASS (object_class),
995 offsetof (PsppireSheetClass, move_range),
997 psppire_marshal_VOID__BOXED_BOXED,
1000 PSPPIRE_TYPE_SHEET_RANGE, PSPPIRE_TYPE_SHEET_RANGE
1003 sheet_signals[TRAVERSE] =
1004 g_signal_new ("traverse",
1005 G_TYPE_FROM_CLASS (object_class),
1007 offsetof (PsppireSheetClass, traverse),
1009 psppire_marshal_BOOLEAN__BOXED_POINTER,
1011 PSPPIRE_TYPE_SHEET_CELL,
1015 sheet_signals[ACTIVATE] =
1016 g_signal_new ("activate",
1017 G_TYPE_FROM_CLASS (object_class),
1019 offsetof (PsppireSheetClass, activate),
1021 psppire_marshal_VOID__INT_INT_INT_INT,
1023 G_TYPE_INT, G_TYPE_INT,
1024 G_TYPE_INT, G_TYPE_INT);
1026 widget_class->set_scroll_adjustments_signal =
1027 g_signal_new ("set-scroll-adjustments",
1028 G_TYPE_FROM_CLASS (object_class),
1030 offsetof (PsppireSheetClass, set_scroll_adjustments),
1032 psppire_marshal_VOID__OBJECT_OBJECT,
1033 G_TYPE_NONE, 2, GTK_TYPE_ADJUSTMENT, GTK_TYPE_ADJUSTMENT);
1036 container_class->add = NULL;
1037 container_class->remove = NULL;
1038 container_class->forall = psppire_sheet_forall;
1039 container_class->set_focus_child = NULL;
1041 object_class->dispose = psppire_sheet_dispose;
1042 object_class->finalize = psppire_sheet_finalize;
1045 g_param_spec_boxed ("cell-padding",
1047 "The space between a cell's contents and its border",
1049 G_PARAM_CONSTRUCT | G_PARAM_READABLE | G_PARAM_WRITABLE);
1052 g_param_spec_pointer ("vertical-axis",
1054 "A pointer to the PsppireAxis object for the rows",
1055 G_PARAM_READABLE | G_PARAM_WRITABLE );
1058 g_param_spec_pointer ("horizontal-axis",
1060 "A pointer to the PsppireAxis object for the columns",
1061 G_PARAM_READABLE | G_PARAM_WRITABLE );
1064 g_param_spec_pointer ("model",
1066 "A pointer to the data model",
1067 G_PARAM_READABLE | G_PARAM_WRITABLE );
1070 object_class->set_property = psppire_sheet_set_property;
1071 object_class->get_property = psppire_sheet_get_property;
1073 g_object_class_install_property (object_class,
1077 g_object_class_install_property (object_class,
1081 g_object_class_install_property (object_class,
1085 g_object_class_install_property (object_class,
1090 widget_class->realize = psppire_sheet_realize;
1091 widget_class->unrealize = psppire_sheet_unrealize;
1092 widget_class->map = psppire_sheet_map;
1093 widget_class->unmap = psppire_sheet_unmap;
1094 widget_class->style_set = psppire_sheet_style_set;
1095 widget_class->button_press_event = psppire_sheet_button_press;
1096 widget_class->button_release_event = psppire_sheet_button_release;
1097 widget_class->motion_notify_event = psppire_sheet_motion;
1098 widget_class->enter_notify_event = psppire_sheet_crossing_notify;
1099 widget_class->leave_notify_event = psppire_sheet_crossing_notify;
1100 widget_class->key_press_event = psppire_sheet_key_press;
1101 widget_class->expose_event = psppire_sheet_expose;
1102 widget_class->size_request = psppire_sheet_size_request;
1103 widget_class->size_allocate = psppire_sheet_size_allocate;
1104 widget_class->focus_in_event = psppire_sheet_focus_in;
1105 widget_class->focus_out_event = NULL;
1107 klass->set_scroll_adjustments = psppire_sheet_set_scroll_adjustments;
1108 klass->select_row = NULL;
1109 klass->select_column = NULL;
1110 klass->select_range = NULL;
1111 klass->resize_range = NULL;
1112 klass->move_range = NULL;
1113 klass->traverse = NULL;
1114 klass->activate = NULL;
1115 klass->changed = NULL;
1119 psppire_sheet_init (PsppireSheet *sheet)
1121 sheet->model = NULL;
1122 sheet->haxis = NULL;
1123 sheet->vaxis = NULL;
1126 sheet->select_status = PSPPIRE_SHEET_NORMAL;
1128 GTK_WIDGET_UNSET_FLAGS (sheet, GTK_NO_WINDOW);
1129 GTK_WIDGET_SET_FLAGS (sheet, GTK_CAN_FOCUS);
1131 sheet->column_title_window = NULL;
1132 sheet->column_title_area.x = 0;
1133 sheet->column_title_area.y = 0;
1134 sheet->column_title_area.width = 0;
1135 sheet->column_title_area.height = DEFAULT_ROW_HEIGHT;
1137 sheet->row_title_window = NULL;
1138 sheet->row_title_area.x = 0;
1139 sheet->row_title_area.y = 0;
1140 sheet->row_title_area.width = DEFAULT_COLUMN_WIDTH;
1141 sheet->row_title_area.height = 0;
1144 sheet->active_cell.row = 0;
1145 sheet->active_cell.col = 0;
1147 sheet->range.row0 = 0;
1148 sheet->range.rowi = 0;
1149 sheet->range.col0 = 0;
1150 sheet->range.coli = 0;
1152 sheet->sheet_window = NULL;
1153 sheet->entry_widget = NULL;
1154 sheet->button = NULL;
1156 sheet->hadjustment = NULL;
1157 sheet->vadjustment = NULL;
1159 sheet->cursor_drag = NULL;
1161 sheet->xor_gc = NULL;
1162 sheet->fg_gc = NULL;
1163 sheet->bg_gc = NULL;
1166 sheet->show_grid = TRUE;
1168 sheet->motion_timer = 0;
1170 sheet->row_titles_visible = TRUE;
1171 sheet->row_title_area.width = DEFAULT_COLUMN_WIDTH;
1173 sheet->column_titles_visible = TRUE;
1176 /* create sheet entry */
1177 sheet->entry_type = GTK_TYPE_ENTRY;
1178 create_sheet_entry (sheet);
1180 /* create global selection button */
1181 create_global_button (sheet);
1185 /* Cause RANGE to be redrawn. If RANGE is null, then the
1186 entire visible range will be redrawn.
1189 redraw_range (PsppireSheet *sheet, PsppireSheetRange *range)
1193 if ( ! GTK_WIDGET_REALIZED (sheet))
1196 if ( NULL != range )
1197 rectangle_from_range (sheet, range, &rect);
1200 GdkRegion *r = gdk_drawable_get_visible_region (sheet->sheet_window);
1201 gdk_region_get_clipbox (r, &rect);
1203 if ( sheet->column_titles_visible)
1205 rect.y += sheet->column_title_area.height;
1206 rect.height -= sheet->column_title_area.height;
1209 if ( sheet->row_titles_visible)
1211 rect.x += sheet->row_title_area.width;
1212 rect.width -= sheet->row_title_area.width;
1216 gdk_window_invalidate_rect (sheet->sheet_window, &rect, FALSE);
1220 /* Callback which occurs whenever columns are inserted / deleted in the model */
1222 columns_inserted_deleted_callback (PsppireSheetModel *model, gint first_column,
1226 PsppireSheet *sheet = PSPPIRE_SHEET (data);
1228 PsppireSheetRange range;
1229 gint model_columns = psppire_sheet_model_get_column_count (model);
1232 /* Need to update all the columns starting from the first column and onwards.
1233 * Previous column are unchanged, so don't need to be updated.
1235 range.col0 = first_column;
1237 range.coli = psppire_axis_unit_count (sheet->haxis) - 1;
1238 range.rowi = psppire_axis_unit_count (sheet->vaxis) - 1;
1240 adjust_scrollbars (sheet);
1242 if (sheet->active_cell.col >= model_columns)
1243 change_active_cell (sheet, sheet->active_cell.row, model_columns - 1);
1245 draw_column_title_buttons_range (sheet,
1246 first_column, max_visible_column (sheet));
1249 redraw_range (sheet, &range);
1255 /* Callback which occurs whenever rows are inserted / deleted in the model */
1257 rows_inserted_deleted_callback (PsppireSheetModel *model, gint first_row,
1258 gint n_rows, gpointer data)
1260 PsppireSheet *sheet = PSPPIRE_SHEET (data);
1262 PsppireSheetRange range;
1264 gint model_rows = psppire_sheet_model_get_row_count (model);
1266 /* Need to update all the rows starting from the first row and onwards.
1267 * Previous rows are unchanged, so don't need to be updated.
1269 range.row0 = first_row;
1271 range.rowi = psppire_axis_unit_count (sheet->vaxis) - 1;
1272 range.coli = psppire_axis_unit_count (sheet->haxis) - 1;
1274 adjust_scrollbars (sheet);
1276 if (sheet->active_cell.row >= model_rows)
1277 change_active_cell (sheet, model_rows - 1, sheet->active_cell.col);
1279 draw_row_title_buttons_range (sheet, first_row, max_visible_row (sheet));
1281 redraw_range (sheet, &range);
1285 If row0 or rowi are negative, then all rows will be updated.
1286 If col0 or coli are negative, then all columns will be updated.
1289 range_update_callback (PsppireSheetModel *m, gint row0, gint col0,
1290 gint rowi, gint coli, gpointer data)
1292 PsppireSheet *sheet = PSPPIRE_SHEET (data);
1294 PsppireSheetRange range;
1301 if ( !GTK_WIDGET_REALIZED (GTK_WIDGET (sheet)))
1304 if ( ( row0 < 0 && col0 < 0 ) || ( rowi < 0 && coli < 0 ) )
1306 redraw_range (sheet, NULL);
1307 adjust_scrollbars (sheet);
1309 draw_row_title_buttons_range (sheet, min_visible_row (sheet),
1310 max_visible_row (sheet));
1312 draw_column_title_buttons_range (sheet, min_visible_column (sheet),
1313 max_visible_column (sheet));
1317 else if ( row0 < 0 || rowi < 0 )
1319 range.row0 = min_visible_row (sheet);
1320 range.rowi = max_visible_row (sheet);
1322 else if ( col0 < 0 || coli < 0 )
1324 range.col0 = min_visible_column (sheet);
1325 range.coli = max_visible_column (sheet);
1328 redraw_range (sheet, &range);
1333 * psppire_sheet_new:
1334 * @rows: initial number of rows
1335 * @columns: initial number of columns
1336 * @title: sheet title
1337 * @model: the model to use for the sheet data
1339 * Creates a new sheet widget with the given number of rows and columns.
1341 * Returns: the new sheet widget
1344 psppire_sheet_new (PsppireSheetModel *model)
1346 GtkWidget *widget = g_object_new (PSPPIRE_TYPE_SHEET,
1354 * psppire_sheet_set_model
1355 * @sheet: the sheet to set the model for
1356 * @model: the model to use for the sheet data
1358 * Sets the model for a PsppireSheet
1362 psppire_sheet_set_model (PsppireSheet *sheet, PsppireSheetModel *model)
1364 g_return_if_fail (PSPPIRE_IS_SHEET (sheet));
1366 if (sheet->model ) g_object_unref (sheet->model);
1368 sheet->model = model;
1372 g_object_ref (model);
1374 sheet->update_handler_id = g_signal_connect (model, "range_changed",
1375 G_CALLBACK (range_update_callback),
1378 g_signal_connect (model, "rows_inserted",
1379 G_CALLBACK (rows_inserted_deleted_callback), sheet);
1381 g_signal_connect (model, "rows_deleted",
1382 G_CALLBACK (rows_inserted_deleted_callback), sheet);
1384 g_signal_connect (model, "columns_inserted",
1385 G_CALLBACK (columns_inserted_deleted_callback), sheet);
1387 g_signal_connect (model, "columns_deleted",
1388 G_CALLBACK (columns_inserted_deleted_callback), sheet);
1394 psppire_sheet_change_entry (PsppireSheet *sheet, GType entry_type)
1396 g_return_if_fail (sheet != NULL);
1397 g_return_if_fail (PSPPIRE_IS_SHEET (sheet));
1399 if (sheet->select_status == PSPPIRE_SHEET_NORMAL)
1400 psppire_sheet_hide_entry_widget (sheet);
1402 sheet->entry_type = entry_type;
1404 create_sheet_entry (sheet);
1406 if (sheet->select_status == PSPPIRE_SHEET_NORMAL)
1407 psppire_sheet_show_entry_widget (sheet);
1411 psppire_sheet_show_grid (PsppireSheet *sheet, gboolean show)
1413 g_return_if_fail (sheet != NULL);
1414 g_return_if_fail (PSPPIRE_IS_SHEET (sheet));
1416 if (show == sheet->show_grid) return;
1418 sheet->show_grid = show;
1420 redraw_range (sheet, NULL);
1424 psppire_sheet_grid_visible (PsppireSheet *sheet)
1426 g_return_val_if_fail (sheet != NULL, 0);
1427 g_return_val_if_fail (PSPPIRE_IS_SHEET (sheet), 0);
1429 return sheet->show_grid;
1433 psppire_sheet_get_columns_count (PsppireSheet *sheet)
1435 g_return_val_if_fail (sheet != NULL, 0);
1436 g_return_val_if_fail (PSPPIRE_IS_SHEET (sheet), 0);
1438 return psppire_axis_unit_count (sheet->haxis);
1441 static void set_column_width (PsppireSheet *sheet,
1447 psppire_sheet_show_column_titles (PsppireSheet *sheet)
1449 if (sheet->column_titles_visible) return;
1451 sheet->column_titles_visible = TRUE;
1453 if (!GTK_WIDGET_REALIZED (GTK_WIDGET (sheet)))
1456 gdk_window_show (sheet->column_title_window);
1457 gdk_window_move_resize (sheet->column_title_window,
1458 sheet->column_title_area.x,
1459 sheet->column_title_area.y,
1460 sheet->column_title_area.width,
1461 sheet->column_title_area.height);
1463 adjust_scrollbars (sheet);
1465 if (sheet->vadjustment)
1466 g_signal_emit_by_name (sheet->vadjustment,
1469 size_allocate_global_button (sheet);
1471 if ( sheet->row_titles_visible)
1472 gtk_widget_show (sheet->button);
1477 psppire_sheet_show_row_titles (PsppireSheet *sheet)
1479 if (sheet->row_titles_visible) return;
1481 sheet->row_titles_visible = TRUE;
1484 if (GTK_WIDGET_REALIZED (GTK_WIDGET (sheet)))
1486 gdk_window_show (sheet->row_title_window);
1487 gdk_window_move_resize (sheet->row_title_window,
1488 sheet->row_title_area.x,
1489 sheet->row_title_area.y,
1490 sheet->row_title_area.width,
1491 sheet->row_title_area.height);
1493 adjust_scrollbars (sheet);
1496 if (sheet->hadjustment)
1497 g_signal_emit_by_name (sheet->hadjustment,
1500 size_allocate_global_button (sheet);
1502 if ( sheet->column_titles_visible)
1503 gtk_widget_show (sheet->button);
1507 psppire_sheet_hide_column_titles (PsppireSheet *sheet)
1509 if (!sheet->column_titles_visible) return;
1511 sheet->column_titles_visible = FALSE;
1513 if (GTK_WIDGET_REALIZED (GTK_WIDGET (sheet)))
1515 if (sheet->column_title_window)
1516 gdk_window_hide (sheet->column_title_window);
1518 gtk_widget_hide (sheet->button);
1520 adjust_scrollbars (sheet);
1523 if (sheet->vadjustment)
1524 g_signal_emit_by_name (sheet->vadjustment,
1529 psppire_sheet_hide_row_titles (PsppireSheet *sheet)
1531 if (!sheet->row_titles_visible) return;
1533 sheet->row_titles_visible = FALSE;
1535 if (GTK_WIDGET_REALIZED (GTK_WIDGET (sheet)))
1537 if (sheet->row_title_window)
1538 gdk_window_hide (sheet->row_title_window);
1540 gtk_widget_hide (sheet->button);
1542 adjust_scrollbars (sheet);
1545 if (sheet->hadjustment)
1546 g_signal_emit_by_name (sheet->hadjustment,
1551 /* Scroll the sheet so that the cell ROW, COLUMN is visible.
1552 If {ROW,COL}_ALIGN is zero, then the cell will be placed
1553 at the {top,left} of the sheet. If it's 1, then it'll
1554 be placed at the {bottom,right}.
1555 ROW or COL may be -1, in which case scrolling in that dimension
1559 psppire_sheet_moveto (PsppireSheet *sheet,
1567 g_return_if_fail (row_align >= 0);
1568 g_return_if_fail (col_align >= 0);
1570 g_return_if_fail (row_align <= 1);
1571 g_return_if_fail (col_align <= 1);
1573 g_return_if_fail (col <
1574 psppire_axis_unit_count (sheet->haxis));
1575 g_return_if_fail (row <
1576 psppire_axis_unit_count (sheet->vaxis));
1578 gdk_drawable_get_size (sheet->sheet_window, &width, &height);
1583 gint y = psppire_axis_start_pixel (sheet->vaxis, row);
1585 gtk_adjustment_set_value (sheet->vadjustment, y - height * row_align);
1591 gint x = psppire_axis_start_pixel (sheet->haxis, col);
1593 gtk_adjustment_set_value (sheet->hadjustment, x - width * col_align);
1601 psppire_sheet_range_isvisible (const PsppireSheet *sheet,
1602 const PsppireSheetRange *range)
1604 g_return_val_if_fail (sheet != NULL, FALSE);
1606 if (range->row0 < 0 || range->row0 >= psppire_axis_unit_count (sheet->vaxis))
1609 if (range->rowi < 0 || range->rowi >= psppire_axis_unit_count (sheet->vaxis))
1612 if (range->col0 < 0 || range->col0 >= psppire_axis_unit_count (sheet->haxis))
1615 if (range->coli < 0 || range->coli >= psppire_axis_unit_count (sheet->haxis))
1618 if (range->rowi < min_visible_row (sheet))
1621 if (range->row0 > max_visible_row (sheet))
1624 if (range->coli < min_visible_column (sheet))
1627 if (range->col0 > max_visible_column (sheet))
1634 psppire_sheet_cell_isvisible (PsppireSheet *sheet,
1635 gint row, gint column)
1637 PsppireSheetRange range;
1640 range.col0 = column;
1642 range.coli = column;
1644 return psppire_sheet_range_isvisible (sheet, &range);
1648 psppire_sheet_get_visible_range (PsppireSheet *sheet, PsppireSheetRange *range)
1650 g_return_if_fail (sheet != NULL);
1651 g_return_if_fail (PSPPIRE_IS_SHEET (sheet)) ;
1652 g_return_if_fail (range != NULL);
1654 range->row0 = min_visible_row (sheet);
1655 range->col0 = min_visible_column (sheet);
1656 range->rowi = max_visible_row (sheet);
1657 range->coli = max_visible_column (sheet);
1662 psppire_sheet_set_scroll_adjustments (PsppireSheet *sheet,
1663 GtkAdjustment *hadjustment,
1664 GtkAdjustment *vadjustment)
1666 if ( sheet->vadjustment != vadjustment )
1668 if (sheet->vadjustment)
1669 g_object_unref (sheet->vadjustment);
1670 sheet->vadjustment = vadjustment;
1674 g_object_ref (vadjustment);
1676 g_signal_connect (sheet->vadjustment, "value_changed",
1677 G_CALLBACK (vadjustment_value_changed),
1682 if ( sheet->hadjustment != hadjustment )
1684 if (sheet->hadjustment)
1685 g_object_unref (sheet->hadjustment);
1687 sheet->hadjustment = hadjustment;
1691 g_object_ref (hadjustment);
1693 g_signal_connect (sheet->hadjustment, "value_changed",
1694 G_CALLBACK (hadjustment_value_changed),
1702 psppire_sheet_finalize (GObject *object)
1704 PsppireSheet *sheet;
1706 g_return_if_fail (object != NULL);
1707 g_return_if_fail (PSPPIRE_IS_SHEET (object));
1709 sheet = PSPPIRE_SHEET (object);
1711 if (G_OBJECT_CLASS (parent_class)->finalize)
1712 (*G_OBJECT_CLASS (parent_class)->finalize) (object);
1716 psppire_sheet_dispose (GObject *object)
1718 PsppireSheet *sheet = PSPPIRE_SHEET (object);
1720 g_return_if_fail (object != NULL);
1721 g_return_if_fail (PSPPIRE_IS_SHEET (object));
1723 if ( sheet->dispose_has_run )
1726 sheet->dispose_has_run = TRUE;
1728 if ( sheet->cell_padding)
1729 g_boxed_free (GTK_TYPE_BORDER, sheet->cell_padding);
1731 if (sheet->model) g_object_unref (sheet->model);
1732 if (sheet->vaxis) g_object_unref (sheet->vaxis);
1733 if (sheet->haxis) g_object_unref (sheet->haxis);
1735 g_object_unref (sheet->button);
1736 sheet->button = NULL;
1738 /* unref adjustments */
1739 if (sheet->hadjustment)
1741 g_signal_handlers_disconnect_matched (sheet->hadjustment,
1742 G_SIGNAL_MATCH_DATA,
1746 g_object_unref (sheet->hadjustment);
1747 sheet->hadjustment = NULL;
1750 if (sheet->vadjustment)
1752 g_signal_handlers_disconnect_matched (sheet->vadjustment,
1753 G_SIGNAL_MATCH_DATA,
1757 g_object_unref (sheet->vadjustment);
1759 sheet->vadjustment = NULL;
1762 if (G_OBJECT_CLASS (parent_class)->dispose)
1763 (*G_OBJECT_CLASS (parent_class)->dispose) (object);
1767 psppire_sheet_style_set (GtkWidget *widget,
1768 GtkStyle *previous_style)
1770 PsppireSheet *sheet;
1772 g_return_if_fail (widget != NULL);
1773 g_return_if_fail (PSPPIRE_IS_SHEET (widget));
1775 if (GTK_WIDGET_CLASS (parent_class)->style_set)
1776 (*GTK_WIDGET_CLASS (parent_class)->style_set) (widget, previous_style);
1778 sheet = PSPPIRE_SHEET (widget);
1780 if (GTK_WIDGET_REALIZED (widget))
1782 gtk_style_set_background (widget->style, widget->window, widget->state);
1785 set_entry_widget_font (sheet);
1790 psppire_sheet_realize (GtkWidget *widget)
1792 PsppireSheet *sheet;
1793 GdkWindowAttr attributes;
1794 const gint attributes_mask =
1795 GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP | GDK_WA_CURSOR;
1798 GdkColormap *colormap;
1799 GdkDisplay *display;
1801 g_return_if_fail (widget != NULL);
1802 g_return_if_fail (PSPPIRE_IS_SHEET (widget));
1804 sheet = PSPPIRE_SHEET (widget);
1806 colormap = gtk_widget_get_colormap (widget);
1807 display = gtk_widget_get_display (widget);
1809 attributes.window_type = GDK_WINDOW_CHILD;
1810 attributes.x = widget->allocation.x;
1811 attributes.y = widget->allocation.y;
1812 attributes.width = widget->allocation.width;
1813 attributes.height = widget->allocation.height;
1814 attributes.wclass = GDK_INPUT_OUTPUT;
1816 attributes.visual = gtk_widget_get_visual (widget);
1817 attributes.colormap = colormap;
1819 attributes.event_mask = gtk_widget_get_events (widget);
1820 attributes.event_mask |= (GDK_EXPOSURE_MASK |
1821 GDK_BUTTON_PRESS_MASK |
1822 GDK_BUTTON_RELEASE_MASK |
1823 GDK_KEY_PRESS_MASK |
1824 GDK_ENTER_NOTIFY_MASK |
1825 GDK_LEAVE_NOTIFY_MASK |
1826 GDK_POINTER_MOTION_MASK |
1827 GDK_POINTER_MOTION_HINT_MASK);
1829 attributes.cursor = gdk_cursor_new_for_display (display, GDK_TOP_LEFT_ARROW);
1832 widget->window = gdk_window_new (gtk_widget_get_parent_window (widget), &attributes, attributes_mask);
1834 gdk_window_set_user_data (widget->window, sheet);
1836 widget->style = gtk_style_attach (widget->style, widget->window);
1838 gtk_style_set_background (widget->style, widget->window, GTK_STATE_NORMAL);
1840 gdk_color_parse ("white", &sheet->color[BG_COLOR]);
1841 gdk_colormap_alloc_color (colormap, &sheet->color[BG_COLOR], FALSE,
1843 gdk_color_parse ("gray", &sheet->color[GRID_COLOR]);
1844 gdk_colormap_alloc_color (colormap, &sheet->color[GRID_COLOR], FALSE,
1849 attributes.width = sheet->column_title_area.width;
1850 attributes.height = sheet->column_title_area.height;
1853 /* column - title window */
1854 sheet->column_title_window =
1855 gdk_window_new (widget->window, &attributes, attributes_mask);
1856 gdk_window_set_user_data (sheet->column_title_window, sheet);
1857 gtk_style_set_background (widget->style, sheet->column_title_window,
1863 attributes.width = sheet->row_title_area.width;
1864 attributes.height = sheet->row_title_area.height;
1866 /* row - title window */
1867 sheet->row_title_window = gdk_window_new (widget->window,
1868 &attributes, attributes_mask);
1869 gdk_window_set_user_data (sheet->row_title_window, sheet);
1870 gtk_style_set_background (widget->style, sheet->row_title_window,
1873 /* sheet - window */
1874 attributes.cursor = gdk_cursor_new_for_display (display, GDK_PLUS);
1879 sheet->sheet_window = gdk_window_new (widget->window,
1880 &attributes, attributes_mask);
1881 gdk_window_set_user_data (sheet->sheet_window, sheet);
1883 gdk_cursor_unref (attributes.cursor);
1885 gdk_window_set_background (sheet->sheet_window, &widget->style->white);
1886 gdk_window_show (sheet->sheet_window);
1889 sheet->fg_gc = gdk_gc_new (widget->window);
1890 sheet->bg_gc = gdk_gc_new (widget->window);
1892 values.foreground = widget->style->white;
1893 values.function = GDK_INVERT;
1894 values.subwindow_mode = GDK_INCLUDE_INFERIORS;
1895 values.line_width = MAX (sheet->cell_padding->left,
1896 MAX (sheet->cell_padding->right,
1897 MAX (sheet->cell_padding->top,
1898 sheet->cell_padding->bottom)));
1900 sheet->xor_gc = gdk_gc_new_with_values (widget->window,
1908 gtk_widget_set_parent_window (sheet->entry_widget, sheet->sheet_window);
1909 gtk_widget_set_parent (sheet->entry_widget, GTK_WIDGET (sheet));
1911 gtk_widget_set_parent_window (sheet->button, sheet->sheet_window);
1912 gtk_widget_set_parent (sheet->button, GTK_WIDGET (sheet));
1914 sheet->button->style = gtk_style_attach (sheet->button->style,
1915 sheet->sheet_window);
1918 sheet->cursor_drag = gdk_cursor_new_for_display (display, GDK_PLUS);
1920 if (sheet->column_titles_visible)
1921 gdk_window_show (sheet->column_title_window);
1922 if (sheet->row_titles_visible)
1923 gdk_window_show (sheet->row_title_window);
1925 sheet->hover_window = create_hover_window ();
1927 draw_row_title_buttons (sheet);
1928 draw_column_title_buttons (sheet);
1930 psppire_sheet_update_primary_selection (sheet);
1933 GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
1937 create_global_button (PsppireSheet *sheet)
1939 sheet->button = gtk_button_new_with_label (" ");
1941 GTK_WIDGET_UNSET_FLAGS(sheet->button, GTK_CAN_FOCUS);
1943 g_object_ref_sink (sheet->button);
1945 g_signal_connect (sheet->button,
1947 G_CALLBACK (global_button_clicked),
1952 size_allocate_global_button (PsppireSheet *sheet)
1954 GtkAllocation allocation;
1956 if (!sheet->column_titles_visible) return;
1957 if (!sheet->row_titles_visible) return;
1959 gtk_widget_size_request (sheet->button, NULL);
1963 allocation.width = sheet->row_title_area.width;
1964 allocation.height = sheet->column_title_area.height;
1966 gtk_widget_size_allocate (sheet->button, &allocation);
1970 global_button_clicked (GtkWidget *widget, gpointer data)
1972 psppire_sheet_click_cell (PSPPIRE_SHEET (data), -1, -1);
1977 psppire_sheet_unrealize (GtkWidget *widget)
1979 PsppireSheet *sheet;
1981 g_return_if_fail (widget != NULL);
1982 g_return_if_fail (PSPPIRE_IS_SHEET (widget));
1984 sheet = PSPPIRE_SHEET (widget);
1986 gdk_cursor_unref (sheet->cursor_drag);
1987 sheet->cursor_drag = NULL;
1989 gdk_colormap_free_colors (gtk_widget_get_colormap (widget),
1990 sheet->color, n_COLORS);
1992 g_object_unref (sheet->xor_gc);
1993 g_object_unref (sheet->fg_gc);
1994 g_object_unref (sheet->bg_gc);
1996 destroy_hover_window (sheet->hover_window);
1998 gdk_window_destroy (sheet->sheet_window);
1999 gdk_window_destroy (sheet->column_title_window);
2000 gdk_window_destroy (sheet->row_title_window);
2002 gtk_widget_unparent (sheet->entry_widget);
2003 if (sheet->button != NULL)
2004 gtk_widget_unparent (sheet->button);
2006 if (GTK_WIDGET_CLASS (parent_class)->unrealize)
2007 (* GTK_WIDGET_CLASS (parent_class)->unrealize) (widget);
2011 psppire_sheet_map (GtkWidget *widget)
2013 PsppireSheet *sheet = PSPPIRE_SHEET (widget);
2015 g_return_if_fail (widget != NULL);
2016 g_return_if_fail (PSPPIRE_IS_SHEET (widget));
2018 if (!GTK_WIDGET_MAPPED (widget))
2020 GTK_WIDGET_SET_FLAGS (widget, GTK_MAPPED);
2022 gdk_window_show (widget->window);
2023 gdk_window_show (sheet->sheet_window);
2025 if (sheet->column_titles_visible)
2027 draw_column_title_buttons (sheet);
2028 gdk_window_show (sheet->column_title_window);
2030 if (sheet->row_titles_visible)
2032 draw_row_title_buttons (sheet);
2033 gdk_window_show (sheet->row_title_window);
2036 if (!GTK_WIDGET_MAPPED (sheet->entry_widget)
2037 && sheet->active_cell.row >= 0
2038 && sheet->active_cell.col >= 0 )
2040 gtk_widget_show (sheet->entry_widget);
2041 gtk_widget_map (sheet->entry_widget);
2044 if (!GTK_WIDGET_MAPPED (sheet->button))
2046 gtk_widget_show (sheet->button);
2047 gtk_widget_map (sheet->button);
2050 redraw_range (sheet, NULL);
2051 change_active_cell (sheet,
2052 sheet->active_cell.row,
2053 sheet->active_cell.col);
2058 psppire_sheet_unmap (GtkWidget *widget)
2060 PsppireSheet *sheet = PSPPIRE_SHEET (widget);
2062 if (!GTK_WIDGET_MAPPED (widget))
2065 GTK_WIDGET_UNSET_FLAGS (widget, GTK_MAPPED);
2067 gdk_window_hide (sheet->sheet_window);
2068 if (sheet->column_titles_visible)
2069 gdk_window_hide (sheet->column_title_window);
2070 if (sheet->row_titles_visible)
2071 gdk_window_hide (sheet->row_title_window);
2072 gdk_window_hide (widget->window);
2074 gtk_widget_unmap (sheet->entry_widget);
2075 gtk_widget_unmap (sheet->button);
2076 gtk_widget_unmap (sheet->hover_window->window);
2079 /* get cell attributes of the given cell */
2080 /* TRUE means that the cell is currently allocated */
2081 static gboolean psppire_sheet_get_attributes (const PsppireSheet *sheet,
2083 PsppireSheetCellAttr *attributes);
2088 psppire_sheet_cell_draw (PsppireSheet *sheet, gint row, gint col)
2090 PangoLayout *layout;
2091 PangoRectangle text;
2092 PangoFontDescription *font_desc = GTK_WIDGET (sheet)->style->font_desc;
2097 PsppireSheetCellAttr attributes;
2100 g_return_if_fail (sheet != NULL);
2102 /* bail now if we aren't yet drawable */
2103 if (!GTK_WIDGET_DRAWABLE (sheet)) return;
2106 row >= psppire_axis_unit_count (sheet->vaxis))
2110 col >= psppire_axis_unit_count (sheet->haxis))
2113 psppire_sheet_get_attributes (sheet, row, col, &attributes);
2115 /* select GC for background rectangle */
2116 gdk_gc_set_foreground (sheet->fg_gc, &attributes.foreground);
2117 gdk_gc_set_foreground (sheet->bg_gc, &attributes.background);
2119 rectangle_from_cell (sheet, row, col, &area);
2121 gdk_gc_set_line_attributes (sheet->fg_gc, 1, 0, 0, 0);
2123 if (sheet->show_grid)
2125 gdk_gc_set_foreground (sheet->bg_gc, &sheet->color[GRID_COLOR]);
2127 gdk_draw_rectangle (sheet->sheet_window,
2131 area.width, area.height);
2135 label = psppire_sheet_cell_get_text (sheet, row, col);
2140 layout = gtk_widget_create_pango_layout (GTK_WIDGET (sheet), label);
2141 dispose_string (sheet, label);
2144 pango_layout_set_font_description (layout, font_desc);
2146 pango_layout_get_pixel_extents (layout, NULL, &text);
2148 gdk_gc_set_clip_rectangle (sheet->fg_gc, &area);
2150 font_height = pango_font_description_get_size (font_desc);
2151 if ( !pango_font_description_get_size_is_absolute (font_desc))
2152 font_height /= PANGO_SCALE;
2155 if ( sheet->cell_padding )
2157 area.x += sheet->cell_padding->left;
2158 area.width -= sheet->cell_padding->right
2159 + sheet->cell_padding->left;
2161 area.y += sheet->cell_padding->top;
2162 area.height -= sheet->cell_padding->bottom
2164 sheet->cell_padding->top;
2167 /* Centre the text vertically */
2168 area.y += (area.height - font_height) / 2.0;
2170 switch (attributes.justification)
2172 case GTK_JUSTIFY_RIGHT:
2173 area.x += area.width - text.width;
2175 case GTK_JUSTIFY_CENTER:
2176 area.x += (area.width - text.width) / 2.0;
2178 case GTK_JUSTIFY_LEFT:
2182 g_critical ("Unhandled justification %d in column %d\n",
2183 attributes.justification, col);
2187 gdk_draw_layout (sheet->sheet_window, sheet->fg_gc,
2192 gdk_gc_set_clip_rectangle (sheet->fg_gc, NULL);
2193 g_object_unref (layout);
2198 draw_sheet_region (PsppireSheet *sheet, GdkRegion *region)
2200 PsppireSheetRange range;
2205 PsppireSheetRange drawing_range;
2207 gdk_region_get_clipbox (region, &area);
2209 y = area.y + sheet->vadjustment->value;
2210 x = area.x + sheet->hadjustment->value;
2212 if ( sheet->column_titles_visible)
2213 y -= sheet->column_title_area.height;
2215 if ( sheet->row_titles_visible)
2216 x -= sheet->row_title_area.width;
2218 maximize_int (&x, 0);
2219 maximize_int (&y, 0);
2221 range.row0 = row_from_ypixel (sheet, y);
2222 range.rowi = row_from_ypixel (sheet, y + area.height);
2224 range.col0 = column_from_xpixel (sheet, x);
2225 range.coli = column_from_xpixel (sheet, x + area.width);
2227 g_return_if_fail (sheet != NULL);
2228 g_return_if_fail (PSPPIRE_SHEET (sheet));
2230 if (!GTK_WIDGET_DRAWABLE (GTK_WIDGET (sheet))) return;
2231 if (!GTK_WIDGET_REALIZED (GTK_WIDGET (sheet))) return;
2232 if (!GTK_WIDGET_MAPPED (GTK_WIDGET (sheet))) return;
2235 drawing_range.row0 = MAX (range.row0, min_visible_row (sheet));
2236 drawing_range.col0 = MAX (range.col0, min_visible_column (sheet));
2237 drawing_range.rowi = MIN (range.rowi, max_visible_row (sheet));
2238 drawing_range.coli = MIN (range.coli, max_visible_column (sheet));
2240 g_return_if_fail (drawing_range.rowi >= drawing_range.row0);
2241 g_return_if_fail (drawing_range.coli >= drawing_range.col0);
2243 for (i = drawing_range.row0; i <= drawing_range.rowi; i++)
2245 for (j = drawing_range.col0; j <= drawing_range.coli; j++)
2246 psppire_sheet_cell_draw (sheet, i, j);
2249 if (sheet->select_status == PSPPIRE_SHEET_NORMAL &&
2250 sheet->active_cell.row >= drawing_range.row0 &&
2251 sheet->active_cell.row <= drawing_range.rowi &&
2252 sheet->active_cell.col >= drawing_range.col0 &&
2253 sheet->active_cell.col <= drawing_range.coli)
2254 psppire_sheet_show_entry_widget (sheet);
2258 psppire_sheet_set_cell (PsppireSheet *sheet, gint row, gint col,
2259 GtkJustification justification,
2262 PsppireSheetModel *model ;
2265 g_return_if_fail (sheet != NULL);
2266 g_return_if_fail (PSPPIRE_IS_SHEET (sheet));
2268 if (col >= psppire_axis_unit_count (sheet->haxis)
2269 || row >= psppire_axis_unit_count (sheet->vaxis))
2272 if (col < 0 || row < 0) return;
2274 model = psppire_sheet_get_model (sheet);
2276 old_text = psppire_sheet_model_get_string (model, row, col);
2278 if (0 != g_strcmp0 (old_text, text))
2280 g_signal_handler_block (sheet->model, sheet->update_handler_id);
2281 psppire_sheet_model_set_string (model, text, row, col);
2282 g_signal_handler_unblock (sheet->model, sheet->update_handler_id);
2285 if ( psppire_sheet_model_free_strings (model))
2291 psppire_sheet_cell_clear (PsppireSheet *sheet, gint row, gint column)
2293 PsppireSheetRange range;
2295 g_return_if_fail (sheet != NULL);
2296 g_return_if_fail (PSPPIRE_IS_SHEET (sheet));
2297 if (column >= psppire_axis_unit_count (sheet->haxis) ||
2298 row >= psppire_axis_unit_count (sheet->vaxis)) return;
2300 if (column < 0 || row < 0) return;
2304 range.col0 = min_visible_column (sheet);
2305 range.coli = max_visible_column (sheet);
2307 psppire_sheet_real_cell_clear (sheet, row, column);
2309 redraw_range (sheet, &range);
2313 psppire_sheet_real_cell_clear (PsppireSheet *sheet, gint row, gint column)
2315 PsppireSheetModel *model = psppire_sheet_get_model (sheet);
2317 gchar *old_text = psppire_sheet_cell_get_text (sheet, row, column);
2319 if (old_text && strlen (old_text) > 0 )
2321 psppire_sheet_model_datum_clear (model, row, column);
2324 dispose_string (sheet, old_text);
2328 psppire_sheet_cell_get_text (const PsppireSheet *sheet, gint row, gint col)
2330 PsppireSheetModel *model;
2331 g_return_val_if_fail (sheet != NULL, NULL);
2332 g_return_val_if_fail (PSPPIRE_IS_SHEET (sheet), NULL);
2334 if (col >= psppire_axis_unit_count (sheet->haxis) || row >= psppire_axis_unit_count (sheet->vaxis))
2336 if (col < 0 || row < 0) return NULL;
2338 model = psppire_sheet_get_model (sheet);
2343 return psppire_sheet_model_get_string (model, row, col);
2347 /* Convert X, Y (in pixels) to *ROW, *COLUMN
2348 If the function returns FALSE, then the results will be unreliable.
2351 psppire_sheet_get_pixel_info (PsppireSheet *sheet,
2359 *column = -G_MAXINT;
2361 g_return_val_if_fail (sheet != NULL, 0);
2362 g_return_val_if_fail (PSPPIRE_IS_SHEET (sheet), 0);
2364 /* bounds checking, return false if the user clicked
2372 if ( sheet->column_titles_visible)
2373 y -= sheet->column_title_area.height;
2375 y += sheet->vadjustment->value;
2377 if ( y < 0 && sheet->column_titles_visible)
2383 trow = row_from_ypixel (sheet, y);
2384 if (trow > psppire_axis_unit_count (sheet->vaxis))
2390 if ( sheet->row_titles_visible)
2391 x -= sheet->row_title_area.width;
2393 x += sheet->hadjustment->value;
2395 if ( x < 0 && sheet->row_titles_visible)
2401 tcol = column_from_xpixel (sheet, x);
2402 if (tcol > psppire_axis_unit_count (sheet->haxis))
2412 psppire_sheet_get_cell_area (PsppireSheet *sheet,
2417 g_return_val_if_fail (sheet != NULL, 0);
2418 g_return_val_if_fail (PSPPIRE_IS_SHEET (sheet), 0);
2420 if (row >= psppire_axis_unit_count (sheet->vaxis) || column >= psppire_axis_unit_count (sheet->haxis))
2423 area->x = (column == -1) ? 0 : psppire_axis_start_pixel (sheet->haxis, column);
2424 area->y = (row == -1) ? 0 : psppire_axis_start_pixel (sheet->vaxis, row);
2426 area->width= (column == -1) ? sheet->row_title_area.width
2427 : psppire_axis_unit_size (sheet->haxis, column);
2429 area->height= (row == -1) ? sheet->column_title_area.height
2430 : psppire_axis_unit_size (sheet->vaxis, row);
2436 psppire_sheet_set_active_cell (PsppireSheet *sheet, gint row, gint col)
2438 g_return_if_fail (sheet != NULL);
2439 g_return_if_fail (PSPPIRE_IS_SHEET (sheet));
2441 if (row < -1 || col < -1)
2444 if (row >= psppire_axis_unit_count (sheet->vaxis)
2446 col >= psppire_axis_unit_count (sheet->haxis))
2449 if (!GTK_WIDGET_REALIZED (GTK_WIDGET (sheet)))
2452 if ( row == -1 || col == -1)
2454 psppire_sheet_hide_entry_widget (sheet);
2458 change_active_cell (sheet, row, col);
2462 psppire_sheet_get_active_cell (PsppireSheet *sheet, gint *row, gint *column)
2464 g_return_if_fail (sheet != NULL);
2465 g_return_if_fail (PSPPIRE_IS_SHEET (sheet));
2467 if ( row ) *row = sheet->active_cell.row;
2468 if (column) *column = sheet->active_cell.col;
2472 entry_load_text (PsppireSheet *sheet)
2476 GtkJustification justification;
2477 PsppireSheetCellAttr attributes;
2479 if (!GTK_WIDGET_VISIBLE (sheet->entry_widget)) return;
2480 if (sheet->select_status != PSPPIRE_SHEET_NORMAL) return;
2482 row = sheet->active_cell.row;
2483 col = sheet->active_cell.col;
2485 if (row < 0 || col < 0) return;
2487 text = gtk_entry_get_text (psppire_sheet_get_entry (sheet));
2489 if (text && strlen (text) > 0)
2491 psppire_sheet_get_attributes (sheet, row, col, &attributes);
2492 justification = attributes.justification;
2493 psppire_sheet_set_cell (sheet, row, col, justification, text);
2499 psppire_sheet_hide_entry_widget (PsppireSheet *sheet)
2501 if (!GTK_WIDGET_REALIZED (GTK_WIDGET (sheet)))
2504 if (sheet->active_cell.row < 0 ||
2505 sheet->active_cell.col < 0) return;
2507 gtk_widget_hide (sheet->entry_widget);
2508 gtk_widget_unmap (sheet->entry_widget);
2510 GTK_WIDGET_UNSET_FLAGS (GTK_WIDGET (sheet->entry_widget), GTK_VISIBLE);
2514 change_active_cell (PsppireSheet *sheet, gint row, gint col)
2516 gint old_row, old_col;
2518 g_return_if_fail (PSPPIRE_IS_SHEET (sheet));
2520 if (row < 0 || col < 0)
2523 if ( row > psppire_axis_unit_count (sheet->vaxis)
2524 || col > psppire_axis_unit_count (sheet->haxis))
2527 old_row = sheet->active_cell.row;
2528 old_col = sheet->active_cell.col;
2530 entry_load_text (sheet);
2532 /* Erase the old cell border */
2533 psppire_sheet_draw_active_cell (sheet);
2535 sheet->active_cell.row = row;
2536 sheet->active_cell.col = col;
2538 PSPPIRE_SHEET_UNSET_FLAGS (sheet, PSPPIRE_SHEET_IN_SELECTION);
2540 GTK_WIDGET_UNSET_FLAGS (sheet->entry_widget, GTK_HAS_FOCUS);
2542 psppire_sheet_draw_active_cell (sheet);
2543 psppire_sheet_show_entry_widget (sheet);
2545 GTK_WIDGET_SET_FLAGS (sheet->entry_widget, GTK_HAS_FOCUS);
2547 g_signal_emit (sheet, sheet_signals [ACTIVATE], 0,
2548 row, col, old_row, old_col);
2553 psppire_sheet_show_entry_widget (PsppireSheet *sheet)
2555 GtkEntry *sheet_entry;
2556 PsppireSheetCellAttr attributes;
2560 g_return_if_fail (PSPPIRE_IS_SHEET (sheet));
2562 row = sheet->active_cell.row;
2563 col = sheet->active_cell.col;
2565 /* Don't show the active cell, if there is no active cell: */
2566 if (! (row >= 0 && col >= 0)) /* e.g row or coll == -1. */
2569 if (!GTK_WIDGET_REALIZED (GTK_WIDGET (sheet))) return;
2570 if (sheet->select_status != PSPPIRE_SHEET_NORMAL) return;
2571 if (PSPPIRE_SHEET_IN_SELECTION (sheet)) return;
2573 GTK_WIDGET_SET_FLAGS (GTK_WIDGET (sheet->entry_widget), GTK_VISIBLE);
2575 sheet_entry = psppire_sheet_get_entry (sheet);
2577 psppire_sheet_get_attributes (sheet, row, col, &attributes);
2579 if (GTK_IS_ENTRY (sheet_entry))
2581 gchar *text = psppire_sheet_cell_get_text (sheet, row, col);
2582 const gchar *old_text = gtk_entry_get_text (GTK_ENTRY (sheet_entry));
2585 text = g_strdup ("");
2587 if (strcmp (old_text, text) != 0)
2588 gtk_entry_set_text (sheet_entry, text);
2590 dispose_string (sheet, text);
2593 switch (attributes.justification)
2595 case GTK_JUSTIFY_RIGHT:
2596 gtk_entry_set_alignment (GTK_ENTRY (sheet_entry), 1.0);
2598 case GTK_JUSTIFY_CENTER:
2599 gtk_entry_set_alignment (GTK_ENTRY (sheet_entry), 0.5);
2601 case GTK_JUSTIFY_LEFT:
2603 gtk_entry_set_alignment (GTK_ENTRY (sheet_entry), 0.0);
2609 psppire_sheet_size_allocate_entry (sheet);
2611 gtk_widget_set_sensitive (GTK_WIDGET (sheet_entry),
2612 psppire_sheet_model_is_editable (sheet->model,
2614 gtk_widget_map (sheet->entry_widget);
2618 psppire_sheet_draw_active_cell (PsppireSheet *sheet)
2621 PsppireSheetRange range;
2623 row = sheet->active_cell.row;
2624 col = sheet->active_cell.col;
2626 if (row < 0 || col < 0) return FALSE;
2628 if (!psppire_sheet_cell_isvisible (sheet, row, col))
2631 range.col0 = range.coli = col;
2632 range.row0 = range.rowi = row;
2634 psppire_sheet_draw_border (sheet, range);
2642 psppire_sheet_draw_border (PsppireSheet *sheet, PsppireSheetRange new_range)
2646 rectangle_from_range (sheet, &new_range, &area);
2651 gdk_gc_set_clip_rectangle (sheet->xor_gc, &area);
2653 area.x += sheet->cell_padding->left / 2;
2654 area.y += sheet->cell_padding->top / 2;
2655 area.width -= (sheet->cell_padding->left + sheet->cell_padding->right ) / 2;
2656 area.height -= (sheet->cell_padding->top + sheet->cell_padding->bottom ) / 2;
2658 gdk_draw_rectangle (sheet->sheet_window, sheet->xor_gc,
2665 gdk_gc_set_clip_rectangle (sheet->xor_gc, NULL);
2670 /* Selection related functions */
2673 psppire_sheet_select_row (PsppireSheet *sheet, gint row)
2676 sheet->select_status = PSPPIRE_SHEET_ROW_SELECTED;
2678 sheet->range.col0 = sheet->range.coli = -1;
2679 sheet->range.row0 = sheet->range.rowi = row;
2681 rectangle_from_range (sheet, &sheet->range, &area);
2685 gdk_window_invalidate_rect (sheet->sheet_window, &area, FALSE);
2687 g_signal_emit (sheet, sheet_signals [SELECT_ROW], 0, row);
2691 psppire_sheet_select_column (PsppireSheet *sheet, gint column)
2694 sheet->select_status = PSPPIRE_SHEET_COLUMN_SELECTED;
2696 sheet->range.col0 = sheet->range.coli = column;
2697 sheet->range.row0 = sheet->range.rowi = -1;
2699 rectangle_from_range (sheet, &sheet->range, &area);
2703 gdk_window_invalidate_rect (sheet->sheet_window, &area, FALSE);
2705 g_signal_emit (sheet, sheet_signals [SELECT_COLUMN], 0, column);
2710 psppire_sheet_select_range (PsppireSheet *sheet, const PsppireSheetRange *range)
2713 sheet->select_status = PSPPIRE_SHEET_RANGE_SELECTED;
2715 sheet->range = *range;
2717 rectangle_from_range (sheet, range, &area);
2720 gdk_window_invalidate_rect (sheet->sheet_window, &area, FALSE);
2725 psppire_sheet_unselect_range (PsppireSheet *sheet)
2728 sheet->select_status = PSPPIRE_SHEET_NORMAL;
2730 rectangle_from_range (sheet, &sheet->range, &area);
2733 gdk_window_invalidate_rect (sheet->sheet_window, &area, FALSE);
2735 g_signal_emit (sheet, sheet_signals [SELECT_COLUMN], 0, -1);
2736 g_signal_emit (sheet, sheet_signals [SELECT_ROW], 0, -1);
2740 psppire_sheet_get_selected_range (PsppireSheet *sheet, PsppireSheetRange *range)
2742 g_return_if_fail (sheet != NULL);
2743 *range = sheet->range;
2748 psppire_sheet_expose (GtkWidget *widget, GdkEventExpose *event)
2750 PsppireSheet *sheet = PSPPIRE_SHEET (widget);
2752 g_return_val_if_fail (event != NULL, FALSE);
2754 if (!GTK_WIDGET_DRAWABLE (widget))
2757 /* exposure events on the sheet */
2758 if (event->window == sheet->row_title_window &&
2759 sheet->row_titles_visible)
2761 draw_row_title_buttons_range (sheet,
2762 min_visible_row (sheet),
2763 max_visible_row (sheet));
2766 if (event->window == sheet->column_title_window &&
2767 sheet->column_titles_visible)
2769 draw_column_title_buttons_range (sheet,
2770 min_visible_column (sheet),
2771 max_visible_column (sheet));
2774 if (event->window == sheet->sheet_window)
2776 draw_sheet_region (sheet, event->region);
2778 if (sheet->select_status != PSPPIRE_SHEET_NORMAL)
2782 rectangle_from_range (sheet, &sheet->range, &area);
2784 gdk_draw_rectangle (sheet->sheet_window,
2787 area.x + 1, area.y + 1,
2788 area.width, area.height);
2792 if ((!PSPPIRE_SHEET_IN_XDRAG (sheet)) && (!PSPPIRE_SHEET_IN_YDRAG (sheet)))
2795 PsppireSheetRange range;
2796 range.row0 = range.rowi = sheet->active_cell.row;
2797 range.col0 = range.coli = sheet->active_cell.col;
2799 rectangle_from_range (sheet, &range, &rect);
2801 if (GDK_OVERLAP_RECTANGLE_OUT !=
2802 gdk_region_rect_in (event->region, &rect))
2804 psppire_sheet_draw_active_cell (sheet);
2810 (* GTK_WIDGET_CLASS (parent_class)->expose_event) (widget, event);
2817 psppire_sheet_button_press (GtkWidget *widget, GdkEventButton *event)
2819 PsppireSheet *sheet;
2820 GdkModifierType mods;
2825 g_return_val_if_fail (widget != NULL, FALSE);
2826 g_return_val_if_fail (PSPPIRE_IS_SHEET (widget), FALSE);
2827 g_return_val_if_fail (event != NULL, FALSE);
2829 sheet = PSPPIRE_SHEET (widget);
2831 /* Cancel any pending tooltips */
2832 if (sheet->motion_timer)
2834 g_source_remove (sheet->motion_timer);
2835 sheet->motion_timer = 0;
2838 gtk_widget_get_pointer (widget, &x, &y);
2839 psppire_sheet_get_pixel_info (sheet, x, y, &row, &column);
2842 if (event->window == sheet->column_title_window)
2844 sheet->x_drag = event->x;
2845 g_signal_emit (sheet,
2846 sheet_signals[BUTTON_EVENT_COLUMN], 0,
2849 if (psppire_sheet_model_get_column_sensitivity (sheet->model, column))
2851 if ( event->type == GDK_2BUTTON_PRESS && event->button == 1)
2852 g_signal_emit (sheet,
2853 sheet_signals[DOUBLE_CLICK_COLUMN], 0, column);
2857 if (event->window == sheet->row_title_window)
2859 g_signal_emit (sheet,
2860 sheet_signals[BUTTON_EVENT_ROW], 0,
2863 if (psppire_sheet_model_get_row_sensitivity (sheet->model, row))
2865 if ( event->type == GDK_2BUTTON_PRESS && event->button == 1)
2866 g_signal_emit (sheet,
2867 sheet_signals[DOUBLE_CLICK_ROW], 0, row);
2871 gdk_window_get_pointer (widget->window, NULL, NULL, &mods);
2873 if (! (mods & GDK_BUTTON1_MASK)) return TRUE;
2876 /* press on resize windows */
2877 if (event->window == sheet->column_title_window)
2879 sheet->x_drag = event->x;
2881 if (on_column_boundary (sheet, sheet->x_drag, &sheet->drag_cell.col))
2883 PSPPIRE_SHEET_SET_FLAGS (sheet, PSPPIRE_SHEET_IN_XDRAG);
2884 gdk_pointer_grab (sheet->column_title_window, FALSE,
2885 GDK_POINTER_MOTION_HINT_MASK |
2886 GDK_BUTTON1_MOTION_MASK |
2887 GDK_BUTTON_RELEASE_MASK,
2888 NULL, NULL, event->time);
2890 draw_xor_vline (sheet);
2895 if (event->window == sheet->row_title_window)
2897 sheet->y_drag = event->y;
2899 if (on_row_boundary (sheet, sheet->y_drag, &sheet->drag_cell.row))
2901 PSPPIRE_SHEET_SET_FLAGS (sheet, PSPPIRE_SHEET_IN_YDRAG);
2902 gdk_pointer_grab (sheet->row_title_window, FALSE,
2903 GDK_POINTER_MOTION_HINT_MASK |
2904 GDK_BUTTON1_MOTION_MASK |
2905 GDK_BUTTON_RELEASE_MASK,
2906 NULL, NULL, event->time);
2908 draw_xor_hline (sheet);
2913 /* the sheet itself does not handle other than single click events */
2914 if (event->type != GDK_BUTTON_PRESS) return FALSE;
2916 /* selections on the sheet */
2917 if (event->window == sheet->sheet_window)
2919 gtk_widget_get_pointer (widget, &x, &y);
2920 psppire_sheet_get_pixel_info (sheet, x, y, &row, &column);
2921 gdk_pointer_grab (sheet->sheet_window, FALSE,
2922 GDK_POINTER_MOTION_HINT_MASK |
2923 GDK_BUTTON1_MOTION_MASK |
2924 GDK_BUTTON_RELEASE_MASK,
2925 NULL, NULL, event->time);
2926 gtk_grab_add (GTK_WIDGET (sheet));
2928 if ( sheet->select_status == PSPPIRE_SHEET_NORMAL)
2930 sheet->range.row0 = row;
2931 sheet->range.col0 = column;
2935 psppire_sheet_unselect_range (sheet);
2937 psppire_sheet_click_cell (sheet, row, column);
2940 if (event->window == sheet->column_title_window)
2942 gtk_widget_get_pointer (widget, &x, &y);
2943 if ( sheet->row_titles_visible)
2944 x -= sheet->row_title_area.width;
2946 x += sheet->hadjustment->value;
2948 column = column_from_xpixel (sheet, x);
2950 if (psppire_sheet_model_get_column_sensitivity (sheet->model, column))
2952 gtk_grab_add (GTK_WIDGET (sheet));
2953 PSPPIRE_SHEET_SET_FLAGS (sheet, PSPPIRE_SHEET_IN_SELECTION);
2957 if (event->window == sheet->row_title_window)
2959 gtk_widget_get_pointer (widget, &x, &y);
2960 if ( sheet->column_titles_visible)
2961 y -= sheet->column_title_area.height;
2963 y += sheet->vadjustment->value;
2965 row = row_from_ypixel (sheet, y);
2966 if (psppire_sheet_model_get_row_sensitivity (sheet->model, row))
2968 gtk_grab_add (GTK_WIDGET (sheet));
2969 PSPPIRE_SHEET_SET_FLAGS (sheet, PSPPIRE_SHEET_IN_SELECTION);
2977 psppire_sheet_click_cell (PsppireSheet *sheet, gint row, gint column)
2979 PsppireSheetCell cell;
2980 gboolean forbid_move;
2985 if (row >= psppire_axis_unit_count (sheet->vaxis)
2986 || column >= psppire_axis_unit_count (sheet->haxis))
2991 g_signal_emit (sheet, sheet_signals[TRAVERSE], 0,
2992 &sheet->active_cell,
2998 if (sheet->select_status == PSPPIRE_SHEET_NORMAL)
3001 row = sheet->active_cell.row;
3002 column = sheet->active_cell.col;
3004 change_active_cell (sheet, row, column);
3008 if (row == -1 && column >= 0)
3010 psppire_sheet_select_column (sheet, column);
3014 if (column == -1 && row >= 0)
3016 psppire_sheet_select_row (sheet, row);
3020 if (row == -1 && column == -1)
3022 sheet->range.row0 = 0;
3023 sheet->range.col0 = 0;
3024 sheet->range.rowi = psppire_axis_unit_count (sheet->vaxis) - 1;
3025 sheet->range.coli = psppire_axis_unit_count (sheet->haxis) - 1;
3029 if (sheet->select_status == PSPPIRE_SHEET_NORMAL)
3030 change_active_cell (sheet, row, column);
3032 gtk_widget_grab_focus (GTK_WIDGET (sheet->entry_widget));
3038 psppire_sheet_button_release (GtkWidget *widget,
3039 GdkEventButton *event)
3041 GdkDisplay *display = gtk_widget_get_display (widget);
3043 PsppireSheet *sheet = PSPPIRE_SHEET (widget);
3045 /* release on resize windows */
3046 if (PSPPIRE_SHEET_IN_XDRAG (sheet))
3049 PSPPIRE_SHEET_UNSET_FLAGS (sheet, PSPPIRE_SHEET_IN_XDRAG);
3050 PSPPIRE_SHEET_UNSET_FLAGS (sheet, PSPPIRE_SHEET_IN_SELECTION);
3052 gdk_display_pointer_ungrab (display, event->time);
3053 draw_xor_vline (sheet);
3056 psppire_axis_start_pixel (sheet->haxis, sheet->drag_cell.col)
3057 + sheet->hadjustment->value;
3059 set_column_width (sheet, sheet->drag_cell.col, width);
3064 if (PSPPIRE_SHEET_IN_YDRAG (sheet))
3067 PSPPIRE_SHEET_UNSET_FLAGS (sheet, PSPPIRE_SHEET_IN_YDRAG);
3068 PSPPIRE_SHEET_UNSET_FLAGS (sheet, PSPPIRE_SHEET_IN_SELECTION);
3070 gdk_display_pointer_ungrab (display, event->time);
3071 draw_xor_hline (sheet);
3074 psppire_axis_start_pixel (sheet->vaxis, sheet->drag_cell.row) +
3075 sheet->vadjustment->value;
3077 set_row_height (sheet, sheet->drag_cell.row, height);
3082 if (PSPPIRE_SHEET_IN_DRAG (sheet))
3084 PsppireSheetRange old_range;
3085 draw_xor_rectangle (sheet, sheet->drag_range);
3086 PSPPIRE_SHEET_UNSET_FLAGS (sheet, PSPPIRE_SHEET_IN_DRAG);
3087 gdk_display_pointer_ungrab (display, event->time);
3089 psppire_sheet_unselect_range (sheet);
3091 old_range = sheet->range;
3092 sheet->range = sheet->drag_range;
3093 sheet->drag_range = old_range;
3094 g_signal_emit (sheet, sheet_signals[MOVE_RANGE], 0,
3095 &sheet->drag_range, &sheet->range);
3096 psppire_sheet_select_range (sheet, &sheet->range);
3099 if (PSPPIRE_SHEET_IN_SELECTION (sheet))
3101 PSPPIRE_SHEET_UNSET_FLAGS (sheet, PSPPIRE_SHEET_IN_SELECTION);
3102 sheet->select_status = PSPPIRE_SHEET_RANGE_SELECTED;
3104 change_active_cell (sheet, sheet->active_cell.row,
3105 sheet->active_cell.col);
3108 gdk_display_pointer_ungrab (display, event->time);
3109 gtk_grab_remove (GTK_WIDGET (sheet));
3111 PSPPIRE_SHEET_UNSET_FLAGS (sheet, PSPPIRE_SHEET_IN_SELECTION);
3120 /* Shamelessly lifted from gtktooltips */
3122 psppire_sheet_subtitle_paint_window (GtkWidget *tip_window)
3126 gtk_widget_size_request (tip_window, &req);
3127 gtk_paint_flat_box (tip_window->style, tip_window->window,
3128 GTK_STATE_NORMAL, GTK_SHADOW_OUT,
3129 NULL, GTK_WIDGET(tip_window), "tooltip",
3130 0, 0, req.width, req.height);
3136 destroy_hover_window (PsppireSheetHoverTitle *h)
3138 gtk_widget_destroy (h->window);
3142 static PsppireSheetHoverTitle *
3143 create_hover_window (void)
3145 PsppireSheetHoverTitle *hw = g_malloc (sizeof (*hw));
3147 hw->window = gtk_window_new (GTK_WINDOW_POPUP);
3149 #if GTK_CHECK_VERSION (2, 9, 0)
3150 gtk_window_set_type_hint (GTK_WINDOW (hw->window),
3151 GDK_WINDOW_TYPE_HINT_TOOLTIP);
3154 gtk_widget_set_app_paintable (hw->window, TRUE);
3155 gtk_window_set_resizable (GTK_WINDOW (hw->window), FALSE);
3156 gtk_widget_set_name (hw->window, "gtk-tooltips");
3157 gtk_container_set_border_width (GTK_CONTAINER (hw->window), 4);
3159 g_signal_connect (hw->window,
3161 G_CALLBACK (psppire_sheet_subtitle_paint_window),
3164 hw->label = gtk_label_new (NULL);
3167 gtk_label_set_line_wrap (GTK_LABEL (hw->label), TRUE);
3168 gtk_misc_set_alignment (GTK_MISC (hw->label), 0.5, 0.5);
3170 gtk_container_add (GTK_CONTAINER (hw->window), hw->label);
3172 gtk_widget_show (hw->label);
3174 g_signal_connect (hw->window,
3176 G_CALLBACK (gtk_widget_destroyed),
3182 #define HOVER_WINDOW_Y_OFFSET 2
3185 show_subtitle (PsppireSheet *sheet, gint row, gint column,
3186 const gchar *subtitle)
3195 gtk_label_set_text (GTK_LABEL (sheet->hover_window->label),
3199 sheet->hover_window->row = row;
3200 sheet->hover_window->column = column;
3202 gdk_window_get_origin (GTK_WIDGET (sheet)->window, &x, &y);
3204 gtk_widget_get_pointer (GTK_WIDGET (sheet), &px, &py);
3206 gtk_widget_show (sheet->hover_window->window);
3208 width = GTK_WIDGET (sheet->hover_window->label)->allocation.width;
3214 y += sheet->column_title_area.y;
3215 y += sheet->column_title_area.height;
3216 y += HOVER_WINDOW_Y_OFFSET;
3222 x += sheet->row_title_area.x;
3223 x += sheet->row_title_area.width * 2 / 3.0;
3226 gtk_window_move (GTK_WINDOW (sheet->hover_window->window),
3231 motion_timeout_callback (gpointer data)
3233 PsppireSheet *sheet = PSPPIRE_SHEET (data);
3237 gdk_threads_enter ();
3238 gtk_widget_get_pointer (GTK_WIDGET (sheet), &x, &y);
3240 if ( psppire_sheet_get_pixel_info (sheet, x, y, &row, &column) )
3242 if (sheet->row_title_under && row >= 0)
3244 gchar *text = psppire_sheet_model_get_row_subtitle (sheet->model, row);
3246 show_subtitle (sheet, row, -1, text);
3250 if (sheet->column_title_under && column >= 0)
3252 gchar *text = psppire_sheet_model_get_column_subtitle (sheet->model,
3255 show_subtitle (sheet, -1, column, text);
3261 gdk_threads_leave ();
3266 psppire_sheet_motion (GtkWidget *widget, GdkEventMotion *event)
3268 PsppireSheet *sheet = PSPPIRE_SHEET (widget);
3269 GdkModifierType mods;
3270 GdkCursorType new_cursor;
3273 GdkDisplay *display;
3275 g_return_val_if_fail (event != NULL, FALSE);
3277 display = gtk_widget_get_display (widget);
3279 /* selections on the sheet */
3283 if (!GTK_WIDGET_VISIBLE (sheet->hover_window->window))
3285 if ( sheet->motion_timer > 0 )
3286 g_source_remove (sheet->motion_timer);
3287 sheet->motion_timer =
3288 g_timeout_add (TIMEOUT_HOVER, motion_timeout_callback, sheet);
3294 gtk_widget_get_pointer (widget, &wx, &wy);
3296 if ( psppire_sheet_get_pixel_info (sheet, wx, wy, &row, &column) )
3298 if ( row != sheet->hover_window->row ||
3299 column != sheet->hover_window->column)
3301 gtk_widget_hide (sheet->hover_window->window);
3306 if (event->window == sheet->column_title_window)
3308 if (!PSPPIRE_SHEET_IN_SELECTION (sheet) &&
3309 on_column_boundary (sheet, x, &column))
3311 new_cursor = GDK_SB_H_DOUBLE_ARROW;
3312 if (new_cursor != sheet->cursor_drag->type)
3314 gdk_cursor_unref (sheet->cursor_drag);
3315 sheet->cursor_drag =
3316 gdk_cursor_new_for_display (display, new_cursor);
3318 gdk_window_set_cursor (sheet->column_title_window,
3319 sheet->cursor_drag);
3324 new_cursor = GDK_TOP_LEFT_ARROW;
3325 if (!PSPPIRE_SHEET_IN_XDRAG (sheet) &&
3326 new_cursor != sheet->cursor_drag->type)
3328 gdk_cursor_unref (sheet->cursor_drag);
3329 sheet->cursor_drag =
3330 gdk_cursor_new_for_display (display, new_cursor);
3331 gdk_window_set_cursor (sheet->column_title_window,
3332 sheet->cursor_drag);
3336 else if (event->window == sheet->row_title_window)
3338 if (!PSPPIRE_SHEET_IN_SELECTION (sheet) &&
3339 on_row_boundary (sheet, y, &row))
3341 new_cursor = GDK_SB_V_DOUBLE_ARROW;
3342 if (new_cursor != sheet->cursor_drag->type)
3344 gdk_cursor_unref (sheet->cursor_drag);
3345 sheet->cursor_drag =
3346 gdk_cursor_new_for_display (display, new_cursor);
3347 gdk_window_set_cursor (sheet->row_title_window,
3348 sheet->cursor_drag);
3353 new_cursor = GDK_TOP_LEFT_ARROW;
3354 if (!PSPPIRE_SHEET_IN_YDRAG (sheet) &&
3355 new_cursor != sheet->cursor_drag->type)
3357 gdk_cursor_unref (sheet->cursor_drag);
3358 sheet->cursor_drag =
3359 gdk_cursor_new_for_display (display, new_cursor);
3360 gdk_window_set_cursor (sheet->row_title_window,
3361 sheet->cursor_drag);
3366 new_cursor = GDK_PLUS;
3367 if ( event->window == sheet->sheet_window &&
3368 !POSSIBLE_DRAG (sheet, x, y, &row, &column) &&
3369 !PSPPIRE_SHEET_IN_DRAG (sheet) &&
3370 !POSSIBLE_RESIZE (sheet, x, y, &row, &column) &&
3371 new_cursor != sheet->cursor_drag->type)
3373 gdk_cursor_unref (sheet->cursor_drag);
3374 sheet->cursor_drag = gdk_cursor_new_for_display (display, GDK_PLUS);
3375 gdk_window_set_cursor (sheet->sheet_window, sheet->cursor_drag);
3378 new_cursor = GDK_TOP_LEFT_ARROW;
3379 if ( event->window == sheet->sheet_window &&
3380 ! (POSSIBLE_RESIZE (sheet, x, y, &row, &column) ) &&
3381 (POSSIBLE_DRAG (sheet, x, y, &row, &column) ||
3382 PSPPIRE_SHEET_IN_DRAG (sheet)) &&
3383 new_cursor != sheet->cursor_drag->type)
3385 gdk_cursor_unref (sheet->cursor_drag);
3386 sheet->cursor_drag = gdk_cursor_new_for_display (display, GDK_TOP_LEFT_ARROW);
3387 gdk_window_set_cursor (sheet->sheet_window, sheet->cursor_drag);
3390 gdk_window_get_pointer (widget->window, &x, &y, &mods);
3391 if (! (mods & GDK_BUTTON1_MASK)) return FALSE;
3393 if (PSPPIRE_SHEET_IN_XDRAG (sheet))
3395 if (event->x != sheet->x_drag)
3397 draw_xor_vline (sheet);
3398 sheet->x_drag = event->x;
3399 draw_xor_vline (sheet);
3405 if (PSPPIRE_SHEET_IN_YDRAG (sheet))
3407 if (event->y != sheet->y_drag)
3409 draw_xor_hline (sheet);
3410 sheet->y_drag = event->y;
3411 draw_xor_hline (sheet);
3417 if (PSPPIRE_SHEET_IN_DRAG (sheet))
3419 PsppireSheetRange aux;
3420 column = column_from_xpixel (sheet, x)- sheet->drag_cell.col;
3421 row = row_from_ypixel (sheet, y) - sheet->drag_cell.row;
3422 if (sheet->select_status == PSPPIRE_SHEET_COLUMN_SELECTED) row = 0;
3423 if (sheet->select_status == PSPPIRE_SHEET_ROW_SELECTED) column = 0;
3427 if (aux.row0 + row >= 0 && aux.rowi + row < psppire_axis_unit_count (sheet->vaxis) &&
3428 aux.col0 + column >= 0 && aux.coli + column < psppire_axis_unit_count (sheet->haxis))
3430 aux = sheet->drag_range;
3431 sheet->drag_range.row0 = sheet->range.row0 + row;
3432 sheet->drag_range.col0 = sheet->range.col0 + column;
3433 sheet->drag_range.rowi = sheet->range.rowi + row;
3434 sheet->drag_range.coli = sheet->range.coli + column;
3435 if (aux.row0 != sheet->drag_range.row0 ||
3436 aux.col0 != sheet->drag_range.col0)
3438 draw_xor_rectangle (sheet, aux);
3439 draw_xor_rectangle (sheet, sheet->drag_range);
3445 psppire_sheet_get_pixel_info (sheet, x, y, &row, &column);
3447 if (sheet->select_status == PSPPIRE_SHEET_NORMAL && row == sheet->active_cell.row &&
3448 column == sheet->active_cell.col) return TRUE;
3450 if ( mods & GDK_BUTTON1_MASK)
3452 if (PSPPIRE_SHEET_IN_SELECTION (sheet) )
3454 /* Redraw the old range */
3455 psppire_sheet_unselect_range (sheet);
3457 sheet->range.rowi = row;
3458 sheet->range.coli = column;
3460 /* Redraw the new range */
3461 psppire_sheet_select_range (sheet, &sheet->range);
3465 PSPPIRE_SHEET_SET_FLAGS (sheet, PSPPIRE_SHEET_IN_SELECTION);
3473 psppire_sheet_crossing_notify (GtkWidget *widget,
3474 GdkEventCrossing *event)
3476 PsppireSheet *sheet = PSPPIRE_SHEET (widget);
3478 if (event->window == sheet->column_title_window)
3479 sheet->column_title_under = event->type == GDK_ENTER_NOTIFY;
3480 else if (event->window == sheet->row_title_window)
3481 sheet->row_title_under = event->type == GDK_ENTER_NOTIFY;
3483 if (event->type == GDK_LEAVE_NOTIFY)
3484 gtk_widget_hide (sheet->hover_window->window);
3491 psppire_sheet_focus_in (GtkWidget *w,
3492 GdkEventFocus *event)
3494 PsppireSheet *sheet = PSPPIRE_SHEET (w);
3496 gtk_widget_grab_focus (sheet->entry_widget);
3504 psppire_sheet_entry_key_press (GtkWidget *widget,
3508 g_signal_emit_by_name (widget, "key_press_event", key, &focus);
3513 /* Number of rows in a step-increment */
3514 #define ROWS_PER_STEP 1
3518 page_vertical (PsppireSheet *sheet, GtkScrollType dir)
3520 gint old_row = sheet->active_cell.row ;
3521 glong vpixel = psppire_axis_start_pixel (sheet->vaxis, old_row);
3525 vpixel -= psppire_axis_start_pixel (sheet->vaxis,
3526 min_visible_row (sheet));
3530 case GTK_SCROLL_PAGE_DOWN:
3531 gtk_adjustment_set_value (sheet->vadjustment,
3532 sheet->vadjustment->value +
3533 sheet->vadjustment->page_increment);
3535 case GTK_SCROLL_PAGE_UP:
3536 gtk_adjustment_set_value (sheet->vadjustment,
3537 sheet->vadjustment->value -
3538 sheet->vadjustment->page_increment);
3542 g_assert_not_reached ();
3547 vpixel += psppire_axis_start_pixel (sheet->vaxis,
3548 min_visible_row (sheet));
3550 new_row = row_from_ypixel (sheet, vpixel);
3552 change_active_cell (sheet, new_row,
3553 sheet->active_cell.col);
3558 step_sheet (PsppireSheet *sheet, GtkScrollType dir)
3560 gint current_row = sheet->active_cell.row;
3561 gint current_col = sheet->active_cell.col;
3562 PsppireSheetCell new_cell ;
3563 gboolean forbidden = FALSE;
3565 new_cell.row = current_row;
3566 new_cell.col = current_col;
3570 case GTK_SCROLL_STEP_DOWN:
3573 case GTK_SCROLL_STEP_UP:
3576 case GTK_SCROLL_STEP_RIGHT:
3579 case GTK_SCROLL_STEP_LEFT:
3582 case GTK_SCROLL_STEP_FORWARD:
3585 psppire_sheet_model_get_column_count (sheet->model))
3591 case GTK_SCROLL_STEP_BACKWARD:
3593 if (new_cell.col < 0)
3596 psppire_sheet_model_get_column_count (sheet->model) - 1;
3601 g_assert_not_reached ();
3605 g_signal_emit (sheet, sheet_signals[TRAVERSE], 0,
3606 &sheet->active_cell,
3614 maximize_int (&new_cell.row, 0);
3615 maximize_int (&new_cell.col, 0);
3617 minimize_int (&new_cell.row,
3618 psppire_axis_unit_count (sheet->vaxis) - 1);
3620 minimize_int (&new_cell.col,
3621 psppire_axis_unit_count (sheet->haxis) - 1);
3623 change_active_cell (sheet, new_cell.row, new_cell.col);
3626 if ( new_cell.col > max_fully_visible_column (sheet))
3629 psppire_axis_start_pixel (sheet->haxis,
3631 hpos -= sheet->hadjustment->page_size;
3633 gtk_adjustment_set_value (sheet->hadjustment,
3636 else if ( new_cell.col < min_fully_visible_column (sheet))
3639 psppire_axis_start_pixel (sheet->haxis,
3642 gtk_adjustment_set_value (sheet->hadjustment,
3647 if ( new_cell.row > max_fully_visible_row (sheet))
3650 psppire_axis_start_pixel (sheet->vaxis,
3652 vpos -= sheet->vadjustment->page_size;
3654 gtk_adjustment_set_value (sheet->vadjustment,
3657 else if ( new_cell.row < min_fully_visible_row (sheet))
3660 psppire_axis_start_pixel (sheet->vaxis,
3663 gtk_adjustment_set_value (sheet->vadjustment,
3667 gtk_widget_grab_focus (GTK_WIDGET (sheet->entry_widget));
3672 psppire_sheet_key_press (GtkWidget *widget,
3675 PsppireSheet *sheet = PSPPIRE_SHEET (widget);
3677 PSPPIRE_SHEET_UNSET_FLAGS (sheet, PSPPIRE_SHEET_IN_SELECTION);
3679 switch (key->keyval)
3682 step_sheet (sheet, GTK_SCROLL_STEP_FORWARD);
3685 step_sheet (sheet, GTK_SCROLL_STEP_RIGHT);
3687 case GDK_ISO_Left_Tab:
3688 step_sheet (sheet, GTK_SCROLL_STEP_BACKWARD);
3691 step_sheet (sheet, GTK_SCROLL_STEP_LEFT);
3695 step_sheet (sheet, GTK_SCROLL_STEP_DOWN);
3698 step_sheet (sheet, GTK_SCROLL_STEP_UP);
3702 page_vertical (sheet, GTK_SCROLL_PAGE_DOWN);
3705 page_vertical (sheet, GTK_SCROLL_PAGE_UP);
3709 gtk_adjustment_set_value (sheet->vadjustment,
3710 sheet->vadjustment->lower);
3712 change_active_cell (sheet, 0,
3713 sheet->active_cell.col);
3718 gtk_adjustment_set_value (sheet->vadjustment,
3719 sheet->vadjustment->upper -
3720 sheet->vadjustment->page_size -
3721 sheet->vadjustment->page_increment);
3724 change_active_cellx (sheet,
3725 psppire_axis_unit_count (sheet->vaxis) - 1,
3726 sheet->active_cell.col);
3730 psppire_sheet_real_cell_clear (sheet, sheet->active_cell.row, sheet->active_cell.col);
3741 psppire_sheet_size_request (GtkWidget *widget,
3742 GtkRequisition *requisition)
3744 PsppireSheet *sheet;
3746 g_return_if_fail (widget != NULL);
3747 g_return_if_fail (PSPPIRE_IS_SHEET (widget));
3748 g_return_if_fail (requisition != NULL);
3750 sheet = PSPPIRE_SHEET (widget);
3752 requisition->width = 3 * DEFAULT_COLUMN_WIDTH;
3753 requisition->height = 3 * DEFAULT_ROW_HEIGHT;
3755 /* compute the size of the column title area */
3756 if (sheet->column_titles_visible)
3757 requisition->height += sheet->column_title_area.height;
3759 /* compute the size of the row title area */
3760 if (sheet->row_titles_visible)
3761 requisition->width += sheet->row_title_area.width;
3766 psppire_sheet_size_allocate (GtkWidget *widget,
3767 GtkAllocation *allocation)
3769 PsppireSheet *sheet;
3770 GtkAllocation sheet_allocation;
3773 g_return_if_fail (widget != NULL);
3774 g_return_if_fail (PSPPIRE_IS_SHEET (widget));
3775 g_return_if_fail (allocation != NULL);
3777 sheet = PSPPIRE_SHEET (widget);
3778 widget->allocation = *allocation;
3779 border_width = GTK_CONTAINER (widget)->border_width;
3781 if (GTK_WIDGET_REALIZED (widget))
3782 gdk_window_move_resize (widget->window,
3783 allocation->x + border_width,
3784 allocation->y + border_width,
3785 allocation->width - 2 * border_width,
3786 allocation->height - 2 * border_width);
3788 sheet_allocation.x = 0;
3789 sheet_allocation.y = 0;
3790 sheet_allocation.width = allocation->width - 2 * border_width;
3791 sheet_allocation.height = allocation->height - 2 * border_width;
3793 if (GTK_WIDGET_REALIZED (widget))
3794 gdk_window_move_resize (sheet->sheet_window,
3797 sheet_allocation.width,
3798 sheet_allocation.height);
3800 /* position the window which holds the column title buttons */
3801 sheet->column_title_area.x = 0;
3802 sheet->column_title_area.y = 0;
3803 sheet->column_title_area.width = sheet_allocation.width ;
3806 /* position the window which holds the row title buttons */
3807 sheet->row_title_area.x = 0;
3808 sheet->row_title_area.y = 0;
3809 sheet->row_title_area.height = sheet_allocation.height;
3811 if (sheet->row_titles_visible)
3812 sheet->column_title_area.x += sheet->row_title_area.width;
3814 if (sheet->column_titles_visible)
3815 sheet->row_title_area.y += sheet->column_title_area.height;
3817 if (GTK_WIDGET_REALIZED (widget) && sheet->column_titles_visible)
3818 gdk_window_move_resize (sheet->column_title_window,
3819 sheet->column_title_area.x,
3820 sheet->column_title_area.y,
3821 sheet->column_title_area.width,
3822 sheet->column_title_area.height);
3825 if (GTK_WIDGET_REALIZED (widget) && sheet->row_titles_visible)
3826 gdk_window_move_resize (sheet->row_title_window,
3827 sheet->row_title_area.x,
3828 sheet->row_title_area.y,
3829 sheet->row_title_area.width,
3830 sheet->row_title_area.height);
3832 size_allocate_global_button (sheet);
3836 gint width = sheet->column_title_area.width;
3838 if ( sheet->row_titles_visible)
3839 width -= sheet->row_title_area.width;
3841 g_object_set (sheet->haxis,
3842 "minimum-extent", width,
3849 gint height = sheet->row_title_area.height;
3851 if ( sheet->column_titles_visible)
3852 height -= sheet->column_title_area.height;
3854 g_object_set (sheet->vaxis,
3855 "minimum-extent", height,
3860 /* set the scrollbars adjustments */
3861 adjust_scrollbars (sheet);
3865 draw_column_title_buttons (PsppireSheet *sheet)
3869 if (!sheet->column_titles_visible) return;
3870 if (!GTK_WIDGET_REALIZED (sheet))
3873 gdk_drawable_get_size (sheet->sheet_window, &width, NULL);
3876 if (sheet->row_titles_visible)
3878 x = sheet->row_title_area.width;
3881 if (sheet->column_title_area.width != width || sheet->column_title_area.x != x)
3883 sheet->column_title_area.width = width;
3884 sheet->column_title_area.x = x;
3885 gdk_window_move_resize (sheet->column_title_window,
3886 sheet->column_title_area.x,
3887 sheet->column_title_area.y,
3888 sheet->column_title_area.width,
3889 sheet->column_title_area.height);
3892 if (max_visible_column (sheet) ==
3893 psppire_axis_unit_count (sheet->haxis) - 1)
3894 gdk_window_clear_area (sheet->column_title_window,
3896 sheet->column_title_area.width,
3897 sheet->column_title_area.height);
3899 if (!GTK_WIDGET_DRAWABLE (sheet)) return;
3901 draw_column_title_buttons_range (sheet, min_visible_column (sheet),
3902 max_visible_column (sheet));
3906 draw_row_title_buttons (PsppireSheet *sheet)
3911 if (!sheet->row_titles_visible) return;
3912 if (!GTK_WIDGET_REALIZED (sheet))
3915 gdk_drawable_get_size (sheet->sheet_window, NULL, &height);
3917 if (sheet->column_titles_visible)
3919 y = sheet->column_title_area.height;
3922 if (sheet->row_title_area.height != height || sheet->row_title_area.y != y)
3924 sheet->row_title_area.y = y;
3925 sheet->row_title_area.height = height;
3926 gdk_window_move_resize (sheet->row_title_window,
3927 sheet->row_title_area.x,
3928 sheet->row_title_area.y,
3929 sheet->row_title_area.width,
3930 sheet->row_title_area.height);
3933 if (max_visible_row (sheet) == psppire_axis_unit_count (sheet->vaxis) - 1)
3934 gdk_window_clear_area (sheet->row_title_window,
3936 sheet->row_title_area.width,
3937 sheet->row_title_area.height);
3939 if (!GTK_WIDGET_DRAWABLE (sheet)) return;
3941 draw_row_title_buttons_range (sheet, min_visible_row (sheet),
3942 max_visible_row (sheet));
3947 psppire_sheet_size_allocate_entry (PsppireSheet *sheet)
3949 GtkAllocation entry_alloc;
3950 PsppireSheetCellAttr attributes = { 0 };
3951 GtkEntry *sheet_entry;
3953 if (!GTK_WIDGET_REALIZED (GTK_WIDGET (sheet))) return;
3954 if (!GTK_WIDGET_MAPPED (GTK_WIDGET (sheet))) return;
3956 sheet_entry = psppire_sheet_get_entry (sheet);
3958 if ( ! psppire_sheet_get_attributes (sheet, sheet->active_cell.row,
3959 sheet->active_cell.col,
3963 if ( GTK_WIDGET_REALIZED (sheet->entry_widget) )
3965 GtkStyle *style = GTK_WIDGET (sheet_entry)->style;
3967 style->bg[GTK_STATE_NORMAL] = attributes.background;
3968 style->fg[GTK_STATE_NORMAL] = attributes.foreground;
3969 style->text[GTK_STATE_NORMAL] = attributes.foreground;
3970 style->bg[GTK_STATE_ACTIVE] = attributes.background;
3971 style->fg[GTK_STATE_ACTIVE] = attributes.foreground;
3972 style->text[GTK_STATE_ACTIVE] = attributes.foreground;
3975 rectangle_from_cell (sheet, sheet->active_cell.row,
3976 sheet->active_cell.col, &entry_alloc);
3978 entry_alloc.x += sheet->cell_padding->left;
3979 entry_alloc.y += sheet->cell_padding->right;
3980 entry_alloc.width -= sheet->cell_padding->left + sheet->cell_padding->right;
3981 entry_alloc.height -= sheet->cell_padding->top + sheet->cell_padding->bottom;
3984 gtk_widget_set_size_request (sheet->entry_widget, entry_alloc.width,
3985 entry_alloc.height);
3986 gtk_widget_size_allocate (sheet->entry_widget, &entry_alloc);
3990 /* Copy the sheet's font to the entry widget */
3992 set_entry_widget_font (PsppireSheet *sheet)
3994 GtkRcStyle *style = gtk_widget_get_modifier_style (sheet->entry_widget);
3996 pango_font_description_free (style->font_desc);
3997 style->font_desc = pango_font_description_copy (GTK_WIDGET (sheet)->style->font_desc);
3999 gtk_widget_modify_style (sheet->entry_widget, style);
4003 create_sheet_entry (PsppireSheet *sheet)
4005 if (sheet->entry_widget)
4007 gtk_widget_unparent (sheet->entry_widget);
4010 sheet->entry_widget = g_object_new (sheet->entry_type, NULL);
4011 g_object_ref_sink (sheet->entry_widget);
4013 gtk_widget_size_request (sheet->entry_widget, NULL);
4015 if ( GTK_IS_ENTRY (sheet->entry_widget))
4017 g_object_set (sheet->entry_widget,
4022 if (GTK_WIDGET_REALIZED (sheet))
4024 gtk_widget_set_parent_window (sheet->entry_widget, sheet->sheet_window);
4025 gtk_widget_set_parent (sheet->entry_widget, GTK_WIDGET (sheet));
4026 gtk_widget_realize (sheet->entry_widget);
4029 g_signal_connect_swapped (sheet->entry_widget, "key_press_event",
4030 G_CALLBACK (psppire_sheet_entry_key_press),
4033 set_entry_widget_font (sheet);
4035 gtk_widget_show (sheet->entry_widget);
4039 /* Finds the last child widget that happens to be of type GtkEntry */
4041 find_entry (GtkWidget *w, gpointer user_data)
4043 GtkWidget **entry = user_data;
4044 if ( GTK_IS_ENTRY (w))
4052 psppire_sheet_get_entry (PsppireSheet *sheet)
4054 GtkWidget *w = sheet->entry_widget;
4056 g_return_val_if_fail (sheet != NULL, NULL);
4057 g_return_val_if_fail (PSPPIRE_IS_SHEET (sheet), NULL);
4058 g_return_val_if_fail (sheet->entry_widget != NULL, NULL);
4060 while (! GTK_IS_ENTRY (w))
4062 GtkWidget *entry = NULL;
4064 if (GTK_IS_CONTAINER (w))
4066 gtk_container_forall (GTK_CONTAINER (w), find_entry, &entry);
4075 return GTK_ENTRY (w);
4080 draw_button (PsppireSheet *sheet, GdkWindow *window,
4081 PsppireSheetButton *button, gboolean is_sensitive,
4082 GdkRectangle allocation)
4084 GtkShadowType shadow_type;
4085 gint text_width = 0, text_height = 0;
4086 PangoAlignment align = PANGO_ALIGN_LEFT;
4092 g_return_if_fail (sheet != NULL);
4093 g_return_if_fail (button != NULL);
4096 rtl = gtk_widget_get_direction (GTK_WIDGET (sheet)) == GTK_TEXT_DIR_RTL;
4098 gdk_window_clear_area (window,
4099 allocation.x, allocation.y,
4100 allocation.width, allocation.height);
4102 gtk_widget_ensure_style (sheet->button);
4104 gtk_paint_box (sheet->button->style, window,
4105 GTK_STATE_NORMAL, GTK_SHADOW_OUT,
4107 GTK_WIDGET (sheet->button),
4109 allocation.x, allocation.y,
4110 allocation.width, allocation.height);
4112 state = button->state;
4113 if (!is_sensitive) state = GTK_STATE_INSENSITIVE;
4115 if (state == GTK_STATE_ACTIVE)
4116 shadow_type = GTK_SHADOW_IN;
4118 shadow_type = GTK_SHADOW_OUT;
4120 if (state != GTK_STATE_NORMAL && state != GTK_STATE_INSENSITIVE)
4121 gtk_paint_box (sheet->button->style, window,
4122 button->state, shadow_type,
4123 &allocation, GTK_WIDGET (sheet->button),
4125 allocation.x, allocation.y,
4126 allocation.width, allocation.height);
4128 if ( button->overstruck)
4130 GdkPoint points[2] = {
4131 {allocation.x, allocation.y},
4132 {allocation.x + allocation.width,
4133 allocation.y + allocation.height}
4136 gtk_paint_polygon (sheet->button->style,
4148 if (button->label_visible)
4150 text_height = DEFAULT_ROW_HEIGHT -
4151 2 * COLUMN_TITLES_HEIGHT;
4153 gdk_gc_set_clip_rectangle (GTK_WIDGET (sheet)->style->fg_gc[button->state],
4155 gdk_gc_set_clip_rectangle (GTK_WIDGET (sheet)->style->white_gc,
4158 allocation.y += 2 * sheet->button->style->ythickness;
4160 if (button->label && strlen (button->label) > 0)
4162 PangoRectangle rect;
4163 gchar *line = button->label;
4165 PangoLayout *layout = NULL;
4166 gint real_x = allocation.x;
4167 gint real_y = allocation.y;
4169 layout = gtk_widget_create_pango_layout (GTK_WIDGET (sheet), line);
4170 pango_layout_get_extents (layout, NULL, &rect);
4172 text_width = PANGO_PIXELS (rect.width);
4173 switch (button->justification)
4175 case GTK_JUSTIFY_LEFT:
4176 real_x = allocation.x + COLUMN_TITLES_HEIGHT;
4177 align = rtl ? PANGO_ALIGN_RIGHT : PANGO_ALIGN_LEFT;
4179 case GTK_JUSTIFY_RIGHT:
4180 real_x = allocation.x + allocation.width - text_width - COLUMN_TITLES_HEIGHT;
4181 align = rtl ? PANGO_ALIGN_LEFT : PANGO_ALIGN_RIGHT;
4183 case GTK_JUSTIFY_CENTER:
4185 real_x = allocation.x + (allocation.width - text_width)/2;
4186 align = rtl ? PANGO_ALIGN_RIGHT : PANGO_ALIGN_LEFT;
4187 pango_layout_set_justify (layout, TRUE);
4189 pango_layout_set_alignment (layout, align);
4190 gtk_paint_layout (GTK_WIDGET (sheet)->style,
4199 g_object_unref (layout);
4202 gdk_gc_set_clip_rectangle (GTK_WIDGET (sheet)->style->fg_gc[button->state],
4204 gdk_gc_set_clip_rectangle (GTK_WIDGET (sheet)->style->white_gc, NULL);
4208 psppire_sheet_button_free (button);
4212 /* Draw the column title buttons FIRST through to LAST */
4214 draw_column_title_buttons_range (PsppireSheet *sheet, gint first, gint last)
4218 if (!GTK_WIDGET_REALIZED (GTK_WIDGET (sheet))) return;
4220 if (!sheet->column_titles_visible) return;
4222 g_return_if_fail (first >= min_visible_column (sheet));
4223 g_return_if_fail (last <= max_visible_column (sheet));
4226 rect.height = sheet->column_title_area.height;
4227 rect.x = psppire_axis_start_pixel (sheet->haxis, first) + CELL_SPACING;
4228 rect.width = psppire_axis_start_pixel (sheet->haxis, last) + CELL_SPACING
4229 + psppire_axis_unit_size (sheet->haxis, last);
4231 rect.x -= sheet->hadjustment->value;
4233 minimize_int (&rect.width, sheet->column_title_area.width);
4234 maximize_int (&rect.x, 0);
4236 gdk_window_begin_paint_rect (sheet->column_title_window, &rect);
4238 for (col = first ; col <= last ; ++col)
4240 GdkRectangle allocation;
4241 gboolean is_sensitive = FALSE;
4243 PsppireSheetButton *
4244 button = psppire_sheet_model_get_column_button (sheet->model, col);
4246 allocation.x = psppire_axis_start_pixel (sheet->haxis, col)
4248 allocation.x -= sheet->hadjustment->value;
4250 allocation.height = sheet->column_title_area.height;
4251 allocation.width = psppire_axis_unit_size (sheet->haxis, col);
4252 is_sensitive = psppire_sheet_model_get_column_sensitivity (sheet->model, col);
4254 draw_button (sheet, sheet->column_title_window,
4255 button, is_sensitive, allocation);
4258 gdk_window_end_paint (sheet->column_title_window);
4263 draw_row_title_buttons_range (PsppireSheet *sheet, gint first, gint last)
4267 if (!GTK_WIDGET_REALIZED (GTK_WIDGET (sheet))) return;
4269 if (!sheet->row_titles_visible) return;
4271 g_return_if_fail (first >= min_visible_row (sheet));
4272 g_return_if_fail (last <= max_visible_row (sheet));
4275 rect.width = sheet->row_title_area.width;
4276 rect.y = psppire_axis_start_pixel (sheet->vaxis, first) + CELL_SPACING;
4277 rect.height = psppire_axis_start_pixel (sheet->vaxis, last) + CELL_SPACING
4278 + psppire_axis_unit_size (sheet->vaxis, last);
4280 rect.y -= sheet->vadjustment->value;
4282 minimize_int (&rect.height, sheet->row_title_area.height);
4283 maximize_int (&rect.y, 0);
4285 gdk_window_begin_paint_rect (sheet->row_title_window, &rect);
4286 for (row = first; row <= last; ++row)
4288 GdkRectangle allocation;
4290 gboolean is_sensitive = FALSE;
4292 PsppireSheetButton *button =
4293 psppire_sheet_model_get_row_button (sheet->model, row);
4295 allocation.y = psppire_axis_start_pixel (sheet->vaxis, row)
4297 allocation.y -= sheet->vadjustment->value;
4299 allocation.width = sheet->row_title_area.width;
4300 allocation.height = psppire_axis_unit_size (sheet->vaxis, row);
4301 is_sensitive = psppire_sheet_model_get_row_sensitivity (sheet->model, row);
4303 draw_button (sheet, sheet->row_title_window,
4304 button, is_sensitive, allocation);
4307 gdk_window_end_paint (sheet->row_title_window);
4314 * vadjustment_value_changed
4315 * hadjustment_value_changed */
4319 update_adjustment (GtkAdjustment *adj, PsppireAxis *axis, gint page_size)
4322 (adj->value + adj->page_size)
4324 (adj->upper - adj->lower);
4326 const glong last_item = psppire_axis_unit_count (axis) - 1;
4328 if (isnan (position) || position < 0)
4332 psppire_axis_start_pixel (axis, last_item)
4334 psppire_axis_unit_size (axis, last_item)
4338 adj->page_size = page_size;
4341 adj->value = position * (adj->upper - adj->lower) - adj->page_size;
4343 if ( adj->value < adj->lower)
4344 adj->value = adj->lower;
4347 gtk_adjustment_changed (adj);
4352 adjust_scrollbars (PsppireSheet *sheet)
4356 if (!GTK_WIDGET_REALIZED (GTK_WIDGET (sheet)))
4359 gdk_drawable_get_size (sheet->sheet_window, &width, &height);
4361 if ( sheet->row_titles_visible)
4362 width -= sheet->row_title_area.width;
4364 if (sheet->column_titles_visible)
4365 height -= sheet->column_title_area.height;
4367 if (sheet->vadjustment)
4369 glong last_row = psppire_axis_unit_count (sheet->vaxis) - 1;
4371 sheet->vadjustment->step_increment =
4373 psppire_axis_unit_size (sheet->vaxis, last_row);
4375 sheet->vadjustment->page_increment =
4377 sheet->column_title_area.height -
4378 psppire_axis_unit_size (sheet->vaxis, last_row);
4380 update_adjustment (sheet->vadjustment, sheet->vaxis, height);
4383 if (sheet->hadjustment)
4385 gint last_col = psppire_axis_unit_count (sheet->haxis) - 1;
4386 sheet->hadjustment->step_increment = 1;
4388 sheet->hadjustment->page_increment = width;
4390 sheet->hadjustment->upper =
4391 psppire_axis_start_pixel (sheet->haxis, last_col)
4393 psppire_axis_unit_size (sheet->haxis, last_col)
4396 update_adjustment (sheet->hadjustment, sheet->haxis, width);
4400 /* Subtracts the region of WIDGET from REGION */
4402 subtract_widget_region (GdkRegion *region, GtkWidget *widget)
4405 GdkRectangle intersect;
4408 gdk_region_get_clipbox (region, &rect);
4409 gtk_widget_intersect (widget,
4413 region2 = gdk_region_rectangle (&intersect);
4414 gdk_region_subtract (region, region2);
4415 gdk_region_destroy (region2);
4419 vadjustment_value_changed (GtkAdjustment *adjustment,
4423 PsppireSheet *sheet = PSPPIRE_SHEET (data);
4425 g_return_if_fail (adjustment != NULL);
4427 if ( ! GTK_WIDGET_REALIZED (sheet)) return;
4429 gtk_widget_hide (sheet->entry_widget);
4432 gdk_drawable_get_visible_region (GDK_DRAWABLE (sheet->sheet_window));
4434 subtract_widget_region (region, sheet->button);
4435 gdk_window_begin_paint_region (sheet->sheet_window, region);
4437 draw_sheet_region (sheet, region);
4439 draw_row_title_buttons (sheet);
4440 psppire_sheet_draw_active_cell (sheet);
4442 gdk_window_end_paint (sheet->sheet_window);
4443 gdk_region_destroy (region);
4448 hadjustment_value_changed (GtkAdjustment *adjustment,
4452 PsppireSheet *sheet = PSPPIRE_SHEET (data);
4454 g_return_if_fail (adjustment != NULL);
4456 if ( ! GTK_WIDGET_REALIZED (sheet)) return;
4458 gtk_widget_hide (sheet->entry_widget);
4462 gdk_drawable_get_visible_region (GDK_DRAWABLE (sheet->sheet_window));
4464 subtract_widget_region (region, sheet->button);
4465 gdk_window_begin_paint_region (sheet->sheet_window, region);
4467 draw_sheet_region (sheet, region);
4469 draw_column_title_buttons (sheet);
4471 psppire_sheet_draw_active_cell (sheet);
4473 gdk_window_end_paint (sheet->sheet_window);
4475 gdk_region_destroy (region);
4479 /* COLUMN RESIZING */
4481 draw_xor_vline (PsppireSheet *sheet)
4484 gint xpos = sheet->x_drag;
4485 gdk_drawable_get_size (sheet->sheet_window,
4488 if (sheet->row_titles_visible)
4489 xpos += sheet->row_title_area.width;
4491 gdk_draw_line (GTK_WIDGET (sheet)->window, sheet->xor_gc,
4493 sheet->column_title_area.height,
4495 height + CELL_SPACING);
4500 draw_xor_hline (PsppireSheet *sheet)
4504 gint ypos = sheet->y_drag;
4506 gdk_drawable_get_size (sheet->sheet_window,
4510 if (sheet->column_titles_visible)
4511 ypos += sheet->column_title_area.height;
4513 gdk_draw_line (GTK_WIDGET (sheet)->window, sheet->xor_gc,
4514 sheet->row_title_area.width,
4516 width + CELL_SPACING,
4520 /* SELECTED RANGE */
4522 draw_xor_rectangle (PsppireSheet *sheet, PsppireSheetRange range)
4525 GdkRectangle clip_area, area;
4528 area.x = psppire_axis_start_pixel (sheet->haxis, range.col0);
4529 area.y = psppire_axis_start_pixel (sheet->vaxis, range.row0);
4530 area.width = psppire_axis_start_pixel (sheet->haxis, range.coli)- area.x+
4531 psppire_axis_unit_size (sheet->haxis, range.coli);
4532 area.height = psppire_axis_start_pixel (sheet->vaxis, range.rowi)- area.y +
4533 psppire_axis_unit_size (sheet->vaxis, range.rowi);
4535 clip_area.x = sheet->row_title_area.width;
4536 clip_area.y = sheet->column_title_area.height;
4538 gdk_drawable_get_size (sheet->sheet_window,
4539 &clip_area.width, &clip_area.height);
4541 if (!sheet->row_titles_visible) clip_area.x = 0;
4542 if (!sheet->column_titles_visible) clip_area.y = 0;
4546 area.width = area.width + area.x;
4549 if (area.width > clip_area.width) area.width = clip_area.width + 10;
4552 area.height = area.height + area.y;
4555 if (area.height > clip_area.height) area.height = clip_area.height + 10;
4559 clip_area.width += 3;
4560 clip_area.height += 3;
4562 gdk_gc_get_values (sheet->xor_gc, &values);
4564 gdk_gc_set_clip_rectangle (sheet->xor_gc, &clip_area);
4566 gdk_draw_rectangle (sheet->sheet_window,
4569 area.x + i, area.y + i,
4570 area.width - 2 * i, area.height - 2 * i);
4573 gdk_gc_set_clip_rectangle (sheet->xor_gc, NULL);
4575 gdk_gc_set_foreground (sheet->xor_gc, &values.foreground);
4580 set_column_width (PsppireSheet *sheet,
4584 g_return_if_fail (sheet != NULL);
4585 g_return_if_fail (PSPPIRE_IS_SHEET (sheet));
4587 if (column < 0 || column >= psppire_axis_unit_count (sheet->haxis))
4593 psppire_axis_resize (sheet->haxis, column,
4594 width - sheet->cell_padding->left -
4595 sheet->cell_padding->right);
4597 if (GTK_WIDGET_REALIZED (GTK_WIDGET (sheet)))
4599 draw_column_title_buttons (sheet);
4600 adjust_scrollbars (sheet);
4601 psppire_sheet_size_allocate_entry (sheet);
4602 redraw_range (sheet, NULL);
4607 set_row_height (PsppireSheet *sheet,
4611 g_return_if_fail (sheet != NULL);
4612 g_return_if_fail (PSPPIRE_IS_SHEET (sheet));
4614 if (row < 0 || row >= psppire_axis_unit_count (sheet->vaxis))
4620 psppire_axis_resize (sheet->vaxis, row,
4621 height - sheet->cell_padding->top -
4622 sheet->cell_padding->bottom);
4624 if (GTK_WIDGET_REALIZED (GTK_WIDGET (sheet)) )
4626 draw_row_title_buttons (sheet);
4627 adjust_scrollbars (sheet);
4628 psppire_sheet_size_allocate_entry (sheet);
4629 redraw_range (sheet, NULL);
4634 psppire_sheet_get_attributes (const PsppireSheet *sheet, gint row, gint col,
4635 PsppireSheetCellAttr *attr)
4638 const GtkJustification *j ;
4639 GdkColormap *colormap;
4641 g_return_val_if_fail (sheet != NULL, FALSE);
4642 g_return_val_if_fail (PSPPIRE_IS_SHEET (sheet), FALSE);
4644 if (row < 0 || col < 0) return FALSE;
4646 attr->foreground = GTK_WIDGET (sheet)->style->black;
4647 attr->background = sheet->color[BG_COLOR];
4649 attr->border.width = 0;
4650 attr->border.line_style = GDK_LINE_SOLID;
4651 attr->border.cap_style = GDK_CAP_NOT_LAST;
4652 attr->border.join_style = GDK_JOIN_MITER;
4653 attr->border.mask = 0;
4654 attr->border.color = GTK_WIDGET (sheet)->style->black;
4656 colormap = gtk_widget_get_colormap (GTK_WIDGET (sheet));
4657 fg = psppire_sheet_model_get_foreground (sheet->model, row, col);
4660 gdk_colormap_alloc_color (colormap, fg, TRUE, TRUE);
4661 attr->foreground = *fg;
4664 bg = psppire_sheet_model_get_background (sheet->model, row, col);
4667 gdk_colormap_alloc_color (colormap, bg, TRUE, TRUE);
4668 attr->background = *bg;
4671 attr->justification =
4672 psppire_sheet_model_get_column_justification (sheet->model, col);
4674 j = psppire_sheet_model_get_justification (sheet->model, row, col);
4676 attr->justification = *j;
4682 psppire_sheet_button_size_request (PsppireSheet *sheet,
4683 const PsppireSheetButton *button,
4684 GtkRequisition *button_requisition)
4686 GtkRequisition requisition;
4687 GtkRequisition label_requisition;
4689 label_requisition.height = DEFAULT_ROW_HEIGHT;
4690 label_requisition.width = COLUMN_MIN_WIDTH;
4692 requisition.height = DEFAULT_ROW_HEIGHT;
4693 requisition.width = COLUMN_MIN_WIDTH;
4696 *button_requisition = requisition;
4697 button_requisition->width = MAX (requisition.width, label_requisition.width);
4698 button_requisition->height = MAX (requisition.height, label_requisition.height);
4703 psppire_sheet_forall (GtkContainer *container,
4704 gboolean include_internals,
4705 GtkCallback callback,
4706 gpointer callback_data)
4708 PsppireSheet *sheet = PSPPIRE_SHEET (container);
4710 g_return_if_fail (callback != NULL);
4712 if (sheet->button && sheet->button->parent)
4713 (* callback) (sheet->button, callback_data);
4715 if (sheet->entry_widget && GTK_IS_CONTAINER (sheet->entry_widget))
4716 (* callback) (sheet->entry_widget, callback_data);
4721 psppire_sheet_get_model (const PsppireSheet *sheet)
4723 g_return_val_if_fail (PSPPIRE_IS_SHEET (sheet), NULL);
4725 return sheet->model;
4729 PsppireSheetButton *
4730 psppire_sheet_button_new (void)
4732 PsppireSheetButton *button = g_malloc (sizeof (PsppireSheetButton));
4734 button->state = GTK_STATE_NORMAL;
4735 button->label = NULL;
4736 button->label_visible = TRUE;
4737 button->justification = GTK_JUSTIFY_FILL;
4738 button->overstruck = FALSE;
4745 psppire_sheet_button_free (PsppireSheetButton *button)
4747 if (!button) return ;
4749 g_free (button->label);
4754 append_cell_text (GString *string, const PsppireSheet *sheet, gint r, gint c)
4756 gchar *celltext = psppire_sheet_cell_get_text (sheet, r, c);
4758 if ( NULL == celltext)
4761 g_string_append (string, celltext);
4767 range_to_text (const PsppireSheet *sheet)
4772 if ( !psppire_sheet_range_isvisible (sheet, &sheet->range))
4775 string = g_string_sized_new (80);
4777 for (r = sheet->range.row0; r <= sheet->range.rowi; ++r)
4779 for (c = sheet->range.col0; c < sheet->range.coli; ++c)
4781 append_cell_text (string, sheet, r, c);
4782 g_string_append (string, "\t");
4784 append_cell_text (string, sheet, r, c);
4785 if ( r < sheet->range.rowi)
4786 g_string_append (string, "\n");
4793 range_to_html (const PsppireSheet *sheet)
4798 if ( !psppire_sheet_range_isvisible (sheet, &sheet->range))
4801 string = g_string_sized_new (480);
4803 g_string_append (string, "<html>\n");
4804 g_string_append (string, "<body>\n");
4805 g_string_append (string, "<table>\n");
4806 for (r = sheet->range.row0; r <= sheet->range.rowi; ++r)
4808 g_string_append (string, "<tr>\n");
4809 for (c = sheet->range.col0; c <= sheet->range.coli; ++c)
4811 g_string_append (string, "<td>");
4812 append_cell_text (string, sheet, r, c);
4813 g_string_append (string, "</td>\n");
4815 g_string_append (string, "</tr>\n");
4817 g_string_append (string, "</table>\n");
4818 g_string_append (string, "</body>\n");
4819 g_string_append (string, "</html>\n");
4831 primary_get_cb (GtkClipboard *clipboard,
4832 GtkSelectionData *selection_data,
4836 PsppireSheet *sheet = PSPPIRE_SHEET (data);
4837 GString *string = NULL;
4841 case SELECT_FMT_TEXT:
4842 string = range_to_text (sheet);
4844 case SELECT_FMT_HTML:
4845 string = range_to_html (sheet);
4848 g_assert_not_reached ();
4851 gtk_selection_data_set (selection_data, selection_data->target,
4853 (const guchar *) string->str, string->len);
4854 g_string_free (string, TRUE);
4858 primary_clear_cb (GtkClipboard *clipboard,
4861 PsppireSheet *sheet = PSPPIRE_SHEET (data);
4862 if ( ! GTK_WIDGET_REALIZED (GTK_WIDGET (sheet)))
4865 psppire_sheet_unselect_range (sheet);
4869 psppire_sheet_update_primary_selection (PsppireSheet *sheet)
4871 static const GtkTargetEntry targets[] = {
4872 { "UTF8_STRING", 0, SELECT_FMT_TEXT },
4873 { "STRING", 0, SELECT_FMT_TEXT },
4874 { "TEXT", 0, SELECT_FMT_TEXT },
4875 { "COMPOUND_TEXT", 0, SELECT_FMT_TEXT },
4876 { "text/plain;charset=utf-8", 0, SELECT_FMT_TEXT },
4877 { "text/plain", 0, SELECT_FMT_TEXT },
4878 { "text/html", 0, SELECT_FMT_HTML }
4881 GtkClipboard *clipboard;
4883 if (!GTK_WIDGET_REALIZED (sheet))
4886 clipboard = gtk_widget_get_clipboard (GTK_WIDGET (sheet),
4887 GDK_SELECTION_PRIMARY);
4889 if (psppire_sheet_range_isvisible (sheet, &sheet->range))
4891 if (!gtk_clipboard_set_with_owner (clipboard, targets,
4892 G_N_ELEMENTS (targets),
4893 primary_get_cb, primary_clear_cb,
4895 primary_clear_cb (clipboard, sheet);
4899 if (gtk_clipboard_get_owner (clipboard) == G_OBJECT (sheet))
4900 gtk_clipboard_clear (clipboard);