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