lib/gtksheet/gtksheet.c

   1 /*
   2  * Copyright (C) 2006, 2008 Free Software Foundation
   3  *
   4  * This version of GtkSheet has been *heavily* modified, for the specific
   5  * requirements of PSPPIRE.  The changes are copyright by the
   6  * Free Software Foundation.  The copyright notice for the original work is
   7  * below.
   8  */
   9
  10 /* GtkSheet widget for Gtk+.
  11  * Copyright (C) 1999-2001 Adrian E. Feiguin <adrian@ifir.ifir.edu.ar>
  12  *
  13  * Based on GtkClist widget by Jay Painter, but major changes.
  14  * Memory allocation routines inspired on SC (Spreadsheet Calculator)
  15  *
  16  * This library is free software; you can redistribute it and/or
  17  * modify it under the terms of the GNU Lesser General Public
  18  * License as published by the Free Software Foundation; either
  19  * version 2.1 of the License, or (at your option) any later version.
  20  *
  21  * This library is distributed in the hope that it will be useful,
  22  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  23  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  24  * Lesser General Public License for more details.
  25  *
  26  * You should have received a copy of the GNU Lesser General Public
  27  * License along with this library; if not, write to the Free Software
  28  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  29  */
  30
  31 /**
  32  * SECTION:gtksheet
  33  * @short_description: spreadsheet widget for gtk2
  34  *
  35  * GtkSheet is a matrix widget for GTK+. It consists of an scrollable grid of
  36  * cells where you can allocate text. Cell contents can be edited interactively
  37  * through a specially designed entry, GtkItemEntry.
  38  *
  39  */
  40 #include <config.h>
  41
  42 #include <string.h>
  43 #include <stdio.h>
  44 #include <stdlib.h>
  45 #include <glib.h>
  46 #include <gdk/gdk.h>
  47 #include <gdk/gdkkeysyms.h>
  48 #include <gtk/gtksignal.h>
  49 #include <gtk/gtkbutton.h>
  50 #include <gtk/gtkadjustment.h>
  51 #include <gtk/gtktypeutils.h>
  52 #include <gtk/gtkentry.h>
  53 #include <gtk/gtkcontainer.h>
  54 #include <pango/pango.h>
  55 #include "gtksheet.h"
  56 #include "gtkextra-marshal.h"
  57 #include "gsheetmodel.h"
  58 #include <libpspp/misc.h>
  59 #include <math.h>
  60
  61 /* sheet flags */
  62 enum
  63   {
  64     GTK_SHEET_IN_XDRAG = 1 << 1,
  65     GTK_SHEET_IN_YDRAG = 1 << 2,
  66     GTK_SHEET_IN_DRAG = 1 << 3,
  67     GTK_SHEET_IN_SELECTION = 1 << 4,
  68     GTK_SHEET_IN_RESIZE = 1 << 5
  69   };
  70
  71 #define GTK_SHEET_FLAGS(sheet) (GTK_SHEET (sheet)->flags)
  72 #define GTK_SHEET_SET_FLAGS(sheet,flag) (GTK_SHEET_FLAGS (sheet) |= (flag))
  73 #define GTK_SHEET_UNSET_FLAGS(sheet,flag) (GTK_SHEET_FLAGS (sheet) &= ~ (flag))
  74
  75 #define GTK_SHEET_IN_XDRAG(sheet) (GTK_SHEET_FLAGS (sheet) & GTK_SHEET_IN_XDRAG)
  76 #define GTK_SHEET_IN_YDRAG(sheet) (GTK_SHEET_FLAGS (sheet) & GTK_SHEET_IN_YDRAG)
  77 #define GTK_SHEET_IN_DRAG(sheet) (GTK_SHEET_FLAGS (sheet) & GTK_SHEET_IN_DRAG)
  78 #define GTK_SHEET_IN_SELECTION(sheet) (GTK_SHEET_FLAGS (sheet) & GTK_SHEET_IN_SELECTION)
  79 #define GTK_SHEET_IN_RESIZE(sheet) (GTK_SHEET_FLAGS (sheet) & GTK_SHEET_IN_RESIZE)
  80
  81 #define CELL_SPACING 1
  82
  83 #define TIMEOUT_HOVER 300
  84 #define COLUMN_MIN_WIDTH 10
  85 #define COLUMN_TITLES_HEIGHT 4
  86 #define DEFAULT_COLUMN_WIDTH 80
  87 #define DEFAULT_ROW_HEIGHT 25
  88
  89 static void gtk_sheet_update_primary_selection (GtkSheet *sheet);
  90 static void gtk_sheet_column_title_button_draw (GtkSheet *sheet, gint column);
  91
  92 static void gtk_sheet_row_title_button_draw (GtkSheet *sheet, gint row);
  93
  94 static void gtk_sheet_set_row_height (GtkSheet *sheet,
  95                                       gint row,
  96                                       guint height);
  97
  98 static void destroy_hover_window (GtkSheetHoverTitle *);
  99 static GtkSheetHoverTitle *create_hover_window (void);
 100
 101 static GtkStateType gtk_sheet_cell_get_state (GtkSheet *sheet, gint row, gint col);
 102
 103
 104 static inline  void
 105 dispose_string (const GtkSheet *sheet, gchar *text)
 106 {
 107   GSheetModel *model = gtk_sheet_get_model (sheet);
 108
 109   if ( ! model )
 110     return;
 111
 112   if (g_sheet_model_free_strings (model))
 113     g_free (text);
 114 }
 115
 116 static
 117 guint STRING_WIDTH (GtkWidget *widget,
 118                     const PangoFontDescription *font, const gchar *text)
 119 {
 120   PangoRectangle rect;
 121   PangoLayout *layout;
 122
 123   layout = gtk_widget_create_pango_layout (widget, text);
 124   pango_layout_set_font_description (layout, font);
 125
 126   pango_layout_get_extents (layout, NULL, &rect);
 127
 128   g_object_unref (layout);
 129   return PANGO_PIXELS (rect.width);
 130 }
 131
 132 /* Return the row containing pixel Y */
 133 static gint
 134 yyy_row_ypixel_to_row (const GtkSheet *sheet, gint y)
 135 {
 136   GSheetRow *geo = sheet->row_geometry;
 137
 138   g_return_val_if_fail (y >= 0, -1);
 139
 140   return g_sheet_row_pixel_to_row (geo, y);
 141 }
 142
 143 /* Return the lowest row number which is wholly or partially on
 144    the visible range of the sheet */
 145 static inline glong
 146 min_visible_row (const GtkSheet *sheet)
 147 {
 148   return yyy_row_ypixel_to_row (sheet, sheet->vadjustment->value);
 149 }
 150
 151 static inline glong
 152 min_fully_visible_row (const GtkSheet *sheet)
 153 {
 154   glong row = yyy_row_ypixel_to_row (sheet, sheet->vadjustment->value);
 155
 156   if ( g_sheet_row_start_pixel (sheet->row_geometry, row) < sheet->vadjustment->value)
 157     row++;
 158
 159   return  row;
 160 }
 161
 162
 163
 164 static inline glong
 165 max_visible_row (const GtkSheet *sheet)
 166 {
 167   return yyy_row_ypixel_to_row (sheet,
 168                            sheet->vadjustment->value +
 169                            sheet->vadjustment->page_size);
 170 }
 171
 172
 173 static inline glong
 174 max_fully_visible_row (const GtkSheet *sheet)
 175 {
 176   glong row = max_visible_row (sheet);
 177
 178   if ( g_sheet_row_start_pixel (sheet->row_geometry, row)
 179        +
 180        g_sheet_row_get_height (sheet->row_geometry, row)
 181        > sheet->vadjustment->value)
 182     row--;
 183
 184   return row;
 185 }
 186
 187
 188 /* returns the column index from a pixel location */
 189 static inline gint
 190 column_from_xpixel (const GtkSheet *sheet, gint pixel)
 191 {
 192   return psppire_axis_get_unit_at_pixel (sheet->haxis, pixel);
 193 }
 194
 195
 196 /* Returns the lowest column number which is wholly or partially
 197    on the sheet */
 198 static inline glong
 199 min_visible_column (const GtkSheet *sheet)
 200 {
 201   return column_from_xpixel (sheet, sheet->hadjustment->value);
 202 }
 203
 204 static inline glong
 205 min_fully_visible_column (const GtkSheet *sheet)
 206 {
 207   glong col = min_visible_column (sheet);
 208
 209   if ( psppire_axis_pixel_start (sheet->haxis, col) < sheet->hadjustment->value)
 210     col++;
 211
 212   return col;
 213 }
 214
 215
 216 /* Returns the highest column number which is wholly or partially
 217    on the sheet */
 218 static inline glong
 219 max_visible_column (const GtkSheet *sheet)
 220 {
 221   return column_from_xpixel (sheet,
 222                              sheet->hadjustment->value +
 223                              sheet->hadjustment->page_size);
 224 }
 225
 226 static inline glong
 227 max_fully_visible_column (const GtkSheet *sheet)
 228 {
 229   glong col = max_visible_column (sheet);
 230
 231   if ( psppire_axis_pixel_start (sheet->haxis, col)
 232        +
 233        psppire_axis_unit_size (sheet->haxis, col)
 234        > sheet->hadjustment->value)
 235     col--;
 236
 237   return col;
 238 }
 239
 240
 241
 242 /* The size of the region (in pixels) around the row/column boundaries
 243    where the height/width may be grabbed to change size */
 244 #define DRAG_WIDTH 6
 245
 246 static gboolean
 247 on_column_boundary (const GtkSheet *sheet, gint x, gint *column)
 248 {
 249   gint col;
 250
 251   x += sheet->hadjustment->value;
 252
 253   col = column_from_xpixel (sheet, x);
 254
 255   if ( column_from_xpixel (sheet, x - DRAG_WIDTH / 2) < col )
 256     {
 257       *column = col - 1;
 258       return TRUE;
 259     }
 260
 261   if  ( column_from_xpixel (sheet, x + DRAG_WIDTH / 2) > col )
 262     {
 263       *column = col;
 264       return TRUE;
 265     }
 266
 267   return FALSE;
 268 }
 269
 270 static inline gboolean
 271 POSSIBLE_YDRAG (const GtkSheet *sheet, gint y, gint *drag_row)
 272 {
 273   gint row, ydrag;
 274
 275   y += sheet->vadjustment->value;
 276   row = yyy_row_ypixel_to_row (sheet, y);
 277   *drag_row = row;
 278
 279   ydrag = g_sheet_row_start_pixel (sheet->row_geometry, row) + CELL_SPACING;
 280   if (y <= ydrag + DRAG_WIDTH / 2 && row != 0)
 281     {
 282       *drag_row = row - 1;
 283       return g_sheet_row_get_sensitivity (sheet->row_geometry, row - 1);
 284     }
 285
 286   ydrag += g_sheet_row_get_height (sheet->row_geometry, row);
 287
 288   if (y >= ydrag - DRAG_WIDTH / 2 && y <= ydrag + DRAG_WIDTH / 2)
 289     return g_sheet_row_get_sensitivity (sheet->row_geometry, row);
 290
 291   return FALSE;
 292 }
 293
 294 static inline gboolean
 295 POSSIBLE_DRAG (const GtkSheet *sheet, gint x, gint y,
 296                gint *drag_row, gint *drag_column)
 297 {
 298   gint ydrag, xdrag;
 299
 300   /* Can't drag if nothing is selected */
 301   if ( sheet->range.row0 < 0 || sheet->range.rowi < 0 ||
 302        sheet->range.col0 < 0 || sheet->range.coli < 0 )
 303     return FALSE;
 304
 305   *drag_column = column_from_xpixel (sheet, x);
 306   *drag_row = yyy_row_ypixel_to_row (sheet, y);
 307
 308   if (x >= psppire_axis_pixel_start (sheet->haxis, sheet->range.col0) - DRAG_WIDTH / 2 &&
 309       x <= psppire_axis_pixel_start (sheet->haxis, sheet->range.coli) +
 310       psppire_axis_unit_size (sheet->haxis, sheet->range.coli) + DRAG_WIDTH / 2)
 311     {
 312       ydrag = g_sheet_row_start_pixel (sheet->row_geometry, sheet->range.row0);
 313       if (y >= ydrag - DRAG_WIDTH / 2 && y <= ydrag + DRAG_WIDTH / 2)
 314         {
 315           *drag_row = sheet->range.row0;
 316           return TRUE;
 317         }
 318       ydrag = g_sheet_row_start_pixel (sheet->row_geometry, sheet->range.rowi) +
 319         g_sheet_row_get_height (sheet->row_geometry, sheet->range.rowi);
 320       if (y >= ydrag - DRAG_WIDTH / 2 && y <= ydrag + DRAG_WIDTH / 2)
 321         {
 322           *drag_row = sheet->range.rowi;
 323           return TRUE;
 324         }
 325     }
 326
 327   if (y >= g_sheet_row_start_pixel (sheet->row_geometry, sheet->range.row0) - DRAG_WIDTH / 2 &&
 328       y <= g_sheet_row_start_pixel (sheet->row_geometry, sheet->range.rowi) +
 329       g_sheet_row_get_height (sheet->row_geometry, sheet->range.rowi) + DRAG_WIDTH / 2)
 330     {
 331       xdrag = psppire_axis_pixel_start (sheet->haxis, sheet->range.col0);
 332       if (x >= xdrag - DRAG_WIDTH / 2 && x <= xdrag + DRAG_WIDTH / 2)
 333         {
 334           *drag_column = sheet->range.col0;
 335           return TRUE;
 336         }
 337       xdrag = psppire_axis_pixel_start (sheet->haxis, sheet->range.coli) +
 338         psppire_axis_unit_size (sheet->haxis, sheet->range.coli);
 339       if (x >= xdrag - DRAG_WIDTH / 2 && x <= xdrag + DRAG_WIDTH / 2)
 340         {
 341           *drag_column = sheet->range.coli;
 342           return TRUE;
 343         }
 344     }
 345
 346   return FALSE;
 347 }
 348
 349 static inline gboolean
 350 POSSIBLE_RESIZE (const GtkSheet *sheet, gint x, gint y,
 351                  gint *drag_row, gint *drag_column)
 352 {
 353   gint xdrag, ydrag;
 354
 355   /* Can't drag if nothing is selected */
 356   if ( sheet->range.row0 < 0 || sheet->range.rowi < 0 ||
 357        sheet->range.col0 < 0 || sheet->range.coli < 0 )
 358     return FALSE;
 359
 360   xdrag = psppire_axis_pixel_start (sheet->haxis, sheet->range.coli)+
 361     psppire_axis_unit_size (sheet->haxis, sheet->range.coli);
 362
 363   ydrag = g_sheet_row_start_pixel (sheet->row_geometry, sheet->range.rowi) +
 364     g_sheet_row_get_height (sheet->row_geometry, sheet->range.rowi);
 365
 366   if (sheet->state == GTK_SHEET_COLUMN_SELECTED)
 367     ydrag = g_sheet_row_start_pixel (sheet->row_geometry, min_visible_row (sheet));
 368
 369   if (sheet->state == GTK_SHEET_ROW_SELECTED)
 370     xdrag = psppire_axis_pixel_start (sheet->haxis, min_visible_column (sheet));
 371
 372   *drag_column = column_from_xpixel (sheet, x);
 373   *drag_row = yyy_row_ypixel_to_row (sheet, y);
 374
 375   if (x >= xdrag - DRAG_WIDTH / 2 && x <= xdrag + DRAG_WIDTH / 2 &&
 376       y >= ydrag - DRAG_WIDTH / 2 && y <= ydrag + DRAG_WIDTH / 2) return TRUE;
 377
 378   return FALSE;
 379 }
 380
 381
 382 static gboolean
 383 rectangle_from_range (GtkSheet *sheet, const GtkSheetRange *range,
 384                       GdkRectangle *r)
 385 {
 386   g_return_val_if_fail (range, FALSE);
 387
 388   r->x = psppire_axis_pixel_start (sheet->haxis, range->col0);
 389   r->x -= round (sheet->hadjustment->value);
 390
 391   if ( sheet->row_titles_visible)
 392     r->x += sheet->row_title_area.width;
 393
 394
 395   r->y = g_sheet_row_start_pixel (sheet->row_geometry, range->row0);
 396   r->y -= round (sheet->vadjustment->value);
 397
 398   if ( sheet->column_titles_visible)
 399     r->y += sheet->column_title_area.height;
 400
 401   r->width = psppire_axis_pixel_start (sheet->haxis, range->coli) -
 402     psppire_axis_pixel_start (sheet->haxis, range->col0) +
 403     psppire_axis_unit_size (sheet->haxis, range->coli);
 404
 405   r->height = g_sheet_row_start_pixel (sheet->row_geometry, range->rowi) -
 406     g_sheet_row_start_pixel (sheet->row_geometry, range->row0) +
 407     g_sheet_row_get_height (sheet->row_geometry, range->rowi);
 408
 409   return TRUE;
 410 }
 411
 412 static gboolean
 413 rectangle_from_cell (GtkSheet *sheet, gint row, gint col,
 414                      GdkRectangle *r)
 415 {
 416   GtkSheetRange range;
 417   g_return_val_if_fail (row >= 0, FALSE);
 418   g_return_val_if_fail (col >= 0, FALSE);
 419
 420   range.row0 = range.rowi = row;
 421   range.col0 = range.coli = col;
 422
 423   return rectangle_from_range (sheet, &range, r);
 424 }
 425
 426
 427 static void gtk_sheet_class_init                 (GtkSheetClass *klass);
 428 static void gtk_sheet_init                       (GtkSheet *sheet);
 429 static void gtk_sheet_dispose                    (GObject *object);
 430 static void gtk_sheet_finalize                   (GObject *object);
 431 static void gtk_sheet_style_set                  (GtkWidget *widget,
 432                                                   GtkStyle *previous_style);
 433 static void gtk_sheet_realize                    (GtkWidget *widget);
 434 static void gtk_sheet_unrealize                  (GtkWidget *widget);
 435 static void gtk_sheet_map                        (GtkWidget *widget);
 436 static void gtk_sheet_unmap                      (GtkWidget *widget);
 437 static gint gtk_sheet_expose                     (GtkWidget *widget,
 438                                                   GdkEventExpose *event);
 439 static void gtk_sheet_forall                     (GtkContainer *container,
 440                                                   gboolean include_internals,
 441                                                   GtkCallback callback,
 442                                                   gpointer callback_data);
 443
 444 static void gtk_sheet_set_scroll_adjustments     (GtkSheet *sheet,
 445                                                   GtkAdjustment *hadjustment,
 446                                                   GtkAdjustment *vadjustment);
 447
 448 static gint gtk_sheet_button_press               (GtkWidget *widget,
 449                                                   GdkEventButton *event);
 450 static gint gtk_sheet_button_release             (GtkWidget *widget,
 451                                                   GdkEventButton *event);
 452 static gint gtk_sheet_motion                     (GtkWidget *widget,
 453                                                   GdkEventMotion *event);
 454 static gboolean gtk_sheet_crossing_notify           (GtkWidget *widget,
 455                                                      GdkEventCrossing *event);
 456 static gint gtk_sheet_entry_key_press            (GtkWidget *widget,
 457                                                   GdkEventKey *key);
 458 static gboolean gtk_sheet_key_press              (GtkWidget *widget,
 459                                                   GdkEventKey *key);
 460 static void gtk_sheet_size_request               (GtkWidget *widget,
 461                                                   GtkRequisition *requisition);
 462 static void gtk_sheet_size_allocate              (GtkWidget *widget,
 463                                                   GtkAllocation *allocation);
 464
 465 /* Sheet queries */
 466
 467 static gboolean gtk_sheet_range_isvisible (const GtkSheet *sheet,
 468                                            GtkSheetRange range);
 469 static gboolean gtk_sheet_cell_isvisible  (GtkSheet *sheet,
 470                                            gint row, gint column);
 471 /* Drawing Routines */
 472
 473 /* draw cell */
 474 static void gtk_sheet_cell_draw (GtkSheet *sheet, gint row, gint column);
 475
 476
 477 /* draw visible part of range. If range == NULL then draw the whole screen */
 478 static void gtk_sheet_range_draw (GtkSheet *sheet,
 479                                   const GtkSheetRange *range);
 480
 481 /* highlight the visible part of the selected range */
 482 static void gtk_sheet_range_draw_selection       (GtkSheet *sheet,
 483                                                   GtkSheetRange range);
 484
 485 /* Selection */
 486
 487 static void gtk_sheet_real_select_range          (GtkSheet *sheet,
 488                                                   const GtkSheetRange *range);
 489 static void gtk_sheet_real_unselect_range        (GtkSheet *sheet,
 490                                                   const GtkSheetRange *range);
 491 static void gtk_sheet_extend_selection           (GtkSheet *sheet,
 492                                                   gint row, gint column);
 493 static void gtk_sheet_new_selection              (GtkSheet *sheet,
 494                                                   GtkSheetRange *range);
 495 static void gtk_sheet_draw_border                (GtkSheet *sheet,
 496                                                   GtkSheetRange range);
 497
 498 /* Active Cell handling */
 499
 500 static void gtk_sheet_entry_changed              (GtkWidget *widget,
 501                                                   gpointer data);
 502 static void gtk_sheet_hide_active_cell           (GtkSheet *sheet);
 503 static void change_active_cell           (GtkSheet *sheet,
 504                                           gint row, gint col);
 505 static void gtk_sheet_draw_active_cell           (GtkSheet *sheet);
 506 static void gtk_sheet_show_active_cell           (GtkSheet *sheet);
 507 static gboolean gtk_sheet_click_cell             (GtkSheet *sheet,
 508                                                   gint row,
 509                                                   gint column);
 510
 511
 512 /* Scrollbars */
 513
 514 static void adjust_scrollbars                    (GtkSheet *sheet);
 515 static void vadjustment_value_changed            (GtkAdjustment *adjustment,
 516                                                   gpointer data);
 517 static void hadjustment_value_changed            (GtkAdjustment *adjustment,
 518                                                   gpointer data);
 519
 520
 521 static void draw_xor_vline                       (GtkSheet *sheet);
 522 static void draw_xor_hline                       (GtkSheet *sheet);
 523 static void draw_xor_rectangle                   (GtkSheet *sheet,
 524                                                   GtkSheetRange range);
 525
 526 static guint new_column_width                    (GtkSheet *sheet,
 527                                                   gint column,
 528                                                   gint *x);
 529 static guint new_row_height                      (GtkSheet *sheet,
 530                                                   gint row,
 531                                                   gint *y);
 532 /* Sheet Button */
 533
 534 static void create_global_button                 (GtkSheet *sheet);
 535 static void global_button_clicked                (GtkWidget *widget,
 536                                                   gpointer data);
 537 /* Sheet Entry */
 538
 539 static void create_sheet_entry                   (GtkSheet *sheet);
 540 static void gtk_sheet_size_allocate_entry        (GtkSheet *sheet);
 541
 542 /* Sheet button gadgets */
 543
 544 static void draw_column_title_buttons    (GtkSheet *sheet);
 545 static void draw_row_title_buttons       (GtkSheet *sheet);
 546
 547
 548 static void size_allocate_global_button          (GtkSheet *sheet);
 549 static void gtk_sheet_button_size_request        (GtkSheet *sheet,
 550                                                   const GtkSheetButton *button,
 551                                                   GtkRequisition *requisition);
 552
 553 static void gtk_sheet_real_cell_clear            (GtkSheet *sheet,
 554                                                   gint row,
 555                                                   gint column);
 556
 557
 558 static void gtk_sheet_column_size_request (GtkSheet *sheet,
 559                                            gint col,
 560                                            guint *requisition);
 561 static void gtk_sheet_row_size_request (GtkSheet *sheet,
 562                                         gint row,
 563                                         guint *requisition);
 564
 565
 566 /* Signals */
 567 enum
 568   {
 569     SELECT_ROW,
 570     SELECT_COLUMN,
 571     DOUBLE_CLICK_ROW,
 572     DOUBLE_CLICK_COLUMN,
 573     BUTTON_EVENT_ROW,
 574     BUTTON_EVENT_COLUMN,
 575     SELECT_RANGE,
 576     RESIZE_RANGE,
 577     MOVE_RANGE,
 578     TRAVERSE,
 579     ACTIVATE,
 580     LAST_SIGNAL
 581   };
 582
 583 static GtkContainerClass *parent_class = NULL;
 584 static guint sheet_signals[LAST_SIGNAL] = { 0 };
 585
 586
 587 GType
 588 gtk_sheet_get_type ()
 589 {
 590   static GType sheet_type = 0;
 591
 592   if (!sheet_type)
 593     {
 594       static const GTypeInfo sheet_info =
 595         {
 596           sizeof (GtkSheetClass),
 597           NULL,
 598           NULL,
 599           (GClassInitFunc) gtk_sheet_class_init,
 600           NULL,
 601           NULL,
 602           sizeof (GtkSheet),
 603           0,
 604           (GInstanceInitFunc) gtk_sheet_init,
 605           NULL,
 606         };
 607
 608       sheet_type =
 609         g_type_register_static (GTK_TYPE_BIN, "GtkSheet",
 610                                 &sheet_info, 0);
 611     }
 612   return sheet_type;
 613 }
 614
 615 \f
 616
 617 static GtkSheetRange*
 618 gtk_sheet_range_copy (const GtkSheetRange *range)
 619 {
 620   GtkSheetRange *new_range;
 621
 622   g_return_val_if_fail (range != NULL, NULL);
 623
 624   new_range = g_new (GtkSheetRange, 1);
 625
 626   *new_range = *range;
 627
 628   return new_range;
 629 }
 630
 631 static void
 632 gtk_sheet_range_free (GtkSheetRange *range)
 633 {
 634   g_return_if_fail (range != NULL);
 635
 636   g_free (range);
 637 }
 638
 639 GType
 640 gtk_sheet_range_get_type (void)
 641 {
 642   static GType sheet_range_type = 0;
 643
 644   if (!sheet_range_type)
 645     {
 646       sheet_range_type =
 647         g_boxed_type_register_static ("GtkSheetRange",
 648                                       (GBoxedCopyFunc) gtk_sheet_range_copy,
 649                                       (GBoxedFreeFunc) gtk_sheet_range_free);
 650     }
 651
 652   return sheet_range_type;
 653 }
 654
 655 static GtkSheetCell*
 656 gtk_sheet_cell_copy (const GtkSheetCell *cell)
 657 {
 658   GtkSheetCell *new_cell;
 659
 660   g_return_val_if_fail (cell != NULL, NULL);
 661
 662   new_cell = g_new (GtkSheetCell, 1);
 663
 664   *new_cell = *cell;
 665
 666   return new_cell;
 667 }
 668
 669 static void
 670 gtk_sheet_cell_free (GtkSheetCell *cell)
 671 {
 672   g_return_if_fail (cell != NULL);
 673
 674   g_free (cell);
 675 }
 676
 677 GType
 678 gtk_sheet_cell_get_type (void)
 679 {
 680   static GType sheet_cell_type = 0;
 681
 682   if (!sheet_cell_type)
 683     {
 684       sheet_cell_type =
 685         g_boxed_type_register_static ("GtkSheetCell",
 686                                       (GBoxedCopyFunc) gtk_sheet_cell_copy,
 687                                       (GBoxedFreeFunc) gtk_sheet_cell_free);
 688     }
 689
 690   return sheet_cell_type;
 691 }
 692 \f
 693
 694 static void column_titles_changed (GtkWidget *w, gint first, gint n_columns,
 695                                    gpointer data);
 696
 697 /* Properties */
 698 enum
 699   {
 700     PROP_0,
 701     PROP_ROW_GEO,
 702     PROP_HAXIS,
 703     PROP_MODEL
 704   };
 705
 706 static void
 707 gtk_sheet_set_row_geometry (GtkSheet *sheet, GSheetRow *geo)
 708 {
 709   if ( sheet->row_geometry ) g_object_unref (sheet->row_geometry);
 710
 711   sheet->row_geometry = geo;
 712
 713   if ( sheet->row_geometry ) g_object_ref (sheet->row_geometry);
 714 }
 715
 716 static void
 717 gtk_sheet_set_horizontal_axis (GtkSheet *sheet, PsppireAxis *a)
 718 {
 719   if ( sheet->haxis )
 720     g_object_unref (sheet->haxis);
 721
 722   sheet->haxis = a;
 723
 724   if ( sheet->haxis )
 725     g_object_ref (sheet->haxis);
 726 }
 727
 728
 729 static void
 730 gtk_sheet_set_property (GObject         *object,
 731                         guint            prop_id,
 732                         const GValue    *value,
 733                         GParamSpec      *pspec)
 734
 735 {
 736   GtkSheet *sheet = GTK_SHEET (object);
 737
 738   switch (prop_id)
 739     {
 740     case PROP_ROW_GEO:
 741       gtk_sheet_set_row_geometry (sheet, g_value_get_pointer (value));
 742       break;
 743     case PROP_HAXIS:
 744       gtk_sheet_set_horizontal_axis (sheet, g_value_get_pointer (value));
 745       break;
 746     case PROP_MODEL:
 747       gtk_sheet_set_model (sheet, g_value_get_pointer (value));
 748       break;
 749     default:
 750       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 751       break;
 752     };
 753 }
 754
 755 static void
 756 gtk_sheet_get_property (GObject         *object,
 757                         guint            prop_id,
 758                         GValue          *value,
 759                         GParamSpec      *pspec)
 760 {
 761   GtkSheet *sheet = GTK_SHEET (object);
 762
 763   switch (prop_id)
 764     {
 765     case PROP_ROW_GEO:
 766       g_value_set_pointer (value, sheet->row_geometry);
 767       break;
 768     case PROP_HAXIS:
 769       g_value_set_pointer (value, sheet->haxis);
 770       break;
 771     case PROP_MODEL:
 772       g_value_set_pointer (value, sheet->model);
 773       break;
 774     default:
 775       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 776       break;
 777     };
 778 }
 779
 780
 781 static void
 782 gtk_sheet_class_init (GtkSheetClass *klass)
 783 {
 784   GObjectClass *object_class = G_OBJECT_CLASS (klass);
 785
 786   GParamSpec *row_geo_spec ;
 787   GParamSpec *haxis_spec ;
 788   GParamSpec *model_spec ;
 789
 790   GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
 791   GtkContainerClass *container_class = GTK_CONTAINER_CLASS (klass);
 792
 793   parent_class = g_type_class_peek_parent (klass);
 794
 795   /**
 796    * GtkSheet::select-row
 797    * @sheet: the sheet widget that emitted the signal
 798    * @row: the newly selected row index
 799    *
 800    * A row has been selected.
 801    */
 802   sheet_signals[SELECT_ROW] =
 803     g_signal_new ("select-row",
 804                   G_TYPE_FROM_CLASS (object_class),
 805                   G_SIGNAL_RUN_LAST,
 806                   offsetof (GtkSheetClass, select_row),
 807                   NULL, NULL,
 808                   g_cclosure_marshal_VOID__INT,
 809                   G_TYPE_NONE,
 810                   1,
 811                   G_TYPE_INT);
 812
 813
 814   /**
 815    * GtkSheet::select - column
 816    * @sheet: the sheet widget that emitted the signal
 817    * @column: the newly selected column index
 818    *
 819    * A column has been selected.
 820    */
 821   sheet_signals[SELECT_COLUMN] =
 822     g_signal_new ("select-column",
 823                   G_TYPE_FROM_CLASS (object_class),
 824                   G_SIGNAL_RUN_LAST,
 825                   offsetof (GtkSheetClass, select_column),
 826                   NULL, NULL,
 827                   g_cclosure_marshal_VOID__INT,
 828                   G_TYPE_NONE,
 829                   1,
 830                   G_TYPE_INT);
 831
 832
 833   /**
 834    * GtkSheet::double-click-row
 835    * @sheet: the sheet widget that emitted the signal
 836    * @row: the row that was double clicked.
 837    *
 838    * A row's title button has been double clicked
 839    */
 840   sheet_signals[DOUBLE_CLICK_ROW] =
 841     g_signal_new ("double-click-row",
 842                   G_TYPE_FROM_CLASS (object_class),
 843                   G_SIGNAL_RUN_LAST,
 844                   0,
 845                   NULL, NULL,
 846                   g_cclosure_marshal_VOID__INT,
 847                   G_TYPE_NONE,
 848                   1,
 849                   G_TYPE_INT);
 850
 851
 852   /**
 853    * GtkSheet::double-click-column
 854    * @sheet: the sheet widget that emitted the signal
 855    * @column: the column that was double clicked.
 856    *
 857    * A column's title button has been double clicked
 858    */
 859   sheet_signals[DOUBLE_CLICK_COLUMN] =
 860     g_signal_new ("double-click-column",
 861                   G_TYPE_FROM_CLASS (object_class),
 862                   G_SIGNAL_RUN_LAST,
 863                   0,
 864                   NULL, NULL,
 865                   g_cclosure_marshal_VOID__INT,
 866                   G_TYPE_NONE,
 867                   1,
 868                   G_TYPE_INT);
 869
 870
 871   /**
 872    * GtkSheet::button-event-column
 873    * @sheet: the sheet widget that emitted the signal
 874    * @column: the column on which the event occured.
 875    *
 876    * A button event occured on a column title button
 877    */
 878   sheet_signals[BUTTON_EVENT_COLUMN] =
 879     g_signal_new ("button-event-column",
 880                   G_TYPE_FROM_CLASS (object_class),
 881                   G_SIGNAL_RUN_LAST,
 882                   0,
 883                   NULL, NULL,
 884                   gtkextra_VOID__INT_POINTER,
 885                   G_TYPE_NONE,
 886                   2,
 887                   G_TYPE_INT,
 888                   G_TYPE_POINTER
 889                   );
 890
 891
 892   /**
 893    * GtkSheet::button-event-row
 894    * @sheet: the sheet widget that emitted the signal
 895    * @column: the column on which the event occured.
 896    *
 897    * A button event occured on a row title button
 898    */
 899   sheet_signals[BUTTON_EVENT_ROW] =
 900     g_signal_new ("button-event-row",
 901                   G_TYPE_FROM_CLASS (object_class),
 902                   G_SIGNAL_RUN_LAST,
 903                   0,
 904                   NULL, NULL,
 905                   gtkextra_VOID__INT_POINTER,
 906                   G_TYPE_NONE,
 907                   2,
 908                   G_TYPE_INT,
 909                   G_TYPE_POINTER
 910                   );
 911
 912
 913   sheet_signals[SELECT_RANGE] =
 914     g_signal_new ("select-range",
 915                   G_TYPE_FROM_CLASS (object_class),
 916                   G_SIGNAL_RUN_LAST,
 917                   offsetof (GtkSheetClass, select_range),
 918                   NULL, NULL,
 919                   g_cclosure_marshal_VOID__BOXED,
 920                   G_TYPE_NONE,
 921                   1,
 922                   GTK_TYPE_SHEET_RANGE);
 923
 924
 925   sheet_signals[RESIZE_RANGE] =
 926     g_signal_new ("resize-range",
 927                   G_TYPE_FROM_CLASS (object_class),
 928                   G_SIGNAL_RUN_LAST,
 929                   offsetof (GtkSheetClass, resize_range),
 930                   NULL, NULL,
 931                   gtkextra_VOID__BOXED_BOXED,
 932                   G_TYPE_NONE,
 933                   2,
 934                   GTK_TYPE_SHEET_RANGE, GTK_TYPE_SHEET_RANGE
 935                   );
 936
 937   sheet_signals[MOVE_RANGE] =
 938     g_signal_new ("move-range",
 939                   G_TYPE_FROM_CLASS (object_class),
 940                   G_SIGNAL_RUN_LAST,
 941                   offsetof (GtkSheetClass, move_range),
 942                   NULL, NULL,
 943                   gtkextra_VOID__BOXED_BOXED,
 944                   G_TYPE_NONE,
 945                   2,
 946                   GTK_TYPE_SHEET_RANGE, GTK_TYPE_SHEET_RANGE
 947                   );
 948
 949   sheet_signals[TRAVERSE] =
 950     g_signal_new ("traverse",
 951                   G_TYPE_FROM_CLASS (object_class),
 952                   G_SIGNAL_RUN_LAST,
 953                   offsetof (GtkSheetClass, traverse),
 954                   NULL, NULL,
 955                   gtkextra_BOOLEAN__BOXED_POINTER,
 956                   G_TYPE_BOOLEAN, 2,
 957                   GTK_TYPE_SHEET_CELL,
 958                   G_TYPE_POINTER);
 959
 960
 961   sheet_signals[ACTIVATE] =
 962     g_signal_new ("activate",
 963                   G_TYPE_FROM_CLASS (object_class),
 964                   G_SIGNAL_RUN_LAST,
 965                   offsetof (GtkSheetClass, activate),
 966                   NULL, NULL,
 967                   gtkextra_VOID__INT_INT_INT_INT,
 968                   G_TYPE_NONE, 4,
 969                   G_TYPE_INT, G_TYPE_INT,
 970                   G_TYPE_INT, G_TYPE_INT);
 971
 972   widget_class->set_scroll_adjustments_signal =
 973     g_signal_new ("set-scroll-adjustments",
 974                   G_TYPE_FROM_CLASS (object_class),
 975                   G_SIGNAL_RUN_LAST,
 976                   offsetof (GtkSheetClass, set_scroll_adjustments),
 977                   NULL, NULL,
 978                   gtkextra_VOID__OBJECT_OBJECT,
 979                   G_TYPE_NONE, 2, GTK_TYPE_ADJUSTMENT, GTK_TYPE_ADJUSTMENT);
 980
 981
 982   container_class->add = NULL;
 983   container_class->remove = NULL;
 984   container_class->forall = gtk_sheet_forall;
 985
 986   object_class->dispose = gtk_sheet_dispose;
 987   object_class->finalize = gtk_sheet_finalize;
 988
 989
 990   row_geo_spec =
 991     g_param_spec_pointer ("row-geometry",
 992                           "Row Geometry",
 993                           "A pointer to the model of the row geometry",
 994                           G_PARAM_READABLE | G_PARAM_WRITABLE );
 995
 996   haxis_spec =
 997     g_param_spec_pointer ("horizontal-axis",
 998                           "Horizontal Axis",
 999                           "A pointer to the PsppireAxis object for the columns",
1000                           G_PARAM_READABLE | G_PARAM_WRITABLE );
1001
1002   model_spec =
1003     g_param_spec_pointer ("model",
1004                           "Model",
1005                           "A pointer to the data model",
1006                           G_PARAM_READABLE | G_PARAM_WRITABLE );
1007
1008
1009   object_class->set_property = gtk_sheet_set_property;
1010   object_class->get_property = gtk_sheet_get_property;
1011
1012   g_object_class_install_property (object_class,
1013                                    PROP_ROW_GEO,
1014                                    row_geo_spec);
1015
1016   g_object_class_install_property (object_class,
1017                                    PROP_HAXIS,
1018                                    haxis_spec);
1019
1020   g_object_class_install_property (object_class,
1021                                    PROP_MODEL,
1022                                    model_spec);
1023
1024
1025   widget_class->realize = gtk_sheet_realize;
1026   widget_class->unrealize = gtk_sheet_unrealize;
1027   widget_class->map = gtk_sheet_map;
1028   widget_class->unmap = gtk_sheet_unmap;
1029   widget_class->style_set = gtk_sheet_style_set;
1030   widget_class->button_press_event = gtk_sheet_button_press;
1031   widget_class->button_release_event = gtk_sheet_button_release;
1032   widget_class->motion_notify_event = gtk_sheet_motion;
1033   widget_class->enter_notify_event = gtk_sheet_crossing_notify;
1034   widget_class->leave_notify_event = gtk_sheet_crossing_notify;
1035   widget_class->key_press_event = gtk_sheet_key_press;
1036   widget_class->expose_event = gtk_sheet_expose;
1037   widget_class->size_request = gtk_sheet_size_request;
1038   widget_class->size_allocate = gtk_sheet_size_allocate;
1039   widget_class->focus_in_event = NULL;
1040   widget_class->focus_out_event = NULL;
1041
1042   klass->set_scroll_adjustments = gtk_sheet_set_scroll_adjustments;
1043   klass->select_row = NULL;
1044   klass->select_column = NULL;
1045   klass->select_range = NULL;
1046   klass->resize_range = NULL;
1047   klass->move_range = NULL;
1048   klass->traverse = NULL;
1049   klass->activate = NULL;
1050   klass->changed = NULL;
1051 }
1052
1053 static void
1054 gtk_sheet_init (GtkSheet *sheet)
1055 {
1056   sheet->model = NULL;
1057   sheet->haxis = NULL;
1058   sheet->row_geometry = NULL;
1059
1060   sheet->flags = 0;
1061   sheet->selection_mode = GTK_SELECTION_NONE;
1062   sheet->state = GTK_SHEET_NORMAL;
1063
1064   GTK_WIDGET_UNSET_FLAGS (sheet, GTK_NO_WINDOW);
1065   GTK_WIDGET_SET_FLAGS (sheet, GTK_CAN_FOCUS);
1066
1067   sheet->column_title_window = NULL;
1068   sheet->column_title_area.x = 0;
1069   sheet->column_title_area.y = 0;
1070   sheet->column_title_area.width = 0;
1071   sheet->column_title_area.height = DEFAULT_ROW_HEIGHT;
1072
1073   sheet->row_title_window = NULL;
1074   sheet->row_title_area.x = 0;
1075   sheet->row_title_area.y = 0;
1076   sheet->row_title_area.width = DEFAULT_COLUMN_WIDTH;
1077   sheet->row_title_area.height = 0;
1078
1079
1080   sheet->active_cell.row = 0;
1081   sheet->active_cell.col = 0;
1082   sheet->selection_cell.row = 0;
1083   sheet->selection_cell.col = 0;
1084
1085   sheet->range.row0 = 0;
1086   sheet->range.rowi = 0;
1087   sheet->range.col0 = 0;
1088   sheet->range.coli = 0;
1089
1090   sheet->state = GTK_SHEET_NORMAL;
1091
1092   sheet->sheet_window = NULL;
1093   sheet->entry_widget = NULL;
1094   sheet->entry_container = NULL;
1095   sheet->entry_handler_id = 0;
1096   sheet->button = NULL;
1097
1098   sheet->hadjustment = NULL;
1099   sheet->vadjustment = NULL;
1100
1101   sheet->cursor_drag = NULL;
1102
1103   sheet->xor_gc = NULL;
1104   sheet->fg_gc = NULL;
1105   sheet->bg_gc = NULL;
1106   sheet->x_drag = 0;
1107   sheet->y_drag = 0;
1108   sheet->show_grid = TRUE;
1109
1110   sheet->motion_timer = 0;
1111
1112   sheet->columns_resizable = TRUE;
1113   sheet->rows_resizable = TRUE;
1114
1115   sheet->row_titles_visible = TRUE;
1116   sheet->row_title_area.width = DEFAULT_COLUMN_WIDTH;
1117
1118   sheet->column_titles_visible = TRUE;
1119
1120
1121   /* create sheet entry */
1122   sheet->entry_type = 0;
1123   create_sheet_entry (sheet);
1124
1125   /* create global selection button */
1126   create_global_button (sheet);
1127 }
1128
1129
1130 /* Callback which occurs whenever columns are inserted / deleted in the model */
1131 static void
1132 columns_inserted_deleted_callback (GSheetModel *model, gint first_column,
1133                                    gint n_columns,
1134                                    gpointer data)
1135 {
1136   gint i;
1137   GtkSheet *sheet = GTK_SHEET (data);
1138
1139   GtkSheetRange range;
1140   gint model_columns = g_sheet_model_get_column_count (model);
1141
1142
1143   /* Need to update all the columns starting from the first column and onwards.
1144    * Previous column are unchanged, so don't need to be updated.
1145    */
1146   range.col0 = first_column;
1147   range.row0 = 0;
1148   range.coli = psppire_axis_unit_count (sheet->haxis) - 1;
1149   range.rowi = g_sheet_row_get_row_count (sheet->row_geometry) - 1;
1150
1151   adjust_scrollbars (sheet);
1152
1153   if (sheet->active_cell.col >= model_columns)
1154     change_active_cell (sheet, sheet->active_cell.row, model_columns - 1);
1155
1156   for (i = first_column; i <= max_visible_column (sheet); i++)
1157     gtk_sheet_column_title_button_draw (sheet, i);
1158
1159   gtk_sheet_range_draw (sheet, &range);
1160 }
1161
1162
1163 /* Callback which occurs whenever rows are inserted / deleted in the model */
1164 static void
1165 rows_inserted_deleted_callback (GSheetModel *model, gint first_row,
1166                                 gint n_rows, gpointer data)
1167 {
1168   gint i;
1169   GtkSheet *sheet = GTK_SHEET (data);
1170
1171   GtkSheetRange range;
1172
1173   gint model_rows = g_sheet_model_get_row_count (model);
1174
1175   /* Need to update all the rows starting from the first row and onwards.
1176    * Previous rows are unchanged, so don't need to be updated.
1177    */
1178   range.row0 = first_row;
1179   range.col0 = 0;
1180   range.rowi = g_sheet_row_get_row_count (sheet->row_geometry) - 1;
1181   range.coli = psppire_axis_unit_count (sheet->haxis) - 1;
1182
1183   adjust_scrollbars (sheet);
1184
1185   if (sheet->active_cell.row >= model_rows)
1186     change_active_cell (sheet, model_rows - 1, sheet->active_cell.col);
1187
1188   for (i = first_row; i <= max_visible_row (sheet); i++)
1189     gtk_sheet_row_title_button_draw (sheet, i);
1190
1191   gtk_sheet_range_draw (sheet, &range);
1192 }
1193
1194 /*
1195   If row0 or rowi are negative, then all rows will be updated.
1196   If col0 or coli are negative, then all columns will be updated.
1197 */
1198 static void
1199 range_update_callback (GSheetModel *m, gint row0, gint col0,
1200                        gint rowi, gint coli, gpointer data)
1201 {
1202   GtkSheet *sheet = GTK_SHEET (data);
1203
1204   GtkSheetRange range;
1205
1206   range.row0 = row0;
1207   range.col0 = col0;
1208   range.rowi = rowi;
1209   range.coli = coli;
1210
1211   if ( !GTK_WIDGET_REALIZED (GTK_WIDGET (sheet)))
1212     return;
1213
1214   if ( max_visible_row (sheet) > g_sheet_model_get_row_count (sheet->model)
1215        ||
1216        max_visible_column (sheet) > g_sheet_model_get_column_count (sheet->model))
1217     {
1218       gtk_sheet_moveto (sheet, 0, 0, 0, 0);
1219     }
1220
1221   if ( ( row0 < 0 && col0 < 0 ) || ( rowi < 0 && coli < 0 ) )
1222     {
1223       gint i;
1224       gtk_sheet_range_draw (sheet, NULL);
1225       adjust_scrollbars (sheet);
1226
1227       for (i = min_visible_row (sheet); i <= max_visible_row (sheet); i++)
1228         gtk_sheet_row_title_button_draw (sheet, i);
1229
1230       for (i = min_visible_column (sheet);
1231            i <= max_visible_column (sheet); i++)
1232         gtk_sheet_column_title_button_draw (sheet, i);
1233
1234       return;
1235     }
1236   else if ( row0 < 0 || rowi < 0 )
1237     {
1238       range.row0 = min_visible_row (sheet);
1239       range.rowi = max_visible_row (sheet);
1240     }
1241   else if ( col0 < 0 || coli < 0 )
1242     {
1243       range.col0 = min_visible_column (sheet);
1244       range.coli = max_visible_column (sheet);
1245     }
1246
1247   gtk_sheet_range_draw (sheet, &range);
1248 }
1249
1250
1251 /**
1252  * gtk_sheet_new:
1253  * @rows: initial number of rows
1254  * @columns: initial number of columns
1255  * @title: sheet title
1256  * @model: the model to use for the sheet data
1257  *
1258  * Creates a new sheet widget with the given number of rows and columns.
1259  *
1260  * Returns: the new sheet widget
1261  */
1262 GtkWidget *
1263 gtk_sheet_new (GSheetRow *vgeo, void *hgeo, GSheetModel *model)
1264 {
1265   GtkWidget *widget = g_object_new (GTK_TYPE_SHEET,
1266                                     "row-geometry", vgeo,
1267                                     "model", model,
1268                                     NULL);
1269   return widget;
1270 }
1271
1272
1273 /**
1274  * gtk_sheet_set_model
1275  * @sheet: the sheet to set the model for
1276  * @model: the model to use for the sheet data
1277  *
1278  * Sets the model for a GtkSheet
1279  *
1280  */
1281 void
1282 gtk_sheet_set_model (GtkSheet *sheet, GSheetModel *model)
1283 {
1284   g_return_if_fail (GTK_IS_SHEET (sheet));
1285
1286   if (sheet->model ) g_object_unref (sheet->model);
1287
1288   sheet->model = model;
1289
1290   if ( model)
1291     {
1292       g_object_ref (model);
1293
1294       g_signal_connect (model, "range_changed",
1295                         G_CALLBACK (range_update_callback), sheet);
1296
1297       g_signal_connect (model, "rows_inserted",
1298                         G_CALLBACK (rows_inserted_deleted_callback), sheet);
1299
1300       g_signal_connect (model, "rows_deleted",
1301                         G_CALLBACK (rows_inserted_deleted_callback), sheet);
1302
1303       g_signal_connect (model, "columns_inserted",
1304                         G_CALLBACK (columns_inserted_deleted_callback), sheet);
1305
1306       g_signal_connect (model, "columns_deleted",
1307                         G_CALLBACK (columns_inserted_deleted_callback), sheet);
1308     }
1309 }
1310
1311
1312 /* Call back for when the column titles have changed.
1313    FIRST is the first column changed.
1314    N_COLUMNS is the number of columns which have changed, or -1, which
1315    indicates that the column has changed to its right-most extremity
1316 */
1317 static void
1318 column_titles_changed (GtkWidget *w, gint first, gint n_columns, gpointer data)
1319 {
1320   GtkSheet *sheet = GTK_SHEET (data);
1321   gboolean extremity = FALSE;
1322
1323   if ( n_columns == -1 )
1324     {
1325       extremity = TRUE;
1326       n_columns = psppire_axis_unit_count (sheet->haxis) - 1 ;
1327     }
1328
1329   if ( extremity)
1330     gtk_sheet_column_title_button_draw (sheet, -1);
1331 }
1332
1333 void
1334 gtk_sheet_change_entry (GtkSheet *sheet, GtkType entry_type)
1335 {
1336   gint state;
1337
1338   g_return_if_fail (sheet != NULL);
1339   g_return_if_fail (GTK_IS_SHEET (sheet));
1340
1341   state = sheet->state;
1342
1343   if (sheet->state == GTK_SHEET_NORMAL)
1344     gtk_sheet_hide_active_cell (sheet);
1345
1346   sheet->entry_type = entry_type;
1347
1348   create_sheet_entry (sheet);
1349
1350   if (state == GTK_SHEET_NORMAL)
1351     {
1352       gtk_sheet_show_active_cell (sheet);
1353     }
1354
1355 }
1356
1357 void
1358 gtk_sheet_show_grid (GtkSheet *sheet, gboolean show)
1359 {
1360   g_return_if_fail (sheet != NULL);
1361   g_return_if_fail (GTK_IS_SHEET (sheet));
1362
1363   if (show == sheet->show_grid) return;
1364
1365   sheet->show_grid = show;
1366
1367   gtk_sheet_range_draw (sheet, NULL);
1368 }
1369
1370 gboolean
1371 gtk_sheet_grid_visible (GtkSheet *sheet)
1372 {
1373   g_return_val_if_fail (sheet != NULL, 0);
1374   g_return_val_if_fail (GTK_IS_SHEET (sheet), 0);
1375
1376   return sheet->show_grid;
1377 }
1378
1379 guint
1380 gtk_sheet_get_columns_count (GtkSheet *sheet)
1381 {
1382   g_return_val_if_fail (sheet != NULL, 0);
1383   g_return_val_if_fail (GTK_IS_SHEET (sheet), 0);
1384
1385   return psppire_axis_unit_count (sheet->haxis);
1386 }
1387
1388 static void
1389 gtk_sheet_set_column_width (GtkSheet *sheet,
1390                             gint column,
1391                             guint width);
1392
1393
1394 static void
1395 gtk_sheet_autoresize_column (GtkSheet *sheet, gint column)
1396 {
1397   gint text_width = 0;
1398   gint row;
1399
1400   g_return_if_fail (sheet != NULL);
1401   g_return_if_fail (GTK_IS_SHEET (sheet));
1402   if (column >= psppire_axis_unit_count (sheet->haxis) || column < 0) return;
1403
1404   for (row = 0; row < g_sheet_row_get_row_count (sheet->row_geometry); row++)
1405     {
1406       gchar *text = gtk_sheet_cell_get_text (sheet, row, column);
1407       if (text && strlen (text) > 0)
1408         {
1409           GtkSheetCellAttr attributes;
1410
1411           gtk_sheet_get_attributes (sheet, row, column, &attributes);
1412           if (attributes.is_visible)
1413             {
1414               gint width = STRING_WIDTH (GTK_WIDGET (sheet),
1415                                          attributes.font_desc,
1416                                          text)
1417                 + 2 * COLUMN_TITLES_HEIGHT + attributes.border.width;
1418               text_width = MAX (text_width, width);
1419             }
1420         }
1421       dispose_string (sheet, text);
1422     }
1423
1424   if (text_width > psppire_axis_unit_size (sheet->haxis, column) )
1425     {
1426       gtk_sheet_set_column_width (sheet, column, text_width);
1427     }
1428 }
1429
1430 void
1431 gtk_sheet_show_column_titles (GtkSheet *sheet)
1432 {
1433   if (sheet->column_titles_visible) return;
1434
1435   sheet->column_titles_visible = TRUE;
1436
1437   if (!GTK_WIDGET_REALIZED (GTK_WIDGET (sheet)))
1438     return;
1439
1440   gdk_window_show (sheet->column_title_window);
1441   gdk_window_move_resize (sheet->column_title_window,
1442                           sheet->column_title_area.x,
1443                           sheet->column_title_area.y,
1444                           sheet->column_title_area.width,
1445                           sheet->column_title_area.height);
1446
1447   adjust_scrollbars (sheet);
1448
1449   if (sheet->vadjustment)
1450     g_signal_emit_by_name (sheet->vadjustment,
1451                            "value_changed");
1452   size_allocate_global_button (sheet);
1453 }
1454
1455
1456 void
1457 gtk_sheet_show_row_titles (GtkSheet *sheet)
1458 {
1459   if (sheet->row_titles_visible) return;
1460
1461   sheet->row_titles_visible = TRUE;
1462
1463
1464   if (GTK_WIDGET_REALIZED (GTK_WIDGET (sheet)))
1465     {
1466       gdk_window_show (sheet->row_title_window);
1467       gdk_window_move_resize (sheet->row_title_window,
1468                               sheet->row_title_area.x,
1469                               sheet->row_title_area.y,
1470                               sheet->row_title_area.width,
1471                               sheet->row_title_area.height);
1472
1473       adjust_scrollbars (sheet);
1474     }
1475
1476   if (sheet->hadjustment)
1477     g_signal_emit_by_name (sheet->hadjustment,
1478                            "value_changed");
1479   size_allocate_global_button (sheet);
1480 }
1481
1482 void
1483 gtk_sheet_hide_column_titles (GtkSheet *sheet)
1484 {
1485   if (!sheet->column_titles_visible) return;
1486
1487   sheet->column_titles_visible = FALSE;
1488
1489   if (GTK_WIDGET_REALIZED (GTK_WIDGET (sheet)))
1490     {
1491       if (sheet->column_title_window)
1492         gdk_window_hide (sheet->column_title_window);
1493       if (GTK_WIDGET_VISIBLE (sheet->button))
1494         gtk_widget_hide (sheet->button);
1495
1496       adjust_scrollbars (sheet);
1497     }
1498
1499   if (sheet->vadjustment)
1500     g_signal_emit_by_name (sheet->vadjustment,
1501                            "value_changed");
1502 }
1503
1504 void
1505 gtk_sheet_hide_row_titles (GtkSheet *sheet)
1506 {
1507   if (!sheet->row_titles_visible) return;
1508
1509   sheet->row_titles_visible = FALSE;
1510
1511   if (GTK_WIDGET_REALIZED (GTK_WIDGET (sheet)))
1512     {
1513       if (sheet->row_title_window)
1514         gdk_window_hide (sheet->row_title_window);
1515
1516       if (GTK_WIDGET_VISIBLE (sheet->button))
1517         gtk_widget_hide (sheet->button);
1518
1519       adjust_scrollbars (sheet);
1520     }
1521
1522   if (sheet->hadjustment)
1523     g_signal_emit_by_name (sheet->hadjustment,
1524                            "value_changed");
1525 }
1526
1527
1528 /* Scroll the sheet so that the cell ROW, COLUMN is visible.
1529    If {ROW,COL}_ALIGN is zero, then the cell will be placed
1530    at the {top,left} of the sheet.  If it's 1, then it'll
1531    be placed at the {bottom,right}.
1532    ROW or COL may be -1, in which case scrolling in that dimension
1533    does not occur.
1534  */
1535 void
1536 gtk_sheet_moveto (GtkSheet *sheet,
1537                   gint row,
1538                   gint col,
1539                   gfloat row_align,
1540                   gfloat col_align)
1541 {
1542   gint width, height;
1543
1544   g_return_if_fail (row_align >= 0);
1545   g_return_if_fail (col_align >= 0);
1546
1547   g_return_if_fail (row_align <= 1);
1548   g_return_if_fail (col_align <= 1);
1549
1550   g_return_if_fail (col <
1551                     psppire_axis_unit_count (sheet->haxis));
1552   g_return_if_fail (row <
1553                     g_sheet_row_get_row_count (sheet->row_geometry));
1554
1555   gdk_drawable_get_size (sheet->sheet_window, &width, &height);
1556
1557
1558   if (row >= 0)
1559   {
1560     gint y =  g_sheet_row_start_pixel (sheet->row_geometry, row);
1561
1562     gtk_adjustment_set_value (sheet->vadjustment, y - height * row_align);
1563   }
1564
1565
1566   if (col >= 0)
1567   {
1568     gint x =  psppire_axis_pixel_start (sheet->haxis, col);
1569
1570     gtk_adjustment_set_value (sheet->hadjustment, x - width * col_align);
1571   }
1572 }
1573
1574
1575 static gboolean
1576 gtk_sheet_columns_resizable (GtkSheet *sheet)
1577 {
1578   g_return_val_if_fail (sheet != NULL, FALSE);
1579   g_return_val_if_fail (GTK_IS_SHEET (sheet), FALSE);
1580
1581   return sheet->columns_resizable;
1582 }
1583
1584
1585 static gboolean
1586 gtk_sheet_rows_resizable (GtkSheet *sheet)
1587 {
1588   g_return_val_if_fail (sheet != NULL, FALSE);
1589   g_return_val_if_fail (GTK_IS_SHEET (sheet), FALSE);
1590
1591   return sheet->rows_resizable;
1592 }
1593
1594
1595 void
1596 gtk_sheet_select_row (GtkSheet *sheet, gint row)
1597 {
1598   g_return_if_fail (sheet != NULL);
1599   g_return_if_fail (GTK_IS_SHEET (sheet));
1600
1601   if (row < 0 || row >= g_sheet_row_get_row_count (sheet->row_geometry))
1602     return;
1603
1604   if (sheet->state != GTK_SHEET_NORMAL)
1605     gtk_sheet_real_unselect_range (sheet, NULL);
1606
1607   sheet->state = GTK_SHEET_ROW_SELECTED;
1608   sheet->range.row0 = row;
1609   sheet->range.col0 = 0;
1610   sheet->range.rowi = row;
1611   sheet->range.coli = psppire_axis_unit_count (sheet->haxis) - 1;
1612   sheet->active_cell.row = row;
1613   sheet->active_cell.col = 0;
1614
1615   g_signal_emit (sheet, sheet_signals[SELECT_ROW], 0, row);
1616   gtk_sheet_real_select_range (sheet, NULL);
1617 }
1618
1619
1620 void
1621 gtk_sheet_select_column (GtkSheet *sheet, gint column)
1622 {
1623   g_return_if_fail (sheet != NULL);
1624   g_return_if_fail (GTK_IS_SHEET (sheet));
1625
1626   if (column < 0 || column >= psppire_axis_unit_count (sheet->haxis))
1627     return;
1628
1629   if (sheet->state != GTK_SHEET_NORMAL)
1630     gtk_sheet_real_unselect_range (sheet, NULL);
1631
1632   sheet->state = GTK_SHEET_COLUMN_SELECTED;
1633   sheet->range.row0 = 0;
1634   sheet->range.col0 = column;
1635   sheet->range.rowi = g_sheet_row_get_row_count (sheet->row_geometry) - 1;
1636   sheet->range.coli = column;
1637   sheet->active_cell.row = 0;
1638   sheet->active_cell.col = column;
1639
1640   g_signal_emit (sheet, sheet_signals[SELECT_COLUMN], 0, column);
1641   gtk_sheet_real_select_range (sheet, NULL);
1642 }
1643
1644
1645
1646
1647 static gboolean
1648 gtk_sheet_range_isvisible (const GtkSheet *sheet,
1649                            GtkSheetRange range)
1650 {
1651   g_return_val_if_fail (sheet != NULL, FALSE);
1652
1653   if (range.row0 < 0 || range.row0 >= g_sheet_row_get_row_count (sheet->row_geometry))
1654     return FALSE;
1655
1656   if (range.rowi < 0 || range.rowi >= g_sheet_row_get_row_count (sheet->row_geometry))
1657     return FALSE;
1658
1659   if (range.col0 < 0 || range.col0 >= psppire_axis_unit_count (sheet->haxis))
1660     return FALSE;
1661
1662   if (range.coli < 0 || range.coli >= psppire_axis_unit_count (sheet->haxis))
1663     return FALSE;
1664
1665   if (range.rowi < min_visible_row (sheet))
1666     return FALSE;
1667
1668   if (range.row0 > max_visible_row (sheet))
1669     return FALSE;
1670
1671   if (range.coli < min_visible_column (sheet))
1672     return FALSE;
1673
1674   if (range.col0 > max_visible_column (sheet))
1675     return FALSE;
1676
1677   return TRUE;
1678 }
1679
1680 static gboolean
1681 gtk_sheet_cell_isvisible (GtkSheet *sheet,
1682                           gint row, gint column)
1683 {
1684   GtkSheetRange range;
1685
1686   range.row0 = row;
1687   range.col0 = column;
1688   range.rowi = row;
1689   range.coli = column;
1690
1691   return gtk_sheet_range_isvisible (sheet, range);
1692 }
1693
1694 void
1695 gtk_sheet_get_visible_range (GtkSheet *sheet, GtkSheetRange *range)
1696 {
1697   g_return_if_fail (sheet != NULL);
1698   g_return_if_fail (GTK_IS_SHEET (sheet)) ;
1699   g_return_if_fail (range != NULL);
1700
1701   range->row0 = min_visible_row (sheet);
1702   range->col0 = min_visible_column (sheet);
1703   range->rowi = max_visible_row (sheet);
1704   range->coli = max_visible_column (sheet);
1705 }
1706
1707
1708 static void
1709 gtk_sheet_set_scroll_adjustments (GtkSheet *sheet,
1710                                   GtkAdjustment *hadjustment,
1711                                   GtkAdjustment *vadjustment)
1712 {
1713   if ( sheet->vadjustment != vadjustment )
1714     {
1715       if (sheet->vadjustment)
1716         g_object_unref (sheet->vadjustment);
1717       sheet->vadjustment = vadjustment;
1718       g_object_ref (vadjustment);
1719
1720       g_signal_connect (sheet->vadjustment, "value_changed",
1721                         G_CALLBACK (vadjustment_value_changed),
1722                         sheet);
1723     }
1724
1725   if ( sheet->hadjustment != hadjustment )
1726     {
1727       if (sheet->hadjustment)
1728         g_object_unref (sheet->hadjustment);
1729       sheet->hadjustment = hadjustment;
1730       g_object_ref (hadjustment);
1731
1732       g_signal_connect (sheet->hadjustment, "value_changed",
1733                         G_CALLBACK (hadjustment_value_changed),
1734                         sheet);
1735     }
1736 }
1737
1738 static void
1739 gtk_sheet_finalize (GObject *object)
1740 {
1741   GtkSheet *sheet;
1742
1743   g_return_if_fail (object != NULL);
1744   g_return_if_fail (GTK_IS_SHEET (object));
1745
1746   sheet = GTK_SHEET (object);
1747
1748   if (G_OBJECT_CLASS (parent_class)->finalize)
1749     (*G_OBJECT_CLASS (parent_class)->finalize) (object);
1750 }
1751
1752 static void
1753 gtk_sheet_dispose  (GObject *object)
1754 {
1755   GtkSheet *sheet = GTK_SHEET (object);
1756
1757   g_return_if_fail (object != NULL);
1758   g_return_if_fail (GTK_IS_SHEET (object));
1759
1760   if ( sheet->dispose_has_run )
1761     return ;
1762
1763   sheet->dispose_has_run = TRUE;
1764
1765   if (sheet->model) g_object_unref (sheet->model);
1766   if (sheet->row_geometry) g_object_unref (sheet->row_geometry);
1767   if (sheet->haxis) g_object_unref (sheet->haxis);
1768
1769   g_object_unref (sheet->entry_container);
1770   sheet->entry_container = NULL;
1771
1772   g_object_unref (sheet->button);
1773   sheet->button = NULL;
1774
1775   /* unref adjustments */
1776   if (sheet->hadjustment)
1777     {
1778       g_signal_handlers_disconnect_matched (sheet->hadjustment,
1779                                             G_SIGNAL_MATCH_DATA,
1780                                             0, 0, 0, 0,
1781                                             sheet);
1782
1783       g_object_unref (sheet->hadjustment);
1784       sheet->hadjustment = NULL;
1785     }
1786
1787   if (sheet->vadjustment)
1788     {
1789       g_signal_handlers_disconnect_matched (sheet->vadjustment,
1790                                             G_SIGNAL_MATCH_DATA,
1791                                             0, 0, 0, 0,
1792                                             sheet);
1793
1794       g_object_unref (sheet->vadjustment);
1795
1796       sheet->vadjustment = NULL;
1797     }
1798
1799   if (G_OBJECT_CLASS (parent_class)->dispose)
1800     (*G_OBJECT_CLASS (parent_class)->dispose) (object);
1801 }
1802
1803 static void
1804 gtk_sheet_style_set (GtkWidget *widget,
1805                      GtkStyle *previous_style)
1806 {
1807   GtkSheet *sheet;
1808
1809   g_return_if_fail (widget != NULL);
1810   g_return_if_fail (GTK_IS_SHEET (widget));
1811
1812   if (GTK_WIDGET_CLASS (parent_class)->style_set)
1813     (*GTK_WIDGET_CLASS (parent_class)->style_set) (widget, previous_style);
1814
1815   sheet = GTK_SHEET (widget);
1816
1817   if (GTK_WIDGET_REALIZED (widget))
1818     {
1819       gtk_style_set_background (widget->style, widget->window, widget->state);
1820     }
1821
1822 }
1823
1824 static void
1825 gtk_sheet_realize (GtkWidget *widget)
1826 {
1827   GtkSheet *sheet;
1828   GdkWindowAttr attributes;
1829   const gint attributes_mask =
1830     GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP | GDK_WA_CURSOR;
1831
1832   GdkGCValues values, auxvalues;
1833   GdkColormap *colormap;
1834   GdkDisplay *display;
1835
1836   g_return_if_fail (widget != NULL);
1837   g_return_if_fail (GTK_IS_SHEET (widget));
1838
1839   sheet = GTK_SHEET (widget);
1840
1841   GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
1842
1843   colormap = gtk_widget_get_colormap (widget);
1844   display = gtk_widget_get_display (widget);
1845
1846   attributes.window_type = GDK_WINDOW_CHILD;
1847   attributes.x = widget->allocation.x;
1848   attributes.y = widget->allocation.y;
1849   attributes.width = widget->allocation.width;
1850   attributes.height = widget->allocation.height;
1851   attributes.wclass = GDK_INPUT_OUTPUT;
1852
1853   attributes.visual = gtk_widget_get_visual (widget);
1854   attributes.colormap = colormap;
1855
1856   attributes.event_mask = gtk_widget_get_events (widget);
1857   attributes.event_mask |= (GDK_EXPOSURE_MASK |
1858                             GDK_BUTTON_PRESS_MASK |
1859                             GDK_BUTTON_RELEASE_MASK |
1860                             GDK_KEY_PRESS_MASK |
1861                             GDK_ENTER_NOTIFY_MASK |
1862                             GDK_LEAVE_NOTIFY_MASK |
1863                             GDK_POINTER_MOTION_MASK |
1864                             GDK_POINTER_MOTION_HINT_MASK);
1865
1866   attributes.cursor = gdk_cursor_new_for_display (display, GDK_TOP_LEFT_ARROW);
1867
1868   /* main window */
1869   widget->window = gdk_window_new (gtk_widget_get_parent_window (widget), &attributes, attributes_mask);
1870
1871   gdk_window_set_user_data (widget->window, sheet);
1872
1873   widget->style = gtk_style_attach (widget->style, widget->window);
1874
1875   gtk_style_set_background (widget->style, widget->window, GTK_STATE_NORMAL);
1876
1877   gdk_color_parse ("white", &sheet->color[BG_COLOR]);
1878   gdk_colormap_alloc_color (colormap, &sheet->color[BG_COLOR], FALSE,
1879                             TRUE);
1880   gdk_color_parse ("gray", &sheet->color[GRID_COLOR]);
1881   gdk_colormap_alloc_color (colormap, &sheet->color[GRID_COLOR], FALSE,
1882                             TRUE);
1883
1884   attributes.x = 0;
1885   attributes.y = 0;
1886   attributes.width = sheet->column_title_area.width;
1887   attributes.height = sheet->column_title_area.height;
1888
1889
1890   /* column - title window */
1891   sheet->column_title_window =
1892     gdk_window_new (widget->window, &attributes, attributes_mask);
1893   gdk_window_set_user_data (sheet->column_title_window, sheet);
1894   gtk_style_set_background (widget->style, sheet->column_title_window,
1895                             GTK_STATE_NORMAL);
1896
1897
1898   attributes.x = 0;
1899   attributes.y = 0;
1900   attributes.width = sheet->row_title_area.width;
1901   attributes.height = sheet->row_title_area.height;
1902
1903   /* row - title window */
1904   sheet->row_title_window = gdk_window_new (widget->window,
1905                                             &attributes, attributes_mask);
1906   gdk_window_set_user_data (sheet->row_title_window, sheet);
1907   gtk_style_set_background (widget->style, sheet->row_title_window,
1908                             GTK_STATE_NORMAL);
1909
1910   /* sheet - window */
1911   attributes.cursor = gdk_cursor_new_for_display (display, GDK_PLUS);
1912
1913   attributes.x = 0;
1914   attributes.y = 0;
1915
1916   sheet->sheet_window = gdk_window_new (widget->window,
1917                                         &attributes, attributes_mask);
1918   gdk_window_set_user_data (sheet->sheet_window, sheet);
1919
1920   gdk_cursor_unref (attributes.cursor);
1921
1922   gdk_window_set_background (sheet->sheet_window, &widget->style->white);
1923   gdk_window_show (sheet->sheet_window);
1924
1925   /* GCs */
1926   sheet->fg_gc = gdk_gc_new (widget->window);
1927   sheet->bg_gc = gdk_gc_new (widget->window);
1928
1929   gdk_gc_get_values (sheet->fg_gc, &auxvalues);
1930
1931   values.foreground = widget->style->white;
1932   values.function = GDK_INVERT;
1933   values.subwindow_mode = GDK_INCLUDE_INFERIORS;
1934   values.line_width = 3;
1935
1936   sheet->xor_gc = gdk_gc_new_with_values (widget->window,
1937                                           &values,
1938                                           GDK_GC_FOREGROUND |
1939                                           GDK_GC_FUNCTION |
1940                                           GDK_GC_SUBWINDOW |
1941                                           GDK_GC_LINE_WIDTH
1942                                           );
1943
1944
1945   gtk_widget_set_parent_window (sheet->entry_widget, sheet->sheet_window);
1946   gtk_widget_set_parent (sheet->entry_widget, GTK_WIDGET (sheet));
1947
1948   gtk_widget_set_parent_window (sheet->button, sheet->sheet_window);
1949   gtk_widget_set_parent (sheet->button, GTK_WIDGET (sheet));
1950
1951
1952   sheet->cursor_drag = gdk_cursor_new_for_display (display, GDK_PLUS);
1953
1954   if (sheet->column_titles_visible)
1955     gdk_window_show (sheet->column_title_window);
1956   if (sheet->row_titles_visible)
1957     gdk_window_show (sheet->row_title_window);
1958
1959   sheet->hover_window = create_hover_window ();
1960
1961   draw_row_title_buttons (sheet);
1962   draw_column_title_buttons (sheet);
1963
1964   gtk_sheet_update_primary_selection (sheet);
1965 }
1966
1967 static void
1968 create_global_button (GtkSheet *sheet)
1969 {
1970   sheet->button = gtk_button_new_with_label (" ");
1971
1972   g_object_ref_sink (sheet->button);
1973
1974   g_signal_connect (sheet->button,
1975                     "pressed",
1976                     G_CALLBACK (global_button_clicked),
1977                     sheet);
1978 }
1979
1980 static void
1981 size_allocate_global_button (GtkSheet *sheet)
1982 {
1983   GtkAllocation allocation;
1984
1985   if (!sheet->column_titles_visible) return;
1986   if (!sheet->row_titles_visible) return;
1987
1988   gtk_widget_size_request (sheet->button, NULL);
1989
1990   allocation.x = 0;
1991   allocation.y = 0;
1992   allocation.width = sheet->row_title_area.width;
1993   allocation.height = sheet->column_title_area.height;
1994
1995   gtk_widget_size_allocate (sheet->button, &allocation);
1996   gtk_widget_show (sheet->button);
1997 }
1998
1999 static void
2000 global_button_clicked (GtkWidget *widget, gpointer data)
2001 {
2002   gtk_sheet_click_cell (GTK_SHEET (data), -1, -1);
2003   gtk_widget_grab_focus (GTK_WIDGET (data));
2004 }
2005
2006
2007 static void
2008 gtk_sheet_unrealize (GtkWidget *widget)
2009 {
2010   GtkSheet *sheet;
2011
2012   g_return_if_fail (widget != NULL);
2013   g_return_if_fail (GTK_IS_SHEET (widget));
2014
2015   sheet = GTK_SHEET (widget);
2016
2017   gdk_cursor_unref (sheet->cursor_drag);
2018   sheet->cursor_drag = NULL;
2019
2020   gdk_colormap_free_colors (gtk_widget_get_colormap (widget),
2021                             sheet->color, n_COLORS);
2022
2023   g_object_unref (sheet->xor_gc);
2024   g_object_unref (sheet->fg_gc);
2025   g_object_unref (sheet->bg_gc);
2026
2027   destroy_hover_window (sheet->hover_window);
2028
2029   gdk_window_destroy (sheet->sheet_window);
2030   gdk_window_destroy (sheet->column_title_window);
2031   gdk_window_destroy (sheet->row_title_window);
2032
2033   gtk_widget_unparent (sheet->entry_widget);
2034   if (sheet->button != NULL)
2035     gtk_widget_unparent (sheet->button);
2036
2037   if (GTK_WIDGET_CLASS (parent_class)->unrealize)
2038     (* GTK_WIDGET_CLASS (parent_class)->unrealize) (widget);
2039 }
2040
2041 static void
2042 gtk_sheet_map (GtkWidget *widget)
2043 {
2044   GtkSheet *sheet = GTK_SHEET (widget);
2045
2046   g_return_if_fail (widget != NULL);
2047   g_return_if_fail (GTK_IS_SHEET (widget));
2048
2049   if (!GTK_WIDGET_MAPPED (widget))
2050     {
2051       GTK_WIDGET_SET_FLAGS (widget, GTK_MAPPED);
2052
2053       gdk_window_show (widget->window);
2054       gdk_window_show (sheet->sheet_window);
2055
2056       if (sheet->column_titles_visible)
2057         {
2058           draw_column_title_buttons (sheet);
2059           gdk_window_show (sheet->column_title_window);
2060         }
2061       if (sheet->row_titles_visible)
2062         {
2063           draw_row_title_buttons (sheet);
2064           gdk_window_show (sheet->row_title_window);
2065         }
2066
2067       if (!GTK_WIDGET_MAPPED (sheet->entry_widget)
2068           && sheet->active_cell.row >= 0
2069           && sheet->active_cell.col >= 0 )
2070         {
2071           gtk_widget_show (sheet->entry_widget);
2072           gtk_widget_map (sheet->entry_widget);
2073         }
2074
2075       if (GTK_WIDGET_VISIBLE (sheet->button) &&
2076           !GTK_WIDGET_MAPPED (sheet->button))
2077         {
2078           gtk_widget_show (sheet->button);
2079           gtk_widget_map (sheet->button);
2080         }
2081
2082       if (GTK_BIN (sheet->button)->child)
2083         if (GTK_WIDGET_VISIBLE (GTK_BIN (sheet->button)->child) &&
2084             !GTK_WIDGET_MAPPED (GTK_BIN (sheet->button)->child))
2085           gtk_widget_map (GTK_BIN (sheet->button)->child);
2086
2087       gtk_sheet_range_draw (sheet, NULL);
2088       change_active_cell (sheet,
2089                      sheet->active_cell.row,
2090                      sheet->active_cell.col);
2091     }
2092 }
2093
2094 static void
2095 gtk_sheet_unmap (GtkWidget *widget)
2096 {
2097   GtkSheet *sheet = GTK_SHEET (widget);
2098
2099   if (!GTK_WIDGET_MAPPED (widget))
2100     return;
2101
2102   GTK_WIDGET_UNSET_FLAGS (widget, GTK_MAPPED);
2103
2104   gdk_window_hide (sheet->sheet_window);
2105   if (sheet->column_titles_visible)
2106     gdk_window_hide (sheet->column_title_window);
2107   if (sheet->row_titles_visible)
2108     gdk_window_hide (sheet->row_title_window);
2109   gdk_window_hide (widget->window);
2110
2111   if (GTK_WIDGET_MAPPED (sheet->entry_widget))
2112     gtk_widget_unmap (sheet->entry_widget);
2113
2114   if (GTK_WIDGET_MAPPED (sheet->button))
2115     gtk_widget_unmap (sheet->button);
2116 }
2117
2118
2119 static void
2120 gtk_sheet_cell_draw (GtkSheet *sheet, gint row, gint col)
2121 {
2122   PangoLayout *layout;
2123   PangoRectangle text;
2124   gint font_height;
2125
2126   gchar *label;
2127
2128   GtkSheetCellAttr attributes;
2129   GdkRectangle area;
2130
2131   g_return_if_fail (sheet != NULL);
2132
2133   /* bail now if we aren't yet drawable */
2134   if (!GTK_WIDGET_DRAWABLE (sheet)) return;
2135
2136   if (row < 0 ||
2137       row >= g_sheet_row_get_row_count (sheet->row_geometry))
2138     return;
2139
2140   if (col < 0 ||
2141       col >= psppire_axis_unit_count (sheet->haxis))
2142     return;
2143
2144   gtk_sheet_get_attributes (sheet, row, col, &attributes);
2145
2146   /* select GC for background rectangle */
2147   gdk_gc_set_foreground (sheet->fg_gc, &attributes.foreground);
2148   gdk_gc_set_foreground (sheet->bg_gc, &attributes.background);
2149
2150   rectangle_from_cell (sheet, row, col, &area);
2151
2152   gdk_gc_set_line_attributes (sheet->fg_gc, 1, 0, 0, 0);
2153
2154   if (sheet->show_grid)
2155     {
2156       gdk_gc_set_foreground (sheet->bg_gc, &sheet->color[GRID_COLOR]);
2157
2158       gdk_draw_rectangle (sheet->sheet_window,
2159                           sheet->bg_gc,
2160                           FALSE,
2161                           area.x, area.y,
2162                           area.width, area.height);
2163     }
2164
2165   //  gtk_sheet_cell_draw_label (sheet, row, col);
2166
2167
2168   label = gtk_sheet_cell_get_text (sheet, row, col);
2169   if (NULL == label)
2170     return;
2171
2172
2173   layout = gtk_widget_create_pango_layout (GTK_WIDGET (sheet), label);
2174   dispose_string (sheet, label);
2175   pango_layout_set_font_description (layout, attributes.font_desc);
2176
2177
2178   pango_layout_get_pixel_extents (layout, NULL, &text);
2179
2180   gdk_gc_set_clip_rectangle (sheet->fg_gc, &area);
2181
2182   font_height = pango_font_description_get_size (attributes.font_desc);
2183   if ( !pango_font_description_get_size_is_absolute (attributes.font_desc))
2184     font_height /= PANGO_SCALE;
2185
2186   /* Centre the text vertically */
2187   area.y += (area.height - font_height) / 2.0;
2188
2189   switch (attributes.justification)
2190     {
2191     case GTK_JUSTIFY_RIGHT:
2192       area.x += area.width - text.width;
2193       break;
2194     case GTK_JUSTIFY_CENTER:
2195       area.x += (area.width - text.width) / 2.0;
2196       break;
2197     case GTK_JUSTIFY_LEFT:
2198       /* Do nothing */
2199       break;
2200     default:
2201       g_critical ("Unhandled justification %d in column %d\n",
2202                  attributes.justification, col);
2203       break;
2204     }
2205
2206   gdk_draw_layout (sheet->sheet_window, sheet->fg_gc,
2207                    area.x,
2208                    area.y,
2209                    layout);
2210
2211   gdk_gc_set_clip_rectangle (sheet->fg_gc, NULL);
2212   g_object_unref (layout);
2213 }
2214
2215
2216
2217 static void
2218 gtk_sheet_range_draw (GtkSheet *sheet, const GtkSheetRange *range)
2219 {
2220   gint i, j;
2221
2222   GdkRectangle area;
2223   GtkSheetRange drawing_range;
2224
2225   g_return_if_fail (sheet != NULL);
2226   g_return_if_fail (GTK_SHEET (sheet));
2227
2228   if (!GTK_WIDGET_DRAWABLE (GTK_WIDGET (sheet))) return;
2229   if (!GTK_WIDGET_REALIZED (GTK_WIDGET (sheet))) return;
2230   if (!GTK_WIDGET_MAPPED (GTK_WIDGET (sheet))) return;
2231
2232   if (range == NULL)
2233     {
2234       drawing_range.row0 = min_visible_row (sheet);
2235       drawing_range.col0 = min_visible_column (sheet);
2236       drawing_range.rowi = MIN (max_visible_row (sheet),
2237                                 g_sheet_row_get_row_count (sheet->row_geometry) - 1);
2238       drawing_range.coli = max_visible_column (sheet);
2239       gdk_drawable_get_size (sheet->sheet_window, &area.width, &area.height);
2240       area.x = area.y = 0;
2241     }
2242   else
2243     {
2244       drawing_range.row0 = MAX (range->row0, min_visible_row (sheet));
2245       drawing_range.col0 = MAX (range->col0, min_visible_column (sheet));
2246       drawing_range.rowi = MIN (range->rowi, max_visible_row (sheet));
2247       drawing_range.coli = MIN (range->coli, max_visible_column (sheet));
2248
2249
2250       rectangle_from_range (sheet, &drawing_range, &area);
2251     }
2252
2253
2254   gdk_draw_rectangle (sheet->sheet_window,
2255                       GTK_WIDGET (sheet)->style->white_gc,
2256                       TRUE,
2257                       area.x, area.y,
2258                       area.width, area.height);
2259
2260   for (i = drawing_range.row0; i <= drawing_range.rowi; i++)
2261     for (j = drawing_range.col0; j <= drawing_range.coli; j++)
2262       {
2263         gtk_sheet_cell_draw (sheet, i, j);
2264       }
2265
2266   if (sheet->state != GTK_SHEET_NORMAL &&
2267       gtk_sheet_range_isvisible (sheet, sheet->range))
2268     gtk_sheet_range_draw_selection (sheet, drawing_range);
2269
2270   if (sheet->state == GTK_STATE_NORMAL &&
2271       sheet->active_cell.row >= drawing_range.row0 &&
2272       sheet->active_cell.row <= drawing_range.rowi &&
2273       sheet->active_cell.col >= drawing_range.col0 &&
2274       sheet->active_cell.col <= drawing_range.coli)
2275     gtk_sheet_show_active_cell (sheet);
2276 }
2277
2278 static void
2279 gtk_sheet_range_draw_selection (GtkSheet *sheet, GtkSheetRange range)
2280 {
2281   GdkRectangle area;
2282   gint i, j;
2283   GtkSheetRange aux;
2284
2285   if (range.col0 > sheet->range.coli || range.coli < sheet->range.col0 ||
2286       range.row0 > sheet->range.rowi || range.rowi < sheet->range.row0)
2287     return;
2288
2289   if (!gtk_sheet_range_isvisible (sheet, range)) return;
2290   if (!GTK_WIDGET_REALIZED (GTK_WIDGET (sheet))) return;
2291
2292   aux = range;
2293
2294   range.col0 = MAX (sheet->range.col0, range.col0);
2295   range.coli = MIN (sheet->range.coli, range.coli);
2296   range.row0 = MAX (sheet->range.row0, range.row0);
2297   range.rowi = MIN (sheet->range.rowi, range.rowi);
2298
2299   range.col0 = MAX (range.col0, min_visible_column (sheet));
2300   range.coli = MIN (range.coli, max_visible_column (sheet));
2301   range.row0 = MAX (range.row0, min_visible_row (sheet));
2302   range.rowi = MIN (range.rowi, max_visible_row (sheet));
2303
2304   for (i = range.row0; i <= range.rowi; i++)
2305     {
2306       for (j = range.col0; j <= range.coli; j++)
2307         {
2308           if (gtk_sheet_cell_get_state (sheet, i, j) == GTK_STATE_SELECTED)
2309             {
2310               rectangle_from_cell (sheet, i, j, &area);
2311
2312               if (i == sheet->range.row0)
2313                 {
2314                   area.y = area.y + 2;
2315                   area.height = area.height - 2;
2316                 }
2317               if (i == sheet->range.rowi) area.height = area.height - 3;
2318               if (j == sheet->range.col0)
2319                 {
2320                   area.x = area.x + 2;
2321                   area.width = area.width - 2;
2322                 }
2323               if (j == sheet->range.coli) area.width = area.width - 3;
2324
2325               if (i != sheet->active_cell.row || j != sheet->active_cell.col)
2326                 {
2327                   gdk_draw_rectangle (sheet->sheet_window,
2328                                       sheet->xor_gc,
2329                                       TRUE,
2330                                       area.x + 1, area.y + 1,
2331                                       area.width, area.height);
2332                 }
2333             }
2334
2335         }
2336     }
2337
2338   gtk_sheet_draw_border (sheet, sheet->range);
2339 }
2340
2341 static void gtk_sheet_set_cell (GtkSheet *sheet, gint row, gint col,
2342                                 GtkJustification justification,
2343                                 const gchar *text);
2344
2345
2346 static inline gint
2347 safe_strcmp (const gchar *s1, const gchar *s2)
2348 {
2349   if ( !s1 && !s2) return 0;
2350   if ( !s1) return - 1;
2351   if ( !s2) return +1;
2352   return strcmp (s1, s2);
2353 }
2354
2355 static void
2356 gtk_sheet_set_cell (GtkSheet *sheet, gint row, gint col,
2357                     GtkJustification justification,
2358                     const gchar *text)
2359 {
2360   GSheetModel *model ;
2361   gchar *old_text ;
2362
2363   g_return_if_fail (sheet != NULL);
2364   g_return_if_fail (GTK_IS_SHEET (sheet));
2365
2366   if (col >= psppire_axis_unit_count (sheet->haxis)
2367       || row >= g_sheet_row_get_row_count (sheet->row_geometry))
2368     return;
2369
2370   if (col < 0 || row < 0) return;
2371
2372   model = gtk_sheet_get_model (sheet);
2373
2374   old_text = g_sheet_model_get_string (model, row, col);
2375
2376   if ( g_sheet_model_free_strings (model))
2377     g_free (old_text);
2378 }
2379
2380
2381 void
2382 gtk_sheet_cell_clear (GtkSheet *sheet, gint row, gint column)
2383 {
2384   GtkSheetRange range;
2385
2386   g_return_if_fail (sheet != NULL);
2387   g_return_if_fail (GTK_IS_SHEET (sheet));
2388   if (column >= psppire_axis_unit_count (sheet->haxis) ||
2389       row >= g_sheet_row_get_row_count (sheet->row_geometry)) return;
2390
2391   if (column < 0 || row < 0) return;
2392
2393   range.row0 = row;
2394   range.rowi = row;
2395   range.col0 = min_visible_column (sheet);
2396   range.coli = max_visible_column (sheet);
2397
2398   gtk_sheet_real_cell_clear (sheet, row, column);
2399
2400   gtk_sheet_range_draw (sheet, &range);
2401 }
2402
2403 static void
2404 gtk_sheet_real_cell_clear (GtkSheet *sheet, gint row, gint column)
2405 {
2406   GSheetModel *model = gtk_sheet_get_model (sheet);
2407
2408   gchar *old_text = gtk_sheet_cell_get_text (sheet, row, column);
2409
2410   if (old_text && strlen (old_text) > 0 )
2411     {
2412       g_sheet_model_datum_clear (model, row, column);
2413     }
2414
2415   dispose_string (sheet, old_text);
2416 }
2417
2418 gchar *
2419 gtk_sheet_cell_get_text (const GtkSheet *sheet, gint row, gint col)
2420 {
2421   GSheetModel *model;
2422   g_return_val_if_fail (sheet != NULL, NULL);
2423   g_return_val_if_fail (GTK_IS_SHEET (sheet), NULL);
2424
2425   if (col >= psppire_axis_unit_count (sheet->haxis) || row >= g_sheet_row_get_row_count (sheet->row_geometry))
2426     return NULL;
2427   if (col < 0 || row < 0) return NULL;
2428
2429   model = gtk_sheet_get_model (sheet);
2430
2431   if ( !model )
2432     return NULL;
2433
2434   return g_sheet_model_get_string (model, row, col);
2435 }
2436
2437
2438 static GtkStateType
2439 gtk_sheet_cell_get_state (GtkSheet *sheet, gint row, gint col)
2440 {
2441   gint state;
2442   GtkSheetRange *range;
2443
2444   g_return_val_if_fail (sheet != NULL, 0);
2445   g_return_val_if_fail (GTK_IS_SHEET (sheet), 0);
2446   if (col >= psppire_axis_unit_count (sheet->haxis) || row >= g_sheet_row_get_row_count (sheet->row_geometry)) return 0;
2447   if (col < 0 || row < 0) return 0;
2448
2449   state = sheet->state;
2450   range = &sheet->range;
2451
2452   switch (state)
2453     {
2454     case GTK_SHEET_NORMAL:
2455       return GTK_STATE_NORMAL;
2456       break;
2457     case GTK_SHEET_ROW_SELECTED:
2458       if (row >= range->row0 && row <= range->rowi)
2459         return GTK_STATE_SELECTED;
2460       break;
2461     case GTK_SHEET_COLUMN_SELECTED:
2462       if (col >= range->col0 && col <= range->coli)
2463         return GTK_STATE_SELECTED;
2464       break;
2465     case GTK_SHEET_RANGE_SELECTED:
2466       if (row >= range->row0 && row <= range->rowi && \
2467           col >= range->col0 && col <= range->coli)
2468         return GTK_STATE_SELECTED;
2469       break;
2470     }
2471   return GTK_STATE_NORMAL;
2472 }
2473
2474 /* Convert X, Y (in pixels) to *ROW, *COLUMN
2475    If the function returns FALSE, then the results will be unreliable.
2476 */
2477 static gboolean
2478 gtk_sheet_get_pixel_info (GtkSheet *sheet,
2479                           gint x,
2480                           gint y,
2481                           gint *row,
2482                           gint *column)
2483 {
2484   gint trow, tcol;
2485   *row = -G_MAXINT;
2486   *column = -G_MAXINT;
2487
2488   g_return_val_if_fail (sheet != NULL, 0);
2489   g_return_val_if_fail (GTK_IS_SHEET (sheet), 0);
2490
2491   /* bounds checking, return false if the user clicked
2492      on a blank area */
2493   if (y < 0)
2494     return FALSE;
2495
2496   if (x < 0)
2497     return FALSE;
2498
2499   if ( sheet->column_titles_visible)
2500     y -= sheet->column_title_area.height;
2501
2502   y += sheet->vadjustment->value;
2503
2504   if ( y < 0 && sheet->column_titles_visible)
2505     {
2506       trow = -1;
2507     }
2508   else
2509     {
2510       trow = yyy_row_ypixel_to_row (sheet, y);
2511       if (trow > g_sheet_row_get_row_count (sheet->row_geometry))
2512         return FALSE;
2513     }
2514
2515   *row = trow;
2516
2517   if ( sheet->row_titles_visible)
2518     x -= sheet->row_title_area.width;
2519
2520   x += sheet->hadjustment->value;
2521
2522   if ( x < 0 && sheet->row_titles_visible)
2523     {
2524       tcol = -1;
2525     }
2526   else
2527     {
2528       tcol = column_from_xpixel (sheet, x);
2529       if (tcol > psppire_axis_unit_count (sheet->haxis))
2530         return FALSE;
2531     }
2532
2533   *column = tcol;
2534
2535   return TRUE;
2536 }
2537
2538 gboolean
2539 gtk_sheet_get_cell_area (GtkSheet *sheet,
2540                          gint row,
2541                          gint column,
2542                          GdkRectangle *area)
2543 {
2544   g_return_val_if_fail (sheet != NULL, 0);
2545   g_return_val_if_fail (GTK_IS_SHEET (sheet), 0);
2546
2547   if (row >= g_sheet_row_get_row_count (sheet->row_geometry) || column >= psppire_axis_unit_count (sheet->haxis))
2548     return FALSE;
2549
2550   area->x = (column == -1) ? 0 : psppire_axis_pixel_start (sheet->haxis, column);
2551   area->y = (row == -1)    ? 0 : g_sheet_row_start_pixel (sheet->row_geometry, row);
2552
2553   area->width= (column == -1) ? sheet->row_title_area.width
2554     : psppire_axis_unit_size (sheet->haxis, column);
2555
2556   area->height= (row == -1) ? sheet->column_title_area.height
2557     : g_sheet_row_get_height (sheet->row_geometry, row);
2558
2559   return TRUE;
2560 }
2561
2562 void
2563 gtk_sheet_set_active_cell (GtkSheet *sheet, gint row, gint col)
2564 {
2565   g_return_if_fail (sheet != NULL);
2566   g_return_if_fail (GTK_IS_SHEET (sheet));
2567
2568   if (row < -1 || col < -1)
2569     return;
2570
2571   if (row >= g_sheet_row_get_row_count (sheet->row_geometry)
2572       ||
2573       col >= psppire_axis_unit_count (sheet->haxis))
2574     return;
2575
2576   sheet->active_cell.row = row;
2577   sheet->active_cell.col = col;
2578
2579   if (!GTK_WIDGET_REALIZED (GTK_WIDGET (sheet)))
2580     return;
2581
2582   if ( row == -1 || col == -1)
2583     {
2584       gtk_sheet_hide_active_cell (sheet);
2585       return;
2586     }
2587
2588   change_active_cell (sheet, row, col);
2589 }
2590
2591 void
2592 gtk_sheet_get_active_cell (GtkSheet *sheet, gint *row, gint *column)
2593 {
2594   g_return_if_fail (sheet != NULL);
2595   g_return_if_fail (GTK_IS_SHEET (sheet));
2596
2597   if ( row ) *row = sheet->active_cell.row;
2598   if (column) *column = sheet->active_cell.col;
2599 }
2600
2601 static void
2602 gtk_sheet_entry_changed (GtkWidget *widget, gpointer data)
2603 {
2604   GtkSheet *sheet;
2605   gint row, col;
2606   const char *text;
2607   GtkJustification justification;
2608   GtkSheetCellAttr attributes;
2609
2610   g_return_if_fail (data != NULL);
2611   g_return_if_fail (GTK_IS_SHEET (data));
2612
2613   sheet = GTK_SHEET (data);
2614
2615   if (!GTK_WIDGET_VISIBLE (widget)) return;
2616   if (sheet->state != GTK_STATE_NORMAL) return;
2617
2618   row = sheet->active_cell.row;
2619   col = sheet->active_cell.col;
2620
2621   if (row < 0 || col < 0) return;
2622
2623   sheet->active_cell.row = -1;
2624   sheet->active_cell.col = -1;
2625
2626   text = gtk_entry_get_text (GTK_ENTRY (gtk_sheet_get_entry (sheet)));
2627
2628   if (text && strlen (text) > 0)
2629     {
2630       gtk_sheet_get_attributes (sheet, row, col, &attributes);
2631       justification = attributes.justification;
2632       gtk_sheet_set_cell (sheet, row, col, justification, text);
2633     }
2634
2635   sheet->active_cell.row = row;;
2636   sheet->active_cell.col = col;
2637 }
2638
2639
2640 static void
2641 gtk_sheet_hide_active_cell (GtkSheet *sheet)
2642 {
2643   GdkRectangle area;
2644
2645   if (!GTK_WIDGET_REALIZED (GTK_WIDGET (sheet)))
2646     return;
2647
2648   if (sheet->active_cell.row < 0 ||
2649       sheet->active_cell.col < 0) return;
2650
2651   gtk_widget_hide (sheet->entry_widget);
2652   gtk_widget_unmap (sheet->entry_widget);
2653
2654   rectangle_from_cell (sheet,
2655                        sheet->active_cell.row, sheet->active_cell.col,
2656                        &area);
2657
2658   gdk_draw_rectangle (sheet->sheet_window,
2659                       GTK_WIDGET (sheet)->style->white_gc,
2660                       TRUE,
2661                       area.x, area.y,
2662                       area.width, area.height);
2663
2664   gtk_sheet_cell_draw (sheet, sheet->active_cell.row,
2665                                sheet->active_cell.col);
2666
2667   GTK_WIDGET_UNSET_FLAGS (GTK_WIDGET (sheet->entry_widget), GTK_VISIBLE);
2668 }
2669
2670 static void
2671 change_active_cell (GtkSheet *sheet, gint row, gint col)
2672 {
2673   gint old_row, old_col;
2674   glong old_handler_id = sheet->entry_handler_id;
2675
2676   g_return_if_fail (GTK_IS_SHEET (sheet));
2677
2678   if (row < 0 || col < 0)
2679     return;
2680
2681   if ( row > g_sheet_row_get_row_count (sheet->row_geometry)
2682        || col > psppire_axis_unit_count (sheet->haxis))
2683     return;
2684
2685   if (sheet->state != GTK_SHEET_NORMAL)
2686     {
2687       sheet->state = GTK_SHEET_NORMAL;
2688       gtk_sheet_real_unselect_range (sheet, NULL);
2689     }
2690
2691   g_signal_handler_block   (sheet->entry_widget, sheet->entry_handler_id);
2692
2693   old_row = sheet->active_cell.row;
2694   old_col = sheet->active_cell.col;
2695
2696   sheet->range.row0 = row;
2697   sheet->range.col0 = col;
2698   sheet->range.rowi = row;
2699   sheet->range.coli = col;
2700   sheet->active_cell.row = row;
2701   sheet->active_cell.col = col;
2702   sheet->selection_cell.row = row;
2703   sheet->selection_cell.col = col;
2704
2705   GTK_SHEET_UNSET_FLAGS (sheet, GTK_SHEET_IN_SELECTION);
2706
2707   gtk_sheet_show_active_cell (sheet);
2708
2709
2710   g_signal_emit (sheet, sheet_signals [ACTIVATE], 0,
2711                  row, col, old_row, old_col);
2712
2713   if ( old_handler_id == sheet->entry_handler_id)
2714     g_signal_handler_unblock   (sheet->entry_widget, sheet->entry_handler_id);
2715 }
2716
2717 static void
2718 gtk_sheet_show_active_cell (GtkSheet *sheet)
2719 {
2720   GtkEntry *sheet_entry;
2721   GtkSheetCellAttr attributes;
2722   gchar *text = NULL;
2723   gint row, col;
2724
2725   g_return_if_fail (sheet != NULL);
2726   g_return_if_fail (GTK_IS_SHEET (sheet));
2727
2728   row = sheet->active_cell.row;
2729   col = sheet->active_cell.col;
2730
2731   /* Don't show the active cell, if there is no active cell: */
2732   if (! (row >= 0 && col >= 0)) /* e.g row or coll == -1. */
2733     return;
2734
2735   if (!GTK_WIDGET_REALIZED (GTK_WIDGET (sheet))) return;
2736   if (sheet->state != GTK_SHEET_NORMAL) return;
2737   if (GTK_SHEET_IN_SELECTION (sheet)) return;
2738
2739   GTK_WIDGET_SET_FLAGS (GTK_WIDGET (sheet->entry_widget), GTK_VISIBLE);
2740
2741   sheet_entry = GTK_ENTRY (gtk_sheet_get_entry (sheet));
2742
2743   gtk_sheet_get_attributes (sheet, row, col, &attributes);
2744
2745
2746   text = gtk_sheet_cell_get_text (sheet, row, col);
2747   if ( ! text )
2748     text = g_strdup ("");
2749
2750   gtk_entry_set_visibility (GTK_ENTRY (sheet_entry), attributes.is_visible);
2751
2752
2753   if ( GTK_IS_ENTRY (sheet_entry))
2754     {
2755       const gchar *old_text = gtk_entry_get_text (GTK_ENTRY (sheet_entry));
2756       if (strcmp (old_text, text) != 0)
2757         gtk_entry_set_text (GTK_ENTRY (sheet_entry), text);
2758
2759       switch (attributes.justification)
2760         {
2761         case GTK_JUSTIFY_RIGHT:
2762           gtk_entry_set_alignment (GTK_ENTRY (sheet_entry), 1.0);
2763           break;
2764         case GTK_JUSTIFY_CENTER:
2765           gtk_entry_set_alignment (GTK_ENTRY (sheet_entry), 0.5);
2766           break;
2767         case GTK_JUSTIFY_LEFT:
2768         default:
2769           gtk_entry_set_alignment (GTK_ENTRY (sheet_entry), 0.0);
2770           break;
2771         }
2772     }
2773
2774   gtk_sheet_size_allocate_entry (sheet);
2775
2776   gtk_widget_map (sheet->entry_widget);
2777
2778   gtk_widget_grab_focus (GTK_WIDGET (sheet_entry));
2779
2780   dispose_string (sheet, text);
2781
2782 }
2783
2784 static void
2785 gtk_sheet_draw_active_cell (GtkSheet *sheet)
2786 {
2787   gint row, col;
2788   GtkSheetRange range;
2789
2790   if (!GTK_WIDGET_DRAWABLE (GTK_WIDGET (sheet))) return;
2791   if (!GTK_WIDGET_REALIZED (GTK_WIDGET (sheet))) return;
2792
2793   row = sheet->active_cell.row;
2794   col = sheet->active_cell.col;
2795
2796   if (row < 0 || col < 0) return;
2797
2798   if (!gtk_sheet_cell_isvisible (sheet, row, col))
2799     return;
2800
2801   range.col0 = range.coli = col;
2802   range.row0 = range.rowi = row;
2803
2804   gtk_sheet_draw_border (sheet, range);
2805 }
2806
2807
2808
2809 static void
2810 gtk_sheet_new_selection (GtkSheet *sheet, GtkSheetRange *range)
2811 {
2812   gint i, j, mask1, mask2;
2813   gint state, selected;
2814   gint x, y, width, height;
2815   GtkSheetRange new_range, aux_range;
2816
2817   g_return_if_fail (sheet != NULL);
2818
2819   if (range == NULL) range=&sheet->range;
2820
2821   new_range=*range;
2822
2823   range->row0 = MIN (range->row0, sheet->range.row0);
2824   range->rowi = MAX (range->rowi, sheet->range.rowi);
2825   range->col0 = MIN (range->col0, sheet->range.col0);
2826   range->coli = MAX (range->coli, sheet->range.coli);
2827
2828   range->row0 = MAX (range->row0, min_visible_row (sheet));
2829   range->rowi = MIN (range->rowi, max_visible_row (sheet));
2830   range->col0 = MAX (range->col0, min_visible_column (sheet));
2831   range->coli = MIN (range->coli, max_visible_column (sheet));
2832
2833   aux_range.row0 = MAX (new_range.row0, min_visible_row (sheet));
2834   aux_range.rowi = MIN (new_range.rowi, max_visible_row (sheet));
2835   aux_range.col0 = MAX (new_range.col0, min_visible_column (sheet));
2836   aux_range.coli = MIN (new_range.coli, max_visible_column (sheet));
2837
2838   for (i = range->row0; i <= range->rowi; i++)
2839     {
2840       for (j = range->col0; j <= range->coli; j++)
2841         {
2842
2843           state = gtk_sheet_cell_get_state (sheet, i, j);
2844           selected= (i <= new_range.rowi && i >= new_range.row0 &&
2845                      j <= new_range.coli && j >= new_range.col0) ? TRUE : FALSE;
2846
2847           if (state == GTK_STATE_SELECTED && selected &&
2848               (i == sheet->range.row0 || i == sheet->range.rowi ||
2849                j == sheet->range.col0 || j == sheet->range.coli ||
2850                i == new_range.row0 || i == new_range.rowi ||
2851                j == new_range.col0 || j == new_range.coli))
2852             {
2853
2854               mask1 = i == sheet->range.row0 ? 1 : 0;
2855               mask1 = i == sheet->range.rowi ? mask1 + 2 : mask1;
2856               mask1 = j == sheet->range.col0 ? mask1 + 4 : mask1;
2857               mask1 = j == sheet->range.coli ? mask1 + 8 : mask1;
2858
2859               mask2 = i == new_range.row0 ? 1 : 0;
2860               mask2 = i == new_range.rowi ? mask2 + 2 : mask2;
2861               mask2 = j == new_range.col0 ? mask2 + 4 : mask2;
2862               mask2 = j == new_range.coli ? mask2 + 8 : mask2;
2863
2864               if (mask1 != mask2)
2865                 {
2866                   x = psppire_axis_pixel_start (sheet->haxis, j);
2867                   y = g_sheet_row_start_pixel (sheet->row_geometry, i);
2868                   width = psppire_axis_pixel_start (sheet->haxis, j)- x+
2869                     psppire_axis_unit_size (sheet->haxis, j);
2870                   height = g_sheet_row_start_pixel (sheet->row_geometry, i) - y + g_sheet_row_get_height (sheet->row_geometry, i);
2871
2872                   if (i == sheet->range.row0)
2873                     {
2874                       y = y - 3;
2875                       height = height + 3;
2876                     }
2877                   if (i == sheet->range.rowi) height = height + 3;
2878                   if (j == sheet->range.col0)
2879                     {
2880                       x = x - 3;
2881                       width = width + 3;
2882                     }
2883                   if (j == sheet->range.coli) width = width + 3;
2884
2885                   if (i != sheet->active_cell.row || j != sheet->active_cell.col)
2886                     {
2887                       x = psppire_axis_pixel_start (sheet->haxis, j);
2888                       y = g_sheet_row_start_pixel (sheet->row_geometry, i);
2889                       width = psppire_axis_pixel_start (sheet->haxis, j)- x+
2890                         psppire_axis_unit_size (sheet->haxis, j);
2891
2892                       height = g_sheet_row_start_pixel (sheet->row_geometry, i) - y + g_sheet_row_get_height (sheet->row_geometry, i);
2893
2894                       if (i == new_range.row0)
2895                         {
2896                           y = y+2;
2897                           height = height - 2;
2898                         }
2899                       if (i == new_range.rowi) height = height - 3;
2900                       if (j == new_range.col0)
2901                         {
2902                           x = x+2;
2903                           width = width - 2;
2904                         }
2905                       if (j == new_range.coli) width = width - 3;
2906
2907                       gdk_draw_rectangle (sheet->sheet_window,
2908                                           sheet->xor_gc,
2909                                           TRUE,
2910                                           x + 1, y + 1,
2911                                           width, height);
2912                     }
2913                 }
2914             }
2915         }
2916     }
2917
2918   for (i = range->row0; i <= range->rowi; i++)
2919     {
2920       for (j = range->col0; j <= range->coli; j++)
2921         {
2922
2923           state = gtk_sheet_cell_get_state (sheet, i, j);
2924           selected= (i <= new_range.rowi && i >= new_range.row0 &&
2925                      j <= new_range.coli && j >= new_range.col0) ? TRUE : FALSE;
2926
2927           if (state == GTK_STATE_SELECTED && !selected)
2928             {
2929
2930               x = psppire_axis_pixel_start (sheet->haxis, j);
2931               y = g_sheet_row_start_pixel (sheet->row_geometry, i);
2932               width = psppire_axis_pixel_start (sheet->haxis, j) - x + psppire_axis_unit_size (sheet->haxis, j);
2933               height = g_sheet_row_start_pixel (sheet->row_geometry, i) - y + g_sheet_row_get_height (sheet->row_geometry, i);
2934
2935               if (i == sheet->range.row0)
2936                 {
2937                   y = y - 3;
2938                   height = height + 3;
2939                 }
2940               if (i == sheet->range.rowi) height = height + 3;
2941               if (j == sheet->range.col0)
2942                 {
2943                   x = x - 3;
2944                   width = width + 3;
2945                 }
2946               if (j == sheet->range.coli) width = width + 3;
2947
2948             }
2949         }
2950     }
2951
2952   for (i = range->row0; i <= range->rowi; i++)
2953     {
2954       for (j = range->col0; j <= range->coli; j++)
2955         {
2956
2957           state = gtk_sheet_cell_get_state (sheet, i, j);
2958           selected= (i <= new_range.rowi && i >= new_range.row0 &&
2959                      j <= new_range.coli && j >= new_range.col0) ? TRUE : FALSE;
2960
2961           if (state != GTK_STATE_SELECTED && selected &&
2962               (i != sheet->active_cell.row || j != sheet->active_cell.col))
2963             {
2964
2965               x = psppire_axis_pixel_start (sheet->haxis, j);
2966               y = g_sheet_row_start_pixel (sheet->row_geometry, i);
2967               width = psppire_axis_pixel_start (sheet->haxis, j) - x + psppire_axis_unit_size (sheet->haxis, j);
2968               height = g_sheet_row_start_pixel (sheet->row_geometry, i) - y + g_sheet_row_get_height (sheet->row_geometry, i);
2969
2970               if (i == new_range.row0)
2971                 {
2972                   y = y+2;
2973                   height = height - 2;
2974                 }
2975               if (i == new_range.rowi) height = height - 3;
2976               if (j == new_range.col0)
2977                 {
2978                   x = x+2;
2979                   width = width - 2;
2980                 }
2981               if (j == new_range.coli) width = width - 3;
2982
2983               gdk_draw_rectangle (sheet->sheet_window,
2984                                   sheet->xor_gc,
2985                                   TRUE,
2986                                   x + 1, y + 1,
2987                                   width, height);
2988
2989             }
2990
2991         }
2992     }
2993
2994   for (i = aux_range.row0; i <= aux_range.rowi; i++)
2995     {
2996       for (j = aux_range.col0; j <= aux_range.coli; j++)
2997         {
2998           state = gtk_sheet_cell_get_state (sheet, i, j);
2999
3000           mask1 = i == sheet->range.row0 ? 1 : 0;
3001           mask1 = i == sheet->range.rowi ? mask1 + 2 : mask1;
3002           mask1 = j == sheet->range.col0 ? mask1 + 4 : mask1;
3003           mask1 = j == sheet->range.coli ? mask1 + 8 : mask1;
3004
3005           mask2 = i == new_range.row0 ? 1 : 0;
3006           mask2 = i == new_range.rowi ? mask2 + 2 : mask2;
3007           mask2 = j == new_range.col0 ? mask2 + 4 : mask2;
3008           mask2 = j == new_range.coli ? mask2 + 8 : mask2;
3009           if (mask2 != mask1 || (mask2 == mask1 && state != GTK_STATE_SELECTED))
3010             {
3011               x = psppire_axis_pixel_start (sheet->haxis, j);
3012               y = g_sheet_row_start_pixel (sheet->row_geometry, i);
3013               width = psppire_axis_unit_size (sheet->haxis, j);
3014               height = g_sheet_row_get_height (sheet->row_geometry, i);
3015               if (mask2 & 1)
3016                 gdk_draw_rectangle (sheet->sheet_window,
3017                                     sheet->xor_gc,
3018                                     TRUE,
3019                                     x + 1, y - 1,
3020                                     width, 3);
3021
3022
3023               if (mask2 & 2)
3024                 gdk_draw_rectangle (sheet->sheet_window,
3025                                     sheet->xor_gc,
3026                                     TRUE,
3027                                     x + 1, y + height - 1,
3028                                     width, 3);
3029
3030               if (mask2 & 4)
3031                 gdk_draw_rectangle (sheet->sheet_window,
3032                                     sheet->xor_gc,
3033                                     TRUE,
3034                                     x - 1, y + 1,
3035                                     3, height);
3036
3037
3038               if (mask2 & 8)
3039                 gdk_draw_rectangle (sheet->sheet_window,
3040                                     sheet->xor_gc,
3041                                     TRUE,
3042                                     x + width - 1, y + 1,
3043                                     3, height);
3044             }
3045         }
3046     }
3047
3048   *range = new_range;
3049 }
3050
3051 static void
3052 gtk_sheet_draw_border (GtkSheet *sheet, GtkSheetRange new_range)
3053 {
3054   GdkRectangle area;
3055
3056   rectangle_from_range (sheet, &new_range, &area);
3057
3058   gdk_draw_rectangle (sheet->sheet_window,
3059                       sheet->xor_gc,
3060                       FALSE,
3061                       area.x + 1,
3062                       area.y + 1,
3063                       area.width - 2,
3064                       area.height - 2);
3065 }
3066
3067
3068 static void
3069 gtk_sheet_real_select_range (GtkSheet *sheet,
3070                              const GtkSheetRange *range)
3071 {
3072   gint state;
3073
3074   g_return_if_fail (sheet != NULL);
3075
3076   if (range == NULL) range = &sheet->range;
3077
3078   memcpy (&sheet->range, range, sizeof (*range));
3079
3080   if (range->row0 < 0 || range->rowi < 0) return;
3081   if (range->col0 < 0 || range->coli < 0) return;
3082
3083   state = sheet->state;
3084
3085 #if 0
3086   if (range->coli != sheet->range.coli || range->col0 != sheet->range.col0 ||
3087       range->rowi != sheet->range.rowi || range->row0 != sheet->range.row0)
3088     {
3089       gtk_sheet_new_selection (sheet, &sheet->range);
3090     }
3091   else
3092     {
3093       gtk_sheet_range_draw_selection (sheet, sheet->range);
3094     }
3095 #endif
3096
3097   gtk_sheet_update_primary_selection (sheet);
3098
3099   g_signal_emit (sheet, sheet_signals[SELECT_RANGE], 0, &sheet->range);
3100 }
3101
3102
3103 void
3104 gtk_sheet_get_selected_range (GtkSheet *sheet, GtkSheetRange *range)
3105 {
3106   g_return_if_fail (sheet != NULL);
3107   *range = sheet->range;
3108 }
3109
3110
3111 void
3112 gtk_sheet_select_range (GtkSheet *sheet, const GtkSheetRange *range)
3113 {
3114   g_return_if_fail (sheet != NULL);
3115
3116   if (range == NULL) range=&sheet->range;
3117
3118   if (range->row0 < 0 || range->rowi < 0) return;
3119   if (range->col0 < 0 || range->coli < 0) return;
3120
3121
3122   if (sheet->state != GTK_SHEET_NORMAL)
3123     gtk_sheet_real_unselect_range (sheet, NULL);
3124
3125   sheet->range.row0 = range->row0;
3126   sheet->range.rowi = range->rowi;
3127   sheet->range.col0 = range->col0;
3128   sheet->range.coli = range->coli;
3129   sheet->active_cell.row = range->row0;
3130   sheet->active_cell.col = range->col0;
3131   sheet->selection_cell.row = range->rowi;
3132   sheet->selection_cell.col = range->coli;
3133
3134   sheet->state = GTK_SHEET_RANGE_SELECTED;
3135   gtk_sheet_real_select_range (sheet, NULL);
3136 }
3137
3138 void
3139 gtk_sheet_unselect_range (GtkSheet *sheet)
3140 {
3141   if (! GTK_WIDGET_REALIZED (GTK_WIDGET (sheet)))
3142     return;
3143
3144   gtk_sheet_real_unselect_range (sheet, NULL);
3145   sheet->state = GTK_STATE_NORMAL;
3146
3147   change_active_cell (sheet,
3148                  sheet->active_cell.row, sheet->active_cell.col);
3149 }
3150
3151
3152 static void
3153 gtk_sheet_real_unselect_range (GtkSheet *sheet,
3154                                const GtkSheetRange *range)
3155 {
3156   g_return_if_fail (sheet != NULL);
3157   g_return_if_fail (GTK_WIDGET_REALIZED (GTK_WIDGET (sheet)));
3158
3159   if ( range == NULL)
3160     range = &sheet->range;
3161
3162   if (range->row0 < 0 || range->rowi < 0) return;
3163   if (range->col0 < 0 || range->coli < 0) return;
3164
3165   g_signal_emit (sheet, sheet_signals[SELECT_COLUMN], 0, -1);
3166   g_signal_emit (sheet, sheet_signals[SELECT_ROW], 0, -1);
3167
3168 #if 0
3169   if (gtk_sheet_range_isvisible (sheet, *range))
3170     gtk_sheet_draw_backing_pixmap (sheet, *range);
3171 #endif
3172
3173   sheet->range.row0 = -1;
3174   sheet->range.rowi = -1;
3175   sheet->range.col0 = -1;
3176   sheet->range.coli = -1;
3177 }
3178
3179
3180 static gint
3181 gtk_sheet_expose (GtkWidget *widget,
3182                   GdkEventExpose *event)
3183 {
3184   GtkSheet *sheet;
3185   GtkSheetRange range;
3186
3187   g_return_val_if_fail (widget != NULL, FALSE);
3188   g_return_val_if_fail (GTK_IS_SHEET (widget), FALSE);
3189   g_return_val_if_fail (event != NULL, FALSE);
3190
3191   sheet = GTK_SHEET (widget);
3192
3193   if (!GTK_WIDGET_DRAWABLE (widget))
3194     return FALSE;
3195
3196   /* exposure events on the sheet */
3197   if (event->window == sheet->row_title_window &&
3198       sheet->row_titles_visible)
3199     {
3200       gint i;
3201       for (i = min_visible_row (sheet); i <= max_visible_row (sheet); i++)
3202         gtk_sheet_row_title_button_draw (sheet, i);
3203     }
3204
3205   if (event->window == sheet->column_title_window &&
3206       sheet->column_titles_visible)
3207     {
3208       gint i;
3209       for (i = min_visible_column (sheet);
3210            i <= max_visible_column (sheet);
3211            ++i)
3212         gtk_sheet_column_title_button_draw (sheet, i);
3213     }
3214
3215
3216   range.row0 =
3217     yyy_row_ypixel_to_row (sheet,
3218                            event->area.y + sheet->vadjustment->value);
3219   range.row0--;
3220
3221   range.rowi =
3222     yyy_row_ypixel_to_row (sheet,
3223                            event->area.y +
3224                            event->area.height + sheet->vadjustment->value);
3225   range.rowi++;
3226
3227   range.col0 =
3228     column_from_xpixel (sheet,
3229                         event->area.x + sheet->hadjustment->value);
3230   range.col0--;
3231
3232   range.coli =
3233     column_from_xpixel (sheet,
3234                         event->area.x + event->area.width +
3235                         sheet->hadjustment->value);
3236   range.coli++;
3237
3238   if (event->window == sheet->sheet_window)
3239     {
3240       gtk_sheet_range_draw (sheet, &range);
3241
3242       if (sheet->state != GTK_SHEET_NORMAL)
3243         {
3244           if (gtk_sheet_range_isvisible (sheet, sheet->range))
3245             gtk_sheet_range_draw (sheet, &sheet->range);
3246
3247           if (GTK_SHEET_IN_RESIZE (sheet) || GTK_SHEET_IN_DRAG (sheet))
3248             gtk_sheet_range_draw (sheet, &sheet->drag_range);
3249
3250           if (gtk_sheet_range_isvisible (sheet, sheet->range))
3251             gtk_sheet_range_draw_selection (sheet, sheet->range);
3252           if (GTK_SHEET_IN_RESIZE (sheet) || GTK_SHEET_IN_DRAG (sheet))
3253             draw_xor_rectangle (sheet, sheet->drag_range);
3254         }
3255
3256       if ((!GTK_SHEET_IN_XDRAG (sheet)) && (!GTK_SHEET_IN_YDRAG (sheet)))
3257         {
3258           if (sheet->state == GTK_SHEET_NORMAL)
3259             gtk_sheet_draw_active_cell (sheet);
3260         }
3261     }
3262
3263   if (sheet->state != GTK_SHEET_NORMAL && GTK_SHEET_IN_SELECTION (sheet))
3264     gtk_widget_grab_focus (GTK_WIDGET (sheet));
3265
3266   (* GTK_WIDGET_CLASS (parent_class)->expose_event) (widget, event);
3267
3268   return FALSE;
3269 }
3270
3271
3272 static gboolean
3273 gtk_sheet_button_press (GtkWidget *widget,
3274                         GdkEventButton *event)
3275 {
3276   GtkSheet *sheet;
3277   GdkModifierType mods;
3278   gint x, y;
3279   gint  row, column;
3280   gboolean veto;
3281
3282   g_return_val_if_fail (widget != NULL, FALSE);
3283   g_return_val_if_fail (GTK_IS_SHEET (widget), FALSE);
3284   g_return_val_if_fail (event != NULL, FALSE);
3285
3286   sheet = GTK_SHEET (widget);
3287
3288   /* Cancel any pending tooltips */
3289   if (sheet->motion_timer)
3290     {
3291       g_source_remove (sheet->motion_timer);
3292       sheet->motion_timer = 0;
3293     }
3294
3295   gtk_widget_get_pointer (widget, &x, &y);
3296   gtk_sheet_get_pixel_info (sheet, x, y, &row, &column);
3297
3298
3299   if (event->window == sheet->column_title_window)
3300     {
3301       g_signal_emit (sheet,
3302                      sheet_signals[BUTTON_EVENT_COLUMN], 0,
3303                      column, event);
3304
3305       if (g_sheet_model_get_column_sensitivity (sheet->model, column))
3306         {
3307           if ( event->type == GDK_2BUTTON_PRESS && event->button == 1)
3308             g_signal_emit (sheet,
3309                            sheet_signals[DOUBLE_CLICK_COLUMN], 0, column);
3310         }
3311     }
3312   else if (event->window == sheet->row_title_window)
3313     {
3314       g_signal_emit (sheet,
3315                      sheet_signals[BUTTON_EVENT_ROW], 0,
3316                      row, event);
3317
3318
3319       if (g_sheet_row_get_sensitivity (sheet->row_geometry, row))
3320         {
3321           if ( event->type == GDK_2BUTTON_PRESS && event->button == 1)
3322             g_signal_emit (sheet,
3323                            sheet_signals[DOUBLE_CLICK_ROW], 0, row);
3324         }
3325     }
3326
3327   gdk_window_get_pointer (widget->window, NULL, NULL, &mods);
3328
3329   if (! (mods & GDK_BUTTON1_MASK)) return TRUE;
3330
3331
3332   /* press on resize windows */
3333   if (event->window == sheet->column_title_window &&
3334       gtk_sheet_columns_resizable (sheet))
3335     {
3336 #if 0
3337       gtk_widget_get_pointer (widget, &sheet->x_drag, NULL);
3338       if ( sheet->row_titles_visible)
3339         sheet->x_drag -= sheet->row_title_area.width;
3340 #endif
3341
3342       sheet->x_drag = event->x;
3343
3344       if (on_column_boundary (sheet, sheet->x_drag, &sheet->drag_cell.col))
3345         {
3346           guint req;
3347           if (event->type == GDK_2BUTTON_PRESS)
3348             {
3349               gtk_sheet_autoresize_column (sheet, sheet->drag_cell.col);
3350               GTK_SHEET_UNSET_FLAGS (sheet, GTK_SHEET_IN_XDRAG);
3351               return TRUE;
3352             }
3353           gtk_sheet_column_size_request (sheet, sheet->drag_cell.col, &req);
3354           GTK_SHEET_SET_FLAGS (sheet, GTK_SHEET_IN_XDRAG);
3355           gdk_pointer_grab (sheet->column_title_window, FALSE,
3356                             GDK_POINTER_MOTION_HINT_MASK |
3357                             GDK_BUTTON1_MOTION_MASK |
3358                             GDK_BUTTON_RELEASE_MASK,
3359                             NULL, NULL, event->time);
3360
3361           draw_xor_vline (sheet);
3362           return TRUE;
3363         }
3364     }
3365
3366   if (event->window == sheet->row_title_window && gtk_sheet_rows_resizable (sheet))
3367     {
3368       gtk_widget_get_pointer (widget, NULL, &sheet->y_drag);
3369
3370       if (POSSIBLE_YDRAG (sheet, sheet->y_drag, &sheet->drag_cell.row))
3371         {
3372           guint req;
3373           gtk_sheet_row_size_request (sheet, sheet->drag_cell.row, &req);
3374           GTK_SHEET_SET_FLAGS (sheet, GTK_SHEET_IN_YDRAG);
3375           gdk_pointer_grab (sheet->row_title_window, FALSE,
3376                             GDK_POINTER_MOTION_HINT_MASK |
3377                             GDK_BUTTON1_MOTION_MASK |
3378                             GDK_BUTTON_RELEASE_MASK,
3379                             NULL, NULL, event->time);
3380
3381           draw_xor_hline (sheet);
3382           return TRUE;
3383         }
3384     }
3385
3386   /* the sheet itself does not handle other than single click events */
3387   if (event->type != GDK_BUTTON_PRESS) return FALSE;
3388
3389   /* selections on the sheet */
3390   if (event->window == sheet->sheet_window)
3391     {
3392       gtk_widget_get_pointer (widget, &x, &y);
3393       gtk_sheet_get_pixel_info (sheet, x, y, &row, &column);
3394       gdk_pointer_grab (sheet->sheet_window, FALSE,
3395                         GDK_POINTER_MOTION_HINT_MASK |
3396                         GDK_BUTTON1_MOTION_MASK |
3397                         GDK_BUTTON_RELEASE_MASK,
3398                         NULL, NULL, event->time);
3399       gtk_grab_add (GTK_WIDGET (sheet));
3400
3401       /* This seems to be a kludge to work around a problem where the sheet
3402          scrolls to another position.  The timeout scrolls it back to its
3403          original posn.          JMD 3 July 2007
3404       */
3405       gtk_widget_grab_focus (GTK_WIDGET (sheet));
3406
3407       if (sheet->selection_mode != GTK_SELECTION_SINGLE &&
3408           sheet->selection_mode != GTK_SELECTION_NONE &&
3409           sheet->cursor_drag->type == GDK_SIZING &&
3410           !GTK_SHEET_IN_SELECTION (sheet) && !GTK_SHEET_IN_RESIZE (sheet))
3411         {
3412           if (sheet->state == GTK_STATE_NORMAL)
3413             {
3414               row = sheet->active_cell.row;
3415               column = sheet->active_cell.col;
3416               sheet->active_cell.row = row;
3417               sheet->active_cell.col = column;
3418               sheet->drag_range = sheet->range;
3419               sheet->state = GTK_SHEET_RANGE_SELECTED;
3420               gtk_sheet_select_range (sheet, &sheet->drag_range);
3421             }
3422           sheet->x_drag = x;
3423           sheet->y_drag = y;
3424           if (row > sheet->range.rowi) row--;
3425           if (column > sheet->range.coli) column--;
3426           sheet->drag_cell.row = row;
3427           sheet->drag_cell.col = column;
3428           sheet->drag_range = sheet->range;
3429           draw_xor_rectangle (sheet, sheet->drag_range);
3430           GTK_SHEET_SET_FLAGS (sheet, GTK_SHEET_IN_RESIZE);
3431         }
3432       else if (sheet->cursor_drag->type == GDK_TOP_LEFT_ARROW &&
3433                !GTK_SHEET_IN_SELECTION (sheet)
3434                && ! GTK_SHEET_IN_DRAG (sheet)
3435                && sheet->active_cell.row >= 0
3436                && sheet->active_cell.col >= 0
3437                )
3438         {
3439           if (sheet->state == GTK_STATE_NORMAL)
3440             {
3441               row = sheet->active_cell.row;
3442               column = sheet->active_cell.col;
3443               sheet->active_cell.row = row;
3444               sheet->active_cell.col = column;
3445               sheet->drag_range = sheet->range;
3446               sheet->state = GTK_SHEET_RANGE_SELECTED;
3447               gtk_sheet_select_range (sheet, &sheet->drag_range);
3448             }
3449           sheet->x_drag = x;
3450           sheet->y_drag = y;
3451           if (row < sheet->range.row0) row++;
3452           if (row > sheet->range.rowi) row--;
3453           if (column < sheet->range.col0) column++;
3454           if (column > sheet->range.coli) column--;
3455           sheet->drag_cell.row = row;
3456           sheet->drag_cell.col = column;
3457           sheet->drag_range = sheet->range;
3458           draw_xor_rectangle (sheet, sheet->drag_range);
3459           GTK_SHEET_SET_FLAGS (sheet, GTK_SHEET_IN_DRAG);
3460         }
3461       else
3462         {
3463           veto = gtk_sheet_click_cell (sheet, row, column);
3464           if (veto) GTK_SHEET_SET_FLAGS (sheet, GTK_SHEET_IN_SELECTION);
3465         }
3466     }
3467
3468   if (event->window == sheet->column_title_window)
3469     {
3470       gtk_widget_get_pointer (widget, &x, &y);
3471       if ( sheet->row_titles_visible)
3472         x -= sheet->row_title_area.width;
3473
3474       x += sheet->hadjustment->value;
3475
3476       column = column_from_xpixel (sheet, x);
3477
3478       if (g_sheet_model_get_column_sensitivity (sheet->model, column))
3479         {
3480           veto = gtk_sheet_click_cell (sheet, -1, column);
3481           gtk_grab_add (GTK_WIDGET (sheet));
3482           gtk_widget_grab_focus (GTK_WIDGET (sheet));
3483           GTK_SHEET_SET_FLAGS (sheet, GTK_SHEET_IN_SELECTION);
3484         }
3485     }
3486
3487   if (event->window == sheet->row_title_window)
3488     {
3489       gtk_widget_get_pointer (widget, &x, &y);
3490       if ( sheet->column_titles_visible)
3491         y -= sheet->column_title_area.height;
3492
3493       y += sheet->vadjustment->value;
3494
3495       row = yyy_row_ypixel_to_row (sheet, y);
3496       if (g_sheet_row_get_sensitivity (sheet->row_geometry, row))
3497         {
3498           veto = gtk_sheet_click_cell (sheet, row, -1);
3499           gtk_grab_add (GTK_WIDGET (sheet));
3500           gtk_widget_grab_focus (GTK_WIDGET (sheet));
3501           GTK_SHEET_SET_FLAGS (sheet, GTK_SHEET_IN_SELECTION);
3502         }
3503     }
3504
3505   return TRUE;
3506 }
3507
3508 static gboolean
3509 gtk_sheet_click_cell (GtkSheet *sheet, gint row, gint column)
3510 {
3511   GtkSheetCell cell;
3512   gboolean forbid_move;
3513
3514   cell.row = row;
3515   cell.col = column;
3516
3517   if (row >= g_sheet_row_get_row_count (sheet->row_geometry)
3518       || column >= psppire_axis_unit_count (sheet->haxis))
3519     {
3520       return FALSE;
3521     }
3522
3523   g_signal_emit (sheet, sheet_signals[TRAVERSE], 0,
3524                  &sheet->active_cell,
3525                  &cell,
3526                  &forbid_move);
3527
3528   if (forbid_move)
3529     {
3530       if (sheet->state == GTK_STATE_NORMAL)
3531         return FALSE;
3532
3533       row = sheet->active_cell.row;
3534       column = sheet->active_cell.col;
3535
3536       change_active_cell (sheet, row, column);
3537       return FALSE;
3538     }
3539
3540   if (row == -1 && column >= 0)
3541     {
3542       gtk_sheet_select_column (sheet, column);
3543       return TRUE;
3544     }
3545
3546   if (column == -1 && row >= 0)
3547     {
3548       gtk_sheet_select_row (sheet, row);
3549       return TRUE;
3550     }
3551
3552   if (row == -1 && column == -1)
3553     {
3554       sheet->range.row0 = 0;
3555       sheet->range.col0 = 0;
3556       sheet->range.rowi = g_sheet_row_get_row_count (sheet->row_geometry) - 1;
3557       sheet->range.coli =
3558         psppire_axis_unit_count (sheet->haxis) - 1;
3559       sheet->active_cell.row = 0;
3560       sheet->active_cell.col = 0;
3561       gtk_sheet_select_range (sheet, NULL);
3562       return TRUE;
3563     }
3564
3565   if (sheet->state != GTK_SHEET_NORMAL)
3566     {
3567       sheet->state = GTK_SHEET_NORMAL;
3568       gtk_sheet_real_unselect_range (sheet, NULL);
3569     }
3570   else
3571     {
3572       change_active_cell (sheet, row, column);
3573     }
3574
3575   sheet->active_cell.row = row;
3576   sheet->active_cell.col = column;
3577   sheet->selection_cell.row = row;
3578   sheet->selection_cell.col = column;
3579   sheet->range.row0 = row;
3580   sheet->range.col0 = column;
3581   sheet->range.rowi = row;
3582   sheet->range.coli = column;
3583   sheet->state = GTK_SHEET_NORMAL;
3584   GTK_SHEET_SET_FLAGS (sheet, GTK_SHEET_IN_SELECTION);
3585   gtk_sheet_draw_active_cell (sheet);
3586   return TRUE;
3587 }
3588
3589 static gint
3590 gtk_sheet_button_release (GtkWidget *widget,
3591                           GdkEventButton *event)
3592 {
3593   gint y;
3594   GdkDisplay *display = gtk_widget_get_display (widget);
3595
3596   GtkSheet *sheet = GTK_SHEET (widget);
3597
3598   /* release on resize windows */
3599   if (GTK_SHEET_IN_XDRAG (sheet))
3600     {
3601       gint xpos = event->x;
3602       gint width;
3603       GTK_SHEET_UNSET_FLAGS (sheet, GTK_SHEET_IN_XDRAG);
3604       GTK_SHEET_UNSET_FLAGS (sheet, GTK_SHEET_IN_SELECTION);
3605
3606       gdk_display_pointer_ungrab (display, event->time);
3607       draw_xor_vline (sheet);
3608
3609       width = new_column_width (sheet, sheet->drag_cell.col, &xpos);
3610
3611       gtk_sheet_set_column_width (sheet, sheet->drag_cell.col, width);
3612       return TRUE;
3613     }
3614
3615   if (GTK_SHEET_IN_YDRAG (sheet))
3616     {
3617       GTK_SHEET_UNSET_FLAGS (sheet, GTK_SHEET_IN_YDRAG);
3618       GTK_SHEET_UNSET_FLAGS (sheet, GTK_SHEET_IN_SELECTION);
3619       gtk_widget_get_pointer (widget, NULL, &y);
3620       gdk_display_pointer_ungrab (display, event->time);
3621       draw_xor_hline (sheet);
3622
3623       gtk_sheet_set_row_height (sheet, sheet->drag_cell.row,
3624                                 new_row_height (sheet, sheet->drag_cell.row, &y));
3625       g_signal_emit_by_name (sheet->vadjustment, "value_changed");
3626       return TRUE;
3627     }
3628
3629
3630   if (GTK_SHEET_IN_DRAG (sheet))
3631     {
3632       GtkSheetRange old_range;
3633       draw_xor_rectangle (sheet, sheet->drag_range);
3634       GTK_SHEET_UNSET_FLAGS (sheet, GTK_SHEET_IN_DRAG);
3635       gdk_display_pointer_ungrab (display, event->time);
3636
3637       gtk_sheet_real_unselect_range (sheet, NULL);
3638
3639       sheet->active_cell.row = sheet->active_cell.row +
3640         (sheet->drag_range.row0 - sheet->range.row0);
3641       sheet->active_cell.col = sheet->active_cell.col +
3642         (sheet->drag_range.col0 - sheet->range.col0);
3643       sheet->selection_cell.row = sheet->selection_cell.row +
3644         (sheet->drag_range.row0 - sheet->range.row0);
3645       sheet->selection_cell.col = sheet->selection_cell.col +
3646         (sheet->drag_range.col0 - sheet->range.col0);
3647       old_range = sheet->range;
3648       sheet->range = sheet->drag_range;
3649       sheet->drag_range = old_range;
3650       g_signal_emit (sheet, sheet_signals[MOVE_RANGE], 0,
3651                      &sheet->drag_range, &sheet->range);
3652       gtk_sheet_select_range (sheet, &sheet->range);
3653     }
3654
3655   if (GTK_SHEET_IN_RESIZE (sheet))
3656     {
3657       GtkSheetRange old_range;
3658       draw_xor_rectangle (sheet, sheet->drag_range);
3659       GTK_SHEET_UNSET_FLAGS (sheet, GTK_SHEET_IN_RESIZE);
3660       gdk_display_pointer_ungrab (display, event->time);
3661
3662       gtk_sheet_real_unselect_range (sheet, NULL);
3663
3664       sheet->active_cell.row = sheet->active_cell.row +
3665         (sheet->drag_range.row0 - sheet->range.row0);
3666       sheet->active_cell.col = sheet->active_cell.col +
3667         (sheet->drag_range.col0 - sheet->range.col0);
3668       if (sheet->drag_range.row0 < sheet->range.row0)
3669         sheet->selection_cell.row = sheet->drag_range.row0;
3670       if (sheet->drag_range.rowi >= sheet->range.rowi)
3671         sheet->selection_cell.row = sheet->drag_range.rowi;
3672       if (sheet->drag_range.col0 < sheet->range.col0)
3673         sheet->selection_cell.col = sheet->drag_range.col0;
3674       if (sheet->drag_range.coli >= sheet->range.coli)
3675         sheet->selection_cell.col = sheet->drag_range.coli;
3676       old_range = sheet->range;
3677       sheet->range = sheet->drag_range;
3678       sheet->drag_range = old_range;
3679
3680       if (sheet->state == GTK_STATE_NORMAL) sheet->state = GTK_SHEET_RANGE_SELECTED;
3681       g_signal_emit (sheet, sheet_signals[RESIZE_RANGE], 0,
3682                      &sheet->drag_range, &sheet->range);
3683       gtk_sheet_select_range (sheet, &sheet->range);
3684     }
3685
3686   if (sheet->state == GTK_SHEET_NORMAL && GTK_SHEET_IN_SELECTION (sheet))
3687     {
3688       GTK_SHEET_UNSET_FLAGS (sheet, GTK_SHEET_IN_SELECTION);
3689       gdk_display_pointer_ungrab (display, event->time);
3690       change_active_cell (sheet, sheet->active_cell.row,
3691                                sheet->active_cell.col);
3692     }
3693
3694   if (GTK_SHEET_IN_SELECTION)
3695     gdk_display_pointer_ungrab (display, event->time);
3696   gtk_grab_remove (GTK_WIDGET (sheet));
3697
3698   GTK_SHEET_UNSET_FLAGS (sheet, GTK_SHEET_IN_SELECTION);
3699
3700   return TRUE;
3701 }
3702
3703 \f
3704
3705
3706
3707 /* Shamelessly lifted from gtktooltips */
3708 static gboolean
3709 gtk_sheet_subtitle_paint_window (GtkWidget *tip_window)
3710 {
3711   GtkRequisition req;
3712
3713   gtk_widget_size_request (tip_window, &req);
3714   gtk_paint_flat_box (tip_window->style, tip_window->window,
3715                       GTK_STATE_NORMAL, GTK_SHADOW_OUT,
3716                       NULL, GTK_WIDGET(tip_window), "tooltip",
3717                       0, 0, req.width, req.height);
3718
3719   return FALSE;
3720 }
3721
3722 static void
3723 destroy_hover_window (GtkSheetHoverTitle *h)
3724 {
3725   gtk_widget_destroy (h->window);
3726   g_free (h);
3727 }
3728
3729 static GtkSheetHoverTitle *
3730 create_hover_window (void)
3731 {
3732   GtkSheetHoverTitle *hw = g_malloc (sizeof (*hw));
3733
3734   hw->window = gtk_window_new (GTK_WINDOW_POPUP);
3735
3736 #if GTK_CHECK_VERSION (2, 9, 0)
3737   gtk_window_set_type_hint (GTK_WINDOW (hw->window),
3738                             GDK_WINDOW_TYPE_HINT_TOOLTIP);
3739 #endif
3740
3741   gtk_widget_set_app_paintable (hw->window, TRUE);
3742   gtk_window_set_resizable (GTK_WINDOW (hw->window), FALSE);
3743   gtk_widget_set_name (hw->window, "gtk-tooltips");
3744   gtk_container_set_border_width (GTK_CONTAINER (hw->window), 4);
3745
3746   g_signal_connect (hw->window,
3747                     "expose_event",
3748                     G_CALLBACK (gtk_sheet_subtitle_paint_window),
3749                     NULL);
3750
3751   hw->label = gtk_label_new (NULL);
3752
3753
3754   gtk_label_set_line_wrap (GTK_LABEL (hw->label), TRUE);
3755   gtk_misc_set_alignment (GTK_MISC (hw->label), 0.5, 0.5);
3756
3757   gtk_container_add (GTK_CONTAINER (hw->window), hw->label);
3758
3759   gtk_widget_show (hw->label);
3760
3761   g_signal_connect (hw->window,
3762                     "destroy",
3763                     G_CALLBACK (gtk_widget_destroyed),
3764                     &hw->window);
3765
3766   return hw;
3767 }
3768
3769 #define HOVER_WINDOW_Y_OFFSET 2
3770
3771 static void
3772 show_subtitle (GtkSheet *sheet, gint row, gint column, const gchar *subtitle)
3773 {
3774   gint x, y;
3775   gint px, py;
3776   gint width;
3777
3778   if ( ! subtitle )
3779     return;
3780
3781   gtk_label_set_text (GTK_LABEL (sheet->hover_window->label),
3782                       subtitle);
3783
3784
3785   sheet->hover_window->row = row;
3786   sheet->hover_window->column = column;
3787
3788   gdk_window_get_origin (GTK_WIDGET (sheet)->window, &x, &y);
3789
3790   gtk_widget_get_pointer (GTK_WIDGET (sheet), &px, &py);
3791
3792   gtk_widget_show (sheet->hover_window->window);
3793
3794   width = GTK_WIDGET (sheet->hover_window->label)->allocation.width;
3795
3796   if (row == -1 )
3797     {
3798       x += px;
3799       x -= width / 2;
3800       y += sheet->column_title_area.y;
3801       y += sheet->column_title_area.height;
3802       y += HOVER_WINDOW_Y_OFFSET;
3803     }
3804
3805   if ( column == -1 )
3806     {
3807       y += py;
3808       x += sheet->row_title_area.x;
3809       x += sheet->row_title_area.width * 2 / 3.0;
3810     }
3811
3812   gtk_window_move (GTK_WINDOW (sheet->hover_window->window),
3813                    x, y);
3814 }
3815
3816 static gboolean
3817 motion_timeout_callback (gpointer data)
3818 {
3819   GtkSheet *sheet = GTK_SHEET (data);
3820   gint x, y;
3821   gint row, column;
3822   gtk_widget_get_pointer (GTK_WIDGET (sheet), &x, &y);
3823
3824   if ( gtk_sheet_get_pixel_info (sheet, x, y, &row, &column) )
3825     {
3826       if (sheet->row_title_under)
3827         {
3828           GSheetRow *row_geo = sheet->row_geometry;
3829           gchar *text = g_sheet_row_get_subtitle (row_geo, row);
3830
3831           show_subtitle (sheet, row, -1, text);
3832           g_free (text);
3833         }
3834
3835       if (sheet->column_title_under)
3836         {
3837           gchar *text = g_sheet_model_get_column_subtitle (sheet->model,
3838                                                            column);
3839
3840           show_subtitle (sheet, -1, column, text);
3841
3842           g_free (text);
3843         }
3844     }
3845
3846   return FALSE;
3847 }
3848
3849 static gboolean
3850 gtk_sheet_motion (GtkWidget *widget,  GdkEventMotion *event)
3851 {
3852   GtkSheet *sheet;
3853   GdkModifierType mods;
3854   GdkCursorType new_cursor;
3855   gint x, y;
3856   gint row, column;
3857   GdkDisplay *display;
3858
3859   g_return_val_if_fail (widget != NULL, FALSE);
3860   g_return_val_if_fail (GTK_IS_SHEET (widget), FALSE);
3861   g_return_val_if_fail (event != NULL, FALSE);
3862
3863   sheet = GTK_SHEET (widget);
3864
3865   display = gtk_widget_get_display (widget);
3866
3867   /* selections on the sheet */
3868   x = event->x;
3869   y = event->y;
3870
3871   if (!GTK_WIDGET_VISIBLE (sheet->hover_window->window))
3872     {
3873       if ( sheet->motion_timer > 0 )
3874         g_source_remove (sheet->motion_timer);
3875       sheet->motion_timer =
3876         g_timeout_add (TIMEOUT_HOVER, motion_timeout_callback, sheet);
3877     }
3878   else
3879     {
3880       gint row, column;
3881       gint wx, wy;
3882       gtk_widget_get_pointer (widget, &wx, &wy);
3883
3884       if ( gtk_sheet_get_pixel_info (sheet, wx, wy, &row, &column) )
3885         {
3886           if ( row != sheet->hover_window->row ||
3887                column != sheet->hover_window->column)
3888             {
3889               gtk_widget_hide (sheet->hover_window->window);
3890             }
3891         }
3892     }
3893
3894   if (event->window == sheet->column_title_window &&
3895       gtk_sheet_columns_resizable (sheet))
3896     {
3897       if (!GTK_SHEET_IN_SELECTION (sheet) &&
3898           on_column_boundary (sheet, x, &column))
3899         {
3900           new_cursor = GDK_SB_H_DOUBLE_ARROW;
3901           if (new_cursor != sheet->cursor_drag->type)
3902             {
3903               gdk_cursor_unref (sheet->cursor_drag);
3904               sheet->cursor_drag = gdk_cursor_new_for_display (display, GDK_SB_H_DOUBLE_ARROW);
3905               gdk_window_set_cursor (sheet->column_title_window,
3906                                      sheet->cursor_drag);
3907             }
3908         }
3909       else
3910         {
3911           new_cursor = GDK_TOP_LEFT_ARROW;
3912           if (!GTK_SHEET_IN_XDRAG (sheet) &&
3913               new_cursor != sheet->cursor_drag->type)
3914             {
3915               gdk_cursor_unref (sheet->cursor_drag);
3916               sheet->cursor_drag = gdk_cursor_new_for_display (display, GDK_TOP_LEFT_ARROW);
3917               gdk_window_set_cursor (sheet->column_title_window,
3918                                      sheet->cursor_drag);
3919             }
3920         }
3921     }
3922
3923   if (event->window == sheet->row_title_window &&
3924       gtk_sheet_rows_resizable (sheet))
3925     {
3926       if (!GTK_SHEET_IN_SELECTION (sheet) && POSSIBLE_YDRAG (sheet, y, &column))
3927         {
3928           new_cursor = GDK_SB_V_DOUBLE_ARROW;
3929           if (new_cursor != sheet->cursor_drag->type)
3930             {
3931               gdk_cursor_unref (sheet->cursor_drag);
3932               sheet->cursor_drag = gdk_cursor_new_for_display (display, GDK_SB_V_DOUBLE_ARROW);
3933               gdk_window_set_cursor (sheet->row_title_window, sheet->cursor_drag);
3934             }
3935         }
3936       else
3937         {
3938           new_cursor = GDK_TOP_LEFT_ARROW;
3939           if (!GTK_SHEET_IN_YDRAG (sheet) &&
3940               new_cursor != sheet->cursor_drag->type)
3941             {
3942               gdk_cursor_unref (sheet->cursor_drag);
3943               sheet->cursor_drag = gdk_cursor_new_for_display (display, GDK_TOP_LEFT_ARROW);
3944               gdk_window_set_cursor (sheet->row_title_window, sheet->cursor_drag);
3945             }
3946         }
3947     }
3948
3949   new_cursor = GDK_PLUS;
3950   if ( event->window == sheet->sheet_window &&
3951        !POSSIBLE_DRAG (sheet, x, y, &row, &column) &&
3952        !GTK_SHEET_IN_DRAG (sheet) &&
3953        !POSSIBLE_RESIZE (sheet, x, y, &row, &column) &&
3954        !GTK_SHEET_IN_RESIZE (sheet) &&
3955        new_cursor != sheet->cursor_drag->type)
3956     {
3957       gdk_cursor_unref (sheet->cursor_drag);
3958       sheet->cursor_drag = gdk_cursor_new_for_display (display, GDK_PLUS);
3959       gdk_window_set_cursor (sheet->sheet_window, sheet->cursor_drag);
3960     }
3961
3962   new_cursor = GDK_TOP_LEFT_ARROW;
3963   if ( event->window == sheet->sheet_window &&
3964        ! (POSSIBLE_RESIZE (sheet, x, y, &row, &column) ||
3965           GTK_SHEET_IN_RESIZE (sheet)) &&
3966        (POSSIBLE_DRAG (sheet, x, y, &row, &column) ||
3967         GTK_SHEET_IN_DRAG (sheet)) &&
3968        new_cursor != sheet->cursor_drag->type)
3969     {
3970       gdk_cursor_unref (sheet->cursor_drag);
3971       sheet->cursor_drag = gdk_cursor_new_for_display (display, GDK_TOP_LEFT_ARROW);
3972       gdk_window_set_cursor (sheet->sheet_window, sheet->cursor_drag);
3973     }
3974
3975   new_cursor = GDK_SIZING;
3976   if ( event->window == sheet->sheet_window &&
3977        sheet->selection_mode != GTK_SELECTION_NONE &&
3978        !GTK_SHEET_IN_DRAG (sheet) &&
3979        (POSSIBLE_RESIZE (sheet, x, y, &row, &column) ||
3980         GTK_SHEET_IN_RESIZE (sheet)) &&
3981        new_cursor != sheet->cursor_drag->type)
3982     {
3983       gdk_cursor_unref (sheet->cursor_drag);
3984       sheet->cursor_drag = gdk_cursor_new_for_display (display, GDK_SIZING);
3985       gdk_window_set_cursor (sheet->sheet_window, sheet->cursor_drag);
3986     }
3987
3988
3989   gdk_window_get_pointer (widget->window, &x, &y, &mods);
3990   if (! (mods & GDK_BUTTON1_MASK)) return FALSE;
3991
3992   if (GTK_SHEET_IN_XDRAG (sheet))
3993     {
3994       x = event->x;
3995
3996       new_column_width (sheet, sheet->drag_cell.col, &x);
3997 #if 0
3998       if (x != sheet->x_drag)
3999         {
4000           draw_xor_vline (sheet);
4001           sheet->x_drag = x;
4002           draw_xor_vline (sheet);
4003         }
4004 #endif
4005       return TRUE;
4006     }
4007
4008   if (GTK_SHEET_IN_YDRAG (sheet))
4009     {
4010       if (event->is_hint || event->window != widget->window)
4011         gtk_widget_get_pointer (widget, NULL, &y);
4012       else
4013         y = event->y;
4014
4015       new_row_height (sheet, sheet->drag_cell.row, &y);
4016       if (y != sheet->y_drag)
4017         {
4018           draw_xor_hline (sheet);
4019           sheet->y_drag = y;
4020           draw_xor_hline (sheet);
4021         }
4022       return TRUE;
4023     }
4024
4025   if (GTK_SHEET_IN_DRAG (sheet))
4026     {
4027       GtkSheetRange aux;
4028       column = column_from_xpixel (sheet, x)- sheet->drag_cell.col;
4029       row = yyy_row_ypixel_to_row (sheet, y) - sheet->drag_cell.row;
4030       if (sheet->state == GTK_SHEET_COLUMN_SELECTED) row = 0;
4031       if (sheet->state == GTK_SHEET_ROW_SELECTED) column = 0;
4032       sheet->x_drag = x;
4033       sheet->y_drag = y;
4034       aux = sheet->range;
4035       if (aux.row0 + row >= 0 && aux.rowi + row < g_sheet_row_get_row_count (sheet->row_geometry) &&
4036           aux.col0 + column >= 0 && aux.coli + column < psppire_axis_unit_count (sheet->haxis))
4037         {
4038           aux = sheet->drag_range;
4039           sheet->drag_range.row0 = sheet->range.row0 + row;
4040           sheet->drag_range.col0 = sheet->range.col0 + column;
4041           sheet->drag_range.rowi = sheet->range.rowi + row;
4042           sheet->drag_range.coli = sheet->range.coli + column;
4043           if (aux.row0 != sheet->drag_range.row0 ||
4044               aux.col0 != sheet->drag_range.col0)
4045             {
4046               draw_xor_rectangle (sheet, aux);
4047               draw_xor_rectangle (sheet, sheet->drag_range);
4048             }
4049         }
4050       return TRUE;
4051     }
4052
4053   if (GTK_SHEET_IN_RESIZE (sheet))
4054     {
4055       GtkSheetRange aux;
4056       gint v_h, current_col, current_row, col_threshold, row_threshold;
4057       v_h = 1;
4058       if (abs (x - psppire_axis_pixel_start (sheet->haxis, sheet->drag_cell.col)) >
4059           abs (y - g_sheet_row_start_pixel (sheet->row_geometry, sheet->drag_cell.row))) v_h = 2;
4060
4061       current_col = column_from_xpixel (sheet, x);
4062       current_row = yyy_row_ypixel_to_row (sheet, y);
4063       column = current_col - sheet->drag_cell.col;
4064       row = current_row - sheet->drag_cell.row;
4065
4066       /*use half of column width resp. row height as threshold to
4067         expand selection*/
4068       col_threshold = psppire_axis_pixel_start (sheet->haxis, current_col) +
4069         psppire_axis_unit_size (sheet->haxis, current_col) / 2;
4070       if (column > 0)
4071         {
4072           if (x < col_threshold)
4073             column -= 1;
4074         }
4075       else if (column < 0)
4076         {
4077           if (x > col_threshold)
4078             column +=1;
4079         }
4080       row_threshold = g_sheet_row_start_pixel (sheet->row_geometry, current_row) +
4081         g_sheet_row_get_height (sheet->row_geometry, current_row)/2;
4082       if (row > 0)
4083         {
4084           if (y < row_threshold)
4085             row -= 1;
4086         }
4087       else if (row < 0)
4088         {
4089           if (y > row_threshold)
4090             row +=1;
4091         }
4092
4093       if (sheet->state == GTK_SHEET_COLUMN_SELECTED) row = 0;
4094       if (sheet->state == GTK_SHEET_ROW_SELECTED) column = 0;
4095       sheet->x_drag = x;
4096       sheet->y_drag = y;
4097       aux = sheet->range;
4098
4099       if (v_h == 1)
4100         column = 0;
4101       else
4102         row = 0;
4103
4104       if (aux.row0 + row >= 0 && aux.rowi + row < g_sheet_row_get_row_count (sheet->row_geometry) &&
4105           aux.col0 + column >= 0 && aux.coli + column < psppire_axis_unit_count (sheet->haxis))
4106         {
4107           aux = sheet->drag_range;
4108           sheet->drag_range = sheet->range;
4109
4110           if (row < 0) sheet->drag_range.row0 = sheet->range.row0 + row;
4111           if (row > 0) sheet->drag_range.rowi = sheet->range.rowi + row;
4112           if (column < 0) sheet->drag_range.col0 = sheet->range.col0 + column;
4113           if (column > 0) sheet->drag_range.coli = sheet->range.coli + column;
4114
4115           if (aux.row0 != sheet->drag_range.row0 ||
4116               aux.rowi != sheet->drag_range.rowi ||
4117               aux.col0 != sheet->drag_range.col0 ||
4118               aux.coli != sheet->drag_range.coli)
4119             {
4120               draw_xor_rectangle (sheet, aux);
4121               draw_xor_rectangle (sheet, sheet->drag_range);
4122             }
4123         }
4124       return TRUE;
4125     }
4126
4127   gtk_sheet_get_pixel_info (sheet, x, y, &row, &column);
4128
4129   if (sheet->state == GTK_SHEET_NORMAL && row == sheet->active_cell.row &&
4130       column == sheet->active_cell.col) return TRUE;
4131
4132   if (GTK_SHEET_IN_SELECTION (sheet) && mods&GDK_BUTTON1_MASK)
4133     gtk_sheet_extend_selection (sheet, row, column);
4134
4135   return TRUE;
4136 }
4137
4138 static gboolean
4139 gtk_sheet_crossing_notify (GtkWidget *widget,
4140                            GdkEventCrossing *event)
4141 {
4142   GtkSheet *sheet = GTK_SHEET (widget);
4143
4144   if (event->window == sheet->column_title_window)
4145     sheet->column_title_under = event->type == GDK_ENTER_NOTIFY;
4146   else if (event->window == sheet->row_title_window)
4147     sheet->row_title_under = event->type == GDK_ENTER_NOTIFY;
4148
4149   return TRUE;
4150 }
4151
4152 static void
4153 gtk_sheet_extend_selection (GtkSheet *sheet, gint row, gint column)
4154 {
4155   GtkSheetRange range;
4156   gint state;
4157   gint r, c;
4158
4159   if (row == sheet->selection_cell.row && column == sheet->selection_cell.col)
4160     return;
4161
4162   if (sheet->selection_mode == GTK_SELECTION_SINGLE) return;
4163
4164   gtk_widget_grab_focus (GTK_WIDGET (sheet));
4165
4166   if (GTK_SHEET_IN_DRAG (sheet)) return;
4167
4168   state = sheet->state;
4169
4170   switch (sheet->state)
4171     {
4172     case GTK_SHEET_ROW_SELECTED:
4173       column = psppire_axis_unit_count (sheet->haxis) - 1;
4174       break;
4175     case GTK_SHEET_COLUMN_SELECTED:
4176       row = g_sheet_row_get_row_count (sheet->row_geometry) - 1;
4177       break;
4178     case GTK_SHEET_NORMAL:
4179       sheet->state = GTK_SHEET_RANGE_SELECTED;
4180       r = sheet->active_cell.row;
4181       c = sheet->active_cell.col;
4182       sheet->range.col0 = c;
4183       sheet->range.row0 = r;
4184       sheet->range.coli = c;
4185       sheet->range.rowi = r;
4186       gtk_sheet_range_draw_selection (sheet, sheet->range);
4187     case GTK_SHEET_RANGE_SELECTED:
4188       sheet->state = GTK_SHEET_RANGE_SELECTED;
4189     }
4190
4191   sheet->selection_cell.row = row;
4192   sheet->selection_cell.col = column;
4193
4194   range.col0 = MIN (column, sheet->active_cell.col);
4195   range.coli = MAX (column, sheet->active_cell.col);
4196   range.row0 = MIN (row, sheet->active_cell.row);
4197   range.rowi = MAX (row, sheet->active_cell.row);
4198
4199   if (range.row0 != sheet->range.row0 || range.rowi != sheet->range.rowi ||
4200       range.col0 != sheet->range.col0 || range.coli != sheet->range.coli ||
4201       state == GTK_SHEET_NORMAL)
4202     gtk_sheet_real_select_range (sheet, &range);
4203
4204 }
4205
4206 static gint
4207 gtk_sheet_entry_key_press (GtkWidget *widget,
4208                            GdkEventKey *key)
4209 {
4210   gboolean focus;
4211   g_signal_emit_by_name (widget, "key_press_event", key, &focus);
4212   return focus;
4213 }
4214
4215
4216 /* Number of rows in a step-increment */
4217 #define ROWS_PER_STEP 1
4218
4219
4220 static void
4221 page_vertical (GtkSheet *sheet, GtkScrollType dir)
4222 {
4223   gint old_row = sheet->active_cell.row ;
4224   glong vpixel = g_sheet_row_start_pixel (sheet->row_geometry, old_row);
4225
4226   gint new_row;
4227
4228   vpixel -= g_sheet_row_start_pixel (sheet->row_geometry,
4229                                      min_visible_row (sheet));
4230
4231   switch ( dir)
4232     {
4233     case GTK_SCROLL_PAGE_DOWN:
4234       gtk_adjustment_set_value (sheet->vadjustment,
4235                                 sheet->vadjustment->value +
4236                                 sheet->vadjustment->page_increment);
4237       break;
4238     case GTK_SCROLL_PAGE_UP:
4239       gtk_adjustment_set_value (sheet->vadjustment,
4240                                 sheet->vadjustment->value -
4241                                 sheet->vadjustment->page_increment);
4242
4243       break;
4244     default:
4245       g_assert_not_reached ();
4246       break;
4247     }
4248
4249
4250   vpixel += g_sheet_row_start_pixel (sheet->row_geometry,
4251                                      min_visible_row (sheet));
4252
4253   new_row =  yyy_row_ypixel_to_row (sheet, vpixel);
4254
4255   change_active_cell (sheet, new_row,
4256                            sheet->active_cell.col);
4257 }
4258
4259
4260 static void
4261 step_sheet (GtkSheet *sheet, GtkScrollType dir)
4262 {
4263   gint current_row = sheet->active_cell.row;
4264   gint current_col = sheet->active_cell.col;
4265   GtkSheetCell new_cell ;
4266   gboolean forbidden = FALSE;
4267
4268   new_cell.row = current_row;
4269   new_cell.col = current_col;
4270
4271   switch ( dir)
4272     {
4273     case GTK_SCROLL_STEP_DOWN:
4274       new_cell.row++;
4275       break;
4276     case GTK_SCROLL_STEP_UP:
4277       new_cell.row--;
4278       break;
4279     case GTK_SCROLL_STEP_RIGHT:
4280       new_cell.col++;
4281       break;
4282     case GTK_SCROLL_STEP_LEFT:
4283       new_cell.col--;
4284       break;
4285     default:
4286       g_assert_not_reached ();
4287       break;
4288     }
4289
4290
4291   maximize_int (&new_cell.row, 0);
4292   maximize_int (&new_cell.col, 0);
4293
4294   minimize_int (&new_cell.row,
4295                 g_sheet_row_get_row_count (sheet->row_geometry) - 1);
4296
4297   minimize_int (&new_cell.col,
4298                 psppire_axis_unit_count (sheet->haxis) - 1);
4299
4300   g_signal_emit (sheet, sheet_signals[TRAVERSE], 0,
4301                  &sheet->active_cell,
4302                  &new_cell,
4303                 &forbidden);
4304
4305   if (forbidden)
4306     return;
4307
4308   change_active_cell (sheet, new_cell.row, new_cell.col);
4309
4310   if ( new_cell.col > max_fully_visible_column (sheet))
4311     {
4312       glong hpos  =
4313         psppire_axis_pixel_start (sheet->haxis,
4314                                     new_cell.col + 1);
4315       hpos -= sheet->hadjustment->page_size;
4316
4317       gtk_adjustment_set_value (sheet->hadjustment,
4318                                 hpos);
4319     }
4320   else if ( new_cell.col < min_fully_visible_column (sheet))
4321     {
4322       glong hpos  =
4323         psppire_axis_pixel_start (sheet->haxis,
4324                                     new_cell.col);
4325
4326       gtk_adjustment_set_value (sheet->hadjustment,
4327                                 hpos);
4328     }
4329
4330
4331   if ( new_cell.row > max_fully_visible_row (sheet))
4332     {
4333       glong vpos  =
4334         g_sheet_row_start_pixel (sheet->row_geometry,
4335                                     new_cell.row + 1);
4336       vpos -= sheet->vadjustment->page_size;
4337
4338       gtk_adjustment_set_value (sheet->vadjustment,
4339                                 vpos);
4340     }
4341   else if ( new_cell.row < min_fully_visible_row (sheet))
4342     {
4343       glong vpos  =
4344         g_sheet_row_start_pixel (sheet->row_geometry,
4345                                     new_cell.row);
4346
4347       gtk_adjustment_set_value (sheet->vadjustment,
4348                                 vpos);
4349     }
4350 }
4351
4352
4353 static gboolean
4354 gtk_sheet_key_press (GtkWidget *widget,
4355                      GdkEventKey *key)
4356 {
4357   GtkSheet *sheet = GTK_SHEET (widget);
4358
4359   GTK_SHEET_UNSET_FLAGS (sheet, GTK_SHEET_IN_SELECTION);
4360
4361   switch (key->keyval)
4362     {
4363     case GDK_Tab:
4364     case GDK_Right:
4365       step_sheet (sheet, GTK_SCROLL_STEP_RIGHT);
4366       break;
4367     case GDK_ISO_Left_Tab:
4368     case GDK_Left:
4369       step_sheet (sheet, GTK_SCROLL_STEP_LEFT);
4370       break;
4371     case GDK_Return:
4372     case GDK_Down:
4373       step_sheet (sheet, GTK_SCROLL_STEP_DOWN);
4374       break;
4375     case GDK_Up:
4376       step_sheet (sheet, GTK_SCROLL_STEP_UP);
4377       break;
4378
4379     case GDK_Page_Down:
4380       page_vertical (sheet, GTK_SCROLL_PAGE_DOWN);
4381       break;
4382     case GDK_Page_Up:
4383       page_vertical (sheet, GTK_SCROLL_PAGE_UP);
4384       break;
4385
4386     case GDK_Home:
4387       gtk_adjustment_set_value (sheet->vadjustment,
4388                                 sheet->vadjustment->lower);
4389
4390       change_active_cell (sheet,  0,
4391                                sheet->active_cell.col);
4392
4393       break;
4394
4395     case GDK_End:
4396       gtk_adjustment_set_value (sheet->vadjustment,
4397                                 sheet->vadjustment->upper -
4398                                 sheet->vadjustment->page_size -
4399                                 sheet->vadjustment->page_increment);
4400
4401       /*
4402         change_active_cellx (sheet,
4403         g_sheet_row_get_row_count (sheet->row_geometry) - 1,
4404         sheet->active_cell.col);
4405       */
4406       break;
4407     case GDK_Delete:
4408       gtk_sheet_real_cell_clear (sheet, sheet->active_cell.row, sheet->active_cell.col);
4409       break;
4410     default:
4411       return FALSE;
4412       break;
4413     }
4414
4415   return TRUE;
4416 }
4417
4418 static void
4419 gtk_sheet_size_request (GtkWidget *widget,
4420                         GtkRequisition *requisition)
4421 {
4422   GtkSheet *sheet;
4423
4424   g_return_if_fail (widget != NULL);
4425   g_return_if_fail (GTK_IS_SHEET (widget));
4426   g_return_if_fail (requisition != NULL);
4427
4428   sheet = GTK_SHEET (widget);
4429
4430   requisition->width = 3 * DEFAULT_COLUMN_WIDTH;
4431   requisition->height = 3 * DEFAULT_ROW_HEIGHT;
4432
4433   /* compute the size of the column title area */
4434   if (sheet->column_titles_visible)
4435     requisition->height += sheet->column_title_area.height;
4436
4437   /* compute the size of the row title area */
4438   if (sheet->row_titles_visible)
4439     requisition->width += sheet->row_title_area.width;
4440 }
4441
4442
4443 static void
4444 gtk_sheet_size_allocate (GtkWidget *widget,
4445                          GtkAllocation *allocation)
4446 {
4447   GtkSheet *sheet;
4448   GtkAllocation sheet_allocation;
4449   gint border_width;
4450
4451   g_return_if_fail (widget != NULL);
4452   g_return_if_fail (GTK_IS_SHEET (widget));
4453   g_return_if_fail (allocation != NULL);
4454
4455   sheet = GTK_SHEET (widget);
4456   widget->allocation = *allocation;
4457   border_width = GTK_CONTAINER (widget)->border_width;
4458
4459   if (GTK_WIDGET_REALIZED (widget))
4460     gdk_window_move_resize (widget->window,
4461                             allocation->x + border_width,
4462                             allocation->y + border_width,
4463                             allocation->width - 2 * border_width,
4464                             allocation->height - 2 * border_width);
4465
4466   /* use internal allocation structure for all the math
4467    * because it's easier than always subtracting the container
4468    * border width */
4469   sheet->internal_allocation.x = 0;
4470   sheet->internal_allocation.y = 0;
4471   sheet->internal_allocation.width = allocation->width - 2 * border_width;
4472   sheet->internal_allocation.height = allocation->height - 2 * border_width;
4473
4474   sheet_allocation.x = 0;
4475   sheet_allocation.y = 0;
4476   sheet_allocation.width = allocation->width - 2 * border_width;
4477   sheet_allocation.height = allocation->height - 2 * border_width;
4478
4479   if (GTK_WIDGET_REALIZED (widget))
4480     gdk_window_move_resize (sheet->sheet_window,
4481                             sheet_allocation.x,
4482                             sheet_allocation.y,
4483                             sheet_allocation.width,
4484                             sheet_allocation.height);
4485
4486   /* position the window which holds the column title buttons */
4487   sheet->column_title_area.x = 0;
4488   sheet->column_title_area.y = 0;
4489
4490   if (sheet->row_titles_visible)
4491     {
4492       sheet->column_title_area.x = sheet->row_title_area.width;
4493     }
4494
4495   sheet->column_title_area.width = sheet_allocation.width ;
4496
4497
4498   if (GTK_WIDGET_REALIZED (widget) && sheet->column_titles_visible)
4499     gdk_window_move_resize (sheet->column_title_window,
4500                             sheet->column_title_area.x,
4501                             sheet->column_title_area.y,
4502                             sheet->column_title_area.width,
4503                             sheet->column_title_area.height);
4504
4505
4506   /* column button allocation */
4507   draw_column_title_buttons (sheet);
4508
4509   /* position the window which holds the row title buttons */
4510   sheet->row_title_area.x = 0;
4511   sheet->row_title_area.y = 0;
4512   if (sheet->column_titles_visible)
4513     {
4514       sheet->row_title_area.y = sheet->column_title_area.height;
4515     }
4516
4517   sheet->row_title_area.height = sheet_allocation.height -
4518     sheet->row_title_area.y;
4519
4520   if (GTK_WIDGET_REALIZED (widget) && sheet->row_titles_visible)
4521     gdk_window_move_resize (sheet->row_title_window,
4522                             sheet->row_title_area.x,
4523                             sheet->row_title_area.y,
4524                             sheet->row_title_area.width,
4525                             sheet->row_title_area.height);
4526
4527
4528   /* row button allocation */
4529   draw_row_title_buttons (sheet);
4530   draw_column_title_buttons (sheet);
4531
4532   /* set the scrollbars adjustments */
4533   adjust_scrollbars (sheet);
4534 }
4535
4536 static void
4537 draw_column_title_buttons (GtkSheet *sheet)
4538 {
4539   gint i;
4540   gint x, width;
4541
4542   if (!sheet->column_titles_visible) return;
4543   if (!GTK_WIDGET_REALIZED (sheet))
4544     return;
4545
4546   gdk_drawable_get_size (sheet->sheet_window, &width, NULL);
4547   x = 0;
4548
4549   if (sheet->row_titles_visible)
4550     {
4551       x = sheet->row_title_area.width;
4552     }
4553
4554   if (sheet->column_title_area.width != width || sheet->column_title_area.x != x)
4555     {
4556       sheet->column_title_area.width = width;
4557       sheet->column_title_area.x = x;
4558       gdk_window_move_resize (sheet->column_title_window,
4559                               sheet->column_title_area.x,
4560                               sheet->column_title_area.y,
4561                               sheet->column_title_area.width,
4562                               sheet->column_title_area.height);
4563     }
4564
4565   if (max_visible_column (sheet) ==
4566       psppire_axis_unit_count (sheet->haxis) - 1)
4567     gdk_window_clear_area (sheet->column_title_window,
4568                            0, 0,
4569                            sheet->column_title_area.width,
4570                            sheet->column_title_area.height);
4571
4572   if (!GTK_WIDGET_DRAWABLE (sheet)) return;
4573
4574   size_allocate_global_button (sheet);
4575
4576   for (i = min_visible_column (sheet); i <= max_visible_column (sheet); i++)
4577     gtk_sheet_column_title_button_draw (sheet, i);
4578 }
4579
4580 static void
4581 draw_row_title_buttons (GtkSheet *sheet)
4582 {
4583   gint i;
4584   gint y = 0;
4585   gint height;
4586
4587   if (!sheet->row_titles_visible) return;
4588   if (!GTK_WIDGET_REALIZED (sheet))
4589     return;
4590
4591   gdk_drawable_get_size (sheet->sheet_window, NULL, &height);
4592
4593   if (sheet->column_titles_visible)
4594     {
4595       y = sheet->column_title_area.height;
4596     }
4597
4598   if (sheet->row_title_area.height != height || sheet->row_title_area.y != y)
4599     {
4600       sheet->row_title_area.y = y;
4601       sheet->row_title_area.height = height;
4602       gdk_window_move_resize (sheet->row_title_window,
4603                               sheet->row_title_area.x,
4604                               sheet->row_title_area.y,
4605                               sheet->row_title_area.width,
4606                               sheet->row_title_area.height);
4607     }
4608
4609   if (max_visible_row (sheet) == g_sheet_row_get_row_count (sheet->row_geometry) - 1)
4610     gdk_window_clear_area (sheet->row_title_window,
4611                            0, 0,
4612                            sheet->row_title_area.width,
4613                            sheet->row_title_area.height);
4614
4615   if (!GTK_WIDGET_DRAWABLE (sheet)) return;
4616
4617   size_allocate_global_button (sheet);
4618
4619   for (i = min_visible_row (sheet); i <= max_visible_row (sheet); i++)
4620     {
4621       if ( i >= g_sheet_row_get_row_count (sheet->row_geometry))
4622         break;
4623       gtk_sheet_row_title_button_draw (sheet, i);
4624     }
4625 }
4626
4627
4628 static void
4629 gtk_sheet_size_allocate_entry (GtkSheet *sheet)
4630 {
4631   GtkAllocation entry_alloc;
4632   GtkSheetCellAttr attributes = { 0 };
4633   GtkEntry *sheet_entry;
4634
4635
4636   if (!GTK_WIDGET_REALIZED (GTK_WIDGET (sheet))) return;
4637   if (!GTK_WIDGET_MAPPED (GTK_WIDGET (sheet))) return;
4638
4639   sheet_entry = GTK_ENTRY (gtk_sheet_get_entry (sheet));
4640
4641   if ( ! gtk_sheet_get_attributes (sheet, sheet->active_cell.row,
4642                                    sheet->active_cell.col,
4643                                    &attributes) )
4644     return ;
4645
4646   gtk_widget_ensure_style (GTK_WIDGET (sheet_entry));
4647
4648   if ( GTK_WIDGET_REALIZED (sheet->entry_widget) )
4649     {
4650       GtkStyle *style = GTK_WIDGET (sheet_entry)->style;
4651
4652       style->bg[GTK_STATE_NORMAL] = attributes.background;
4653       style->fg[GTK_STATE_NORMAL] = attributes.foreground;
4654       style->text[GTK_STATE_NORMAL] = attributes.foreground;
4655       style->bg[GTK_STATE_ACTIVE] = attributes.background;
4656       style->fg[GTK_STATE_ACTIVE] = attributes.foreground;
4657       style->text[GTK_STATE_ACTIVE] = attributes.foreground;
4658
4659       pango_font_description_free (style->font_desc);
4660       g_assert (attributes.font_desc);
4661       style->font_desc = pango_font_description_copy (attributes.font_desc);
4662     }
4663
4664   rectangle_from_cell (sheet, sheet->active_cell.row,
4665                        sheet->active_cell.col, &entry_alloc);
4666
4667   gtk_widget_set_size_request (sheet->entry_widget, entry_alloc.width,
4668                                entry_alloc.height);
4669   gtk_widget_size_allocate (sheet->entry_widget, &entry_alloc);
4670 }
4671
4672
4673 static void
4674 create_sheet_entry (GtkSheet *sheet)
4675 {
4676   if (sheet->entry_widget)
4677     {
4678       gtk_widget_unparent (sheet->entry_widget);
4679     }
4680
4681   if (sheet->entry_type)
4682     {
4683       sheet->entry_container = g_object_new (sheet->entry_type, NULL);
4684       g_object_ref_sink (sheet->entry_container);
4685       sheet->entry_widget = gtk_sheet_get_entry (sheet);
4686
4687       if  ( NULL == sheet->entry_widget)
4688         {
4689           g_warning ("Entry type is %s. It must be GtkEntry subclass, or a widget containing one. "
4690                      "Using default", g_type_name (sheet->entry_type));
4691           g_object_unref (sheet->entry_container);
4692           sheet->entry_widget = sheet->entry_container = gtk_entry_new ();
4693         }
4694       else
4695         {
4696           sheet->entry_widget = sheet->entry_container ;
4697         }
4698     }
4699   else
4700     {
4701       sheet->entry_widget = sheet->entry_container = gtk_entry_new ();
4702       g_object_ref_sink (sheet->entry_container);
4703     }
4704
4705   gtk_widget_size_request (sheet->entry_widget, NULL);
4706
4707   if (GTK_WIDGET_REALIZED (sheet))
4708     {
4709       gtk_widget_set_parent_window (sheet->entry_widget, sheet->sheet_window);
4710       gtk_widget_set_parent (sheet->entry_widget, GTK_WIDGET (sheet));
4711       gtk_widget_realize (sheet->entry_widget);
4712     }
4713
4714   g_signal_connect_swapped (sheet->entry_widget, "key_press_event",
4715                             G_CALLBACK (gtk_sheet_entry_key_press),
4716                             sheet);
4717
4718   sheet->entry_handler_id =
4719     g_signal_connect (sheet->entry_widget,
4720                       "changed",
4721                       G_CALLBACK (gtk_sheet_entry_changed),
4722                       sheet);
4723
4724   gtk_widget_show (sheet->entry_widget);
4725 }
4726
4727
4728 /* Finds the last child widget that happens to be of type GtkEntry */
4729 static void
4730 find_entry (GtkWidget *w, gpointer user_data)
4731 {
4732   GtkWidget **entry = user_data;
4733   if ( GTK_IS_ENTRY (w))
4734     {
4735       *entry = w;
4736     }
4737 }
4738
4739 GtkWidget *
4740 gtk_sheet_get_entry (GtkSheet *sheet)
4741 {
4742   GtkWidget *parent;
4743   GtkWidget *entry = NULL;
4744
4745   g_return_val_if_fail (sheet != NULL, NULL);
4746   g_return_val_if_fail (GTK_IS_SHEET (sheet), NULL);
4747   g_return_val_if_fail (sheet->entry_widget != NULL, NULL);
4748
4749   if (GTK_IS_ENTRY (sheet->entry_container))
4750     return (sheet->entry_container);
4751
4752   parent = sheet->entry_container;
4753
4754   if (GTK_IS_CONTAINER (parent))
4755     {
4756       gtk_container_forall (GTK_CONTAINER (parent), find_entry, &entry);
4757
4758       if (GTK_IS_ENTRY (entry))
4759         return entry;
4760     }
4761
4762   if (!GTK_IS_ENTRY (entry)) return NULL;
4763
4764   return (entry);
4765
4766 }
4767
4768 GtkWidget *
4769 gtk_sheet_get_entry_widget (GtkSheet *sheet)
4770 {
4771   g_return_val_if_fail (sheet != NULL, NULL);
4772   g_return_val_if_fail (GTK_IS_SHEET (sheet), NULL);
4773   g_return_val_if_fail (sheet->entry_widget != NULL, NULL);
4774
4775   return (sheet->entry_widget);
4776 }
4777
4778
4779 static void
4780 gtk_sheet_button_draw (GtkSheet *sheet, GdkWindow *window,
4781                        GtkSheetButton *button, gboolean is_sensitive,
4782                        GdkRectangle allocation)
4783 {
4784   GtkShadowType shadow_type;
4785   gint text_width = 0, text_height = 0;
4786   PangoAlignment align = PANGO_ALIGN_LEFT;
4787
4788   gboolean rtl ;
4789
4790   gint state = 0;
4791   gint len = 0;
4792   gchar *line = 0;
4793
4794   g_return_if_fail (sheet != NULL);
4795   g_return_if_fail (button != NULL);
4796
4797
4798   rtl = gtk_widget_get_direction (GTK_WIDGET (sheet)) == GTK_TEXT_DIR_RTL;
4799
4800   gdk_window_clear_area (window,
4801                          allocation.x, allocation.y,
4802                          allocation.width, allocation.height);
4803
4804   gtk_paint_box (sheet->button->style, window,
4805                  GTK_STATE_NORMAL, GTK_SHADOW_OUT,
4806                  &allocation, GTK_WIDGET (sheet->button),
4807                  "buttondefault",
4808                  allocation.x, allocation.y,
4809                  allocation.width, allocation.height);
4810
4811   state = button->state;
4812   if (!is_sensitive) state = GTK_STATE_INSENSITIVE;
4813
4814   if (state == GTK_STATE_ACTIVE)
4815     shadow_type = GTK_SHADOW_IN;
4816   else
4817     shadow_type = GTK_SHADOW_OUT;
4818
4819   if (state != GTK_STATE_NORMAL && state != GTK_STATE_INSENSITIVE)
4820     gtk_paint_box (sheet->button->style, window,
4821                    button->state, shadow_type,
4822                    &allocation, GTK_WIDGET (sheet->button),
4823                    "button",
4824                    allocation.x, allocation.y,
4825                    allocation.width, allocation.height);
4826
4827   if (button->label_visible)
4828     {
4829
4830       text_height = DEFAULT_ROW_HEIGHT -
4831         2 * COLUMN_TITLES_HEIGHT;
4832
4833       gdk_gc_set_clip_rectangle (GTK_WIDGET (sheet)->style->fg_gc[button->state],
4834                                  &allocation);
4835       gdk_gc_set_clip_rectangle (GTK_WIDGET (sheet)->style->white_gc,
4836                                  &allocation);
4837
4838       allocation.y += 2 * sheet->button->style->ythickness;
4839
4840
4841       if (button->label && strlen (button->label)>0)
4842         {
4843           gchar *words = 0;
4844           PangoLayout *layout = NULL;
4845           gint real_x = allocation.x, real_y = allocation.y;
4846
4847           words = button->label;
4848           line = g_new (gchar, 1);
4849           line[0]='\0';
4850
4851           while (words && *words != '\0')
4852             {
4853               if (*words != '\n')
4854                 {
4855                   len = strlen (line);
4856                   line = g_realloc (line, len + 2);
4857                   line[len]=*words;
4858                   line[len + 1]='\0';
4859                 }
4860               if (*words == '\n' || * (words + 1) == '\0')
4861                 {
4862                   text_width = STRING_WIDTH (GTK_WIDGET (sheet), GTK_WIDGET (sheet)->style->font_desc, line);
4863
4864                   layout = gtk_widget_create_pango_layout (GTK_WIDGET (sheet), line);
4865                   switch (button->justification)
4866                     {
4867                     case GTK_JUSTIFY_LEFT:
4868                       real_x = allocation.x + COLUMN_TITLES_HEIGHT;
4869                       align = rtl ? PANGO_ALIGN_RIGHT : PANGO_ALIGN_LEFT;
4870                       break;
4871                     case GTK_JUSTIFY_RIGHT:
4872                       real_x = allocation.x + allocation.width - text_width - COLUMN_TITLES_HEIGHT;
4873                       align = rtl ? PANGO_ALIGN_LEFT : PANGO_ALIGN_RIGHT;
4874                       break;
4875                     case GTK_JUSTIFY_CENTER:
4876                     default:
4877                       real_x = allocation.x + (allocation.width - text_width)/2;
4878                       align = rtl ? PANGO_ALIGN_RIGHT : PANGO_ALIGN_LEFT;
4879                       pango_layout_set_justify (layout, TRUE);
4880                     }
4881                   pango_layout_set_alignment (layout, align);
4882                   gtk_paint_layout (GTK_WIDGET (sheet)->style,
4883                                     window,
4884                                     state,
4885                                     FALSE,
4886                                     &allocation,
4887                                     GTK_WIDGET (sheet),
4888                                     "label",
4889                                     real_x, real_y,
4890                                     layout);
4891                   g_object_unref (layout);
4892
4893                   real_y += text_height + 2;
4894
4895                   g_free (line);
4896                   line = g_new (gchar, 1);
4897                   line[0]='\0';
4898                 }
4899               words++;
4900             }
4901           g_free (line);
4902         }
4903
4904       gdk_gc_set_clip_rectangle (GTK_WIDGET (sheet)->style->fg_gc[button->state],
4905                                  NULL);
4906       gdk_gc_set_clip_rectangle (GTK_WIDGET (sheet)->style->white_gc, NULL);
4907
4908     }
4909
4910   gtk_sheet_button_free (button);
4911 }
4912
4913 static void
4914 gtk_sheet_column_title_button_draw (GtkSheet *sheet, gint column)
4915 {
4916   GdkRectangle allocation;
4917   GtkSheetButton *button = NULL;
4918   gboolean is_sensitive = FALSE;
4919
4920   if (!GTK_WIDGET_REALIZED (GTK_WIDGET (sheet))) return;
4921
4922   if (!sheet->column_titles_visible) return;
4923
4924   if (column < min_visible_column (sheet)) return;
4925   if (column > max_visible_column (sheet)) return;
4926
4927   button = g_sheet_model_get_column_button (sheet->model, column);
4928   allocation.y = 0;
4929   allocation.x = psppire_axis_pixel_start (sheet->haxis, column) + CELL_SPACING;
4930   allocation.x -= sheet->hadjustment->value;
4931
4932   allocation.height = sheet->column_title_area.height;
4933   allocation.width = psppire_axis_unit_size (sheet->haxis, column);
4934   is_sensitive = g_sheet_model_get_column_sensitivity (sheet->model, column);
4935
4936   gtk_sheet_button_draw (sheet, sheet->column_title_window,
4937                          button, is_sensitive, allocation);
4938 }
4939
4940
4941 static void
4942 gtk_sheet_row_title_button_draw (GtkSheet *sheet, gint row)
4943 {
4944   GdkRectangle allocation;
4945   GtkSheetButton *button = NULL;
4946   gboolean is_sensitive = FALSE;
4947
4948
4949   if (!GTK_WIDGET_REALIZED (GTK_WIDGET (sheet))) return;
4950
4951   if (!sheet->row_titles_visible) return;
4952
4953   if (row < min_visible_row (sheet)) return;
4954   if (row > max_visible_row (sheet)) return;
4955
4956   button = g_sheet_row_get_button (sheet->row_geometry, row);
4957   allocation.x = 0;
4958   allocation.y = g_sheet_row_start_pixel (sheet->row_geometry, row) + CELL_SPACING;
4959   allocation.y -= sheet->vadjustment->value;
4960
4961   allocation.width = sheet->row_title_area.width;
4962   allocation.height = g_sheet_row_get_height (sheet->row_geometry, row);
4963   is_sensitive = g_sheet_row_get_sensitivity (sheet->row_geometry, row);
4964
4965   gtk_sheet_button_draw (sheet, sheet->row_title_window,
4966                          button, is_sensitive, allocation);
4967 }
4968
4969 /* SCROLLBARS
4970  *
4971  * functions:
4972  * adjust_scrollbars
4973  * vadjustment_value_changed
4974  * hadjustment_value_changed */
4975
4976 static void
4977 adjust_scrollbars (GtkSheet *sheet)
4978 {
4979   gint width, height;
4980
4981   if (!GTK_WIDGET_REALIZED (GTK_WIDGET (sheet)))
4982     return;
4983
4984   gdk_drawable_get_size (sheet->sheet_window, &width, &height);
4985
4986   if ( sheet->row_titles_visible)
4987     width -= sheet->row_title_area.width;
4988
4989   if (sheet->column_titles_visible)
4990     height -= sheet->column_title_area.height;
4991
4992   if (sheet->vadjustment)
4993     {
4994       glong last_row = g_sheet_row_get_row_count (sheet->row_geometry) - 1;
4995
4996       sheet->vadjustment->step_increment =
4997         ROWS_PER_STEP *
4998         g_sheet_row_get_height (sheet->row_geometry, last_row);
4999
5000       sheet->vadjustment->page_increment =
5001         height -
5002         sheet->column_title_area.height -
5003         g_sheet_row_get_height (sheet->row_geometry, last_row);
5004
5005
5006
5007       sheet->vadjustment->upper =
5008         g_sheet_row_start_pixel (sheet->row_geometry, last_row)
5009         +
5010         g_sheet_row_get_height (sheet->row_geometry, last_row)
5011         ;
5012
5013       sheet->vadjustment->lower = 0;
5014       sheet->vadjustment->page_size = height;
5015
5016       g_signal_emit_by_name (sheet->vadjustment, "changed");
5017     }
5018
5019   if (sheet->hadjustment)
5020     {
5021       gint last_col;
5022       sheet->hadjustment->step_increment = 1;
5023
5024       sheet->hadjustment->page_increment = width;
5025
5026       last_col = psppire_axis_unit_count (sheet->haxis) - 1;
5027
5028       sheet->hadjustment->upper =
5029         psppire_axis_pixel_start (sheet->haxis, last_col)
5030         +
5031         psppire_axis_unit_size (sheet->haxis, last_col)
5032         ;
5033
5034       sheet->hadjustment->lower = 0;
5035       sheet->hadjustment->page_size = width;
5036
5037       g_signal_emit_by_name (sheet->hadjustment, "changed");
5038     }
5039 }
5040
5041 static void
5042 vadjustment_value_changed (GtkAdjustment *adjustment,
5043                            gpointer data)
5044 {
5045   GdkRegion *region;
5046   GtkSheet *sheet = GTK_SHEET (data);
5047
5048   g_return_if_fail (adjustment != NULL);
5049
5050   if ( ! GTK_WIDGET_REALIZED (sheet)) return;
5051
5052
5053   gtk_widget_hide (sheet->entry_widget);
5054
5055   region =
5056     gdk_drawable_get_visible_region (GDK_DRAWABLE (sheet->sheet_window));
5057
5058   gdk_window_begin_paint_region (sheet->sheet_window, region);
5059
5060
5061   gtk_sheet_range_draw (sheet, NULL);
5062   draw_row_title_buttons (sheet);
5063   //  size_allocate_global_button (sheet);
5064
5065   gdk_window_end_paint (sheet->sheet_window);
5066 }
5067
5068
5069 static void
5070 hadjustment_value_changed (GtkAdjustment *adjustment,
5071                            gpointer data)
5072 {
5073   GdkRegion *region;
5074   GtkSheet *sheet = GTK_SHEET (data);
5075
5076   g_return_if_fail (adjustment != NULL);
5077
5078   if ( ! GTK_WIDGET_REALIZED (sheet)) return;
5079
5080   gtk_widget_hide (sheet->entry_widget);
5081
5082
5083   region =
5084     gdk_drawable_get_visible_region (GDK_DRAWABLE (sheet->sheet_window));
5085
5086   gdk_window_begin_paint_region (sheet->sheet_window, region);
5087
5088   gtk_sheet_range_draw (sheet, NULL);
5089   draw_column_title_buttons (sheet);
5090   //  size_allocate_global_button (sheet);
5091
5092   gdk_window_end_paint (sheet->sheet_window);
5093 }
5094
5095
5096 /* COLUMN RESIZING */
5097 static void
5098 draw_xor_vline (GtkSheet *sheet)
5099 {
5100   gint height;
5101   gint xpos = sheet->x_drag;
5102   gdk_drawable_get_size (sheet->sheet_window,
5103                          NULL, &height);
5104
5105
5106   if (sheet->row_titles_visible)
5107     xpos += sheet->row_title_area.width;
5108
5109   gdk_draw_line (GTK_WIDGET (sheet)->window, sheet->xor_gc,
5110                  xpos,
5111                  sheet->column_title_area.height,
5112                  xpos,
5113                  height + CELL_SPACING);
5114 }
5115
5116 /* ROW RESIZING */
5117 static void
5118 draw_xor_hline (GtkSheet *sheet)
5119
5120 {
5121   gint width;
5122   gint ypos = sheet->y_drag;
5123
5124   gdk_drawable_get_size (sheet->sheet_window,
5125                          &width, NULL);
5126
5127
5128   if (sheet->column_titles_visible)
5129     ypos += sheet->column_title_area.height;
5130
5131   gdk_draw_line (GTK_WIDGET (sheet)->window, sheet->xor_gc,
5132                  sheet->row_title_area.width,
5133                  ypos,
5134                  width + CELL_SPACING,
5135                  ypos);
5136 }
5137
5138 /* SELECTED RANGE */
5139 static void
5140 draw_xor_rectangle (GtkSheet *sheet, GtkSheetRange range)
5141 {
5142   gint i = 0;
5143   GdkRectangle clip_area, area;
5144   GdkGCValues values;
5145
5146   area.x = psppire_axis_pixel_start (sheet->haxis, range.col0);
5147   area.y = g_sheet_row_start_pixel (sheet->row_geometry, range.row0);
5148   area.width = psppire_axis_pixel_start (sheet->haxis, range.coli)- area.x+
5149     psppire_axis_unit_size (sheet->haxis, range.coli);
5150   area.height = g_sheet_row_start_pixel (sheet->row_geometry, range.rowi)- area.y +
5151     g_sheet_row_get_height (sheet->row_geometry, range.rowi);
5152
5153   clip_area.x = sheet->row_title_area.width;
5154   clip_area.y = sheet->column_title_area.height;
5155
5156   gdk_drawable_get_size (sheet->sheet_window,
5157                          &clip_area.width, &clip_area.height);
5158
5159   if (!sheet->row_titles_visible) clip_area.x = 0;
5160   if (!sheet->column_titles_visible) clip_area.y = 0;
5161
5162   if (area.x < 0)
5163     {
5164       area.width = area.width + area.x;
5165       area.x = 0;
5166     }
5167   if (area.width > clip_area.width) area.width = clip_area.width + 10;
5168   if (area.y < 0)
5169     {
5170       area.height = area.height + area.y;
5171       area.y = 0;
5172     }
5173   if (area.height > clip_area.height) area.height = clip_area.height + 10;
5174
5175   clip_area.x--;
5176   clip_area.y--;
5177   clip_area.width += 3;
5178   clip_area.height += 3;
5179
5180   gdk_gc_get_values (sheet->xor_gc, &values);
5181
5182   gdk_gc_set_clip_rectangle (sheet->xor_gc, &clip_area);
5183
5184   gdk_draw_rectangle (sheet->sheet_window,
5185                       sheet->xor_gc,
5186                       FALSE,
5187                       area.x + i, area.y + i,
5188                       area.width - 2 * i, area.height - 2 * i);
5189
5190
5191   gdk_gc_set_clip_rectangle (sheet->xor_gc, NULL);
5192
5193   gdk_gc_set_foreground (sheet->xor_gc, &values.foreground);
5194 }
5195
5196
5197 /* this function returns the new width of the column being resized given
5198  * the COLUMN and X position of the cursor; the x cursor position is passed
5199  * in as a pointer and automaticaly corrected if it's outside the acceptable
5200  * range */
5201 static guint
5202 new_column_width (GtkSheet *sheet, gint column, gint *x)
5203 {
5204   gint left_pos = psppire_axis_pixel_start (sheet->haxis, column)
5205     - sheet->hadjustment->value;
5206
5207   gint width = *x - left_pos;
5208
5209   if ( width < sheet->column_requisition)
5210     {
5211       width = sheet->column_requisition;
5212       *x = left_pos + width;
5213     }
5214
5215 #if AXIS_TRANSITION
5216   g_sheet_column_set_width (sheet->column_geometry, column, width);
5217 #endif
5218
5219   draw_column_title_buttons (sheet);
5220
5221   return width;
5222 }
5223
5224 /* this function returns the new height of the row being resized given
5225  * the row and y position of the cursor; the y cursor position is passed
5226  * in as a pointer and automaticaly corrected if it's beyond min / max limits */
5227 static guint
5228 new_row_height (GtkSheet *sheet, gint row, gint *y)
5229 {
5230   gint height;
5231   guint min_height;
5232
5233   gint cy = *y;
5234   min_height = sheet->row_requisition;
5235
5236   /* you can't shrink a row to less than its minimum height */
5237   if (cy < g_sheet_row_start_pixel (sheet->row_geometry, row) + min_height)
5238
5239     {
5240       *y = cy = g_sheet_row_start_pixel (sheet->row_geometry, row) + min_height;
5241     }
5242
5243   /* calculate new row height making sure it doesn't end up
5244    * less than the minimum height */
5245   height = (cy - g_sheet_row_start_pixel (sheet->row_geometry, row));
5246   if (height < min_height)
5247     height = min_height;
5248
5249   g_sheet_row_set_height (sheet->row_geometry, row, height);
5250   draw_row_title_buttons (sheet);
5251
5252   return height;
5253 }
5254
5255 static void
5256 gtk_sheet_set_column_width (GtkSheet *sheet,
5257                             gint column,
5258                             guint width)
5259 {
5260   guint min_width;
5261
5262   g_return_if_fail (sheet != NULL);
5263   g_return_if_fail (GTK_IS_SHEET (sheet));
5264
5265   if (column < 0 || column >= psppire_axis_unit_count (sheet->haxis))
5266     return;
5267
5268   gtk_sheet_column_size_request (sheet, column, &min_width);
5269   if (width < min_width) return;
5270
5271 #if AXIS_TRANSITION
5272   g_sheet_column_set_width (sheet->column_geometry, column, width);
5273 #endif
5274
5275   if (GTK_WIDGET_REALIZED (GTK_WIDGET (sheet)))
5276     {
5277       draw_column_title_buttons (sheet);
5278       adjust_scrollbars (sheet);
5279       gtk_sheet_size_allocate_entry (sheet);
5280       gtk_sheet_range_draw (sheet, NULL);
5281     }
5282 }
5283
5284
5285
5286 static void
5287 gtk_sheet_set_row_height (GtkSheet *sheet,
5288                           gint row,
5289                           guint height)
5290 {
5291   guint min_height;
5292
5293   g_return_if_fail (sheet != NULL);
5294   g_return_if_fail (GTK_IS_SHEET (sheet));
5295
5296   if (row < 0 || row >= g_sheet_row_get_row_count (sheet->row_geometry))
5297     return;
5298
5299   gtk_sheet_row_size_request (sheet, row, &min_height);
5300   if (height < min_height) return;
5301
5302   g_sheet_row_set_height (sheet->row_geometry, row, height);
5303
5304   if (GTK_WIDGET_REALIZED (GTK_WIDGET (sheet)) )
5305     {
5306       draw_row_title_buttons (sheet);
5307       adjust_scrollbars (sheet);
5308       gtk_sheet_size_allocate_entry (sheet);
5309       gtk_sheet_range_draw (sheet, NULL);
5310     }
5311 }
5312
5313 gboolean
5314 gtk_sheet_get_attributes (const GtkSheet *sheet, gint row, gint col,
5315                           GtkSheetCellAttr *attr)
5316 {
5317   GdkColor *fg, *bg;
5318   const GtkJustification *j ;
5319   const PangoFontDescription *font_desc ;
5320   const GtkSheetCellBorder *border ;
5321   GdkColormap *colormap;
5322
5323   g_return_val_if_fail (sheet != NULL, FALSE);
5324   g_return_val_if_fail (GTK_IS_SHEET (sheet), FALSE);
5325
5326   if (row < 0 || col < 0) return FALSE;
5327
5328
5329   attr->foreground = GTK_WIDGET (sheet)->style->black;
5330   attr->background = sheet->color[BG_COLOR];
5331
5332   attr->border.width = 0;
5333   attr->border.line_style = GDK_LINE_SOLID;
5334   attr->border.cap_style = GDK_CAP_NOT_LAST;
5335   attr->border.join_style = GDK_JOIN_MITER;
5336   attr->border.mask = 0;
5337   attr->border.color = GTK_WIDGET (sheet)->style->black;
5338   attr->font_desc = GTK_WIDGET (sheet)->style->font_desc;
5339
5340   attr->is_editable = g_sheet_model_is_editable (sheet->model, row, col);
5341   attr->is_visible = g_sheet_model_is_visible (sheet->model, row, col);
5342
5343
5344   colormap = gtk_widget_get_colormap (GTK_WIDGET (sheet));
5345   fg = g_sheet_model_get_foreground (sheet->model, row, col);
5346   if ( fg )
5347     {
5348       gdk_colormap_alloc_color (colormap, fg, TRUE, TRUE);
5349       attr->foreground = *fg;
5350     }
5351
5352   bg = g_sheet_model_get_background (sheet->model, row, col);
5353   if ( bg )
5354     {
5355       gdk_colormap_alloc_color (colormap, bg, TRUE, TRUE);
5356       attr->background = *bg;
5357     }
5358
5359   attr->justification =
5360     g_sheet_model_get_column_justification (sheet->model, col);
5361
5362   j = g_sheet_model_get_justification (sheet->model, row, col);
5363   if (j)
5364     attr->justification = *j;
5365
5366   font_desc = g_sheet_model_get_font_desc (sheet->model, row, col);
5367   if ( font_desc ) attr->font_desc = font_desc;
5368
5369   border = g_sheet_model_get_cell_border (sheet->model, row, col);
5370
5371   if ( border ) attr->border = *border;
5372
5373   return TRUE;
5374 }
5375
5376 static void
5377 gtk_sheet_button_size_request    (GtkSheet *sheet,
5378                                   const GtkSheetButton *button,
5379                                   GtkRequisition *button_requisition)
5380 {
5381   GtkRequisition requisition;
5382   GtkRequisition label_requisition;
5383
5384   label_requisition.height = DEFAULT_ROW_HEIGHT;
5385   label_requisition.width = COLUMN_MIN_WIDTH;
5386
5387   requisition.height = DEFAULT_ROW_HEIGHT;
5388   requisition.width = COLUMN_MIN_WIDTH;
5389
5390
5391   *button_requisition = requisition;
5392   button_requisition->width = MAX (requisition.width, label_requisition.width);
5393   button_requisition->height = MAX (requisition.height, label_requisition.height);
5394
5395 }
5396
5397 static void
5398 gtk_sheet_row_size_request (GtkSheet *sheet,
5399                             gint row,
5400                             guint *requisition)
5401 {
5402   GtkRequisition button_requisition;
5403
5404   gtk_sheet_button_size_request (sheet,
5405                                  g_sheet_row_get_button (sheet->row_geometry, row),
5406                                  &button_requisition);
5407
5408   *requisition = button_requisition.height;
5409
5410   sheet->row_requisition = *requisition;
5411 }
5412
5413 static void
5414 gtk_sheet_column_size_request (GtkSheet *sheet,
5415                                gint col,
5416                                guint *requisition)
5417 {
5418   GtkRequisition button_requisition;
5419
5420   GtkSheetButton *button = g_sheet_model_get_column_button (sheet->model, col);
5421
5422   gtk_sheet_button_size_request (sheet,
5423                                  button,
5424                                  &button_requisition);
5425
5426   gtk_sheet_button_free (button);
5427
5428   *requisition = button_requisition.width;
5429
5430   sheet->column_requisition = *requisition;
5431 }
5432
5433
5434 static void
5435 gtk_sheet_forall (GtkContainer *container,
5436                   gboolean include_internals,
5437                   GtkCallback callback,
5438                   gpointer callback_data)
5439 {
5440   GtkSheet *sheet = GTK_SHEET (container);
5441
5442   g_return_if_fail (callback != NULL);
5443
5444   if (sheet->button && sheet->button->parent)
5445     (* callback) (sheet->button, callback_data);
5446
5447   if (sheet->entry_container && GTK_IS_CONTAINER (sheet->entry_container))
5448     (* callback) (sheet->entry_container, callback_data);
5449 }
5450
5451
5452 GSheetModel *
5453 gtk_sheet_get_model (const GtkSheet *sheet)
5454 {
5455   g_return_val_if_fail (GTK_IS_SHEET (sheet), NULL);
5456
5457   return sheet->model;
5458 }
5459
5460
5461 GtkSheetButton *
5462 gtk_sheet_button_new (void)
5463 {
5464   GtkSheetButton *button = g_malloc (sizeof (GtkSheetButton));
5465
5466   button->state = GTK_STATE_NORMAL;
5467   button->label = NULL;
5468   button->label_visible = TRUE;
5469   button->justification = GTK_JUSTIFY_FILL;
5470
5471   return button;
5472 }
5473
5474
5475 void
5476 gtk_sheet_button_free (GtkSheetButton *button)
5477 {
5478   if (!button) return ;
5479
5480   g_free (button->label);
5481   g_free (button);
5482 }
5483
5484 static void
5485 append_cell_text (GString *string, const GtkSheet *sheet, gint r, gint c)
5486 {
5487   gchar *celltext = gtk_sheet_cell_get_text (sheet, r, c);
5488
5489   if ( NULL == celltext)
5490     return;
5491
5492   g_string_append (string, celltext);
5493   g_free (celltext);
5494 }
5495
5496
5497 static GString *
5498 range_to_text (const GtkSheet *sheet)
5499 {
5500   gint r, c;
5501   GString *string;
5502
5503   if ( !gtk_sheet_range_isvisible (sheet, sheet->range))
5504     return NULL;
5505
5506   string = g_string_sized_new (80);
5507
5508   for (r = sheet->range.row0; r <= sheet->range.rowi; ++r)
5509     {
5510       for (c = sheet->range.col0; c < sheet->range.coli; ++c)
5511         {
5512           append_cell_text (string, sheet, r, c);
5513           g_string_append (string, "\t");
5514         }
5515       append_cell_text (string, sheet, r, c);
5516       if ( r < sheet->range.rowi)
5517         g_string_append (string, "\n");
5518     }
5519
5520   return string;
5521 }
5522
5523 static GString *
5524 range_to_html (const GtkSheet *sheet)
5525 {
5526   gint r, c;
5527   GString *string;
5528
5529   if ( !gtk_sheet_range_isvisible (sheet, sheet->range))
5530     return NULL;
5531
5532   string = g_string_sized_new (480);
5533
5534   g_string_append (string, "<html>\n");
5535   g_string_append (string, "<body>\n");
5536   g_string_append (string, "<table>\n");
5537   for (r = sheet->range.row0; r <= sheet->range.rowi; ++r)
5538     {
5539       g_string_append (string, "<tr>\n");
5540       for (c = sheet->range.col0; c <= sheet->range.coli; ++c)
5541         {
5542           g_string_append (string, "<td>");
5543           append_cell_text (string, sheet, r, c);
5544           g_string_append (string, "</td>\n");
5545         }
5546       g_string_append (string, "</tr>\n");
5547     }
5548   g_string_append (string, "</table>\n");
5549   g_string_append (string, "</body>\n");
5550   g_string_append (string, "</html>\n");
5551
5552   return string;
5553 }
5554
5555 enum {
5556   SELECT_FMT_NULL,
5557   SELECT_FMT_TEXT,
5558   SELECT_FMT_HTML
5559 };
5560
5561 static void
5562 primary_get_cb (GtkClipboard     *clipboard,
5563                 GtkSelectionData *selection_data,
5564                 guint             info,
5565                 gpointer          data)
5566 {
5567   GtkSheet *sheet = GTK_SHEET (data);
5568   GString *string = NULL;
5569
5570   switch (info)
5571     {
5572     case SELECT_FMT_TEXT:
5573       string = range_to_text (sheet);
5574       break;
5575     case SELECT_FMT_HTML:
5576       string = range_to_html (sheet);
5577       break;
5578     default:
5579       g_assert_not_reached ();
5580     }
5581
5582   gtk_selection_data_set (selection_data, selection_data->target,
5583                           8,
5584                           (const guchar *) string->str, string->len);
5585   g_string_free (string, TRUE);
5586 }
5587
5588 static void
5589 primary_clear_cb (GtkClipboard *clipboard,
5590                   gpointer      data)
5591 {
5592   GtkSheet *sheet = GTK_SHEET (data);
5593   if ( ! GTK_WIDGET_REALIZED (GTK_WIDGET (sheet)))
5594     return;
5595
5596   gtk_sheet_real_unselect_range (sheet, NULL);
5597 }
5598
5599 static void
5600 gtk_sheet_update_primary_selection (GtkSheet *sheet)
5601 {
5602   static const GtkTargetEntry targets[] = {
5603     { "UTF8_STRING",   0, SELECT_FMT_TEXT },
5604     { "STRING",        0, SELECT_FMT_TEXT },
5605     { "TEXT",          0, SELECT_FMT_TEXT },
5606     { "COMPOUND_TEXT", 0, SELECT_FMT_TEXT },
5607     { "text/plain;charset=utf-8", 0, SELECT_FMT_TEXT },
5608     { "text/plain",    0, SELECT_FMT_TEXT },
5609     { "text/html",     0, SELECT_FMT_HTML }
5610   };
5611
5612   GtkClipboard *clipboard;
5613
5614   if (!GTK_WIDGET_REALIZED (sheet))
5615     return;
5616
5617   clipboard = gtk_widget_get_clipboard (GTK_WIDGET (sheet),
5618                                         GDK_SELECTION_PRIMARY);
5619
5620   if (gtk_sheet_range_isvisible (sheet, sheet->range))
5621     {
5622       if (!gtk_clipboard_set_with_owner (clipboard, targets,
5623                                          G_N_ELEMENTS (targets),
5624                                          primary_get_cb, primary_clear_cb,
5625                                          G_OBJECT (sheet)))
5626         primary_clear_cb (clipboard, sheet);
5627     }
5628   else
5629     {
5630       if (gtk_clipboard_get_owner (clipboard) == G_OBJECT (sheet))
5631         gtk_clipboard_clear (clipboard);
5632     }
5633 }