lib/gtksheet/gtksheet.h

   1 /* This version of GtkSheet has been heavily modified, for the specific
   2    requirements of PSPPIRE. */
   3
   4
   5 /* GtkSheet widget for Gtk+.
   6  * Copyright (C) 1999-2001 Adrian E. Feiguin <adrian@ifir.ifir.edu.ar>
   7  *
   8  * Based on GtkClist widget by Jay Painter, but major changes.
   9  * Memory allocation routines inspired on SC (Spreadsheet Calculator)
  10  *
  11  * This library is free software; you can redistribute it and/or
  12  * modify it under the terms of the GNU Lesser General Public
  13  * License as published by the Free Software Foundation; either
  14  * version 2.1 of the License, or (at your option) any later version.
  15  *
  16  * This library is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19  * Lesser General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU Lesser General Public
  22  * License along with this library; if not, write to the Free Software
  23  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  24  */
  25
  26 #ifndef __GTK_SHEET_H__
  27 #define __GTK_SHEET_H__
  28
  29 #include <gtk/gtk.h>
  30
  31 #include "gtkextra-sheet.h"
  32 #include "gsheetmodel.h"
  33 #include "gsheet-column-iface.h"
  34 #include "gsheet-row-iface.h"
  35
  36
  37 #ifdef __cplusplus
  38 extern "C" {
  39 #endif /* __cplusplus */
  40
  41
  42 typedef enum
  43 {
  44   GTK_SHEET_FOREGROUND,
  45   GTK_SHEET_BACKGROUND,
  46   GTK_SHEET_FONT,
  47   GTK_SHEET_JUSTIFICATION,
  48   GTK_SHEET_BORDER,
  49   GTK_SHEET_BORDER_COLOR,
  50   GTK_SHEET_IS_EDITABLE,
  51   GTK_SHEET_IS_VISIBLE
  52 } GtkSheetAttrType;
  53
  54 /* sheet->state */
  55
  56 enum
  57 {
  58   GTK_SHEET_NORMAL,
  59   GTK_SHEET_ROW_SELECTED,
  60   GTK_SHEET_COLUMN_SELECTED,
  61   GTK_SHEET_RANGE_SELECTED
  62 };
  63
  64
  65 #define GTK_TYPE_SHEET_RANGE (gtk_sheet_range_get_type ())
  66 #define GTK_TYPE_SHEET (gtk_sheet_get_type ())
  67
  68 #define GTK_SHEET(obj)          GTK_CHECK_CAST (obj, gtk_sheet_get_type (), GtkSheet)
  69 #define GTK_SHEET_CLASS(klass)  GTK_CHECK_CLASS_CAST (klass, gtk_sheet_get_type (), GtkSheetClass)
  70 #define GTK_IS_SHEET(obj)       GTK_CHECK_TYPE (obj, gtk_sheet_get_type ())
  71
  72 /* Public flags, for compatibility */
  73
  74 #define GTK_SHEET_ROW_FROZEN(sheet)      !gtk_sheet_rows_resizable (sheet)
  75 #define GTK_SHEET_COLUMN_FROZEN(sheet)   !gtk_sheet_columns_resizable (sheet)
  76 #define GTK_SHEET_AUTORESIZE(sheet)      gtk_sheet_autoresize (sheet)
  77 #define GTK_SHEET_CLIP_TEXT(sheet)       gtk_sheet_clip_text (sheet)
  78 #define GTK_SHEET_ROW_TITLES_VISIBLE(sheet)   gtk_sheet_row_titles_visible (sheet)
  79 #define GTK_SHEET_COL_TITLES_VISIBLE(sheet)   gtk_sheet_column_titles_visible (sheet)
  80 #define GTK_SHEET_AUTO_SCROLL(sheet)     gtk_sheet_autoscroll (sheet)
  81 #define GTK_SHEET_JUSTIFY_ENTRY(sheet)   gtk_sheet_justify_entry (sheet)
  82
  83
  84 typedef struct _GtkSheetClass GtkSheetClass;
  85 typedef struct _GtkSheetCellAttr     GtkSheetCellAttr;
  86 typedef struct _GtkSheetCell GtkSheetCell;
  87 typedef struct _GtkSheetHoverTitle GtkSheetHoverTitle;
  88
  89
  90 struct _GtkSheetCellAttr
  91 {
  92   GtkJustification justification;
  93   const PangoFontDescription *font_desc;
  94   GdkColor foreground;
  95   GdkColor background;
  96   GtkSheetCellBorder border;
  97   gboolean is_editable;
  98   gboolean is_visible;
  99 };
 100
 101 struct _GtkSheetCell
 102 {
 103   gint row;
 104   gint col;
 105 };
 106
 107 struct _GtkSheetHoverTitle
 108 {
 109   GtkWidget *window;
 110   GtkWidget *label;
 111   gint row, column;
 112 };
 113
 114 struct _GtkSheet{
 115   GtkContainer container;
 116
 117   GSheetColumn *column_geometry;
 118   GSheetRow *row_geometry;
 119
 120   guint16 flags;
 121
 122   GSheetModel *model;
 123
 124   GtkSelectionMode selection_mode;
 125   gboolean autoresize;
 126   gboolean autoscroll;
 127   gboolean clip_text;
 128   gboolean justify_entry;
 129
 130   guint freeze_count;
 131
 132   /* Background colors */
 133   GdkColor bg_color;
 134   GdkColor grid_color;
 135   gboolean show_grid;
 136
 137   /* sheet children */
 138   GList *children;
 139
 140   /* allocation rectangle after the container_border_width
 141      and the width of the shadow border */
 142   GdkRectangle internal_allocation;
 143
 144   gchar *name;
 145
 146   gint16 column_requisition;
 147   gint16 row_requisition;
 148
 149   gboolean rows_resizable;
 150   gboolean columns_resizable;
 151
 152   /* Displayed range */
 153   GtkSheetRange view;
 154
 155   /* active cell */
 156   GtkSheetCell active_cell;
 157   GtkWidget *sheet_entry;
 158
 159   GtkType entry_type;
 160
 161   /* expanding selection */
 162   GtkSheetCell selection_cell;
 163
 164   /* timer for flashing clipped range */
 165   gint32 clip_timer;
 166   gint interval;
 167
 168   /* global selection button */
 169   GtkWidget *button;
 170
 171   /* sheet state */
 172   gint state;
 173
 174   /* selected range */
 175   GtkSheetRange range;
 176
 177   /*the scrolling window and it's height and width to
 178    * make things a little speedier */
 179   GdkWindow *sheet_window;
 180   guint sheet_window_width;
 181   guint sheet_window_height;
 182
 183   /* sheet backing pixmap */
 184   GdkPixmap *pixmap;
 185
 186   /* offsets for scrolling */
 187   gint hoffset;
 188   gint voffset;
 189   gfloat old_hadjustment;
 190   gfloat old_vadjustment;
 191
 192   /* border shadow style */
 193   GtkShadowType shadow_type;
 194
 195   /* Column Titles */
 196   GdkRectangle column_title_area;
 197   GdkWindow *column_title_window;
 198   gboolean column_titles_visible;
 199
 200   /* Row Titles */
 201   GdkRectangle row_title_area;
 202   GdkWindow *row_title_window;
 203   gboolean row_titles_visible;
 204
 205   /*scrollbars*/
 206   GtkAdjustment *hadjustment;
 207   GtkAdjustment *vadjustment;
 208
 209   /* xor GC for the verticle drag line */
 210   GdkGC *xor_gc;
 211
 212   /* gc for drawing unselected cells */
 213   GdkGC *fg_gc;
 214   GdkGC *bg_gc;
 215
 216   /* cursor used to indicate dragging */
 217   GdkCursor *cursor_drag;
 218
 219   /* the current x-pixel location of the xor-drag vline */
 220   gint x_drag;
 221
 222   /* the current y-pixel location of the xor-drag hline */
 223   gint y_drag;
 224
 225   /* current cell being dragged */
 226   GtkSheetCell drag_cell;
 227   /* current range being dragged */
 228   GtkSheetRange drag_range;
 229
 230   /* clipped range */
 231   GtkSheetRange clip_range;
 232
 233   /* Used for the subtitle (popups) */
 234   gint motion_events;
 235   GtkSheetHoverTitle *hover_window;
 236 };
 237
 238 struct _GtkSheetClass
 239 {
 240  GtkContainerClass parent_class;
 241
 242  void (*set_scroll_adjustments) (GtkSheet *sheet,
 243                                  GtkAdjustment *hadjustment,
 244                                  GtkAdjustment *vadjustment);
 245
 246  void (*select_row)             (GtkSheet *sheet, gint row);
 247
 248  void (*select_column)          (GtkSheet *sheet, gint column);
 249
 250  void (*select_range)           (GtkSheet *sheet, GtkSheetRange *range);
 251
 252  void (*clip_range)             (GtkSheet *sheet, GtkSheetRange *clip_range);
 253
 254  void (*resize_range)           (GtkSheet *sheet,
 255                                 GtkSheetRange *old_range,
 256                                 GtkSheetRange *new_range);
 257
 258  void (*move_range)             (GtkSheet *sheet,
 259                                 GtkSheetRange *old_range,
 260                                 GtkSheetRange *new_range);
 261
 262  gboolean (*traverse)           (GtkSheet *sheet,
 263                                 gint row, gint column,
 264                                 gint *new_row, gint *new_column);
 265
 266  gboolean (*deactivate)         (GtkSheet *sheet,
 267                                 gint row, gint column);
 268
 269  gboolean (*activate)           (GtkSheet *sheet,
 270                                 gint row, gint column);
 271
 272  void (*set_cell)               (GtkSheet *sheet,
 273                                 gint row, gint column);
 274
 275  void (*clear_cell)             (GtkSheet *sheet,
 276                                 gint row, gint column);
 277
 278  void (*changed)                (GtkSheet *sheet,
 279                                 gint row, gint column);
 280
 281  void (*new_column_width)       (GtkSheet *sheet,
 282                                  gint col,
 283                                  guint width);
 284
 285  void (*new_row_height)         (GtkSheet *sheet,
 286                                  gint row,
 287                                  guint height);
 288
 289 };
 290
 291 GType gtk_sheet_get_type (void);
 292 GtkType gtk_sheet_range_get_type (void);
 293
 294
 295 /* create a new sheet */
 296 GtkWidget * gtk_sheet_new (GSheetRow *vgeo, GSheetColumn *hgeo,
 297                            const gchar *title,
 298                            GSheetModel *model);
 299
 300
 301
 302
 303 /* create a new browser sheet. It cells can not be edited */
 304 GtkWidget *
 305 gtk_sheet_new_browser                   (guint rows, guint columns, const gchar *title);
 306
 307 void
 308 gtk_sheet_construct_browser             (GtkSheet *sheet,
 309                                          guint rows, guint columns, const gchar *title);
 310
 311 /* create a new sheet with custom entry */
 312 GtkWidget *
 313 gtk_sheet_new_with_custom_entry         (GSheetRow *vgeo,
 314                                          GSheetColumn *hgeo,
 315                                          const gchar *title,
 316                                          GtkType entry_type);
 317 void
 318 gtk_sheet_construct_with_custom_entry   (GtkSheet *sheet,
 319                                          GSheetRow *vgeo,
 320                                          GSheetColumn *hgeo,
 321                                          const gchar *title,
 322                                          GtkType entry_type);
 323 /* change scroll adjustments */
 324 void
 325 gtk_sheet_set_hadjustment               (GtkSheet *sheet,
 326                                          GtkAdjustment *adjustment);
 327 void
 328 gtk_sheet_set_vadjustment               (GtkSheet *sheet,
 329                                          GtkAdjustment *adjustment);
 330 /* Change entry */
 331 void
 332 gtk_sheet_change_entry                  (GtkSheet *sheet, GtkType entry_type);
 333
 334 /* Returns sheet's entry widget */
 335 GtkWidget *
 336 gtk_sheet_get_entry                     (GtkSheet *sheet);
 337 GtkWidget *
 338 gtk_sheet_get_entry_widget              (GtkSheet *sheet);
 339
 340 /* Returns sheet->state
 341  * Added by Steven Rostedt <steven.rostedt@lmco.com> */
 342 gint
 343 gtk_sheet_get_state                     (GtkSheet *sheet);
 344
 345 /* Returns sheet's ranges
 346  * Added by Murray Cumming */
 347 guint
 348 gtk_sheet_get_columns_count             (GtkSheet *sheet);
 349
 350 guint
 351 gtk_sheet_get_rows_count                (GtkSheet *sheet);
 352
 353 void
 354 gtk_sheet_get_visible_range             (GtkSheet *sheet,
 355                                          GtkSheetRange *range);
 356 void
 357 gtk_sheet_set_selection_mode            (GtkSheet *sheet, gint mode);
 358
 359 void
 360 gtk_sheet_set_autoresize                (GtkSheet *sheet, gboolean autoresize);
 361
 362 gboolean
 363 gtk_sheet_autoresize                    (GtkSheet *sheet);
 364
 365 void
 366 gtk_sheet_set_autoscroll                (GtkSheet *sheet, gboolean autoscroll);
 367
 368 gboolean
 369 gtk_sheet_autoscroll                    (GtkSheet *sheet);
 370
 371 void
 372 gtk_sheet_set_clip_text                 (GtkSheet *sheet, gboolean clip_text);
 373
 374 gboolean
 375 gtk_sheet_clip_text                     (GtkSheet *sheet);
 376
 377 void
 378 gtk_sheet_set_justify_entry             (GtkSheet *sheet, gboolean justify);
 379
 380 gboolean
 381 gtk_sheet_justify_entry                 (GtkSheet *sheet);
 382
 383 void
 384 gtk_sheet_set_locked                    (GtkSheet *sheet, gboolean lock);
 385
 386 gboolean
 387 gtk_sheet_locked                        (const GtkSheet *sheet);
 388
 389 /* set sheet title */
 390 void
 391 gtk_sheet_set_title                     (GtkSheet *sheet, const gchar *title);
 392
 393 /* freeze all visual updates of the sheet.
 394  * Then thaw the sheet after you have made a number of changes.
 395  * The updates will occure in a more efficent way than if
 396  * you made them on a unfrozen sheet */
 397 void
 398 gtk_sheet_freeze                        (GtkSheet *sheet);
 399 void
 400 gtk_sheet_thaw                          (GtkSheet *sheet);
 401 /* Background colors */
 402 void
 403 gtk_sheet_set_background                (GtkSheet *sheet,
 404                                          GdkColor *bg_color);
 405 void
 406 gtk_sheet_set_grid                      (GtkSheet *sheet,
 407                                          GdkColor *grid_color);
 408 void
 409 gtk_sheet_show_grid                     (GtkSheet *sheet,
 410                                          gboolean show);
 411 gboolean
 412 gtk_sheet_grid_visible                  (GtkSheet *sheet);
 413
 414 /* set/get column title */
 415 void
 416 gtk_sheet_set_column_title              (GtkSheet * sheet,
 417                                         gint column,
 418                                         const gchar * title);
 419
 420 const gchar *
 421 gtk_sheet_get_column_title              (GtkSheet * sheet,
 422                                         gint column);
 423
 424 /* set/get row title */
 425 void
 426 gtk_sheet_set_row_title                 (GtkSheet * sheet,
 427                                         gint row,
 428                                         const gchar * title);
 429 const gchar *
 430 gtk_sheet_get_row_title                 (GtkSheet * sheet,
 431                                         gint row);
 432
 433
 434 /* set/get button label */
 435 void
 436 gtk_sheet_row_button_add_label          (GtkSheet *sheet,
 437                                         gint row, const gchar *label);
 438 const gchar *
 439 gtk_sheet_row_button_get_label          (GtkSheet *sheet,
 440                                         gint row);
 441 void
 442 gtk_sheet_row_button_justify            (GtkSheet *sheet,
 443                                         gint row, GtkJustification justification);
 444
 445
 446
 447 /* scroll the viewing area of the sheet to the given column
 448  * and row; row_align and col_align are between 0-1 representing the
 449  * location the row should appear on the screen, 0.0 being top or left,
 450  * 1.0 being bottom or right; if row or column is negative then there
 451  * is no change */
 452 void
 453 gtk_sheet_moveto (GtkSheet *sheet,
 454                   gint row,
 455                   gint column,
 456                   gfloat row_align,
 457                   gfloat col_align);
 458
 459
 460 void
 461 gtk_sheet_show_row_titles               (GtkSheet *sheet);
 462 void
 463 gtk_sheet_hide_row_titles               (GtkSheet *sheet);
 464 gboolean
 465 gtk_sheet_row_titles_visible            (GtkSheet *sheet);
 466
 467
 468 /* set row button sensitivity. If sensitivity is TRUE can be toggled,
 469  * otherwise it acts as a title */
 470 void
 471 gtk_sheet_row_set_sensitivity           (GtkSheet *sheet,
 472                                         gint row,  gboolean sensitive);
 473
 474 /* set sensitivity for all row buttons */
 475 void
 476 gtk_sheet_rows_set_sensitivity          (GtkSheet *sheet, gboolean sensitive);
 477 void
 478 gtk_sheet_rows_set_resizable            (GtkSheet *sheet, gboolean resizable);
 479 gboolean
 480 gtk_sheet_rows_resizable                (GtkSheet *sheet);
 481
 482 /* set row visibility. The default value is TRUE. If FALSE, the
 483  * row is hidden */
 484 void
 485 gtk_sheet_row_set_visibility            (GtkSheet *sheet,
 486                                          gint row, gboolean visible);
 487 void
 488 gtk_sheet_row_label_set_visibility      (GtkSheet *sheet,
 489                                          gint row, gboolean visible);
 490 void
 491 gtk_sheet_rows_labels_set_visibility    (GtkSheet *sheet, gboolean visible);
 492
 493
 494 /* select the row. The range is then highlighted, and the bounds are stored
 495  * in sheet->range  */
 496 void
 497 gtk_sheet_select_row                    (GtkSheet * sheet,
 498                                         gint row);
 499
 500 /* select the column. The range is then highlighted, and the bounds are stored
 501  * in sheet->range  */
 502 void
 503 gtk_sheet_select_column                 (GtkSheet * sheet,
 504                                         gint column);
 505
 506 /* save selected range to "clipboard" */
 507 void
 508 gtk_sheet_clip_range                    (GtkSheet *sheet, const GtkSheetRange *range);
 509 /* free clipboard */
 510 void
 511 gtk_sheet_unclip_range                  (GtkSheet *sheet);
 512
 513 gboolean
 514 gtk_sheet_in_clip                       (GtkSheet *sheet);
 515
 516 /* get scrollbars adjustment */
 517 GtkAdjustment *
 518 gtk_sheet_get_vadjustment               (GtkSheet * sheet);
 519 GtkAdjustment *
 520 gtk_sheet_get_hadjustment               (GtkSheet * sheet);
 521
 522 /* highlight the selected range and store bounds in sheet->range */
 523 void gtk_sheet_select_range             (GtkSheet *sheet,
 524                                          const GtkSheetRange *range);
 525
 526 /* obvious */
 527 void gtk_sheet_unselect_range           (GtkSheet *sheet);
 528
 529 /* set active cell where the entry will be displayed
 530  * returns FALSE if current cell can't be deactivated or
 531  * requested cell can't be activated */
 532 gboolean
 533 gtk_sheet_set_active_cell               (GtkSheet *sheet,
 534                                         gint row, gint column);
 535
 536 /* Sets *ROW and *COLUMN to be the coordinates of the active cell.
 537    ROW and/or COLUMN may be null if the caller is not interested in their
 538    values */
 539 void
 540 gtk_sheet_get_active_cell               (GtkSheet *sheet,
 541                                         gint *row, gint *column);
 542
 543 /* set cell contents and allocate memory if needed */
 544 void
 545 gtk_sheet_set_cell                      (GtkSheet *sheet,
 546                                         gint row, gint col,
 547                                         GtkJustification justification,
 548                                         const gchar *text);
 549 void
 550 gtk_sheet_set_cell_text                 (GtkSheet *sheet,
 551                                         gint row, gint col,
 552                                         const gchar *text);
 553 /* get cell contents */
 554 gchar *
 555 gtk_sheet_cell_get_text                 (const GtkSheet *sheet, gint row, gint col);
 556
 557 /* clear cell contents */
 558 void
 559 gtk_sheet_cell_clear                    (GtkSheet *sheet, gint row, gint col);
 560 /* clear cell contents and remove links */
 561 void
 562 gtk_sheet_cell_delete                   (GtkSheet *sheet, gint row, gint col);
 563
 564 /* clear range contents. If range==NULL the whole sheet will be cleared */
 565 void
 566 gtk_sheet_range_clear                   (GtkSheet *sheet,
 567                                          const GtkSheetRange *range);
 568 /* clear range contents and remove links */
 569 void
 570 gtk_sheet_range_delete                  (GtkSheet *sheet,
 571                                          const GtkSheetRange *range);
 572
 573 /* get cell state: GTK_STATE_NORMAL, GTK_STATE_SELECTED */
 574 GtkStateType
 575 gtk_sheet_cell_get_state                (GtkSheet *sheet, gint row, gint col);
 576
 577 /* get row and column correspondig to the given position in the screen */
 578 gboolean
 579 gtk_sheet_get_pixel_info (GtkSheet * sheet,
 580                           gint x,
 581                           gint y,
 582                           gint * row,
 583                           gint * column);
 584
 585 /* get area of a given cell */
 586 gboolean
 587 gtk_sheet_get_cell_area (GtkSheet *sheet,
 588                          gint row,
 589                          gint column,
 590                          GdkRectangle *area);
 591
 592 /* set row height */
 593 void
 594 gtk_sheet_set_row_height (GtkSheet * sheet,
 595                           gint row,
 596                           guint height);
 597
 598
 599 /* delete nrows rows starting in row */
 600 void
 601 gtk_sheet_delete_rows                   (GtkSheet *sheet, guint row, guint nrows);
 602
 603 /* append nrows row to the end of the sheet */
 604 void
 605 gtk_sheet_add_row                       (GtkSheet *sheet, guint nrows);
 606
 607 /* insert nrows rows before the given row and pull right */
 608 void
 609 gtk_sheet_insert_rows                   (GtkSheet *sheet, guint row, guint nrows);
 610
 611 /* set abckground color of the given range */
 612 void
 613 gtk_sheet_range_set_background          (GtkSheet *sheet,
 614                                         const GtkSheetRange *range,
 615                                         const GdkColor *color);
 616
 617 /* set foreground color (text color) of the given range */
 618 void
 619 gtk_sheet_range_set_foreground          (GtkSheet *sheet,
 620                                         const GtkSheetRange *range,
 621                                         const GdkColor *color);
 622
 623 /* set text justification (GTK_JUSTIFY_LEFT, RIGHT, CENTER) of the given range.
 624  * The default value is GTK_JUSTIFY_LEFT. If autoformat is on, the
 625  * default justification for numbers is GTK_JUSTIFY_RIGHT */
 626 void
 627 gtk_sheet_range_set_justification       (GtkSheet *sheet,
 628                                         const GtkSheetRange *range,
 629                                         GtkJustification justification);
 630 void
 631 gtk_sheet_column_set_justification      (GtkSheet *sheet,
 632                                         gint column,
 633                                         GtkJustification justification);
 634 /* set if cell contents can be edited or not in the given range:
 635  * accepted values are TRUE or FALSE. */
 636 void
 637 gtk_sheet_range_set_editable            (GtkSheet *sheet,
 638                                         const GtkSheetRange *range,
 639                                         gint editable);
 640
 641 /* set if cell contents are visible or not in the given range:
 642  * accepted values are TRUE or FALSE.*/
 643 void
 644 gtk_sheet_range_set_visible             (GtkSheet *sheet,
 645                                         const GtkSheetRange *range,
 646                                         gboolean visible);
 647
 648 /* set cell border style in the given range.
 649  * mask values are CELL_LEFT_BORDER, CELL_RIGHT_BORDER, CELL_TOP_BORDER,
 650  * CELL_BOTTOM_BORDER
 651  * width is the width of the border line in pixels
 652  * line_style is the line_style for the border line */
 653 void
 654 gtk_sheet_range_set_border              (GtkSheet *sheet,
 655                                         const GtkSheetRange *range,
 656                                         gint mask,
 657                                         guint width,
 658                                         gint line_style);
 659
 660 /* set border color for the given range */
 661 void
 662 gtk_sheet_range_set_border_color        (GtkSheet *sheet,
 663                                         const GtkSheetRange *range,
 664                                         const GdkColor *color);
 665
 666 /* set font for the given range */
 667 void
 668 gtk_sheet_range_set_font                (GtkSheet *sheet,
 669                                         const GtkSheetRange *range,
 670                                         PangoFontDescription *font);
 671
 672 /* get cell attributes of the given cell */
 673 /* TRUE means that the cell is currently allocated */
 674 gboolean
 675 gtk_sheet_get_attributes                (const GtkSheet *sheet,
 676                                         gint row, gint col,
 677                                         GtkSheetCellAttr *attributes);
 678
 679
 680 GtkSheetChild *
 681 gtk_sheet_put                           (GtkSheet *sheet,
 682                                          GtkWidget *widget,
 683                                          gint x, gint y);
 684 void
 685 gtk_sheet_attach_floating               (GtkSheet *sheet,
 686                                          GtkWidget *widget,
 687                                          gint row, gint col);
 688 void
 689 gtk_sheet_attach_default                (GtkSheet *sheet,
 690                                          GtkWidget *widget,
 691                                          gint row, gint col);
 692 void
 693 gtk_sheet_attach                        (GtkSheet *sheet,
 694                                          GtkWidget *widget,
 695                                          gint row, gint col,
 696                                          gint xoptions,
 697                                          gint yoptions,
 698                                          gint xpadding,
 699                                          gint ypadding);
 700
 701
 702 void
 703 gtk_sheet_move_child                    (GtkSheet *sheet,
 704                                          GtkWidget *widget,
 705                                          gint x, gint y);
 706
 707 GtkSheetChild *
 708 gtk_sheet_get_child_at                  (GtkSheet *sheet,
 709                                          gint row, gint col);
 710
 711 void
 712 gtk_sheet_button_attach                 (GtkSheet *sheet,
 713                                          GtkWidget *widget,
 714                                          gint row, gint col);
 715
 716
 717
 718 void           gtk_sheet_set_model (GtkSheet *sheet,
 719                                    GSheetModel *model);
 720
 721 GSheetModel * gtk_sheet_get_model (const GtkSheet *sheet);
 722
 723
 724 #ifdef __cplusplus
 725 }
 726 #endif /* __cplusplus */
 727
 728
 729 #endif /* __GTK_SHEET_H__ */
 730
 731