gattrib/include/gtksheet_1_2.h

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