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