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