lib/gtksheet/gtksheet.c

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