lib/gtksheet/gtksheet.c

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