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