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