lib/gtksheet/gtksheet.c

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