lib/gtksheet/gtksheet.c

   1 /* This version of GtkSheet has been *heavily* modified, for the specific
   2    requirements of PSPPIRE. */
   3
   4 /* GtkSheet widget for Gtk+.
   5  * Copyright (C) 1999-2001 Adrian E. Feiguin <adrian@ifir.ifir.edu.ar>
   6  *
   7  * Based on GtkClist widget by Jay Painter, but major changes.
   8  * Memory allocation routines inspired on SC (Spreadsheet Calculator)
   9  *
  10  * This library is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU Lesser General Public
  12  * License as published by the Free Software Foundation; either
  13  * version 2.1 of the License, or (at your option) any later version.
  14  *
  15  * This library is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  18  * Lesser General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Lesser General Public
  21  * License along with this library; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  23  */
  24
  25 /**
  26  * SECTION:gtksheet
  27  * @short_description: spreadsheet widget for gtk2
  28  *
  29  * GtkSheet is a matrix widget for GTK+. It consists of an scrollable grid of
  30  * cells where you can allocate text. Cell contents can be edited interactively
  31  * through a specially designed entry, GtkItemEntry. It is also a container
  32  * subclass, allowing you to display buttons, curves, pixmaps and any other
  33  * widgets in it.
  34  *
  35  * You can also set many attributes as: border, foreground and background color,
  36  * text justification, and more.
  37  *
  38  * The testgtksheet program shows how easy is to create a spreadsheet-like GUI
  39  * using this widget.
  40  */
  41 #include <config.h>
  42
  43 #include <string.h>
  44 #include <stdio.h>
  45 #include <stdlib.h>
  46 #include <glib.h>
  47 #include <gdk/gdk.h>
  48 #include <gdk/gdkkeysyms.h>
  49 #include <gtk/gtksignal.h>
  50 #include <gtk/gtklabel.h>
  51 #include <gtk/gtkbutton.h>
  52 #include <gtk/gtkadjustment.h>
  53 #include <gtk/gtktable.h>
  54 #include <gtk/gtkbox.h>
  55 #include <gtk/gtkmain.h>
  56 #include <gtk/gtktypeutils.h>
  57 #include <gtk/gtkentry.h>
  58 #include <gtk/gtkcontainer.h>
  59 #include <gtk/gtkpixmap.h>
  60 #include <pango/pango.h>
  61 #include "gtkitementry.h"
  62 #include "gtksheet.h"
  63 #include "gtkextra-marshal.h"
  64 #include "gsheetmodel.h"
  65
  66 /* sheet flags */
  67 enum
  68   {
  69     GTK_SHEET_IS_LOCKED = 1 << 0,
  70     GTK_SHEET_IS_FROZEN = 1 << 1,
  71     GTK_SHEET_IN_XDRAG = 1 << 2,
  72     GTK_SHEET_IN_YDRAG = 1 << 3,
  73     GTK_SHEET_IN_DRAG = 1 << 4,
  74     GTK_SHEET_IN_SELECTION = 1 << 5,
  75     GTK_SHEET_IN_RESIZE = 1 << 6,
  76     GTK_SHEET_REDRAW_PENDING = 1 << 7,
  77   };
  78
  79 #define GTK_SHEET_FLAGS(sheet) (GTK_SHEET (sheet)->flags)
  80 #define GTK_SHEET_SET_FLAGS(sheet,flag) (GTK_SHEET_FLAGS (sheet) |= (flag))
  81 #define GTK_SHEET_UNSET_FLAGS(sheet,flag) (GTK_SHEET_FLAGS (sheet) &= ~ (flag))
  82
  83 #define GTK_SHEET_IS_LOCKED(sheet) (GTK_SHEET_FLAGS (sheet) & GTK_SHEET_IS_LOCKED)
  84
  85
  86 #define GTK_SHEET_IS_FROZEN(sheet) (GTK_SHEET_FLAGS (sheet) & GTK_SHEET_IS_FROZEN)
  87 #define GTK_SHEET_IN_XDRAG(sheet) (GTK_SHEET_FLAGS (sheet) & GTK_SHEET_IN_XDRAG)
  88 #define GTK_SHEET_IN_YDRAG(sheet) (GTK_SHEET_FLAGS (sheet) & GTK_SHEET_IN_YDRAG)
  89 #define GTK_SHEET_IN_DRAG(sheet) (GTK_SHEET_FLAGS (sheet) & GTK_SHEET_IN_DRAG)
  90 #define GTK_SHEET_IN_SELECTION(sheet) (GTK_SHEET_FLAGS (sheet) & GTK_SHEET_IN_SELECTION)
  91 #define GTK_SHEET_IN_RESIZE(sheet) (GTK_SHEET_FLAGS (sheet) & GTK_SHEET_IN_RESIZE)
  92 #define GTK_SHEET_REDRAW_PENDING(sheet) (GTK_SHEET_FLAGS (sheet) & GTK_SHEET_REDRAW_PENDING)
  93
  94 #define CELL_SPACING 1
  95 #define DRAG_WIDTH 6
  96 #define TIMEOUT_HOVER 300
  97 #define TIME_INTERVAL 8
  98 #define COLUMN_MIN_WIDTH 10
  99 #define MINROWS 1
 100 #define MINCOLS 1
 101 #define MAXLENGTH 30
 102 #define CELLOFFSET 4
 103 #define DEFAULT_COLUMN_WIDTH 80
 104
 105
 106 static void gtk_sheet_update_primary_selection (GtkSheet *sheet);
 107
 108
 109 static void gtk_sheet_column_title_button_draw (GtkSheet *sheet, gint column);
 110
 111 static void gtk_sheet_row_title_button_draw (GtkSheet *sheet, gint row);
 112
 113
 114 static gboolean gtk_sheet_cell_empty (const GtkSheet *sheet, gint row, gint col);
 115
 116 static inline
 117 void dispose_string (const GtkSheet *sheet, gchar *text)
 118 {
 119   GSheetModel *model = gtk_sheet_get_model (sheet);
 120
 121   if ( ! model )
 122     return;
 123
 124   if (g_sheet_model_free_strings (model))
 125     g_free (text);
 126 }
 127
 128 static inline
 129 guint DEFAULT_ROW_HEIGHT (GtkWidget *widget)
 130 {
 131   if (!widget->style->font_desc) return 24;
 132   else
 133     {
 134       PangoContext *context = gtk_widget_get_pango_context (widget);
 135       PangoFontMetrics *metrics =
 136         pango_context_get_metrics (context,
 137                                    widget->style->font_desc,
 138                                    pango_context_get_language (context));
 139       guint val = pango_font_metrics_get_descent (metrics) +
 140         pango_font_metrics_get_ascent (metrics);
 141       pango_font_metrics_unref (metrics);
 142       return PANGO_PIXELS (val)+2 * CELLOFFSET;
 143     }
 144 }
 145
 146 static inline
 147 guint DEFAULT_FONT_ASCENT (GtkWidget *widget)
 148 {
 149   if (!widget->style->font_desc) return 12;
 150   else
 151     {
 152       PangoContext *context = gtk_widget_get_pango_context (widget);
 153       PangoFontMetrics *metrics =
 154         pango_context_get_metrics (context,
 155                                    widget->style->font_desc,
 156                                    pango_context_get_language (context));
 157       guint val = pango_font_metrics_get_ascent (metrics);
 158       pango_font_metrics_unref (metrics);
 159       return PANGO_PIXELS (val);
 160     }
 161 }
 162
 163 static inline
 164 guint STRING_WIDTH (GtkWidget *widget,
 165                     const PangoFontDescription *font, const gchar *text)
 166 {
 167   PangoRectangle rect;
 168   PangoLayout *layout;
 169
 170   layout = gtk_widget_create_pango_layout (widget, text);
 171   pango_layout_set_font_description (layout, font);
 172
 173   pango_layout_get_extents (layout, NULL, &rect);
 174
 175   g_object_unref (G_OBJECT (layout));
 176   return PANGO_PIXELS (rect.width);
 177 }
 178
 179 static inline
 180 guint DEFAULT_FONT_DESCENT (GtkWidget *widget)
 181 {
 182   if (!widget->style->font_desc) return 12;
 183   else
 184     {
 185       PangoContext *context = gtk_widget_get_pango_context (widget);
 186       PangoFontMetrics *metrics =
 187         pango_context_get_metrics (context,
 188                                    widget->style->font_desc,
 189                                    pango_context_get_language (context));
 190       guint val = pango_font_metrics_get_descent (metrics);
 191       pango_font_metrics_unref (metrics);
 192       return PANGO_PIXELS (val);
 193     }
 194 }
 195
 196
 197 static gint
 198 yyy_row_is_visible (const GtkSheet *sheet, gint row)
 199 {
 200   GSheetRow *row_geo = sheet->row_geometry;
 201
 202   return g_sheet_row_get_visibility (row_geo, row, 0);
 203 }
 204
 205
 206 static gint
 207 yyy_row_is_sensitive (const GtkSheet *sheet, gint row)
 208 {
 209   GSheetRow *row_geo = sheet->row_geometry;
 210
 211   return g_sheet_row_get_sensitivity (row_geo, row, 0);
 212 }
 213
 214
 215
 216 static inline gint
 217 yyy_row_count (const GtkSheet *sheet)
 218 {
 219   GSheetRow *row_geo = sheet->row_geometry;
 220
 221   return g_sheet_row_get_row_count (row_geo, 0);
 222 }
 223
 224 static inline gint
 225 yyy_row_height (const GtkSheet *sheet, gint row)
 226 {
 227   GSheetRow *row_geo = sheet->row_geometry;
 228
 229   return g_sheet_row_get_height (row_geo, row, 0);
 230 }
 231
 232 static gint
 233 yyy_row_top_ypixel (const GtkSheet *sheet, gint row)
 234 {
 235   GSheetRow *geo = sheet->row_geometry;
 236
 237   gint y = g_sheet_row_start_pixel (geo, row, 0);
 238
 239   if ( sheet->column_titles_visible )
 240     y += sheet->column_title_area.height;
 241
 242   return y;
 243 }
 244
 245
 246 /* Return the row containing pixel Y */
 247 static gint
 248 yyy_row_ypixel_to_row (const GtkSheet *sheet, gint y)
 249 {
 250   GSheetRow *geo = sheet->row_geometry;
 251
 252   gint cy = sheet->voffset;
 253
 254   if (sheet->column_titles_visible)
 255     cy += sheet->column_title_area.height;
 256
 257   if (y < cy) return 0;
 258
 259   return g_sheet_row_pixel_to_row (geo, y - cy, 0);
 260 }
 261
 262
 263 /* gives the top pixel of the given row in context of
 264  * the sheet's voffset */
 265 static inline gint
 266 ROW_TOP_YPIXEL (const GtkSheet *sheet, gint row)
 267 {
 268   return (sheet->voffset + yyy_row_top_ypixel (sheet, row));
 269 }
 270
 271
 272 /* returns the row index from a y pixel location in the
 273  * context of the sheet's voffset */
 274 static inline gint
 275 ROW_FROM_YPIXEL (const GtkSheet *sheet, gint y)
 276 {
 277   return (yyy_row_ypixel_to_row (sheet, y));
 278 }
 279
 280 static inline GtkSheetButton *
 281 xxx_column_button (const GtkSheet *sheet, gint col)
 282 {
 283   GSheetColumn *col_geo = sheet->column_geometry;
 284   if ( col < 0 ) return NULL ;
 285
 286   return g_sheet_column_get_button (col_geo, col);
 287 }
 288
 289
 290 static inline gint
 291 xxx_column_left_xpixel (const GtkSheet *sheet, gint col)
 292 {
 293   GSheetColumn *geo = sheet->column_geometry;
 294
 295   gint x = g_sheet_column_start_pixel (geo, col);
 296
 297   if ( sheet->row_titles_visible )
 298     x += sheet->row_title_area.width;
 299
 300   return x;
 301 }
 302
 303 static inline gint
 304 xxx_column_width (const GtkSheet *sheet, gint col)
 305 {
 306   GSheetColumn *col_geo = sheet->column_geometry;
 307
 308   return g_sheet_column_get_width (col_geo, col);
 309 }
 310
 311
 312 static inline void
 313 xxx_set_column_width (GtkSheet *sheet, gint col, gint width)
 314 {
 315   if ( sheet->column_geometry )
 316     g_sheet_column_set_width (sheet->column_geometry, col, width);
 317 }
 318
 319 static inline void
 320 xxx_column_set_left_column (GtkSheet *sheet, gint col, gint i)
 321 {
 322   GSheetColumn *col_geo = sheet->column_geometry;
 323
 324   g_sheet_column_set_left_text_column (col_geo, col, i);
 325 }
 326
 327 static inline gint
 328 xxx_column_left_column (const GtkSheet *sheet, gint col)
 329 {
 330   GSheetColumn *col_geo = sheet->column_geometry;
 331
 332   return g_sheet_column_get_left_text_column (col_geo, col);
 333 }
 334
 335 static inline void
 336 xxx_column_set_right_column (GtkSheet *sheet, gint col, gint i)
 337 {
 338   GSheetColumn *col_geo = sheet->column_geometry;
 339
 340   g_sheet_column_set_right_text_column (col_geo, col, i);
 341 }
 342
 343 static inline gint
 344 xxx_column_right_column (const GtkSheet *sheet, gint col)
 345 {
 346   GSheetColumn *col_geo = sheet->column_geometry;
 347
 348   return g_sheet_column_get_right_text_column (col_geo, col);
 349 }
 350
 351 static inline GtkJustification
 352 xxx_column_justification (const GtkSheet *sheet, gint col)
 353 {
 354   GSheetColumn *col_geo = sheet->column_geometry;
 355
 356   return g_sheet_column_get_justification (col_geo, col);
 357 }
 358
 359 static inline gint
 360 xxx_column_is_visible (const GtkSheet *sheet, gint col)
 361 {
 362   GSheetColumn *col_geo = sheet->column_geometry;
 363
 364   return g_sheet_column_get_visibility (col_geo, col);
 365 }
 366
 367
 368 static inline gint
 369 xxx_column_is_sensitive (const GtkSheet *sheet, gint col)
 370 {
 371   GSheetColumn *col_geo = sheet->column_geometry;
 372
 373   return g_sheet_column_get_sensitivity (col_geo, col);
 374 }
 375
 376
 377 /* gives the left pixel of the given column in context of
 378  * the sheet's hoffset */
 379 static inline gint
 380 COLUMN_LEFT_XPIXEL (const GtkSheet *sheet, gint ncol)
 381 {
 382   return (sheet->hoffset + xxx_column_left_xpixel (sheet, ncol));
 383 }
 384
 385 static inline gint
 386 xxx_column_count (const GtkSheet *sheet)
 387 {
 388   GSheetColumn *col_geo = sheet->column_geometry;
 389
 390   return g_sheet_column_get_column_count (col_geo);
 391 }
 392
 393 /* returns the column index from a x pixel location in the
 394  * context of the sheet's hoffset */
 395 static inline gint
 396 COLUMN_FROM_XPIXEL (const GtkSheet * sheet,
 397                     gint x)
 398 {
 399   gint i, cx;
 400
 401   cx = sheet->hoffset;
 402   if ( sheet->row_titles_visible )
 403     cx += sheet->row_title_area.width;
 404
 405   if (x < cx) return 0;
 406   for (i = 0; i < xxx_column_count (sheet); i++)
 407     {
 408       if (x >= cx && x <= (cx + xxx_column_width (sheet, i)) &&
 409           xxx_column_is_visible (sheet, i))
 410         return i;
 411       if ( xxx_column_is_visible (sheet, i))
 412         cx += xxx_column_width (sheet, i);
 413     }
 414
 415   /* no match */
 416   return xxx_column_count (sheet) - 1;
 417 }
 418
 419 /* returns the total height of the sheet */
 420 static inline gint SHEET_HEIGHT (GtkSheet *sheet)
 421 {
 422   const gint n_rows = yyy_row_count (sheet);
 423
 424   return yyy_row_top_ypixel (sheet, n_rows - 1) +
 425     yyy_row_height (sheet, n_rows - 1);
 426 }
 427
 428
 429 static inline GtkSheetButton *
 430 yyy_row_button (GtkSheet *sheet, gint row)
 431 {
 432   GSheetRow *row_geo = sheet->row_geometry;
 433
 434   return g_sheet_row_get_button (row_geo, row, sheet);
 435 }
 436
 437
 438
 439
 440 static inline void
 441 yyy_set_row_height (GtkSheet *sheet, gint row, gint height)
 442 {
 443   if ( sheet->row_geometry )
 444     g_sheet_row_set_height (sheet->row_geometry, row, height, sheet);
 445 }
 446
 447
 448
 449 /* returns the total width of the sheet */
 450 static inline gint SHEET_WIDTH (GtkSheet *sheet)
 451 {
 452   gint i, cx;
 453
 454   cx = ( sheet->row_titles_visible ? sheet->row_title_area.width : 0);
 455
 456   for (i = 0; i < xxx_column_count (sheet); i++)
 457     if (xxx_column_is_visible (sheet, i))
 458       cx += xxx_column_width (sheet, i);
 459
 460   return cx;
 461 }
 462
 463 #define MIN_VISIBLE_ROW(sheet) \
 464     ROW_FROM_YPIXEL (sheet, sheet->column_title_area.height + 1)
 465
 466 #define MAX_VISIBLE_ROW(sheet) \
 467     ROW_FROM_YPIXEL (sheet, sheet->sheet_window_height - 1)
 468
 469 #define MIN_VISIBLE_COLUMN(sheet) \
 470     COLUMN_FROM_XPIXEL (sheet, sheet->row_title_area.width + 1)
 471
 472 #define MAX_VISIBLE_COLUMN(sheet) \
 473     COLUMN_FROM_XPIXEL (sheet, sheet->sheet_window_width)
 474
 475
 476
 477 static inline gboolean
 478 POSSIBLE_XDRAG (const GtkSheet *sheet, gint x, gint *drag_column)
 479 {
 480   gint column, xdrag;
 481
 482   column = COLUMN_FROM_XPIXEL (sheet, x);
 483   *drag_column = column;
 484
 485   xdrag = COLUMN_LEFT_XPIXEL (sheet, column) + CELL_SPACING;
 486   if (x <= xdrag + DRAG_WIDTH / 2 && column != 0)
 487     {
 488       while (! xxx_column_is_visible (sheet, column - 1) && column > 0) column--;
 489       *drag_column = column - 1;
 490       return xxx_column_is_sensitive (sheet, column - 1);
 491     }
 492
 493   xdrag += xxx_column_width (sheet, column);
 494   if (x >= xdrag - DRAG_WIDTH / 2 && x <= xdrag + DRAG_WIDTH / 2)
 495     return xxx_column_is_sensitive (sheet, column);
 496
 497   return FALSE;
 498 }
 499
 500 static inline gboolean
 501 POSSIBLE_YDRAG (const GtkSheet *sheet, gint y, gint *drag_row)
 502 {
 503   gint row, ydrag;
 504   row = ROW_FROM_YPIXEL (sheet, y);
 505   *drag_row = row;
 506
 507   ydrag = ROW_TOP_YPIXEL (sheet, row)+CELL_SPACING;
 508   if (y <= ydrag + DRAG_WIDTH / 2 && row != 0)
 509     {
 510       while (!yyy_row_is_visible (sheet, row - 1) && row > 0) row--;
 511       *drag_row = row - 1;
 512       return yyy_row_is_sensitive (sheet, row - 1);
 513     }
 514
 515   ydrag +=yyy_row_height (sheet, row);
 516
 517   if (y >= ydrag - DRAG_WIDTH / 2 && y <= ydrag + DRAG_WIDTH / 2)
 518     return yyy_row_is_sensitive (sheet, row);
 519
 520
 521   return FALSE;
 522 }
 523
 524 static inline gboolean
 525 POSSIBLE_DRAG (const GtkSheet *sheet, gint x, gint y,
 526                gint *drag_row, gint *drag_column)
 527 {
 528   gint ydrag, xdrag;
 529
 530   /* Can't drag if nothing is selected */
 531   if ( sheet->range.row0 < 0 || sheet->range.rowi < 0 ||
 532        sheet->range.col0 < 0 || sheet->range.coli < 0 )
 533     return FALSE;
 534
 535   *drag_column = COLUMN_FROM_XPIXEL (sheet, x);
 536   *drag_row = ROW_FROM_YPIXEL (sheet, y);
 537
 538   if (x >= COLUMN_LEFT_XPIXEL (sheet, sheet->range.col0) - DRAG_WIDTH / 2 &&
 539       x <= COLUMN_LEFT_XPIXEL (sheet, sheet->range.coli) +
 540       xxx_column_width (sheet, sheet->range.coli) + DRAG_WIDTH / 2)
 541     {
 542       ydrag = ROW_TOP_YPIXEL (sheet, sheet->range.row0);
 543       if (y >= ydrag - DRAG_WIDTH / 2 && y <= ydrag + DRAG_WIDTH / 2)
 544         {
 545           *drag_row = sheet->range.row0;
 546           return TRUE;
 547         }
 548       ydrag = ROW_TOP_YPIXEL (sheet, sheet->range.rowi) +
 549         yyy_row_height (sheet, sheet->range.rowi);
 550       if (y >= ydrag - DRAG_WIDTH / 2 && y <= ydrag + DRAG_WIDTH / 2)
 551         {
 552           *drag_row = sheet->range.rowi;
 553           return TRUE;
 554         }
 555     }
 556
 557   if (y >= ROW_TOP_YPIXEL (sheet, sheet->range.row0) - DRAG_WIDTH / 2 &&
 558       y <= ROW_TOP_YPIXEL (sheet, sheet->range.rowi) +
 559       yyy_row_height (sheet, sheet->range.rowi) + DRAG_WIDTH / 2)
 560     {
 561       xdrag = COLUMN_LEFT_XPIXEL (sheet, sheet->range.col0);
 562       if (x >= xdrag - DRAG_WIDTH / 2 && x <= xdrag + DRAG_WIDTH / 2)
 563         {
 564           *drag_column = sheet->range.col0;
 565           return TRUE;
 566         }
 567       xdrag = COLUMN_LEFT_XPIXEL (sheet, sheet->range.coli) +
 568         xxx_column_width (sheet, sheet->range.coli);
 569       if (x >= xdrag - DRAG_WIDTH / 2 && x <= xdrag + DRAG_WIDTH / 2)
 570         {
 571           *drag_column = sheet->range.coli;
 572           return TRUE;
 573         }
 574     }
 575
 576   return FALSE;
 577 }
 578
 579 static inline gboolean
 580 POSSIBLE_RESIZE (const GtkSheet *sheet, gint x, gint y,
 581                  gint *drag_row, gint *drag_column)
 582 {
 583   gint xdrag, ydrag;
 584
 585   /* Can't drag if nothing is selected */
 586   if ( sheet->range.row0 < 0 || sheet->range.rowi < 0 ||
 587        sheet->range.col0 < 0 || sheet->range.coli < 0 )
 588     return FALSE;
 589
 590   xdrag = COLUMN_LEFT_XPIXEL (sheet, sheet->range.coli)+
 591     xxx_column_width (sheet, sheet->range.coli);
 592
 593   ydrag = ROW_TOP_YPIXEL (sheet, sheet->range.rowi)+
 594     yyy_row_height (sheet, sheet->range.rowi);
 595
 596   if (sheet->state == GTK_SHEET_COLUMN_SELECTED)
 597     ydrag = ROW_TOP_YPIXEL (sheet, MIN_VISIBLE_ROW (sheet));
 598
 599   if (sheet->state == GTK_SHEET_ROW_SELECTED)
 600     xdrag = COLUMN_LEFT_XPIXEL (sheet, MIN_VISIBLE_COLUMN (sheet));
 601
 602   *drag_column = COLUMN_FROM_XPIXEL (sheet, x);
 603   *drag_row = ROW_FROM_YPIXEL (sheet, y);
 604
 605   if (x >= xdrag - DRAG_WIDTH / 2 && x <= xdrag + DRAG_WIDTH / 2 &&
 606       y >= ydrag - DRAG_WIDTH / 2 && y <= ydrag + DRAG_WIDTH / 2) return TRUE;
 607
 608   return FALSE;
 609 }
 610
 611 static void gtk_sheet_class_init                 (GtkSheetClass * klass);
 612 static void gtk_sheet_init                       (GtkSheet * sheet);
 613 static void gtk_sheet_destroy                    (GtkObject * object);
 614 static void gtk_sheet_finalize                   (GObject * object);
 615 static void gtk_sheet_style_set                  (GtkWidget *widget,
 616                                                   GtkStyle *previous_style);
 617 static void gtk_sheet_realize                    (GtkWidget * widget);
 618 static void gtk_sheet_unrealize                  (GtkWidget * widget);
 619 static void gtk_sheet_map                        (GtkWidget * widget);
 620 static void gtk_sheet_unmap                      (GtkWidget * widget);
 621 static gint gtk_sheet_expose                     (GtkWidget * widget,
 622                                                   GdkEventExpose * event);
 623 static void gtk_sheet_forall                     (GtkContainer *container,
 624                                                   gboolean include_internals,
 625                                                   GtkCallback callback,
 626                                                   gpointer callback_data);
 627
 628 static void gtk_sheet_set_scroll_adjustments     (GtkSheet *sheet,
 629                                                   GtkAdjustment *hadjustment,
 630                                                   GtkAdjustment *vadjustment);
 631
 632 static gint gtk_sheet_button_press               (GtkWidget * widget,
 633                                                   GdkEventButton * event);
 634 static gint gtk_sheet_button_release             (GtkWidget * widget,
 635                                                   GdkEventButton * event);
 636 static gint gtk_sheet_motion                     (GtkWidget * widget,
 637                                                   GdkEventMotion * event);
 638 static gint gtk_sheet_entry_key_press            (GtkWidget *widget,
 639                                                   GdkEventKey *key);
 640 static gint gtk_sheet_key_press                  (GtkWidget *widget,
 641                                                   GdkEventKey *key);
 642 static void gtk_sheet_size_request               (GtkWidget * widget,
 643                                                   GtkRequisition * requisition);
 644 static void gtk_sheet_size_allocate              (GtkWidget * widget,
 645                                                   GtkAllocation * allocation);
 646
 647 /* Sheet queries */
 648
 649 static gboolean gtk_sheet_range_isvisible (const GtkSheet * sheet,
 650                                            GtkSheetRange range);
 651 static gboolean gtk_sheet_cell_isvisible  (GtkSheet * sheet,
 652                                            gint row, gint column);
 653 /* Drawing Routines */
 654
 655 /* draw cell background and frame */
 656 static void gtk_sheet_cell_draw_default          (GtkSheet *sheet,
 657                                                   gint row, gint column);
 658
 659 /* draw cell contents */
 660 static void gtk_sheet_cell_draw_label            (GtkSheet *sheet,
 661                                                   gint row, gint column);
 662
 663 /* draw visible part of range. If range == NULL then draw the whole screen */
 664 static void gtk_sheet_range_draw                 (GtkSheet *sheet,
 665                                                   const GtkSheetRange *range);
 666
 667 /* highlight the visible part of the selected range */
 668 static void gtk_sheet_range_draw_selection       (GtkSheet *sheet,
 669                                                   GtkSheetRange range);
 670
 671 /* Selection */
 672
 673 static gboolean gtk_sheet_move_query             (GtkSheet *sheet,
 674                                                   gint row, gint column);
 675 static void gtk_sheet_real_select_range          (GtkSheet * sheet,
 676                                                   const GtkSheetRange * range);
 677 static void gtk_sheet_real_unselect_range        (GtkSheet * sheet,
 678                                                   const GtkSheetRange * range);
 679 static void gtk_sheet_extend_selection           (GtkSheet *sheet,
 680                                                   gint row, gint column);
 681 static void gtk_sheet_new_selection              (GtkSheet *sheet,
 682                                                   GtkSheetRange *range);
 683 static void gtk_sheet_draw_border                (GtkSheet *sheet,
 684                                                   GtkSheetRange range);
 685 static void gtk_sheet_draw_corners               (GtkSheet *sheet,
 686                                                   GtkSheetRange range);
 687
 688
 689 /* Active Cell handling */
 690
 691 static void gtk_sheet_entry_changed              (GtkWidget *widget,
 692                                                   gpointer data);
 693 static gboolean gtk_sheet_deactivate_cell        (GtkSheet *sheet);
 694 static void gtk_sheet_hide_active_cell           (GtkSheet *sheet);
 695 static gboolean gtk_sheet_activate_cell          (GtkSheet *sheet,
 696                                                   gint row, gint col);
 697 static void gtk_sheet_draw_active_cell           (GtkSheet *sheet);
 698 static void gtk_sheet_show_active_cell           (GtkSheet *sheet);
 699 static void gtk_sheet_click_cell                 (GtkSheet *sheet,
 700                                                   gint row,
 701                                                   gint column,
 702                                                   gboolean *veto);
 703
 704 /* Backing Pixmap */
 705
 706 static void gtk_sheet_make_backing_pixmap        (GtkSheet *sheet,
 707                                                   guint width, guint height);
 708 static void gtk_sheet_draw_backing_pixmap        (GtkSheet *sheet,
 709                                                   GtkSheetRange range);
 710 /* Scrollbars */
 711
 712 static void adjust_scrollbars                    (GtkSheet * sheet);
 713 static void vadjustment_value_changed            (GtkAdjustment * adjustment,
 714                                                   gpointer data);
 715 static void hadjustment_value_changed            (GtkAdjustment * adjustment,
 716                                                   gpointer data);
 717
 718
 719 static void draw_xor_vline                       (GtkSheet * sheet);
 720 static void draw_xor_hline                       (GtkSheet * sheet);
 721 static void draw_xor_rectangle                   (GtkSheet *sheet,
 722                                                   GtkSheetRange range);
 723
 724 static guint new_column_width                    (GtkSheet * sheet,
 725                                                   gint column,
 726                                                   gint * x);
 727 static guint new_row_height                      (GtkSheet * sheet,
 728                                                   gint row,
 729                                                   gint * y);
 730 /* Sheet Button */
 731
 732 static void create_global_button                 (GtkSheet *sheet);
 733 static void global_button_clicked                (GtkWidget *widget,
 734                                                   gpointer data);
 735 /* Sheet Entry */
 736
 737 static void create_sheet_entry                   (GtkSheet *sheet);
 738 static void gtk_sheet_size_allocate_entry        (GtkSheet *sheet);
 739 static void gtk_sheet_entry_set_max_size         (GtkSheet *sheet);
 740
 741 /* Sheet button gadgets */
 742
 743 static void size_allocate_column_title_buttons   (GtkSheet * sheet);
 744 static void size_allocate_row_title_buttons      (GtkSheet * sheet);
 745
 746
 747 static void size_allocate_global_button          (GtkSheet *sheet);
 748 static void gtk_sheet_button_size_request        (GtkSheet *sheet,
 749                                                   const GtkSheetButton *button,
 750                                                   GtkRequisition *requisition);
 751
 752 /* Attributes routines */
 753 static void init_attributes                      (const GtkSheet *sheet, gint col,
 754                                                   GtkSheetCellAttr *attributes);
 755
 756
 757 /* Memory allocation routines */
 758 static void gtk_sheet_real_range_clear           (GtkSheet *sheet,
 759                                                   const GtkSheetRange *range);
 760
 761 static void gtk_sheet_real_cell_clear            (GtkSheet *sheet,
 762                                                   gint row,
 763                                                   gint column);
 764
 765
 766 /* Container Functions */
 767 static void gtk_sheet_remove                     (GtkContainer *container,
 768                                                   GtkWidget *widget);
 769 static void gtk_sheet_realize_child              (GtkSheet *sheet,
 770                                                   GtkSheetChild *child);
 771 static void gtk_sheet_position_child             (GtkSheet *sheet,
 772                                                   GtkSheetChild *child);
 773 static void gtk_sheet_position_children          (GtkSheet *sheet);
 774 static void gtk_sheet_child_show                 (GtkSheetChild *child);
 775 static void gtk_sheet_child_hide                 (GtkSheetChild *child);
 776 static void gtk_sheet_column_size_request (GtkSheet *sheet,
 777                                            gint col,
 778                                            guint *requisition);
 779 static void gtk_sheet_row_size_request (GtkSheet *sheet,
 780                                         gint row,
 781                                         guint *requisition);
 782
 783
 784 /* Signals */
 785
 786 extern void
 787 _gtkextra_signal_emit (GtkObject *object, guint signal_id, ...);
 788
 789 enum
 790   {
 791     SELECT_ROW,
 792     SELECT_COLUMN,
 793     DOUBLE_CLICK_ROW,
 794     DOUBLE_CLICK_COLUMN,
 795     BUTTON_EVENT_ROW,
 796     BUTTON_EVENT_COLUMN,
 797     SELECT_RANGE,
 798     RESIZE_RANGE,
 799     MOVE_RANGE,
 800     TRAVERSE,
 801     DEACTIVATE,
 802     ACTIVATE,
 803     SET_CELL,
 804     CLEAR_CELL,
 805     CHANGED,
 806     NEW_COL_WIDTH,
 807     NEW_ROW_HEIGHT,
 808     LAST_SIGNAL
 809   };
 810
 811 static GtkContainerClass *parent_class = NULL;
 812 static guint sheet_signals[LAST_SIGNAL] = { 0 };
 813
 814
 815 GType
 816 gtk_sheet_get_type ()
 817 {
 818   static GType sheet_type = 0;
 819
 820   if (!sheet_type)
 821     {
 822       static const GTypeInfo sheet_info =
 823         {
 824           sizeof (GtkSheetClass),
 825           NULL,
 826           NULL,
 827           (GClassInitFunc) gtk_sheet_class_init,
 828           NULL,
 829           NULL,
 830           sizeof (GtkSheet),
 831           0,
 832           (GInstanceInitFunc) gtk_sheet_init,
 833           NULL,
 834         };
 835       sheet_type =
 836         g_type_register_static (GTK_TYPE_CONTAINER, "GtkSheet",
 837                                 &sheet_info, 0);
 838     }
 839   return sheet_type;
 840 }
 841
 842 static GtkSheetRange*
 843 gtk_sheet_range_copy (const GtkSheetRange *range)
 844 {
 845   GtkSheetRange *new_range;
 846
 847   g_return_val_if_fail (range != NULL, NULL);
 848
 849   new_range = g_new (GtkSheetRange, 1);
 850
 851   *new_range = *range;
 852
 853   return new_range;
 854 }
 855
 856 static void
 857 gtk_sheet_range_free (GtkSheetRange *range)
 858 {
 859   g_return_if_fail (range != NULL);
 860
 861   g_free (range);
 862 }
 863
 864 GType
 865 gtk_sheet_range_get_type (void)
 866 {
 867   static GType sheet_range_type = 0;
 868
 869   if (!sheet_range_type)
 870     {
 871       sheet_range_type =
 872         g_boxed_type_register_static ("GtkSheetRange",
 873                                       (GBoxedCopyFunc) gtk_sheet_range_copy,
 874                                       (GBoxedFreeFunc) gtk_sheet_range_free);
 875     }
 876
 877   return sheet_range_type;
 878 }
 879
 880 static void
 881 gtk_sheet_class_init (GtkSheetClass * klass)
 882 {
 883   GtkObjectClass *object_class;
 884   GtkWidgetClass *widget_class;
 885   GtkContainerClass *container_class;
 886   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
 887
 888   object_class = (GtkObjectClass *) klass;
 889   widget_class = (GtkWidgetClass *) klass;
 890   container_class = (GtkContainerClass *) klass;
 891
 892   parent_class = g_type_class_peek_parent (klass);
 893
 894   /**
 895    * GtkSheet::select-row
 896    * @sheet: the sheet widget that emitted the signal
 897    * @row: the newly selected row index
 898    *
 899    * A row has been selected.
 900    */
 901   sheet_signals[SELECT_ROW] =
 902     g_signal_new ("select-row",
 903                   G_TYPE_FROM_CLASS (object_class),
 904                   G_SIGNAL_RUN_LAST,
 905                   offsetof (GtkSheetClass, select_row),
 906                   NULL, NULL,
 907                   gtkextra_VOID__INT,
 908                   G_TYPE_NONE,
 909                   1,
 910                   G_TYPE_INT);
 911
 912
 913   /**
 914    * GtkSheet::select - column
 915    * @sheet: the sheet widget that emitted the signal
 916    * @column: the newly selected column index
 917    *
 918    * A column has been selected.
 919    */
 920   sheet_signals[SELECT_COLUMN] =
 921     g_signal_new ("select-column",
 922                   G_TYPE_FROM_CLASS (object_class),
 923                   G_SIGNAL_RUN_LAST,
 924                   offsetof (GtkSheetClass, select_column),
 925                   NULL, NULL,
 926                   gtkextra_VOID__INT,
 927                   G_TYPE_NONE,
 928                   1,
 929                   G_TYPE_INT);
 930
 931
 932   /**
 933    * GtkSheet::double-click-row
 934    * @sheet: the sheet widget that emitted the signal
 935    * @row: the row that was double clicked.
 936    *
 937    * A row's title button has been double clicked
 938    */
 939   sheet_signals[DOUBLE_CLICK_ROW] =
 940     g_signal_new ("double-click-row",
 941                   G_TYPE_FROM_CLASS (object_class),
 942                   G_SIGNAL_RUN_LAST,
 943                   0,
 944                   NULL, NULL,
 945                   gtkextra_VOID__INT,
 946                   G_TYPE_NONE,
 947                   1,
 948                   G_TYPE_INT);
 949
 950
 951   /**
 952    * GtkSheet::double-click-column
 953    * @sheet: the sheet widget that emitted the signal
 954    * @column: the column that was double clicked.
 955    *
 956    * A column's title button has been double clicked
 957    */
 958   sheet_signals[DOUBLE_CLICK_COLUMN] =
 959     g_signal_new ("double-click-column",
 960                   G_TYPE_FROM_CLASS (object_class),
 961                   G_SIGNAL_RUN_LAST,
 962                   0,
 963                   NULL, NULL,
 964                   gtkextra_VOID__INT,
 965                   G_TYPE_NONE,
 966                   1,
 967                   G_TYPE_INT);
 968
 969
 970   /**
 971    * GtkSheet::button-event-column
 972    * @sheet: the sheet widget that emitted the signal
 973    * @column: the column on which the event occured.
 974    *
 975    * A button event occured on a column title button
 976    */
 977   sheet_signals[BUTTON_EVENT_COLUMN] =
 978     g_signal_new ("button-event-column",
 979                   G_TYPE_FROM_CLASS (object_class),
 980                   G_SIGNAL_RUN_LAST,
 981                   0,
 982                   NULL, NULL,
 983                   gtkextra_VOID__INT_POINTER,
 984                   G_TYPE_NONE,
 985                   2,
 986                   G_TYPE_INT,
 987                   G_TYPE_POINTER
 988                   );
 989
 990
 991   /**
 992    * GtkSheet::button-event-row
 993    * @sheet: the sheet widget that emitted the signal
 994    * @column: the column on which the event occured.
 995    *
 996    * A button event occured on a row title button
 997    */
 998   sheet_signals[BUTTON_EVENT_ROW] =
 999     g_signal_new ("button-event-row",
1000                   G_TYPE_FROM_CLASS (object_class),
1001                   G_SIGNAL_RUN_LAST,
1002                   0,
1003                   NULL, NULL,
1004                   gtkextra_VOID__INT_POINTER,
1005                   G_TYPE_NONE,
1006                   2,
1007                   G_TYPE_INT,
1008                   G_TYPE_POINTER
1009                   );
1010
1011
1012   sheet_signals[SELECT_RANGE] =
1013     g_signal_new ("select-range",
1014                   G_TYPE_FROM_CLASS (object_class),
1015                   G_SIGNAL_RUN_LAST,
1016                   offsetof (GtkSheetClass, select_range),
1017                   NULL, NULL,
1018                   gtkextra_VOID__BOXED,
1019                   G_TYPE_NONE,
1020                   1,
1021                   GTK_TYPE_SHEET_RANGE);
1022
1023
1024   sheet_signals[RESIZE_RANGE] =
1025     g_signal_new ("resize-range",
1026                   G_TYPE_FROM_CLASS (object_class),
1027                   G_SIGNAL_RUN_LAST,
1028                   offsetof (GtkSheetClass, resize_range),
1029                   NULL, NULL,
1030                   gtkextra_VOID__BOXED_BOXED,
1031                   G_TYPE_NONE,
1032                   2,
1033                   GTK_TYPE_SHEET_RANGE, GTK_TYPE_SHEET_RANGE
1034                   );
1035
1036   sheet_signals[MOVE_RANGE] =
1037     g_signal_new ("move-range",
1038                   G_TYPE_FROM_CLASS (object_class),
1039                   G_SIGNAL_RUN_LAST,
1040                   offsetof (GtkSheetClass, move_range),
1041                   NULL, NULL,
1042                   gtkextra_VOID__BOXED_BOXED,
1043                   G_TYPE_NONE,
1044                   2,
1045                   GTK_TYPE_SHEET_RANGE, GTK_TYPE_SHEET_RANGE
1046                   );
1047
1048   sheet_signals[TRAVERSE] =
1049     g_signal_new ("traverse",
1050                   G_TYPE_FROM_CLASS (object_class),
1051                   G_SIGNAL_RUN_LAST,
1052                   offsetof (GtkSheetClass, traverse),
1053                   NULL, NULL,
1054                   gtkextra_BOOLEAN__INT_INT_POINTER_POINTER,
1055                   G_TYPE_BOOLEAN, 4, G_TYPE_INT, G_TYPE_INT,
1056                   G_TYPE_POINTER, G_TYPE_POINTER);
1057
1058
1059   sheet_signals[DEACTIVATE] =
1060     g_signal_new ("deactivate",
1061                   G_TYPE_FROM_CLASS (object_class),
1062                   G_SIGNAL_RUN_LAST,
1063                   offsetof (GtkSheetClass, deactivate),
1064                   NULL, NULL,
1065                   gtkextra_BOOLEAN__INT_INT,
1066                   G_TYPE_BOOLEAN, 2, G_TYPE_INT, G_TYPE_INT);
1067
1068   sheet_signals[ACTIVATE] =
1069     g_signal_new ("activate",
1070                   G_TYPE_FROM_CLASS (object_class),
1071                   G_SIGNAL_RUN_LAST,
1072                   offsetof (GtkSheetClass, activate),
1073                   NULL, NULL,
1074                   gtkextra_BOOLEAN__INT_INT,
1075                   G_TYPE_BOOLEAN, 2, G_TYPE_INT, G_TYPE_INT);
1076
1077   sheet_signals[SET_CELL] =
1078     g_signal_new ("set-cell",
1079                   G_TYPE_FROM_CLASS (object_class),
1080                   G_SIGNAL_RUN_LAST,
1081                   offsetof (GtkSheetClass, set_cell),
1082                   NULL, NULL,
1083                   gtkextra_VOID__INT_INT,
1084                   G_TYPE_NONE, 2, G_TYPE_INT, G_TYPE_INT);
1085
1086
1087   sheet_signals[CLEAR_CELL] =
1088     g_signal_new ("clear-cell",
1089                   G_TYPE_FROM_CLASS (object_class),
1090                   G_SIGNAL_RUN_LAST,
1091                   offsetof (GtkSheetClass, clear_cell),
1092                   NULL, NULL,
1093                   gtkextra_VOID__INT_INT,
1094                   G_TYPE_NONE, 2, G_TYPE_INT, G_TYPE_INT);
1095
1096   sheet_signals[CHANGED] =
1097     g_signal_new ("changed",
1098                   G_TYPE_FROM_CLASS (object_class),
1099                   G_SIGNAL_RUN_LAST,
1100                   offsetof (GtkSheetClass, changed),
1101                   NULL, NULL,
1102                   gtkextra_VOID__INT_INT,
1103                   G_TYPE_NONE, 2, G_TYPE_INT, G_TYPE_INT);
1104
1105   sheet_signals[NEW_COL_WIDTH] =
1106     g_signal_new ("new-column-width",
1107                   G_TYPE_FROM_CLASS (object_class),
1108                   G_SIGNAL_RUN_LAST,
1109                   offsetof (GtkSheetClass, new_column_width), /*!!!! */
1110                   NULL, NULL,
1111                   gtkextra_VOID__INT_INT,
1112                   G_TYPE_NONE, 2, G_TYPE_INT, G_TYPE_INT);
1113
1114   sheet_signals[NEW_ROW_HEIGHT] =
1115     g_signal_new ("new-row-height",
1116                   G_TYPE_FROM_CLASS (object_class),
1117                   G_SIGNAL_RUN_LAST,
1118                   offsetof (GtkSheetClass, new_row_height), /*!!!! */
1119                   NULL, NULL,
1120                   gtkextra_VOID__INT_INT,
1121                   G_TYPE_NONE, 2, G_TYPE_INT, G_TYPE_INT);
1122
1123   widget_class->set_scroll_adjustments_signal =
1124     g_signal_new ("set-scroll-adjustments",
1125                   G_TYPE_FROM_CLASS (object_class),
1126                   G_SIGNAL_RUN_LAST,
1127                   offsetof (GtkSheetClass, set_scroll_adjustments),
1128                   NULL, NULL,
1129                   gtkextra_VOID__OBJECT_OBJECT,
1130                   G_TYPE_NONE, 2, GTK_TYPE_ADJUSTMENT, GTK_TYPE_ADJUSTMENT);
1131
1132
1133   container_class->add = NULL;
1134   container_class->remove = gtk_sheet_remove;
1135   container_class->forall = gtk_sheet_forall;
1136
1137   object_class->destroy = gtk_sheet_destroy;
1138   gobject_class->finalize = gtk_sheet_finalize;
1139
1140   widget_class->realize = gtk_sheet_realize;
1141   widget_class->unrealize = gtk_sheet_unrealize;
1142   widget_class->map = gtk_sheet_map;
1143   widget_class->unmap = gtk_sheet_unmap;
1144   widget_class->style_set = gtk_sheet_style_set;
1145   widget_class->button_press_event = gtk_sheet_button_press;
1146   widget_class->button_release_event = gtk_sheet_button_release;
1147   widget_class->motion_notify_event = gtk_sheet_motion;
1148   widget_class->key_press_event = gtk_sheet_key_press;
1149   widget_class->expose_event = gtk_sheet_expose;
1150   widget_class->size_request = gtk_sheet_size_request;
1151   widget_class->size_allocate = gtk_sheet_size_allocate;
1152   widget_class->focus_in_event = NULL;
1153   widget_class->focus_out_event = NULL;
1154
1155   klass->set_scroll_adjustments = gtk_sheet_set_scroll_adjustments;
1156   klass->select_row = NULL;
1157   klass->select_column = NULL;
1158   klass->select_range = NULL;
1159   klass->resize_range = NULL;
1160   klass->move_range = NULL;
1161   klass->traverse = NULL;
1162   klass->deactivate = NULL;
1163   klass->activate = NULL;
1164   klass->set_cell = NULL;
1165   klass->clear_cell = NULL;
1166   klass->changed = NULL;
1167 }
1168
1169 static void
1170 gtk_sheet_init (GtkSheet *sheet)
1171 {
1172   sheet->column_geometry = NULL;
1173   sheet->row_geometry = NULL;
1174
1175   sheet->children = NULL;
1176
1177   sheet->flags = 0;
1178   sheet->selection_mode = GTK_SELECTION_NONE;
1179   sheet->freeze_count = 0;
1180   sheet->state = GTK_SHEET_NORMAL;
1181
1182   GTK_WIDGET_UNSET_FLAGS (sheet, GTK_NO_WINDOW);
1183   GTK_WIDGET_SET_FLAGS (sheet, GTK_CAN_FOCUS);
1184
1185   sheet->column_title_window = NULL;
1186   sheet->column_title_area.x = 0;
1187   sheet->column_title_area.y = 0;
1188   sheet->column_title_area.width = 0;
1189   sheet->column_title_area.height = DEFAULT_ROW_HEIGHT (GTK_WIDGET (sheet));
1190
1191   sheet->row_title_window = NULL;
1192   sheet->row_title_area.x = 0;
1193   sheet->row_title_area.y = 0;
1194   sheet->row_title_area.width = DEFAULT_COLUMN_WIDTH;
1195   sheet->row_title_area.height = 0;
1196
1197
1198   sheet->active_cell.row = 0;
1199   sheet->active_cell.col = 0;
1200   sheet->selection_cell.row = 0;
1201   sheet->selection_cell.col = 0;
1202
1203   sheet->sheet_entry = NULL;
1204   sheet->pixmap = NULL;
1205
1206   sheet->range.row0 = 0;
1207   sheet->range.rowi = 0;
1208   sheet->range.col0 = 0;
1209   sheet->range.coli = 0;
1210
1211   sheet->state = GTK_SHEET_NORMAL;
1212
1213   sheet->sheet_window = NULL;
1214   sheet->sheet_window_width = 0;
1215   sheet->sheet_window_height = 0;
1216   sheet->sheet_entry = NULL;
1217   sheet->button = NULL;
1218
1219   sheet->hoffset = 0;
1220   sheet->voffset = 0;
1221
1222   sheet->hadjustment = NULL;
1223   sheet->vadjustment = NULL;
1224
1225   sheet->cursor_drag = gdk_cursor_new (GDK_PLUS);
1226   sheet->xor_gc = NULL;
1227   sheet->fg_gc = NULL;
1228   sheet->bg_gc = NULL;
1229   sheet->x_drag = 0;
1230   sheet->y_drag = 0;
1231
1232   gdk_color_parse ("white", &sheet->bg_color);
1233   gdk_color_alloc (gdk_colormap_get_system (), &sheet->bg_color);
1234   gdk_color_parse ("gray", &sheet->grid_color);
1235   gdk_color_alloc (gdk_colormap_get_system (), &sheet->grid_color);
1236   sheet->show_grid = TRUE;
1237
1238   sheet->motion_timer = 0;
1239 }
1240
1241
1242 /* Callback which occurs whenever columns are inserted / deleted in the model */
1243 static void
1244 columns_inserted_deleted_callback (GSheetModel *model, gint first_column,
1245                                    gint n_columns,
1246                                    gpointer data)
1247 {
1248   gint i;
1249   GtkSheet *sheet = GTK_SHEET (data);
1250
1251   GtkSheetRange range;
1252   gint model_columns = g_sheet_model_get_column_count (model);
1253
1254
1255   /* Need to update all the columns starting from the first column and onwards.
1256    * Previous column are unchanged, so don't need to be updated.
1257    */
1258   range.col0 = first_column;
1259   range.row0 = 0;
1260   range.coli = xxx_column_count (sheet) - 1;
1261   range.rowi = yyy_row_count (sheet) - 1;
1262
1263   adjust_scrollbars (sheet);
1264
1265   if (sheet->active_cell.col >= model_columns)
1266     gtk_sheet_activate_cell (sheet, sheet->active_cell.row, model_columns - 1);
1267
1268   for (i = first_column; i <= MAX_VISIBLE_COLUMN (sheet); i++)
1269     gtk_sheet_column_title_button_draw (sheet, i);
1270
1271   gtk_sheet_range_draw (sheet, &range);
1272 }
1273
1274
1275 /* Callback which occurs whenever rows are inserted / deleted in the model */
1276 static void
1277 rows_inserted_deleted_callback (GSheetModel *model, gint first_row,
1278                                 gint n_rows, gpointer data)
1279 {
1280   gint i;
1281   GtkSheet *sheet = GTK_SHEET (data);
1282
1283   GtkSheetRange range;
1284
1285   gint model_rows = g_sheet_model_get_row_count (model);
1286
1287   /* Need to update all the rows starting from the first row and onwards.
1288    * Previous rows are unchanged, so don't need to be updated.
1289    */
1290   range.row0 = first_row;
1291   range.col0 = 0;
1292   range.rowi = yyy_row_count (sheet) - 1;
1293   range.coli = xxx_column_count (sheet) - 1;
1294
1295   adjust_scrollbars (sheet);
1296
1297   if (sheet->active_cell.row >= model_rows)
1298     gtk_sheet_activate_cell (sheet, model_rows - 1, sheet->active_cell.col);
1299
1300   for (i = first_row; i <= MAX_VISIBLE_ROW (sheet); i++)
1301     gtk_sheet_row_title_button_draw (sheet, i);
1302
1303   gtk_sheet_range_draw (sheet, &range);
1304 }
1305
1306 /*
1307   If row0 or rowi are negative, then all rows will be updated.
1308   If col0 or coli are negative, then all columns will be updated.
1309 */
1310 static void
1311 range_update_callback (GSheetModel *m, gint row0, gint col0,
1312                        gint rowi, gint coli, gpointer data)
1313 {
1314   GtkSheet *sheet = GTK_SHEET (data);
1315
1316   GtkSheetRange range;
1317
1318   range.row0 = row0;
1319   range.col0 = col0;
1320   range.rowi = rowi;
1321   range.coli = coli;
1322
1323   if ( ( row0 < 0 && col0 < 0 ) || ( rowi < 0 && coli < 0 ) )
1324     {
1325       gint i;
1326       gtk_sheet_range_draw (sheet, NULL);
1327       adjust_scrollbars (sheet);
1328
1329       for (i = MIN_VISIBLE_ROW (sheet); i <= MAX_VISIBLE_ROW (sheet); i++)
1330         gtk_sheet_row_title_button_draw (sheet, i);
1331
1332       for (i = MIN_VISIBLE_COLUMN (sheet);
1333            i <= MAX_VISIBLE_COLUMN (sheet); i++)
1334         gtk_sheet_column_title_button_draw (sheet, i);
1335
1336       return;
1337     }
1338   else if ( row0 < 0 || rowi < 0 )
1339     {
1340       range.row0 = MIN_VISIBLE_ROW (sheet);
1341       range.rowi = MAX_VISIBLE_ROW (sheet);
1342     }
1343   else if ( col0 < 0 || coli < 0 )
1344     {
1345       range.col0 = MIN_VISIBLE_COLUMN (sheet);
1346       range.coli = MAX_VISIBLE_COLUMN (sheet);
1347     }
1348
1349   gtk_sheet_range_draw (sheet, &range);
1350 }
1351
1352
1353 static void gtk_sheet_construct  (GtkSheet *sheet,
1354                                   GSheetRow *vgeo,
1355                                   GSheetColumn *hgeo,
1356                                   const gchar *title);
1357
1358
1359 /**
1360  * gtk_sheet_new:
1361  * @rows: initial number of rows
1362  * @columns: initial number of columns
1363  * @title: sheet title
1364  * @model: the model to use for the sheet data
1365  *
1366  * Creates a new sheet widget with the given number of rows and columns.
1367  *
1368  * Returns: the new sheet widget
1369  */
1370 GtkWidget *
1371 gtk_sheet_new (GSheetRow *vgeo, GSheetColumn *hgeo, const gchar *title,
1372                GSheetModel *model)
1373 {
1374   GtkWidget *widget = g_object_new (GTK_TYPE_SHEET, NULL);
1375
1376   gtk_sheet_construct (GTK_SHEET (widget), vgeo, hgeo, title);
1377
1378   if (model)
1379     gtk_sheet_set_model (GTK_SHEET (widget), model);
1380
1381
1382   return widget;
1383 }
1384
1385
1386 /**
1387  * gtk_sheet_set_model
1388  * @sheet: the sheet to set the model for
1389  * @model: the model to use for the sheet data
1390  *
1391  * Sets the model for a GtkSheet
1392  *
1393  */
1394 void
1395 gtk_sheet_set_model (GtkSheet *sheet, GSheetModel *model)
1396 {
1397   g_return_if_fail (GTK_IS_SHEET (sheet));
1398   g_return_if_fail (G_IS_SHEET_MODEL (model));
1399
1400   sheet->model = model;
1401
1402   g_signal_connect (model, "range_changed",
1403                     G_CALLBACK (range_update_callback), sheet);
1404
1405   g_signal_connect (model, "rows_inserted",
1406                     G_CALLBACK (rows_inserted_deleted_callback), sheet);
1407
1408   g_signal_connect (model, "rows_deleted",
1409                     G_CALLBACK (rows_inserted_deleted_callback), sheet);
1410
1411   g_signal_connect (model, "columns_inserted",
1412                     G_CALLBACK (columns_inserted_deleted_callback), sheet);
1413
1414   g_signal_connect (model, "columns_deleted",
1415                     G_CALLBACK (columns_inserted_deleted_callback), sheet);
1416
1417 }
1418
1419
1420 /* Call back for when the column titles have changed.
1421    FIRST is the first column changed.
1422    N_COLUMNS is the number of columns which have changed, or - 1, which
1423    indicates that the column has changed to its right - most extremity
1424 */
1425 static void
1426 column_titles_changed (GtkWidget *w, gint first, gint n_columns, gpointer data)
1427 {
1428   GtkSheet *sheet = GTK_SHEET (data);
1429   gboolean extremity = FALSE;
1430
1431   if ( n_columns == -1 )
1432     {
1433       extremity = TRUE;
1434       n_columns = xxx_column_count (sheet) - 1 ;
1435     }
1436
1437   if (!GTK_SHEET_IS_FROZEN (sheet))
1438     {
1439       gint i;
1440       for ( i = first ; i <= first + n_columns ; ++i )
1441         {
1442           gtk_sheet_column_title_button_draw (sheet, i);
1443           g_signal_emit (G_OBJECT (sheet), sheet_signals[CHANGED], 0, -1, i);
1444         }
1445     }
1446
1447   if ( extremity)
1448     gtk_sheet_column_title_button_draw (sheet, -1);
1449
1450 }
1451
1452 static void
1453 gtk_sheet_construct (GtkSheet *sheet,
1454                      GSheetRow *vgeo,
1455                      GSheetColumn *hgeo,
1456                      const gchar *title)
1457 {
1458   g_return_if_fail (G_IS_SHEET_COLUMN (hgeo));
1459   g_return_if_fail (G_IS_SHEET_ROW (vgeo));
1460
1461   sheet->column_geometry = hgeo;
1462   sheet->row_geometry = vgeo;
1463
1464
1465   sheet->columns_resizable = TRUE;
1466   sheet->rows_resizable = TRUE;
1467
1468   sheet->row_titles_visible = TRUE;
1469   sheet->row_title_area.width = DEFAULT_COLUMN_WIDTH;
1470
1471   sheet->column_titles_visible = TRUE;
1472   sheet->autoscroll = TRUE;
1473   sheet->justify_entry = TRUE;
1474
1475
1476   /* create sheet entry */
1477   sheet->entry_type = 0;
1478   create_sheet_entry (sheet);
1479
1480   /* create global selection button */
1481   create_global_button (sheet);
1482
1483   if (title)
1484     sheet->name = g_strdup (title);
1485
1486   g_signal_connect (sheet->column_geometry, "columns_changed",
1487                     G_CALLBACK (column_titles_changed), sheet);
1488
1489 }
1490
1491
1492 GtkWidget *
1493 gtk_sheet_new_with_custom_entry (GSheetRow *rows, GSheetColumn *columns,
1494                                  const gchar *title, GtkType entry_type)
1495 {
1496   GtkWidget *widget = g_object_new (GTK_TYPE_SHEET, NULL);
1497
1498   gtk_sheet_construct_with_custom_entry (GTK_SHEET (widget),
1499                                          rows, columns, title, entry_type);
1500
1501   return widget;
1502 }
1503
1504 void
1505 gtk_sheet_construct_with_custom_entry (GtkSheet *sheet,
1506                                        GSheetRow *vgeo,
1507                                        GSheetColumn *hgeo,
1508                                        const gchar *title,
1509                                        GtkType entry_type)
1510 {
1511   gtk_sheet_construct (sheet, vgeo, hgeo, title);
1512
1513   sheet->entry_type = entry_type;
1514   create_sheet_entry (sheet);
1515 }
1516
1517
1518
1519 void
1520 gtk_sheet_change_entry (GtkSheet *sheet, GtkType entry_type)
1521 {
1522   gint state;
1523
1524   g_return_if_fail (sheet != NULL);
1525   g_return_if_fail (GTK_IS_SHEET (sheet));
1526
1527   state = sheet->state;
1528
1529   if (sheet->state == GTK_SHEET_NORMAL)
1530     gtk_sheet_hide_active_cell (sheet);
1531
1532   sheet->entry_type = entry_type;
1533
1534   create_sheet_entry (sheet);
1535
1536   if (state == GTK_SHEET_NORMAL)
1537     {
1538       gtk_sheet_show_active_cell (sheet);
1539       g_signal_connect (G_OBJECT (gtk_sheet_get_entry (sheet)),
1540                         "changed",
1541                         G_CALLBACK (gtk_sheet_entry_changed),
1542                         sheet);
1543     }
1544 }
1545
1546 void
1547 gtk_sheet_show_grid (GtkSheet *sheet, gboolean show)
1548 {
1549   g_return_if_fail (sheet != NULL);
1550   g_return_if_fail (GTK_IS_SHEET (sheet));
1551
1552   if (show == sheet->show_grid) return;
1553
1554   sheet->show_grid = show;
1555
1556   if (!GTK_SHEET_IS_FROZEN (sheet))
1557     gtk_sheet_range_draw (sheet, NULL);
1558 }
1559
1560 gboolean
1561 gtk_sheet_grid_visible (GtkSheet *sheet)
1562 {
1563   g_return_val_if_fail (sheet != NULL, 0);
1564   g_return_val_if_fail (GTK_IS_SHEET (sheet), 0);
1565
1566   return sheet->show_grid;
1567 }
1568
1569 void
1570 gtk_sheet_set_background (GtkSheet *sheet, GdkColor *color)
1571 {
1572   g_return_if_fail (sheet != NULL);
1573   g_return_if_fail (GTK_IS_SHEET (sheet));
1574
1575   if (!color)
1576     {
1577       gdk_color_parse ("white", &sheet->bg_color);
1578       gdk_color_alloc (gdk_colormap_get_system (), &sheet->bg_color);
1579     }
1580   else
1581     sheet->bg_color = *color;
1582
1583   if (!GTK_SHEET_IS_FROZEN (sheet))
1584     gtk_sheet_range_draw (sheet, NULL);
1585 }
1586
1587 void
1588 gtk_sheet_set_grid (GtkSheet *sheet, GdkColor *color)
1589 {
1590   g_return_if_fail (sheet != NULL);
1591   g_return_if_fail (GTK_IS_SHEET (sheet));
1592
1593   if (!color)
1594     {
1595       gdk_color_parse ("black", &sheet->grid_color);
1596       gdk_color_alloc (gdk_colormap_get_system (), &sheet->grid_color);
1597     }
1598   else
1599     sheet->grid_color = *color;
1600
1601   if (!GTK_SHEET_IS_FROZEN (sheet))
1602     gtk_sheet_range_draw (sheet, NULL);
1603 }
1604
1605 guint
1606 gtk_sheet_get_columns_count (GtkSheet *sheet)
1607 {
1608   g_return_val_if_fail (sheet != NULL, 0);
1609   g_return_val_if_fail (GTK_IS_SHEET (sheet), 0);
1610
1611   return xxx_column_count (sheet);
1612 }
1613
1614 guint
1615 gtk_sheet_get_rows_count (GtkSheet *sheet)
1616 {
1617   g_return_val_if_fail (sheet != NULL, 0);
1618   g_return_val_if_fail (GTK_IS_SHEET (sheet), 0);
1619
1620   return yyy_row_count (sheet);
1621 }
1622
1623 gint
1624 gtk_sheet_get_state (GtkSheet *sheet)
1625 {
1626   g_return_val_if_fail (sheet != NULL, 0);
1627   g_return_val_if_fail (GTK_IS_SHEET (sheet), 0);
1628
1629   return (sheet->state);
1630 }
1631
1632 void
1633 gtk_sheet_set_selection_mode (GtkSheet *sheet, gint mode)
1634 {
1635   g_return_if_fail (sheet != NULL);
1636   g_return_if_fail (GTK_IS_SHEET (sheet));
1637
1638   if (GTK_WIDGET_REALIZED (sheet))
1639     gtk_sheet_real_unselect_range (sheet, NULL);
1640
1641   sheet->selection_mode = mode;
1642 }
1643
1644 void
1645 gtk_sheet_set_autoresize (GtkSheet *sheet, gboolean autoresize)
1646 {
1647   g_return_if_fail (sheet != NULL);
1648   g_return_if_fail (GTK_IS_SHEET (sheet));
1649
1650   sheet->autoresize = autoresize;
1651 }
1652
1653 gboolean
1654 gtk_sheet_autoresize (GtkSheet *sheet)
1655 {
1656   g_return_val_if_fail (sheet != NULL, FALSE);
1657   g_return_val_if_fail (GTK_IS_SHEET (sheet), FALSE);
1658
1659   return sheet->autoresize;
1660 }
1661
1662 static void
1663 gtk_sheet_set_column_width (GtkSheet * sheet,
1664                             gint column,
1665                             guint width);
1666
1667
1668 static void
1669 gtk_sheet_autoresize_column (GtkSheet *sheet, gint column)
1670 {
1671   gint text_width = 0;
1672   gint row;
1673
1674   g_return_if_fail (sheet != NULL);
1675   g_return_if_fail (GTK_IS_SHEET (sheet));
1676   if (column >= xxx_column_count (sheet) || column < 0) return;
1677
1678   for (row = 0; row < yyy_row_count (sheet); row++)
1679     {
1680       gchar *text = gtk_sheet_cell_get_text (sheet, row, column);
1681       if (text && strlen (text) > 0)
1682         {
1683           GtkSheetCellAttr attributes;
1684
1685           gtk_sheet_get_attributes (sheet, row, column, &attributes);
1686           if (attributes.is_visible)
1687             {
1688               gint width = STRING_WIDTH (GTK_WIDGET (sheet),
1689                                          attributes.font_desc,
1690                                          text)
1691                 + 2 * CELLOFFSET + attributes.border.width;
1692               text_width = MAX (text_width, width);
1693             }
1694         }
1695       dispose_string (sheet, text);
1696     }
1697
1698   if (text_width > xxx_column_width (sheet, column) )
1699     {
1700       gtk_sheet_set_column_width (sheet, column, text_width);
1701       GTK_SHEET_SET_FLAGS (sheet, GTK_SHEET_REDRAW_PENDING);
1702     }
1703 }
1704
1705
1706 void
1707 gtk_sheet_set_autoscroll (GtkSheet *sheet, gboolean autoscroll)
1708 {
1709   g_return_if_fail (sheet != NULL);
1710   g_return_if_fail (GTK_IS_SHEET (sheet));
1711
1712   sheet->autoscroll = autoscroll;
1713 }
1714
1715 gboolean
1716 gtk_sheet_autoscroll (GtkSheet *sheet)
1717 {
1718   g_return_val_if_fail (sheet != NULL, FALSE);
1719   g_return_val_if_fail (GTK_IS_SHEET (sheet), FALSE);
1720
1721   return sheet->autoscroll;
1722 }
1723
1724
1725 void
1726 gtk_sheet_set_justify_entry (GtkSheet *sheet, gboolean justify)
1727 {
1728   g_return_if_fail (sheet != NULL);
1729   g_return_if_fail (GTK_IS_SHEET (sheet));
1730
1731   sheet->justify_entry = justify;
1732 }
1733
1734 gboolean
1735 gtk_sheet_justify_entry (GtkSheet *sheet)
1736 {
1737   g_return_val_if_fail (sheet != NULL, FALSE);
1738   g_return_val_if_fail (GTK_IS_SHEET (sheet), FALSE);
1739
1740   return sheet->justify_entry;
1741 }
1742
1743 void
1744 gtk_sheet_set_locked (GtkSheet *sheet, gboolean locked)
1745 {
1746   g_return_if_fail (sheet != NULL);
1747   g_return_if_fail (GTK_IS_SHEET (sheet));
1748
1749   if ( locked )
1750     {
1751       GTK_SHEET_SET_FLAGS (sheet, GTK_SHEET_IS_LOCKED);
1752       gtk_widget_hide (sheet->sheet_entry);
1753       gtk_widget_unmap (sheet->sheet_entry);
1754     }
1755   else
1756     {
1757       GTK_SHEET_UNSET_FLAGS (sheet, GTK_SHEET_IS_LOCKED);
1758       if (GTK_WIDGET_MAPPED (GTK_WIDGET (sheet)))
1759         {
1760           gtk_widget_show (sheet->sheet_entry);
1761           gtk_widget_map (sheet->sheet_entry);
1762         }
1763     }
1764
1765   gtk_editable_set_editable (GTK_EDITABLE (sheet->sheet_entry), locked);
1766
1767 }
1768
1769 gboolean
1770 gtk_sheet_locked (const GtkSheet *sheet)
1771 {
1772   g_return_val_if_fail (sheet != NULL, FALSE);
1773   g_return_val_if_fail (GTK_IS_SHEET (sheet), FALSE);
1774
1775   return GTK_SHEET_IS_LOCKED (sheet);
1776 }
1777
1778 /* This routine has problems with gtk+- 1.2 related with the
1779    label / button drawing - I think it's a bug in gtk+- 1.2 */
1780 void
1781 gtk_sheet_set_title (GtkSheet *sheet, const gchar *title)
1782 {
1783   GtkWidget *label;
1784
1785   g_return_if_fail (sheet != NULL);
1786   g_return_if_fail (title != NULL);
1787   g_return_if_fail (GTK_IS_SHEET (sheet));
1788
1789   if (sheet->name)
1790     g_free (sheet->name);
1791
1792   sheet->name = g_strdup (title);
1793
1794   if (!GTK_WIDGET_REALIZED (GTK_WIDGET (sheet)) || !title) return;
1795
1796   if (GTK_BIN (sheet->button)->child)
1797     label = GTK_BIN (sheet->button)->child;
1798
1799   size_allocate_global_button (sheet);
1800 }
1801
1802 void
1803 gtk_sheet_freeze (GtkSheet *sheet)
1804 {
1805   g_return_if_fail (sheet != NULL);
1806   g_return_if_fail (GTK_IS_SHEET (sheet));
1807
1808   sheet->freeze_count++;
1809   GTK_SHEET_SET_FLAGS (sheet, GTK_SHEET_IS_FROZEN);
1810 }
1811
1812 void
1813 gtk_sheet_thaw (GtkSheet *sheet)
1814 {
1815   g_return_if_fail (sheet != NULL);
1816   g_return_if_fail (GTK_IS_SHEET (sheet));
1817
1818   if (sheet->freeze_count == 0) return;
1819
1820   sheet->freeze_count--;
1821   if (sheet->freeze_count > 0) return;
1822
1823   adjust_scrollbars (sheet);
1824
1825   GTK_SHEET_UNSET_FLAGS (sheet, GTK_SHEET_IS_FROZEN);
1826
1827   sheet->old_vadjustment = -1.;
1828   sheet->old_hadjustment = -1.;
1829
1830   if (sheet->hadjustment)
1831     g_signal_emit_by_name (G_OBJECT (sheet->hadjustment),
1832                            "value_changed");
1833   if (sheet->vadjustment)
1834     g_signal_emit_by_name (G_OBJECT (sheet->vadjustment),
1835                            "value_changed");
1836
1837   if (sheet->state == GTK_STATE_NORMAL)
1838     if (sheet->sheet_entry && GTK_WIDGET_MAPPED (sheet->sheet_entry))
1839       {
1840         gtk_sheet_activate_cell (sheet, sheet->active_cell.row,
1841                                  sheet->active_cell.col);
1842       }
1843
1844 }
1845
1846 void
1847 gtk_sheet_set_row_titles_width (GtkSheet *sheet, guint width)
1848 {
1849   if (width < COLUMN_MIN_WIDTH) return;
1850
1851   sheet->row_title_area.width = width;
1852
1853   adjust_scrollbars (sheet);
1854
1855   sheet->old_hadjustment = -1.;
1856   if (sheet->hadjustment)
1857     g_signal_emit_by_name (G_OBJECT (sheet->hadjustment),
1858                            "value_changed");
1859   size_allocate_global_button (sheet);
1860 }
1861
1862 void
1863 gtk_sheet_set_column_titles_height (GtkSheet *sheet, guint height)
1864 {
1865   if (height < DEFAULT_ROW_HEIGHT (GTK_WIDGET (sheet))) return;
1866
1867   sheet->column_title_area.height = height;
1868
1869   adjust_scrollbars (sheet);
1870
1871   sheet->old_vadjustment = -1.;
1872   if (sheet->vadjustment)
1873     g_signal_emit_by_name (G_OBJECT (sheet->vadjustment),
1874                            "value_changed");
1875   size_allocate_global_button (sheet);
1876 }
1877
1878 void
1879 gtk_sheet_show_column_titles (GtkSheet *sheet)
1880 {
1881   gint col;
1882
1883   if (sheet->column_titles_visible) return;
1884
1885   sheet->column_titles_visible = TRUE;
1886
1887
1888   if (GTK_WIDGET_REALIZED (GTK_WIDGET (sheet)))
1889     {
1890       gdk_window_show (sheet->column_title_window);
1891       gdk_window_move_resize (sheet->column_title_window,
1892                               sheet->column_title_area.x,
1893                               sheet->column_title_area.y,
1894                               sheet->column_title_area.width,
1895                               sheet->column_title_area.height);
1896
1897       for (col = MIN_VISIBLE_COLUMN (sheet);
1898            col <= MAX_VISIBLE_COLUMN (sheet);
1899            col++)
1900         {
1901           GtkSheetButton *button = xxx_column_button (sheet, col);
1902           GtkSheetChild *child = button->child;
1903           if (child)
1904             gtk_sheet_child_show (child);
1905           gtk_sheet_button_free (button);
1906         }
1907       adjust_scrollbars (sheet);
1908     }
1909
1910   sheet->old_vadjustment = -1.;
1911   if (sheet->vadjustment)
1912     g_signal_emit_by_name (G_OBJECT (sheet->vadjustment),
1913                            "value_changed");
1914   size_allocate_global_button (sheet);
1915 }
1916
1917
1918 void
1919 gtk_sheet_show_row_titles (GtkSheet *sheet)
1920 {
1921   gint row;
1922
1923   if (sheet->row_titles_visible) return;
1924
1925   sheet->row_titles_visible = TRUE;
1926
1927
1928   if (GTK_WIDGET_REALIZED (GTK_WIDGET (sheet)))
1929     {
1930       gdk_window_show (sheet->row_title_window);
1931       gdk_window_move_resize (sheet->row_title_window,
1932                               sheet->row_title_area.x,
1933                               sheet->row_title_area.y,
1934                               sheet->row_title_area.width,
1935                               sheet->row_title_area.height);
1936
1937       for (row = MIN_VISIBLE_ROW (sheet);
1938            row <= MAX_VISIBLE_ROW (sheet);
1939            row++)
1940         {
1941           const GtkSheetButton *button = yyy_row_button (sheet, row);
1942           GtkSheetChild *child = button->child;
1943
1944           if (child)
1945             {
1946               gtk_sheet_child_show (child);
1947             }
1948         }
1949       adjust_scrollbars (sheet);
1950     }
1951
1952   sheet->old_hadjustment = -1.;
1953   if (sheet->hadjustment)
1954     g_signal_emit_by_name (G_OBJECT (sheet->hadjustment),
1955                            "value_changed");
1956   size_allocate_global_button (sheet);
1957 }
1958
1959 void
1960 gtk_sheet_hide_column_titles (GtkSheet *sheet)
1961 {
1962   gint col;
1963
1964   if (!sheet->column_titles_visible) return;
1965
1966   sheet->column_titles_visible = FALSE;
1967
1968   if (GTK_WIDGET_REALIZED (GTK_WIDGET (sheet)))
1969     {
1970       if (sheet->column_title_window)
1971         gdk_window_hide (sheet->column_title_window);
1972       if (GTK_WIDGET_VISIBLE (sheet->button))
1973         gtk_widget_hide (sheet->button);
1974
1975       for (col = MIN_VISIBLE_COLUMN (sheet);
1976            col <= MAX_VISIBLE_COLUMN (sheet);
1977            col++)
1978         {
1979           GtkSheetButton *button = xxx_column_button (sheet, col);
1980           GtkSheetChild *child = button->child;
1981           if (child)
1982             gtk_sheet_child_hide (child);
1983           gtk_sheet_button_free (button);
1984         }
1985       adjust_scrollbars (sheet);
1986     }
1987
1988   sheet->old_vadjustment = -1.;
1989   if (sheet->vadjustment)
1990     g_signal_emit_by_name (G_OBJECT (sheet->vadjustment),
1991                            "value_changed");
1992 }
1993
1994 void
1995 gtk_sheet_hide_row_titles (GtkSheet *sheet)
1996 {
1997   gint row;
1998
1999   if (!sheet->row_titles_visible) return;
2000
2001   sheet->row_titles_visible = FALSE;
2002
2003
2004   if (GTK_WIDGET_REALIZED (GTK_WIDGET (sheet)))
2005     {
2006       if (sheet->row_title_window)
2007         gdk_window_hide (sheet->row_title_window);
2008       if (GTK_WIDGET_VISIBLE (sheet->button))
2009         gtk_widget_hide (sheet->button);
2010       for (row = MIN_VISIBLE_ROW (sheet);
2011            row <= MAX_VISIBLE_ROW (sheet);
2012            row++)
2013         {
2014           const GtkSheetButton *button = yyy_row_button (sheet, row);
2015           GtkSheetChild *child = button->child;
2016
2017           if (child)
2018             gtk_sheet_child_hide (child);
2019         }
2020       adjust_scrollbars (sheet);
2021     }
2022
2023   sheet->old_hadjustment = -1.;
2024   if (sheet->hadjustment)
2025     g_signal_emit_by_name (G_OBJECT (sheet->hadjustment),
2026                            "value_changed");
2027 }
2028
2029 gboolean
2030 gtk_sheet_column_titles_visible (GtkSheet *sheet)
2031 {
2032   g_return_val_if_fail (sheet != NULL, FALSE);
2033   g_return_val_if_fail (GTK_IS_SHEET (sheet), FALSE);
2034   return sheet->column_titles_visible;
2035 }
2036
2037 gboolean
2038 gtk_sheet_row_titles_visible (GtkSheet *sheet)
2039 {
2040   g_return_val_if_fail (sheet != NULL, FALSE);
2041   g_return_val_if_fail (GTK_IS_SHEET (sheet), FALSE);
2042   return sheet->row_titles_visible;
2043 }
2044
2045 void
2046 gtk_sheet_moveto (GtkSheet *sheet,
2047                   gint row,
2048                   gint column,
2049                   gfloat row_align,
2050                   gfloat col_align)
2051 {
2052   gint x, y;
2053   guint width, height;
2054   gint adjust;
2055   gint min_row, min_col;
2056
2057   g_return_if_fail (sheet != NULL);
2058   g_return_if_fail (GTK_IS_SHEET (sheet));
2059   g_return_if_fail (sheet->hadjustment != NULL);
2060   g_return_if_fail (sheet->vadjustment != NULL);
2061
2062   if (row < 0 || row >= yyy_row_count (sheet))
2063     return;
2064   if (column < 0 || column >= xxx_column_count (sheet))
2065     return;
2066
2067   height = sheet->sheet_window_height;
2068   width = sheet->sheet_window_width;
2069
2070   /* adjust vertical scrollbar */
2071   if (row >= 0 && row_align >= 0.)
2072     {
2073       y = ROW_TOP_YPIXEL (sheet, row) - sheet->voffset
2074         - (gint) ( row_align*height + (1. - row_align)
2075                    * yyy_row_height (sheet, row));
2076
2077       /* This forces the sheet to scroll when you don't see the entire cell */
2078       min_row = row;
2079       adjust = 0;
2080       if (row_align == 1.)
2081         {
2082           while (min_row >= 0 && min_row > MIN_VISIBLE_ROW (sheet))
2083             {
2084               if (yyy_row_is_visible (sheet, min_row))
2085                 adjust += yyy_row_height (sheet, min_row);
2086               if (adjust >= height)
2087                 {
2088                   break;
2089                 }
2090               min_row--;
2091             }
2092           min_row = MAX (min_row, 0);
2093           y = ROW_TOP_YPIXEL (sheet, min_row) - sheet->voffset +
2094             yyy_row_height (sheet, min_row) - 1;
2095         }
2096
2097       if (y < 0)
2098         sheet->vadjustment->value = 0.0;
2099       else
2100         sheet->vadjustment->value = y;
2101
2102       sheet->old_vadjustment = -1.;
2103       g_signal_emit_by_name (G_OBJECT (sheet->vadjustment),
2104                              "value_changed");
2105
2106     }
2107
2108   /* adjust horizontal scrollbar */
2109   if (column >= 0 && col_align >= 0.)
2110     {
2111       x = COLUMN_LEFT_XPIXEL (sheet, column) - sheet->hoffset
2112         - (gint) ( col_align*width + (1.- col_align)*
2113                    xxx_column_width (sheet, column));
2114
2115
2116       /* This forces the sheet to scroll when you don't see the entire cell */
2117       min_col = column;
2118       adjust = 0;
2119       if (col_align == 1.)
2120         {
2121           while (min_col >= 0 && min_col > MIN_VISIBLE_COLUMN (sheet))
2122             {
2123               if (xxx_column_is_visible (sheet, min_col))
2124                 adjust += xxx_column_width (sheet, min_col);
2125
2126               if (adjust >= width)
2127                 {
2128                   break;
2129                 }
2130               min_col--;
2131             }
2132           min_col = MAX (min_col, 0);
2133           x = COLUMN_LEFT_XPIXEL (sheet, min_col) - sheet->hoffset +
2134             xxx_column_width (sheet, min_col) - 1;
2135         }
2136
2137       if (x < 0)
2138         sheet->hadjustment->value = 0.0;
2139       else
2140         sheet->hadjustment->value = x;
2141
2142       sheet->old_vadjustment = -1.;
2143       g_signal_emit_by_name (G_OBJECT (sheet->hadjustment),
2144                              "value_changed");
2145
2146     }
2147 }
2148
2149
2150 void
2151 gtk_sheet_columns_set_resizable (GtkSheet *sheet, gboolean resizable)
2152 {
2153   g_return_if_fail (sheet != NULL);
2154   g_return_if_fail (GTK_IS_SHEET (sheet));
2155
2156   sheet->columns_resizable = resizable;
2157 }
2158
2159 gboolean
2160 gtk_sheet_columns_resizable (GtkSheet *sheet)
2161 {
2162   g_return_val_if_fail (sheet != NULL, FALSE);
2163   g_return_val_if_fail (GTK_IS_SHEET (sheet), FALSE);
2164
2165   return sheet->columns_resizable;
2166 }
2167
2168
2169 void
2170 gtk_sheet_rows_set_resizable (GtkSheet *sheet, gboolean resizable)
2171 {
2172   g_return_if_fail (sheet != NULL);
2173   g_return_if_fail (GTK_IS_SHEET (sheet));
2174
2175   sheet->rows_resizable = resizable;
2176 }
2177
2178 gboolean
2179 gtk_sheet_rows_resizable (GtkSheet *sheet)
2180 {
2181   g_return_val_if_fail (sheet != NULL, FALSE);
2182   g_return_val_if_fail (GTK_IS_SHEET (sheet), FALSE);
2183
2184   return sheet->rows_resizable;
2185 }
2186
2187
2188 void
2189 gtk_sheet_select_row (GtkSheet * sheet,
2190                       gint row)
2191 {
2192   g_return_if_fail (sheet != NULL);
2193   g_return_if_fail (GTK_IS_SHEET (sheet));
2194
2195   if (row < 0 || row >= yyy_row_count (sheet))
2196     return;
2197
2198   if (sheet->state != GTK_SHEET_NORMAL)
2199     gtk_sheet_real_unselect_range (sheet, NULL);
2200   else
2201     {
2202       gboolean veto = TRUE;
2203       veto = gtk_sheet_deactivate_cell (sheet);
2204       if (!veto) return;
2205     }
2206
2207   sheet->state = GTK_SHEET_ROW_SELECTED;
2208   sheet->range.row0 = row;
2209   sheet->range.col0 = 0;
2210   sheet->range.rowi = row;
2211   sheet->range.coli = xxx_column_count (sheet) - 1;
2212   sheet->active_cell.row = row;
2213   sheet->active_cell.col = 0;
2214
2215   g_signal_emit (G_OBJECT (sheet), sheet_signals[SELECT_ROW], 0, row);
2216   gtk_sheet_real_select_range (sheet, NULL);
2217 }
2218
2219
2220 void
2221 gtk_sheet_select_column (GtkSheet * sheet, gint column)
2222 {
2223   g_return_if_fail (sheet != NULL);
2224   g_return_if_fail (GTK_IS_SHEET (sheet));
2225
2226   if (column < 0 || column >= xxx_column_count (sheet))
2227     return;
2228
2229   if (sheet->state != GTK_SHEET_NORMAL)
2230     gtk_sheet_real_unselect_range (sheet, NULL);
2231   else
2232     {
2233       gboolean veto = TRUE;
2234       veto = gtk_sheet_deactivate_cell (sheet);
2235       if (!veto) return;
2236     }
2237
2238   sheet->state = GTK_SHEET_COLUMN_SELECTED;
2239   sheet->range.row0 = 0;
2240   sheet->range.col0 = column;
2241   sheet->range.rowi = yyy_row_count (sheet) - 1;
2242   sheet->range.coli = column;
2243   sheet->active_cell.row = 0;
2244   sheet->active_cell.col = column;
2245
2246   g_signal_emit (G_OBJECT (sheet), sheet_signals[SELECT_COLUMN], 0, column);
2247   gtk_sheet_real_select_range (sheet, NULL);
2248 }
2249
2250
2251
2252
2253 static gboolean
2254 gtk_sheet_range_isvisible (const GtkSheet * sheet,
2255                            GtkSheetRange range)
2256 {
2257   g_return_val_if_fail (sheet != NULL, FALSE);
2258
2259   if (range.row0 < 0 || range.row0 >= yyy_row_count (sheet))
2260     return FALSE;
2261
2262   if (range.rowi < 0 || range.rowi >= yyy_row_count (sheet))
2263     return FALSE;
2264
2265   if (range.col0 < 0 || range.col0 >= xxx_column_count (sheet))
2266     return FALSE;
2267
2268   if (range.coli < 0 || range.coli >= xxx_column_count (sheet))
2269     return FALSE;
2270
2271   if (range.rowi < MIN_VISIBLE_ROW (sheet))
2272     return FALSE;
2273
2274   if (range.row0 > MAX_VISIBLE_ROW (sheet))
2275     return FALSE;
2276
2277   if (range.coli < MIN_VISIBLE_COLUMN (sheet))
2278     return FALSE;
2279
2280   if (range.col0 > MAX_VISIBLE_COLUMN (sheet))
2281     return FALSE;
2282
2283   return TRUE;
2284 }
2285
2286 static gboolean
2287 gtk_sheet_cell_isvisible (GtkSheet * sheet,
2288                           gint row, gint column)
2289 {
2290   GtkSheetRange range;
2291
2292   range.row0 = row;
2293   range.col0 = column;
2294   range.rowi = row;
2295   range.coli = column;
2296
2297   return gtk_sheet_range_isvisible (sheet, range);
2298 }
2299
2300 void
2301 gtk_sheet_get_visible_range (GtkSheet *sheet, GtkSheetRange *range)
2302 {
2303   g_return_if_fail (sheet != NULL);
2304   g_return_if_fail (GTK_IS_SHEET (sheet)) ;
2305   g_return_if_fail (range != NULL);
2306
2307   range->row0 = MIN_VISIBLE_ROW (sheet);
2308   range->col0 = MIN_VISIBLE_COLUMN (sheet);
2309   range->rowi = MAX_VISIBLE_ROW (sheet);
2310   range->coli = MAX_VISIBLE_COLUMN (sheet);
2311 }
2312
2313 GtkAdjustment *
2314 gtk_sheet_get_vadjustment (GtkSheet * sheet)
2315 {
2316   g_return_val_if_fail (sheet != NULL, NULL);
2317   g_return_val_if_fail (GTK_IS_SHEET (sheet), NULL);
2318
2319   return sheet->vadjustment;
2320 }
2321
2322 GtkAdjustment *
2323 gtk_sheet_get_hadjustment (GtkSheet * sheet)
2324 {
2325   g_return_val_if_fail (sheet != NULL, NULL);
2326   g_return_val_if_fail (GTK_IS_SHEET (sheet), NULL);
2327
2328   return sheet->hadjustment;
2329 }
2330
2331 void
2332 gtk_sheet_set_vadjustment (GtkSheet *sheet,
2333                            GtkAdjustment *adjustment)
2334 {
2335   GtkAdjustment *old_adjustment;
2336
2337   g_return_if_fail (sheet != NULL);
2338   g_return_if_fail (GTK_IS_SHEET (sheet));
2339   if (adjustment)
2340     g_return_if_fail (GTK_IS_ADJUSTMENT (adjustment));
2341
2342   if (sheet->vadjustment == adjustment)
2343     return;
2344
2345   old_adjustment = sheet->vadjustment;
2346
2347   if (sheet->vadjustment)
2348     {
2349       g_signal_handlers_disconnect_matched (G_OBJECT (sheet->vadjustment),
2350                                             G_SIGNAL_MATCH_DATA,
2351                                             0, 0, 0, 0,
2352                                             sheet);
2353       g_object_unref (G_OBJECT (sheet->vadjustment));
2354     }
2355
2356   sheet->vadjustment = adjustment;
2357
2358   if (sheet->vadjustment)
2359     {
2360       g_object_ref (G_OBJECT (sheet->vadjustment));
2361       g_object_ref_sink (G_OBJECT (sheet->vadjustment));
2362
2363       g_signal_connect (G_OBJECT (sheet->vadjustment), "value_changed",
2364                         G_CALLBACK (vadjustment_value_changed),
2365                         sheet);
2366     }
2367
2368   if (!sheet->vadjustment || !old_adjustment)
2369     {
2370       gtk_widget_queue_resize (GTK_WIDGET (sheet));
2371       return;
2372     }
2373
2374   sheet->old_vadjustment = sheet->vadjustment->value;
2375 }
2376
2377 void
2378 gtk_sheet_set_hadjustment (GtkSheet *sheet,
2379                            GtkAdjustment *adjustment)
2380 {
2381   GtkAdjustment *old_adjustment;
2382
2383   g_return_if_fail (sheet != NULL);
2384   g_return_if_fail (GTK_IS_SHEET (sheet));
2385   if (adjustment)
2386     g_return_if_fail (GTK_IS_ADJUSTMENT (adjustment));
2387
2388   if (sheet->hadjustment == adjustment)
2389     return;
2390
2391   old_adjustment = sheet->hadjustment;
2392
2393   if (sheet->hadjustment)
2394     {
2395       g_signal_handlers_disconnect_matched (G_OBJECT (sheet->hadjustment),
2396                                             G_SIGNAL_MATCH_DATA,
2397                                             0, 0, 0, 0,
2398                                             sheet);
2399       g_object_unref (G_OBJECT (sheet->hadjustment));
2400     }
2401
2402   sheet->hadjustment = adjustment;
2403
2404   if (sheet->hadjustment)
2405     {
2406       g_object_ref (G_OBJECT (sheet->hadjustment));
2407       g_object_ref_sink (G_OBJECT (sheet->hadjustment));
2408
2409       g_signal_connect (G_OBJECT (sheet->hadjustment), "value_changed",
2410                         G_CALLBACK (hadjustment_value_changed),
2411                         sheet);
2412     }
2413
2414   if (!sheet->hadjustment || !old_adjustment)
2415     {
2416       gtk_widget_queue_resize (GTK_WIDGET (sheet));
2417       return;
2418     }
2419
2420   sheet->old_hadjustment = sheet->hadjustment->value;
2421 }
2422
2423 static void
2424 gtk_sheet_set_scroll_adjustments (GtkSheet *sheet,
2425                                   GtkAdjustment *hadjustment,
2426                                   GtkAdjustment *vadjustment)
2427 {
2428   if (sheet->hadjustment != hadjustment)
2429     gtk_sheet_set_hadjustment (sheet, hadjustment);
2430
2431   if (sheet->vadjustment != vadjustment)
2432     gtk_sheet_set_vadjustment (sheet, vadjustment);
2433 }
2434
2435 static void
2436 gtk_sheet_finalize (GObject * object)
2437 {
2438   GtkSheet *sheet;
2439
2440   g_return_if_fail (object != NULL);
2441   g_return_if_fail (GTK_IS_SHEET (object));
2442
2443   sheet = GTK_SHEET (object);
2444
2445   if (sheet->name)
2446     {
2447       g_free (sheet->name);
2448       sheet->name = NULL;
2449     }
2450
2451   if (G_OBJECT_CLASS (parent_class)->finalize)
2452     (*G_OBJECT_CLASS (parent_class)->finalize) (object);
2453 }
2454
2455 static void
2456 gtk_sheet_destroy (GtkObject * object)
2457 {
2458   GtkSheet *sheet;
2459   GList *children;
2460
2461   g_return_if_fail (object != NULL);
2462   g_return_if_fail (GTK_IS_SHEET (object));
2463
2464   sheet = GTK_SHEET (object);
2465
2466   /* destroy the entry */
2467   if (sheet->sheet_entry && GTK_IS_WIDGET (sheet->sheet_entry))
2468     {
2469       gtk_widget_destroy (sheet->sheet_entry);
2470       sheet->sheet_entry = NULL;
2471     }
2472
2473   /* destroy the global selection button */
2474   if (sheet->button && GTK_IS_WIDGET (sheet->button))
2475     {
2476       gtk_widget_destroy (sheet->button);
2477       sheet->button = NULL;
2478     }
2479
2480   /* unref adjustments */
2481   if (sheet->hadjustment)
2482     {
2483       g_signal_handlers_disconnect_matched (G_OBJECT (sheet->hadjustment),
2484                                             G_SIGNAL_MATCH_DATA,
2485                                             0, 0, 0, 0,
2486                                             sheet);
2487
2488       g_object_unref (G_OBJECT (sheet->hadjustment));
2489       sheet->hadjustment = NULL;
2490     }
2491
2492   if (sheet->vadjustment)
2493     {
2494       g_signal_handlers_disconnect_matched (G_OBJECT (sheet->vadjustment),
2495                                             G_SIGNAL_MATCH_DATA,
2496                                             0, 0, 0, 0,
2497                                             sheet);
2498
2499       g_object_unref (G_OBJECT (sheet->vadjustment));
2500
2501       sheet->vadjustment = NULL;
2502     }
2503
2504   children = sheet->children;
2505   while (children)
2506     {
2507       GtkSheetChild *child = (GtkSheetChild *)children->data;
2508       if (child && child->widget)
2509         gtk_sheet_remove (GTK_CONTAINER (sheet), child->widget);
2510       children = sheet->children;
2511     }
2512   sheet->children = NULL;
2513
2514   if (GTK_OBJECT_CLASS (parent_class)->destroy)
2515     (*GTK_OBJECT_CLASS (parent_class)->destroy) (object);
2516 }
2517
2518 static void
2519 gtk_sheet_style_set (GtkWidget *widget,
2520                      GtkStyle *previous_style)
2521 {
2522   GtkSheet *sheet;
2523
2524   g_return_if_fail (widget != NULL);
2525   g_return_if_fail (GTK_IS_SHEET (widget));
2526
2527   if (GTK_WIDGET_CLASS (parent_class)->style_set)
2528     (*GTK_WIDGET_CLASS (parent_class)->style_set) (widget, previous_style);
2529
2530   sheet = GTK_SHEET (widget);
2531
2532   if (GTK_WIDGET_REALIZED (widget))
2533     {
2534       gtk_style_set_background (widget->style, widget->window, widget->state);
2535     }
2536
2537 }
2538
2539 static void
2540 gtk_sheet_realize (GtkWidget * widget)
2541 {
2542   GtkSheet *sheet;
2543   GdkWindowAttr attributes;
2544   gint attributes_mask;
2545   GdkGCValues values, auxvalues;
2546   GdkColormap *colormap;
2547   gchar *name;
2548   GtkSheetChild *child;
2549   GList *children;
2550
2551   g_return_if_fail (widget != NULL);
2552   g_return_if_fail (GTK_IS_SHEET (widget));
2553
2554   sheet = GTK_SHEET (widget);
2555
2556   GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
2557
2558   attributes.window_type = GDK_WINDOW_CHILD;
2559   attributes.x = widget->allocation.x;
2560   attributes.y = widget->allocation.y;
2561   attributes.width = widget->allocation.width;
2562   attributes.height = widget->allocation.height;
2563   attributes.wclass = GDK_INPUT_OUTPUT;
2564
2565   attributes.visual = gtk_widget_get_visual (widget);
2566   attributes.colormap = gtk_widget_get_colormap (widget);
2567
2568   attributes.event_mask = gtk_widget_get_events (widget);
2569   attributes.event_mask |= (GDK_EXPOSURE_MASK |
2570                             GDK_BUTTON_PRESS_MASK |
2571                             GDK_BUTTON_RELEASE_MASK |
2572                             GDK_KEY_PRESS_MASK |
2573                             GDK_POINTER_MOTION_MASK |
2574                             GDK_POINTER_MOTION_HINT_MASK);
2575   attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP |
2576     GDK_WA_CURSOR;
2577
2578   attributes.cursor = gdk_cursor_new (GDK_TOP_LEFT_ARROW);
2579
2580   /* main window */
2581   widget->window = gdk_window_new (gtk_widget_get_parent_window (widget), &attributes, attributes_mask);
2582
2583   gdk_window_set_user_data (widget->window, sheet);
2584
2585   widget->style = gtk_style_attach (widget->style, widget->window);
2586
2587   gtk_style_set_background (widget->style, widget->window, GTK_STATE_NORMAL);
2588
2589   attributes.x = 0;
2590   if (sheet->row_titles_visible)
2591     attributes.x = sheet->row_title_area.width;
2592   attributes.y = 0;
2593   attributes.width = sheet->column_title_area.width;
2594   attributes.height = sheet->column_title_area.height;
2595
2596   /* column - title window */
2597   sheet->column_title_window = gdk_window_new (widget->window, &attributes, attributes_mask);
2598   gdk_window_set_user_data (sheet->column_title_window, sheet);
2599   gtk_style_set_background (widget->style, sheet->column_title_window, GTK_STATE_NORMAL);
2600
2601   attributes.x = 0;
2602   attributes.y = 0;
2603   if (sheet->column_titles_visible)
2604     attributes.y = sheet->column_title_area.height;
2605   attributes.width = sheet->row_title_area.width;
2606   attributes.height = sheet->row_title_area.height;
2607
2608   /* row - title window */
2609   sheet->row_title_window = gdk_window_new (widget->window, &attributes, attributes_mask);
2610   gdk_window_set_user_data (sheet->row_title_window, sheet);
2611   gtk_style_set_background (widget->style, sheet->row_title_window, GTK_STATE_NORMAL);
2612
2613   /* sheet - window */
2614   attributes.cursor = gdk_cursor_new (GDK_PLUS);
2615
2616   attributes.x = 0;
2617   attributes.y = 0;
2618   attributes.width = sheet->sheet_window_width,
2619     attributes.height = sheet->sheet_window_height;
2620
2621   sheet->sheet_window = gdk_window_new (widget->window, &attributes, attributes_mask);
2622   gdk_window_set_user_data (sheet->sheet_window, sheet);
2623
2624   gdk_cursor_unref (attributes.cursor);
2625
2626   gdk_window_set_background (sheet->sheet_window, &widget->style->white);
2627   gdk_window_show (sheet->sheet_window);
2628
2629   /* backing_pixmap */
2630   gtk_sheet_make_backing_pixmap (sheet, 0, 0);
2631
2632   /* GCs */
2633   if (sheet->fg_gc)
2634     gdk_gc_unref (sheet->fg_gc);
2635   if (sheet->bg_gc)
2636     gdk_gc_unref (sheet->bg_gc);
2637   sheet->fg_gc = gdk_gc_new (widget->window);
2638   sheet->bg_gc = gdk_gc_new (widget->window);
2639
2640   colormap = gtk_widget_get_colormap (widget);
2641
2642   gdk_color_white (colormap, &widget->style->white);
2643   gdk_color_black (colormap, &widget->style->black);
2644
2645   gdk_gc_get_values (sheet->fg_gc, &auxvalues);
2646
2647   values.foreground = widget->style->white;
2648   values.function = GDK_INVERT;
2649   values.subwindow_mode = GDK_INCLUDE_INFERIORS;
2650   if (sheet->xor_gc)
2651     gdk_gc_unref (sheet->xor_gc);
2652   sheet->xor_gc = gdk_gc_new_with_values (widget->window,
2653                                           &values,
2654                                           GDK_GC_FOREGROUND |
2655                                           GDK_GC_FUNCTION |
2656                                           GDK_GC_SUBWINDOW);
2657
2658   if (sheet->sheet_entry->parent)
2659     {
2660       gtk_widget_ref (sheet->sheet_entry);
2661       gtk_widget_unparent (sheet->sheet_entry);
2662     }
2663   gtk_widget_set_parent_window (sheet->sheet_entry, sheet->sheet_window);
2664   gtk_widget_set_parent (sheet->sheet_entry, GTK_WIDGET (sheet));
2665
2666   if (sheet->button && sheet->button->parent)
2667     {
2668       gtk_widget_ref (sheet->button);
2669       gtk_widget_unparent (sheet->button);
2670     }
2671   gtk_widget_set_parent_window (sheet->button, sheet->sheet_window);
2672   gtk_widget_set_parent (sheet->button, GTK_WIDGET (sheet));
2673
2674   if (!sheet->cursor_drag)
2675     sheet->cursor_drag = gdk_cursor_new (GDK_PLUS);
2676
2677   if (sheet->column_titles_visible)
2678     gdk_window_show (sheet->column_title_window);
2679   if (sheet->row_titles_visible)
2680     gdk_window_show (sheet->row_title_window);
2681
2682   size_allocate_row_title_buttons (sheet);
2683   size_allocate_column_title_buttons (sheet);
2684
2685   name = g_strdup (sheet->name);
2686   gtk_sheet_set_title (sheet, name);
2687
2688   g_free (name);
2689
2690   children = sheet->children;
2691   while (children)
2692     {
2693       child = children->data;
2694       children = children->next;
2695
2696       gtk_sheet_realize_child (sheet, child);
2697     }
2698
2699   gtk_sheet_update_primary_selection (sheet);
2700 }
2701
2702 static void
2703 create_global_button (GtkSheet *sheet)
2704 {
2705   sheet->button = gtk_button_new_with_label (" ");
2706
2707   g_signal_connect (G_OBJECT (sheet->button),
2708                     "pressed",
2709                     G_CALLBACK (global_button_clicked),
2710                     sheet);
2711 }
2712
2713 static void
2714 size_allocate_global_button (GtkSheet *sheet)
2715 {
2716   GtkAllocation allocation;
2717
2718   if (!sheet->column_titles_visible) return;
2719   if (!sheet->row_titles_visible) return;
2720
2721   gtk_widget_size_request (sheet->button, NULL);
2722
2723   allocation.x = 0;
2724   allocation.y = 0;
2725   allocation.width = sheet->row_title_area.width;
2726   allocation.height = sheet->column_title_area.height;
2727
2728   gtk_widget_size_allocate (sheet->button, &allocation);
2729   gtk_widget_show (sheet->button);
2730 }
2731
2732 static void
2733 global_button_clicked (GtkWidget *widget, gpointer data)
2734 {
2735   gboolean veto;
2736
2737   gtk_sheet_click_cell (GTK_SHEET (data), - 1, - 1, &veto);
2738   gtk_widget_grab_focus (GTK_WIDGET (data));
2739 }
2740
2741
2742 static void
2743 gtk_sheet_unrealize (GtkWidget * widget)
2744 {
2745   GtkSheet *sheet;
2746
2747   g_return_if_fail (widget != NULL);
2748   g_return_if_fail (GTK_IS_SHEET (widget));
2749
2750   sheet = GTK_SHEET (widget);
2751
2752   gdk_cursor_destroy (sheet->cursor_drag);
2753
2754   gdk_gc_destroy (sheet->xor_gc);
2755   gdk_gc_destroy (sheet->fg_gc);
2756   gdk_gc_destroy (sheet->bg_gc);
2757
2758   gdk_window_destroy (sheet->sheet_window);
2759   gdk_window_destroy (sheet->column_title_window);
2760   gdk_window_destroy (sheet->row_title_window);
2761
2762   if (sheet->pixmap)
2763     {
2764       g_object_unref (sheet->pixmap);
2765       sheet->pixmap = NULL;
2766     }
2767
2768   sheet->column_title_window = NULL;
2769   sheet->sheet_window = NULL;
2770   sheet->cursor_drag = NULL;
2771   sheet->xor_gc = NULL;
2772   sheet->fg_gc = NULL;
2773   sheet->bg_gc = NULL;
2774
2775   if (GTK_WIDGET_CLASS (parent_class)->unrealize)
2776     (* GTK_WIDGET_CLASS (parent_class)->unrealize) (widget);
2777 }
2778
2779 static void
2780 gtk_sheet_map (GtkWidget * widget)
2781 {
2782   GtkSheet *sheet;
2783   GtkSheetChild *child;
2784   GList *children;
2785
2786   g_return_if_fail (widget != NULL);
2787   g_return_if_fail (GTK_IS_SHEET (widget));
2788
2789   sheet = GTK_SHEET (widget);
2790
2791   if (!GTK_WIDGET_MAPPED (widget))
2792     {
2793       GTK_WIDGET_SET_FLAGS (widget, GTK_MAPPED);
2794
2795       if (!sheet->cursor_drag) sheet->cursor_drag = gdk_cursor_new (GDK_PLUS);
2796
2797       gdk_window_show (widget->window);
2798
2799       gdk_window_show (sheet->sheet_window);
2800
2801       if (sheet->column_titles_visible)
2802         {
2803           size_allocate_column_title_buttons (sheet);
2804           gdk_window_show (sheet->column_title_window);
2805         }
2806       if (sheet->row_titles_visible)
2807         {
2808           size_allocate_row_title_buttons (sheet);
2809           gdk_window_show (sheet->row_title_window);
2810         }
2811
2812       if (!GTK_WIDGET_MAPPED (sheet->sheet_entry)
2813           && ! gtk_sheet_locked (sheet)
2814           && sheet->active_cell.row >= 0
2815           && sheet->active_cell.col >= 0 )
2816         {
2817           gtk_widget_show (sheet->sheet_entry);
2818           gtk_widget_map (sheet->sheet_entry);
2819         }
2820
2821       if (GTK_WIDGET_VISIBLE (sheet->button) &&
2822           !GTK_WIDGET_MAPPED (sheet->button))
2823         {
2824           gtk_widget_show (sheet->button);
2825           gtk_widget_map (sheet->button);
2826         }
2827
2828       if (GTK_BIN (sheet->button)->child)
2829         if (GTK_WIDGET_VISIBLE (GTK_BIN (sheet->button)->child) &&
2830             !GTK_WIDGET_MAPPED (GTK_BIN (sheet->button)->child))
2831           gtk_widget_map (GTK_BIN (sheet->button)->child);
2832
2833       gtk_sheet_range_draw (sheet, NULL);
2834       gtk_sheet_activate_cell (sheet,
2835                                sheet->active_cell.row,
2836                                sheet->active_cell.col);
2837
2838       children = sheet->children;
2839       while (children)
2840         {
2841           child = children->data;
2842           children = children->next;
2843
2844           if (GTK_WIDGET_VISIBLE (child->widget) &&
2845               !GTK_WIDGET_MAPPED (child->widget))
2846             {
2847               gtk_widget_map (child->widget);
2848               gtk_sheet_position_child (sheet, child);
2849             }
2850         }
2851
2852     }
2853 }
2854
2855 static void
2856 gtk_sheet_unmap (GtkWidget * widget)
2857 {
2858   GtkSheet *sheet;
2859   GtkSheetChild *child;
2860   GList *children;
2861
2862   g_return_if_fail (widget != NULL);
2863   g_return_if_fail (GTK_IS_SHEET (widget));
2864
2865   sheet = GTK_SHEET (widget);
2866
2867   if (GTK_WIDGET_MAPPED (widget))
2868     {
2869       GTK_WIDGET_UNSET_FLAGS (widget, GTK_MAPPED);
2870
2871       gdk_window_hide (sheet->sheet_window);
2872       if (sheet->column_titles_visible)
2873         gdk_window_hide (sheet->column_title_window);
2874       if (sheet->row_titles_visible)
2875         gdk_window_hide (sheet->row_title_window);
2876       gdk_window_hide (widget->window);
2877
2878       if (GTK_WIDGET_MAPPED (sheet->sheet_entry))
2879         gtk_widget_unmap (sheet->sheet_entry);
2880
2881       if (GTK_WIDGET_MAPPED (sheet->button))
2882         gtk_widget_unmap (sheet->button);
2883
2884       children = sheet->children;
2885       while (children)
2886         {
2887           child = children->data;
2888           children = children->next;
2889
2890           if (GTK_WIDGET_VISIBLE (child->widget) &&
2891               GTK_WIDGET_MAPPED (child->widget))
2892             {
2893               gtk_widget_unmap (child->widget);
2894             }
2895         }
2896
2897     }
2898 }
2899
2900
2901 static void
2902 gtk_sheet_cell_draw_default (GtkSheet *sheet, gint row, gint col)
2903 {
2904   GtkWidget *widget;
2905   GdkGC *fg_gc, *bg_gc;
2906   GtkSheetCellAttr attributes;
2907   GdkRectangle area;
2908
2909   g_return_if_fail (sheet != NULL);
2910
2911   /* bail now if we arn't drawable yet */
2912   if (!GTK_WIDGET_DRAWABLE (sheet)) return;
2913
2914   if (row < 0 || row >= yyy_row_count (sheet)) return;
2915   if (col < 0 || col >= xxx_column_count (sheet)) return;
2916   if (! xxx_column_is_visible (sheet, col)) return;
2917   if (! yyy_row_is_visible (sheet, row)) return;
2918
2919   widget = GTK_WIDGET (sheet);
2920
2921   gtk_sheet_get_attributes (sheet, row, col, &attributes);
2922
2923   /* select GC for background rectangle */
2924   gdk_gc_set_foreground (sheet->fg_gc, &attributes.foreground);
2925   gdk_gc_set_foreground (sheet->bg_gc, &attributes.background);
2926
2927   fg_gc = sheet->fg_gc;
2928   bg_gc = sheet->bg_gc;
2929
2930   area.x = COLUMN_LEFT_XPIXEL (sheet, col);
2931   area.y = ROW_TOP_YPIXEL (sheet, row);
2932   area.width= xxx_column_width (sheet, col);
2933   area.height = yyy_row_height (sheet, row);
2934
2935   gdk_draw_rectangle (sheet->pixmap,
2936                       bg_gc,
2937                       TRUE,
2938                       area.x,
2939                       area.y,
2940                       area.width,
2941                       area.height);
2942
2943   gdk_gc_set_line_attributes (sheet->fg_gc, 1, 0, 0, 0);
2944
2945   if (sheet->show_grid)
2946     {
2947       gdk_gc_set_foreground (sheet->bg_gc, &sheet->grid_color);
2948
2949       gdk_draw_rectangle (sheet->pixmap,
2950                           sheet->bg_gc,
2951                           FALSE,
2952                           area.x, area.y,
2953                           area.width, area.height);
2954     }
2955 }
2956
2957 static void
2958 gtk_sheet_cell_draw_label (GtkSheet *sheet, gint row, gint col)
2959 {
2960   GtkWidget *widget;
2961   GdkRectangle area;
2962   gint i;
2963   gint text_width, text_height, y;
2964   gint xoffset = 0;
2965   gint size, sizel, sizer;
2966   GdkGC *fg_gc, *bg_gc;
2967   GtkSheetCellAttr attributes;
2968   PangoLayout *layout;
2969   PangoRectangle rect;
2970   PangoRectangle logical_rect;
2971   PangoLayoutLine *line;
2972   PangoFontMetrics *metrics;
2973   PangoContext *context = gtk_widget_get_pango_context (GTK_WIDGET (sheet));
2974   gint ascent, descent, y_pos;
2975
2976   gchar *label;
2977
2978   g_return_if_fail (sheet != NULL);
2979
2980   /* bail now if we aren't drawable yet */
2981   if (!GTK_WIDGET_DRAWABLE (sheet))
2982     return;
2983
2984   label = gtk_sheet_cell_get_text (sheet, row, col);
2985   if (!label)
2986     return;
2987
2988   if (row < 0 || row >= yyy_row_count (sheet)) return;
2989   if (col < 0 || col >= xxx_column_count (sheet)) return;
2990   if (! xxx_column_is_visible (sheet, col)) return;
2991   if (!yyy_row_is_visible (sheet, row)) return;
2992
2993
2994   widget = GTK_WIDGET (sheet);
2995
2996   gtk_sheet_get_attributes (sheet, row, col, &attributes);
2997
2998   /* select GC for background rectangle */
2999   gdk_gc_set_foreground (sheet->fg_gc, &attributes.foreground);
3000   gdk_gc_set_foreground (sheet->bg_gc, &attributes.background);
3001
3002   fg_gc = sheet->fg_gc;
3003   bg_gc = sheet->bg_gc;
3004
3005   area.x = COLUMN_LEFT_XPIXEL (sheet, col);
3006   area.y = ROW_TOP_YPIXEL (sheet, row);
3007   area.width = xxx_column_width (sheet, col);
3008   area.height = yyy_row_height (sheet, row);
3009
3010
3011   layout = gtk_widget_create_pango_layout (GTK_WIDGET (sheet), label);
3012   dispose_string (sheet, label);
3013   pango_layout_set_font_description (layout, attributes.font_desc);
3014
3015   pango_layout_get_pixel_extents (layout, NULL, &rect);
3016
3017   line = pango_layout_get_lines (layout)->data;
3018   pango_layout_line_get_extents (line, NULL, &logical_rect);
3019
3020   metrics = pango_context_get_metrics (context,
3021                                        attributes.font_desc,
3022                                        pango_context_get_language (context));
3023
3024   ascent = pango_font_metrics_get_ascent (metrics) / PANGO_SCALE;
3025   descent = pango_font_metrics_get_descent (metrics) / PANGO_SCALE;
3026
3027   pango_font_metrics_unref (metrics);
3028
3029   /* Align primarily for locale's ascent / descent */
3030
3031   logical_rect.height /= PANGO_SCALE;
3032   logical_rect.y /= PANGO_SCALE;
3033   y_pos = area.height - logical_rect.height;
3034
3035   if (logical_rect.height > area.height)
3036     y_pos = (logical_rect.height - area.height - 2 * CELLOFFSET) / 2;
3037   else if (y_pos < 0)
3038     y_pos = 0;
3039   else if (y_pos + logical_rect.height > area.height)
3040     y_pos = area.height - logical_rect.height;
3041
3042   text_width = rect.width;
3043   text_height = rect.height;
3044   y = area.y + y_pos - CELLOFFSET;
3045
3046   switch (attributes.justification)
3047     {
3048     case GTK_JUSTIFY_RIGHT:
3049       size = area.width;
3050       area.x +=area.width;
3051         {
3052           for (i = col - 1; i >= MIN_VISIBLE_COLUMN (sheet); i--)
3053             {
3054               if ( !gtk_sheet_cell_empty (sheet, row, i)) break;
3055               if (size >= text_width + CELLOFFSET) break;
3056               size +=xxx_column_width (sheet, i);
3057               xxx_column_set_right_column (sheet, i,
3058                                            MAX (col,
3059                                                 xxx_column_right_column (sheet, i)));
3060             }
3061           area.width = size;
3062         }
3063       area.x -= size;
3064       xoffset += area.width - text_width - 2 * CELLOFFSET -
3065         attributes.border.width / 2;
3066       break;
3067     case GTK_JUSTIFY_CENTER:
3068       sizel = area.width / 2;
3069       sizer = area.width / 2;
3070       area.x += area.width / 2;
3071         {
3072           for (i = col + 1; i <= MAX_VISIBLE_COLUMN (sheet); i++)
3073             {
3074               if ( ! gtk_sheet_cell_empty (sheet, row, i)) break;
3075               if (sizer >= text_width / 2) break;
3076               sizer += xxx_column_width (sheet, i);
3077               xxx_column_set_left_column (sheet, i,
3078                                           MIN (
3079                                                col,
3080                                                xxx_column_left_column (sheet, i)));
3081             }
3082           for (i = col - 1; i >= MIN_VISIBLE_COLUMN (sheet); i--)
3083             {
3084               if ( ! gtk_sheet_cell_empty (sheet, row, i)) break;
3085               if (sizel >= text_width / 2) break;
3086               sizel +=xxx_column_width (sheet, i);
3087               xxx_column_set_right_column (sheet, i,
3088                                            MAX (col,
3089                                                 xxx_column_right_column (sheet, i)));
3090             }
3091           size = MIN (sizel, sizer);
3092         }
3093       area.x -= sizel;
3094       xoffset += sizel - text_width / 2 - CELLOFFSET;
3095       area.width = sizel + sizer;
3096       break;
3097     case GTK_JUSTIFY_LEFT:
3098     default:
3099       size = area.width;
3100         {
3101           for (i = col + 1; i <= MAX_VISIBLE_COLUMN (sheet); i++)
3102             {
3103               if (! gtk_sheet_cell_empty (sheet, row, i)) break;
3104               if (size >= text_width + CELLOFFSET) break;
3105               size +=xxx_column_width (sheet, i);
3106               xxx_column_set_left_column (sheet, i,
3107                                           MIN (
3108                                                col,
3109                                                xxx_column_left_column (sheet, i)));
3110
3111             }
3112           area.width = size;
3113         }
3114       xoffset += attributes.border.width / 2;
3115       break;
3116     }
3117
3118   gdk_gc_set_clip_rectangle (fg_gc, &area);
3119
3120
3121   gdk_draw_layout (sheet->pixmap, fg_gc,
3122                    area.x + xoffset + CELLOFFSET,
3123                    y,
3124                    layout);
3125
3126   gdk_gc_set_clip_rectangle (fg_gc, NULL);
3127   g_object_unref (G_OBJECT (layout));
3128
3129   gdk_draw_pixmap (sheet->sheet_window,
3130                    GTK_WIDGET (sheet)->style->fg_gc[GTK_STATE_NORMAL],
3131                    sheet->pixmap,
3132                    area.x,
3133                    area.y,
3134                    area.x,
3135                    area.y,
3136                    area.width,
3137                    area.height);
3138
3139 }
3140
3141 static void
3142 gtk_sheet_range_draw (GtkSheet *sheet, const GtkSheetRange *range)
3143 {
3144   gint i, j;
3145   GtkSheetRange drawing_range;
3146   GdkRectangle area;
3147
3148   g_return_if_fail (sheet != NULL);
3149   g_return_if_fail (GTK_SHEET (sheet));
3150
3151   if (!GTK_WIDGET_DRAWABLE (GTK_WIDGET (sheet))) return;
3152   if (!GTK_WIDGET_REALIZED (GTK_WIDGET (sheet))) return;
3153   if (!GTK_WIDGET_MAPPED (GTK_WIDGET (sheet))) return;
3154
3155   if (range == NULL)
3156     {
3157       drawing_range.row0 = MIN_VISIBLE_ROW (sheet);
3158       drawing_range.col0 = MIN_VISIBLE_COLUMN (sheet);
3159       drawing_range.rowi = MIN (MAX_VISIBLE_ROW (sheet),
3160                                 yyy_row_count (sheet) - 1);
3161       drawing_range.coli = MAX_VISIBLE_COLUMN (sheet);
3162
3163
3164       gdk_draw_rectangle (sheet->pixmap,
3165                           GTK_WIDGET (sheet)->style->white_gc,
3166                           TRUE,
3167                           0, 0,
3168                           sheet->sheet_window_width,
3169                           sheet->sheet_window_height);
3170     }
3171   else
3172     {
3173       drawing_range.row0 = MAX (range->row0, MIN_VISIBLE_ROW (sheet));
3174       drawing_range.col0 = MAX (range->col0, MIN_VISIBLE_COLUMN (sheet));
3175       drawing_range.rowi = MIN (range->rowi, MAX_VISIBLE_ROW (sheet));
3176       drawing_range.coli = MIN (range->coli, MAX_VISIBLE_COLUMN (sheet));
3177     }
3178
3179   if (drawing_range.coli == xxx_column_count (sheet) - 1)
3180     {
3181       area.x = COLUMN_LEFT_XPIXEL (sheet,
3182                                    xxx_column_count (sheet) - 1) +
3183         xxx_column_width (sheet, xxx_column_count (sheet) - 1) + 1;
3184
3185       area.y = 0;
3186
3187       gdk_gc_set_foreground (sheet->fg_gc, &sheet->bg_color);
3188
3189       gdk_draw_rectangle (sheet->pixmap,
3190                           sheet->fg_gc,
3191                           TRUE,
3192                           area.x, area.y,
3193                           sheet->sheet_window_width - area.x,
3194                           sheet->sheet_window_height);
3195
3196       gdk_draw_pixmap (sheet->sheet_window,
3197                        GTK_WIDGET (sheet)->style->fg_gc[GTK_STATE_NORMAL],
3198                        sheet->pixmap,
3199                        area.x,
3200                        area.y,
3201                        area.x,
3202                        area.y,
3203                        sheet->sheet_window_width - area.x,
3204                        sheet->sheet_window_height);
3205     }
3206
3207   if (drawing_range.rowi == yyy_row_count (sheet) - 1)
3208     {
3209       area.x = 0;
3210       area.y = ROW_TOP_YPIXEL (sheet,
3211                                yyy_row_count (sheet) - 1) +
3212         yyy_row_height (sheet, yyy_row_count (sheet) - 1) + 1;
3213
3214       gdk_gc_set_foreground (sheet->fg_gc, &sheet->bg_color);
3215
3216       gdk_draw_rectangle (sheet->pixmap,
3217                           sheet->fg_gc,
3218                           TRUE,
3219                           area.x, area.y,
3220                           sheet->sheet_window_width,
3221                           sheet->sheet_window_height - area.y);
3222
3223       gdk_draw_pixmap (sheet->sheet_window,
3224                        GTK_WIDGET (sheet)->style->fg_gc[GTK_STATE_NORMAL],
3225                        sheet->pixmap,
3226                        area.x,
3227                        area.y,
3228                        area.x,
3229                        area.y,
3230                        sheet->sheet_window_width,
3231                        sheet->sheet_window_height - area.y);
3232     }
3233
3234   for (i = drawing_range.row0; i <= drawing_range.rowi; i++)
3235     for (j = drawing_range.col0; j <= drawing_range.coli; j++)
3236       {
3237         gtk_sheet_cell_draw_default (sheet, i, j);
3238         gtk_sheet_cell_draw_label (sheet, i, j);
3239       }
3240
3241   gtk_sheet_draw_backing_pixmap (sheet, drawing_range);
3242
3243   if (sheet->state != GTK_SHEET_NORMAL &&
3244       gtk_sheet_range_isvisible (sheet, sheet->range))
3245     gtk_sheet_range_draw_selection (sheet, drawing_range);
3246
3247   if (sheet->state == GTK_STATE_NORMAL &&
3248       sheet->active_cell.row >= drawing_range.row0 &&
3249       sheet->active_cell.row <= drawing_range.rowi &&
3250       sheet->active_cell.col >= drawing_range.col0 &&
3251       sheet->active_cell.col <= drawing_range.coli)
3252     gtk_sheet_show_active_cell (sheet);
3253 }
3254
3255 static void
3256 gtk_sheet_range_draw_selection (GtkSheet *sheet, GtkSheetRange range)
3257 {
3258   GdkRectangle area;
3259   gint i, j;
3260   GtkSheetRange aux;
3261
3262   if (range.col0 > sheet->range.coli || range.coli < sheet->range.col0 ||
3263       range.row0 > sheet->range.rowi || range.rowi < sheet->range.row0)
3264     return;
3265
3266   if (!gtk_sheet_range_isvisible (sheet, range)) return;
3267   if (!GTK_WIDGET_REALIZED (GTK_WIDGET (sheet))) return;
3268
3269   aux = range;
3270
3271   range.col0 = MAX (sheet->range.col0, range.col0);
3272   range.coli = MIN (sheet->range.coli, range.coli);
3273   range.row0 = MAX (sheet->range.row0, range.row0);
3274   range.rowi = MIN (sheet->range.rowi, range.rowi);
3275
3276   range.col0 = MAX (range.col0, MIN_VISIBLE_COLUMN (sheet));
3277   range.coli = MIN (range.coli, MAX_VISIBLE_COLUMN (sheet));
3278   range.row0 = MAX (range.row0, MIN_VISIBLE_ROW (sheet));
3279   range.rowi = MIN (range.rowi, MAX_VISIBLE_ROW (sheet));
3280
3281   for (i = range.row0; i <= range.rowi; i++)
3282     {
3283       for (j = range.col0; j <= range.coli; j++)
3284         {
3285
3286           if (gtk_sheet_cell_get_state (sheet, i, j) == GTK_STATE_SELECTED &&
3287               xxx_column_is_visible (sheet, j) && yyy_row_is_visible (sheet, i))
3288             {
3289
3290               area.x = COLUMN_LEFT_XPIXEL (sheet, j);
3291               area.y = ROW_TOP_YPIXEL (sheet, i);
3292               area.width= xxx_column_width (sheet, j);
3293               area.height = yyy_row_height (sheet, i);
3294
3295               if (i == sheet->range.row0)
3296                 {
3297                   area.y = area.y + 2;
3298                   area.height = area.height - 2;
3299                 }
3300               if (i == sheet->range.rowi) area.height = area.height - 3;
3301               if (j == sheet->range.col0)
3302                 {
3303                   area.x = area.x + 2;
3304                   area.width = area.width - 2;
3305                 }
3306               if (j == sheet->range.coli) area.width = area.width - 3;
3307
3308               if (i != sheet->active_cell.row || j != sheet->active_cell.col)
3309                 {
3310                   gdk_draw_rectangle (sheet->sheet_window,
3311                                       sheet->xor_gc,
3312                                       TRUE,
3313                                       area.x + 1, area.y + 1,
3314                                       area.width, area.height);
3315                 }
3316             }
3317
3318         }
3319     }
3320
3321   gtk_sheet_draw_border (sheet, sheet->range);
3322 }
3323
3324 static void
3325 gtk_sheet_draw_backing_pixmap (GtkSheet *sheet, GtkSheetRange range)
3326 {
3327   gint x, y, width, height;
3328
3329   if (!GTK_WIDGET_REALIZED (GTK_WIDGET (sheet))) return;
3330
3331   x = COLUMN_LEFT_XPIXEL (sheet, range.col0);
3332   y = ROW_TOP_YPIXEL (sheet, range.row0);
3333   width = COLUMN_LEFT_XPIXEL (sheet, range.coli) - x +
3334     xxx_column_width (sheet, range.coli);
3335
3336   height = ROW_TOP_YPIXEL (sheet, range.rowi)- y + yyy_row_height (sheet, range.rowi);
3337
3338   if (range.row0 == sheet->range.row0)
3339     {
3340       y = y - 5;
3341       height = height + 5;
3342     }
3343   if (range.rowi == sheet->range.rowi) height = height + 5;
3344   if (range.col0 == sheet->range.col0)
3345     {
3346       x = x - 5;
3347       width = width + 5;
3348     }
3349   if (range.coli == sheet->range.coli) width = width + 5;
3350
3351   width = MIN (width, sheet->sheet_window_width - x);
3352   height = MIN (height, sheet->sheet_window_height - y);
3353
3354   x--;
3355   y--;
3356   width +=2;
3357   height +=2;
3358
3359   x = (sheet->row_titles_visible)
3360     ? MAX (x, sheet->row_title_area.width) : MAX (x, 0);
3361   y = (sheet->column_titles_visible)
3362     ? MAX (y, sheet->column_title_area.height) : MAX (y, 0);
3363
3364   if (range.coli == xxx_column_count (sheet) - 1)
3365     width = sheet->sheet_window_width - x;
3366   if (range.rowi == yyy_row_count (sheet) - 1)
3367     height = sheet->sheet_window_height - y;
3368
3369   gdk_draw_pixmap (sheet->sheet_window,
3370                    GTK_WIDGET (sheet)->style->fg_gc[GTK_STATE_NORMAL],
3371                    sheet->pixmap,
3372                    x,
3373                    y,
3374                    x,
3375                    y,
3376                    width + 1,
3377                    height + 1);
3378 }
3379
3380
3381 void
3382 gtk_sheet_set_cell_text (GtkSheet *sheet, gint row, gint col, const gchar *text)
3383 {
3384   GtkSheetCellAttr attributes;
3385
3386   g_return_if_fail (sheet != NULL);
3387   g_return_if_fail (GTK_IS_SHEET (sheet));
3388   if (col >= xxx_column_count (sheet) || row >= yyy_row_count (sheet)) return;
3389   if (col < 0 || row < 0) return;
3390
3391   gtk_sheet_get_attributes (sheet, row, col, &attributes);
3392   gtk_sheet_set_cell (sheet, row, col, attributes.justification, text);
3393 }
3394
3395 static inline gint
3396 safe_strcmp (const gchar *s1, const gchar *s2)
3397 {
3398   if ( !s1 && !s2) return 0;
3399   if ( !s1) return - 1;
3400   if ( !s2) return +1;
3401   return strcmp (s1, s2);
3402 }
3403
3404 void
3405 gtk_sheet_set_cell (GtkSheet *sheet, gint row, gint col,
3406                     GtkJustification justification,
3407                     const gchar *text)
3408 {
3409   GSheetModel *model ;
3410   gboolean changed ;
3411   gchar *old_text ;
3412
3413   GtkSheetRange range;
3414   gint text_width;
3415   GtkSheetCellAttr attributes;
3416
3417   g_return_if_fail (sheet != NULL);
3418   g_return_if_fail (GTK_IS_SHEET (sheet));
3419   if (col >= xxx_column_count (sheet) || row >= yyy_row_count (sheet)) return;
3420   if (col < 0 || row < 0) return;
3421
3422   gtk_sheet_get_attributes (sheet, row, col, &attributes);
3423
3424   attributes.justification = justification;
3425
3426   model = gtk_sheet_get_model (sheet);
3427
3428   old_text = g_sheet_model_get_string (model, row, col);
3429
3430   changed = FALSE;
3431
3432   if (0 != safe_strcmp (old_text, text))
3433     changed = g_sheet_model_set_string (model, text, row, col);
3434
3435   if ( g_sheet_model_free_strings (model))
3436     g_free (old_text);
3437
3438
3439   if (changed && attributes.is_visible)
3440     {
3441       gchar *s = gtk_sheet_cell_get_text (sheet, row, col);
3442       text_width = 0;
3443       if (s && strlen (s) > 0)
3444         {
3445           text_width = STRING_WIDTH (GTK_WIDGET (sheet),
3446                                      attributes.font_desc, text);
3447         }
3448       dispose_string (sheet, s);
3449
3450       range.row0 = row;
3451       range.rowi = row;
3452       range.col0 = MIN_VISIBLE_COLUMN (sheet);
3453       range.coli = MAX_VISIBLE_COLUMN (sheet);
3454
3455       if (gtk_sheet_autoresize (sheet) &&
3456           text_width > xxx_column_width (sheet, col) -
3457           2 * CELLOFFSET- attributes.border.width)
3458         {
3459           gtk_sheet_set_column_width (sheet, col, text_width + 2 * CELLOFFSET
3460                                       + attributes.border.width);
3461           GTK_SHEET_SET_FLAGS (sheet, GTK_SHEET_REDRAW_PENDING);
3462         }
3463       else
3464         if (!GTK_SHEET_IS_FROZEN (sheet))
3465           gtk_sheet_range_draw (sheet, &range);
3466     }
3467
3468   if ( changed )
3469     g_signal_emit (G_OBJECT (sheet), sheet_signals[CHANGED], 0, row, col);
3470
3471 }
3472
3473
3474 void
3475 gtk_sheet_cell_clear (GtkSheet *sheet, gint row, gint column)
3476 {
3477   GtkSheetRange range;
3478
3479   g_return_if_fail (sheet != NULL);
3480   g_return_if_fail (GTK_IS_SHEET (sheet));
3481   if (column >= xxx_column_count (sheet) ||
3482       row >= yyy_row_count (sheet)) return;
3483
3484   if (column < 0 || row < 0) return;
3485
3486   range.row0 = row;
3487   range.rowi = row;
3488   range.col0 = MIN_VISIBLE_COLUMN (sheet);
3489   range.coli = MAX_VISIBLE_COLUMN (sheet);
3490
3491   gtk_sheet_real_cell_clear (sheet, row, column);
3492
3493   if (!GTK_SHEET_IS_FROZEN (sheet))
3494     {
3495       gtk_sheet_range_draw (sheet, &range);
3496     }
3497 }
3498
3499 static void
3500 gtk_sheet_real_cell_clear (GtkSheet *sheet, gint row, gint column)
3501 {
3502   GSheetModel *model = gtk_sheet_get_model (sheet);
3503
3504   gchar *old_text = gtk_sheet_cell_get_text (sheet, row, column);
3505
3506   if (old_text && strlen (old_text) > 0 )
3507     {
3508       g_sheet_model_datum_clear (model, row, column);
3509
3510       if (GTK_IS_OBJECT (sheet) && G_OBJECT (sheet)->ref_count > 0)
3511         g_signal_emit (G_OBJECT (sheet), sheet_signals[CLEAR_CELL], 0,
3512                        row, column);
3513     }
3514
3515   dispose_string (sheet, old_text);
3516 }
3517
3518 void
3519 gtk_sheet_range_clear (GtkSheet *sheet, const GtkSheetRange *range)
3520 {
3521   g_return_if_fail (sheet != NULL);
3522   g_return_if_fail (GTK_IS_SHEET (sheet));
3523
3524   gtk_sheet_real_range_clear (sheet, range);
3525 }
3526
3527 static void
3528 gtk_sheet_real_range_clear (GtkSheet *sheet, const GtkSheetRange *range)
3529 {
3530   gint i, j;
3531   GtkSheetRange clear;
3532
3533   if (!range)
3534     {
3535       clear.row0 = 0;
3536       clear.rowi = yyy_row_count (sheet) - 1;
3537       clear.col0 = 0;
3538       clear.coli = xxx_column_count (sheet) - 1;
3539     }
3540   else
3541     clear=*range;
3542
3543   clear.row0 = MAX (clear.row0, 0);
3544   clear.col0 = MAX (clear.col0, 0);
3545   clear.rowi = MIN (clear.rowi, yyy_row_count (sheet) - 1 );
3546   clear.coli = MIN (clear.coli, xxx_column_count (sheet) - 1 );
3547
3548   for (i = clear.row0; i <= clear.rowi; i++)
3549     for (j = clear.col0; j <= clear.coli; j++)
3550       {
3551         gtk_sheet_real_cell_clear (sheet, i, j);
3552       }
3553
3554   gtk_sheet_range_draw (sheet, NULL);
3555 }
3556
3557
3558 static gboolean
3559 gtk_sheet_cell_empty (const GtkSheet *sheet, gint row, gint col)
3560 {
3561   gboolean empty;
3562   char *text = gtk_sheet_cell_get_text (sheet, row, col);
3563   empty = (text == NULL );
3564
3565   dispose_string (sheet, text);
3566
3567   return empty;
3568 }
3569
3570
3571 gchar *
3572 gtk_sheet_cell_get_text (const GtkSheet *sheet, gint row, gint col)
3573 {
3574   GSheetModel *model;
3575   g_return_val_if_fail (sheet != NULL, NULL);
3576   g_return_val_if_fail (GTK_IS_SHEET (sheet), NULL);
3577
3578   if (col >= xxx_column_count (sheet) || row >= yyy_row_count (sheet))
3579     return NULL;
3580   if (col < 0 || row < 0) return NULL;
3581
3582   model = gtk_sheet_get_model (sheet);
3583
3584   if ( !model )
3585     return NULL;
3586
3587   return g_sheet_model_get_string (model, row, col);
3588 }
3589
3590
3591 GtkStateType
3592 gtk_sheet_cell_get_state (GtkSheet *sheet, gint row, gint col)
3593 {
3594   gint state;
3595   GtkSheetRange *range;
3596
3597   g_return_val_if_fail (sheet != NULL, 0);
3598   g_return_val_if_fail (GTK_IS_SHEET (sheet), 0);
3599   if (col >= xxx_column_count (sheet) || row >= yyy_row_count (sheet)) return 0;
3600   if (col < 0 || row < 0) return 0;
3601
3602   state = sheet->state;
3603   range = &sheet->range;
3604
3605   switch (state)
3606     {
3607     case GTK_SHEET_NORMAL:
3608       return GTK_STATE_NORMAL;
3609       break;
3610     case GTK_SHEET_ROW_SELECTED:
3611       if (row >= range->row0 && row <= range->rowi)
3612         return GTK_STATE_SELECTED;
3613       break;
3614     case GTK_SHEET_COLUMN_SELECTED:
3615       if (col >= range->col0 && col <= range->coli)
3616         return GTK_STATE_SELECTED;
3617       break;
3618     case GTK_SHEET_RANGE_SELECTED:
3619       if (row >= range->row0 && row <= range->rowi && \
3620           col >= range->col0 && col <= range->coli)
3621         return GTK_STATE_SELECTED;
3622       break;
3623     }
3624   return GTK_STATE_NORMAL;
3625 }
3626
3627 /* Convert X, Y (in pixels) to *ROW, *COLUMN (in cell coords)
3628    -1 indicates the title buttons.
3629    If the function returns FALSE, then the results will be unreliable.
3630 */
3631 gboolean
3632 gtk_sheet_get_pixel_info (GtkSheet *sheet,
3633                           gint x,
3634                           gint y,
3635                           gint *row,
3636                           gint *column)
3637 {
3638   gint trow, tcol;
3639   *row = -G_MAXINT;
3640   *column = -G_MAXINT;
3641
3642   g_return_val_if_fail (sheet != NULL, 0);
3643   g_return_val_if_fail (GTK_IS_SHEET (sheet), 0);
3644
3645   /* bounds checking, return false if the user clicked
3646      on a blank area */
3647   if (y < 0)
3648     return FALSE;
3649
3650   if (x < 0)
3651     return FALSE;
3652
3653   if ( y < sheet->column_title_area.height + sheet->column_title_area.y)
3654     *row = -1;
3655
3656   else
3657     {
3658       trow = ROW_FROM_YPIXEL (sheet, y);
3659       if (trow > yyy_row_count (sheet))
3660         return FALSE;
3661
3662       *row = trow;
3663     }
3664
3665   if ( x < sheet->row_title_area.width + sheet->row_title_area.x)
3666     *column = -1;
3667   else
3668     {
3669       tcol = COLUMN_FROM_XPIXEL (sheet, x);
3670       if (tcol > xxx_column_count (sheet))
3671         return FALSE;
3672
3673       *column = tcol;
3674     }
3675
3676   return TRUE;
3677 }
3678
3679 gboolean
3680 gtk_sheet_get_cell_area (GtkSheet * sheet,
3681                          gint row,
3682                          gint column,
3683                          GdkRectangle *area)
3684 {
3685   g_return_val_if_fail (sheet != NULL, 0);
3686   g_return_val_if_fail (GTK_IS_SHEET (sheet), 0);
3687
3688   if (row >= yyy_row_count (sheet) || column >= xxx_column_count (sheet))
3689     return FALSE;
3690
3691   area->x = (column == -1) ? 0 : (COLUMN_LEFT_XPIXEL (sheet, column) -
3692                                   (sheet->row_titles_visible
3693                                    ? sheet->row_title_area.width
3694                                    : 0));
3695   area->y = (row == -1) ? 0 : (ROW_TOP_YPIXEL (sheet, row) -
3696                                (sheet->column_titles_visible
3697                                 ? sheet->column_title_area.height
3698                                 : 0));
3699   area->width= (column == -1) ? sheet->row_title_area.width
3700     : xxx_column_width (sheet, column);
3701
3702   area->height= (row == -1) ? sheet->column_title_area.height
3703     : yyy_row_height (sheet, row);
3704
3705   return TRUE;
3706 }
3707
3708 gboolean
3709 gtk_sheet_set_active_cell (GtkSheet *sheet, gint row, gint column)
3710 {
3711   g_return_val_if_fail (sheet != NULL, 0);
3712   g_return_val_if_fail (GTK_IS_SHEET (sheet), 0);
3713
3714   if (row < - 1 || column < - 1) return FALSE;
3715   if (row >= yyy_row_count (sheet) || column >= xxx_column_count (sheet))
3716     return FALSE;
3717
3718   if (GTK_WIDGET_REALIZED (GTK_WIDGET (sheet)))
3719     {
3720       if (!gtk_sheet_deactivate_cell (sheet)) return FALSE;
3721     }
3722
3723   sheet->active_cell.row = row;
3724   sheet->active_cell.col = column;
3725
3726   if ( row == -1 || column == -1)
3727     {
3728       gtk_sheet_hide_active_cell (sheet);
3729       return TRUE;
3730     }
3731
3732   if (!gtk_sheet_activate_cell (sheet, row, column)) return FALSE;
3733
3734   if (gtk_sheet_autoscroll (sheet))
3735     gtk_sheet_move_query (sheet, row, column);
3736
3737   return TRUE;
3738 }
3739
3740 void
3741 gtk_sheet_get_active_cell (GtkSheet *sheet, gint *row, gint *column)
3742 {
3743   g_return_if_fail (sheet != NULL);
3744   g_return_if_fail (GTK_IS_SHEET (sheet));
3745
3746   if ( row ) *row = sheet->active_cell.row;
3747   if (column) *column = sheet->active_cell.col;
3748 }
3749
3750 static void
3751 gtk_sheet_entry_changed (GtkWidget *widget, gpointer data)
3752 {
3753   GtkSheet *sheet;
3754   gint row, col;
3755   const char *text;
3756   GtkJustification justification;
3757   GtkSheetCellAttr attributes;
3758
3759   g_return_if_fail (data != NULL);
3760   g_return_if_fail (GTK_IS_SHEET (data));
3761
3762   sheet = GTK_SHEET (data);
3763
3764   if (!GTK_WIDGET_VISIBLE (widget)) return;
3765   if (sheet->state != GTK_STATE_NORMAL) return;
3766
3767   row = sheet->active_cell.row;
3768   col = sheet->active_cell.col;
3769
3770   if (row < 0 || col < 0) return;
3771
3772   sheet->active_cell.row =- 1;
3773   sheet->active_cell.col =- 1;
3774
3775   text = gtk_entry_get_text (GTK_ENTRY (gtk_sheet_get_entry (sheet)));
3776
3777   GTK_SHEET_SET_FLAGS (sheet, GTK_SHEET_IS_FROZEN);
3778
3779   if (text && strlen (text) > 0)
3780     {
3781       gtk_sheet_get_attributes (sheet, row, col, &attributes);
3782       justification = attributes.justification;
3783       gtk_sheet_set_cell (sheet, row, col, justification, text);
3784     }
3785
3786   if (sheet->freeze_count == 0)
3787     GTK_SHEET_UNSET_FLAGS (sheet, GTK_SHEET_IS_FROZEN);
3788
3789   sheet->active_cell.row = row;;
3790   sheet->active_cell.col = col;
3791 }
3792
3793
3794 static gboolean
3795 gtk_sheet_deactivate_cell (GtkSheet *sheet)
3796 {
3797   gboolean veto = TRUE;
3798
3799   g_return_val_if_fail (sheet != NULL, FALSE);
3800   g_return_val_if_fail (GTK_IS_SHEET (sheet), FALSE);
3801
3802   if (!GTK_WIDGET_REALIZED (GTK_WIDGET (sheet))) return FALSE;
3803   if (sheet->state != GTK_SHEET_NORMAL) return FALSE;
3804
3805   _gtkextra_signal_emit (GTK_OBJECT (sheet), sheet_signals[DEACTIVATE],
3806                          sheet->active_cell.row,
3807                          sheet->active_cell.col, &veto);
3808
3809   if (!veto) return FALSE;
3810
3811   if ( sheet->active_cell.row == -1 || sheet->active_cell.col == -1 )
3812     return TRUE;
3813
3814   g_signal_handlers_disconnect_by_func (G_OBJECT (gtk_sheet_get_entry (sheet)),
3815                                         G_CALLBACK (gtk_sheet_entry_changed),
3816                                         sheet);
3817
3818   gtk_sheet_hide_active_cell (sheet);
3819   sheet->active_cell.row = -1;
3820   sheet->active_cell.col = -1;
3821
3822   if (GTK_SHEET_REDRAW_PENDING (sheet))
3823     {
3824       GTK_SHEET_UNSET_FLAGS (sheet, GTK_SHEET_REDRAW_PENDING);
3825       gtk_sheet_range_draw (sheet, NULL);
3826     }
3827
3828   return TRUE;
3829 }
3830
3831 static void
3832 gtk_sheet_hide_active_cell (GtkSheet *sheet)
3833 {
3834   const char *text;
3835   gint row, col;
3836   GtkJustification justification;
3837   GtkSheetCellAttr attributes;
3838
3839   if (!GTK_WIDGET_REALIZED (GTK_WIDGET (sheet))) return;
3840
3841   row = sheet->active_cell.row;
3842   col = sheet->active_cell.col;
3843
3844   if (row < 0 || col < 0) return;
3845
3846   if (sheet->freeze_count == 0)
3847     GTK_SHEET_UNSET_FLAGS (sheet, GTK_SHEET_IS_FROZEN);
3848
3849   text = gtk_entry_get_text (GTK_ENTRY (gtk_sheet_get_entry (sheet)));
3850
3851   gtk_sheet_get_attributes (sheet, row, col, &attributes);
3852   justification = attributes.justification;
3853
3854   if (text && strlen (text) != 0)
3855     {
3856       gtk_sheet_set_cell (sheet, row, col, justification, text);
3857       g_signal_emit (G_OBJECT (sheet), sheet_signals[SET_CELL], 0, row, col);
3858     }
3859   else
3860     {
3861       gtk_sheet_cell_clear (sheet, row, col);
3862     }
3863
3864   row = sheet->active_cell.row;
3865   col = sheet->active_cell.col;
3866
3867   gtk_widget_hide (sheet->sheet_entry);
3868   gtk_widget_unmap (sheet->sheet_entry);
3869
3870   if (row != -1 && col != -1)
3871     gdk_draw_pixmap (sheet->sheet_window,
3872                      GTK_WIDGET (sheet)->style->fg_gc[GTK_STATE_NORMAL],
3873                      sheet->pixmap,
3874                      COLUMN_LEFT_XPIXEL (sheet, col)- 1,
3875                      ROW_TOP_YPIXEL (sheet, row)- 1,
3876                      COLUMN_LEFT_XPIXEL (sheet, col)- 1,
3877                      ROW_TOP_YPIXEL (sheet, row)- 1,
3878                      xxx_column_width (sheet, col) + 4,
3879                      yyy_row_height (sheet, row)+4);
3880
3881   gtk_widget_grab_focus (GTK_WIDGET (sheet));
3882
3883   GTK_WIDGET_UNSET_FLAGS (GTK_WIDGET (sheet->sheet_entry), GTK_VISIBLE);
3884
3885 }
3886
3887 static gboolean
3888 gtk_sheet_activate_cell (GtkSheet *sheet, gint row, gint col)
3889 {
3890   gboolean veto = TRUE;
3891
3892   g_return_val_if_fail (sheet != NULL, FALSE);
3893   g_return_val_if_fail (GTK_IS_SHEET (sheet), FALSE);
3894
3895   if (row < 0 || col < 0) return FALSE;
3896   if (row >= yyy_row_count (sheet) || col >= xxx_column_count (sheet))
3897     return FALSE;
3898
3899   if (!veto) return FALSE;
3900   if (sheet->state != GTK_SHEET_NORMAL)
3901     {
3902       sheet->state = GTK_SHEET_NORMAL;
3903       gtk_sheet_real_unselect_range (sheet, NULL);
3904     }
3905
3906   sheet->range.row0 = row;
3907   sheet->range.col0 = col;
3908   sheet->range.rowi = row;
3909   sheet->range.coli = col;
3910   sheet->active_cell.row = row;
3911   sheet->active_cell.col = col;
3912   sheet->selection_cell.row = row;
3913   sheet->selection_cell.col = col;
3914
3915   GTK_SHEET_UNSET_FLAGS (sheet, GTK_SHEET_IN_SELECTION);
3916
3917   gtk_sheet_show_active_cell (sheet);
3918
3919
3920   g_signal_connect (G_OBJECT (gtk_sheet_get_entry (sheet)),
3921                     "changed",
3922                     G_CALLBACK (gtk_sheet_entry_changed),
3923                     sheet);
3924
3925   _gtkextra_signal_emit (GTK_OBJECT (sheet), sheet_signals [ACTIVATE], row, col, &veto);
3926
3927   return TRUE;
3928 }
3929
3930 static void
3931 gtk_sheet_show_active_cell (GtkSheet *sheet)
3932 {
3933   GtkEntry *sheet_entry;
3934   GtkSheetCellAttr attributes;
3935   gchar *text = NULL;
3936   const gchar *old_text;
3937   GtkJustification justification;
3938   gint row, col;
3939
3940   g_return_if_fail (sheet != NULL);
3941   g_return_if_fail (GTK_IS_SHEET (sheet));
3942
3943   row = sheet->active_cell.row;
3944   col = sheet->active_cell.col;
3945
3946   /* Don't show the active cell, if there is no active cell: */
3947   if (! (row >= 0 && col >= 0)) /* e.g row or coll == -1. */
3948     return;
3949
3950   if (!GTK_WIDGET_REALIZED (GTK_WIDGET (sheet))) return;
3951   if (sheet->state != GTK_SHEET_NORMAL) return;
3952   if (GTK_SHEET_IN_SELECTION (sheet)) return;
3953
3954   GTK_WIDGET_SET_FLAGS (GTK_WIDGET (sheet->sheet_entry), GTK_VISIBLE);
3955
3956   sheet_entry = GTK_ENTRY (gtk_sheet_get_entry (sheet));
3957
3958   gtk_sheet_get_attributes (sheet, row, col, &attributes);
3959
3960   justification = GTK_JUSTIFY_LEFT;
3961
3962   if (gtk_sheet_justify_entry (sheet))
3963     justification = attributes.justification;
3964
3965   text = gtk_sheet_cell_get_text (sheet, row, col);
3966   if ( ! text )
3967     text = g_strdup ("");
3968
3969   gtk_entry_set_visibility (GTK_ENTRY (sheet_entry), attributes.is_visible);
3970
3971   if (gtk_sheet_locked (sheet) || !attributes.is_editable)
3972     gtk_editable_set_editable (GTK_EDITABLE (sheet_entry), FALSE);
3973   else
3974     gtk_editable_set_editable (GTK_EDITABLE (sheet_entry), TRUE);
3975
3976   /*** Added by John Gotts. Mar 25, 2005 *********/
3977   old_text = gtk_entry_get_text (GTK_ENTRY (sheet_entry));
3978   if (strcmp (old_text, text) != 0)
3979     {
3980       if (!GTK_IS_ITEM_ENTRY (sheet_entry))
3981         gtk_entry_set_text (GTK_ENTRY (sheet_entry), text);
3982       else
3983         gtk_item_entry_set_text (GTK_ITEM_ENTRY (sheet_entry), text, justification);
3984     }
3985
3986   gtk_sheet_entry_set_max_size (sheet);
3987   gtk_sheet_size_allocate_entry (sheet);
3988
3989   gtk_widget_map (sheet->sheet_entry);
3990
3991   gtk_widget_grab_focus (GTK_WIDGET (sheet_entry));
3992
3993   dispose_string (sheet, text);
3994 }
3995
3996 static void
3997 gtk_sheet_draw_active_cell (GtkSheet *sheet)
3998 {
3999   gint row, col;
4000   GtkSheetRange range;
4001
4002   if (!GTK_WIDGET_DRAWABLE (GTK_WIDGET (sheet))) return;
4003   if (!GTK_WIDGET_REALIZED (GTK_WIDGET (sheet))) return;
4004
4005   row = sheet->active_cell.row;
4006   col = sheet->active_cell.col;
4007
4008   if (row < 0 || col < 0) return;
4009
4010   if (!gtk_sheet_cell_isvisible (sheet, row, col)) return;
4011
4012   range.col0 = range.coli = col;
4013   range.row0 = range.rowi = row;
4014
4015   gtk_sheet_draw_border (sheet, range);
4016 }
4017
4018
4019 static void
4020 gtk_sheet_make_backing_pixmap (GtkSheet *sheet, guint width, guint height)
4021 {
4022   gint pixmap_width, pixmap_height;
4023
4024   if (!GTK_WIDGET_REALIZED (GTK_WIDGET (sheet))) return;
4025
4026   if (width == 0 && height == 0)
4027     {
4028       width = sheet->sheet_window_width + 80;
4029       height = sheet->sheet_window_height + 80;
4030     }
4031
4032   if (!sheet->pixmap)
4033     {
4034       /* allocate */
4035       sheet->pixmap = gdk_pixmap_new (sheet->sheet_window,
4036                                       width, height,
4037                                       - 1);
4038       if (!GTK_SHEET_IS_FROZEN (sheet)) gtk_sheet_range_draw (sheet, NULL);
4039     }
4040   else
4041     {
4042       /* reallocate if sizes don't match */
4043       gdk_window_get_size (sheet->pixmap,
4044                            &pixmap_width, &pixmap_height);
4045       if ( (pixmap_width != width) || (pixmap_height != height))
4046         {
4047           g_object_unref (sheet->pixmap);
4048           sheet->pixmap = gdk_pixmap_new (sheet->sheet_window,
4049                                           width, height,
4050                                           - 1);
4051           if (!GTK_SHEET_IS_FROZEN (sheet)) gtk_sheet_range_draw (sheet, NULL);
4052         }
4053     }
4054 }
4055
4056 static void
4057 gtk_sheet_new_selection (GtkSheet *sheet, GtkSheetRange *range)
4058 {
4059   gint i, j, mask1, mask2;
4060   gint state, selected;
4061   gint x, y, width, height;
4062   GtkSheetRange new_range, aux_range;
4063
4064   g_return_if_fail (sheet != NULL);
4065
4066   if (range == NULL) range=&sheet->range;
4067
4068   new_range=*range;
4069
4070   range->row0 = MIN (range->row0, sheet->range.row0);
4071   range->rowi = MAX (range->rowi, sheet->range.rowi);
4072   range->col0 = MIN (range->col0, sheet->range.col0);
4073   range->coli = MAX (range->coli, sheet->range.coli);
4074
4075   range->row0 = MAX (range->row0, MIN_VISIBLE_ROW (sheet));
4076   range->rowi = MIN (range->rowi, MAX_VISIBLE_ROW (sheet));
4077   range->col0 = MAX (range->col0, MIN_VISIBLE_COLUMN (sheet));
4078   range->coli = MIN (range->coli, MAX_VISIBLE_COLUMN (sheet));
4079
4080   aux_range.row0 = MAX (new_range.row0, MIN_VISIBLE_ROW (sheet));
4081   aux_range.rowi = MIN (new_range.rowi, MAX_VISIBLE_ROW (sheet));
4082   aux_range.col0 = MAX (new_range.col0, MIN_VISIBLE_COLUMN (sheet));
4083   aux_range.coli = MIN (new_range.coli, MAX_VISIBLE_COLUMN (sheet));
4084
4085   for (i = range->row0; i <= range->rowi; i++)
4086     {
4087       for (j = range->col0; j <= range->coli; j++)
4088         {
4089
4090           state = gtk_sheet_cell_get_state (sheet, i, j);
4091           selected= (i <= new_range.rowi && i >= new_range.row0 &&
4092                      j <= new_range.coli && j >= new_range.col0) ? TRUE : FALSE;
4093
4094           if (state == GTK_STATE_SELECTED && selected &&
4095               xxx_column_is_visible (sheet, j) && yyy_row_is_visible (sheet, i) &&
4096               (i == sheet->range.row0 || i == sheet->range.rowi ||
4097                j == sheet->range.col0 || j == sheet->range.coli ||
4098                i == new_range.row0 || i == new_range.rowi ||
4099                j == new_range.col0 || j == new_range.coli))
4100             {
4101
4102               mask1 = i == sheet->range.row0 ? 1 : 0;
4103               mask1 = i == sheet->range.rowi ? mask1 + 2 : mask1;
4104               mask1 = j == sheet->range.col0 ? mask1 + 4 : mask1;
4105               mask1 = j == sheet->range.coli ? mask1 + 8 : mask1;
4106
4107               mask2 = i == new_range.row0 ? 1 : 0;
4108               mask2 = i == new_range.rowi ? mask2 + 2 : mask2;
4109               mask2 = j == new_range.col0 ? mask2 + 4 : mask2;
4110               mask2 = j == new_range.coli ? mask2 + 8 : mask2;
4111
4112               if (mask1 != mask2)
4113                 {
4114                   x = COLUMN_LEFT_XPIXEL (sheet, j);
4115                   y = ROW_TOP_YPIXEL (sheet, i);
4116                   width = COLUMN_LEFT_XPIXEL (sheet, j)- x+
4117                     xxx_column_width (sheet, j);
4118                   height = ROW_TOP_YPIXEL (sheet, i)- y + yyy_row_height (sheet, i);
4119
4120                   if (i == sheet->range.row0)
4121                     {
4122                       y = y - 3;
4123                       height = height + 3;
4124                     }
4125                   if (i == sheet->range.rowi) height = height + 3;
4126                   if (j == sheet->range.col0)
4127                     {
4128                       x = x - 3;
4129                       width = width + 3;
4130                     }
4131                   if (j == sheet->range.coli) width = width + 3;
4132
4133                   gdk_draw_pixmap (sheet->sheet_window,
4134                                    GTK_WIDGET (sheet)->style->fg_gc[GTK_STATE_NORMAL],
4135                                    sheet->pixmap,
4136                                    x + 1,
4137                                    y + 1,
4138                                    x + 1,
4139                                    y + 1,
4140                                    width,
4141                                    height);
4142
4143                   if (i != sheet->active_cell.row || j != sheet->active_cell.col)
4144                     {
4145                       x = COLUMN_LEFT_XPIXEL (sheet, j);
4146                       y = ROW_TOP_YPIXEL (sheet, i);
4147                       width = COLUMN_LEFT_XPIXEL (sheet, j)- x+
4148                         xxx_column_width (sheet, j);
4149
4150                       height = ROW_TOP_YPIXEL (sheet, i)- y + yyy_row_height (sheet, i);
4151
4152                       if (i == new_range.row0)
4153                         {
4154                           y = y+2;
4155                           height = height - 2;
4156                         }
4157                       if (i == new_range.rowi) height = height - 3;
4158                       if (j == new_range.col0)
4159                         {
4160                           x = x+2;
4161                           width = width - 2;
4162                         }
4163                       if (j == new_range.coli) width = width - 3;
4164
4165                       gdk_draw_rectangle (sheet->sheet_window,
4166                                           sheet->xor_gc,
4167                                           TRUE,
4168                                           x + 1, y + 1,
4169                                           width, height);
4170                     }
4171                 }
4172             }
4173         }
4174     }
4175
4176   for (i = range->row0; i <= range->rowi; i++)
4177     {
4178       for (j = range->col0; j <= range->coli; j++)
4179         {
4180
4181           state = gtk_sheet_cell_get_state (sheet, i, j);
4182           selected= (i <= new_range.rowi && i >= new_range.row0 &&
4183                      j <= new_range.coli && j >= new_range.col0) ? TRUE : FALSE;
4184
4185           if (state == GTK_STATE_SELECTED && !selected &&
4186               xxx_column_is_visible (sheet, j) && yyy_row_is_visible (sheet, i))
4187             {
4188
4189               x = COLUMN_LEFT_XPIXEL (sheet, j);
4190               y = ROW_TOP_YPIXEL (sheet, i);
4191               width = COLUMN_LEFT_XPIXEL (sheet, j)- x+ xxx_column_width (sheet, j);
4192               height = ROW_TOP_YPIXEL (sheet, i)- y + yyy_row_height (sheet, i);
4193
4194               if (i == sheet->range.row0)
4195                 {
4196                   y = y - 3;
4197                   height = height + 3;
4198                 }
4199               if (i == sheet->range.rowi) height = height + 3;
4200               if (j == sheet->range.col0)
4201                 {
4202                   x = x - 3;
4203                   width = width + 3;
4204                 }
4205               if (j == sheet->range.coli) width = width + 3;
4206
4207               gdk_draw_pixmap (sheet->sheet_window,
4208                                GTK_WIDGET (sheet)->style->fg_gc[GTK_STATE_NORMAL],
4209                                sheet->pixmap,
4210                                x + 1,
4211                                y + 1,
4212                                x + 1,
4213                                y + 1,
4214                                width,
4215                                height);
4216             }
4217         }
4218     }
4219
4220   for (i = range->row0; i <= range->rowi; i++)
4221     {
4222       for (j = range->col0; j <= range->coli; j++)
4223         {
4224
4225           state = gtk_sheet_cell_get_state (sheet, i, j);
4226           selected= (i <= new_range.rowi && i >= new_range.row0 &&
4227                      j <= new_range.coli && j >= new_range.col0) ? TRUE : FALSE;
4228
4229           if (state != GTK_STATE_SELECTED && selected &&
4230               xxx_column_is_visible (sheet, j) && yyy_row_is_visible (sheet, i) &&
4231               (i != sheet->active_cell.row || j != sheet->active_cell.col))
4232             {
4233
4234               x = COLUMN_LEFT_XPIXEL (sheet, j);
4235               y = ROW_TOP_YPIXEL (sheet, i);
4236               width = COLUMN_LEFT_XPIXEL (sheet, j)- x+ xxx_column_width (sheet, j);
4237               height = ROW_TOP_YPIXEL (sheet, i)- y + yyy_row_height (sheet, i);
4238
4239               if (i == new_range.row0)
4240                 {
4241                   y = y+2;
4242                   height = height - 2;
4243                 }
4244               if (i == new_range.rowi) height = height - 3;
4245               if (j == new_range.col0)
4246                 {
4247                   x = x+2;
4248                   width = width - 2;
4249                 }
4250               if (j == new_range.coli) width = width - 3;
4251
4252               gdk_draw_rectangle (sheet->sheet_window,
4253                                   sheet->xor_gc,
4254                                   TRUE,
4255                                   x + 1, y + 1,
4256                                   width, height);
4257
4258             }
4259
4260         }
4261     }
4262
4263   for (i = aux_range.row0; i <= aux_range.rowi; i++)
4264     {
4265       for (j = aux_range.col0; j <= aux_range.coli; j++)
4266         {
4267
4268           if (xxx_column_is_visible (sheet, j) && yyy_row_is_visible (sheet, i))
4269             {
4270
4271               state = gtk_sheet_cell_get_state (sheet, i, j);
4272
4273               mask1 = i == sheet->range.row0 ? 1 : 0;
4274               mask1 = i == sheet->range.rowi ? mask1 + 2 : mask1;
4275               mask1 = j == sheet->range.col0 ? mask1 + 4 : mask1;
4276               mask1 = j == sheet->range.coli ? mask1 + 8 : mask1;
4277
4278               mask2 = i == new_range.row0 ? 1 : 0;
4279               mask2 = i == new_range.rowi ? mask2 + 2 : mask2;
4280               mask2 = j == new_range.col0 ? mask2 + 4 : mask2;
4281               mask2 = j == new_range.coli ? mask2 + 8 : mask2;
4282               if (mask2 != mask1 || (mask2 == mask1 && state != GTK_STATE_SELECTED))
4283                 {
4284                   x = COLUMN_LEFT_XPIXEL (sheet, j);
4285                   y = ROW_TOP_YPIXEL (sheet, i);
4286                   width = xxx_column_width (sheet, j);
4287                   height = yyy_row_height (sheet, i);
4288                   if (mask2 & 1)
4289                     gdk_draw_rectangle (sheet->sheet_window,
4290                                         sheet->xor_gc,
4291                                         TRUE,
4292                                         x + 1, y - 1,
4293                                         width, 3);
4294
4295
4296                   if (mask2 & 2)
4297                     gdk_draw_rectangle (sheet->sheet_window,
4298                                         sheet->xor_gc,
4299                                         TRUE,
4300                                         x + 1, y + height - 1,
4301                                         width, 3);
4302
4303                   if (mask2 & 4)
4304                     gdk_draw_rectangle (sheet->sheet_window,
4305                                         sheet->xor_gc,
4306                                         TRUE,
4307                                         x - 1, y + 1,
4308                                         3, height);
4309
4310
4311                   if (mask2 & 8)
4312                     gdk_draw_rectangle (sheet->sheet_window,
4313                                         sheet->xor_gc,
4314                                         TRUE,
4315                                         x + width - 1, y + 1,
4316                                         3, height);
4317
4318
4319
4320                 }
4321
4322             }
4323
4324         }
4325     }
4326
4327
4328   *range = new_range;
4329   gtk_sheet_draw_corners (sheet, new_range);
4330
4331 }
4332
4333 static void
4334 gtk_sheet_draw_border (GtkSheet *sheet, GtkSheetRange new_range)
4335 {
4336   GtkWidget *widget;
4337   GdkRectangle area;
4338   gint i;
4339   gint x, y, width, height;
4340
4341   widget = GTK_WIDGET (sheet);
4342
4343   x = COLUMN_LEFT_XPIXEL (sheet, new_range.col0);
4344   y = ROW_TOP_YPIXEL (sheet, new_range.row0);
4345   width = COLUMN_LEFT_XPIXEL (sheet, new_range.coli) - x +
4346     xxx_column_width (sheet, new_range.coli);
4347
4348   height = ROW_TOP_YPIXEL (sheet, new_range.rowi) - y +
4349     yyy_row_height (sheet, new_range.rowi);
4350
4351   area.x = COLUMN_LEFT_XPIXEL (sheet, MIN_VISIBLE_COLUMN (sheet));
4352   area.y = ROW_TOP_YPIXEL (sheet, MIN_VISIBLE_ROW (sheet));
4353   area.width = sheet->sheet_window_width;
4354   area.height = sheet->sheet_window_height;
4355
4356   if (x < 0)
4357     {
4358       width = width + x;
4359       x = 0;
4360     }
4361   if (width > area.width) width = area.width + 10;
4362   if (y < 0)
4363     {
4364       height = height + y;
4365       y = 0;
4366     }
4367   if (height > area.height) height = area.height + 10;
4368
4369   gdk_gc_set_clip_rectangle (sheet->xor_gc, &area);
4370
4371   for (i =- 1; i <= 1; ++i)
4372     gdk_draw_rectangle (sheet->sheet_window,
4373                         sheet->xor_gc,
4374                         FALSE,
4375                         x + i,
4376                         y + i,
4377                         width - 2 * i,
4378                         height - 2 * i);
4379
4380   gdk_gc_set_clip_rectangle (sheet->xor_gc, NULL);
4381
4382
4383   gtk_sheet_draw_corners (sheet, new_range);
4384 }
4385
4386 static void
4387 gtk_sheet_draw_corners (GtkSheet *sheet, GtkSheetRange range)
4388 {
4389   gint x, y;
4390   guint width = 1;
4391
4392   if (gtk_sheet_cell_isvisible (sheet, range.row0, range.col0))
4393     {
4394       x = COLUMN_LEFT_XPIXEL (sheet, range.col0);
4395       y = ROW_TOP_YPIXEL (sheet, range.row0);
4396       gdk_draw_pixmap (sheet->sheet_window,
4397                        GTK_WIDGET (sheet)->style->fg_gc[GTK_STATE_NORMAL],
4398                        sheet->pixmap,
4399                        x - 1,
4400                        y - 1,
4401                        x - 1,
4402                        y - 1,
4403                        3,
4404                        3);
4405       gdk_draw_rectangle (sheet->sheet_window,
4406                           sheet->xor_gc,
4407                           TRUE,
4408                           x - 1, y - 1,
4409                           3, 3);
4410     }
4411
4412   if (gtk_sheet_cell_isvisible (sheet, range.row0, range.coli) ||
4413       sheet->state == GTK_SHEET_COLUMN_SELECTED)
4414     {
4415       x = COLUMN_LEFT_XPIXEL (sheet, range.coli)+
4416         xxx_column_width (sheet, range.coli);
4417       y = ROW_TOP_YPIXEL (sheet, range.row0);
4418       width = 1;
4419       if (sheet->state == GTK_SHEET_COLUMN_SELECTED)
4420         {
4421           y = ROW_TOP_YPIXEL (sheet, MIN_VISIBLE_ROW (sheet))+3;
4422           width = 3;
4423         }
4424       gdk_draw_pixmap (sheet->sheet_window,
4425                        GTK_WIDGET (sheet)->style->fg_gc[GTK_STATE_NORMAL],
4426                        sheet->pixmap,
4427                        x - width,
4428                        y - width,
4429                        x - width,
4430                        y - width,
4431                        2 * width + 1,
4432                        2 * width + 1);
4433       gdk_draw_rectangle (sheet->sheet_window,
4434                           sheet->xor_gc,
4435                           TRUE,
4436                           x - width + width / 2, y - width + width / 2,
4437                           2 + width, 2 + width);
4438     }
4439
4440   if (gtk_sheet_cell_isvisible (sheet, range.rowi, range.col0) ||
4441       sheet->state == GTK_SHEET_ROW_SELECTED)
4442     {
4443       x = COLUMN_LEFT_XPIXEL (sheet, range.col0);
4444       y = ROW_TOP_YPIXEL (sheet, range.rowi)+
4445         yyy_row_height (sheet, range.rowi);
4446       width = 1;
4447       if (sheet->state == GTK_SHEET_ROW_SELECTED)
4448         {
4449           x = COLUMN_LEFT_XPIXEL (sheet, MIN_VISIBLE_COLUMN (sheet))+3;
4450           width = 3;
4451         }
4452       gdk_draw_pixmap (sheet->sheet_window,
4453                        GTK_WIDGET (sheet)->style->fg_gc[GTK_STATE_NORMAL],
4454                        sheet->pixmap,
4455                        x - width,
4456                        y - width,
4457                        x - width,
4458                        y - width,
4459                        2 * width + 1,
4460                        2 * width + 1);
4461       gdk_draw_rectangle (sheet->sheet_window,
4462                           sheet->xor_gc,
4463                           TRUE,
4464                           x - width + width / 2, y - width + width / 2,
4465                           2 + width, 2 + width);
4466     }
4467
4468   if (gtk_sheet_cell_isvisible (sheet, range.rowi, range.coli))
4469     {
4470       x = COLUMN_LEFT_XPIXEL (sheet, range.coli)+
4471         xxx_column_width (sheet, range.coli);
4472       y = ROW_TOP_YPIXEL (sheet, range.rowi)+
4473         yyy_row_height (sheet, range.rowi);
4474       width = 1;
4475       if (sheet->state == GTK_SHEET_RANGE_SELECTED) width = 3;
4476       if (sheet->state == GTK_SHEET_NORMAL) width = 3;
4477       gdk_draw_pixmap (sheet->sheet_window,
4478                        GTK_WIDGET (sheet)->style->fg_gc[GTK_STATE_NORMAL],
4479                        sheet->pixmap,
4480                        x - width,
4481                        y - width,
4482                        x - width,
4483                        y - width,
4484                        2 * width + 1,
4485                        2 * width + 1);
4486       gdk_draw_rectangle (sheet->sheet_window,
4487                           sheet->xor_gc,
4488                           TRUE,
4489                           x - width + width / 2, y - width + width / 2,
4490                           2 + width, 2 + width);
4491
4492     }
4493
4494 }
4495
4496
4497 static void
4498 gtk_sheet_real_select_range (GtkSheet * sheet,
4499                              const GtkSheetRange * range)
4500 {
4501   gint state;
4502
4503   g_return_if_fail (sheet != NULL);
4504
4505   if (range == NULL) range = &sheet->range;
4506
4507   memcpy (&sheet->range, range, sizeof (*range));
4508
4509   if (range->row0 < 0 || range->rowi < 0) return;
4510   if (range->col0 < 0 || range->coli < 0) return;
4511
4512   state = sheet->state;
4513
4514   if (range->coli != sheet->range.coli || range->col0 != sheet->range.col0 ||
4515       range->rowi != sheet->range.rowi || range->row0 != sheet->range.row0)
4516     {
4517       gtk_sheet_new_selection (sheet, &sheet->range);
4518     }
4519   else
4520     {
4521       gtk_sheet_draw_backing_pixmap (sheet, sheet->range);
4522       gtk_sheet_range_draw_selection (sheet, sheet->range);
4523     }
4524
4525   gtk_sheet_update_primary_selection (sheet);
4526
4527   g_signal_emit (G_OBJECT (sheet), sheet_signals[SELECT_RANGE], 0, &sheet->range);
4528 }
4529
4530
4531 void
4532 gtk_sheet_get_selected_range            (GtkSheet *sheet,
4533                                          GtkSheetRange *range)
4534 {
4535   g_return_if_fail (sheet != NULL);
4536   *range = sheet->range;
4537 }
4538
4539
4540 void
4541 gtk_sheet_select_range (GtkSheet * sheet, const GtkSheetRange *range)
4542 {
4543   g_return_if_fail (sheet != NULL);
4544
4545   if (range == NULL) range=&sheet->range;
4546
4547   if (range->row0 < 0 || range->rowi < 0) return;
4548   if (range->col0 < 0 || range->coli < 0) return;
4549
4550
4551   if ( gtk_sheet_locked (sheet)) return ;
4552
4553   if (sheet->state != GTK_SHEET_NORMAL)
4554     gtk_sheet_real_unselect_range (sheet, NULL);
4555   else
4556     {
4557       gboolean veto = TRUE;
4558       veto = gtk_sheet_deactivate_cell (sheet);
4559       if (!veto) return;
4560     }
4561
4562   sheet->range.row0 = range->row0;
4563   sheet->range.rowi = range->rowi;
4564   sheet->range.col0 = range->col0;
4565   sheet->range.coli = range->coli;
4566   sheet->active_cell.row = range->row0;
4567   sheet->active_cell.col = range->col0;
4568   sheet->selection_cell.row = range->rowi;
4569   sheet->selection_cell.col = range->coli;
4570
4571   sheet->state = GTK_SHEET_RANGE_SELECTED;
4572   gtk_sheet_real_select_range (sheet, NULL);
4573
4574 }
4575
4576 void
4577 gtk_sheet_unselect_range (GtkSheet * sheet)
4578 {
4579   gtk_sheet_real_unselect_range (sheet, NULL);
4580   sheet->state = GTK_STATE_NORMAL;
4581
4582   gtk_sheet_activate_cell (sheet,
4583                            sheet->active_cell.row, sheet->active_cell.col);
4584 }
4585
4586
4587 static void
4588 gtk_sheet_real_unselect_range (GtkSheet * sheet,
4589                                const GtkSheetRange *range)
4590 {
4591   g_return_if_fail (sheet != NULL);
4592   g_return_if_fail (GTK_WIDGET_REALIZED (GTK_WIDGET (sheet)));
4593
4594   if ( range == NULL)
4595     range = &sheet->range;
4596
4597   if (range->row0 < 0 || range->rowi < 0) return;
4598   if (range->col0 < 0 || range->coli < 0) return;
4599
4600   g_signal_emit (G_OBJECT (sheet), sheet_signals[SELECT_COLUMN], 0, -1);
4601   g_signal_emit (G_OBJECT (sheet), sheet_signals[SELECT_ROW], 0, -1);
4602
4603   if (gtk_sheet_range_isvisible (sheet, *range))
4604     gtk_sheet_draw_backing_pixmap (sheet, *range);
4605
4606   sheet->range.row0 = -1;
4607   sheet->range.rowi = -1;
4608   sheet->range.col0 = -1;
4609   sheet->range.coli = -1;
4610
4611   gtk_sheet_position_children (sheet);
4612 }
4613
4614
4615 static gint
4616 gtk_sheet_expose (GtkWidget * widget,
4617                   GdkEventExpose * event)
4618 {
4619   GtkSheet *sheet;
4620   GtkSheetRange range;
4621
4622   g_return_val_if_fail (widget != NULL, FALSE);
4623   g_return_val_if_fail (GTK_IS_SHEET (widget), FALSE);
4624   g_return_val_if_fail (event != NULL, FALSE);
4625
4626
4627   sheet = GTK_SHEET (widget);
4628
4629   if (GTK_WIDGET_DRAWABLE (widget))
4630     {
4631       range.row0 = ROW_FROM_YPIXEL (sheet, event->area.y);
4632       range.col0 = COLUMN_FROM_XPIXEL (sheet, event->area.x);
4633       range.rowi = ROW_FROM_YPIXEL (sheet, event->area.y + event->area.height);
4634       range.coli = COLUMN_FROM_XPIXEL (sheet, event->area.x + event->area.width);
4635
4636       /* exposure events on the sheet */
4637       if (event->window == sheet->row_title_window &&
4638           sheet->row_titles_visible)
4639         {
4640           gint i;
4641           for (i = MIN_VISIBLE_ROW (sheet); i <= MAX_VISIBLE_ROW (sheet); i++)
4642             gtk_sheet_row_title_button_draw (sheet, i);
4643         }
4644
4645       if (event->window == sheet->column_title_window &&
4646           sheet->column_titles_visible)
4647         {
4648           gint i;
4649           for (i = MIN_VISIBLE_COLUMN (sheet); i <= MAX_VISIBLE_COLUMN (sheet); i++)
4650             gtk_sheet_column_title_button_draw (sheet, i);
4651         }
4652
4653       if (event->window == sheet->sheet_window)
4654         {
4655           gtk_sheet_draw_backing_pixmap (sheet, range);
4656
4657           if (sheet->state != GTK_SHEET_NORMAL)
4658             {
4659               if (gtk_sheet_range_isvisible (sheet, sheet->range))
4660                 gtk_sheet_draw_backing_pixmap (sheet, sheet->range);
4661               if (GTK_SHEET_IN_RESIZE (sheet) || GTK_SHEET_IN_DRAG (sheet))
4662                 gtk_sheet_draw_backing_pixmap (sheet, sheet->drag_range);
4663
4664               if (gtk_sheet_range_isvisible (sheet, sheet->range))
4665                 gtk_sheet_range_draw_selection (sheet, sheet->range);
4666               if (GTK_SHEET_IN_RESIZE (sheet) || GTK_SHEET_IN_DRAG (sheet))
4667                 draw_xor_rectangle (sheet, sheet->drag_range);
4668             }
4669
4670           if ((!GTK_SHEET_IN_XDRAG (sheet)) && (!GTK_SHEET_IN_YDRAG (sheet)))
4671             {
4672               if (sheet->state == GTK_SHEET_NORMAL)
4673                 {
4674                   gtk_sheet_draw_active_cell (sheet);
4675                   if (!GTK_SHEET_IN_SELECTION (sheet))
4676                     gtk_widget_queue_draw (sheet->sheet_entry);
4677                 }
4678             }
4679         }
4680     }
4681
4682   if (sheet->state != GTK_SHEET_NORMAL && GTK_SHEET_IN_SELECTION (sheet))
4683     gtk_widget_grab_focus (GTK_WIDGET (sheet));
4684
4685   (* GTK_WIDGET_CLASS (parent_class)->expose_event) (widget, event);
4686
4687   return FALSE;
4688 }
4689
4690
4691 static gboolean
4692 gtk_sheet_button_press (GtkWidget * widget,
4693                         GdkEventButton * event)
4694 {
4695   GtkSheet *sheet;
4696   GdkModifierType mods;
4697   gint x, y, row, column;
4698   gboolean veto;
4699
4700   g_return_val_if_fail (widget != NULL, FALSE);
4701   g_return_val_if_fail (GTK_IS_SHEET (widget), FALSE);
4702   g_return_val_if_fail (event != NULL, FALSE);
4703
4704   sheet = GTK_SHEET (widget);
4705
4706   /* Cancel any pending tooltips */
4707   if (sheet->motion_timer)
4708     {
4709       g_source_remove (sheet->motion_timer);
4710       sheet->motion_timer = 0;
4711     }
4712
4713   gtk_widget_get_pointer (widget, &x, &y);
4714   gtk_sheet_get_pixel_info (sheet, x, y, &row, &column);
4715
4716
4717   if (event->window == sheet->column_title_window)
4718     {
4719       g_signal_emit (G_OBJECT (sheet),
4720                      sheet_signals[BUTTON_EVENT_COLUMN], 0,
4721                      column, event);
4722
4723       if ( event->type == GDK_2BUTTON_PRESS && event->button == 1)
4724         g_signal_emit (G_OBJECT (sheet),
4725                        sheet_signals[DOUBLE_CLICK_COLUMN], 0, column);
4726
4727     }
4728   else if (event->window == sheet->row_title_window)
4729     {
4730       g_signal_emit (G_OBJECT (sheet),
4731                      sheet_signals[BUTTON_EVENT_ROW], 0,
4732                      row, event);
4733
4734       if ( event->type == GDK_2BUTTON_PRESS && event->button == 1)
4735         g_signal_emit (G_OBJECT (sheet),
4736                        sheet_signals[DOUBLE_CLICK_ROW], 0, row);
4737     }
4738
4739
4740   gdk_window_get_pointer (widget->window, NULL, NULL, &mods);
4741
4742   if (! (mods & GDK_BUTTON1_MASK)) return TRUE;
4743
4744
4745   /* press on resize windows */
4746   if (event->window == sheet->column_title_window &&
4747       gtk_sheet_columns_resizable (sheet))
4748     {
4749       gtk_widget_get_pointer (widget, &sheet->x_drag, NULL);
4750       if (POSSIBLE_XDRAG (sheet, sheet->x_drag, &sheet->drag_cell.col))
4751         {
4752           guint req;
4753           if (event->type == GDK_2BUTTON_PRESS)
4754             {
4755               gtk_sheet_autoresize_column (sheet, sheet->drag_cell.col);
4756               GTK_SHEET_UNSET_FLAGS (sheet, GTK_SHEET_IN_XDRAG);
4757               return TRUE;
4758             }
4759           gtk_sheet_column_size_request (sheet, sheet->drag_cell.col, &req);
4760           GTK_SHEET_SET_FLAGS (sheet, GTK_SHEET_IN_XDRAG);
4761           gdk_pointer_grab (sheet->column_title_window, FALSE,
4762                             GDK_POINTER_MOTION_HINT_MASK |
4763                             GDK_BUTTON1_MOTION_MASK |
4764                             GDK_BUTTON_RELEASE_MASK,
4765                             NULL, NULL, event->time);
4766
4767           draw_xor_vline (sheet);
4768           return TRUE;
4769         }
4770     }
4771
4772   if (event->window == sheet->row_title_window && gtk_sheet_rows_resizable (sheet))
4773     {
4774       gtk_widget_get_pointer (widget, NULL, &sheet->y_drag);
4775
4776       if (POSSIBLE_YDRAG (sheet, sheet->y_drag, &sheet->drag_cell.row))
4777         {
4778           guint req;
4779           gtk_sheet_row_size_request (sheet, sheet->drag_cell.row, &req);
4780           GTK_SHEET_SET_FLAGS (sheet, GTK_SHEET_IN_YDRAG);
4781           gdk_pointer_grab (sheet->row_title_window, FALSE,
4782                             GDK_POINTER_MOTION_HINT_MASK |
4783                             GDK_BUTTON1_MOTION_MASK |
4784                             GDK_BUTTON_RELEASE_MASK,
4785                             NULL, NULL, event->time);
4786
4787           draw_xor_hline (sheet);
4788           return TRUE;
4789         }
4790     }
4791
4792   /* the sheet itself does not handle other than single click events */
4793   if (event->type != GDK_BUTTON_PRESS) return FALSE;
4794
4795   /* selections on the sheet */
4796   if (event->window == sheet->sheet_window)
4797     {
4798       gtk_widget_get_pointer (widget, &x, &y);
4799       gtk_sheet_get_pixel_info (sheet, x, y, &row, &column);
4800       gdk_pointer_grab (sheet->sheet_window, FALSE,
4801                         GDK_POINTER_MOTION_HINT_MASK |
4802                         GDK_BUTTON1_MOTION_MASK |
4803                         GDK_BUTTON_RELEASE_MASK,
4804                         NULL, NULL, event->time);
4805       gtk_grab_add (GTK_WIDGET (sheet));
4806
4807       /* This seems to be a kludge to work around a problem where the sheet
4808          scrolls to another position.  The timeout scrolls it back to its
4809          original posn.          JMD 3 July 2007
4810       */
4811       gtk_widget_grab_focus (GTK_WIDGET (sheet));
4812
4813       if (sheet->selection_mode != GTK_SELECTION_SINGLE &&
4814           sheet->selection_mode != GTK_SELECTION_NONE &&
4815           sheet->cursor_drag->type == GDK_SIZING &&
4816           !GTK_SHEET_IN_SELECTION (sheet) && !GTK_SHEET_IN_RESIZE (sheet))
4817         {
4818           if (sheet->state == GTK_STATE_NORMAL)
4819             {
4820               row = sheet->active_cell.row;
4821               column = sheet->active_cell.col;
4822               if (!gtk_sheet_deactivate_cell (sheet)) return FALSE;
4823               sheet->active_cell.row = row;
4824               sheet->active_cell.col = column;
4825               sheet->drag_range = sheet->range;
4826               sheet->state = GTK_SHEET_RANGE_SELECTED;
4827               gtk_sheet_select_range (sheet, &sheet->drag_range);
4828             }
4829           sheet->x_drag = x;
4830           sheet->y_drag = y;
4831           if (row > sheet->range.rowi) row--;
4832           if (column > sheet->range.coli) column--;
4833           sheet->drag_cell.row = row;
4834           sheet->drag_cell.col = column;
4835           sheet->drag_range = sheet->range;
4836           draw_xor_rectangle (sheet, sheet->drag_range);
4837           GTK_SHEET_SET_FLAGS (sheet, GTK_SHEET_IN_RESIZE);
4838         }
4839       else if (sheet->cursor_drag->type == GDK_TOP_LEFT_ARROW &&
4840                !GTK_SHEET_IN_SELECTION (sheet)
4841                && ! GTK_SHEET_IN_DRAG (sheet)
4842                && ! gtk_sheet_locked (sheet)
4843                && sheet->active_cell.row >= 0
4844                && sheet->active_cell.col >= 0
4845                )
4846         {
4847           if (sheet->state == GTK_STATE_NORMAL)
4848             {
4849               row = sheet->active_cell.row;
4850               column = sheet->active_cell.col;
4851               if (!gtk_sheet_deactivate_cell (sheet)) return FALSE;
4852               sheet->active_cell.row = row;
4853               sheet->active_cell.col = column;
4854               sheet->drag_range = sheet->range;
4855               sheet->state = GTK_SHEET_RANGE_SELECTED;
4856               gtk_sheet_select_range (sheet, &sheet->drag_range);
4857             }
4858           sheet->x_drag = x;
4859           sheet->y_drag = y;
4860           if (row < sheet->range.row0) row++;
4861           if (row > sheet->range.rowi) row--;
4862           if (column < sheet->range.col0) column++;
4863           if (column > sheet->range.coli) column--;
4864           sheet->drag_cell.row = row;
4865           sheet->drag_cell.col = column;
4866           sheet->drag_range = sheet->range;
4867           draw_xor_rectangle (sheet, sheet->drag_range);
4868           GTK_SHEET_SET_FLAGS (sheet, GTK_SHEET_IN_DRAG);
4869         }
4870       else
4871         {
4872           gtk_sheet_click_cell (sheet, row, column, &veto);
4873           if (veto) GTK_SHEET_SET_FLAGS (sheet, GTK_SHEET_IN_SELECTION);
4874         }
4875     }
4876
4877   if (event->window == sheet->column_title_window)
4878     {
4879       gtk_widget_get_pointer (widget, &x, &y);
4880       column = COLUMN_FROM_XPIXEL (sheet, x);
4881
4882       if (xxx_column_is_sensitive (sheet, column))
4883         {
4884           gtk_sheet_click_cell (sheet, - 1, column, &veto);
4885           gtk_grab_add (GTK_WIDGET (sheet));
4886           gtk_widget_grab_focus (GTK_WIDGET (sheet));
4887           GTK_SHEET_SET_FLAGS (sheet, GTK_SHEET_IN_SELECTION);
4888         }
4889     }
4890
4891   if (event->window == sheet->row_title_window)
4892     {
4893       gtk_widget_get_pointer (widget, &x, &y);
4894       row = ROW_FROM_YPIXEL (sheet, y);
4895       if (yyy_row_is_sensitive (sheet, row))
4896         {
4897           gtk_sheet_click_cell (sheet, row, - 1, &veto);
4898           gtk_grab_add (GTK_WIDGET (sheet));
4899           gtk_widget_grab_focus (GTK_WIDGET (sheet));
4900           GTK_SHEET_SET_FLAGS (sheet, GTK_SHEET_IN_SELECTION);
4901         }
4902     }
4903
4904   return TRUE;
4905 }
4906
4907 #if 0
4908 static gint
4909 gtk_sheet_scroll (gpointer data)
4910 {
4911   GtkSheet *sheet;
4912   gint x, y, row, column;
4913   gint move;
4914
4915   sheet = GTK_SHEET (data);
4916
4917   GDK_THREADS_ENTER ();
4918
4919   gtk_widget_get_pointer (GTK_WIDGET (sheet), &x, &y);
4920   gtk_sheet_get_pixel_info (sheet, x, y, &row, &column);
4921
4922   move = TRUE;
4923
4924   if (GTK_SHEET_IN_SELECTION (sheet))
4925     gtk_sheet_extend_selection (sheet, row, column);
4926
4927   if (GTK_SHEET_IN_DRAG (sheet) || GTK_SHEET_IN_RESIZE (sheet))
4928     {
4929       move = gtk_sheet_move_query (sheet, row, column);
4930       if (move) draw_xor_rectangle (sheet, sheet->drag_range);
4931     }
4932
4933   GDK_THREADS_LEAVE ();
4934
4935   return TRUE;
4936 }
4937 #endif
4938
4939 static void
4940 gtk_sheet_click_cell (GtkSheet *sheet, gint row, gint column, gboolean *veto)
4941 {
4942   *veto = TRUE;
4943
4944   if (row >= yyy_row_count (sheet) || column >= xxx_column_count (sheet))
4945     {
4946       *veto = FALSE;
4947       return;
4948     }
4949
4950   if (column >= 0 && row >= 0)
4951     if (! xxx_column_is_visible (sheet, column) || !yyy_row_is_visible (sheet, row))
4952       {
4953         *veto = FALSE;
4954         return;
4955       }
4956
4957   _gtkextra_signal_emit (GTK_OBJECT (sheet), sheet_signals[TRAVERSE],
4958                          sheet->active_cell.row, sheet->active_cell.col,
4959                          &row, &column, veto);
4960
4961   if (!*veto)
4962     {
4963       if (sheet->state == GTK_STATE_NORMAL) return;
4964
4965       row = sheet->active_cell.row;
4966       column = sheet->active_cell.col;
4967
4968       gtk_sheet_activate_cell (sheet, row, column);
4969       return;
4970     }
4971
4972   if (row == -1 && column >= 0)
4973     {
4974       if (gtk_sheet_autoscroll (sheet))
4975         gtk_sheet_move_query (sheet, row, column);
4976       gtk_sheet_select_column (sheet, column);
4977       return;
4978     }
4979   if (column == -1 && row >= 0)
4980     {
4981       if (gtk_sheet_autoscroll (sheet))
4982         gtk_sheet_move_query (sheet, row, column);
4983       gtk_sheet_select_row (sheet, row);
4984       return;
4985     }
4986
4987   if (row == - 1 && column == - 1)
4988     {
4989       sheet->range.row0 = 0;
4990       sheet->range.col0 = 0;
4991       sheet->range.rowi = yyy_row_count (sheet) - 1;
4992       sheet->range.coli = xxx_column_count (sheet) - 1;
4993       sheet->active_cell.row = 0;
4994       sheet->active_cell.col = 0;
4995       gtk_sheet_select_range (sheet, NULL);
4996       return;
4997     }
4998
4999   if (row != -1 && column != -1)
5000     {
5001       if (sheet->state != GTK_SHEET_NORMAL)
5002         {
5003           sheet->state = GTK_SHEET_NORMAL;
5004           gtk_sheet_real_unselect_range (sheet, NULL);
5005         }
5006       else
5007         {
5008           if (!gtk_sheet_deactivate_cell (sheet))
5009             {
5010               *veto = FALSE;
5011               return;
5012             }
5013           gtk_sheet_activate_cell (sheet, row, column);
5014         }
5015
5016       if (gtk_sheet_autoscroll (sheet))
5017         gtk_sheet_move_query (sheet, row, column);
5018       sheet->active_cell.row = row;
5019       sheet->active_cell.col = column;
5020       sheet->selection_cell.row = row;
5021       sheet->selection_cell.col = column;
5022       sheet->range.row0 = row;
5023       sheet->range.col0 = column;
5024       sheet->range.rowi = row;
5025       sheet->range.coli = column;
5026       sheet->state = GTK_SHEET_NORMAL;
5027       GTK_SHEET_SET_FLAGS (sheet, GTK_SHEET_IN_SELECTION);
5028       gtk_sheet_draw_active_cell (sheet);
5029       return;
5030     }
5031
5032   g_assert_not_reached ();
5033   gtk_sheet_activate_cell (sheet, sheet->active_cell.row,
5034                            sheet->active_cell.col);
5035 }
5036
5037 static gint
5038 gtk_sheet_button_release (GtkWidget * widget,
5039                           GdkEventButton * event)
5040 {
5041   GtkSheet *sheet;
5042   gint x, y;
5043
5044   sheet = GTK_SHEET (widget);
5045
5046   /* release on resize windows */
5047   if (GTK_SHEET_IN_XDRAG (sheet))
5048     {
5049       GTK_SHEET_UNSET_FLAGS (sheet, GTK_SHEET_IN_XDRAG);
5050       GTK_SHEET_UNSET_FLAGS (sheet, GTK_SHEET_IN_SELECTION);
5051       gtk_widget_get_pointer (widget, &x, NULL);
5052       gdk_pointer_ungrab (event->time);
5053       draw_xor_vline (sheet);
5054
5055       gtk_sheet_set_column_width (sheet, sheet->drag_cell.col,
5056                                   new_column_width (sheet, sheet->drag_cell.col, &x));
5057       sheet->old_hadjustment = -1.;
5058       g_signal_emit_by_name (G_OBJECT (sheet->hadjustment), "value_changed");
5059       return TRUE;
5060     }
5061
5062   if (GTK_SHEET_IN_YDRAG (sheet))
5063     {
5064       GTK_SHEET_UNSET_FLAGS (sheet, GTK_SHEET_IN_YDRAG);
5065       GTK_SHEET_UNSET_FLAGS (sheet, GTK_SHEET_IN_SELECTION);
5066       gtk_widget_get_pointer (widget, NULL, &y);
5067       gdk_pointer_ungrab (event->time);
5068       draw_xor_hline (sheet);
5069
5070       gtk_sheet_set_row_height (sheet, sheet->drag_cell.row, new_row_height (sheet, sheet->drag_cell.row, &y));
5071       sheet->old_vadjustment = -1.;
5072       g_signal_emit_by_name (G_OBJECT (sheet->vadjustment), "value_changed");
5073       return TRUE;
5074     }
5075
5076
5077   if (GTK_SHEET_IN_DRAG (sheet))
5078     {
5079       GtkSheetRange old_range;
5080       draw_xor_rectangle (sheet, sheet->drag_range);
5081       GTK_SHEET_UNSET_FLAGS (sheet, GTK_SHEET_IN_DRAG);
5082       gdk_pointer_ungrab (event->time);
5083
5084       gtk_sheet_real_unselect_range (sheet, NULL);
5085
5086       sheet->active_cell.row = sheet->active_cell.row +
5087         (sheet->drag_range.row0 - sheet->range.row0);
5088       sheet->active_cell.col = sheet->active_cell.col +
5089         (sheet->drag_range.col0 - sheet->range.col0);
5090       sheet->selection_cell.row = sheet->selection_cell.row +
5091         (sheet->drag_range.row0 - sheet->range.row0);
5092       sheet->selection_cell.col = sheet->selection_cell.col +
5093         (sheet->drag_range.col0 - sheet->range.col0);
5094       old_range = sheet->range;
5095       sheet->range = sheet->drag_range;
5096       sheet->drag_range = old_range;
5097       g_signal_emit (G_OBJECT (sheet), sheet_signals[MOVE_RANGE], 0,
5098                      &sheet->drag_range, &sheet->range);
5099       gtk_sheet_select_range (sheet, &sheet->range);
5100     }
5101
5102   if (GTK_SHEET_IN_RESIZE (sheet))
5103     {
5104       GtkSheetRange old_range;
5105       draw_xor_rectangle (sheet, sheet->drag_range);
5106       GTK_SHEET_UNSET_FLAGS (sheet, GTK_SHEET_IN_RESIZE);
5107       gdk_pointer_ungrab (event->time);
5108
5109       gtk_sheet_real_unselect_range (sheet, NULL);
5110
5111       sheet->active_cell.row = sheet->active_cell.row +
5112         (sheet->drag_range.row0 - sheet->range.row0);
5113       sheet->active_cell.col = sheet->active_cell.col +
5114         (sheet->drag_range.col0 - sheet->range.col0);
5115       if (sheet->drag_range.row0 < sheet->range.row0)
5116         sheet->selection_cell.row = sheet->drag_range.row0;
5117       if (sheet->drag_range.rowi >= sheet->range.rowi)
5118         sheet->selection_cell.row = sheet->drag_range.rowi;
5119       if (sheet->drag_range.col0 < sheet->range.col0)
5120         sheet->selection_cell.col = sheet->drag_range.col0;
5121       if (sheet->drag_range.coli >= sheet->range.coli)
5122         sheet->selection_cell.col = sheet->drag_range.coli;
5123       old_range = sheet->range;
5124       sheet->range = sheet->drag_range;
5125       sheet->drag_range = old_range;
5126
5127       if (sheet->state == GTK_STATE_NORMAL) sheet->state = GTK_SHEET_RANGE_SELECTED;
5128       g_signal_emit (G_OBJECT (sheet), sheet_signals[RESIZE_RANGE], 0,
5129                      &sheet->drag_range, &sheet->range);
5130       gtk_sheet_select_range (sheet, &sheet->range);
5131     }
5132
5133   if (sheet->state == GTK_SHEET_NORMAL && GTK_SHEET_IN_SELECTION (sheet))
5134     {
5135       GTK_SHEET_UNSET_FLAGS (sheet, GTK_SHEET_IN_SELECTION);
5136       gdk_pointer_ungrab (event->time);
5137       gtk_sheet_activate_cell (sheet, sheet->active_cell.row,
5138                                sheet->active_cell.col);
5139     }
5140
5141   if (GTK_SHEET_IN_SELECTION)
5142     gdk_pointer_ungrab (event->time);
5143   gtk_grab_remove (GTK_WIDGET (sheet));
5144
5145   GTK_SHEET_UNSET_FLAGS (sheet, GTK_SHEET_IN_SELECTION);
5146
5147   return TRUE;
5148 }
5149
5150 /* Shamelessly lifted from gtktooltips */
5151 static gboolean
5152 gtk_sheet_subtitle_paint_window (GtkWidget *tip_window)
5153 {
5154   GtkRequisition req;
5155
5156   gtk_widget_size_request (tip_window, &req);
5157   gtk_paint_flat_box (tip_window->style, tip_window->window,
5158                       GTK_STATE_NORMAL, GTK_SHADOW_OUT,
5159                       NULL, GTK_WIDGET(tip_window), "tooltip",
5160                       0, 0, req.width, req.height);
5161
5162   return FALSE;
5163 }
5164
5165 static GtkSheetHoverTitle *
5166 create_hover_window (void)
5167 {
5168   GtkSheetHoverTitle *hw = malloc (sizeof (*hw));
5169
5170   hw->window = gtk_window_new (GTK_WINDOW_POPUP);
5171
5172 #if GTK_CHECK_VERSION (2, 9, 0)
5173   gtk_window_set_type_hint (GTK_WINDOW (hw->window),
5174                             GDK_WINDOW_TYPE_HINT_TOOLTIP);
5175 #endif
5176
5177   gtk_widget_set_app_paintable (hw->window, TRUE);
5178   gtk_window_set_resizable (GTK_WINDOW (hw->window), FALSE);
5179   gtk_widget_set_name (hw->window, "gtk-tooltips");
5180   gtk_container_set_border_width (GTK_CONTAINER (hw->window), 4);
5181
5182   g_signal_connect (hw->window,
5183                     "expose_event",
5184                     G_CALLBACK (gtk_sheet_subtitle_paint_window),
5185                     NULL);
5186
5187   hw->label = gtk_label_new (NULL);
5188
5189
5190   gtk_label_set_line_wrap (GTK_LABEL (hw->label), TRUE);
5191   gtk_misc_set_alignment (GTK_MISC (hw->label), 0.5, 0.5);
5192
5193   gtk_container_add (GTK_CONTAINER (hw->window), hw->label);
5194
5195   gtk_widget_show (hw->label);
5196
5197   g_signal_connect (hw->window,
5198                     "destroy",
5199                     G_CALLBACK (gtk_widget_destroyed),
5200                     &hw->window);
5201
5202   return hw;
5203 }
5204
5205 #define HOVER_WINDOW_Y_OFFSET 2
5206
5207 static void
5208 show_subtitle (GtkSheet *sheet, gint row, gint column, const gchar *subtitle)
5209 {
5210   gint x, y;
5211   gint px, py;
5212   gint width;
5213
5214   if ( ! subtitle )
5215     return;
5216
5217   if ( ! sheet->hover_window)
5218     {
5219       sheet->hover_window = create_hover_window ();
5220       gtk_widget_add_events (GTK_WIDGET (sheet), GDK_LEAVE_NOTIFY_MASK);
5221
5222       g_signal_connect_swapped (sheet, "leave-notify-event",
5223                                 G_CALLBACK (gtk_widget_hide),
5224                                 sheet->hover_window->window);
5225     }
5226
5227   gtk_label_set_text (GTK_LABEL (sheet->hover_window->label),
5228                       subtitle);
5229
5230
5231   sheet->hover_window->row = row;
5232   sheet->hover_window->column = column;
5233
5234   gdk_window_get_origin (GTK_WIDGET (sheet)->window, &x, &y);
5235
5236   gtk_widget_get_pointer (GTK_WIDGET (sheet), &px, &py);
5237
5238   gtk_widget_show (sheet->hover_window->window);
5239
5240   width = GTK_WIDGET (sheet->hover_window->label)->allocation.width;
5241
5242   if (row == -1 )
5243     {
5244       x += px;
5245       x -= width / 2;
5246       y += sheet->column_title_area.y;
5247       y += sheet->column_title_area.height;
5248       y += HOVER_WINDOW_Y_OFFSET;
5249     }
5250
5251   if ( column == -1 )
5252     {
5253       y += py;
5254       x += sheet->row_title_area.x;
5255       x += sheet->row_title_area.width * 2 / 3.0;
5256     }
5257
5258   gtk_window_move (GTK_WINDOW (sheet->hover_window->window),
5259                    x, y);
5260 }
5261
5262 static gboolean
5263 motion_timeout_callback (gpointer data)
5264 {
5265   GtkSheet *sheet = GTK_SHEET (data);
5266   gint x, y;
5267   gint row, column;
5268   gtk_widget_get_pointer (GTK_WIDGET (sheet), &x, &y);
5269
5270   if ( gtk_sheet_get_pixel_info (sheet, x, y, &row, &column) )
5271     {
5272       if ( column == -1 && row == -1 )
5273         return FALSE;
5274
5275       if ( column == -1)
5276         {
5277           GSheetRow *row_geo = sheet->row_geometry;
5278           gchar *text;
5279
5280           text = g_sheet_row_get_subtitle (row_geo, row);
5281
5282           show_subtitle (sheet, row, column, text);
5283           g_free (text);
5284         }
5285
5286       if ( row == -1)
5287         {
5288           GSheetColumn *col_geo = sheet->column_geometry;
5289           gchar *text;
5290
5291           text = g_sheet_column_get_subtitle (col_geo, column);
5292
5293           show_subtitle (sheet, row, column, text );
5294
5295           g_free (text);
5296         }
5297     }
5298
5299   return FALSE;
5300 }
5301
5302 static gint
5303 gtk_sheet_motion (GtkWidget * widget,
5304                   GdkEventMotion * event)
5305 {
5306   GtkSheet *sheet;
5307   GdkModifierType mods;
5308   GdkCursorType new_cursor;
5309   gint x, y;
5310   gint row, column;
5311
5312   g_return_val_if_fail (widget != NULL, FALSE);
5313   g_return_val_if_fail (GTK_IS_SHEET (widget), FALSE);
5314   g_return_val_if_fail (event != NULL, FALSE);
5315
5316   sheet = GTK_SHEET (widget);
5317
5318   /* selections on the sheet */
5319   x = event->x;
5320   y = event->y;
5321
5322   if (!sheet->hover_window || ! GTK_WIDGET_VISIBLE (sheet->hover_window->window))
5323     {
5324       if ( sheet->motion_timer > 0 )
5325         g_source_remove (sheet->motion_timer);
5326       sheet->motion_timer = g_timeout_add (TIMEOUT_HOVER, motion_timeout_callback, sheet);
5327     }
5328   else
5329     {
5330       gint row, column;
5331       gint wx, wy;
5332       gtk_widget_get_pointer (widget, &wx, &wy);
5333
5334       if ( gtk_sheet_get_pixel_info (sheet, wx, wy, &row, &column) )
5335         {
5336           if ( row != sheet->hover_window->row || column != sheet->hover_window->column)
5337             {
5338               gtk_widget_hide (sheet->hover_window->window);
5339             }
5340         }
5341     }
5342
5343   if (event->window == sheet->column_title_window &&
5344       gtk_sheet_columns_resizable (sheet))
5345     {
5346       gtk_widget_get_pointer (widget, &x, &y);
5347       if (!GTK_SHEET_IN_SELECTION (sheet) &&
5348           POSSIBLE_XDRAG (sheet, x, &column))
5349         {
5350           new_cursor = GDK_SB_H_DOUBLE_ARROW;
5351           if (new_cursor != sheet->cursor_drag->type)
5352             {
5353               gdk_cursor_destroy (sheet->cursor_drag);
5354               sheet->cursor_drag = gdk_cursor_new (GDK_SB_H_DOUBLE_ARROW);
5355               gdk_window_set_cursor (sheet->column_title_window,
5356                                      sheet->cursor_drag);
5357             }
5358         }
5359       else
5360         {
5361           new_cursor = GDK_TOP_LEFT_ARROW;
5362           if (!GTK_SHEET_IN_XDRAG (sheet) &&
5363               new_cursor != sheet->cursor_drag->type)
5364             {
5365               gdk_cursor_destroy (sheet->cursor_drag);
5366               sheet->cursor_drag = gdk_cursor_new (GDK_TOP_LEFT_ARROW);
5367               gdk_window_set_cursor (sheet->column_title_window,
5368                                      sheet->cursor_drag);
5369             }
5370         }
5371     }
5372
5373   if (event->window == sheet->row_title_window &&
5374       gtk_sheet_rows_resizable (sheet))
5375     {
5376       gtk_widget_get_pointer (widget, &x, &y);
5377       if (!GTK_SHEET_IN_SELECTION (sheet) && POSSIBLE_YDRAG (sheet, y, &column))
5378         {
5379           new_cursor = GDK_SB_V_DOUBLE_ARROW;
5380           if (new_cursor != sheet->cursor_drag->type)
5381             {
5382               gdk_cursor_destroy (sheet->cursor_drag);
5383               sheet->cursor_drag = gdk_cursor_new (GDK_SB_V_DOUBLE_ARROW);
5384               gdk_window_set_cursor (sheet->row_title_window, sheet->cursor_drag);
5385             }
5386         }
5387       else
5388         {
5389           new_cursor = GDK_TOP_LEFT_ARROW;
5390           if (!GTK_SHEET_IN_YDRAG (sheet) &&
5391               new_cursor != sheet->cursor_drag->type)
5392             {
5393               gdk_cursor_destroy (sheet->cursor_drag);
5394               sheet->cursor_drag = gdk_cursor_new (GDK_TOP_LEFT_ARROW);
5395               gdk_window_set_cursor (sheet->row_title_window, sheet->cursor_drag);
5396             }
5397         }
5398     }
5399
5400   new_cursor = GDK_PLUS;
5401   if ( event->window == sheet->sheet_window &&
5402        !POSSIBLE_DRAG (sheet, x, y, &row, &column) &&
5403        !GTK_SHEET_IN_DRAG (sheet) &&
5404        !POSSIBLE_RESIZE (sheet, x, y, &row, &column) &&
5405        !GTK_SHEET_IN_RESIZE (sheet) &&
5406        new_cursor != sheet->cursor_drag->type)
5407     {
5408       gdk_cursor_destroy (sheet->cursor_drag);
5409       sheet->cursor_drag = gdk_cursor_new (GDK_PLUS);
5410       gdk_window_set_cursor (sheet->sheet_window, sheet->cursor_drag);
5411     }
5412
5413   new_cursor = GDK_TOP_LEFT_ARROW;
5414   if ( event->window == sheet->sheet_window &&
5415        ! (POSSIBLE_RESIZE (sheet, x, y, &row, &column) || GTK_SHEET_IN_RESIZE (sheet)) && (POSSIBLE_DRAG (sheet, x, y, &row, &column) || GTK_SHEET_IN_DRAG (sheet)) &&
5416
5417        new_cursor != sheet->cursor_drag->type)
5418     {
5419       gdk_cursor_destroy (sheet->cursor_drag);
5420       sheet->cursor_drag = gdk_cursor_new (GDK_TOP_LEFT_ARROW);
5421       gdk_window_set_cursor (sheet->sheet_window, sheet->cursor_drag);
5422     }
5423
5424   new_cursor = GDK_SIZING;
5425   if ( event->window == sheet->sheet_window &&
5426        sheet->selection_mode != GTK_SELECTION_NONE &&
5427        !GTK_SHEET_IN_DRAG (sheet) &&
5428        (POSSIBLE_RESIZE (sheet, x, y, &row, &column) ||
5429         GTK_SHEET_IN_RESIZE (sheet)) &&
5430        new_cursor != sheet->cursor_drag->type)
5431     {
5432       gdk_cursor_destroy (sheet->cursor_drag);
5433       sheet->cursor_drag = gdk_cursor_new (GDK_SIZING);
5434       gdk_window_set_cursor (sheet->sheet_window, sheet->cursor_drag);
5435     }
5436
5437
5438   gdk_window_get_pointer (widget->window, &x, &y, &mods);
5439   if (! (mods & GDK_BUTTON1_MASK)) return FALSE;
5440
5441   if (GTK_SHEET_IN_XDRAG (sheet))
5442     {
5443       if (event->is_hint || event->window != widget->window)
5444         gtk_widget_get_pointer (widget, &x, NULL);
5445       else
5446         x = event->x;
5447
5448       new_column_width (sheet, sheet->drag_cell.col, &x);
5449       if (x != sheet->x_drag)
5450         {
5451           draw_xor_vline (sheet);
5452           sheet->x_drag = x;
5453           draw_xor_vline (sheet);
5454         }
5455       return TRUE;
5456     }
5457
5458   if (GTK_SHEET_IN_YDRAG (sheet))
5459     {
5460       if (event->is_hint || event->window != widget->window)
5461         gtk_widget_get_pointer (widget, NULL, &y);
5462       else
5463         y = event->y;
5464
5465       new_row_height (sheet, sheet->drag_cell.row, &y);
5466       if (y != sheet->y_drag)
5467         {
5468           draw_xor_hline (sheet);
5469           sheet->y_drag = y;
5470           draw_xor_hline (sheet);
5471         }
5472       return TRUE;
5473     }
5474
5475   if (GTK_SHEET_IN_DRAG (sheet))
5476     {
5477       GtkSheetRange aux;
5478       column = COLUMN_FROM_XPIXEL (sheet, x)- sheet->drag_cell.col;
5479       row = ROW_FROM_YPIXEL (sheet, y)- sheet->drag_cell.row;
5480       if (sheet->state == GTK_SHEET_COLUMN_SELECTED) row = 0;
5481       if (sheet->state == GTK_SHEET_ROW_SELECTED) column = 0;
5482       sheet->x_drag = x;
5483       sheet->y_drag = y;
5484       aux = sheet->range;
5485       if (aux.row0 + row >= 0 && aux.rowi + row < yyy_row_count (sheet) &&
5486           aux.col0 + column >= 0 && aux.coli + column < xxx_column_count (sheet))
5487         {
5488           aux = sheet->drag_range;
5489           sheet->drag_range.row0 = sheet->range.row0 + row;
5490           sheet->drag_range.col0 = sheet->range.col0 + column;
5491           sheet->drag_range.rowi = sheet->range.rowi + row;
5492           sheet->drag_range.coli = sheet->range.coli + column;
5493           if (aux.row0 != sheet->drag_range.row0 ||
5494               aux.col0 != sheet->drag_range.col0)
5495             {
5496               draw_xor_rectangle (sheet, aux);
5497               draw_xor_rectangle (sheet, sheet->drag_range);
5498             }
5499         }
5500       return TRUE;
5501     }
5502
5503   if (GTK_SHEET_IN_RESIZE (sheet))
5504     {
5505       GtkSheetRange aux;
5506       gint v_h, current_col, current_row, col_threshold, row_threshold;
5507       v_h = 1;
5508
5509       if (abs (x - COLUMN_LEFT_XPIXEL (sheet, sheet->drag_cell.col)) >
5510           abs (y - ROW_TOP_YPIXEL (sheet, sheet->drag_cell.row))) v_h = 2;
5511
5512       current_col = COLUMN_FROM_XPIXEL (sheet, x);
5513       current_row = ROW_FROM_YPIXEL (sheet, y);
5514       column = current_col - sheet->drag_cell.col;
5515       row = current_row - sheet->drag_cell.row;
5516
5517       /*use half of column width resp. row height as threshold to
5518         expand selection*/
5519       col_threshold = COLUMN_LEFT_XPIXEL (sheet, current_col) +
5520         xxx_column_width (sheet, current_col) / 2;
5521       if (column > 0)
5522         {
5523           if (x < col_threshold)
5524             column -= 1;
5525         }
5526       else if (column < 0)
5527         {
5528           if (x > col_threshold)
5529             column +=1;
5530         }
5531       row_threshold = ROW_TOP_YPIXEL (sheet, current_row) +
5532         yyy_row_height (sheet, current_row)/2;
5533       if (row > 0)
5534         {
5535           if (y < row_threshold)
5536             row -= 1;
5537         }
5538       else if (row < 0)
5539         {
5540           if (y > row_threshold)
5541             row +=1;
5542         }
5543
5544       if (sheet->state == GTK_SHEET_COLUMN_SELECTED) row = 0;
5545       if (sheet->state == GTK_SHEET_ROW_SELECTED) column = 0;
5546       sheet->x_drag = x;
5547       sheet->y_drag = y;
5548       aux = sheet->range;
5549
5550       if (v_h == 1)
5551         column = 0;
5552       else
5553         row = 0;
5554
5555       if (aux.row0 + row >= 0 && aux.rowi + row < yyy_row_count (sheet) &&
5556           aux.col0 + column >= 0 && aux.coli + column < xxx_column_count (sheet))
5557         {
5558           aux = sheet->drag_range;
5559           sheet->drag_range = sheet->range;
5560
5561           if (row < 0) sheet->drag_range.row0 = sheet->range.row0 + row;
5562           if (row > 0) sheet->drag_range.rowi = sheet->range.rowi + row;
5563           if (column < 0) sheet->drag_range.col0 = sheet->range.col0 + column;
5564           if (column > 0) sheet->drag_range.coli = sheet->range.coli + column;
5565
5566           if (aux.row0 != sheet->drag_range.row0 ||
5567               aux.rowi != sheet->drag_range.rowi ||
5568               aux.col0 != sheet->drag_range.col0 ||
5569               aux.coli != sheet->drag_range.coli)
5570             {
5571               draw_xor_rectangle (sheet, aux);
5572               draw_xor_rectangle (sheet, sheet->drag_range);
5573             }
5574         }
5575       return TRUE;
5576     }
5577
5578   gtk_sheet_get_pixel_info (sheet, x, y, &row, &column);
5579
5580   if (sheet->state == GTK_SHEET_NORMAL && row == sheet->active_cell.row &&
5581       column == sheet->active_cell.col) return TRUE;
5582
5583   if (GTK_SHEET_IN_SELECTION (sheet) && mods&GDK_BUTTON1_MASK)
5584     gtk_sheet_extend_selection (sheet, row, column);
5585
5586   return TRUE;
5587 }
5588
5589 static gboolean
5590 gtk_sheet_move_query (GtkSheet *sheet, gint row, gint column)
5591 {
5592   gint row_move, column_move;
5593   gfloat row_align, col_align;
5594   guint height, width;
5595   gint new_row = row;
5596   gint new_col = column;
5597
5598   row_move = FALSE;
5599   column_move = FALSE;
5600   row_align =- 1.;
5601   col_align =- 1.;
5602
5603   height = sheet->sheet_window_height;
5604   width = sheet->sheet_window_width;
5605
5606   if (row >= MAX_VISIBLE_ROW (sheet) && sheet->state != GTK_SHEET_COLUMN_SELECTED)
5607     {
5608       row_align = 1.;
5609       new_row = MIN (yyy_row_count (sheet), row + 1);
5610       row_move = TRUE;
5611       if (MAX_VISIBLE_ROW (sheet) == yyy_row_count (sheet) - 1 &&
5612           ROW_TOP_YPIXEL (sheet, yyy_row_count (sheet)- 1) +
5613           yyy_row_height (sheet, yyy_row_count (sheet)- 1) < height)
5614         {
5615           row_move = FALSE;
5616           row_align = -1.;
5617         }
5618     }
5619   if (row < MIN_VISIBLE_ROW (sheet) && sheet->state != GTK_SHEET_COLUMN_SELECTED)
5620     {
5621       row_align= 0.;
5622       row_move = TRUE;
5623     }
5624   if (column >= MAX_VISIBLE_COLUMN (sheet) && sheet->state != GTK_SHEET_ROW_SELECTED)
5625     {
5626       col_align = 1.;
5627       new_col = MIN (xxx_column_count (sheet) - 1, column + 1);
5628       column_move = TRUE;
5629       if (MAX_VISIBLE_COLUMN (sheet) == (xxx_column_count (sheet) - 1) &&
5630           COLUMN_LEFT_XPIXEL (sheet, xxx_column_count (sheet) - 1) +
5631           xxx_column_width (sheet, xxx_column_count (sheet) - 1) < width)
5632         {
5633           column_move = FALSE;
5634           col_align = -1.;
5635         }
5636     }
5637   if (column < MIN_VISIBLE_COLUMN (sheet) && sheet->state != GTK_SHEET_ROW_SELECTED)
5638     {
5639       col_align = 0.;
5640       column_move = TRUE;
5641     }
5642
5643   if (row_move || column_move)
5644     {
5645       gtk_sheet_moveto (sheet, new_row, new_col, row_align, col_align);
5646     }
5647
5648   return (row_move || column_move);
5649 }
5650
5651 static void
5652 gtk_sheet_extend_selection (GtkSheet *sheet, gint row, gint column)
5653 {
5654   GtkSheetRange range;
5655   gint state;
5656   gint r, c;
5657
5658   if (row == sheet->selection_cell.row && column == sheet->selection_cell.col)
5659     return;
5660
5661   if (sheet->selection_mode == GTK_SELECTION_SINGLE) return;
5662
5663   gtk_sheet_move_query (sheet, row, column);
5664   gtk_widget_grab_focus (GTK_WIDGET (sheet));
5665
5666   if (GTK_SHEET_IN_DRAG (sheet)) return;
5667
5668   state = sheet->state;
5669
5670   switch (sheet->state)
5671     {
5672     case GTK_SHEET_ROW_SELECTED:
5673       column = xxx_column_count (sheet) - 1;
5674       break;
5675     case GTK_SHEET_COLUMN_SELECTED:
5676       row = yyy_row_count (sheet) - 1;
5677       break;
5678     case GTK_SHEET_NORMAL:
5679       sheet->state = GTK_SHEET_RANGE_SELECTED;
5680       r = sheet->active_cell.row;
5681       c = sheet->active_cell.col;
5682       sheet->range.col0 = c;
5683       sheet->range.row0 = r;
5684       sheet->range.coli = c;
5685       sheet->range.rowi = r;
5686       gdk_draw_pixmap (sheet->sheet_window,
5687                        GTK_WIDGET (sheet)->style->fg_gc[GTK_STATE_NORMAL],
5688                        sheet->pixmap,
5689                        COLUMN_LEFT_XPIXEL (sheet, c)- 1,
5690                        ROW_TOP_YPIXEL (sheet, r)- 1,
5691                        COLUMN_LEFT_XPIXEL (sheet, c)- 1,
5692                        ROW_TOP_YPIXEL (sheet, r)- 1,
5693                        xxx_column_width (sheet, c)+4,
5694                        yyy_row_height (sheet, r)+4);
5695       gtk_sheet_range_draw_selection (sheet, sheet->range);
5696     case GTK_SHEET_RANGE_SELECTED:
5697       sheet->state = GTK_SHEET_RANGE_SELECTED;
5698     }
5699
5700   sheet->selection_cell.row = row;
5701   sheet->selection_cell.col = column;
5702
5703   range.col0 = MIN (column, sheet->active_cell.col);
5704   range.coli = MAX (column, sheet->active_cell.col);
5705   range.row0 = MIN (row, sheet->active_cell.row);
5706   range.rowi = MAX (row, sheet->active_cell.row);
5707
5708   if (range.row0 != sheet->range.row0 || range.rowi != sheet->range.rowi ||
5709       range.col0 != sheet->range.col0 || range.coli != sheet->range.coli ||
5710       state == GTK_SHEET_NORMAL)
5711     gtk_sheet_real_select_range (sheet, &range);
5712
5713 }
5714
5715 static gint
5716 gtk_sheet_entry_key_press (GtkWidget *widget,
5717                            GdkEventKey *key)
5718 {
5719   gboolean focus;
5720   g_signal_emit_by_name (G_OBJECT (widget), "key_press_event", key, &focus);
5721   return focus;
5722 }
5723
5724 static gint
5725 gtk_sheet_key_press (GtkWidget *widget,
5726                      GdkEventKey *key)
5727 {
5728   GtkSheet *sheet;
5729   gint row, col;
5730   gint state;
5731   gboolean extend_selection = FALSE;
5732   gboolean force_move = FALSE;
5733   gboolean in_selection = FALSE;
5734   gboolean veto = TRUE;
5735   gint scroll = 1;
5736
5737   sheet = GTK_SHEET (widget);
5738
5739   if (key->state & GDK_CONTROL_MASK || key->keyval == GDK_Control_L ||
5740       key->keyval == GDK_Control_R) return FALSE;
5741
5742   extend_selection = (key->state & GDK_SHIFT_MASK) || key->keyval == GDK_Shift_L
5743     || key->keyval == GDK_Shift_R;
5744
5745   state = sheet->state;
5746   in_selection = GTK_SHEET_IN_SELECTION (sheet);
5747   GTK_SHEET_UNSET_FLAGS (sheet, GTK_SHEET_IN_SELECTION);
5748
5749   switch (key->keyval)
5750     {
5751     case GDK_Return: case GDK_KP_Enter:
5752       if (sheet->state == GTK_SHEET_NORMAL &&
5753           !GTK_SHEET_IN_SELECTION (sheet))
5754         g_signal_stop_emission_by_name (gtk_sheet_get_entry (sheet),
5755                                          "key-press-event");
5756       row = sheet->active_cell.row;
5757       col = sheet->active_cell.col;
5758       if (sheet->state == GTK_SHEET_COLUMN_SELECTED)
5759         row = MIN_VISIBLE_ROW (sheet)- 1;
5760       if (sheet->state == GTK_SHEET_ROW_SELECTED)
5761         col = MIN_VISIBLE_COLUMN (sheet);
5762       if (row < yyy_row_count (sheet) - 1)
5763         {
5764           row = row + scroll;
5765           while (!yyy_row_is_visible (sheet, row) && row < yyy_row_count (sheet)- 1)
5766             row++;
5767         }
5768       gtk_sheet_click_cell (sheet, row, col, &veto);
5769       extend_selection = FALSE;
5770       break;
5771     case GDK_ISO_Left_Tab:
5772       row = sheet->active_cell.row;
5773       col = sheet->active_cell.col;
5774       if (sheet->state == GTK_SHEET_ROW_SELECTED)
5775         col = MIN_VISIBLE_COLUMN (sheet)- 1;
5776       if (sheet->state == GTK_SHEET_COLUMN_SELECTED)
5777         row = MIN_VISIBLE_ROW (sheet);
5778       if (col > 0)
5779         {
5780           col = col - scroll;
5781           while (! xxx_column_is_visible (sheet, col) && col > 0) col--;
5782           col = MAX (0, col);
5783         }
5784       gtk_sheet_click_cell (sheet, row, col, &veto);
5785       extend_selection = FALSE;
5786       break;
5787     case GDK_Tab:
5788       row = sheet->active_cell.row;
5789       col = sheet->active_cell.col;
5790       if (sheet->state == GTK_SHEET_ROW_SELECTED)
5791         col = MIN_VISIBLE_COLUMN (sheet)- 1;
5792       if (sheet->state == GTK_SHEET_COLUMN_SELECTED)
5793         row = MIN_VISIBLE_ROW (sheet);
5794       if (col < xxx_column_count (sheet) - 1)
5795         {
5796           col = col + scroll;
5797           while (! xxx_column_is_visible (sheet, col) &&
5798                  col < xxx_column_count (sheet) - 1)
5799             col++;
5800         }
5801       gtk_sheet_click_cell (sheet, row, col, &veto);
5802       extend_selection = FALSE;
5803       break;
5804     case GDK_Page_Up:
5805       scroll = MAX_VISIBLE_ROW (sheet)- MIN_VISIBLE_ROW (sheet)+1;
5806     case GDK_Up:
5807       if (extend_selection)
5808         {
5809           if (state == GTK_STATE_NORMAL)
5810             {
5811               row = sheet->active_cell.row;
5812               col = sheet->active_cell.col;
5813               gtk_sheet_click_cell (sheet, row, col, &veto);
5814               if (!veto) break;
5815             }
5816           if (sheet->selection_cell.row > 0)
5817             {
5818               row = sheet->selection_cell.row - scroll;
5819               while (!yyy_row_is_visible (sheet, row) && row > 0) row--;
5820               row = MAX (0, row);
5821               gtk_sheet_extend_selection (sheet, row, sheet->selection_cell.col);
5822             }
5823           return TRUE;
5824         }
5825       col = sheet->active_cell.col;
5826       row = sheet->active_cell.row;
5827       if (state == GTK_SHEET_COLUMN_SELECTED)
5828         row = MIN_VISIBLE_ROW (sheet);
5829       if (state == GTK_SHEET_ROW_SELECTED)
5830         col = MIN_VISIBLE_COLUMN (sheet);
5831       row = row - scroll;
5832       while (!yyy_row_is_visible (sheet, row) && row > 0) row--;
5833       row = MAX (0, row);
5834       gtk_sheet_click_cell (sheet, row, col, &veto);
5835       extend_selection = FALSE;
5836       break;
5837     case GDK_Page_Down:
5838       scroll = MAX_VISIBLE_ROW (sheet)- MIN_VISIBLE_ROW (sheet)+1;
5839     case GDK_Down:
5840       if (extend_selection)
5841         {
5842           if (state == GTK_STATE_NORMAL)
5843             {
5844               row = sheet->active_cell.row;
5845               col = sheet->active_cell.col;
5846               gtk_sheet_click_cell (sheet, row, col, &veto);
5847               if (!veto) break;
5848             }
5849           if (sheet->selection_cell.row < yyy_row_count (sheet)- 1)
5850             {
5851               row = sheet->selection_cell.row + scroll;
5852               while (!yyy_row_is_visible (sheet, row) && row < yyy_row_count (sheet)- 1) row++;
5853               row = MIN (yyy_row_count (sheet)- 1, row);
5854               gtk_sheet_extend_selection (sheet, row, sheet->selection_cell.col);
5855             }
5856           return TRUE;
5857         }
5858       col = sheet->active_cell.col;
5859       row = sheet->active_cell.row;
5860       if (sheet->active_cell.row < yyy_row_count (sheet)- 1)
5861         {
5862           if (state == GTK_SHEET_COLUMN_SELECTED)
5863             row = MIN_VISIBLE_ROW (sheet)- 1;
5864           if (state == GTK_SHEET_ROW_SELECTED)
5865             col = MIN_VISIBLE_COLUMN (sheet);
5866           row = row + scroll;
5867           while (!yyy_row_is_visible (sheet, row) && row < yyy_row_count (sheet)- 1) row++;
5868           row = MIN (yyy_row_count (sheet)- 1, row);
5869         }
5870       gtk_sheet_click_cell (sheet, row, col, &veto);
5871       extend_selection = FALSE;
5872       break;
5873     case GDK_Right:
5874       if (extend_selection)
5875         {
5876           if (state == GTK_STATE_NORMAL)
5877             {
5878               row = sheet->active_cell.row;
5879               col = sheet->active_cell.col;
5880               gtk_sheet_click_cell (sheet, row, col, &veto);
5881               if (!veto) break;
5882             }
5883           if (sheet->selection_cell.col < xxx_column_count (sheet) - 1)
5884             {
5885               col = sheet->selection_cell.col + 1;
5886               while (! xxx_column_is_visible (sheet, col) && col < xxx_column_count (sheet) - 1)
5887                 col++;
5888               gtk_sheet_extend_selection (sheet, sheet->selection_cell.row, col);
5889             }
5890           return TRUE;
5891         }
5892       col = sheet->active_cell.col;
5893       row = sheet->active_cell.row;
5894       if (sheet->active_cell.col < xxx_column_count (sheet) - 1)
5895         {
5896           col ++;
5897           if (state == GTK_SHEET_ROW_SELECTED)
5898             col = MIN_VISIBLE_COLUMN (sheet)- 1;
5899           if (state == GTK_SHEET_COLUMN_SELECTED)
5900             row = MIN_VISIBLE_ROW (sheet);
5901           while (! xxx_column_is_visible (sheet, col) && col < xxx_column_count (sheet) - 1) col++;
5902           if (strlen (gtk_entry_get_text (GTK_ENTRY (gtk_sheet_get_entry (sheet)))) == 0
5903               || force_move)
5904             {
5905               gtk_sheet_click_cell (sheet, row, col, &veto);
5906             }
5907           else
5908             return FALSE;
5909         }
5910       extend_selection = FALSE;
5911       break;
5912     case GDK_Left:
5913       if (extend_selection)
5914         {
5915           if (state == GTK_STATE_NORMAL)
5916             {
5917               row = sheet->active_cell.row;
5918               col = sheet->active_cell.col;
5919               gtk_sheet_click_cell (sheet, row, col, &veto);
5920               if (!veto) break;
5921             }
5922           if (sheet->selection_cell.col > 0)
5923             {
5924               col = sheet->selection_cell.col - 1;
5925               while (! xxx_column_is_visible (sheet, col) && col > 0) col--;
5926               gtk_sheet_extend_selection (sheet, sheet->selection_cell.row, col);
5927             }
5928           return TRUE;
5929         }
5930       col = sheet->active_cell.col - 1;
5931       row = sheet->active_cell.row;
5932       if (state == GTK_SHEET_ROW_SELECTED)
5933         col = MIN_VISIBLE_COLUMN (sheet)- 1;
5934       if (state == GTK_SHEET_COLUMN_SELECTED)
5935         row = MIN_VISIBLE_ROW (sheet);
5936       while (! xxx_column_is_visible (sheet, col) && col > 0) col--;
5937       col = MAX (0, col);
5938
5939       if (strlen (gtk_entry_get_text (GTK_ENTRY (gtk_sheet_get_entry (sheet)))) == 0
5940           || force_move)
5941         {
5942           gtk_sheet_click_cell (sheet, row, col, &veto);
5943         }
5944       else
5945         return FALSE;
5946       extend_selection = FALSE;
5947       break;
5948     case GDK_Home:
5949       row = 0;
5950       while (!yyy_row_is_visible (sheet, row) && row < yyy_row_count (sheet)- 1) row++;
5951       gtk_sheet_click_cell (sheet, row, sheet->active_cell.col, &veto);
5952       extend_selection = FALSE;
5953       break;
5954     case GDK_End:
5955       row = yyy_row_count (sheet)- 1;
5956       while (!yyy_row_is_visible (sheet, row) && row > 0) row--;
5957       gtk_sheet_click_cell (sheet, row, sheet->active_cell.col, &veto);
5958       extend_selection = FALSE;
5959       break;
5960     default:
5961       if (in_selection)
5962         {
5963           GTK_SHEET_SET_FLAGS (sheet, GTK_SHEET_IN_SELECTION);
5964           if (extend_selection) return TRUE;
5965         }
5966       if (state == GTK_SHEET_ROW_SELECTED)
5967         sheet->active_cell.col = MIN_VISIBLE_COLUMN (sheet);
5968       if (state == GTK_SHEET_COLUMN_SELECTED)
5969         sheet->active_cell.row = MIN_VISIBLE_ROW (sheet);
5970       return FALSE;
5971     }
5972
5973   if (extend_selection) return TRUE;
5974
5975   gtk_sheet_activate_cell (sheet, sheet->active_cell.row,
5976                            sheet->active_cell.col);
5977
5978   return TRUE;
5979 }
5980
5981 static void
5982 gtk_sheet_size_request (GtkWidget * widget,
5983                         GtkRequisition * requisition)
5984 {
5985   GtkSheet *sheet;
5986   GList *children;
5987   GtkSheetChild *child;
5988   GtkRequisition child_requisition;
5989
5990   g_return_if_fail (widget != NULL);
5991   g_return_if_fail (GTK_IS_SHEET (widget));
5992   g_return_if_fail (requisition != NULL);
5993
5994   sheet = GTK_SHEET (widget);
5995
5996   requisition->width = 3*DEFAULT_COLUMN_WIDTH;
5997   requisition->height = 3*DEFAULT_ROW_HEIGHT (widget);
5998
5999   /* compute the size of the column title area */
6000   if (sheet->column_titles_visible)
6001     requisition->height += sheet->column_title_area.height;
6002
6003   /* compute the size of the row title area */
6004   if (sheet->row_titles_visible)
6005     requisition->width += sheet->row_title_area.width;
6006
6007   children = sheet->children;
6008   while (children)
6009     {
6010       child = children->data;
6011       children = children->next;
6012
6013       gtk_widget_size_request (child->widget, &child_requisition);
6014     }
6015 }
6016
6017
6018 static void
6019 gtk_sheet_size_allocate (GtkWidget * widget,
6020                          GtkAllocation * allocation)
6021 {
6022   GtkSheet *sheet;
6023   GtkAllocation sheet_allocation;
6024   gint border_width;
6025
6026   g_return_if_fail (widget != NULL);
6027   g_return_if_fail (GTK_IS_SHEET (widget));
6028   g_return_if_fail (allocation != NULL);
6029
6030   sheet = GTK_SHEET (widget);
6031   widget->allocation = *allocation;
6032   border_width = GTK_CONTAINER (widget)->border_width;
6033
6034   if (GTK_WIDGET_REALIZED (widget))
6035     gdk_window_move_resize (widget->window,
6036                             allocation->x + border_width,
6037                             allocation->y + border_width,
6038                             allocation->width - 2 * border_width,
6039                             allocation->height - 2 * border_width);
6040
6041   /* use internal allocation structure for all the math
6042    * because it's easier than always subtracting the container
6043    * border width */
6044   sheet->internal_allocation.x = 0;
6045   sheet->internal_allocation.y = 0;
6046   sheet->internal_allocation.width = allocation->width - 2 * border_width;
6047   sheet->internal_allocation.height = allocation->height - 2 * border_width;
6048
6049   sheet_allocation.x = 0;
6050   sheet_allocation.y = 0;
6051   sheet_allocation.width = allocation->width - 2 * border_width;
6052   sheet_allocation.height = allocation->height - 2 * border_width;
6053
6054   sheet->sheet_window_width = sheet_allocation.width;
6055   sheet->sheet_window_height = sheet_allocation.height;
6056
6057   if (GTK_WIDGET_REALIZED (widget))
6058     gdk_window_move_resize (sheet->sheet_window,
6059                             sheet_allocation.x,
6060                             sheet_allocation.y,
6061                             sheet_allocation.width,
6062                             sheet_allocation.height);
6063
6064   /* position the window which holds the column title buttons */
6065   sheet->column_title_area.x = 0;
6066   sheet->column_title_area.y = 0;
6067   if (sheet->row_titles_visible)
6068     sheet->column_title_area.x = sheet->row_title_area.width;
6069   sheet->column_title_area.width = sheet_allocation.width -
6070     sheet->column_title_area.x;
6071   if (GTK_WIDGET_REALIZED (widget) && sheet->column_titles_visible)
6072     gdk_window_move_resize (sheet->column_title_window,
6073                             sheet->column_title_area.x,
6074                             sheet->column_title_area.y,
6075                             sheet->column_title_area.width,
6076                             sheet->column_title_area.height);
6077
6078   sheet->sheet_window_width = sheet_allocation.width;
6079   sheet->sheet_window_height = sheet_allocation.height;
6080
6081   /* column button allocation */
6082   size_allocate_column_title_buttons (sheet);
6083
6084   /* position the window which holds the row title buttons */
6085   sheet->row_title_area.x = 0;
6086   sheet->row_title_area.y = 0;
6087   if (sheet->column_titles_visible)
6088     sheet->row_title_area.y = sheet->column_title_area.height;
6089   sheet->row_title_area.height = sheet_allocation.height -
6090     sheet->row_title_area.y;
6091
6092   if (GTK_WIDGET_REALIZED (widget) && sheet->row_titles_visible)
6093     gdk_window_move_resize (sheet->row_title_window,
6094                             sheet->row_title_area.x,
6095                             sheet->row_title_area.y,
6096                             sheet->row_title_area.width,
6097                             sheet->row_title_area.height);
6098
6099
6100   /* row button allocation */
6101   size_allocate_row_title_buttons (sheet);
6102   size_allocate_column_title_buttons (sheet);
6103
6104   /* re - scale backing pixmap */
6105   gtk_sheet_make_backing_pixmap (sheet, 0, 0);
6106   gtk_sheet_position_children (sheet);
6107
6108   /* set the scrollbars adjustments */
6109   adjust_scrollbars (sheet);
6110 }
6111
6112 static void
6113 size_allocate_column_title_buttons (GtkSheet * sheet)
6114 {
6115   gint i;
6116   gint x, width;
6117
6118   if (!sheet->column_titles_visible) return;
6119   if (!GTK_WIDGET_REALIZED (sheet))
6120     return;
6121
6122   width = sheet->sheet_window_width;
6123   x = 0;
6124
6125   if (sheet->row_titles_visible)
6126     {
6127       width -= sheet->row_title_area.width;
6128       x = sheet->row_title_area.width;
6129     }
6130
6131   if (sheet->column_title_area.width != width || sheet->column_title_area.x != x)
6132     {
6133       sheet->column_title_area.width = width;
6134       sheet->column_title_area.x = x;
6135       gdk_window_move_resize (sheet->column_title_window,
6136                               sheet->column_title_area.x,
6137                               sheet->column_title_area.y,
6138                               sheet->column_title_area.width,
6139                               sheet->column_title_area.height);
6140     }
6141
6142
6143   if (MAX_VISIBLE_COLUMN (sheet) == xxx_column_count (sheet) - 1)
6144     gdk_window_clear_area (sheet->column_title_window,
6145                            0, 0,
6146                            sheet->column_title_area.width,
6147                            sheet->column_title_area.height);
6148
6149   if (!GTK_WIDGET_DRAWABLE (sheet)) return;
6150
6151   for (i = MIN_VISIBLE_COLUMN (sheet); i <= MAX_VISIBLE_COLUMN (sheet); i++)
6152     gtk_sheet_column_title_button_draw (sheet, i);
6153 }
6154
6155 static void
6156 size_allocate_row_title_buttons (GtkSheet * sheet)
6157 {
6158   gint i;
6159   gint y, height;
6160
6161   if (!sheet->row_titles_visible) return;
6162   if (!GTK_WIDGET_REALIZED (sheet))
6163     return;
6164
6165   height = sheet->sheet_window_height;
6166   y = 0;
6167
6168   if (sheet->column_titles_visible)
6169     {
6170       height -= sheet->column_title_area.height;
6171       y = sheet->column_title_area.height;
6172     }
6173
6174   if (sheet->row_title_area.height != height || sheet->row_title_area.y != y)
6175     {
6176       sheet->row_title_area.y = y;
6177       sheet->row_title_area.height = height;
6178       gdk_window_move_resize (sheet->row_title_window,
6179                               sheet->row_title_area.x,
6180                               sheet->row_title_area.y,
6181                               sheet->row_title_area.width,
6182                               sheet->row_title_area.height);
6183     }
6184   if (MAX_VISIBLE_ROW (sheet) == yyy_row_count (sheet)- 1)
6185     gdk_window_clear_area (sheet->row_title_window,
6186                            0, 0,
6187                            sheet->row_title_area.width,
6188                            sheet->row_title_area.height);
6189
6190   if (!GTK_WIDGET_DRAWABLE (sheet)) return;
6191
6192   for (i = MIN_VISIBLE_ROW (sheet); i <= MAX_VISIBLE_ROW (sheet); i++)
6193     {
6194       if ( i >= yyy_row_count (sheet))
6195         break;
6196       gtk_sheet_row_title_button_draw (sheet, i);
6197     }
6198 }
6199
6200
6201 static void
6202 gtk_sheet_size_allocate_entry (GtkSheet *sheet)
6203 {
6204   GtkAllocation shentry_allocation;
6205   GtkSheetCellAttr attributes = { 0 };
6206   GtkEntry *sheet_entry;
6207   GtkStyle *style = NULL, *previous_style = NULL;
6208   gint row, col;
6209   gint size, max_size, text_size, column_width;
6210   const gchar *text;
6211
6212   if (!GTK_WIDGET_REALIZED (GTK_WIDGET (sheet))) return;
6213   if (!GTK_WIDGET_MAPPED (GTK_WIDGET (sheet))) return;
6214
6215   sheet_entry = GTK_ENTRY (gtk_sheet_get_entry (sheet));
6216
6217   if ( ! gtk_sheet_get_attributes (sheet, sheet->active_cell.row,
6218                                    sheet->active_cell.col,
6219                                    &attributes) )
6220     return ;
6221
6222   if ( GTK_WIDGET_REALIZED (sheet->sheet_entry) )
6223     {
6224       if (!GTK_WIDGET (sheet_entry)->style)
6225         gtk_widget_ensure_style (GTK_WIDGET (sheet_entry));
6226
6227       previous_style = GTK_WIDGET (sheet_entry)->style;
6228
6229       style = gtk_style_copy (previous_style);
6230       style->bg[GTK_STATE_NORMAL] = attributes.background;
6231       style->fg[GTK_STATE_NORMAL] = attributes.foreground;
6232       style->text[GTK_STATE_NORMAL] = attributes.foreground;
6233       style->bg[GTK_STATE_ACTIVE] = attributes.background;
6234       style->fg[GTK_STATE_ACTIVE] = attributes.foreground;
6235       style->text[GTK_STATE_ACTIVE] = attributes.foreground;
6236
6237       pango_font_description_free (style->font_desc);
6238       g_assert (attributes.font_desc);
6239       style->font_desc = pango_font_description_copy (attributes.font_desc);
6240
6241       GTK_WIDGET (sheet_entry)->style = style;
6242       gtk_widget_size_request (sheet->sheet_entry, NULL);
6243       GTK_WIDGET (sheet_entry)->style = previous_style;
6244
6245       if (style != previous_style)
6246         {
6247           if (!GTK_IS_ITEM_ENTRY (sheet->sheet_entry))
6248             {
6249               style->bg[GTK_STATE_NORMAL] = previous_style->bg[GTK_STATE_NORMAL];
6250               style->fg[GTK_STATE_NORMAL] = previous_style->fg[GTK_STATE_NORMAL];
6251               style->bg[GTK_STATE_ACTIVE] = previous_style->bg[GTK_STATE_ACTIVE];
6252               style->fg[GTK_STATE_ACTIVE] = previous_style->fg[GTK_STATE_ACTIVE];
6253             }
6254           gtk_widget_set_style (GTK_WIDGET (sheet_entry), style);
6255         }
6256     }
6257
6258   if (GTK_IS_ITEM_ENTRY (sheet_entry))
6259     max_size = GTK_ITEM_ENTRY (sheet_entry)->text_max_size;
6260   else
6261     max_size = 0;
6262
6263   text_size = 0;
6264   text = gtk_entry_get_text (GTK_ENTRY (sheet_entry));
6265   if (text && strlen (text) > 0)
6266     text_size = STRING_WIDTH (GTK_WIDGET (sheet), attributes.font_desc, text);
6267
6268   column_width = xxx_column_width (sheet, sheet->active_cell.col);
6269
6270   size = MIN (text_size, max_size);
6271   size = MAX (size, column_width - 2 * CELLOFFSET);
6272
6273   row = sheet->active_cell.row;
6274   col = sheet->active_cell.col;
6275
6276   shentry_allocation.x = COLUMN_LEFT_XPIXEL (sheet, sheet->active_cell.col);
6277   shentry_allocation.y = ROW_TOP_YPIXEL (sheet, sheet->active_cell.row);
6278   shentry_allocation.width = column_width;
6279   shentry_allocation.height = yyy_row_height (sheet, sheet->active_cell.row);
6280
6281   if (GTK_IS_ITEM_ENTRY (sheet->sheet_entry))
6282     {
6283       shentry_allocation.height -= 2 * CELLOFFSET;
6284       shentry_allocation.y += CELLOFFSET;
6285       shentry_allocation.width = size;
6286
6287       switch (GTK_ITEM_ENTRY (sheet_entry)->justification)
6288         {
6289         case GTK_JUSTIFY_CENTER:
6290           shentry_allocation.x += column_width / 2 - size / 2;
6291           break;
6292         case GTK_JUSTIFY_RIGHT:
6293           shentry_allocation.x += column_width - size - CELLOFFSET;
6294           break;
6295         case GTK_JUSTIFY_LEFT:
6296         case GTK_JUSTIFY_FILL:
6297           shentry_allocation.x += CELLOFFSET;
6298           break;
6299         }
6300     }
6301
6302   if (!GTK_IS_ITEM_ENTRY (sheet->sheet_entry))
6303     {
6304       shentry_allocation.x += 2;
6305       shentry_allocation.y += 2;
6306       shentry_allocation.width -= MIN (shentry_allocation.width, 3);
6307       shentry_allocation.height -= MIN (shentry_allocation.height, 3);
6308     }
6309
6310   gtk_widget_size_allocate (sheet->sheet_entry, &shentry_allocation);
6311
6312   if (previous_style == style) g_object_unref (previous_style);
6313 }
6314
6315 static void
6316 gtk_sheet_entry_set_max_size (GtkSheet *sheet)
6317 {
6318   gint i;
6319   gint size = 0;
6320   gint sizel = 0, sizer = 0;
6321   gint row, col;
6322   GtkJustification justification;
6323   gchar *s = NULL;
6324
6325   row = sheet->active_cell.row;
6326   col = sheet->active_cell.col;
6327
6328   if ( ! GTK_IS_ITEM_ENTRY (sheet->sheet_entry) )
6329     return;
6330
6331   justification = GTK_ITEM_ENTRY (sheet->sheet_entry)->justification;
6332
6333   switch (justification)
6334     {
6335     case GTK_JUSTIFY_FILL:
6336     case GTK_JUSTIFY_LEFT:
6337       for (i = col + 1; i <= MAX_VISIBLE_COLUMN (sheet); i++)
6338         {
6339           if ((s = gtk_sheet_cell_get_text (sheet, row, i)))
6340             {
6341               g_free (s);
6342               break;
6343             }
6344           size +=xxx_column_width (sheet, i);
6345         }
6346       size = MIN (size, sheet->sheet_window_width - COLUMN_LEFT_XPIXEL (sheet, col));
6347       break;
6348     case GTK_JUSTIFY_RIGHT:
6349       for (i = col - 1; i >= MIN_VISIBLE_COLUMN (sheet); i--)
6350         {
6351           if ((s = gtk_sheet_cell_get_text (sheet, row, i)))
6352             {
6353               g_free (s);
6354               break;
6355             }
6356           size +=xxx_column_width (sheet, i);
6357         }
6358       break;
6359     case GTK_JUSTIFY_CENTER:
6360       for (i = col + 1; i <= MAX_VISIBLE_COLUMN (sheet); i++)
6361         {
6362           sizer += xxx_column_width (sheet, i);
6363         }
6364       for (i = col - 1; i >= MIN_VISIBLE_COLUMN (sheet); i--)
6365         {
6366           if ((s = gtk_sheet_cell_get_text (sheet, row, i)))
6367             {
6368               g_free (s);
6369               break;
6370             }
6371           sizel +=xxx_column_width (sheet, i);
6372         }
6373       size = 2 * MIN (sizel, sizer);
6374       break;
6375     }
6376
6377   if (size != 0)
6378     size += xxx_column_width (sheet, col);
6379   GTK_ITEM_ENTRY (sheet->sheet_entry)->text_max_size = size;
6380 }
6381
6382
6383 static void
6384 create_sheet_entry (GtkSheet *sheet)
6385 {
6386   GtkWidget *widget;
6387   GtkWidget *parent;
6388   GtkWidget *entry;
6389   gint found_entry = FALSE;
6390
6391   widget = GTK_WIDGET (sheet);
6392
6393   if (sheet->sheet_entry)
6394     {
6395       /* avoids warnings */
6396       gtk_widget_ref (sheet->sheet_entry);
6397       gtk_widget_unparent (sheet->sheet_entry);
6398       gtk_widget_destroy (sheet->sheet_entry);
6399     }
6400
6401   if (sheet->entry_type)
6402     {
6403       if (!g_type_is_a (sheet->entry_type, GTK_TYPE_ENTRY))
6404         {
6405           parent = g_object_new (sheet->entry_type, NULL);
6406
6407           sheet->sheet_entry = parent;
6408
6409           entry = gtk_sheet_get_entry (sheet);
6410           if (GTK_IS_ENTRY (entry))
6411             found_entry = TRUE;
6412         }
6413       else
6414         {
6415           parent = g_object_new (sheet->entry_type, NULL);
6416           entry = parent;
6417           found_entry = TRUE;
6418         }
6419
6420       if (!found_entry)
6421         {
6422           g_warning ("Entry type must be GtkEntry subclass, using default");
6423           entry = gtk_item_entry_new ();
6424           sheet->sheet_entry = entry;
6425         }
6426       else
6427         sheet->sheet_entry = parent;
6428     }
6429   else
6430     {
6431       entry = gtk_item_entry_new ();
6432       sheet->sheet_entry = entry;
6433     }
6434
6435   gtk_widget_size_request (sheet->sheet_entry, NULL);
6436
6437   if (GTK_WIDGET_REALIZED (sheet))
6438     {
6439       gtk_widget_set_parent_window (sheet->sheet_entry, sheet->sheet_window);
6440       gtk_widget_set_parent (sheet->sheet_entry, GTK_WIDGET (sheet));
6441       gtk_widget_realize (sheet->sheet_entry);
6442     }
6443
6444   g_signal_connect_swapped (G_OBJECT (entry), "key_press_event",
6445                             G_CALLBACK (gtk_sheet_entry_key_press),
6446                             sheet);
6447
6448   gtk_widget_show (sheet->sheet_entry);
6449 }
6450
6451
6452 /* Finds the last child widget that happens to be of type GtkEntry */
6453 static void
6454 find_entry (GtkWidget *w, gpointer user_data)
6455 {
6456   GtkWidget **entry = user_data;
6457   if ( GTK_IS_ENTRY (w))
6458     {
6459       *entry = w;
6460     }
6461 }
6462
6463 GtkWidget *
6464 gtk_sheet_get_entry (GtkSheet *sheet)
6465 {
6466   GtkWidget *parent;
6467   GtkWidget *entry = NULL;
6468   GtkTableChild *table_child;
6469   GtkBoxChild *box_child;
6470   GList *children = NULL;
6471
6472   g_return_val_if_fail (sheet != NULL, NULL);
6473   g_return_val_if_fail (GTK_IS_SHEET (sheet), NULL);
6474   g_return_val_if_fail (sheet->sheet_entry != NULL, NULL);
6475
6476   if (GTK_IS_ENTRY (sheet->sheet_entry)) return (sheet->sheet_entry);
6477
6478   parent = GTK_WIDGET (sheet->sheet_entry);
6479
6480   if (GTK_IS_TABLE (parent)) children = GTK_TABLE (parent)->children;
6481   if (GTK_IS_BOX (parent)) children = GTK_BOX (parent)->children;
6482
6483   if (GTK_IS_CONTAINER (parent))
6484     {
6485       gtk_container_forall (GTK_CONTAINER (parent), find_entry, &entry);
6486
6487       if (GTK_IS_ENTRY (entry))
6488         return entry;
6489     }
6490
6491   if (!children) return NULL;
6492
6493   while (children)
6494     {
6495       if (GTK_IS_TABLE (parent))
6496         {
6497           table_child = children->data;
6498           entry = table_child->widget;
6499         }
6500       if (GTK_IS_BOX (parent))
6501         {
6502           box_child = children->data;
6503           entry = box_child->widget;
6504         }
6505
6506       if (GTK_IS_ENTRY (entry))
6507         break;
6508       children = children->next;
6509     }
6510
6511
6512   if (!GTK_IS_ENTRY (entry)) return NULL;
6513
6514   return (entry);
6515
6516 }
6517
6518 GtkWidget *
6519 gtk_sheet_get_entry_widget (GtkSheet *sheet)
6520 {
6521   g_return_val_if_fail (sheet != NULL, NULL);
6522   g_return_val_if_fail (GTK_IS_SHEET (sheet), NULL);
6523   g_return_val_if_fail (sheet->sheet_entry != NULL, NULL);
6524
6525   return (sheet->sheet_entry);
6526 }
6527
6528
6529 static void
6530 gtk_sheet_button_draw (GtkSheet *sheet, GdkWindow *window,
6531                        GtkSheetButton *button, gboolean is_sensitive,
6532                        GdkRectangle allocation)
6533 {
6534   GtkShadowType shadow_type;
6535   gint text_width = 0, text_height = 0;
6536   GtkSheetChild *child = NULL;
6537   PangoAlignment align = PANGO_ALIGN_LEFT;
6538
6539   gboolean rtl ;
6540
6541   gint state = 0;
6542   gint len = 0;
6543   gchar *line = 0;
6544
6545   g_return_if_fail (sheet != NULL);
6546   g_return_if_fail (button != NULL);
6547
6548   rtl = gtk_widget_get_direction (GTK_WIDGET (sheet)) == GTK_TEXT_DIR_RTL;
6549
6550   gdk_window_clear_area (window,
6551                          allocation.x, allocation.y,
6552                          allocation.width, allocation.height);
6553
6554   gtk_paint_box (sheet->button->style, window,
6555                  GTK_STATE_NORMAL, GTK_SHADOW_OUT,
6556                  &allocation, GTK_WIDGET (sheet->button),
6557                  "buttondefault",
6558                  allocation.x, allocation.y,
6559                  allocation.width, allocation.height);
6560
6561   state = button->state;
6562   if (!is_sensitive) state = GTK_STATE_INSENSITIVE;
6563
6564   if (state == GTK_STATE_ACTIVE)
6565     shadow_type = GTK_SHADOW_IN;
6566   else
6567     shadow_type = GTK_SHADOW_OUT;
6568
6569   if (state != GTK_STATE_NORMAL && state != GTK_STATE_INSENSITIVE)
6570     gtk_paint_box (sheet->button->style, window,
6571                    button->state, shadow_type,
6572                    &allocation, GTK_WIDGET (sheet->button),
6573                    "button",
6574                    allocation.x, allocation.y,
6575                    allocation.width, allocation.height);
6576
6577   if (button->label_visible)
6578     {
6579
6580       text_height = DEFAULT_ROW_HEIGHT (GTK_WIDGET (sheet))- 2 * CELLOFFSET;
6581
6582       gdk_gc_set_clip_rectangle (GTK_WIDGET (sheet)->style->fg_gc[button->state],
6583                                  &allocation);
6584       gdk_gc_set_clip_rectangle (GTK_WIDGET (sheet)->style->white_gc, &allocation);
6585
6586       allocation.y += 2 * sheet->button->style->ythickness;
6587
6588
6589       if (button->label && strlen (button->label)>0)
6590         {
6591           gchar *words = 0;
6592           PangoLayout *layout = NULL;
6593           gint real_x = allocation.x, real_y = allocation.y;
6594
6595           words = button->label;
6596           line = g_new (gchar, 1);
6597           line[0]='\0';
6598
6599           while (words && *words != '\0')
6600             {
6601               if (*words != '\n')
6602                 {
6603                   len = strlen (line);
6604                   line = g_realloc (line, len + 2);
6605                   line[len]=*words;
6606                   line[len + 1]='\0';
6607                 }
6608               if (*words == '\n' || * (words + 1) == '\0')
6609                 {
6610                   text_width = STRING_WIDTH (GTK_WIDGET (sheet), GTK_WIDGET (sheet)->style->font_desc, line);
6611
6612                   layout = gtk_widget_create_pango_layout (GTK_WIDGET (sheet), line);
6613                   switch (button->justification)
6614                     {
6615                     case GTK_JUSTIFY_LEFT:
6616                       real_x = allocation.x + CELLOFFSET;
6617                       align = rtl ? PANGO_ALIGN_RIGHT : PANGO_ALIGN_LEFT;
6618                       break;
6619                     case GTK_JUSTIFY_RIGHT:
6620                       real_x = allocation.x + allocation.width - text_width - CELLOFFSET;
6621                       align = rtl ? PANGO_ALIGN_LEFT : PANGO_ALIGN_RIGHT;
6622                       break;
6623                     case GTK_JUSTIFY_CENTER:
6624                     default:
6625                       real_x = allocation.x + (allocation.width - text_width)/2;
6626                       align = rtl ? PANGO_ALIGN_RIGHT : PANGO_ALIGN_LEFT;
6627                       pango_layout_set_justify (layout, TRUE);
6628                     }
6629                   pango_layout_set_alignment (layout, align);
6630                   gtk_paint_layout (GTK_WIDGET (sheet)->style,
6631                                     window,
6632                                     state,
6633                                     FALSE,
6634                                     &allocation,
6635                                     GTK_WIDGET (sheet),
6636                                     "label",
6637                                     real_x, real_y,
6638                                     layout);
6639                   g_object_unref (G_OBJECT (layout));
6640
6641                   real_y += text_height + 2;
6642
6643                   g_free (line);
6644                   line = g_new (gchar, 1);
6645                   line[0]='\0';
6646                 }
6647               words++;
6648             }
6649           g_free (line);
6650         }
6651
6652       gdk_gc_set_clip_rectangle (GTK_WIDGET (sheet)->style->fg_gc[button->state],
6653                                  NULL);
6654       gdk_gc_set_clip_rectangle (GTK_WIDGET (sheet)->style->white_gc, NULL);
6655
6656     }
6657
6658   if ((child = button->child) && (child->widget))
6659     {
6660       child->x = allocation.x;
6661       child->y = allocation.y;
6662
6663       child->x += (allocation.width - child->widget->requisition.width) / 2;
6664       child->y += (allocation.height - child->widget->requisition.height) / 2;
6665       allocation.x = child->x;
6666       allocation.y = child->y;
6667       allocation.width = child->widget->requisition.width;
6668       allocation.height = child->widget->requisition.height;
6669
6670       allocation.x = child->x;
6671       allocation.y = child->y;
6672
6673       gtk_widget_set_state (child->widget, button->state);
6674
6675       if (GTK_WIDGET_REALIZED (GTK_WIDGET (sheet)) &&
6676           GTK_WIDGET_MAPPED (child->widget))
6677         {
6678           gtk_widget_size_allocate (child->widget,
6679                                     &allocation);
6680           gtk_widget_queue_draw (child->widget);
6681         }
6682     }
6683
6684   gtk_sheet_button_free (button);
6685 }
6686
6687
6688 /* COLUMN value of - 1 indicates that the area to the right of the rightmost
6689    button should be redrawn */
6690 static void
6691 gtk_sheet_column_title_button_draw (GtkSheet *sheet, gint column)
6692 {
6693   GdkWindow *window = NULL;
6694   GdkRectangle allocation;
6695   GtkSheetButton *button = NULL;
6696   gboolean is_sensitive = FALSE;
6697
6698   if (!GTK_WIDGET_REALIZED (GTK_WIDGET (sheet))) return;
6699
6700   if (column >= 0 && ! xxx_column_is_visible (sheet, column)) return;
6701   if (column >= 0 && !sheet->column_titles_visible) return;
6702   if (column >= 0 && column < MIN_VISIBLE_COLUMN (sheet)) return;
6703   if (column >= 0 && column > MAX_VISIBLE_COLUMN (sheet)) return;
6704
6705   window = sheet->column_title_window;
6706   allocation.y = 0;
6707   allocation.height = sheet->column_title_area.height;
6708
6709   if ( column == -1 )
6710     {
6711       const gint cols = xxx_column_count (sheet) ;
6712       allocation.x = COLUMN_LEFT_XPIXEL (sheet, cols - 1)
6713         ;
6714       allocation.width = sheet->column_title_area.width
6715         + sheet->column_title_area.x
6716         - allocation.x;
6717
6718       gdk_window_clear_area (window,
6719                              allocation.x, allocation.y,
6720                              allocation.width, allocation.height);
6721     }
6722   else
6723     {
6724       button = xxx_column_button (sheet, column);
6725       allocation.x = COLUMN_LEFT_XPIXEL (sheet, column) + CELL_SPACING;
6726       if (sheet->row_titles_visible)
6727         allocation.x -= sheet->row_title_area.width;
6728
6729       allocation.width = xxx_column_width (sheet, column);
6730
6731       is_sensitive = xxx_column_is_sensitive (sheet, column);
6732       gtk_sheet_button_draw (sheet, window, button,
6733                              is_sensitive, allocation);
6734     }
6735 }
6736
6737 static void
6738 gtk_sheet_row_title_button_draw (GtkSheet *sheet, gint row)
6739 {
6740   GdkWindow *window = NULL;
6741   GdkRectangle allocation;
6742   GtkSheetButton *button = NULL;
6743   gboolean is_sensitive = FALSE;
6744
6745
6746   if (!GTK_WIDGET_REALIZED (GTK_WIDGET (sheet))) return;
6747
6748   if (row >= 0 && !yyy_row_is_visible (sheet, row)) return;
6749   if (row >= 0 && !sheet->row_titles_visible) return;
6750   if (row >= 0 && row < MIN_VISIBLE_ROW (sheet)) return;
6751   if (row >= 0 && row > MAX_VISIBLE_ROW (sheet)) return;
6752
6753
6754   window = sheet->row_title_window;
6755   button = yyy_row_button (sheet, row);
6756   allocation.x = 0;
6757   allocation.y = ROW_TOP_YPIXEL (sheet, row) + CELL_SPACING;
6758   if (sheet->column_titles_visible)
6759     allocation.y -= sheet->column_title_area.height;
6760   allocation.width = sheet->row_title_area.width;
6761   allocation.height = yyy_row_height (sheet, row);
6762   is_sensitive = yyy_row_is_sensitive (sheet, row);
6763
6764   gtk_sheet_button_draw (sheet, window, button, is_sensitive, allocation);
6765 }
6766
6767 /* SCROLLBARS
6768  *
6769  * functions:
6770  * adjust_scrollbars
6771  * vadjustment_value_changed
6772  * hadjustment_value_changed */
6773
6774 static void
6775 adjust_scrollbars (GtkSheet * sheet)
6776 {
6777   if (sheet->vadjustment)
6778     {
6779       sheet->vadjustment->page_size = sheet->sheet_window_height;
6780       sheet->vadjustment->page_increment = sheet->sheet_window_height / 2;
6781       sheet->vadjustment->step_increment = DEFAULT_ROW_HEIGHT (GTK_WIDGET (sheet));
6782       sheet->vadjustment->lower = 0;
6783       sheet->vadjustment->upper = SHEET_HEIGHT (sheet) + 80;
6784       g_signal_emit_by_name (G_OBJECT (sheet->vadjustment), "changed");
6785
6786     }
6787
6788   if (sheet->hadjustment)
6789     {
6790       sheet->hadjustment->page_size = sheet->sheet_window_width;
6791       sheet->hadjustment->page_increment = sheet->sheet_window_width / 2;
6792       sheet->hadjustment->step_increment = DEFAULT_COLUMN_WIDTH;
6793       sheet->hadjustment->lower = 0;
6794       sheet->hadjustment->upper = SHEET_WIDTH (sheet)+ 80;
6795       g_signal_emit_by_name (G_OBJECT (sheet->hadjustment), "changed");
6796
6797     }
6798 }
6799
6800 static void
6801 vadjustment_value_changed (GtkAdjustment * adjustment,
6802                            gpointer data)
6803 {
6804   GtkSheet *sheet;
6805   gint diff, value, old_value;
6806   gint row, new_row;
6807   gint y = 0;
6808
6809   g_return_if_fail (adjustment != NULL);
6810   g_return_if_fail (data != NULL);
6811   g_return_if_fail (GTK_IS_SHEET (data));
6812
6813   sheet = GTK_SHEET (data);
6814
6815   if (GTK_SHEET_IS_FROZEN (sheet)) return;
6816
6817   row = ROW_FROM_YPIXEL (sheet, sheet->column_title_area.height + CELL_SPACING);
6818   if (!sheet->column_titles_visible)
6819     row = ROW_FROM_YPIXEL (sheet, CELL_SPACING);
6820
6821   old_value = - sheet->voffset;
6822
6823   new_row = g_sheet_row_pixel_to_row (sheet->row_geometry,
6824                                       adjustment->value, sheet);
6825
6826   y = g_sheet_row_start_pixel (sheet->row_geometry, new_row, sheet);
6827
6828   if (adjustment->value > sheet->old_vadjustment && sheet->old_vadjustment > 0. &&
6829       yyy_row_height (sheet, row) > sheet->vadjustment->step_increment)
6830     {
6831       /* This avoids embarrassing twitching */
6832       if (row == new_row && row != yyy_row_count (sheet) - 1 &&
6833           adjustment->value - sheet->old_vadjustment >=
6834           sheet->vadjustment->step_increment &&
6835           new_row + 1 != MIN_VISIBLE_ROW (sheet))
6836         {
6837           new_row +=1;
6838           y = y+yyy_row_height (sheet, row);
6839         }
6840     }
6841
6842   /* Negative old_adjustment enforces the redraw, otherwise avoid
6843      spureous redraw */
6844   if (sheet->old_vadjustment >= 0. && row == new_row)
6845     {
6846       sheet->old_vadjustment = sheet->vadjustment->value;
6847       return;
6848     }
6849
6850   sheet->old_vadjustment = sheet->vadjustment->value;
6851   adjustment->value = y;
6852
6853
6854   if (new_row == 0)
6855     {
6856       sheet->vadjustment->step_increment = yyy_row_height (sheet, 0);
6857     }
6858   else
6859     {
6860       sheet->vadjustment->step_increment =
6861         MIN (yyy_row_height (sheet, new_row), yyy_row_height (sheet, new_row - 1));
6862     }
6863
6864   sheet->vadjustment->value = adjustment->value;
6865
6866   value = adjustment->value;
6867
6868   if (value >= - sheet->voffset)
6869     {
6870       /* scroll down */
6871       diff = value + sheet->voffset;
6872     }
6873   else
6874     {
6875       /* scroll up */
6876       diff = - sheet->voffset - value;
6877     }
6878
6879   sheet->voffset = - value;
6880
6881   if (GTK_WIDGET_REALIZED (sheet->sheet_entry) &&
6882       sheet->state == GTK_SHEET_NORMAL &&
6883       sheet->active_cell.row >= 0 && sheet->active_cell.col >= 0 &&
6884       !gtk_sheet_cell_isvisible (sheet, sheet->active_cell.row,
6885                                  sheet->active_cell.col))
6886     {
6887       const gchar *text;
6888
6889       text = gtk_entry_get_text (GTK_ENTRY (gtk_sheet_get_entry (sheet)));
6890
6891       if (!text || strlen (text) == 0)
6892         gtk_sheet_cell_clear (sheet,
6893                               sheet->active_cell.row,
6894                               sheet->active_cell.col);
6895       gtk_widget_unmap (sheet->sheet_entry);
6896     }
6897
6898   gtk_sheet_position_children (sheet);
6899
6900   gtk_sheet_range_draw (sheet, NULL);
6901   size_allocate_row_title_buttons (sheet);
6902   size_allocate_global_button (sheet);
6903 }
6904
6905 static void
6906 hadjustment_value_changed (GtkAdjustment * adjustment,
6907                            gpointer data)
6908 {
6909   GtkSheet *sheet;
6910   gint i, diff, value, old_value;
6911   gint column, new_column;
6912   gint x = 0;
6913
6914   g_return_if_fail (adjustment != NULL);
6915   g_return_if_fail (data != NULL);
6916   g_return_if_fail (GTK_IS_SHEET (data));
6917
6918   sheet = GTK_SHEET (data);
6919
6920   if (GTK_SHEET_IS_FROZEN (sheet)) return;
6921
6922   column = COLUMN_FROM_XPIXEL (sheet, sheet->row_title_area.width + CELL_SPACING);
6923   if (!sheet->row_titles_visible)
6924     column = COLUMN_FROM_XPIXEL (sheet, CELL_SPACING);
6925
6926   old_value = - sheet->hoffset;
6927
6928   for (i = 0; i < xxx_column_count (sheet); i++)
6929     {
6930       if (xxx_column_is_visible (sheet, i)) x += xxx_column_width (sheet, i);
6931       if (x > adjustment->value) break;
6932     }
6933   x -= xxx_column_width (sheet, i);
6934   new_column = i;
6935
6936   if (adjustment->value > sheet->old_hadjustment && sheet->old_hadjustment > 0 &&
6937       xxx_column_width (sheet, i) > sheet->hadjustment->step_increment)
6938     {
6939       /* This avoids embarrassing twitching */
6940       if (column == new_column && column != xxx_column_count (sheet) - 1 &&
6941           adjustment->value - sheet->old_hadjustment >=
6942           sheet->hadjustment->step_increment &&
6943           new_column + 1 != MIN_VISIBLE_COLUMN (sheet))
6944         {
6945           new_column += 1;
6946           x += xxx_column_width (sheet, column);
6947         }
6948     }
6949
6950   /* Negative old_adjustment enforces the redraw, otherwise avoid spureous redraw */
6951   if (sheet->old_hadjustment >= 0. && new_column == column)
6952     {
6953       sheet->old_hadjustment = sheet->hadjustment->value;
6954       return;
6955     }
6956
6957   sheet->old_hadjustment = sheet->hadjustment->value;
6958   adjustment->value = x;
6959
6960   if (new_column == 0)
6961     {
6962       sheet->hadjustment->step_increment = xxx_column_width (sheet, 0);
6963     }
6964   else
6965     {
6966       sheet->hadjustment->step_increment =
6967         MIN (xxx_column_width (sheet, new_column), xxx_column_width (sheet, new_column - 1));
6968     }
6969
6970
6971   sheet->hadjustment->value = adjustment->value;
6972
6973   value = adjustment->value;
6974
6975   if (value >= - sheet->hoffset)
6976     {
6977       /* scroll right */
6978       diff = value + sheet->hoffset;
6979     }
6980   else
6981     {
6982       /* scroll left */
6983       diff = - sheet->hoffset - value;
6984     }
6985
6986   sheet->hoffset = - value;
6987   if (GTK_WIDGET_REALIZED (sheet->sheet_entry) &&
6988       sheet->state == GTK_SHEET_NORMAL &&
6989       sheet->active_cell.row >= 0 && sheet->active_cell.col >= 0 &&
6990       !gtk_sheet_cell_isvisible (sheet, sheet->active_cell.row,
6991                                  sheet->active_cell.col))
6992     {
6993       const gchar *text;
6994
6995       text = gtk_entry_get_text (GTK_ENTRY (gtk_sheet_get_entry (sheet)));
6996       if (!text || strlen (text) == 0)
6997         gtk_sheet_cell_clear (sheet,
6998                               sheet->active_cell.row,
6999                               sheet->active_cell.col);
7000
7001       gtk_widget_unmap (sheet->sheet_entry);
7002     }
7003
7004   gtk_sheet_position_children (sheet);
7005
7006   gtk_sheet_range_draw (sheet, NULL);
7007   size_allocate_column_title_buttons (sheet);
7008 }
7009
7010
7011 /* COLUMN RESIZING */
7012 static void
7013 draw_xor_vline (GtkSheet * sheet)
7014 {
7015   GtkWidget *widget;
7016
7017   g_return_if_fail (sheet != NULL);
7018
7019   widget = GTK_WIDGET (sheet);
7020
7021   gdk_draw_line (widget->window, sheet->xor_gc,
7022                  sheet->x_drag,
7023                  sheet->column_title_area.height,
7024                  sheet->x_drag,
7025                  sheet->sheet_window_height + 1);
7026 }
7027
7028 /* ROW RESIZING */
7029 static void
7030 draw_xor_hline (GtkSheet * sheet)
7031 {
7032   GtkWidget *widget;
7033
7034   g_return_if_fail (sheet != NULL);
7035
7036   widget = GTK_WIDGET (sheet);
7037
7038   gdk_draw_line (widget->window, sheet->xor_gc,
7039                  sheet->row_title_area.width,
7040                  sheet->y_drag,
7041
7042                  sheet->sheet_window_width + 1,
7043                  sheet->y_drag);
7044 }
7045
7046 /* SELECTED RANGE */
7047 static void
7048 draw_xor_rectangle (GtkSheet *sheet, GtkSheetRange range)
7049 {
7050   gint i;
7051   GdkRectangle clip_area, area;
7052   GdkGCValues values;
7053
7054   area.x = COLUMN_LEFT_XPIXEL (sheet, range.col0);
7055   area.y = ROW_TOP_YPIXEL (sheet, range.row0);
7056   area.width = COLUMN_LEFT_XPIXEL (sheet, range.coli)- area.x+
7057     xxx_column_width (sheet, range.coli);
7058   area.height = ROW_TOP_YPIXEL (sheet, range.rowi)- area.y+
7059     yyy_row_height (sheet, range.rowi);
7060
7061   clip_area.x = sheet->row_title_area.width;
7062   clip_area.y = sheet->column_title_area.height;
7063   clip_area.width = sheet->sheet_window_width;
7064   clip_area.height = sheet->sheet_window_height;
7065
7066   if (!sheet->row_titles_visible) clip_area.x = 0;
7067   if (!sheet->column_titles_visible) clip_area.y = 0;
7068
7069   if (area.x < 0)
7070     {
7071       area.width = area.width + area.x;
7072       area.x = 0;
7073     }
7074   if (area.width > clip_area.width) area.width = clip_area.width + 10;
7075   if (area.y < 0)
7076     {
7077       area.height = area.height + area.y;
7078       area.y = 0;
7079     }
7080   if (area.height > clip_area.height) area.height = clip_area.height + 10;
7081
7082   clip_area.x--;
7083   clip_area.y--;
7084   clip_area.width += 3;
7085   clip_area.height += 3;
7086
7087   gdk_gc_get_values (sheet->xor_gc, &values);
7088
7089   gdk_gc_set_clip_rectangle (sheet->xor_gc, &clip_area);
7090
7091   for (i =- 1; i <= 1; ++i)
7092     gdk_draw_rectangle (sheet->sheet_window,
7093                         sheet->xor_gc,
7094                         FALSE,
7095                         area.x + i, area.y + i,
7096                         area.width - 2 * i, area.height - 2 * i);
7097
7098
7099   gdk_gc_set_clip_rectangle (sheet->xor_gc, NULL);
7100
7101   gdk_gc_set_foreground (sheet->xor_gc, &values.foreground);
7102
7103 }
7104
7105
7106 /* this function returns the new width of the column being resized given
7107  * the column and x position of the cursor; the x cursor position is passed
7108  * in as a pointer and automaticaly corrected if it's beyond min / max limits */
7109 static guint
7110 new_column_width (GtkSheet * sheet,
7111                   gint column,
7112                   gint * x)
7113 {
7114   gint cx, width;
7115   guint min_width;
7116
7117   cx = *x;
7118
7119   min_width = sheet->column_requisition;
7120
7121   /* you can't shrink a column to less than its minimum width */
7122   if (cx < COLUMN_LEFT_XPIXEL (sheet, column) + min_width)
7123     {
7124       *x = cx = COLUMN_LEFT_XPIXEL (sheet, column) + min_width;
7125     }
7126
7127   /* calculate new column width making sure it doesn't end up
7128    * less than the minimum width */
7129   width = cx - COLUMN_LEFT_XPIXEL (sheet, column);
7130   if (width < min_width)
7131     width = min_width;
7132
7133   xxx_set_column_width (sheet, column, width);
7134   size_allocate_column_title_buttons (sheet);
7135
7136   return width;
7137 }
7138
7139 /* this function returns the new height of the row being resized given
7140  * the row and y position of the cursor; the y cursor position is passed
7141  * in as a pointer and automaticaly corrected if it's beyond min / max limits */
7142 static guint
7143 new_row_height (GtkSheet * sheet,
7144                 gint row,
7145                 gint * y)
7146 {
7147   gint cy, height;
7148   guint min_height;
7149
7150   cy = *y;
7151   min_height = sheet->row_requisition;
7152
7153   /* you can't shrink a row to less than its minimum height */
7154   if (cy < ROW_TOP_YPIXEL (sheet, row) + min_height)
7155
7156     {
7157       *y = cy = ROW_TOP_YPIXEL (sheet, row) + min_height;
7158     }
7159
7160   /* calculate new row height making sure it doesn't end up
7161    * less than the minimum height */
7162   height = (cy - ROW_TOP_YPIXEL (sheet, row));
7163   if (height < min_height)
7164     height = min_height;
7165
7166   yyy_set_row_height (sheet, row, height);
7167   size_allocate_row_title_buttons (sheet);
7168
7169   return height;
7170 }
7171
7172 static void
7173 gtk_sheet_set_column_width (GtkSheet * sheet,
7174                             gint column,
7175                             guint width)
7176 {
7177   guint min_width;
7178
7179   g_return_if_fail (sheet != NULL);
7180   g_return_if_fail (GTK_IS_SHEET (sheet));
7181
7182   if (column < 0 || column >= xxx_column_count (sheet))
7183     return;
7184
7185   gtk_sheet_column_size_request (sheet, column, &min_width);
7186   if (width < min_width) return;
7187
7188   xxx_set_column_width (sheet, column, width);
7189
7190   if (GTK_WIDGET_REALIZED (GTK_WIDGET (sheet)) && !GTK_SHEET_IS_FROZEN (sheet))
7191     {
7192       size_allocate_column_title_buttons (sheet);
7193       adjust_scrollbars (sheet);
7194       gtk_sheet_size_allocate_entry (sheet);
7195       gtk_sheet_range_draw (sheet, NULL);
7196     }
7197
7198   g_signal_emit (G_OBJECT (sheet), sheet_signals[CHANGED], 0, -1, column);
7199   g_signal_emit (G_OBJECT (sheet), sheet_signals[NEW_COL_WIDTH], 0,
7200                  column, width);
7201 }
7202
7203
7204
7205 void
7206 gtk_sheet_set_row_height (GtkSheet * sheet,
7207                           gint row,
7208                           guint height)
7209 {
7210   guint min_height;
7211
7212   g_return_if_fail (sheet != NULL);
7213   g_return_if_fail (GTK_IS_SHEET (sheet));
7214
7215   if (row < 0 || row >= yyy_row_count (sheet))
7216     return;
7217
7218   gtk_sheet_row_size_request (sheet, row, &min_height);
7219   if (height < min_height) return;
7220
7221   yyy_set_row_height (sheet, row, height);
7222
7223   if (GTK_WIDGET_REALIZED (GTK_WIDGET (sheet)) && !GTK_SHEET_IS_FROZEN (sheet))
7224     {
7225       size_allocate_row_title_buttons (sheet);
7226       adjust_scrollbars (sheet);
7227       gtk_sheet_size_allocate_entry (sheet);
7228       gtk_sheet_range_draw (sheet, NULL);
7229     }
7230
7231   g_signal_emit (G_OBJECT (sheet), sheet_signals[CHANGED], 0, row, - 1);
7232   g_signal_emit (G_OBJECT (sheet), sheet_signals[NEW_ROW_HEIGHT], 0,
7233                  row, height);
7234
7235 }
7236
7237
7238 gboolean
7239 gtk_sheet_get_attributes (const GtkSheet *sheet, gint row, gint col,
7240                           GtkSheetCellAttr *attributes)
7241 {
7242   const GdkColor *fg, *bg;
7243   const GtkJustification *j ;
7244   const PangoFontDescription *font_desc ;
7245   const GtkSheetCellBorder *border ;
7246
7247   g_return_val_if_fail (sheet != NULL, FALSE);
7248   g_return_val_if_fail (GTK_IS_SHEET (sheet), FALSE);
7249
7250   if (row < 0 || col < 0) return FALSE;
7251
7252   init_attributes (sheet, col, attributes);
7253
7254   if ( !sheet->model)
7255     return FALSE;
7256
7257   attributes->is_editable = g_sheet_model_is_editable (sheet->model, row, col);
7258   attributes->is_visible = g_sheet_model_is_visible (sheet->model, row, col);
7259
7260   fg = g_sheet_model_get_foreground (sheet->model, row, col);
7261   if ( fg )
7262     attributes->foreground = *fg;
7263
7264   bg = g_sheet_model_get_background (sheet->model, row, col);
7265   if ( bg )
7266     attributes->background = *bg;
7267
7268   j = g_sheet_model_get_justification (sheet->model, row, col);
7269   if (j) attributes->justification = *j;
7270
7271   font_desc = g_sheet_model_get_font_desc (sheet->model, row, col);
7272   if ( font_desc ) attributes->font_desc = font_desc;
7273
7274   border = g_sheet_model_get_cell_border (sheet->model, row, col);
7275
7276   if ( border ) attributes->border = *border;
7277
7278   return TRUE;
7279 }
7280
7281 static void
7282 init_attributes (const GtkSheet *sheet, gint col, GtkSheetCellAttr *attributes)
7283 {
7284   /* DEFAULT VALUES */
7285   attributes->foreground = GTK_WIDGET (sheet)->style->black;
7286   attributes->background = sheet->bg_color;
7287   if (!GTK_WIDGET_REALIZED (GTK_WIDGET (sheet)))
7288     {
7289       GdkColormap *colormap;
7290       colormap = gdk_colormap_get_system ();
7291       gdk_color_black (colormap, &attributes->foreground);
7292       attributes->background = sheet->bg_color;
7293     }
7294   attributes->justification = xxx_column_justification (sheet, col);
7295   attributes->border.width = 0;
7296   attributes->border.line_style = GDK_LINE_SOLID;
7297   attributes->border.cap_style = GDK_CAP_NOT_LAST;
7298   attributes->border.join_style = GDK_JOIN_MITER;
7299   attributes->border.mask = 0;
7300   attributes->border.color = GTK_WIDGET (sheet)->style->black;
7301   attributes->is_editable = TRUE;
7302   attributes->is_visible = TRUE;
7303   attributes->font_desc = GTK_WIDGET (sheet)->style->font_desc;
7304 }
7305
7306
7307 /********************************************************************
7308  * Container Functions:
7309  * gtk_sheet_add
7310  * gtk_sheet_put
7311  * gtk_sheet_attach
7312  * gtk_sheet_remove
7313  * gtk_sheet_move_child
7314  * gtk_sheet_position_child
7315  * gtk_sheet_position_children
7316  * gtk_sheet_realize_child
7317  * gtk_sheet_get_child_at
7318  ********************************************************************/
7319
7320 GtkSheetChild *
7321 gtk_sheet_put (GtkSheet *sheet, GtkWidget *child, gint x, gint y)
7322 {
7323   GtkRequisition child_requisition;
7324   GtkSheetChild *child_info;
7325
7326   g_return_val_if_fail (sheet != NULL, NULL);
7327   g_return_val_if_fail (GTK_IS_SHEET (sheet), NULL);
7328   g_return_val_if_fail (child != NULL, NULL);
7329   g_return_val_if_fail (child->parent == NULL, NULL);
7330
7331   child_info = g_new (GtkSheetChild, 1);
7332   child_info->widget = child;
7333   child_info->x = x;
7334   child_info->y = y;
7335   child_info->attached_to_cell = FALSE;
7336   child_info->floating = TRUE;
7337   child_info->xpadding = child_info->ypadding = 0;
7338   child_info->xexpand = child_info->yexpand = FALSE;
7339   child_info->xshrink = child_info->yshrink = FALSE;
7340   child_info->xfill = child_info->yfill = FALSE;
7341
7342   sheet->children = g_list_append (sheet->children, child_info);
7343
7344   gtk_widget_set_parent (child, GTK_WIDGET (sheet));
7345
7346   gtk_widget_size_request (child, &child_requisition);
7347
7348   if (GTK_WIDGET_VISIBLE (GTK_WIDGET (sheet)))
7349     {
7350       if (GTK_WIDGET_REALIZED (GTK_WIDGET (sheet)) &&
7351           (!GTK_WIDGET_REALIZED (child) || GTK_WIDGET_NO_WINDOW (child)))
7352         gtk_sheet_realize_child (sheet, child_info);
7353
7354       if (GTK_WIDGET_MAPPED (GTK_WIDGET (sheet)) &&
7355           !GTK_WIDGET_MAPPED (child))
7356         gtk_widget_map (child);
7357     }
7358
7359   gtk_sheet_position_child (sheet, child_info);
7360
7361   /* This will avoid drawing on the titles */
7362
7363   if (GTK_WIDGET_REALIZED (GTK_WIDGET (sheet)))
7364     {
7365       if (sheet->row_titles_visible)
7366         gdk_window_show (sheet->row_title_window);
7367       if (sheet->column_titles_visible)
7368         gdk_window_show (sheet->column_title_window);
7369     }
7370
7371   return (child_info);
7372 }
7373
7374 void
7375 gtk_sheet_attach_floating (GtkSheet *sheet,
7376                            GtkWidget *widget,
7377                            gint row, gint col)
7378 {
7379   GdkRectangle area;
7380   GtkSheetChild *child;
7381
7382   if (row < 0 || col < 0)
7383     {
7384       gtk_sheet_button_attach (sheet, widget, row, col);
7385       return;
7386     }
7387
7388   gtk_sheet_get_cell_area (sheet, row, col, &area);
7389   child = gtk_sheet_put (sheet, widget, area.x, area.y);
7390   child->attached_to_cell = TRUE;
7391   child->row = row;
7392   child->col = col;
7393 }
7394
7395 void
7396 gtk_sheet_attach_default (GtkSheet *sheet,
7397                           GtkWidget *widget,
7398                           gint row, gint col)
7399 {
7400   if (row < 0 || col < 0)
7401     {
7402       gtk_sheet_button_attach (sheet, widget, row, col);
7403       return;
7404     }
7405
7406   gtk_sheet_attach (sheet, widget, row, col,
7407                     GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
7408 }
7409
7410 void
7411 gtk_sheet_attach (GtkSheet *sheet,
7412                   GtkWidget *widget,
7413                   gint row, gint col,
7414                   gint xoptions,
7415                   gint yoptions,
7416                   gint xpadding,
7417                   gint ypadding)
7418 {
7419   GdkRectangle area;
7420   GtkSheetChild *child = NULL;
7421
7422   if (row < 0 || col < 0)
7423     {
7424       gtk_sheet_button_attach (sheet, widget, row, col);
7425       return;
7426     }
7427
7428   child = g_new0 (GtkSheetChild, 1);
7429   child->attached_to_cell = TRUE;
7430   child->floating = FALSE;
7431   child->widget = widget;
7432   child->row = row;
7433   child->col = col;
7434   child->xpadding = xpadding;
7435   child->ypadding = ypadding;
7436   child->xexpand = (xoptions & GTK_EXPAND) != 0;
7437   child->yexpand = (yoptions & GTK_EXPAND) != 0;
7438   child->xshrink = (xoptions & GTK_SHRINK) != 0;
7439   child->yshrink = (yoptions & GTK_SHRINK) != 0;
7440   child->xfill = (xoptions & GTK_FILL) != 0;
7441   child->yfill = (yoptions & GTK_FILL) != 0;
7442
7443   sheet->children = g_list_append (sheet->children, child);
7444
7445   gtk_sheet_get_cell_area (sheet, row, col, &area);
7446
7447   child->x = area.x + child->xpadding;
7448   child->y = area.y + child->ypadding;
7449
7450   if (GTK_WIDGET_VISIBLE (GTK_WIDGET (sheet)))
7451     {
7452       if (GTK_WIDGET_REALIZED (GTK_WIDGET (sheet)) &&
7453           (!GTK_WIDGET_REALIZED (widget) || GTK_WIDGET_NO_WINDOW (widget)))
7454         gtk_sheet_realize_child (sheet, child);
7455
7456       if (GTK_WIDGET_MAPPED (GTK_WIDGET (sheet)) &&
7457           !GTK_WIDGET_MAPPED (widget))
7458         gtk_widget_map (widget);
7459     }
7460
7461   gtk_sheet_position_child (sheet, child);
7462
7463   /* This will avoid drawing on the titles */
7464
7465   if (GTK_WIDGET_REALIZED (GTK_WIDGET (sheet)))
7466     {
7467       if (GTK_SHEET_ROW_TITLES_VISIBLE (sheet))
7468         gdk_window_show (sheet->row_title_window);
7469       if (GTK_SHEET_COL_TITLES_VISIBLE (sheet))
7470         gdk_window_show (sheet->column_title_window);
7471     }
7472
7473 }
7474
7475 void
7476 gtk_sheet_button_attach          (GtkSheet *sheet,
7477                                   GtkWidget *widget,
7478                                   gint row, gint col)
7479 {
7480   GtkSheetButton *button = 0;
7481   GtkSheetChild *child;
7482   GtkRequisition button_requisition;
7483
7484   if (row >= 0 && col >= 0) return;
7485   if (row < 0 && col < 0) return;
7486
7487   child = g_new (GtkSheetChild, 1);
7488   child->widget = widget;
7489   child->x = 0;
7490   child->y = 0;
7491   child->attached_to_cell = TRUE;
7492   child->floating = FALSE;
7493   child->row = row;
7494   child->col = col;
7495   child->xpadding = child->ypadding = 0;
7496   child->xshrink = child->yshrink = FALSE;
7497   child->xfill = child->yfill = FALSE;
7498
7499
7500   sheet->children = g_list_append (sheet->children, child);
7501
7502   gtk_sheet_button_size_request (sheet, button, &button_requisition);
7503
7504
7505   if (GTK_WIDGET_VISIBLE (GTK_WIDGET (sheet)))
7506     {
7507       if (GTK_WIDGET_REALIZED (GTK_WIDGET (sheet)) &&
7508           (!GTK_WIDGET_REALIZED (widget) || GTK_WIDGET_NO_WINDOW (widget)))
7509         gtk_sheet_realize_child (sheet, child);
7510
7511       if (GTK_WIDGET_MAPPED (GTK_WIDGET (sheet)) &&
7512           !GTK_WIDGET_MAPPED (widget))
7513         gtk_widget_map (widget);
7514     }
7515
7516   if (row == -1) size_allocate_column_title_buttons (sheet);
7517   if (col == -1) size_allocate_row_title_buttons (sheet);
7518
7519 }
7520
7521 static void
7522 label_size_request (GtkSheet *sheet, gchar *label, GtkRequisition *req)
7523 {
7524   gchar *words;
7525   gchar word[1000];
7526   gint n = 0;
7527   gint row_height = DEFAULT_ROW_HEIGHT (GTK_WIDGET (sheet)) - 2 * CELLOFFSET + 2;
7528
7529   req->height = 0;
7530   req->width = 0;
7531   words = label;
7532
7533   while (words && *words != '\0')
7534     {
7535       if (*words == '\n' || * (words + 1) == '\0')
7536         {
7537           req->height += row_height;
7538
7539           word[n] = '\0';
7540           req->width = MAX (req->width, STRING_WIDTH (GTK_WIDGET (sheet), GTK_WIDGET (sheet)->style->font_desc, word));
7541           n = 0;
7542         }
7543       else
7544         {
7545           word[n++] = *words;
7546         }
7547       words++;
7548     }
7549
7550   if (n > 0) req->height -= 2;
7551 }
7552
7553 static void
7554 gtk_sheet_button_size_request    (GtkSheet *sheet,
7555                                   const GtkSheetButton *button,
7556                                   GtkRequisition *button_requisition)
7557 {
7558   GtkRequisition requisition;
7559   GtkRequisition label_requisition;
7560
7561   if (gtk_sheet_autoresize (sheet) && button->label && strlen (button->label) > 0)
7562     {
7563       label_size_request (sheet, button->label, &label_requisition);
7564       label_requisition.width += 2 * CELLOFFSET;
7565       label_requisition.height += 2 * CELLOFFSET;
7566     }
7567   else
7568     {
7569       label_requisition.height = DEFAULT_ROW_HEIGHT (GTK_WIDGET (sheet));
7570       label_requisition.width = COLUMN_MIN_WIDTH;
7571     }
7572
7573   if (button->child)
7574     {
7575       gtk_widget_size_request (button->child->widget, &requisition);
7576       requisition.width += 2 * button->child->xpadding;
7577       requisition.height += 2 * button->child->ypadding;
7578       requisition.width += 2 * sheet->button->style->xthickness;
7579       requisition.height += 2 * sheet->button->style->ythickness;
7580     }
7581   else
7582     {
7583       requisition.height = DEFAULT_ROW_HEIGHT (GTK_WIDGET (sheet));
7584       requisition.width = COLUMN_MIN_WIDTH;
7585     }
7586
7587   *button_requisition = requisition;
7588   button_requisition->width = MAX (requisition.width, label_requisition.width);
7589   button_requisition->height = MAX (requisition.height, label_requisition.height);
7590
7591 }
7592
7593 static void
7594 gtk_sheet_row_size_request (GtkSheet *sheet,
7595                             gint row,
7596                             guint *requisition)
7597 {
7598   GtkRequisition button_requisition;
7599   GList *children;
7600
7601   gtk_sheet_button_size_request (sheet,
7602                                  yyy_row_button (sheet, row),
7603                                  &button_requisition);
7604
7605   *requisition = button_requisition.height;
7606
7607   children = sheet->children;
7608   while (children)
7609     {
7610       GtkSheetChild *child = (GtkSheetChild *)children->data;
7611       GtkRequisition child_requisition;
7612
7613       if (child->attached_to_cell && child->row == row && child->col != -1 && !child->floating && !child->yshrink)
7614         {
7615           gtk_widget_get_child_requisition (child->widget, &child_requisition);
7616
7617           if (child_requisition.height + 2 * child->ypadding > *requisition)
7618             *requisition = child_requisition.height + 2 * child->ypadding;
7619         }
7620       children = children->next;
7621     }
7622
7623   sheet->row_requisition = * requisition;
7624 }
7625
7626 static void
7627 gtk_sheet_column_size_request (GtkSheet *sheet,
7628                                gint col,
7629                                guint *requisition)
7630 {
7631   GtkRequisition button_requisition;
7632   GList *children;
7633
7634   gtk_sheet_button_size_request (sheet,
7635                                  xxx_column_button (sheet, col),
7636                                  &button_requisition);
7637
7638   *requisition = button_requisition.width;
7639
7640   children = sheet->children;
7641   while (children)
7642     {
7643       GtkSheetChild *child = (GtkSheetChild *)children->data;
7644       GtkRequisition child_requisition;
7645
7646       if (child->attached_to_cell && child->col == col && child->row != -1 && !child->floating && !child->xshrink)
7647         {
7648           gtk_widget_get_child_requisition (child->widget, &child_requisition);
7649
7650           if (child_requisition.width + 2 * child->xpadding > *requisition)
7651             *requisition = child_requisition.width + 2 * child->xpadding;
7652         }
7653       children = children->next;
7654     }
7655
7656   sheet->column_requisition = *requisition;
7657 }
7658
7659 void
7660 gtk_sheet_move_child (GtkSheet *sheet, GtkWidget *widget, gint x, gint y)
7661 {
7662   GtkSheetChild *child;
7663   GList *children;
7664
7665   g_return_if_fail (sheet != NULL);
7666   g_return_if_fail (GTK_IS_SHEET (sheet));
7667
7668   children = sheet->children;
7669   while (children)
7670     {
7671       child = children->data;
7672
7673       if (child->widget == widget)
7674         {
7675           child->x = x;
7676           child->y = y;
7677           child->row = ROW_FROM_YPIXEL (sheet, y);
7678           child->col = COLUMN_FROM_XPIXEL (sheet, x);
7679           gtk_sheet_position_child (sheet, child);
7680           return;
7681         }
7682
7683       children = children->next;
7684     }
7685
7686   g_warning ("Widget must be a GtkSheet child");
7687
7688 }
7689
7690 static void
7691 gtk_sheet_position_child (GtkSheet *sheet, GtkSheetChild *child)
7692 {
7693   GtkRequisition child_requisition;
7694   GtkAllocation child_allocation;
7695   gint xoffset = 0;
7696   gint yoffset = 0;
7697   gint x = 0, y = 0;
7698   GdkRectangle area;
7699
7700   gtk_widget_get_child_requisition (child->widget, &child_requisition);
7701
7702   if (sheet->column_titles_visible)
7703     yoffset = sheet->column_title_area.height;
7704
7705   if (sheet->row_titles_visible)
7706     xoffset = sheet->row_title_area.width;
7707
7708   if (child->attached_to_cell)
7709     {
7710       gtk_sheet_get_cell_area (sheet, child->row, child->col, &area);
7711       child->x = area.x + child->xpadding;
7712       child->y = area.y + child->ypadding;
7713
7714       if (!child->floating)
7715         {
7716           if (child_requisition.width + 2 * child->xpadding <= xxx_column_width (sheet, child->col))
7717             {
7718               if (child->xfill)
7719                 {
7720                   child_requisition.width = child_allocation.width = xxx_column_width (sheet, child->col) - 2 * child->xpadding;
7721                 }
7722               else
7723                 {
7724                   if (child->xexpand)
7725                     {
7726                       child->x = area.x + xxx_column_width (sheet, child->col) / 2 -
7727                         child_requisition.width / 2;
7728                     }
7729                   child_allocation.width = child_requisition.width;
7730                 }
7731             }
7732           else
7733             {
7734               if (!child->xshrink)
7735                 {
7736                   gtk_sheet_set_column_width (sheet, child->col, child_requisition.width + 2 * child->xpadding);
7737                 }
7738               child_allocation.width = xxx_column_width (sheet, child->col) - 2 * child->xpadding;
7739             }
7740
7741           if (child_requisition.height +
7742               2 * child->ypadding <= yyy_row_height (sheet, child->row))
7743             {
7744               if (child->yfill)
7745                 {
7746                   child_requisition.height = child_allocation.height =
7747                     yyy_row_height (sheet, child->row) - 2 * child->ypadding;
7748                 }
7749               else
7750                 {
7751                   if (child->yexpand)
7752                     {
7753                       child->y = area.y + yyy_row_height (sheet, child->row) / 2
7754                         - child_requisition.height / 2;
7755                     }
7756                   child_allocation.height = child_requisition.height;
7757                 }
7758             }
7759           else
7760             {
7761               if (!child->yshrink)
7762                 {
7763                   gtk_sheet_set_row_height (sheet, child->row, child_requisition.height + 2 * child->ypadding);
7764                 }
7765               child_allocation.height = yyy_row_height (sheet, child->row) -
7766                 2 * child->ypadding;
7767             }
7768         }
7769       else
7770         {
7771           child_allocation.width = child_requisition.width;
7772           child_allocation.height = child_requisition.height;
7773         }
7774
7775       x = child_allocation.x = child->x + xoffset;
7776       y = child_allocation.y = child->y + yoffset;
7777     }
7778   else
7779     {
7780       x = child_allocation.x = child->x + sheet->hoffset + xoffset;
7781       x = child_allocation.x = child->x + xoffset;
7782       y = child_allocation.y = child->y + sheet->voffset + yoffset;
7783       y = child_allocation.y = child->y + yoffset;
7784       child_allocation.width = child_requisition.width;
7785       child_allocation.height = child_requisition.height;
7786     }
7787
7788   gtk_widget_size_allocate (child->widget, &child_allocation);
7789   gtk_widget_queue_draw (child->widget);
7790 }
7791
7792 static void
7793 gtk_sheet_forall (GtkContainer *container,
7794                   gboolean include_internals,
7795                   GtkCallback callback,
7796                   gpointer callback_data)
7797 {
7798   GtkSheet *sheet;
7799   GtkSheetChild *child;
7800   GList *children;
7801
7802   g_return_if_fail (GTK_IS_SHEET (container));
7803   g_return_if_fail (callback != NULL);
7804
7805   sheet = GTK_SHEET (container);
7806   children = sheet->children;
7807   while (children)
7808     {
7809       child = children->data;
7810       children = children->next;
7811
7812       (* callback) (child->widget, callback_data);
7813     }
7814   if (sheet->button)
7815     (* callback) (sheet->button, callback_data);
7816   if (sheet->sheet_entry)
7817     (* callback) (sheet->sheet_entry, callback_data);
7818 }
7819
7820
7821 static void
7822 gtk_sheet_position_children (GtkSheet *sheet)
7823 {
7824   GList *children;
7825   GtkSheetChild *child;
7826
7827   children = sheet->children;
7828
7829   while (children)
7830     {
7831       child = (GtkSheetChild *)children->data;
7832
7833       if (child->col != -1 && child->row != -1)
7834         gtk_sheet_position_child (sheet, child);
7835
7836       if (child->row == -1)
7837         {
7838           if (child->col < MIN_VISIBLE_COLUMN (sheet) ||
7839               child->col > MAX_VISIBLE_COLUMN (sheet))
7840             gtk_sheet_child_hide (child);
7841           else
7842             gtk_sheet_child_show (child);
7843         }
7844       if (child->col == -1)
7845         {
7846           if (child->row < MIN_VISIBLE_ROW (sheet) ||
7847               child->row > MAX_VISIBLE_ROW (sheet))
7848             gtk_sheet_child_hide (child);
7849           else
7850             gtk_sheet_child_show (child);
7851         }
7852
7853       children = children->next;
7854     }
7855 }
7856
7857 static void
7858 gtk_sheet_remove (GtkContainer *container, GtkWidget *widget)
7859 {
7860   GtkSheet *sheet;
7861   GList *children;
7862   GtkSheetChild *child = 0;
7863
7864   g_return_if_fail (container != NULL);
7865   g_return_if_fail (GTK_IS_SHEET (container));
7866
7867   sheet = GTK_SHEET (container);
7868
7869   children = sheet->children;
7870
7871   while (children)
7872     {
7873       child = (GtkSheetChild *)children->data;
7874
7875       if (child->widget == widget) break;
7876
7877       children = children->next;
7878     }
7879
7880   if (children)
7881     {
7882       gtk_widget_unparent (widget);
7883       child->widget = NULL;
7884
7885       sheet->children = g_list_remove_link (sheet->children, children);
7886       g_list_free_1 (children);
7887       g_free (child);
7888     }
7889
7890 }
7891
7892 static void
7893 gtk_sheet_realize_child (GtkSheet *sheet, GtkSheetChild *child)
7894 {
7895   GtkWidget *widget;
7896
7897   widget = GTK_WIDGET (sheet);
7898
7899   if (GTK_WIDGET_REALIZED (widget))
7900     {
7901       if (child->row == -1)
7902         gtk_widget_set_parent_window (child->widget, sheet->column_title_window);
7903       else if (child->col == -1)
7904         gtk_widget_set_parent_window (child->widget, sheet->row_title_window);
7905       else
7906         gtk_widget_set_parent_window (child->widget, sheet->sheet_window);
7907     }
7908
7909   gtk_widget_set_parent (child->widget, widget);
7910 }
7911
7912
7913
7914 GtkSheetChild *
7915 gtk_sheet_get_child_at (GtkSheet *sheet, gint row, gint col)
7916 {
7917   GList *children;
7918   GtkSheetChild *child = 0;
7919
7920   g_return_val_if_fail (sheet != NULL, NULL);
7921   g_return_val_if_fail (GTK_IS_SHEET (sheet), NULL);
7922
7923   children = sheet->children;
7924
7925   while (children)
7926     {
7927       child = (GtkSheetChild *)children->data;
7928
7929       if (child->attached_to_cell)
7930         if (child->row == row && child->col == col) break;
7931
7932       children = children->next;
7933     }
7934
7935   if (children) return child;
7936
7937   return NULL;
7938 }
7939
7940 static void
7941 gtk_sheet_child_hide (GtkSheetChild *child)
7942 {
7943   g_return_if_fail (child != NULL);
7944   gtk_widget_hide (child->widget);
7945 }
7946
7947 static void
7948 gtk_sheet_child_show (GtkSheetChild *child)
7949 {
7950   g_return_if_fail (child != NULL);
7951
7952   gtk_widget_show (child->widget);
7953 }
7954
7955 GSheetModel *
7956 gtk_sheet_get_model (const GtkSheet *sheet)
7957 {
7958   g_return_val_if_fail (GTK_IS_SHEET (sheet), NULL);
7959
7960   return sheet->model;
7961 }
7962
7963
7964 GtkSheetButton *
7965 gtk_sheet_button_new (void)
7966 {
7967   GtkSheetButton *button = g_malloc (sizeof (GtkSheetButton));
7968
7969   button->state = GTK_STATE_NORMAL;
7970   button->label = NULL;
7971   button->label_visible = TRUE;
7972   button->child = NULL;
7973   button->justification = GTK_JUSTIFY_FILL;
7974
7975   return button;
7976 }
7977
7978
7979 inline void
7980 gtk_sheet_button_free (GtkSheetButton *button)
7981 {
7982   if (!button) return ;
7983
7984   g_free (button->label);
7985   g_free (button);
7986 }
7987
7988
7989 static GString *
7990 range_to_text (const GtkSheet *sheet)
7991 {
7992   gchar *celltext = NULL;
7993   gint r, c;
7994   GString *string;
7995
7996   if ( !gtk_sheet_range_isvisible (sheet, sheet->range))
7997     return NULL;
7998
7999   string = g_string_sized_new (80);
8000
8001   for (r = sheet->range.row0; r <= sheet->range.rowi; ++r)
8002     {
8003       for (c = sheet->range.col0; c < sheet->range.coli; ++c)
8004         {
8005           celltext = gtk_sheet_cell_get_text (sheet, r, c);
8006           g_string_append (string, celltext);
8007           g_string_append (string, "\t");
8008           g_free (celltext);
8009         }
8010       celltext = gtk_sheet_cell_get_text (sheet, r, c);
8011       g_string_append (string, celltext);
8012       if ( r < sheet->range.rowi)
8013         g_string_append (string, "\n");
8014       g_free (celltext);
8015     }
8016
8017   return string;
8018 }
8019
8020 static GString *
8021 range_to_html (const GtkSheet *sheet)
8022 {
8023   gchar *celltext = NULL;
8024   gint r, c;
8025   GString *string;
8026
8027   if ( !gtk_sheet_range_isvisible (sheet, sheet->range))
8028     return NULL;
8029
8030   string = g_string_sized_new (480);
8031
8032   g_string_append (string, "<html>\n");
8033   g_string_append (string, "<body>\n");
8034   g_string_append (string, "<table>\n");
8035   for (r = sheet->range.row0; r <= sheet->range.rowi; ++r)
8036     {
8037       g_string_append (string, "<tr>\n");
8038       for (c = sheet->range.col0; c <= sheet->range.coli; ++c)
8039         {
8040           g_string_append (string, "<td>");
8041           celltext = gtk_sheet_cell_get_text (sheet, r, c);
8042           g_string_append (string, celltext);
8043           g_string_append (string, "</td>\n");
8044           g_free (celltext);
8045         }
8046       g_string_append (string, "</tr>\n");
8047     }
8048   g_string_append (string, "</table>\n");
8049   g_string_append (string, "</body>\n");
8050   g_string_append (string, "</html>\n");
8051
8052   return string;
8053 }
8054
8055 enum {
8056   SELECT_FMT_NULL,
8057   SELECT_FMT_TEXT,
8058   SELECT_FMT_HTML
8059 };
8060
8061 static void
8062 primary_get_cb (GtkClipboard     *clipboard,
8063                 GtkSelectionData *selection_data,
8064                 guint             info,
8065                 gpointer          data)
8066 {
8067   GtkSheet *sheet = GTK_SHEET (data);
8068   GString *string = NULL;
8069
8070   switch (info)
8071   {
8072   case SELECT_FMT_TEXT:
8073     string = range_to_text (sheet);
8074     break;
8075   case SELECT_FMT_HTML:
8076     string = range_to_html (sheet);
8077     break;
8078   default:
8079     g_assert_not_reached ();
8080   }
8081
8082   gtk_selection_data_set (selection_data, selection_data->target,
8083                           8,
8084                           (const guchar *) string->str, string->len);
8085   g_string_free (string, TRUE);
8086 }
8087
8088 static void
8089 primary_clear_cb (GtkClipboard *clipboard,
8090                   gpointer      data)
8091 {
8092   GtkSheet *sheet = GTK_SHEET (data);
8093   gtk_sheet_real_unselect_range (sheet, NULL);
8094 }
8095
8096 static void
8097 gtk_sheet_update_primary_selection (GtkSheet *sheet)
8098 {
8099   static const GtkTargetEntry targets[] = {
8100     { "UTF8_STRING",   0, SELECT_FMT_TEXT },
8101     { "STRING",        0, SELECT_FMT_TEXT },
8102     { "TEXT",          0, SELECT_FMT_TEXT },
8103     { "COMPOUND_TEXT", 0, SELECT_FMT_TEXT },
8104     { "text/plain;charset=utf-8", 0, SELECT_FMT_TEXT },
8105     { "text/plain",    0, SELECT_FMT_TEXT },
8106     { "text/html",     0, SELECT_FMT_HTML }
8107   };
8108
8109   GtkClipboard *clipboard;
8110
8111   if (!GTK_WIDGET_REALIZED (sheet))
8112     return;
8113
8114   clipboard = gtk_widget_get_clipboard (GTK_WIDGET (sheet),
8115                                         GDK_SELECTION_PRIMARY);
8116
8117   if (gtk_sheet_range_isvisible (sheet, sheet->range))
8118     {
8119       if (!gtk_clipboard_set_with_owner (clipboard, targets,
8120                                          G_N_ELEMENTS (targets),
8121                                          primary_get_cb, primary_clear_cb,
8122                                          G_OBJECT (sheet)))
8123         primary_clear_cb (clipboard, sheet);
8124     }
8125   else
8126     {
8127       if (gtk_clipboard_get_owner (clipboard) == G_OBJECT (sheet))
8128         gtk_clipboard_clear (clipboard);
8129     }
8130 }
8131