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 G_BEGIN_DECLS
  38
  39
  40 typedef enum
  41 {
  42   GTK_SHEET_FOREGROUND,
  43   GTK_SHEET_BACKGROUND,
  44   GTK_SHEET_FONT,
  45   GTK_SHEET_JUSTIFICATION,
  46   GTK_SHEET_BORDER,
  47   GTK_SHEET_BORDER_COLOR,
  48   GTK_SHEET_IS_EDITABLE,
  49   GTK_SHEET_IS_VISIBLE
  50 } GtkSheetAttrType;
  51
  52 /* sheet->state */
  53
  54 enum
  55 {
  56   GTK_SHEET_NORMAL,
  57   GTK_SHEET_ROW_SELECTED,
  58   GTK_SHEET_COLUMN_SELECTED,
  59   GTK_SHEET_RANGE_SELECTED
  60 };
  61
  62
  63 #define GTK_TYPE_SHEET_RANGE (gtk_sheet_range_get_type ())
  64 #define GTK_TYPE_SHEET (gtk_sheet_get_type ())
  65
  66 #define GTK_SHEET(obj)          GTK_CHECK_CAST (obj, gtk_sheet_get_type (), GtkSheet)
  67 #define GTK_SHEET_CLASS(klass)  GTK_CHECK_CLASS_CAST (klass, gtk_sheet_get_type (), GtkSheetClass)
  68 #define GTK_IS_SHEET(obj)       GTK_CHECK_TYPE (obj, gtk_sheet_get_type ())
  69
  70
  71
  72 #define GTK_SHEET_AUTORESIZE(sheet)      gtk_sheet_autoresize (sheet)
  73 #define GTK_SHEET_AUTO_SCROLL(sheet)     gtk_sheet_autoscroll (sheet)
  74 #define GTK_SHEET_JUSTIFY_ENTRY(sheet)   gtk_sheet_justify_entry (sheet)
  75
  76
  77 typedef struct _GtkSheetClass GtkSheetClass;
  78 typedef struct _GtkSheetCellAttr     GtkSheetCellAttr;
  79 typedef struct _GtkSheetCell GtkSheetCell;
  80 typedef struct _GtkSheetHoverTitle GtkSheetHoverTitle;
  81
  82
  83 struct _GtkSheetCellAttr
  84 {
  85   GtkJustification justification;
  86   const PangoFontDescription *font_desc;
  87   GdkColor foreground;
  88   GdkColor background;
  89   GtkSheetCellBorder border;
  90   gboolean is_editable;
  91   gboolean is_visible;
  92 };
  93
  94 struct _GtkSheetCell
  95 {
  96   gint row;
  97   gint col;
  98 };
  99
 100
 101 struct _GtkSheetHoverTitle
 102 {
 103   GtkWidget *window;
 104   GtkWidget *label;
 105   gint row, column;
 106 };
 107
 108 struct _GtkSheet
 109 {
 110   GtkBin parent;
 111
 112   gboolean dispose_has_run;
 113   GSheetColumn *column_geometry;
 114   GSheetRow *row_geometry;
 115
 116   guint16 flags;
 117
 118   GSheetModel *model;
 119
 120   GtkSelectionMode selection_mode;
 121   gboolean autoresize;
 122   gboolean autoscroll;
 123   gboolean justify_entry;
 124
 125   /* Background colors */
 126   GdkColor bg_color;
 127   GdkColor grid_color;
 128   gboolean show_grid;
 129
 130   /* allocation rectangle after the container_border_width
 131      and the width of the shadow border */
 132   GdkRectangle internal_allocation;
 133
 134   gint16 column_requisition;
 135   gint16 row_requisition;
 136
 137   gboolean rows_resizable;
 138   gboolean columns_resizable;
 139
 140   /* active cell */
 141   GtkSheetCell active_cell;
 142
 143   /* The GtkEntry used for editing the cells */
 144   GtkWidget *entry_widget;
 145
 146   /* The widget containing entry_widget, or
 147      entry_widget itself if no container */
 148   GtkWidget *entry_container;
 149
 150   /* The type of entry_widget */
 151   GtkType entry_type;
 152
 153   /* expanding selection */
 154   GtkSheetCell selection_cell;
 155
 156   /* global selection button */
 157   GtkWidget *button;
 158
 159   /* sheet state */
 160   gint state;
 161
 162   /* selected range */
 163   GtkSheetRange range;
 164
 165   /*the scrolling window and it's height and width to
 166    * make things a little speedier */
 167   GdkWindow *sheet_window;
 168   guint sheet_window_width;
 169   guint sheet_window_height;
 170
 171   /* sheet backing pixmap */
 172   GdkPixmap *pixmap;
 173
 174   /* border shadow style */
 175   GtkShadowType shadow_type;
 176
 177   /* Column Titles */
 178   GdkRectangle column_title_area;
 179   GdkWindow *column_title_window;
 180   gboolean column_titles_visible;
 181   /* TRUE if the cursor is over the column title window */
 182   gboolean column_title_under;
 183
 184   /* Row Titles */
 185   GdkRectangle row_title_area;
 186   GdkWindow *row_title_window;
 187   gboolean row_titles_visible;
 188   /* TRUE if the cursor is over the row title window */
 189   gboolean row_title_under;
 190
 191   /*scrollbars*/
 192   GtkAdjustment *hadjustment;
 193   GtkAdjustment *vadjustment;
 194
 195   /* xor GC for the verticle drag line */
 196   GdkGC *xor_gc;
 197
 198   /* gc for drawing unselected cells */
 199   GdkGC *fg_gc;
 200   GdkGC *bg_gc;
 201
 202   /* cursor used to indicate dragging */
 203   GdkCursor *cursor_drag;
 204
 205   /* the current x-pixel location of the xor-drag vline */
 206   gint x_drag;
 207
 208   /* the current y-pixel location of the xor-drag hline */
 209   gint y_drag;
 210
 211   /* current cell being dragged */
 212   GtkSheetCell drag_cell;
 213   /* current range being dragged */
 214   GtkSheetRange drag_range;
 215
 216   /* Used for the subtitle (popups) */
 217   gint motion_timer;
 218   GtkSheetHoverTitle *hover_window;
 219 };
 220
 221 struct _GtkSheetClass
 222 {
 223   GtkBinClass parent_class;
 224
 225  void (*set_scroll_adjustments) (GtkSheet *sheet,
 226                                  GtkAdjustment *hadjustment,
 227                                  GtkAdjustment *vadjustment);
 228
 229  void (*select_row)             (GtkSheet *sheet, gint row);
 230
 231  void (*select_column)          (GtkSheet *sheet, gint column);
 232
 233  void (*select_range)           (GtkSheet *sheet, GtkSheetRange *range);
 234
 235  void (*resize_range)           (GtkSheet *sheet,
 236                                 GtkSheetRange *old_range,
 237                                 GtkSheetRange *new_range);
 238
 239  void (*move_range)             (GtkSheet *sheet,
 240                                 GtkSheetRange *old_range,
 241                                 GtkSheetRange *new_range);
 242
 243  gboolean (*traverse)           (GtkSheet *sheet,
 244                                 gint row, gint column,
 245                                 gint *new_row, gint *new_column);
 246
 247  gboolean (*deactivate)         (GtkSheet *sheet,
 248                                 gint row, gint column);
 249
 250  gboolean (*activate)           (GtkSheet *sheet,
 251                                 gint row, gint column);
 252
 253  void (*changed)                (GtkSheet *sheet,
 254                                 gint row, gint column);
 255 };
 256
 257 GType gtk_sheet_get_type (void);
 258 GtkType gtk_sheet_range_get_type (void);
 259
 260
 261 /* create a new sheet */
 262 GtkWidget * gtk_sheet_new (GSheetRow *vgeo, GSheetColumn *hgeo,
 263                            GSheetModel *model);
 264
 265 /* create a new sheet with custom entry */
 266 GtkWidget *
 267 gtk_sheet_new_with_custom_entry         (GSheetRow *vgeo,
 268                                          GSheetColumn *hgeo,
 269                                          GtkType entry_type);
 270 void
 271 gtk_sheet_construct_with_custom_entry   (GtkSheet *sheet,
 272                                          GSheetRow *vgeo,
 273                                          GSheetColumn *hgeo,
 274                                          GtkType entry_type);
 275 /* Change entry */
 276 void gtk_sheet_change_entry             (GtkSheet *sheet, GtkType entry_type);
 277
 278 GtkWidget *gtk_sheet_get_entry    (GtkSheet *sheet);
 279
 280
 281 guint gtk_sheet_get_columns_count (GtkSheet *sheet);
 282
 283 guint gtk_sheet_get_rows_count    (GtkSheet *sheet);
 284
 285 void gtk_sheet_get_selected_range (GtkSheet *sheet,
 286                                          GtkSheetRange *range);
 287
 288 void gtk_sheet_set_selection_mode (GtkSheet *sheet, gint mode);
 289
 290 void gtk_sheet_set_autoresize     (GtkSheet *sheet, gboolean autoresize);
 291
 292 gboolean gtk_sheet_autoresize     (GtkSheet *sheet);
 293
 294 void gtk_sheet_set_autoscroll     (GtkSheet *sheet, gboolean autoscroll);
 295
 296 gboolean gtk_sheet_autoscroll     (GtkSheet *sheet);
 297
 298 void gtk_sheet_set_justify_entry  (GtkSheet *sheet, gboolean justify);
 299
 300 gboolean gtk_sheet_justify_entry  (GtkSheet *sheet);
 301
 302 /* Background colors */
 303 void gtk_sheet_set_background     (GtkSheet *sheet,
 304                                          GdkColor *bg_color);
 305
 306 void gtk_sheet_set_grid           (GtkSheet *sheet,
 307                                          GdkColor *grid_color);
 308
 309 void gtk_sheet_show_grid          (GtkSheet *sheet,
 310                                          gboolean show);
 311
 312 gboolean gtk_sheet_grid_visible   (GtkSheet *sheet);
 313
 314 /* set/get column title */
 315 void gtk_sheet_set_column_title   (GtkSheet * sheet,
 316                                         gint column,
 317                                         const gchar * title);
 318
 319 const gchar *gtk_sheet_get_column_title  (GtkSheet * sheet,
 320                                         gint column);
 321
 322 /* set/get row title */
 323 void gtk_sheet_set_row_title      (GtkSheet * sheet,
 324                                         gint row,
 325                                         const gchar * title);
 326
 327 const gchar *gtk_sheet_get_row_title (GtkSheet * sheet,
 328                                       gint row);
 329
 330 /* set/get button label */
 331 void gtk_sheet_row_button_add_label (GtkSheet *sheet,
 332                                         gint row, const gchar *label);
 333
 334 const gchar *gtk_sheet_row_button_get_label  (GtkSheet *sheet,
 335                                               gint row);
 336
 337 void gtk_sheet_row_button_justify   (GtkSheet *sheet,
 338                                      gint row, GtkJustification justification);
 339
 340 /* scroll the viewing area of the sheet to the given column
 341  * and row; row_align and col_align are between 0-1 representing the
 342  * location the row should appear on the screen, 0.0 being top or left,
 343  * 1.0 being bottom or right; if row or column is negative then there
 344  * is no change */
 345 void gtk_sheet_moveto (GtkSheet *sheet,
 346                   gint row,
 347                   gint column,
 348                   gfloat row_align,
 349                   gfloat col_align);
 350
 351
 352 void gtk_sheet_show_row_titles          (GtkSheet *sheet);
 353 void gtk_sheet_hide_row_titles          (GtkSheet *sheet);
 354 void gtk_sheet_show_column_titles       (GtkSheet *sheet);
 355 void gtk_sheet_hide_column_titles       (GtkSheet *sheet);
 356
 357 gboolean gtk_sheet_row_titles_visible   (GtkSheet *sheet);
 358
 359
 360 /* set row button sensitivity. If sensitivity is TRUE can be toggled,
 361  * otherwise it acts as a title */
 362 void gtk_sheet_row_set_sensitivity      (GtkSheet *sheet,
 363                                         gint row,  gboolean sensitive);
 364
 365 /* set sensitivity for all row buttons */
 366 void gtk_sheet_rows_set_sensitivity     (GtkSheet *sheet, gboolean sensitive);
 367 void gtk_sheet_rows_set_resizable       (GtkSheet *sheet, gboolean resizable);
 368 gboolean gtk_sheet_rows_resizable       (GtkSheet *sheet);
 369
 370 /* set row visibility. The default value is TRUE. If FALSE, the
 371  * row is hidden */
 372 void gtk_sheet_row_set_visibility       (GtkSheet *sheet,
 373                                          gint row, gboolean visible);
 374
 375 void gtk_sheet_row_label_set_visibility (GtkSheet *sheet,
 376                                          gint row, gboolean visible);
 377
 378 void gtk_sheet_rows_labels_set_visibility (GtkSheet *sheet, gboolean visible);
 379
 380
 381 /* select the row. The range is then highlighted, and the bounds are stored
 382  * in sheet->range  */
 383 void gtk_sheet_select_row    (GtkSheet * sheet,  gint row);
 384
 385 /* select the column. The range is then highlighted, and the bounds are stored
 386  * in sheet->range  */
 387 void gtk_sheet_select_column (GtkSheet * sheet,  gint column);
 388
 389 /* highlight the selected range and store bounds in sheet->range */
 390 void gtk_sheet_select_range (GtkSheet *sheet, const GtkSheetRange *range);
 391
 392 void gtk_sheet_get_visible_range (GtkSheet *sheet, GtkSheetRange *range);
 393
 394
 395 /* obvious */
 396 void gtk_sheet_unselect_range           (GtkSheet *sheet);
 397
 398 /* set active cell where the entry will be displayed
 399  * returns FALSE if current cell can't be deactivated or
 400  * requested cell can't be activated */
 401 gboolean gtk_sheet_set_active_cell (GtkSheet *sheet,
 402                                         gint row, gint column);
 403
 404 /* Sets *ROW and *COLUMN to be the coordinates of the active cell.
 405    ROW and/or COLUMN may be null if the caller is not interested in their
 406    values */
 407 void gtk_sheet_get_active_cell (GtkSheet *sheet,
 408                                         gint *row, gint *column);
 409
 410 /* get cell contents */
 411 gchar *gtk_sheet_cell_get_text (const GtkSheet *sheet, gint row, gint col);
 412
 413 /* clear cell contents */
 414 void gtk_sheet_cell_clear      (GtkSheet *sheet, gint row, gint col);
 415
 416 /* clear range contents. If range==NULL the whole sheet will be cleared */
 417 void gtk_sheet_range_clear      (GtkSheet *sheet,
 418                                          const GtkSheetRange *range);
 419
 420 /* get cell state: GTK_STATE_NORMAL, GTK_STATE_SELECTED */
 421 GtkStateType gtk_sheet_cell_get_state (GtkSheet *sheet, gint row, gint col);
 422
 423 /* get area of a given cell */
 424 gboolean gtk_sheet_get_cell_area (GtkSheet *sheet,
 425                          gint row,
 426                          gint column,
 427                          GdkRectangle *area);
 428
 429 /* set row height */
 430 void gtk_sheet_set_row_height (GtkSheet * sheet,
 431                           gint row,
 432                           guint height);
 433
 434
 435 /* delete nrows rows starting in row */
 436 void gtk_sheet_delete_rows    (GtkSheet *sheet, guint row, guint nrows);
 437
 438 /* append nrows row to the end of the sheet */
 439 void gtk_sheet_add_row        (GtkSheet *sheet, guint nrows);
 440
 441 /* insert nrows rows before the given row and pull right */
 442 void gtk_sheet_insert_rows    (GtkSheet *sheet, guint row, guint nrows);
 443
 444 /* set abckground color of the given range */
 445 void gtk_sheet_range_set_background  (GtkSheet *sheet,
 446                                         const GtkSheetRange *range,
 447                                         const GdkColor *color);
 448
 449 /* set foreground color (text color) of the given range */
 450 void gtk_sheet_range_set_foreground  (GtkSheet *sheet,
 451                                         const GtkSheetRange *range,
 452                                         const GdkColor *color);
 453
 454 /* set text justification (GTK_JUSTIFY_LEFT, RIGHT, CENTER) of the given range.
 455  * The default value is GTK_JUSTIFY_LEFT. If autoformat is on, the
 456  * default justification for numbers is GTK_JUSTIFY_RIGHT */
 457 void gtk_sheet_range_set_justification  (GtkSheet *sheet,
 458                                         const GtkSheetRange *range,
 459                                         GtkJustification justification);
 460
 461 void gtk_sheet_column_set_justification (GtkSheet *sheet,
 462                                         gint column,
 463                                         GtkJustification justification);
 464
 465 /* set if cell contents can be edited or not in the given range:
 466  * accepted values are TRUE or FALSE. */
 467 void gtk_sheet_range_set_editable (GtkSheet *sheet,
 468                                         const GtkSheetRange *range,
 469                                         gint editable);
 470
 471 /* set if cell contents are visible or not in the given range:
 472  * accepted values are TRUE or FALSE.*/
 473 void gtk_sheet_range_set_visible  (GtkSheet *sheet,
 474                                         const GtkSheetRange *range,
 475                                         gboolean visible);
 476
 477 /* set cell border style in the given range.
 478  * mask values are CELL_LEFT_BORDER, CELL_RIGHT_BORDER, CELL_TOP_BORDER,
 479  * CELL_BOTTOM_BORDER
 480  * width is the width of the border line in pixels
 481  * line_style is the line_style for the border line */
 482 void gtk_sheet_range_set_border         (GtkSheet *sheet,
 483                                         const GtkSheetRange *range,
 484                                         gint mask,
 485                                         guint width,
 486                                         gint line_style);
 487
 488 /* set border color for the given range */
 489 void gtk_sheet_range_set_border_color   (GtkSheet *sheet,
 490                                         const GtkSheetRange *range,
 491                                         const GdkColor *color);
 492
 493 /* set font for the given range */
 494 void gtk_sheet_range_set_font           (GtkSheet *sheet,
 495                                         const GtkSheetRange *range,
 496                                         PangoFontDescription *font);
 497
 498 /* get cell attributes of the given cell */
 499 /* TRUE means that the cell is currently allocated */
 500 gboolean gtk_sheet_get_attributes       (const GtkSheet *sheet,
 501                                         gint row, gint col,
 502                                         GtkSheetCellAttr *attributes);
 503
 504
 505 void           gtk_sheet_set_model (GtkSheet *sheet,
 506                                    GSheetModel *model);
 507
 508 GSheetModel * gtk_sheet_get_model (const GtkSheet *sheet);
 509
 510
 511 G_END_DECLS
 512
 513
 514 #endif /* __GTK_SHEET_H__ */
 515
 516