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   /* _gtkextra_signal_emit (GTK_OBJECT (sheet),sheet_signals[ACTIVATE], row, col, &veto);
3900      if (!GTK_WIDGET_REALIZED (GTK_WIDGET (sheet))) return veto;
3901   */
3902
3903   if (!veto) return FALSE;
3904   if (sheet->state != GTK_SHEET_NORMAL)
3905     {
3906       sheet->state = GTK_SHEET_NORMAL;
3907       gtk_sheet_real_unselect_range (sheet, NULL);
3908     }
3909
3910   sheet->range.row0 = row;
3911   sheet->range.col0 = col;
3912   sheet->range.rowi = row;
3913   sheet->range.coli = col;
3914   sheet->active_cell.row = row;
3915   sheet->active_cell.col = col;
3916   sheet->selection_cell.row = row;
3917   sheet->selection_cell.col = col;
3918
3919   GTK_SHEET_UNSET_FLAGS (sheet, GTK_SHEET_IN_SELECTION);
3920
3921   gtk_sheet_show_active_cell (sheet);
3922
3923
3924   g_signal_connect (G_OBJECT (gtk_sheet_get_entry (sheet)),
3925                     "changed",
3926                     G_CALLBACK (gtk_sheet_entry_changed),
3927                     sheet);
3928
3929   _gtkextra_signal_emit (GTK_OBJECT (sheet),sheet_signals[ACTIVATE], row, col, &veto);
3930
3931   return TRUE;
3932 }
3933
3934 static void
3935 gtk_sheet_show_active_cell (GtkSheet *sheet)
3936 {
3937   GtkEntry *sheet_entry;
3938   GtkSheetCellAttr attributes;
3939   gchar *text = NULL;
3940   const gchar *old_text;
3941   GtkJustification justification;
3942   gint row, col;
3943
3944   g_return_if_fail (sheet != NULL);
3945   g_return_if_fail (GTK_IS_SHEET (sheet));
3946
3947   row = sheet->active_cell.row;
3948   col = sheet->active_cell.col;
3949
3950   /* Don't show the active cell, if there is no active cell: */
3951   if (! (row >= 0 && col >= 0)) /* e.g row or coll == -1. */
3952     return;
3953
3954   if (!GTK_WIDGET_REALIZED (GTK_WIDGET (sheet))) return;
3955   if (sheet->state != GTK_SHEET_NORMAL) return;
3956   if (GTK_SHEET_IN_SELECTION (sheet)) return;
3957
3958   GTK_WIDGET_SET_FLAGS (GTK_WIDGET (sheet->sheet_entry), GTK_VISIBLE);
3959
3960   sheet_entry = GTK_ENTRY (gtk_sheet_get_entry (sheet));
3961
3962   gtk_sheet_get_attributes (sheet, row, col, &attributes);
3963
3964   justification = GTK_JUSTIFY_LEFT;
3965
3966   if (gtk_sheet_justify_entry (sheet))
3967     justification = attributes.justification;
3968
3969   text = gtk_sheet_cell_get_text (sheet, row, col);
3970   if ( ! text )
3971     text = g_strdup ("");
3972
3973   gtk_entry_set_visibility (GTK_ENTRY (sheet_entry), attributes.is_visible);
3974
3975   if (gtk_sheet_locked (sheet) || !attributes.is_editable)
3976     gtk_editable_set_editable (GTK_EDITABLE (sheet_entry), FALSE);
3977   else
3978     gtk_editable_set_editable (GTK_EDITABLE (sheet_entry), TRUE);
3979
3980   /*** Added by John Gotts. Mar 25, 2005 *********/
3981   old_text = gtk_entry_get_text (GTK_ENTRY (sheet_entry));
3982   if (strcmp (old_text, text) != 0)
3983     {
3984       if (!GTK_IS_ITEM_ENTRY (sheet_entry))
3985         gtk_entry_set_text (GTK_ENTRY (sheet_entry), text);
3986       else
3987         gtk_item_entry_set_text (GTK_ITEM_ENTRY (sheet_entry), text, justification);
3988     }
3989
3990   gtk_sheet_entry_set_max_size (sheet);
3991   gtk_sheet_size_allocate_entry (sheet);
3992
3993   gtk_widget_map (sheet->sheet_entry);
3994
3995   gtk_widget_grab_focus (GTK_WIDGET (sheet_entry));
3996
3997   dispose_string (sheet, text);
3998 }
3999
4000 static void
4001 gtk_sheet_draw_active_cell (GtkSheet *sheet)
4002 {
4003   gint row, col;
4004
4005   if (!GTK_WIDGET_DRAWABLE (GTK_WIDGET (sheet))) return;
4006   if (!GTK_WIDGET_REALIZED (GTK_WIDGET (sheet))) return;
4007
4008   row = sheet->active_cell.row;
4009   col = sheet->active_cell.col;
4010
4011   if (row < 0 || col < 0) return;
4012
4013   if (!gtk_sheet_cell_isvisible (sheet, row, col)) return;
4014
4015   gtk_sheet_draw_border (sheet, 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         }
5014
5015       if (gtk_sheet_autoscroll (sheet))
5016         gtk_sheet_move_query (sheet, row, column);
5017       sheet->active_cell.row = row;
5018       sheet->active_cell.col = column;
5019       sheet->selection_cell.row = row;
5020       sheet->selection_cell.col = column;
5021       sheet->range.row0 = row;
5022       sheet->range.col0 = column;
5023       sheet->range.rowi = row;
5024       sheet->range.coli = column;
5025       sheet->state = GTK_SHEET_NORMAL;
5026       GTK_SHEET_SET_FLAGS (sheet, GTK_SHEET_IN_SELECTION);
5027       gtk_sheet_draw_active_cell (sheet);
5028       return;
5029     }
5030
5031   g_assert_not_reached ();
5032   gtk_sheet_activate_cell (sheet, sheet->active_cell.row,
5033                            sheet->active_cell.col);
5034 }
5035
5036 static gint
5037 gtk_sheet_button_release (GtkWidget * widget,
5038                           GdkEventButton * event)
5039 {
5040   GtkSheet *sheet;
5041   gint x,y;
5042
5043   sheet = GTK_SHEET (widget);
5044
5045   /* release on resize windows */
5046   if (GTK_SHEET_IN_XDRAG (sheet))
5047     {
5048       GTK_SHEET_UNSET_FLAGS (sheet, GTK_SHEET_IN_XDRAG);
5049       GTK_SHEET_UNSET_FLAGS (sheet, GTK_SHEET_IN_SELECTION);
5050       gtk_widget_get_pointer (widget, &x, NULL);
5051       gdk_pointer_ungrab (event->time);
5052       draw_xor_vline (sheet);
5053
5054       gtk_sheet_set_column_width (sheet, sheet->drag_cell.col,
5055                                   new_column_width (sheet, sheet->drag_cell.col, &x));
5056       sheet->old_hadjustment = -1.;
5057       g_signal_emit_by_name (G_OBJECT (sheet->hadjustment), "value_changed");
5058       return TRUE;
5059     }
5060
5061   if (GTK_SHEET_IN_YDRAG (sheet))
5062     {
5063       GTK_SHEET_UNSET_FLAGS (sheet, GTK_SHEET_IN_YDRAG);
5064       GTK_SHEET_UNSET_FLAGS (sheet, GTK_SHEET_IN_SELECTION);
5065       gtk_widget_get_pointer (widget, NULL, &y);
5066       gdk_pointer_ungrab (event->time);
5067       draw_xor_hline (sheet);
5068
5069       gtk_sheet_set_row_height (sheet, sheet->drag_cell.row, new_row_height (sheet, sheet->drag_cell.row, &y));
5070       sheet->old_vadjustment = -1.;
5071       g_signal_emit_by_name (G_OBJECT (sheet->vadjustment), "value_changed");
5072       return TRUE;
5073     }
5074
5075
5076   if (GTK_SHEET_IN_DRAG (sheet))
5077     {
5078       GtkSheetRange old_range;
5079       draw_xor_rectangle (sheet, sheet->drag_range);
5080       GTK_SHEET_UNSET_FLAGS (sheet, GTK_SHEET_IN_DRAG);
5081       gdk_pointer_ungrab (event->time);
5082
5083       gtk_sheet_real_unselect_range (sheet, NULL);
5084
5085       sheet->active_cell.row = sheet->active_cell.row +
5086         (sheet->drag_range.row0 - sheet->range.row0);
5087       sheet->active_cell.col = sheet->active_cell.col +
5088         (sheet->drag_range.col0 - sheet->range.col0);
5089       sheet->selection_cell.row = sheet->selection_cell.row +
5090         (sheet->drag_range.row0 - sheet->range.row0);
5091       sheet->selection_cell.col = sheet->selection_cell.col +
5092         (sheet->drag_range.col0 - sheet->range.col0);
5093       old_range = sheet->range;
5094       sheet->range = sheet->drag_range;
5095       sheet->drag_range = old_range;
5096       g_signal_emit (G_OBJECT (sheet), sheet_signals[MOVE_RANGE], 0,
5097                      &sheet->drag_range, &sheet->range);
5098       gtk_sheet_select_range (sheet, &sheet->range);
5099     }
5100
5101   if (GTK_SHEET_IN_RESIZE (sheet))
5102     {
5103       GtkSheetRange old_range;
5104       draw_xor_rectangle (sheet, sheet->drag_range);
5105       GTK_SHEET_UNSET_FLAGS (sheet, GTK_SHEET_IN_RESIZE);
5106       gdk_pointer_ungrab (event->time);
5107
5108       gtk_sheet_real_unselect_range (sheet, NULL);
5109
5110       sheet->active_cell.row = sheet->active_cell.row +
5111         (sheet->drag_range.row0 - sheet->range.row0);
5112       sheet->active_cell.col = sheet->active_cell.col +
5113         (sheet->drag_range.col0 - sheet->range.col0);
5114       if (sheet->drag_range.row0 < sheet->range.row0)
5115         sheet->selection_cell.row = sheet->drag_range.row0;
5116       if (sheet->drag_range.rowi >= sheet->range.rowi)
5117         sheet->selection_cell.row = sheet->drag_range.rowi;
5118       if (sheet->drag_range.col0 < sheet->range.col0)
5119         sheet->selection_cell.col = sheet->drag_range.col0;
5120       if (sheet->drag_range.coli >= sheet->range.coli)
5121         sheet->selection_cell.col = sheet->drag_range.coli;
5122       old_range = sheet->range;
5123       sheet->range = sheet->drag_range;
5124       sheet->drag_range = old_range;
5125
5126       if (sheet->state == GTK_STATE_NORMAL) sheet->state = GTK_SHEET_RANGE_SELECTED;
5127       g_signal_emit (G_OBJECT (sheet), sheet_signals[RESIZE_RANGE], 0,
5128                      &sheet->drag_range, &sheet->range);
5129       gtk_sheet_select_range (sheet, &sheet->range);
5130     }
5131
5132   if (sheet->state == GTK_SHEET_NORMAL && GTK_SHEET_IN_SELECTION (sheet))
5133     {
5134       GTK_SHEET_UNSET_FLAGS (sheet, GTK_SHEET_IN_SELECTION);
5135       gdk_pointer_ungrab (event->time);
5136       gtk_sheet_activate_cell (sheet, sheet->active_cell.row,
5137                                sheet->active_cell.col);
5138     }
5139
5140   if (GTK_SHEET_IN_SELECTION)
5141     gdk_pointer_ungrab (event->time);
5142   gtk_grab_remove (GTK_WIDGET (sheet));
5143
5144   GTK_SHEET_UNSET_FLAGS (sheet, GTK_SHEET_IN_SELECTION);
5145
5146   return TRUE;
5147 }
5148
5149 /* Shamelessly lifted from gtktooltips */
5150 static gboolean
5151 gtk_sheet_subtitle_paint_window (GtkWidget *tip_window)
5152 {
5153   GtkRequisition req;
5154
5155   gtk_widget_size_request (tip_window, &req);
5156   gtk_paint_flat_box (tip_window->style, tip_window->window,
5157                       GTK_STATE_NORMAL, GTK_SHADOW_OUT,
5158                       NULL, GTK_WIDGET(tip_window), "tooltip",
5159                       0, 0, req.width, req.height);
5160
5161   return FALSE;
5162 }
5163
5164 static GtkSheetHoverTitle *
5165 create_hover_window (void)
5166 {
5167   GtkSheetHoverTitle *hw = malloc (sizeof (*hw));
5168
5169   hw->window = gtk_window_new (GTK_WINDOW_POPUP);
5170
5171 #if GTK_CHECK_VERSION (2, 9, 0)
5172   gtk_window_set_type_hint (GTK_WINDOW (hw->window),
5173                             GDK_WINDOW_TYPE_HINT_TOOLTIP);
5174 #endif
5175
5176   gtk_widget_set_app_paintable (hw->window, TRUE);
5177   gtk_window_set_resizable (GTK_WINDOW (hw->window), FALSE);
5178   gtk_widget_set_name (hw->window, "gtk-tooltips");
5179   gtk_container_set_border_width (GTK_CONTAINER (hw->window), 4);
5180
5181   g_signal_connect (hw->window,
5182                     "expose_event",
5183                     G_CALLBACK (gtk_sheet_subtitle_paint_window),
5184                     NULL);
5185
5186   hw->label = gtk_label_new (NULL);
5187
5188
5189   gtk_label_set_line_wrap (GTK_LABEL (hw->label), TRUE);
5190   gtk_misc_set_alignment (GTK_MISC (hw->label), 0.5, 0.5);
5191
5192   gtk_container_add (GTK_CONTAINER (hw->window), hw->label);
5193
5194   gtk_widget_show (hw->label);
5195
5196   g_signal_connect (hw->window,
5197                     "destroy",
5198                     G_CALLBACK (gtk_widget_destroyed),
5199                     &hw->window);
5200
5201   return hw;
5202 }
5203
5204 #define HOVER_WINDOW_Y_OFFSET 2
5205
5206 static void
5207 show_subtitle (GtkSheet *sheet, gint row, gint column, const gchar *subtitle)
5208 {
5209   gint x, y;
5210   gint px, py;
5211   gint width;
5212
5213   if ( ! subtitle )
5214     return;
5215
5216   if ( ! sheet->hover_window)
5217     {
5218       sheet->hover_window = create_hover_window ();
5219       gtk_widget_add_events (GTK_WIDGET (sheet), GDK_LEAVE_NOTIFY_MASK);
5220
5221       g_signal_connect_swapped (sheet, "leave-notify-event",
5222                                 G_CALLBACK (gtk_widget_hide),
5223                                 sheet->hover_window->window);
5224     }
5225
5226   gtk_label_set_text (GTK_LABEL (sheet->hover_window->label),
5227                       subtitle);
5228
5229
5230   sheet->hover_window->row = row;
5231   sheet->hover_window->column = column;
5232
5233   gdk_window_get_origin (GTK_WIDGET (sheet)->window, &x, &y);
5234
5235   gtk_widget_get_pointer (GTK_WIDGET (sheet), &px, &py);
5236
5237   gtk_widget_show (sheet->hover_window->window);
5238
5239   width = GTK_WIDGET (sheet->hover_window->label)->allocation.width;
5240
5241   if (row == -1 )
5242     {
5243       x += px;
5244       x -= width / 2;
5245       y += sheet->column_title_area.y;
5246       y += sheet->column_title_area.height;
5247       y += HOVER_WINDOW_Y_OFFSET;
5248     }
5249
5250   if ( column == -1 )
5251     {
5252       y += py;
5253       x += sheet->row_title_area.x;
5254       x += sheet->row_title_area.width * 2 / 3.0;
5255     }
5256
5257   gtk_window_move (GTK_WINDOW (sheet->hover_window->window),
5258                    x, y);
5259 }
5260
5261 static gboolean
5262 motion_timeout_callback (gpointer data)
5263 {
5264   GtkSheet *sheet = GTK_SHEET (data);
5265   gint x, y;
5266   gint row, column;
5267   gtk_widget_get_pointer (GTK_WIDGET (sheet), &x, &y);
5268
5269   if ( gtk_sheet_get_pixel_info (sheet, x, y, &row, &column) )
5270     {
5271       if ( column == -1 && row == -1 )
5272         return FALSE;
5273
5274       if ( column == -1)
5275         {
5276           GSheetRow *row_geo = sheet->row_geometry;
5277           gchar *text;
5278
5279           text = g_sheet_row_get_subtitle (row_geo, row);
5280
5281           show_subtitle (sheet, row, column, text);
5282           g_free (text);
5283         }
5284
5285       if ( row == -1)
5286         {
5287           GSheetColumn *col_geo = sheet->column_geometry;
5288           gchar *text;
5289
5290           text = g_sheet_column_get_subtitle (col_geo, column);
5291
5292           show_subtitle (sheet, row, column, text );
5293
5294           g_free (text);
5295         }
5296     }
5297
5298   return FALSE;
5299 }
5300
5301 static gint
5302 gtk_sheet_motion (GtkWidget * widget,
5303                   GdkEventMotion * event)
5304 {
5305   GtkSheet *sheet;
5306   GdkModifierType mods;
5307   GdkCursorType new_cursor;
5308   gint x, y;
5309   gint row, column;
5310
5311   g_return_val_if_fail (widget != NULL, FALSE);
5312   g_return_val_if_fail (GTK_IS_SHEET (widget), FALSE);
5313   g_return_val_if_fail (event != NULL, FALSE);
5314
5315   sheet = GTK_SHEET (widget);
5316
5317   /* selections on the sheet */
5318   x = event->x;
5319   y = event->y;
5320
5321   if (!sheet->hover_window || ! GTK_WIDGET_VISIBLE (sheet->hover_window->window))
5322     {
5323       if ( sheet->motion_timer > 0 )
5324         g_source_remove (sheet->motion_timer);
5325       sheet->motion_timer = g_timeout_add (TIMEOUT_HOVER, motion_timeout_callback, sheet);
5326     }
5327   else
5328     {
5329       gint row, column;
5330       gint wx, wy;
5331       gtk_widget_get_pointer (widget, &wx, &wy);
5332
5333       if ( gtk_sheet_get_pixel_info (sheet, wx, wy, &row, &column) )
5334         {
5335           if ( row != sheet->hover_window->row || column != sheet->hover_window->column)
5336             {
5337               gtk_widget_hide (sheet->hover_window->window);
5338             }
5339         }
5340     }
5341
5342   if (event->window == sheet->column_title_window &&
5343       gtk_sheet_columns_resizable (sheet))
5344     {
5345       gtk_widget_get_pointer (widget, &x, &y);
5346       if (!GTK_SHEET_IN_SELECTION (sheet) &&
5347           POSSIBLE_XDRAG (sheet, x, &column))
5348         {
5349           new_cursor = GDK_SB_H_DOUBLE_ARROW;
5350           if (new_cursor != sheet->cursor_drag->type)
5351             {
5352               gdk_cursor_destroy (sheet->cursor_drag);
5353               sheet->cursor_drag = gdk_cursor_new (GDK_SB_H_DOUBLE_ARROW);
5354               gdk_window_set_cursor (sheet->column_title_window,
5355                                      sheet->cursor_drag);
5356             }
5357         }
5358       else
5359         {
5360           new_cursor = GDK_TOP_LEFT_ARROW;
5361           if (!GTK_SHEET_IN_XDRAG (sheet) &&
5362               new_cursor != sheet->cursor_drag->type)
5363             {
5364               gdk_cursor_destroy (sheet->cursor_drag);
5365               sheet->cursor_drag = gdk_cursor_new (GDK_TOP_LEFT_ARROW);
5366               gdk_window_set_cursor (sheet->column_title_window,
5367                                      sheet->cursor_drag);
5368             }
5369         }
5370     }
5371
5372   if (event->window == sheet->row_title_window &&
5373       gtk_sheet_rows_resizable (sheet))
5374     {
5375       gtk_widget_get_pointer (widget, &x, &y);
5376       if (!GTK_SHEET_IN_SELECTION (sheet) && POSSIBLE_YDRAG (sheet,y, &column))
5377         {
5378           new_cursor = GDK_SB_V_DOUBLE_ARROW;
5379           if (new_cursor != sheet->cursor_drag->type)
5380             {
5381               gdk_cursor_destroy (sheet->cursor_drag);
5382               sheet->cursor_drag = gdk_cursor_new (GDK_SB_V_DOUBLE_ARROW);
5383               gdk_window_set_cursor (sheet->row_title_window, sheet->cursor_drag);
5384             }
5385         }
5386       else
5387         {
5388           new_cursor = GDK_TOP_LEFT_ARROW;
5389           if (!GTK_SHEET_IN_YDRAG (sheet) &&
5390               new_cursor != sheet->cursor_drag->type)
5391             {
5392               gdk_cursor_destroy (sheet->cursor_drag);
5393               sheet->cursor_drag = gdk_cursor_new (GDK_TOP_LEFT_ARROW);
5394               gdk_window_set_cursor (sheet->row_title_window, sheet->cursor_drag);
5395             }
5396         }
5397     }
5398
5399   new_cursor = GDK_PLUS;
5400   if ( event->window == sheet->sheet_window &&
5401        !POSSIBLE_DRAG (sheet, x, y, &row, &column) &&
5402        !GTK_SHEET_IN_DRAG (sheet) &&
5403        !POSSIBLE_RESIZE (sheet, x, y, &row, &column) &&
5404        !GTK_SHEET_IN_RESIZE (sheet) &&
5405        new_cursor != sheet->cursor_drag->type)
5406     {
5407       gdk_cursor_destroy (sheet->cursor_drag);
5408       sheet->cursor_drag = gdk_cursor_new (GDK_PLUS);
5409       gdk_window_set_cursor (sheet->sheet_window, sheet->cursor_drag);
5410     }
5411
5412   new_cursor = GDK_TOP_LEFT_ARROW;
5413   if ( event->window == sheet->sheet_window &&
5414        ! (POSSIBLE_RESIZE (sheet,x,y,&row,&column) || GTK_SHEET_IN_RESIZE (sheet)) && (POSSIBLE_DRAG (sheet, x,y,&row,&column) || GTK_SHEET_IN_DRAG (sheet)) &&
5415
5416        new_cursor != sheet->cursor_drag->type)
5417     {
5418       gdk_cursor_destroy (sheet->cursor_drag);
5419       sheet->cursor_drag = gdk_cursor_new (GDK_TOP_LEFT_ARROW);
5420       gdk_window_set_cursor (sheet->sheet_window,sheet->cursor_drag);
5421     }
5422
5423   new_cursor = GDK_SIZING;
5424   if ( event->window == sheet->sheet_window &&
5425        sheet->selection_mode != GTK_SELECTION_NONE &&
5426        !GTK_SHEET_IN_DRAG (sheet) &&
5427        (POSSIBLE_RESIZE (sheet, x, y, &row, &column) ||
5428         GTK_SHEET_IN_RESIZE (sheet)) &&
5429        new_cursor != sheet->cursor_drag->type)
5430     {
5431       gdk_cursor_destroy (sheet->cursor_drag);
5432       sheet->cursor_drag = gdk_cursor_new (GDK_SIZING);
5433       gdk_window_set_cursor (sheet->sheet_window,sheet->cursor_drag);
5434     }
5435
5436
5437   gdk_window_get_pointer (widget->window, &x, &y, &mods);
5438   if (! (mods & GDK_BUTTON1_MASK)) return FALSE;
5439
5440   if (GTK_SHEET_IN_XDRAG (sheet))
5441     {
5442       if (event->is_hint || event->window != widget->window)
5443         gtk_widget_get_pointer (widget, &x, NULL);
5444       else
5445         x = event->x;
5446
5447       new_column_width (sheet, sheet->drag_cell.col, &x);
5448       if (x != sheet->x_drag)
5449         {
5450           draw_xor_vline (sheet);
5451           sheet->x_drag = x;
5452           draw_xor_vline (sheet);
5453         }
5454       return TRUE;
5455     }
5456
5457   if (GTK_SHEET_IN_YDRAG (sheet))
5458     {
5459       if (event->is_hint || event->window != widget->window)
5460         gtk_widget_get_pointer (widget, NULL, &y);
5461       else
5462         y = event->y;
5463
5464       new_row_height (sheet, sheet->drag_cell.row, &y);
5465       if (y != sheet->y_drag)
5466         {
5467           draw_xor_hline (sheet);
5468           sheet->y_drag = y;
5469           draw_xor_hline (sheet);
5470         }
5471       return TRUE;
5472     }
5473
5474   if (GTK_SHEET_IN_DRAG (sheet))
5475     {
5476       GtkSheetRange aux;
5477       column = COLUMN_FROM_XPIXEL (sheet,x)- sheet->drag_cell.col;
5478       row = ROW_FROM_YPIXEL (sheet,y)- sheet->drag_cell.row;
5479       if (sheet->state == GTK_SHEET_COLUMN_SELECTED) row = 0;
5480       if (sheet->state == GTK_SHEET_ROW_SELECTED) column = 0;
5481       sheet->x_drag = x;
5482       sheet->y_drag = y;
5483       aux = sheet->range;
5484       if (aux.row0 + row >= 0 && aux.rowi + row < yyy_row_count (sheet) &&
5485           aux.col0 + column >= 0 && aux.coli + column < xxx_column_count (sheet))
5486         {
5487           aux = sheet->drag_range;
5488           sheet->drag_range.row0 = sheet->range.row0 + row;
5489           sheet->drag_range.col0 = sheet->range.col0 + column;
5490           sheet->drag_range.rowi = sheet->range.rowi + row;
5491           sheet->drag_range.coli = sheet->range.coli + column;
5492           if (aux.row0 != sheet->drag_range.row0 ||
5493               aux.col0 != sheet->drag_range.col0)
5494             {
5495               draw_xor_rectangle (sheet, aux);
5496               draw_xor_rectangle (sheet, sheet->drag_range);
5497             }
5498         }
5499       return TRUE;
5500     }
5501
5502   if (GTK_SHEET_IN_RESIZE (sheet))
5503     {
5504       GtkSheetRange aux;
5505       gint v_h, current_col, current_row, col_threshold, row_threshold;
5506       v_h = 1;
5507
5508       if (abs (x - COLUMN_LEFT_XPIXEL (sheet,sheet->drag_cell.col)) >
5509           abs (y - ROW_TOP_YPIXEL (sheet,sheet->drag_cell.row))) v_h = 2;
5510
5511       current_col = COLUMN_FROM_XPIXEL (sheet,x);
5512       current_row = ROW_FROM_YPIXEL (sheet,y);
5513       column = current_col - sheet->drag_cell.col;
5514       row = current_row - sheet->drag_cell.row;
5515
5516       /*use half of column width resp. row height as threshold to
5517         expand selection*/
5518       col_threshold = COLUMN_LEFT_XPIXEL (sheet,current_col) +
5519         xxx_column_width (sheet,current_col) / 2;
5520       if (column > 0)
5521         {
5522           if (x < col_threshold)
5523             column -= 1;
5524         }
5525       else if (column < 0)
5526         {
5527           if (x > col_threshold)
5528             column +=1;
5529         }
5530       row_threshold = ROW_TOP_YPIXEL (sheet,current_row) +
5531         yyy_row_height (sheet, current_row)/2;
5532       if (row > 0)
5533         {
5534           if (y < row_threshold)
5535             row -= 1;
5536         }
5537       else if (row < 0)
5538         {
5539           if (y > row_threshold)
5540             row +=1;
5541         }
5542
5543       if (sheet->state == GTK_SHEET_COLUMN_SELECTED) row = 0;
5544       if (sheet->state == GTK_SHEET_ROW_SELECTED) column = 0;
5545       sheet->x_drag = x;
5546       sheet->y_drag = y;
5547       aux = sheet->range;
5548
5549       if (v_h == 1)
5550         column = 0;
5551       else
5552         row = 0;
5553
5554       if (aux.row0 + row >= 0 && aux.rowi + row < yyy_row_count (sheet) &&
5555           aux.col0 + column >= 0 && aux.coli + column < xxx_column_count (sheet))
5556         {
5557           aux = sheet->drag_range;
5558           sheet->drag_range = sheet->range;
5559
5560           if (row < 0) sheet->drag_range.row0 = sheet->range.row0 + row;
5561           if (row > 0) sheet->drag_range.rowi = sheet->range.rowi + row;
5562           if (column < 0) sheet->drag_range.col0 = sheet->range.col0 + column;
5563           if (column > 0) sheet->drag_range.coli = sheet->range.coli + column;
5564
5565           if (aux.row0 != sheet->drag_range.row0 ||
5566               aux.rowi != sheet->drag_range.rowi ||
5567               aux.col0 != sheet->drag_range.col0 ||
5568               aux.coli != sheet->drag_range.coli)
5569             {
5570               draw_xor_rectangle (sheet, aux);
5571               draw_xor_rectangle (sheet, sheet->drag_range);
5572             }
5573         }
5574       return TRUE;
5575     }
5576
5577   gtk_sheet_get_pixel_info (sheet, x, y, &row, &column);
5578
5579   if (sheet->state == GTK_SHEET_NORMAL && row == sheet->active_cell.row &&
5580       column == sheet->active_cell.col) return TRUE;
5581
5582   if (GTK_SHEET_IN_SELECTION (sheet) && mods&GDK_BUTTON1_MASK)
5583     gtk_sheet_extend_selection (sheet, row, column);
5584
5585   return TRUE;
5586 }
5587
5588 static gboolean
5589 gtk_sheet_move_query (GtkSheet *sheet, gint row, gint column)
5590 {
5591   gint row_move, column_move;
5592   gfloat row_align, col_align;
5593   guint height, width;
5594   gint new_row = row;
5595   gint new_col = column;
5596
5597   row_move = FALSE;
5598   column_move = FALSE;
5599   row_align =- 1.;
5600   col_align =- 1.;
5601
5602   height = sheet->sheet_window_height;
5603   width = sheet->sheet_window_width;
5604
5605   if (row >= MAX_VISIBLE_ROW (sheet) && sheet->state != GTK_SHEET_COLUMN_SELECTED)
5606     {
5607       row_align = 1.;
5608       new_row = MIN (yyy_row_count (sheet), row + 1);
5609       row_move = TRUE;
5610       if (MAX_VISIBLE_ROW (sheet) == yyy_row_count (sheet) - 1 &&
5611           ROW_TOP_YPIXEL (sheet, yyy_row_count (sheet)- 1) +
5612           yyy_row_height (sheet, yyy_row_count (sheet)- 1) < height)
5613         {
5614           row_move = FALSE;
5615           row_align = -1.;
5616         }
5617     }
5618   if (row < MIN_VISIBLE_ROW (sheet) && sheet->state != GTK_SHEET_COLUMN_SELECTED)
5619     {
5620       row_align= 0.;
5621       row_move = TRUE;
5622     }
5623   if (column >= MAX_VISIBLE_COLUMN (sheet) && sheet->state != GTK_SHEET_ROW_SELECTED)
5624     {
5625       col_align = 1.;
5626       new_col = MIN (xxx_column_count (sheet) - 1, column + 1);
5627       column_move = TRUE;
5628       if (MAX_VISIBLE_COLUMN (sheet) == (xxx_column_count (sheet) - 1) &&
5629           COLUMN_LEFT_XPIXEL (sheet, xxx_column_count (sheet) - 1) +
5630           xxx_column_width (sheet, xxx_column_count (sheet) - 1) < width)
5631         {
5632           column_move = FALSE;
5633           col_align = -1.;
5634         }
5635     }
5636   if (column < MIN_VISIBLE_COLUMN (sheet) && sheet->state != GTK_SHEET_ROW_SELECTED)
5637     {
5638       col_align = 0.;
5639       column_move = TRUE;
5640     }
5641
5642   if (row_move || column_move)
5643     {
5644       gtk_sheet_moveto (sheet, new_row, new_col, row_align, col_align);
5645     }
5646
5647   return (row_move || column_move);
5648 }
5649
5650 static void
5651 gtk_sheet_extend_selection (GtkSheet *sheet, gint row, gint column)
5652 {
5653   GtkSheetRange range;
5654   gint state;
5655   gint r,c;
5656
5657   if (row == sheet->selection_cell.row && column == sheet->selection_cell.col)
5658     return;
5659
5660   if (sheet->selection_mode == GTK_SELECTION_SINGLE) return;
5661
5662   gtk_sheet_move_query (sheet, row, column);
5663   gtk_widget_grab_focus (GTK_WIDGET (sheet));
5664
5665   if (GTK_SHEET_IN_DRAG (sheet)) return;
5666
5667   state = sheet->state;
5668
5669   switch (sheet->state)
5670     {
5671     case GTK_SHEET_ROW_SELECTED:
5672       column = xxx_column_count (sheet) - 1;
5673       break;
5674     case GTK_SHEET_COLUMN_SELECTED:
5675       row = yyy_row_count (sheet) - 1;
5676       break;
5677     case GTK_SHEET_NORMAL:
5678       sheet->state = GTK_SHEET_RANGE_SELECTED;
5679       r = sheet->active_cell.row;
5680       c = sheet->active_cell.col;
5681       sheet->range.col0 = c;
5682       sheet->range.row0 = r;
5683       sheet->range.coli = c;
5684       sheet->range.rowi = r;
5685       gdk_draw_pixmap (sheet->sheet_window,
5686                        GTK_WIDGET (sheet)->style->fg_gc[GTK_STATE_NORMAL],
5687                        sheet->pixmap,
5688                        COLUMN_LEFT_XPIXEL (sheet,c)- 1,
5689                        ROW_TOP_YPIXEL (sheet,r)- 1,
5690                        COLUMN_LEFT_XPIXEL (sheet,c)- 1,
5691                        ROW_TOP_YPIXEL (sheet,r)- 1,
5692                        xxx_column_width (sheet, c)+4,
5693                        yyy_row_height (sheet, r)+4);
5694       gtk_sheet_range_draw_selection (sheet, sheet->range);
5695     case GTK_SHEET_RANGE_SELECTED:
5696       sheet->state = GTK_SHEET_RANGE_SELECTED;
5697     }
5698
5699   sheet->selection_cell.row = row;
5700   sheet->selection_cell.col = column;
5701
5702   range.col0 = MIN (column,sheet->active_cell.col);
5703   range.coli = MAX (column,sheet->active_cell.col);
5704   range.row0 = MIN (row,sheet->active_cell.row);
5705   range.rowi = MAX (row,sheet->active_cell.row);
5706
5707   if (range.row0 != sheet->range.row0 || range.rowi != sheet->range.rowi ||
5708       range.col0 != sheet->range.col0 || range.coli != sheet->range.coli ||
5709       state == GTK_SHEET_NORMAL)
5710     gtk_sheet_real_select_range (sheet, &range);
5711
5712 }
5713
5714 static gint
5715 gtk_sheet_entry_key_press (GtkWidget *widget,
5716                            GdkEventKey *key)
5717 {
5718   gboolean focus;
5719   g_signal_emit_by_name (G_OBJECT (widget), "key_press_event", key, &focus);
5720   return focus;
5721 }
5722
5723 static gint
5724 gtk_sheet_key_press (GtkWidget *widget,
5725                      GdkEventKey *key)
5726 {
5727   GtkSheet *sheet;
5728   gint row, col;
5729   gint state;
5730   gboolean extend_selection = FALSE;
5731   gboolean force_move = FALSE;
5732   gboolean in_selection = FALSE;
5733   gboolean veto = TRUE;
5734   gint scroll = 1;
5735
5736   sheet = GTK_SHEET (widget);
5737
5738   if (key->state & GDK_CONTROL_MASK || key->keyval == GDK_Control_L ||
5739       key->keyval == GDK_Control_R) return FALSE;
5740
5741   extend_selection = (key->state & GDK_SHIFT_MASK) || key->keyval == GDK_Shift_L
5742     || key->keyval == GDK_Shift_R;
5743
5744   state = sheet->state;
5745   in_selection = GTK_SHEET_IN_SELECTION (sheet);
5746   GTK_SHEET_UNSET_FLAGS (sheet, GTK_SHEET_IN_SELECTION);
5747
5748   switch (key->keyval)
5749     {
5750     case GDK_Return: case GDK_KP_Enter:
5751       if (sheet->state == GTK_SHEET_NORMAL &&
5752           !GTK_SHEET_IN_SELECTION (sheet))
5753         g_signal_stop_emission_by_name (gtk_sheet_get_entry (sheet),
5754                                          "key-press-event");
5755       row = sheet->active_cell.row;
5756       col = sheet->active_cell.col;
5757       if (sheet->state == GTK_SHEET_COLUMN_SELECTED)
5758         row = MIN_VISIBLE_ROW (sheet)- 1;
5759       if (sheet->state == GTK_SHEET_ROW_SELECTED)
5760         col = MIN_VISIBLE_COLUMN (sheet);
5761       if (row < yyy_row_count (sheet) - 1)
5762         {
5763           row = row + scroll;
5764           while (!yyy_row_is_visible (sheet, row) && row < yyy_row_count (sheet)- 1)
5765             row++;
5766         }
5767       gtk_sheet_click_cell (sheet, row, col, &veto);
5768       extend_selection = FALSE;
5769       break;
5770     case GDK_ISO_Left_Tab:
5771       row = sheet->active_cell.row;
5772       col = sheet->active_cell.col;
5773       if (sheet->state == GTK_SHEET_ROW_SELECTED)
5774         col = MIN_VISIBLE_COLUMN (sheet)- 1;
5775       if (sheet->state == GTK_SHEET_COLUMN_SELECTED)
5776         row = MIN_VISIBLE_ROW (sheet);
5777       if (col > 0)
5778         {
5779           col = col - scroll;
5780           while (! xxx_column_is_visible (sheet, col) && col > 0) col--;
5781           col = MAX (0, col);
5782         }
5783       gtk_sheet_click_cell (sheet, row, col, &veto);
5784       extend_selection = FALSE;
5785       break;
5786     case GDK_Tab:
5787       row = sheet->active_cell.row;
5788       col = sheet->active_cell.col;
5789       if (sheet->state == GTK_SHEET_ROW_SELECTED)
5790         col = MIN_VISIBLE_COLUMN (sheet)- 1;
5791       if (sheet->state == GTK_SHEET_COLUMN_SELECTED)
5792         row = MIN_VISIBLE_ROW (sheet);
5793       if (col < xxx_column_count (sheet) - 1)
5794         {
5795           col = col + scroll;
5796           while (! xxx_column_is_visible (sheet, col) &&
5797                  col < xxx_column_count (sheet) - 1)
5798             col++;
5799         }
5800       gtk_sheet_click_cell (sheet, row, col, &veto);
5801       extend_selection = FALSE;
5802       break;
5803     case GDK_Page_Up:
5804       scroll = MAX_VISIBLE_ROW (sheet)- MIN_VISIBLE_ROW (sheet)+1;
5805     case GDK_Up:
5806       if (extend_selection)
5807         {
5808           if (state == GTK_STATE_NORMAL)
5809             {
5810               row = sheet->active_cell.row;
5811               col = sheet->active_cell.col;
5812               gtk_sheet_click_cell (sheet, row, col, &veto);
5813               if (!veto) break;
5814             }
5815           if (sheet->selection_cell.row > 0)
5816             {
5817               row = sheet->selection_cell.row - scroll;
5818               while (!yyy_row_is_visible (sheet, row) && row > 0) row--;
5819               row = MAX (0, row);
5820               gtk_sheet_extend_selection (sheet, row, sheet->selection_cell.col);
5821             }
5822           return TRUE;
5823         }
5824       col = sheet->active_cell.col;
5825       row = sheet->active_cell.row;
5826       if (state == GTK_SHEET_COLUMN_SELECTED)
5827         row = MIN_VISIBLE_ROW (sheet);
5828       if (state == GTK_SHEET_ROW_SELECTED)
5829         col = MIN_VISIBLE_COLUMN (sheet);
5830       row = row - scroll;
5831       while (!yyy_row_is_visible (sheet, row) && row > 0) row--;
5832       row = MAX (0,row);
5833       gtk_sheet_click_cell (sheet, row, col, &veto);
5834       extend_selection = FALSE;
5835       break;
5836     case GDK_Page_Down:
5837       scroll = MAX_VISIBLE_ROW (sheet)- MIN_VISIBLE_ROW (sheet)+1;
5838     case GDK_Down:
5839       if (extend_selection)
5840         {
5841           if (state == GTK_STATE_NORMAL)
5842             {
5843               row = sheet->active_cell.row;
5844               col = sheet->active_cell.col;
5845               gtk_sheet_click_cell (sheet, row, col, &veto);
5846               if (!veto) break;
5847             }
5848           if (sheet->selection_cell.row < yyy_row_count (sheet)- 1)
5849             {
5850               row = sheet->selection_cell.row + scroll;
5851               while (!yyy_row_is_visible (sheet, row) && row < yyy_row_count (sheet)- 1) row++;
5852               row = MIN (yyy_row_count (sheet)- 1, row);
5853               gtk_sheet_extend_selection (sheet, row, sheet->selection_cell.col);
5854             }
5855           return TRUE;
5856         }
5857       col = sheet->active_cell.col;
5858       row = sheet->active_cell.row;
5859       if (sheet->active_cell.row < yyy_row_count (sheet)- 1)
5860         {
5861           if (state == GTK_SHEET_COLUMN_SELECTED)
5862             row = MIN_VISIBLE_ROW (sheet)- 1;
5863           if (state == GTK_SHEET_ROW_SELECTED)
5864             col = MIN_VISIBLE_COLUMN (sheet);
5865           row = row + scroll;
5866           while (!yyy_row_is_visible (sheet, row) && row < yyy_row_count (sheet)- 1) row++;
5867           row = MIN (yyy_row_count (sheet)- 1, row);
5868         }
5869       gtk_sheet_click_cell (sheet, row, col, &veto);
5870       extend_selection = FALSE;
5871       break;
5872     case GDK_Right:
5873       if (extend_selection)
5874         {
5875           if (state == GTK_STATE_NORMAL)
5876             {
5877               row = sheet->active_cell.row;
5878               col = sheet->active_cell.col;
5879               gtk_sheet_click_cell (sheet, row, col, &veto);
5880               if (!veto) break;
5881             }
5882           if (sheet->selection_cell.col < xxx_column_count (sheet) - 1)
5883             {
5884               col = sheet->selection_cell.col + 1;
5885               while (! xxx_column_is_visible (sheet, col) && col < xxx_column_count (sheet) - 1)
5886                 col++;
5887               gtk_sheet_extend_selection (sheet, sheet->selection_cell.row, col);
5888             }
5889           return TRUE;
5890         }
5891       col = sheet->active_cell.col;
5892       row = sheet->active_cell.row;
5893       if (sheet->active_cell.col < xxx_column_count (sheet) - 1)
5894         {
5895           col ++;
5896           if (state == GTK_SHEET_ROW_SELECTED)
5897             col = MIN_VISIBLE_COLUMN (sheet)- 1;
5898           if (state == GTK_SHEET_COLUMN_SELECTED)
5899             row = MIN_VISIBLE_ROW (sheet);
5900           while (! xxx_column_is_visible (sheet, col) && col < xxx_column_count (sheet) - 1) col++;
5901           if (strlen (gtk_entry_get_text (GTK_ENTRY (gtk_sheet_get_entry (sheet)))) == 0
5902               || force_move)
5903             {
5904               gtk_sheet_click_cell (sheet, row, col, &veto);
5905             }
5906           else
5907             return FALSE;
5908         }
5909       extend_selection = FALSE;
5910       break;
5911     case GDK_Left:
5912       if (extend_selection)
5913         {
5914           if (state == GTK_STATE_NORMAL)
5915             {
5916               row = sheet->active_cell.row;
5917               col = sheet->active_cell.col;
5918               gtk_sheet_click_cell (sheet, row, col, &veto);
5919               if (!veto) break;
5920             }
5921           if (sheet->selection_cell.col > 0)
5922             {
5923               col = sheet->selection_cell.col - 1;
5924               while (! xxx_column_is_visible (sheet, col) && col > 0) col--;
5925               gtk_sheet_extend_selection (sheet, sheet->selection_cell.row, col);
5926             }
5927           return TRUE;
5928         }
5929       col = sheet->active_cell.col - 1;
5930       row = sheet->active_cell.row;
5931       if (state == GTK_SHEET_ROW_SELECTED)
5932         col = MIN_VISIBLE_COLUMN (sheet)- 1;
5933       if (state == GTK_SHEET_COLUMN_SELECTED)
5934         row = MIN_VISIBLE_ROW (sheet);
5935       while (! xxx_column_is_visible (sheet, col) && col > 0) col--;
5936       col = MAX (0, col);
5937
5938       if (strlen (gtk_entry_get_text (GTK_ENTRY (gtk_sheet_get_entry (sheet)))) == 0
5939           || force_move)
5940         {
5941           gtk_sheet_click_cell (sheet, row, col, &veto);
5942         }
5943       else
5944         return FALSE;
5945       extend_selection = FALSE;
5946       break;
5947     case GDK_Home:
5948       row = 0;
5949       while (!yyy_row_is_visible (sheet, row) && row < yyy_row_count (sheet)- 1) row++;
5950       gtk_sheet_click_cell (sheet, row, sheet->active_cell.col, &veto);
5951       extend_selection = FALSE;
5952       break;
5953     case GDK_End:
5954       row = yyy_row_count (sheet)- 1;
5955       while (!yyy_row_is_visible (sheet, row) && row > 0) row--;
5956       gtk_sheet_click_cell (sheet, row, sheet->active_cell.col, &veto);
5957       extend_selection = FALSE;
5958       break;
5959     default:
5960       if (in_selection)
5961         {
5962           GTK_SHEET_SET_FLAGS (sheet, GTK_SHEET_IN_SELECTION);
5963           if (extend_selection) return TRUE;
5964         }
5965       if (state == GTK_SHEET_ROW_SELECTED)
5966         sheet->active_cell.col = MIN_VISIBLE_COLUMN (sheet);
5967       if (state == GTK_SHEET_COLUMN_SELECTED)
5968         sheet->active_cell.row = MIN_VISIBLE_ROW (sheet);
5969       return FALSE;
5970     }
5971
5972   if (extend_selection) return TRUE;
5973
5974   gtk_sheet_activate_cell (sheet, sheet->active_cell.row,
5975                            sheet->active_cell.col);
5976
5977   return TRUE;
5978 }
5979
5980 static void
5981 gtk_sheet_size_request (GtkWidget * widget,
5982                         GtkRequisition * requisition)
5983 {
5984   GtkSheet *sheet;
5985   GList *children;
5986   GtkSheetChild *child;
5987   GtkRequisition child_requisition;
5988
5989   g_return_if_fail (widget != NULL);
5990   g_return_if_fail (GTK_IS_SHEET (widget));
5991   g_return_if_fail (requisition != NULL);
5992
5993   sheet = GTK_SHEET (widget);
5994
5995   requisition->width = 3*DEFAULT_COLUMN_WIDTH;
5996   requisition->height = 3*DEFAULT_ROW_HEIGHT (widget);
5997
5998   /* compute the size of the column title area */
5999   if (sheet->column_titles_visible)
6000     requisition->height += sheet->column_title_area.height;
6001
6002   /* compute the size of the row title area */
6003   if (sheet->row_titles_visible)
6004     requisition->width += sheet->row_title_area.width;
6005
6006   children = sheet->children;
6007   while (children)
6008     {
6009       child = children->data;
6010       children = children->next;
6011
6012       gtk_widget_size_request (child->widget, &child_requisition);
6013     }
6014 }
6015
6016
6017 static void
6018 gtk_sheet_size_allocate (GtkWidget * widget,
6019                          GtkAllocation * allocation)
6020 {
6021   GtkSheet *sheet;
6022   GtkAllocation sheet_allocation;
6023   gint border_width;
6024
6025   g_return_if_fail (widget != NULL);
6026   g_return_if_fail (GTK_IS_SHEET (widget));
6027   g_return_if_fail (allocation != NULL);
6028
6029   sheet = GTK_SHEET (widget);
6030   widget->allocation = *allocation;
6031   border_width = GTK_CONTAINER (widget)->border_width;
6032
6033   if (GTK_WIDGET_REALIZED (widget))
6034     gdk_window_move_resize (widget->window,
6035                             allocation->x + border_width,
6036                             allocation->y + border_width,
6037                             allocation->width - 2 * border_width,
6038                             allocation->height - 2 * border_width);
6039
6040   /* use internal allocation structure for all the math
6041    * because it's easier than always subtracting the container
6042    * border width */
6043   sheet->internal_allocation.x = 0;
6044   sheet->internal_allocation.y = 0;
6045   sheet->internal_allocation.width = allocation->width - 2 * border_width;
6046   sheet->internal_allocation.height = allocation->height - 2 * border_width;
6047
6048   sheet_allocation.x = 0;
6049   sheet_allocation.y = 0;
6050   sheet_allocation.width = allocation->width - 2 * border_width;
6051   sheet_allocation.height = allocation->height - 2 * border_width;
6052
6053   sheet->sheet_window_width = sheet_allocation.width;
6054   sheet->sheet_window_height = sheet_allocation.height;
6055
6056   if (GTK_WIDGET_REALIZED (widget))
6057     gdk_window_move_resize (sheet->sheet_window,
6058                             sheet_allocation.x,
6059                             sheet_allocation.y,
6060                             sheet_allocation.width,
6061                             sheet_allocation.height);
6062
6063   /* position the window which holds the column title buttons */
6064   sheet->column_title_area.x = 0;
6065   sheet->column_title_area.y = 0;
6066   if (sheet->row_titles_visible)
6067     sheet->column_title_area.x = sheet->row_title_area.width;
6068   sheet->column_title_area.width = sheet_allocation.width -
6069     sheet->column_title_area.x;
6070   if (GTK_WIDGET_REALIZED (widget) && sheet->column_titles_visible)
6071     gdk_window_move_resize (sheet->column_title_window,
6072                             sheet->column_title_area.x,
6073                             sheet->column_title_area.y,
6074                             sheet->column_title_area.width,
6075                             sheet->column_title_area.height);
6076
6077   sheet->sheet_window_width = sheet_allocation.width;
6078   sheet->sheet_window_height = sheet_allocation.height;
6079
6080   /* column button allocation */
6081   size_allocate_column_title_buttons (sheet);
6082
6083   /* position the window which holds the row title buttons */
6084   sheet->row_title_area.x = 0;
6085   sheet->row_title_area.y = 0;
6086   if (sheet->column_titles_visible)
6087     sheet->row_title_area.y = sheet->column_title_area.height;
6088   sheet->row_title_area.height = sheet_allocation.height -
6089     sheet->row_title_area.y;
6090
6091   if (GTK_WIDGET_REALIZED (widget) && sheet->row_titles_visible)
6092     gdk_window_move_resize (sheet->row_title_window,
6093                             sheet->row_title_area.x,
6094                             sheet->row_title_area.y,
6095                             sheet->row_title_area.width,
6096                             sheet->row_title_area.height);
6097
6098
6099   /* row button allocation */
6100   size_allocate_row_title_buttons (sheet);
6101   size_allocate_column_title_buttons (sheet);
6102
6103   /* re - scale backing pixmap */
6104   gtk_sheet_make_backing_pixmap (sheet, 0, 0);
6105   gtk_sheet_position_children (sheet);
6106
6107   /* set the scrollbars adjustments */
6108   adjust_scrollbars (sheet);
6109 }
6110
6111 static void
6112 size_allocate_column_title_buttons (GtkSheet * sheet)
6113 {
6114   gint i;
6115   gint x,width;
6116
6117   if (!sheet->column_titles_visible) return;
6118   if (!GTK_WIDGET_REALIZED (sheet))
6119     return;
6120
6121   width = sheet->sheet_window_width;
6122   x = 0;
6123
6124   if (sheet->row_titles_visible)
6125     {
6126       width -= sheet->row_title_area.width;
6127       x = sheet->row_title_area.width;
6128     }
6129
6130   if (sheet->column_title_area.width != width || sheet->column_title_area.x != x)
6131     {
6132       sheet->column_title_area.width = width;
6133       sheet->column_title_area.x = x;
6134       gdk_window_move_resize (sheet->column_title_window,
6135                               sheet->column_title_area.x,
6136                               sheet->column_title_area.y,
6137                               sheet->column_title_area.width,
6138                               sheet->column_title_area.height);
6139     }
6140
6141
6142   if (MAX_VISIBLE_COLUMN (sheet) == xxx_column_count (sheet) - 1)
6143     gdk_window_clear_area (sheet->column_title_window,
6144                            0,0,
6145                            sheet->column_title_area.width,
6146                            sheet->column_title_area.height);
6147
6148   if (!GTK_WIDGET_DRAWABLE (sheet)) return;
6149
6150   for (i = MIN_VISIBLE_COLUMN (sheet); i <= MAX_VISIBLE_COLUMN (sheet); i++)
6151     gtk_sheet_column_title_button_draw (sheet, i);
6152 }
6153
6154 static void
6155 size_allocate_row_title_buttons (GtkSheet * sheet)
6156 {
6157   gint i;
6158   gint y, height;
6159
6160   if (!sheet->row_titles_visible) return;
6161   if (!GTK_WIDGET_REALIZED (sheet))
6162     return;
6163
6164   height = sheet->sheet_window_height;
6165   y = 0;
6166
6167   if (sheet->column_titles_visible)
6168     {
6169       height -= sheet->column_title_area.height;
6170       y = sheet->column_title_area.height;
6171     }
6172
6173   if (sheet->row_title_area.height != height || sheet->row_title_area.y != y)
6174     {
6175       sheet->row_title_area.y = y;
6176       sheet->row_title_area.height = height;
6177       gdk_window_move_resize (sheet->row_title_window,
6178                               sheet->row_title_area.x,
6179                               sheet->row_title_area.y,
6180                               sheet->row_title_area.width,
6181                               sheet->row_title_area.height);
6182     }
6183   if (MAX_VISIBLE_ROW (sheet) == yyy_row_count (sheet)- 1)
6184     gdk_window_clear_area (sheet->row_title_window,
6185                            0,0,
6186                            sheet->row_title_area.width,
6187                            sheet->row_title_area.height);
6188
6189   if (!GTK_WIDGET_DRAWABLE (sheet)) return;
6190
6191   for (i = MIN_VISIBLE_ROW (sheet); i <= MAX_VISIBLE_ROW (sheet); i++)
6192     {
6193       if ( i >= yyy_row_count (sheet))
6194         break;
6195       gtk_sheet_row_title_button_draw (sheet, i);
6196     }
6197 }
6198
6199
6200 static void
6201 gtk_sheet_size_allocate_entry (GtkSheet *sheet)
6202 {
6203   GtkAllocation shentry_allocation;
6204   GtkSheetCellAttr attributes = { 0 };
6205   GtkEntry *sheet_entry;
6206   GtkStyle *style = NULL, *previous_style = NULL;
6207   gint row, col;
6208   gint size, max_size, text_size, column_width;
6209   const gchar *text;
6210
6211   if (!GTK_WIDGET_REALIZED (GTK_WIDGET (sheet))) return;
6212   if (!GTK_WIDGET_MAPPED (GTK_WIDGET (sheet))) return;
6213
6214   sheet_entry = GTK_ENTRY (gtk_sheet_get_entry (sheet));
6215
6216   if ( ! gtk_sheet_get_attributes (sheet, sheet->active_cell.row,
6217                                    sheet->active_cell.col,
6218                                    &attributes) )
6219     return ;
6220
6221   if ( GTK_WIDGET_REALIZED (sheet->sheet_entry) )
6222     {
6223       if (!GTK_WIDGET (sheet_entry)->style)
6224         gtk_widget_ensure_style (GTK_WIDGET (sheet_entry));
6225
6226       previous_style = GTK_WIDGET (sheet_entry)->style;
6227
6228       style = gtk_style_copy (previous_style);
6229       style->bg[GTK_STATE_NORMAL] = attributes.background;
6230       style->fg[GTK_STATE_NORMAL] = attributes.foreground;
6231       style->text[GTK_STATE_NORMAL] = attributes.foreground;
6232       style->bg[GTK_STATE_ACTIVE] = attributes.background;
6233       style->fg[GTK_STATE_ACTIVE] = attributes.foreground;
6234       style->text[GTK_STATE_ACTIVE] = attributes.foreground;
6235
6236       pango_font_description_free (style->font_desc);
6237       g_assert (attributes.font_desc);
6238       style->font_desc = pango_font_description_copy (attributes.font_desc);
6239
6240       GTK_WIDGET (sheet_entry)->style = style;
6241       gtk_widget_size_request (sheet->sheet_entry, NULL);
6242       GTK_WIDGET (sheet_entry)->style = previous_style;
6243
6244       if (style != previous_style)
6245         {
6246           if (!GTK_IS_ITEM_ENTRY (sheet->sheet_entry))
6247             {
6248               style->bg[GTK_STATE_NORMAL] = previous_style->bg[GTK_STATE_NORMAL];
6249               style->fg[GTK_STATE_NORMAL] = previous_style->fg[GTK_STATE_NORMAL];
6250               style->bg[GTK_STATE_ACTIVE] = previous_style->bg[GTK_STATE_ACTIVE];
6251               style->fg[GTK_STATE_ACTIVE] = previous_style->fg[GTK_STATE_ACTIVE];
6252             }
6253           gtk_widget_set_style (GTK_WIDGET (sheet_entry), style);
6254         }
6255     }
6256
6257   if (GTK_IS_ITEM_ENTRY (sheet_entry))
6258     max_size = GTK_ITEM_ENTRY (sheet_entry)->text_max_size;
6259   else
6260     max_size = 0;
6261
6262   text_size = 0;
6263   text = gtk_entry_get_text (GTK_ENTRY (sheet_entry));
6264   if (text && strlen (text) > 0)
6265     text_size = STRING_WIDTH (GTK_WIDGET (sheet), attributes.font_desc, text);
6266
6267   column_width = xxx_column_width (sheet, sheet->active_cell.col);
6268
6269   size = MIN (text_size, max_size);
6270   size = MAX (size,column_width - 2 * CELLOFFSET);
6271
6272   row = sheet->active_cell.row;
6273   col = sheet->active_cell.col;
6274
6275   shentry_allocation.x = COLUMN_LEFT_XPIXEL (sheet,sheet->active_cell.col);
6276   shentry_allocation.y = ROW_TOP_YPIXEL (sheet,sheet->active_cell.row);
6277   shentry_allocation.width = column_width;
6278   shentry_allocation.height = yyy_row_height (sheet, sheet->active_cell.row);
6279
6280   if (GTK_IS_ITEM_ENTRY (sheet->sheet_entry))
6281     {
6282       shentry_allocation.height -= 2 * CELLOFFSET;
6283       shentry_allocation.y += CELLOFFSET;
6284       shentry_allocation.width = size;
6285
6286       switch (GTK_ITEM_ENTRY (sheet_entry)->justification)
6287         {
6288         case GTK_JUSTIFY_CENTER:
6289           shentry_allocation.x += column_width / 2 - size / 2;
6290           break;
6291         case GTK_JUSTIFY_RIGHT:
6292           shentry_allocation.x += column_width - size - CELLOFFSET;
6293           break;
6294         case GTK_JUSTIFY_LEFT:
6295         case GTK_JUSTIFY_FILL:
6296           shentry_allocation.x += CELLOFFSET;
6297           break;
6298         }
6299     }
6300
6301   if (!GTK_IS_ITEM_ENTRY (sheet->sheet_entry))
6302     {
6303       shentry_allocation.x += 2;
6304       shentry_allocation.y += 2;
6305       shentry_allocation.width -= MIN (shentry_allocation.width, 3);
6306       shentry_allocation.height -= MIN (shentry_allocation.height, 3);
6307     }
6308
6309   gtk_widget_size_allocate (sheet->sheet_entry, &shentry_allocation);
6310
6311   if (previous_style == style) g_object_unref (previous_style);
6312 }
6313
6314 static void
6315 gtk_sheet_entry_set_max_size (GtkSheet *sheet)
6316 {
6317   gint i;
6318   gint size = 0;
6319   gint sizel = 0, sizer = 0;
6320   gint row,col;
6321   GtkJustification justification;
6322   gchar *s = NULL;
6323
6324   row = sheet->active_cell.row;
6325   col = sheet->active_cell.col;
6326
6327   if ( ! GTK_IS_ITEM_ENTRY (sheet->sheet_entry) )
6328     return;
6329
6330   justification = GTK_ITEM_ENTRY (sheet->sheet_entry)->justification;
6331
6332   switch (justification)
6333     {
6334     case GTK_JUSTIFY_FILL:
6335     case GTK_JUSTIFY_LEFT:
6336       for (i = col + 1; i <= MAX_VISIBLE_COLUMN (sheet); i++)
6337         {
6338           if ((s = gtk_sheet_cell_get_text (sheet, row, i)))
6339             {
6340               g_free (s);
6341               break;
6342             }
6343           size +=xxx_column_width (sheet, i);
6344         }
6345       size = MIN (size, sheet->sheet_window_width - COLUMN_LEFT_XPIXEL (sheet, col));
6346       break;
6347     case GTK_JUSTIFY_RIGHT:
6348       for (i = col - 1; i >= MIN_VISIBLE_COLUMN (sheet); i--)
6349         {
6350           if ((s = gtk_sheet_cell_get_text (sheet, row, i)))
6351             {
6352               g_free (s);
6353               break;
6354             }
6355           size +=xxx_column_width (sheet, i);
6356         }
6357       break;
6358     case GTK_JUSTIFY_CENTER:
6359       for (i = col + 1; i <= MAX_VISIBLE_COLUMN (sheet); i++)
6360         {
6361           sizer += xxx_column_width (sheet, i);
6362         }
6363       for (i = col - 1; i >= MIN_VISIBLE_COLUMN (sheet); i--)
6364         {
6365           if ((s = gtk_sheet_cell_get_text (sheet, row, i)))
6366             {
6367               g_free (s);
6368               break;
6369             }
6370           sizel +=xxx_column_width (sheet, i);
6371         }
6372       size = 2 * MIN (sizel, sizer);
6373       break;
6374     }
6375
6376   if (size != 0)
6377     size += xxx_column_width (sheet, col);
6378   GTK_ITEM_ENTRY (sheet->sheet_entry)->text_max_size = size;
6379 }
6380
6381
6382 static void
6383 create_sheet_entry (GtkSheet *sheet)
6384 {
6385   GtkWidget *widget;
6386   GtkWidget *parent;
6387   GtkWidget *entry;
6388   gint found_entry = FALSE;
6389
6390   widget = GTK_WIDGET (sheet);
6391
6392   if (sheet->sheet_entry)
6393     {
6394       /* avoids warnings */
6395       gtk_widget_ref (sheet->sheet_entry);
6396       gtk_widget_unparent (sheet->sheet_entry);
6397       gtk_widget_destroy (sheet->sheet_entry);
6398     }
6399
6400   if (sheet->entry_type)
6401     {
6402       if (!g_type_is_a (sheet->entry_type, GTK_TYPE_ENTRY))
6403         {
6404           parent = g_object_new (sheet->entry_type, NULL);
6405
6406           sheet->sheet_entry = parent;
6407
6408           entry = gtk_sheet_get_entry (sheet);
6409           if (GTK_IS_ENTRY (entry))
6410             found_entry = TRUE;
6411         }
6412       else
6413         {
6414           parent = g_object_new (sheet->entry_type, NULL);
6415           entry = parent;
6416           found_entry = TRUE;
6417         }
6418
6419       if (!found_entry)
6420         {
6421           g_warning ("Entry type must be GtkEntry subclass, using default");
6422           entry = gtk_item_entry_new ();
6423           sheet->sheet_entry = entry;
6424         }
6425       else
6426         sheet->sheet_entry = parent;
6427     }
6428   else
6429     {
6430       entry = gtk_item_entry_new ();
6431       sheet->sheet_entry = entry;
6432     }
6433
6434   gtk_widget_size_request (sheet->sheet_entry, NULL);
6435
6436   if (GTK_WIDGET_REALIZED (sheet))
6437     {
6438       gtk_widget_set_parent_window (sheet->sheet_entry, sheet->sheet_window);
6439       gtk_widget_set_parent (sheet->sheet_entry, GTK_WIDGET (sheet));
6440       gtk_widget_realize (sheet->sheet_entry);
6441     }
6442
6443   g_signal_connect_swapped (G_OBJECT (entry), "key_press_event",
6444                             G_CALLBACK (gtk_sheet_entry_key_press),
6445                             sheet);
6446
6447   gtk_widget_show (sheet->sheet_entry);
6448 }
6449
6450
6451 /* Finds the last child widget that happens to be of type GtkEntry */
6452 static void
6453 find_entry (GtkWidget *w, gpointer user_data)
6454 {
6455   GtkWidget **entry = user_data;
6456   if ( GTK_IS_ENTRY (w))
6457     {
6458       *entry = w;
6459     }
6460 }
6461
6462 GtkWidget *
6463 gtk_sheet_get_entry (GtkSheet *sheet)
6464 {
6465   GtkWidget *parent;
6466   GtkWidget *entry = NULL;
6467   GtkTableChild *table_child;
6468   GtkBoxChild *box_child;
6469   GList *children = NULL;
6470
6471   g_return_val_if_fail (sheet != NULL, NULL);
6472   g_return_val_if_fail (GTK_IS_SHEET (sheet), NULL);
6473   g_return_val_if_fail (sheet->sheet_entry != NULL, NULL);
6474
6475   if (GTK_IS_ENTRY (sheet->sheet_entry)) return (sheet->sheet_entry);
6476
6477   parent = GTK_WIDGET (sheet->sheet_entry);
6478
6479   if (GTK_IS_TABLE (parent)) children = GTK_TABLE (parent)->children;
6480   if (GTK_IS_BOX (parent)) children = GTK_BOX (parent)->children;
6481
6482   if (GTK_IS_CONTAINER (parent))
6483     {
6484       gtk_container_forall (GTK_CONTAINER (parent), find_entry, &entry);
6485
6486       if (GTK_IS_ENTRY (entry))
6487         return entry;
6488     }
6489
6490   if (!children) return NULL;
6491
6492   while (children)
6493     {
6494       if (GTK_IS_TABLE (parent))
6495         {
6496           table_child = children->data;
6497           entry = table_child->widget;
6498         }
6499       if (GTK_IS_BOX (parent))
6500         {
6501           box_child = children->data;
6502           entry = box_child->widget;
6503         }
6504
6505       if (GTK_IS_ENTRY (entry))
6506         break;
6507       children = children->next;
6508     }
6509
6510
6511   if (!GTK_IS_ENTRY (entry)) return NULL;
6512
6513   return (entry);
6514
6515 }
6516
6517 GtkWidget *
6518 gtk_sheet_get_entry_widget (GtkSheet *sheet)
6519 {
6520   g_return_val_if_fail (sheet != NULL, NULL);
6521   g_return_val_if_fail (GTK_IS_SHEET (sheet), NULL);
6522   g_return_val_if_fail (sheet->sheet_entry != NULL, NULL);
6523
6524   return (sheet->sheet_entry);
6525 }
6526
6527
6528 static void
6529 gtk_sheet_button_draw (GtkSheet *sheet, GdkWindow *window,
6530                        GtkSheetButton *button, gboolean is_sensitive,
6531                        GdkRectangle allocation)
6532 {
6533   GtkShadowType shadow_type;
6534   gint text_width = 0, text_height = 0;
6535   GtkSheetChild *child = NULL;
6536   PangoAlignment align = PANGO_ALIGN_LEFT;
6537
6538   gboolean rtl ;
6539
6540   gint state = 0;
6541   gint len = 0;
6542   gchar *line = 0;
6543
6544   g_return_if_fail (sheet != NULL);
6545   g_return_if_fail (button != NULL);
6546
6547   rtl = gtk_widget_get_direction (GTK_WIDGET (sheet)) == GTK_TEXT_DIR_RTL;
6548
6549   gdk_window_clear_area (window,
6550                          allocation.x, allocation.y,
6551                          allocation.width, allocation.height);
6552
6553   gtk_paint_box (sheet->button->style, window,
6554                  GTK_STATE_NORMAL, GTK_SHADOW_OUT,
6555                  &allocation, GTK_WIDGET (sheet->button),
6556                  "buttondefault",
6557                  allocation.x, allocation.y,
6558                  allocation.width, allocation.height);
6559
6560   state = button->state;
6561   if (!is_sensitive) state = GTK_STATE_INSENSITIVE;
6562
6563   if (state == GTK_STATE_ACTIVE)
6564     shadow_type = GTK_SHADOW_IN;
6565   else
6566     shadow_type = GTK_SHADOW_OUT;
6567
6568   if (state != GTK_STATE_NORMAL && state != GTK_STATE_INSENSITIVE)
6569     gtk_paint_box (sheet->button->style, window,
6570                    button->state, shadow_type,
6571                    &allocation, GTK_WIDGET (sheet->button),
6572                    "button",
6573                    allocation.x, allocation.y,
6574                    allocation.width, allocation.height);
6575
6576   if (button->label_visible)
6577     {
6578
6579       text_height = DEFAULT_ROW_HEIGHT (GTK_WIDGET (sheet))- 2 * CELLOFFSET;
6580
6581       gdk_gc_set_clip_rectangle (GTK_WIDGET (sheet)->style->fg_gc[button->state],
6582                                  &allocation);
6583       gdk_gc_set_clip_rectangle (GTK_WIDGET (sheet)->style->white_gc, &allocation);
6584
6585       allocation.y += 2 * sheet->button->style->ythickness;
6586
6587
6588       if (button->label && strlen (button->label)>0)
6589         {
6590           gchar *words = 0;
6591           PangoLayout *layout = NULL;
6592           gint real_x = allocation.x, real_y = allocation.y;
6593
6594           words = button->label;
6595           line = g_new (gchar, 1);
6596           line[0]='\0';
6597
6598           while (words && *words != '\0')
6599             {
6600               if (*words != '\n')
6601                 {
6602                   len = strlen (line);
6603                   line = g_realloc (line, len + 2);
6604                   line[len]=*words;
6605                   line[len + 1]='\0';
6606                 }
6607               if (*words == '\n' || * (words + 1) == '\0')
6608                 {
6609                   text_width = STRING_WIDTH (GTK_WIDGET (sheet), GTK_WIDGET (sheet)->style->font_desc, line);
6610
6611                   layout = gtk_widget_create_pango_layout (GTK_WIDGET (sheet), line);
6612                   switch (button->justification)
6613                     {
6614                     case GTK_JUSTIFY_LEFT:
6615                       real_x = allocation.x + CELLOFFSET;
6616                       align = rtl ? PANGO_ALIGN_RIGHT : PANGO_ALIGN_LEFT;
6617                       break;
6618                     case GTK_JUSTIFY_RIGHT:
6619                       real_x = allocation.x + allocation.width - text_width - CELLOFFSET;
6620                       align = rtl ? PANGO_ALIGN_LEFT : PANGO_ALIGN_RIGHT;
6621                       break;
6622                     case GTK_JUSTIFY_CENTER:
6623                     default:
6624                       real_x = allocation.x + (allocation.width - text_width)/2;
6625                       align = rtl ? PANGO_ALIGN_RIGHT : PANGO_ALIGN_LEFT;
6626                       pango_layout_set_justify (layout, TRUE);
6627                     }
6628                   pango_layout_set_alignment (layout, align);
6629                   gtk_paint_layout (GTK_WIDGET (sheet)->style,
6630                                     window,
6631                                     state,
6632                                     FALSE,
6633                                     &allocation,
6634                                     GTK_WIDGET (sheet),
6635                                     "label",
6636                                     real_x, real_y,
6637                                     layout);
6638                   g_object_unref (G_OBJECT (layout));
6639
6640                   real_y += text_height + 2;
6641
6642                   g_free (line);
6643                   line = g_new (gchar, 1);
6644                   line[0]='\0';
6645                 }
6646               words++;
6647             }
6648           g_free (line);
6649         }
6650
6651       gdk_gc_set_clip_rectangle (GTK_WIDGET (sheet)->style->fg_gc[button->state],
6652                                  NULL);
6653       gdk_gc_set_clip_rectangle (GTK_WIDGET (sheet)->style->white_gc, NULL);
6654
6655     }
6656
6657   if ((child = button->child) && (child->widget))
6658     {
6659       child->x = allocation.x;
6660       child->y = allocation.y;
6661
6662       child->x += (allocation.width - child->widget->requisition.width) / 2;
6663       child->y += (allocation.height - child->widget->requisition.height) / 2;
6664       allocation.x = child->x;
6665       allocation.y = child->y;
6666       allocation.width = child->widget->requisition.width;
6667       allocation.height = child->widget->requisition.height;
6668
6669       allocation.x = child->x;
6670       allocation.y = child->y;
6671
6672       gtk_widget_set_state (child->widget, button->state);
6673
6674       if (GTK_WIDGET_REALIZED (GTK_WIDGET (sheet)) &&
6675           GTK_WIDGET_MAPPED (child->widget))
6676         {
6677           gtk_widget_size_allocate (child->widget,
6678                                     &allocation);
6679           gtk_widget_queue_draw (child->widget);
6680         }
6681     }
6682
6683   gtk_sheet_button_free (button);
6684 }
6685
6686
6687 /* COLUMN value of - 1 indicates that the area to the right of the rightmost
6688    button should be redrawn */
6689 static void
6690 gtk_sheet_column_title_button_draw (GtkSheet *sheet, gint column)
6691 {
6692   GdkWindow *window = NULL;
6693   GdkRectangle allocation;
6694   GtkSheetButton *button = NULL;
6695   gboolean is_sensitive = FALSE;
6696
6697   if (!GTK_WIDGET_REALIZED (GTK_WIDGET (sheet))) return;
6698
6699   if (column >= 0 && ! xxx_column_is_visible (sheet, column)) return;
6700   if (column >= 0 && !sheet->column_titles_visible) return;
6701   if (column >= 0 && column < MIN_VISIBLE_COLUMN (sheet)) return;
6702   if (column >= 0 && column > MAX_VISIBLE_COLUMN (sheet)) return;
6703
6704   window = sheet->column_title_window;
6705   allocation.y = 0;
6706   allocation.height = sheet->column_title_area.height;
6707
6708   if ( column == -1 )
6709     {
6710       const gint cols = xxx_column_count (sheet) ;
6711       allocation.x = COLUMN_LEFT_XPIXEL (sheet, cols - 1)
6712         ;
6713       allocation.width = sheet->column_title_area.width
6714         + sheet->column_title_area.x
6715         - allocation.x;
6716
6717       gdk_window_clear_area (window,
6718                              allocation.x, allocation.y,
6719                              allocation.width, allocation.height);
6720     }
6721   else
6722     {
6723       button = xxx_column_button (sheet, column);
6724       allocation.x = COLUMN_LEFT_XPIXEL (sheet, column) + CELL_SPACING;
6725       if (sheet->row_titles_visible)
6726         allocation.x -= sheet->row_title_area.width;
6727
6728       allocation.width = xxx_column_width (sheet, column);
6729
6730       is_sensitive = xxx_column_is_sensitive (sheet, column);
6731       gtk_sheet_button_draw (sheet, window, button,
6732                              is_sensitive, allocation);
6733     }
6734 }
6735
6736 static void
6737 gtk_sheet_row_title_button_draw (GtkSheet *sheet, gint row)
6738 {
6739   GdkWindow *window = NULL;
6740   GdkRectangle allocation;
6741   GtkSheetButton *button = NULL;
6742   gboolean is_sensitive = FALSE;
6743
6744
6745   if (!GTK_WIDGET_REALIZED (GTK_WIDGET (sheet))) return;
6746
6747   if (row >= 0 && !yyy_row_is_visible (sheet, row)) return;
6748   if (row >= 0 && !sheet->row_titles_visible) return;
6749   if (row >= 0 && row < MIN_VISIBLE_ROW (sheet)) return;
6750   if (row >= 0 && row > MAX_VISIBLE_ROW (sheet)) return;
6751
6752
6753   window = sheet->row_title_window;
6754   button = yyy_row_button (sheet, row);
6755   allocation.x = 0;
6756   allocation.y = ROW_TOP_YPIXEL (sheet, row) + CELL_SPACING;
6757   if (sheet->column_titles_visible)
6758     allocation.y -= sheet->column_title_area.height;
6759   allocation.width = sheet->row_title_area.width;
6760   allocation.height = yyy_row_height (sheet, row);
6761   is_sensitive = yyy_row_is_sensitive (sheet, row);
6762
6763   gtk_sheet_button_draw (sheet, window, button, is_sensitive, allocation);
6764 }
6765
6766 /* SCROLLBARS
6767  *
6768  * functions:
6769  * adjust_scrollbars
6770  * vadjustment_value_changed
6771  * hadjustment_value_changed */
6772
6773 static void
6774 adjust_scrollbars (GtkSheet * sheet)
6775 {
6776   if (sheet->vadjustment)
6777     {
6778       sheet->vadjustment->page_size = sheet->sheet_window_height;
6779       sheet->vadjustment->page_increment = sheet->sheet_window_height / 2;
6780       sheet->vadjustment->step_increment = DEFAULT_ROW_HEIGHT (GTK_WIDGET (sheet));
6781       sheet->vadjustment->lower = 0;
6782       sheet->vadjustment->upper = SHEET_HEIGHT (sheet) + 80;
6783       g_signal_emit_by_name (G_OBJECT (sheet->vadjustment), "changed");
6784
6785     }
6786
6787   if (sheet->hadjustment)
6788     {
6789       sheet->hadjustment->page_size = sheet->sheet_window_width;
6790       sheet->hadjustment->page_increment = sheet->sheet_window_width / 2;
6791       sheet->hadjustment->step_increment = DEFAULT_COLUMN_WIDTH;
6792       sheet->hadjustment->lower = 0;
6793       sheet->hadjustment->upper = SHEET_WIDTH (sheet)+ 80;
6794       g_signal_emit_by_name (G_OBJECT (sheet->hadjustment), "changed");
6795
6796     }
6797 }
6798
6799 static void
6800 vadjustment_value_changed (GtkAdjustment * adjustment,
6801                            gpointer data)
6802 {
6803   GtkSheet *sheet;
6804   gint diff, value, old_value;
6805   gint row, new_row;
6806   gint y = 0;
6807
6808   g_return_if_fail (adjustment != NULL);
6809   g_return_if_fail (data != NULL);
6810   g_return_if_fail (GTK_IS_SHEET (data));
6811
6812   sheet = GTK_SHEET (data);
6813
6814   if (GTK_SHEET_IS_FROZEN (sheet)) return;
6815
6816   row = ROW_FROM_YPIXEL (sheet,sheet->column_title_area.height + CELL_SPACING);
6817   if (!sheet->column_titles_visible)
6818     row = ROW_FROM_YPIXEL (sheet, CELL_SPACING);
6819
6820   old_value = - sheet->voffset;
6821
6822   new_row = g_sheet_row_pixel_to_row (sheet->row_geometry,
6823                                       adjustment->value,sheet);
6824
6825   y = g_sheet_row_start_pixel (sheet->row_geometry, new_row, sheet);
6826
6827   if (adjustment->value > sheet->old_vadjustment && sheet->old_vadjustment > 0. &&
6828       yyy_row_height (sheet, row) > sheet->vadjustment->step_increment)
6829     {
6830       /* This avoids embarrassing twitching */
6831       if (row == new_row && row != yyy_row_count (sheet) - 1 &&
6832           adjustment->value - sheet->old_vadjustment >=
6833           sheet->vadjustment->step_increment &&
6834           new_row + 1 != MIN_VISIBLE_ROW (sheet))
6835         {
6836           new_row +=1;
6837           y = y+yyy_row_height (sheet, row);
6838         }
6839     }
6840
6841   /* Negative old_adjustment enforces the redraw, otherwise avoid
6842      spureous redraw */
6843   if (sheet->old_vadjustment >= 0. && row == new_row)
6844     {
6845       sheet->old_vadjustment = sheet->vadjustment->value;
6846       return;
6847     }
6848
6849   sheet->old_vadjustment = sheet->vadjustment->value;
6850   adjustment->value = y;
6851
6852
6853   if (new_row == 0)
6854     {
6855       sheet->vadjustment->step_increment = yyy_row_height (sheet, 0);
6856     }
6857   else
6858     {
6859       sheet->vadjustment->step_increment =
6860         MIN (yyy_row_height (sheet, new_row), yyy_row_height (sheet, new_row - 1));
6861     }
6862
6863   sheet->vadjustment->value = adjustment->value;
6864
6865   value = adjustment->value;
6866
6867   if (value >= - sheet->voffset)
6868     {
6869       /* scroll down */
6870       diff = value + sheet->voffset;
6871     }
6872   else
6873     {
6874       /* scroll up */
6875       diff = - sheet->voffset - value;
6876     }
6877
6878   sheet->voffset = - value;
6879
6880   if (GTK_WIDGET_REALIZED (sheet->sheet_entry) &&
6881       sheet->state == GTK_SHEET_NORMAL &&
6882       sheet->active_cell.row >= 0 && sheet->active_cell.col >= 0 &&
6883       !gtk_sheet_cell_isvisible (sheet, sheet->active_cell.row,
6884                                  sheet->active_cell.col))
6885     {
6886       const gchar *text;
6887
6888       text = gtk_entry_get_text (GTK_ENTRY (gtk_sheet_get_entry (sheet)));
6889
6890       if (!text || strlen (text) == 0)
6891         gtk_sheet_cell_clear (sheet,
6892                               sheet->active_cell.row,
6893                               sheet->active_cell.col);
6894       gtk_widget_unmap (sheet->sheet_entry);
6895     }
6896
6897   gtk_sheet_position_children (sheet);
6898
6899   gtk_sheet_range_draw (sheet, NULL);
6900   size_allocate_row_title_buttons (sheet);
6901   size_allocate_global_button (sheet);
6902 }
6903
6904 static void
6905 hadjustment_value_changed (GtkAdjustment * adjustment,
6906                            gpointer data)
6907 {
6908   GtkSheet *sheet;
6909   gint i, diff, value, old_value;
6910   gint column, new_column;
6911   gint x = 0;
6912
6913   g_return_if_fail (adjustment != NULL);
6914   g_return_if_fail (data != NULL);
6915   g_return_if_fail (GTK_IS_SHEET (data));
6916
6917   sheet = GTK_SHEET (data);
6918
6919   if (GTK_SHEET_IS_FROZEN (sheet)) return;
6920
6921   column = COLUMN_FROM_XPIXEL (sheet,sheet->row_title_area.width + CELL_SPACING);
6922   if (!sheet->row_titles_visible)
6923     column = COLUMN_FROM_XPIXEL (sheet, CELL_SPACING);
6924
6925   old_value = - sheet->hoffset;
6926
6927   for (i = 0; i < xxx_column_count (sheet); i++)
6928     {
6929       if (xxx_column_is_visible (sheet, i)) x += xxx_column_width (sheet, i);
6930       if (x > adjustment->value) break;
6931     }
6932   x -= xxx_column_width (sheet, i);
6933   new_column = i;
6934
6935   if (adjustment->value > sheet->old_hadjustment && sheet->old_hadjustment > 0 &&
6936       xxx_column_width (sheet, i) > sheet->hadjustment->step_increment)
6937     {
6938       /* This avoids embarrassing twitching */
6939       if (column == new_column && column != xxx_column_count (sheet) - 1 &&
6940           adjustment->value - sheet->old_hadjustment >=
6941           sheet->hadjustment->step_increment &&
6942           new_column + 1 != MIN_VISIBLE_COLUMN (sheet))
6943         {
6944           new_column += 1;
6945           x += xxx_column_width (sheet, column);
6946         }
6947     }
6948
6949   /* Negative old_adjustment enforces the redraw, otherwise avoid spureous redraw */
6950   if (sheet->old_hadjustment >= 0. && new_column == column)
6951     {
6952       sheet->old_hadjustment = sheet->hadjustment->value;
6953       return;
6954     }
6955
6956   sheet->old_hadjustment = sheet->hadjustment->value;
6957   adjustment->value = x;
6958
6959   if (new_column == 0)
6960     {
6961       sheet->hadjustment->step_increment = xxx_column_width (sheet, 0);
6962     }
6963   else
6964     {
6965       sheet->hadjustment->step_increment =
6966         MIN (xxx_column_width (sheet, new_column), xxx_column_width (sheet, new_column - 1));
6967     }
6968
6969
6970   sheet->hadjustment->value = adjustment->value;
6971
6972   value = adjustment->value;
6973
6974   if (value >= - sheet->hoffset)
6975     {
6976       /* scroll right */
6977       diff = value + sheet->hoffset;
6978     }
6979   else
6980     {
6981       /* scroll left */
6982       diff = - sheet->hoffset - value;
6983     }
6984
6985   sheet->hoffset = - value;
6986   if (GTK_WIDGET_REALIZED (sheet->sheet_entry) &&
6987       sheet->state == GTK_SHEET_NORMAL &&
6988       sheet->active_cell.row >= 0 && sheet->active_cell.col >= 0 &&
6989       !gtk_sheet_cell_isvisible (sheet, sheet->active_cell.row,
6990                                  sheet->active_cell.col))
6991     {
6992       const gchar *text;
6993
6994       text = gtk_entry_get_text (GTK_ENTRY (gtk_sheet_get_entry (sheet)));
6995       if (!text || strlen (text) == 0)
6996         gtk_sheet_cell_clear (sheet,
6997                               sheet->active_cell.row,
6998                               sheet->active_cell.col);
6999
7000       gtk_widget_unmap (sheet->sheet_entry);
7001     }
7002
7003   gtk_sheet_position_children (sheet);
7004
7005   gtk_sheet_range_draw (sheet, NULL);
7006   size_allocate_column_title_buttons (sheet);
7007 }
7008
7009
7010 /* COLUMN RESIZING */
7011 static void
7012 draw_xor_vline (GtkSheet * sheet)
7013 {
7014   GtkWidget *widget;
7015
7016   g_return_if_fail (sheet != NULL);
7017
7018   widget = GTK_WIDGET (sheet);
7019
7020   gdk_draw_line (widget->window, sheet->xor_gc,
7021                  sheet->x_drag,
7022                  sheet->column_title_area.height,
7023                  sheet->x_drag,
7024                  sheet->sheet_window_height + 1);
7025 }
7026
7027 /* ROW RESIZING */
7028 static void
7029 draw_xor_hline (GtkSheet * sheet)
7030 {
7031   GtkWidget *widget;
7032
7033   g_return_if_fail (sheet != NULL);
7034
7035   widget = GTK_WIDGET (sheet);
7036
7037   gdk_draw_line (widget->window, sheet->xor_gc,
7038                  sheet->row_title_area.width,
7039                  sheet->y_drag,
7040
7041                  sheet->sheet_window_width + 1,
7042                  sheet->y_drag);
7043 }
7044
7045 /* SELECTED RANGE */
7046 static void
7047 draw_xor_rectangle (GtkSheet *sheet, GtkSheetRange range)
7048 {
7049   gint i;
7050   GdkRectangle clip_area, area;
7051   GdkGCValues values;
7052
7053   area.x = COLUMN_LEFT_XPIXEL (sheet, range.col0);
7054   area.y = ROW_TOP_YPIXEL (sheet, range.row0);
7055   area.width = COLUMN_LEFT_XPIXEL (sheet, range.coli)- area.x+
7056     xxx_column_width (sheet, range.coli);
7057   area.height = ROW_TOP_YPIXEL (sheet, range.rowi)- area.y+
7058     yyy_row_height (sheet, range.rowi);
7059
7060   clip_area.x = sheet->row_title_area.width;
7061   clip_area.y = sheet->column_title_area.height;
7062   clip_area.width = sheet->sheet_window_width;
7063   clip_area.height = sheet->sheet_window_height;
7064
7065   if (!sheet->row_titles_visible) clip_area.x = 0;
7066   if (!sheet->column_titles_visible) clip_area.y = 0;
7067
7068   if (area.x < 0)
7069     {
7070       area.width = area.width + area.x;
7071       area.x = 0;
7072     }
7073   if (area.width > clip_area.width) area.width = clip_area.width + 10;
7074   if (area.y < 0)
7075     {
7076       area.height = area.height + area.y;
7077       area.y = 0;
7078     }
7079   if (area.height > clip_area.height) area.height = clip_area.height + 10;
7080
7081   clip_area.x--;
7082   clip_area.y--;
7083   clip_area.width += 3;
7084   clip_area.height += 3;
7085
7086   gdk_gc_get_values (sheet->xor_gc, &values);
7087
7088   gdk_gc_set_clip_rectangle (sheet->xor_gc, &clip_area);
7089
7090   for (i =- 1; i <= 1; ++i)
7091     gdk_draw_rectangle (sheet->sheet_window,
7092                         sheet->xor_gc,
7093                         FALSE,
7094                         area.x + i, area.y + i,
7095                         area.width - 2 * i, area.height - 2 * i);
7096
7097
7098   gdk_gc_set_clip_rectangle (sheet->xor_gc, NULL);
7099
7100   gdk_gc_set_foreground (sheet->xor_gc, &values.foreground);
7101
7102 }
7103
7104
7105 /* this function returns the new width of the column being resized given
7106  * the column and x position of the cursor; the x cursor position is passed
7107  * in as a pointer and automaticaly corrected if it's beyond min / max limits */
7108 static guint
7109 new_column_width (GtkSheet * sheet,
7110                   gint column,
7111                   gint * x)
7112 {
7113   gint cx, width;
7114   guint min_width;
7115
7116   cx = *x;
7117
7118   min_width = sheet->column_requisition;
7119
7120   /* you can't shrink a column to less than its minimum width */
7121   if (cx < COLUMN_LEFT_XPIXEL (sheet, column) + min_width)
7122     {
7123       *x = cx = COLUMN_LEFT_XPIXEL (sheet, column) + min_width;
7124     }
7125
7126   /* calculate new column width making sure it doesn't end up
7127    * less than the minimum width */
7128   width = cx - COLUMN_LEFT_XPIXEL (sheet, column);
7129   if (width < min_width)
7130     width = min_width;
7131
7132   xxx_set_column_width (sheet, column, width);
7133   size_allocate_column_title_buttons (sheet);
7134
7135   return width;
7136 }
7137
7138 /* this function returns the new height of the row being resized given
7139  * the row and y position of the cursor; the y cursor position is passed
7140  * in as a pointer and automaticaly corrected if it's beyond min / max limits */
7141 static guint
7142 new_row_height (GtkSheet * sheet,
7143                 gint row,
7144                 gint * y)
7145 {
7146   gint cy, height;
7147   guint min_height;
7148
7149   cy = *y;
7150   min_height = sheet->row_requisition;
7151
7152   /* you can't shrink a row to less than its minimum height */
7153   if (cy < ROW_TOP_YPIXEL (sheet, row) + min_height)
7154
7155     {
7156       *y = cy = ROW_TOP_YPIXEL (sheet, row) + min_height;
7157     }
7158
7159   /* calculate new row height making sure it doesn't end up
7160    * less than the minimum height */
7161   height = (cy - ROW_TOP_YPIXEL (sheet, row));
7162   if (height < min_height)
7163     height = min_height;
7164
7165   yyy_set_row_height (sheet, row, height);
7166   size_allocate_row_title_buttons (sheet);
7167
7168   return height;
7169 }
7170
7171 static void
7172 gtk_sheet_set_column_width (GtkSheet * sheet,
7173                             gint column,
7174                             guint width)
7175 {
7176   guint min_width;
7177
7178   g_return_if_fail (sheet != NULL);
7179   g_return_if_fail (GTK_IS_SHEET (sheet));
7180
7181   if (column < 0 || column >= xxx_column_count (sheet))
7182     return;
7183
7184   gtk_sheet_column_size_request (sheet, column, &min_width);
7185   if (width < min_width) return;
7186
7187   xxx_set_column_width (sheet, column, width);
7188
7189   if (GTK_WIDGET_REALIZED (GTK_WIDGET (sheet)) && !GTK_SHEET_IS_FROZEN (sheet))
7190     {
7191       size_allocate_column_title_buttons (sheet);
7192       adjust_scrollbars (sheet);
7193       gtk_sheet_size_allocate_entry (sheet);
7194       gtk_sheet_range_draw (sheet, NULL);
7195     }
7196
7197   g_signal_emit (G_OBJECT (sheet), sheet_signals[CHANGED], 0, -1, column);
7198   g_signal_emit (G_OBJECT (sheet), sheet_signals[NEW_COL_WIDTH], 0,
7199                  column, width);
7200 }
7201
7202
7203
7204 void
7205 gtk_sheet_set_row_height (GtkSheet * sheet,
7206                           gint row,
7207                           guint height)
7208 {
7209   guint min_height;
7210
7211   g_return_if_fail (sheet != NULL);
7212   g_return_if_fail (GTK_IS_SHEET (sheet));
7213
7214   if (row < 0 || row >= yyy_row_count (sheet))
7215     return;
7216
7217   gtk_sheet_row_size_request (sheet, row, &min_height);
7218   if (height < min_height) return;
7219
7220   yyy_set_row_height (sheet, row, height);
7221
7222   if (GTK_WIDGET_REALIZED (GTK_WIDGET (sheet)) && !GTK_SHEET_IS_FROZEN (sheet))
7223     {
7224       size_allocate_row_title_buttons (sheet);
7225       adjust_scrollbars (sheet);
7226       gtk_sheet_size_allocate_entry (sheet);
7227       gtk_sheet_range_draw (sheet, NULL);
7228     }
7229
7230   g_signal_emit (G_OBJECT (sheet), sheet_signals[CHANGED], 0, row, - 1);
7231   g_signal_emit (G_OBJECT (sheet), sheet_signals[NEW_ROW_HEIGHT], 0,
7232                  row, height);
7233
7234 }
7235
7236
7237 gboolean
7238 gtk_sheet_get_attributes (const GtkSheet *sheet, gint row, gint col,
7239                           GtkSheetCellAttr *attributes)
7240 {
7241   const GdkColor *fg, *bg;
7242   const GtkJustification *j ;
7243   const PangoFontDescription *font_desc ;
7244   const GtkSheetCellBorder *border ;
7245
7246   g_return_val_if_fail (sheet != NULL, FALSE);
7247   g_return_val_if_fail (GTK_IS_SHEET (sheet), FALSE);
7248
7249   if (row < 0 || col < 0) return FALSE;
7250
7251   init_attributes (sheet, col, attributes);
7252
7253   if ( !sheet->model)
7254     return FALSE;
7255
7256   attributes->is_editable = g_sheet_model_is_editable (sheet->model, row, col);
7257   attributes->is_visible = g_sheet_model_is_visible (sheet->model, row, col);
7258
7259   fg = g_sheet_model_get_foreground (sheet->model, row, col);
7260   if ( fg )
7261     attributes->foreground = *fg;
7262
7263   bg = g_sheet_model_get_background (sheet->model, row, col);
7264   if ( bg )
7265     attributes->background = *bg;
7266
7267   j = g_sheet_model_get_justification (sheet->model, row, col);
7268   if (j) attributes->justification = *j;
7269
7270   font_desc = g_sheet_model_get_font_desc (sheet->model, row, col);
7271   if ( font_desc ) attributes->font_desc = font_desc;
7272
7273   border = g_sheet_model_get_cell_border (sheet->model, row, col);
7274
7275   if ( border ) attributes->border = *border;
7276
7277   return TRUE;
7278 }
7279
7280 static void
7281 init_attributes (const GtkSheet *sheet, gint col, GtkSheetCellAttr *attributes)
7282 {
7283   /* DEFAULT VALUES */
7284   attributes->foreground = GTK_WIDGET (sheet)->style->black;
7285   attributes->background = sheet->bg_color;
7286   if (!GTK_WIDGET_REALIZED (GTK_WIDGET (sheet)))
7287     {
7288       GdkColormap *colormap;
7289       colormap = gdk_colormap_get_system ();
7290       gdk_color_black (colormap, &attributes->foreground);
7291       attributes->background = sheet->bg_color;
7292     }
7293   attributes->justification = xxx_column_justification (sheet, col);
7294   attributes->border.width = 0;
7295   attributes->border.line_style = GDK_LINE_SOLID;
7296   attributes->border.cap_style = GDK_CAP_NOT_LAST;
7297   attributes->border.join_style = GDK_JOIN_MITER;
7298   attributes->border.mask = 0;
7299   attributes->border.color = GTK_WIDGET (sheet)->style->black;
7300   attributes->is_editable = TRUE;
7301   attributes->is_visible = TRUE;
7302   attributes->font_desc = GTK_WIDGET (sheet)->style->font_desc;
7303 }
7304
7305
7306 /********************************************************************
7307  * Container Functions:
7308  * gtk_sheet_add
7309  * gtk_sheet_put
7310  * gtk_sheet_attach
7311  * gtk_sheet_remove
7312  * gtk_sheet_move_child
7313  * gtk_sheet_position_child
7314  * gtk_sheet_position_children
7315  * gtk_sheet_realize_child
7316  * gtk_sheet_get_child_at
7317  ********************************************************************/
7318
7319 GtkSheetChild *
7320 gtk_sheet_put (GtkSheet *sheet, GtkWidget *child, gint x, gint y)
7321 {
7322   GtkRequisition child_requisition;
7323   GtkSheetChild *child_info;
7324
7325   g_return_val_if_fail (sheet != NULL, NULL);
7326   g_return_val_if_fail (GTK_IS_SHEET (sheet), NULL);
7327   g_return_val_if_fail (child != NULL, NULL);
7328   g_return_val_if_fail (child->parent == NULL, NULL);
7329
7330   child_info = g_new (GtkSheetChild, 1);
7331   child_info->widget = child;
7332   child_info->x = x;
7333   child_info->y = y;
7334   child_info->attached_to_cell = FALSE;
7335   child_info->floating = TRUE;
7336   child_info->xpadding = child_info->ypadding = 0;
7337   child_info->xexpand = child_info->yexpand = FALSE;
7338   child_info->xshrink = child_info->yshrink = FALSE;
7339   child_info->xfill = child_info->yfill = FALSE;
7340
7341   sheet->children = g_list_append (sheet->children, child_info);
7342
7343   gtk_widget_set_parent (child, GTK_WIDGET (sheet));
7344
7345   gtk_widget_size_request (child, &child_requisition);
7346
7347   if (GTK_WIDGET_VISIBLE (GTK_WIDGET (sheet)))
7348     {
7349       if (GTK_WIDGET_REALIZED (GTK_WIDGET (sheet)) &&
7350           (!GTK_WIDGET_REALIZED (child) || GTK_WIDGET_NO_WINDOW (child)))
7351         gtk_sheet_realize_child (sheet, child_info);
7352
7353       if (GTK_WIDGET_MAPPED (GTK_WIDGET (sheet)) &&
7354           !GTK_WIDGET_MAPPED (child))
7355         gtk_widget_map (child);
7356     }
7357
7358   gtk_sheet_position_child (sheet, child_info);
7359
7360   /* This will avoid drawing on the titles */
7361
7362   if (GTK_WIDGET_REALIZED (GTK_WIDGET (sheet)))
7363     {
7364       if (sheet->row_titles_visible)
7365         gdk_window_show (sheet->row_title_window);
7366       if (sheet->column_titles_visible)
7367         gdk_window_show (sheet->column_title_window);
7368     }
7369
7370   return (child_info);
7371 }
7372
7373 void
7374 gtk_sheet_attach_floating (GtkSheet *sheet,
7375                            GtkWidget *widget,
7376                            gint row, gint col)
7377 {
7378   GdkRectangle area;
7379   GtkSheetChild *child;
7380
7381   if (row < 0 || col < 0)
7382     {
7383       gtk_sheet_button_attach (sheet, widget, row, col);
7384       return;
7385     }
7386
7387   gtk_sheet_get_cell_area (sheet, row, col, &area);
7388   child = gtk_sheet_put (sheet, widget, area.x, area.y);
7389   child->attached_to_cell = TRUE;
7390   child->row = row;
7391   child->col = col;
7392 }
7393
7394 void
7395 gtk_sheet_attach_default (GtkSheet *sheet,
7396                           GtkWidget *widget,
7397                           gint row, gint col)
7398 {
7399   if (row < 0 || col < 0)
7400     {
7401       gtk_sheet_button_attach (sheet, widget, row, col);
7402       return;
7403     }
7404
7405   gtk_sheet_attach (sheet, widget, row, col,
7406                     GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
7407 }
7408
7409 void
7410 gtk_sheet_attach (GtkSheet *sheet,
7411                   GtkWidget *widget,
7412                   gint row, gint col,
7413                   gint xoptions,
7414                   gint yoptions,
7415                   gint xpadding,
7416                   gint ypadding)
7417 {
7418   GdkRectangle area;
7419   GtkSheetChild *child = NULL;
7420
7421   if (row < 0 || col < 0)
7422     {
7423       gtk_sheet_button_attach (sheet, widget, row, col);
7424       return;
7425     }
7426
7427   child = g_new0 (GtkSheetChild, 1);
7428   child->attached_to_cell = TRUE;
7429   child->floating = FALSE;
7430   child->widget = widget;
7431   child->row = row;
7432   child->col = col;
7433   child->xpadding = xpadding;
7434   child->ypadding = ypadding;
7435   child->xexpand = (xoptions & GTK_EXPAND) != 0;
7436   child->yexpand = (yoptions & GTK_EXPAND) != 0;
7437   child->xshrink = (xoptions & GTK_SHRINK) != 0;
7438   child->yshrink = (yoptions & GTK_SHRINK) != 0;
7439   child->xfill = (xoptions & GTK_FILL) != 0;
7440   child->yfill = (yoptions & GTK_FILL) != 0;
7441
7442   sheet->children = g_list_append (sheet->children, child);
7443
7444   gtk_sheet_get_cell_area (sheet, row, col, &area);
7445
7446   child->x = area.x + child->xpadding;
7447   child->y = area.y + child->ypadding;
7448
7449   if (GTK_WIDGET_VISIBLE (GTK_WIDGET (sheet)))
7450     {
7451       if (GTK_WIDGET_REALIZED (GTK_WIDGET (sheet)) &&
7452           (!GTK_WIDGET_REALIZED (widget) || GTK_WIDGET_NO_WINDOW (widget)))
7453         gtk_sheet_realize_child (sheet, child);
7454
7455       if (GTK_WIDGET_MAPPED (GTK_WIDGET (sheet)) &&
7456           !GTK_WIDGET_MAPPED (widget))
7457         gtk_widget_map (widget);
7458     }
7459
7460   gtk_sheet_position_child (sheet, child);
7461
7462   /* This will avoid drawing on the titles */
7463
7464   if (GTK_WIDGET_REALIZED (GTK_WIDGET (sheet)))
7465     {
7466       if (GTK_SHEET_ROW_TITLES_VISIBLE (sheet))
7467         gdk_window_show (sheet->row_title_window);
7468       if (GTK_SHEET_COL_TITLES_VISIBLE (sheet))
7469         gdk_window_show (sheet->column_title_window);
7470     }
7471
7472 }
7473
7474 void
7475 gtk_sheet_button_attach          (GtkSheet *sheet,
7476                                   GtkWidget *widget,
7477                                   gint row, gint col)
7478 {
7479   GtkSheetButton *button = 0;
7480   GtkSheetChild *child;
7481   GtkRequisition button_requisition;
7482
7483   if (row >= 0 && col >= 0) return;
7484   if (row < 0 && col < 0) return;
7485
7486   child = g_new (GtkSheetChild, 1);
7487   child->widget = widget;
7488   child->x = 0;
7489   child->y = 0;
7490   child->attached_to_cell = TRUE;
7491   child->floating = FALSE;
7492   child->row = row;
7493   child->col = col;
7494   child->xpadding = child->ypadding = 0;
7495   child->xshrink = child->yshrink = FALSE;
7496   child->xfill = child->yfill = FALSE;
7497
7498
7499   sheet->children = g_list_append (sheet->children, child);
7500
7501   gtk_sheet_button_size_request (sheet, button, &button_requisition);
7502
7503
7504   if (GTK_WIDGET_VISIBLE (GTK_WIDGET (sheet)))
7505     {
7506       if (GTK_WIDGET_REALIZED (GTK_WIDGET (sheet)) &&
7507           (!GTK_WIDGET_REALIZED (widget) || GTK_WIDGET_NO_WINDOW (widget)))
7508         gtk_sheet_realize_child (sheet, child);
7509
7510       if (GTK_WIDGET_MAPPED (GTK_WIDGET (sheet)) &&
7511           !GTK_WIDGET_MAPPED (widget))
7512         gtk_widget_map (widget);
7513     }
7514
7515   if (row == -1) size_allocate_column_title_buttons (sheet);
7516   if (col == -1) size_allocate_row_title_buttons (sheet);
7517
7518 }
7519
7520 static void
7521 label_size_request (GtkSheet *sheet, gchar *label, GtkRequisition *req)
7522 {
7523   gchar *words;
7524   gchar word[1000];
7525   gint n = 0;
7526   gint row_height = DEFAULT_ROW_HEIGHT (GTK_WIDGET (sheet)) - 2 * CELLOFFSET + 2;
7527
7528   req->height = 0;
7529   req->width = 0;
7530   words = label;
7531
7532   while (words && *words != '\0')
7533     {
7534       if (*words == '\n' || * (words + 1) == '\0')
7535         {
7536           req->height += row_height;
7537
7538           word[n] = '\0';
7539           req->width = MAX (req->width, STRING_WIDTH (GTK_WIDGET (sheet), GTK_WIDGET (sheet)->style->font_desc, word));
7540           n = 0;
7541         }
7542       else
7543         {
7544           word[n++] = *words;
7545         }
7546       words++;
7547     }
7548
7549   if (n > 0) req->height -= 2;
7550 }
7551
7552 static void
7553 gtk_sheet_button_size_request    (GtkSheet *sheet,
7554                                   const GtkSheetButton *button,
7555                                   GtkRequisition *button_requisition)
7556 {
7557   GtkRequisition requisition;
7558   GtkRequisition label_requisition;
7559
7560   if (gtk_sheet_autoresize (sheet) && button->label && strlen (button->label) > 0)
7561     {
7562       label_size_request (sheet, button->label, &label_requisition);
7563       label_requisition.width += 2 * CELLOFFSET;
7564       label_requisition.height += 2 * CELLOFFSET;
7565     }
7566   else
7567     {
7568       label_requisition.height = DEFAULT_ROW_HEIGHT (GTK_WIDGET (sheet));
7569       label_requisition.width = COLUMN_MIN_WIDTH;
7570     }
7571
7572   if (button->child)
7573     {
7574       gtk_widget_size_request (button->child->widget, &requisition);
7575       requisition.width += 2 * button->child->xpadding;
7576       requisition.height += 2 * button->child->ypadding;
7577       requisition.width += 2 * sheet->button->style->xthickness;
7578       requisition.height += 2 * sheet->button->style->ythickness;
7579     }
7580   else
7581     {
7582       requisition.height = DEFAULT_ROW_HEIGHT (GTK_WIDGET (sheet));
7583       requisition.width = COLUMN_MIN_WIDTH;
7584     }
7585
7586   *button_requisition = requisition;
7587   button_requisition->width = MAX (requisition.width, label_requisition.width);
7588   button_requisition->height = MAX (requisition.height, label_requisition.height);
7589
7590 }
7591
7592 static void
7593 gtk_sheet_row_size_request (GtkSheet *sheet,
7594                             gint row,
7595                             guint *requisition)
7596 {
7597   GtkRequisition button_requisition;
7598   GList *children;
7599
7600   gtk_sheet_button_size_request (sheet,
7601                                  yyy_row_button (sheet, row),
7602                                  &button_requisition);
7603
7604   *requisition = button_requisition.height;
7605
7606   children = sheet->children;
7607   while (children)
7608     {
7609       GtkSheetChild *child = (GtkSheetChild *)children->data;
7610       GtkRequisition child_requisition;
7611
7612       if (child->attached_to_cell && child->row == row && child->col != -1 && !child->floating && !child->yshrink)
7613         {
7614           gtk_widget_get_child_requisition (child->widget, &child_requisition);
7615
7616           if (child_requisition.height + 2 * child->ypadding > *requisition)
7617             *requisition = child_requisition.height + 2 * child->ypadding;
7618         }
7619       children = children->next;
7620     }
7621
7622   sheet->row_requisition = * requisition;
7623 }
7624
7625 static void
7626 gtk_sheet_column_size_request (GtkSheet *sheet,
7627                                gint col,
7628                                guint *requisition)
7629 {
7630   GtkRequisition button_requisition;
7631   GList *children;
7632
7633   gtk_sheet_button_size_request (sheet,
7634                                  xxx_column_button (sheet, col),
7635                                  &button_requisition);
7636
7637   *requisition = button_requisition.width;
7638
7639   children = sheet->children;
7640   while (children)
7641     {
7642       GtkSheetChild *child = (GtkSheetChild *)children->data;
7643       GtkRequisition child_requisition;
7644
7645       if (child->attached_to_cell && child->col == col && child->row != -1 && !child->floating && !child->xshrink)
7646         {
7647           gtk_widget_get_child_requisition (child->widget, &child_requisition);
7648
7649           if (child_requisition.width + 2 * child->xpadding > *requisition)
7650             *requisition = child_requisition.width + 2 * child->xpadding;
7651         }
7652       children = children->next;
7653     }
7654
7655   sheet->column_requisition = *requisition;
7656 }
7657
7658 void
7659 gtk_sheet_move_child (GtkSheet *sheet, GtkWidget *widget, gint x, gint y)
7660 {
7661   GtkSheetChild *child;
7662   GList *children;
7663
7664   g_return_if_fail (sheet != NULL);
7665   g_return_if_fail (GTK_IS_SHEET (sheet));
7666
7667   children = sheet->children;
7668   while (children)
7669     {
7670       child = children->data;
7671
7672       if (child->widget == widget)
7673         {
7674           child->x = x;
7675           child->y = y;
7676           child->row = ROW_FROM_YPIXEL (sheet, y);
7677           child->col = COLUMN_FROM_XPIXEL (sheet, x);
7678           gtk_sheet_position_child (sheet, child);
7679           return;
7680         }
7681
7682       children = children->next;
7683     }
7684
7685   g_warning ("Widget must be a GtkSheet child");
7686
7687 }
7688
7689 static void
7690 gtk_sheet_position_child (GtkSheet *sheet, GtkSheetChild *child)
7691 {
7692   GtkRequisition child_requisition;
7693   GtkAllocation child_allocation;
7694   gint xoffset = 0;
7695   gint yoffset = 0;
7696   gint x = 0, y = 0;
7697   GdkRectangle area;
7698
7699   gtk_widget_get_child_requisition (child->widget, &child_requisition);
7700
7701   if (sheet->column_titles_visible)
7702     yoffset = sheet->column_title_area.height;
7703
7704   if (sheet->row_titles_visible)
7705     xoffset = sheet->row_title_area.width;
7706
7707   if (child->attached_to_cell)
7708     {
7709       gtk_sheet_get_cell_area (sheet, child->row, child->col, &area);
7710       child->x = area.x + child->xpadding;
7711       child->y = area.y + child->ypadding;
7712
7713       if (!child->floating)
7714         {
7715           if (child_requisition.width + 2 * child->xpadding <= xxx_column_width (sheet, child->col))
7716             {
7717               if (child->xfill)
7718                 {
7719                   child_requisition.width = child_allocation.width = xxx_column_width (sheet, child->col) - 2 * child->xpadding;
7720                 }
7721               else
7722                 {
7723                   if (child->xexpand)
7724                     {
7725                       child->x = area.x + xxx_column_width (sheet, child->col) / 2 -
7726                         child_requisition.width / 2;
7727                     }
7728                   child_allocation.width = child_requisition.width;
7729                 }
7730             }
7731           else
7732             {
7733               if (!child->xshrink)
7734                 {
7735                   gtk_sheet_set_column_width (sheet, child->col, child_requisition.width + 2 * child->xpadding);
7736                 }
7737               child_allocation.width = xxx_column_width (sheet, child->col) - 2 * child->xpadding;
7738             }
7739
7740           if (child_requisition.height +
7741               2 * child->ypadding <= yyy_row_height (sheet, child->row))
7742             {
7743               if (child->yfill)
7744                 {
7745                   child_requisition.height = child_allocation.height =
7746                     yyy_row_height (sheet, child->row) - 2 * child->ypadding;
7747                 }
7748               else
7749                 {
7750                   if (child->yexpand)
7751                     {
7752                       child->y = area.y + yyy_row_height (sheet, child->row) / 2
7753                         - child_requisition.height / 2;
7754                     }
7755                   child_allocation.height = child_requisition.height;
7756                 }
7757             }
7758           else
7759             {
7760               if (!child->yshrink)
7761                 {
7762                   gtk_sheet_set_row_height (sheet, child->row, child_requisition.height + 2 * child->ypadding);
7763                 }
7764               child_allocation.height = yyy_row_height (sheet, child->row) -
7765                 2 * child->ypadding;
7766             }
7767         }
7768       else
7769         {
7770           child_allocation.width = child_requisition.width;
7771           child_allocation.height = child_requisition.height;
7772         }
7773
7774       x = child_allocation.x = child->x + xoffset;
7775       y = child_allocation.y = child->y + yoffset;
7776     }
7777   else
7778     {
7779       x = child_allocation.x = child->x + sheet->hoffset + xoffset;
7780       x = child_allocation.x = child->x + xoffset;
7781       y = child_allocation.y = child->y + sheet->voffset + yoffset;
7782       y = child_allocation.y = child->y + yoffset;
7783       child_allocation.width = child_requisition.width;
7784       child_allocation.height = child_requisition.height;
7785     }
7786
7787   gtk_widget_size_allocate (child->widget, &child_allocation);
7788   gtk_widget_queue_draw (child->widget);
7789 }
7790
7791 static void
7792 gtk_sheet_forall (GtkContainer *container,
7793                   gboolean include_internals,
7794                   GtkCallback callback,
7795                   gpointer callback_data)
7796 {
7797   GtkSheet *sheet;
7798   GtkSheetChild *child;
7799   GList *children;
7800
7801   g_return_if_fail (GTK_IS_SHEET (container));
7802   g_return_if_fail (callback != NULL);
7803
7804   sheet = GTK_SHEET (container);
7805   children = sheet->children;
7806   while (children)
7807     {
7808       child = children->data;
7809       children = children->next;
7810
7811       (* callback) (child->widget, callback_data);
7812     }
7813   if (sheet->button)
7814     (* callback) (sheet->button, callback_data);
7815   if (sheet->sheet_entry)
7816     (* callback) (sheet->sheet_entry, callback_data);
7817 }
7818
7819
7820 static void
7821 gtk_sheet_position_children (GtkSheet *sheet)
7822 {
7823   GList *children;
7824   GtkSheetChild *child;
7825
7826   children = sheet->children;
7827
7828   while (children)
7829     {
7830       child = (GtkSheetChild *)children->data;
7831
7832       if (child->col != -1 && child->row != -1)
7833         gtk_sheet_position_child (sheet, child);
7834
7835       if (child->row == -1)
7836         {
7837           if (child->col < MIN_VISIBLE_COLUMN (sheet) ||
7838               child->col > MAX_VISIBLE_COLUMN (sheet))
7839             gtk_sheet_child_hide (child);
7840           else
7841             gtk_sheet_child_show (child);
7842         }
7843       if (child->col == -1)
7844         {
7845           if (child->row < MIN_VISIBLE_ROW (sheet) ||
7846               child->row > MAX_VISIBLE_ROW (sheet))
7847             gtk_sheet_child_hide (child);
7848           else
7849             gtk_sheet_child_show (child);
7850         }
7851
7852       children = children->next;
7853     }
7854 }
7855
7856 static void
7857 gtk_sheet_remove (GtkContainer *container, GtkWidget *widget)
7858 {
7859   GtkSheet *sheet;
7860   GList *children;
7861   GtkSheetChild *child = 0;
7862
7863   g_return_if_fail (container != NULL);
7864   g_return_if_fail (GTK_IS_SHEET (container));
7865
7866   sheet = GTK_SHEET (container);
7867
7868   children = sheet->children;
7869
7870   while (children)
7871     {
7872       child = (GtkSheetChild *)children->data;
7873
7874       if (child->widget == widget) break;
7875
7876       children = children->next;
7877     }
7878
7879   if (children)
7880     {
7881       gtk_widget_unparent (widget);
7882       child->widget = NULL;
7883
7884       sheet->children = g_list_remove_link (sheet->children, children);
7885       g_list_free_1 (children);
7886       g_free (child);
7887     }
7888
7889 }
7890
7891 static void
7892 gtk_sheet_realize_child (GtkSheet *sheet, GtkSheetChild *child)
7893 {
7894   GtkWidget *widget;
7895
7896   widget = GTK_WIDGET (sheet);
7897
7898   if (GTK_WIDGET_REALIZED (widget))
7899     {
7900       if (child->row == -1)
7901         gtk_widget_set_parent_window (child->widget, sheet->column_title_window);
7902       else if (child->col == -1)
7903         gtk_widget_set_parent_window (child->widget, sheet->row_title_window);
7904       else
7905         gtk_widget_set_parent_window (child->widget, sheet->sheet_window);
7906     }
7907
7908   gtk_widget_set_parent (child->widget, widget);
7909 }
7910
7911
7912
7913 GtkSheetChild *
7914 gtk_sheet_get_child_at (GtkSheet *sheet, gint row, gint col)
7915 {
7916   GList *children;
7917   GtkSheetChild *child = 0;
7918
7919   g_return_val_if_fail (sheet != NULL, NULL);
7920   g_return_val_if_fail (GTK_IS_SHEET (sheet), NULL);
7921
7922   children = sheet->children;
7923
7924   while (children)
7925     {
7926       child = (GtkSheetChild *)children->data;
7927
7928       if (child->attached_to_cell)
7929         if (child->row == row && child->col == col) break;
7930
7931       children = children->next;
7932     }
7933
7934   if (children) return child;
7935
7936   return NULL;
7937 }
7938
7939 static void
7940 gtk_sheet_child_hide (GtkSheetChild *child)
7941 {
7942   g_return_if_fail (child != NULL);
7943   gtk_widget_hide (child->widget);
7944 }
7945
7946 static void
7947 gtk_sheet_child_show (GtkSheetChild *child)
7948 {
7949   g_return_if_fail (child != NULL);
7950
7951   gtk_widget_show (child->widget);
7952 }
7953
7954 GSheetModel *
7955 gtk_sheet_get_model (const GtkSheet *sheet)
7956 {
7957   g_return_val_if_fail (GTK_IS_SHEET (sheet), NULL);
7958
7959   return sheet->model;
7960 }
7961
7962
7963 GtkSheetButton *
7964 gtk_sheet_button_new (void)
7965 {
7966   GtkSheetButton *button = g_malloc (sizeof (GtkSheetButton));
7967
7968   button->state = GTK_STATE_NORMAL;
7969   button->label = NULL;
7970   button->label_visible = TRUE;
7971   button->child = NULL;
7972   button->justification = GTK_JUSTIFY_FILL;
7973
7974   return button;
7975 }
7976
7977
7978 inline void
7979 gtk_sheet_button_free (GtkSheetButton *button)
7980 {
7981   if (!button) return ;
7982
7983   g_free (button->label);
7984   g_free (button);
7985 }
7986
7987
7988 static GString *
7989 range_to_text (const GtkSheet *sheet)
7990 {
7991   gchar *celltext = NULL;
7992   gint r, c;
7993   GString *string;
7994
7995   if ( !gtk_sheet_range_isvisible (sheet, sheet->range))
7996     return NULL;
7997
7998   string = g_string_sized_new (80);
7999
8000   for (r = sheet->range.row0; r <= sheet->range.rowi; ++r)
8001     {
8002       for (c = sheet->range.col0; c < sheet->range.coli; ++c)
8003         {
8004           celltext = gtk_sheet_cell_get_text (sheet, r, c);
8005           g_string_append (string, celltext);
8006           g_string_append (string, "\t");
8007           g_free (celltext);
8008         }
8009       celltext = gtk_sheet_cell_get_text (sheet, r, c);
8010       g_string_append (string, celltext);
8011       if ( r < sheet->range.rowi)
8012         g_string_append (string, "\n");
8013       g_free (celltext);
8014     }
8015
8016   return string;
8017 }
8018
8019 static GString *
8020 range_to_html (const GtkSheet *sheet)
8021 {
8022   gchar *celltext = NULL;
8023   gint r, c;
8024   GString *string;
8025
8026   if ( !gtk_sheet_range_isvisible (sheet, sheet->range))
8027     return NULL;
8028
8029   string = g_string_sized_new (480);
8030
8031   g_string_append (string, "<html>\n");
8032   g_string_append (string, "<body>\n");
8033   g_string_append (string, "<table>\n");
8034   for (r = sheet->range.row0; r <= sheet->range.rowi; ++r)
8035     {
8036       g_string_append (string, "<tr>\n");
8037       for (c = sheet->range.col0; c <= sheet->range.coli; ++c)
8038         {
8039           g_string_append (string, "<td>");
8040           celltext = gtk_sheet_cell_get_text (sheet, r, c);
8041           g_string_append (string, celltext);
8042           g_string_append (string, "</td>\n");
8043           g_free (celltext);
8044         }
8045       g_string_append (string, "</tr>\n");
8046     }
8047   g_string_append (string, "</table>\n");
8048   g_string_append (string, "</body>\n");
8049   g_string_append (string, "</html>\n");
8050
8051   return string;
8052 }
8053
8054 enum {
8055   SELECT_FMT_NULL,
8056   SELECT_FMT_TEXT,
8057   SELECT_FMT_HTML
8058 };
8059
8060 static void
8061 primary_get_cb (GtkClipboard     *clipboard,
8062                 GtkSelectionData *selection_data,
8063                 guint             info,
8064                 gpointer          data)
8065 {
8066   GtkSheet *sheet = GTK_SHEET (data);
8067   GString *string = NULL;
8068
8069   switch (info)
8070   {
8071   case SELECT_FMT_TEXT:
8072     string = range_to_text (sheet);
8073     break;
8074   case SELECT_FMT_HTML:
8075     string = range_to_html (sheet);
8076     break;
8077   default:
8078     g_assert_not_reached ();
8079   }
8080
8081   gtk_selection_data_set (selection_data, selection_data->target,
8082                           8,
8083                           (const guchar *) string->str, string->len);
8084   g_string_free (string, TRUE);
8085 }
8086
8087 static void
8088 primary_clear_cb (GtkClipboard *clipboard,
8089                   gpointer      data)
8090 {
8091   GtkSheet *sheet = GTK_SHEET (data);
8092   gtk_sheet_real_unselect_range (sheet, NULL);
8093 }
8094
8095 static void
8096 gtk_sheet_update_primary_selection (GtkSheet *sheet)
8097 {
8098   static const GtkTargetEntry targets[] = {
8099     { "UTF8_STRING",   0, SELECT_FMT_TEXT },
8100     { "STRING",        0, SELECT_FMT_TEXT },
8101     { "TEXT",          0, SELECT_FMT_TEXT },
8102     { "COMPOUND_TEXT", 0, SELECT_FMT_TEXT },
8103     { "text/plain;charset=utf-8", 0, SELECT_FMT_TEXT },
8104     { "text/plain",    0, SELECT_FMT_TEXT },
8105     { "text/html",     0, SELECT_FMT_HTML }
8106   };
8107
8108   GtkClipboard *clipboard;
8109
8110   if (!GTK_WIDGET_REALIZED (sheet))
8111     return;
8112
8113   clipboard = gtk_widget_get_clipboard (GTK_WIDGET (sheet),
8114                                         GDK_SELECTION_PRIMARY);
8115
8116   if (gtk_sheet_range_isvisible (sheet, sheet->range))
8117     {
8118       if (!gtk_clipboard_set_with_owner (clipboard, targets,
8119                                          G_N_ELEMENTS (targets),
8120                                          primary_get_cb, primary_clear_cb,
8121                                          G_OBJECT (sheet)))
8122         primary_clear_cb (clipboard, sheet);
8123     }
8124   else
8125     {
8126       if (gtk_clipboard_get_owner (clipboard) == G_OBJECT (sheet))
8127         gtk_clipboard_clear (clipboard);
8128     }
8129 }
8130