/[pspp]/psppire/gtk_sheet/gtksheet.h
ViewVC logotype

Diff of /psppire/gtk_sheet/gtksheet.h

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

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

Legend:
Removed from v.1.1.1.1  
changed lines
  Added in v.1.2

savannah-hackers-public@gnu.org
ViewVC Help
Powered by ViewVC 1.1.26