GTK_SHEET_ROW_FROZEN()

#define GTK_SHEET_ROW_FROZEN(sheet)      !gtk_sheet_rows_resizable(sheet)

GTK_SHEET_COLUMN_FROZEN()

#define GTK_SHEET_COLUMN_FROZEN(sheet)   !gtk_sheet_columns_resizable(sheet)

GTK_SHEET_AUTORESIZE()

#define GTK_SHEET_AUTORESIZE(sheet)      gtk_sheet_autoresize(sheet)

GTK_SHEET_CLIP_TEXT()

#define GTK_SHEET_CLIP_TEXT(sheet)       gtk_sheet_clip_text(sheet)

GTK_SHEET_ROW_TITLES_VISIBLE()

#define GTK_SHEET_ROW_TITLES_VISIBLE(sheet)   gtk_sheet_row_titles_visible(sheet)

GTK_SHEET_COL_TITLES_VISIBLE()

#define GTK_SHEET_COL_TITLES_VISIBLE(sheet)   gtk_sheet_column_titles_visible(sheet)

GTK_SHEET_AUTO_SCROLL()

#define GTK_SHEET_AUTO_SCROLL(sheet)     gtk_sheet_autoscroll(sheet)

GTK_SHEET_JUSTIFY_ENTRY()

#define GTK_SHEET_JUSTIFY_ENTRY(sheet)   gtk_sheet_justify_entry(sheet)

gtk_sheet_new ()

GtkWidget *
gtk_sheet_new (guint rows,
               guint columns,
               const gchar *title);

Creates a new sheet widget with the given number of rows and columns.

gtk_sheet_construct ()

void
gtk_sheet_construct (GtkSheet *sheet,
                     guint rows,
                     guint columns,
                     const gchar *title);

Initializes an existent GtkSheet with the given number of rows and columns.

gtk_sheet_new_browser ()

GtkWidget *
gtk_sheet_new_browser (guint rows,
                       guint columns,
                       const gchar *title);

Creates a new browser sheet. Its cells cannot be edited(read-only).

gtk_sheet_construct_browser ()

void
gtk_sheet_construct_browser (GtkSheet *sheet,
                             guint rows,
                             guint columns,
                             const gchar *title);

Initializes an existent read-only GtkSheet with the given number of rows and columns.

gtk_sheet_new_with_custom_entry ()

GtkWidget *
gtk_sheet_new_with_custom_entry (guint rows,
                                 guint columns,
                                 const gchar *title,
                                 GType entry_type);

Creates a new sheet widget with the given number of rows and columns and a custome entry type.

gtk_sheet_construct_with_custom_entry ()

void
gtk_sheet_construct_with_custom_entry (GtkSheet *sheet,
                                       guint rows,
                                       guint columns,
                                       const gchar *title,
                                       GType entry_type);

Initializes an existent read-only GtkSheet with the given number of rows and columns and a custom entry.

gtk_sheet_set_hadjustment ()

void
gtk_sheet_set_hadjustment (GtkSheet *sheet,
                           GtkAdjustment *adjustment);

Change horizontal scroll adjustments.

gtk_sheet_set_vadjustment ()

void
gtk_sheet_set_vadjustment (GtkSheet *sheet,
                           GtkAdjustment *adjustment);

Change vertical scroll adjustments.

gtk_sheet_change_entry ()

void
gtk_sheet_change_entry (GtkSheet *sheet,
                        const GType entry_type);

Changes the current entry of the cell in GtkSheet. The old sheet entry widget gets dropped and a new entry widget is created. Beware: You will have to reconnect all your signal handlers after changing an entry.

gtk_sheet_get_entry_type ()

GType
gtk_sheet_get_entry_type (GtkSheet *sheet);

Get sheets entry type, if known

gtk_sheet_get_entry ()

GtkWidget *
gtk_sheet_get_entry (GtkSheet *sheet);

Get sheet's entry widget.

If the entry widget is a container, the direct childs of the container are searched for a valid entry widget. If you want the container itself to be returned, you should use gtk_sheet_get_entry_widget() instead.

gtk_sheet_get_entry_widget ()

GtkWidget *
gtk_sheet_get_entry_widget (GtkSheet *sheet);

Get sheet's entry widget.

If the entry widget is a container, the container widget is returned. In order to get the entry in the container child, you might want to use gtk_sheet_get_entry() instead.

gtk_sheet_get_entry_text ()

gchar *
gtk_sheet_get_entry_text (GtkSheet *sheet);

Get the text out of the sheet_entry.

This function is mainly used to synchronize the text of a second entry with the sheet_entry.

This function is necessary, because not all possible entry widgets implement the GtkEditable interface yet.

gtk_sheet_set_entry_text ()

void
gtk_sheet_set_entry_text (GtkSheet *sheet,
                          const gchar *text);

Set the text in the sheet_entry (and active cell).

This function is mainly used to synchronize the text of a second entry with the sheet_entry.

This function is necessary, because not all possible entry widgets implement the GtkEditable interface yet.

gtk_sheet_set_entry_editable ()

void
gtk_sheet_set_entry_editable (GtkSheet *sheet,
                              const gboolean editable);

Set the editable flag in the sheet_entry

This function is mainly used to synchronize the editable flag of a second entry with the sheet_entry.

This function is necessary, because not all possible entry widgets implement the GtkEditable interface yet.

gtk_sheet_entry_select_region ()

void
gtk_sheet_entry_select_region (GtkSheet *sheet,
                               gint start_pos,
                               gint end_pos);

Selects a region of text.

This function is necessary, because not all possible entry widgets implement the GtkEditable interface yet.

gtk_sheet_entry_signal_connect_changed ()

gulong
gtk_sheet_entry_signal_connect_changed
                               (GtkSheet *sheet,
                                GCallback handler);

Connect a handler to the sheet_entry "changed" signal. The user_data argument of the handler will be filled with the GtkSheet.

This function is mainly used to synchronize a second entry widget with the sheet_entry.

This function is necessary, because not all possible entry widgets implement the GtkEditable interface yet.

gtk_sheet_entry_signal_disconnect_by_func ()

void
gtk_sheet_entry_signal_disconnect_by_func
                               (GtkSheet *sheet,
                                GCallback handler);

Disconnect a handler from the sheet_entry "changed" signal

This function is mainly used to synchronize a second entry widget with the sheet_entry.

This function is necessary, because not all possible entry widgets implement the GtkEditable interface yet.

gtk_sheet_get_state ()

GtkSheetState
gtk_sheet_get_state (GtkSheet *sheet);

Get the selection state of the sheet (GtkSheetState).

gtk_sheet_get_rows_count ()

guint
gtk_sheet_get_rows_count (GtkSheet *sheet);

Get the number of the rows of the GtkSheet.

gtk_sheet_get_columns_count ()

guint
gtk_sheet_get_columns_count (GtkSheet *sheet);

Get the number of the columns of the GtkSheet.

gtk_sheet_get_visible_range ()

void
gtk_sheet_get_visible_range (GtkSheet *sheet,
                             GtkSheetRange *range);

Get sheet's ranges in a GkSheetRange structure.

gtk_sheet_get_selection ()

gboolean
gtk_sheet_get_selection (GtkSheet *sheet,
                         GtkSheetState *state,
                         GtkSheetRange *range);

Inquire current cell selection state and range.

gtk_sheet_set_selection_mode ()

void
gtk_sheet_set_selection_mode (GtkSheet *sheet,
                              GtkSelectionMode mode);

Sets the selection mode of the cells in a GtkSheet.

gtk_sheet_set_autoresize ()

void
gtk_sheet_set_autoresize (GtkSheet *sheet,
                          gboolean autoresize);

Controls wether cells will be autoresized upon deactivation, as you type text or set a cell_text value. If you want the cells to be autoresized when you pack widgets look at gtk_sheet_attach_*(). This function sets both: autoresize_columns and autoresize_cells.

gtk_sheet_set_autoresize_columns ()

void
gtk_sheet_set_autoresize_columns (GtkSheet *sheet,
                                  gboolean autoresize);

Controls wether columns will be autoresized upon deactivation, as you type text or set a cell_text value. If you want the cells to be autoresized when you pack widgets look at gtk_sheet_attach_*().

gtk_sheet_set_autoresize_rows ()

void
gtk_sheet_set_autoresize_rows (GtkSheet *sheet,
                               gboolean autoresize);

Controls wether rows will be autoresized upon deactivation, as you type text or set a cell_text value. If you want the cells to be autoresized when you pack widgets look at gtk_sheet_attach_*().

gtk_sheet_autoresize ()

gboolean
gtk_sheet_autoresize (GtkSheet *sheet);

Gets the autoresize mode of GtkSheet.

gtk_sheet_autoresize_columns ()

gboolean
gtk_sheet_autoresize_columns (GtkSheet *sheet);

Gets the autoresize mode for GtkSheet columns.

gtk_sheet_autoresize_rows ()

gboolean
gtk_sheet_autoresize_rows (GtkSheet *sheet);

Gets the autoresize mode for GtkSheet rows.

gtk_sheet_set_autoscroll ()

void
gtk_sheet_set_autoscroll (GtkSheet *sheet,
                          gboolean autoscroll);

The sheet will be automatically scrolled when you move beyond the last row/col in GtkSheet.

gtk_sheet_autoscroll ()

gboolean
gtk_sheet_autoscroll (GtkSheet *sheet);

Get the autoscroll mode of GtkSheet.

gtk_sheet_set_clip_text ()

void
gtk_sheet_set_clip_text (GtkSheet *sheet,
                         gboolean clip_text);

Clip text in cell. When clip text mode is turned off, cell text is written over neighbour columns, as long as their contents are empty.

gtk_sheet_clip_text ()

gboolean
gtk_sheet_clip_text (GtkSheet *sheet);

Get clip text mode in GtkSheet. When clip text mode is turned off, cell text is written over neighbour columns, as long as their contents are empty.

gtk_sheet_set_justify_entry ()

void
gtk_sheet_set_justify_entry (GtkSheet *sheet,
                             gboolean justify);

Justify cell entry editor in GtkSheet.

gtk_sheet_justify_entry ()

gboolean
gtk_sheet_justify_entry (GtkSheet *sheet);

Get the cell entry editor justification setting from GtkSheet.

gtk_sheet_set_vjustification ()

void
gtk_sheet_set_vjustification (GtkSheet *sheet,
                              GtkSheetVerticalJustification vjust);

Set the default vertical cell text justification for GtkSheet.

gtk_sheet_get_vjustification ()

GtkSheetVerticalJustification
gtk_sheet_get_vjustification (GtkSheet *sheet);

Get the default vertical cell text justification from GtkSheet.

gtk_sheet_set_traverse_type ()

void
gtk_sheet_set_traverse_type (GtkSheet *sheet,
                             GtkSheetTraverseType ttype);

Set the default traversal type for cursor movement in a GtkSheet.

gtk_sheet_get_traverse_type ()

GtkSheetTraverseType
gtk_sheet_get_traverse_type (GtkSheet *sheet);

Get the default cell traversal type from GtkSheet.

gtk_sheet_set_locked ()

void
gtk_sheet_set_locked (GtkSheet *sheet,
                      gboolean locked);

Lock the GtkSheet, which means it is no longer editable, cell contents cannot be modified by the user.

gtk_sheet_locked ()

gboolean
gtk_sheet_locked (GtkSheet *sheet);

Get the lock status of GtkSheet, locked means the sheet is not editable, cell contents cannot be modified by the user.

gtk_sheet_set_title ()

void
gtk_sheet_set_title (GtkSheet *sheet,
                     const gchar *title);

Set GtkSheet title. The widget will keep a copy of the string.

gtk_sheet_set_description ()

void
gtk_sheet_set_description (GtkSheet *sheet,
                           const gchar *description);

Set GtkSheet description for application use.

gtk_sheet_get_description ()

const gchar *
gtk_sheet_get_description (GtkSheet *sheet,
                           const gchar *description);

Get sheet description.

gtk_sheet_is_frozen ()

gboolean
gtk_sheet_is_frozen (GtkSheet *sheet);

Get freeze status.

gtk_sheet_freeze ()

void
gtk_sheet_freeze (GtkSheet *sheet);

Freeze all visual updates of the GtkSheet. The updates will occure in a more efficient way than if you made them on a unfrozen GtkSheet .

gtk_sheet_thaw ()

void
gtk_sheet_thaw (GtkSheet *sheet);

Thaw the sheet after you have made a number of changes on a frozen sheet. The updates will occure in a more efficient way than if you made them on a unfrozen sheet .

gtk_sheet_set_background ()

void
gtk_sheet_set_background (GtkSheet *sheet,
                          GdkColor *color);

Sets the background color of the GtkSheet. If pass NULL, the sheet will be reset to the default color.

gtk_sheet_set_grid ()

void
gtk_sheet_set_grid (GtkSheet *sheet,
                    GdkColor *color);

Set the grid color. If pass NULL, the grid will be reset to the default color.

gtk_sheet_show_grid ()

void
gtk_sheet_show_grid (GtkSheet *sheet,
                     gboolean show);

Sets the visibility of grid in GtkSheet.

gtk_sheet_grid_visible ()

gboolean
gtk_sheet_grid_visible (GtkSheet *sheet);

Gets the visibility of grid in GtkSheet.

gtk_sheet_set_row_title ()

void
gtk_sheet_set_row_title (GtkSheet *sheet,
                         gint row,
                         const gchar *title);

Set row title.

gtk_sheet_get_row_title ()

const gchar *
gtk_sheet_get_row_title (GtkSheet *sheet,
                         gint row);

Get row title.

gtk_sheet_row_button_add_label ()

void
gtk_sheet_row_button_add_label (GtkSheet *sheet,
                                gint row,
                                const gchar *label);

Set button label.It is used to set a row title.

gtk_sheet_row_button_get_label ()

const gchar *
gtk_sheet_row_button_get_label (GtkSheet *sheet,
                                gint row);

Get a row button label.

gtk_sheet_row_button_justify ()

void
gtk_sheet_row_button_justify (GtkSheet *sheet,
                              gint row,
                              GtkJustification justification);

Set the justification(alignment) of the row buttons.

gtk_sheet_moveto ()

void
gtk_sheet_moveto (GtkSheet *sheet,
                  gint row,
                  gint column,
                  gint row_align,
                  gint col_align);

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 being top or left, 1 being bottom or right.

passing row_align/col_align of -1 will suppress movement in that direction.

if row or column is negative then there is no change

gtk_sheet_set_row_titles_width ()

void
gtk_sheet_set_row_titles_width (GtkSheet *sheet,
                                guint width);

Resize row titles area.

gtk_sheet_show_row_titles ()

void
gtk_sheet_show_row_titles (GtkSheet *sheet);

Show row titles .

gtk_sheet_hide_row_titles ()

void
gtk_sheet_hide_row_titles (GtkSheet *sheet);

Hide row titles .

gtk_sheet_row_titles_visible ()

gboolean
gtk_sheet_row_titles_visible (GtkSheet *sheet);

Get the visibility of row column titles .

gtk_sheet_row_sensitive ()

gboolean
gtk_sheet_row_sensitive (GtkSheet *sheet,
                         gint row);

Get row button sensitivity.

gtk_sheet_row_set_sensitivity ()

void
gtk_sheet_row_set_sensitivity (GtkSheet *sheet,
                               gint row,
                               gboolean sensitive);

Set row button sensitivity. If sensitivity is TRUE can be toggled, otherwise it acts as a title .

gtk_sheet_rows_set_sensitivity ()

void
gtk_sheet_rows_set_sensitivity (GtkSheet *sheet,
                                gboolean sensitive);

Set rows buttons sensitivity. If sensitivity is TRUE button can be toggled, otherwise act as titles. The sheet itself has no such property, it is a convenience function to set the property for all existing rows.

gtk_sheet_rows_resizable ()

gboolean
gtk_sheet_rows_resizable (GtkSheet *sheet);

Get rows resizable status.

gtk_sheet_rows_set_resizable ()

void
gtk_sheet_rows_set_resizable (GtkSheet *sheet,
                              gboolean resizable);

Set rows resizable status.

gtk_sheet_row_visible ()

gboolean
gtk_sheet_row_visible (GtkSheet *sheet,
                       gint row);

Get row visibility.

gtk_sheet_row_set_visibility ()

void
gtk_sheet_row_set_visibility (GtkSheet *sheet,
                              gint row,
                              gboolean visible);

Set row visibility. The default value is TRUE. If FALSE, the row is hidden.

gtk_sheet_row_label_set_visibility ()

void
gtk_sheet_row_label_set_visibility (GtkSheet *sheet,
                                    gint row,
                                    gboolean visible);

Set row label visibility.

gtk_sheet_rows_labels_set_visibility ()

void
gtk_sheet_rows_labels_set_visibility (GtkSheet *sheet,
                                      gboolean visible);

Set all rows label visibility. The sheet itself has no such property, this is a convenience function to set the property for all existing rows.

gtk_sheet_get_tooltip_markup ()

gchar *
gtk_sheet_get_tooltip_markup (GtkSheet *sheet);

Gets the contents of the tooltip (markup) for sheet

gtk_sheet_set_tooltip_markup ()

void
gtk_sheet_set_tooltip_markup (GtkSheet *sheet,
                              const gchar *markup);

Sets markup as the contents of the tooltip, which is marked up with the Pango text markup language.

gtk_sheet_get_tooltip_text ()

gchar *
gtk_sheet_get_tooltip_text (GtkSheet *sheet);

Gets the contents of the tooltip for the GtkSheet

gtk_sheet_set_tooltip_text ()

void
gtk_sheet_set_tooltip_text (GtkSheet *sheet,
                            const gchar *text);

Sets text as the contents of the tooltip.

gtk_sheet_row_get_tooltip_markup ()

gchar *
gtk_sheet_row_get_tooltip_markup (GtkSheet *sheet,
                                  const gint row);

Gets the contents of the tooltip (markup) for the column

gtk_sheet_row_set_tooltip_markup ()

void
gtk_sheet_row_set_tooltip_markup (GtkSheet *sheet,
                                  const gint row,
                                  const gchar *markup);

Sets markup as the contents of the tooltip, which is marked up with the Pango text markup language.

gtk_sheet_row_get_tooltip_text ()

gchar *
gtk_sheet_row_get_tooltip_text (GtkSheet *sheet,
                                const gint row);

Gets the contents of the tooltip for the column

gtk_sheet_row_set_tooltip_text ()

void
gtk_sheet_row_set_tooltip_text (GtkSheet *sheet,
                                const gint row,
                                const gchar *text);

Sets text as the contents of the tooltip.

gtk_sheet_row_get_readonly ()

gboolean
gtk_sheet_row_get_readonly (GtkSheet *sheet,
                            const gint row);

Gets the row readonly flag

gtk_sheet_row_set_readonly ()

void
gtk_sheet_row_set_readonly (GtkSheet *sheet,
                            const gint row,
                            const gboolean is_readonly);

Sets the row readonly flag. A cell is editable if the sheet is not locked, the row is not readonly and the cell (-range) was set to editable.

gtk_sheet_row_get_can_focus ()

gboolean
gtk_sheet_row_get_can_focus (GtkSheet *sheet,
                             const gint row);

Gets the row can_focus flag

gtk_sheet_row_set_can_focus ()

void
gtk_sheet_row_set_can_focus (GtkSheet *sheet,
                             const gint row,
                             const gboolean can_focus);

Sets the row can_focus flag. Note: Does not check row visiblity, sensitivity, etc. Use the macro GTK_SHEET_ROW_CAN_GRAB_FOCUS() for dependency checking.

gtk_sheet_cell_get_tooltip_markup ()

gchar *
gtk_sheet_cell_get_tooltip_markup (GtkSheet *sheet,
                                   const gint row,
                                   const gint col);

Gets the contents of the tooltip (markup) for the column

gtk_sheet_cell_set_tooltip_markup ()

void
gtk_sheet_cell_set_tooltip_markup (GtkSheet *sheet,
                                   const gint row,
                                   const gint col,
                                   const gchar *markup);

Sets markup as the contents of the tooltip, which is marked up with the Pango text markup language.

gtk_sheet_cell_get_tooltip_text ()

gchar *
gtk_sheet_cell_get_tooltip_text (GtkSheet *sheet,
                                 const gint row,
                                 const gint col);

Gets the contents of the tooltip for the column

gtk_sheet_cell_set_tooltip_text ()

void
gtk_sheet_cell_set_tooltip_text (GtkSheet *sheet,
                                 const gint row,
                                 const gint col,
                                 const gchar *text);

Sets text as the contents of the tooltip.

gtk_sheet_cell_get_editable ()

gboolean
gtk_sheet_cell_get_editable (GtkSheet *sheet,
                             const gint row,
                             const gint col);

Check editable status of sheet, row, column and cell to decide if a sheet cell is editable

gtk_sheet_cell_set_editable ()

void
gtk_sheet_cell_set_editable (GtkSheet *sheet,
                             const gint row,
                             const gint col,
                             const gboolean is_editable);

Sets cell editable status in cell attributes.

gtk_sheet_cell_get_sensitive ()

gboolean
gtk_sheet_cell_get_sensitive (GtkSheet *sheet,
                              const gint row,
                              const gint col);

Check sensitivity status of sheet, row, column and cell to decide if a sheet cell can receive focus.

gtk_sheet_cell_set_sensitive ()

void
gtk_sheet_cell_set_sensitive (GtkSheet *sheet,
                              const gint row,
                              const gint col,
                              const gboolean is_sensitive);

Sets cell sensitive status

gtk_sheet_cell_get_can_focus ()

gboolean
gtk_sheet_cell_get_can_focus (GtkSheet *sheet,
                              const gint row,
                              const gint col);

Check ability of cell to grab focus. Check includes checking for blocks at row/column/sheet level.

gtk_sheet_cell_set_can_focus ()

void
gtk_sheet_cell_set_can_focus (GtkSheet *sheet,
                              const gint row,
                              const gint col,
                              const gboolean can_focus);

Sets cell can_focus flag

gtk_sheet_select_row ()

void
gtk_sheet_select_row (GtkSheet *sheet,
                      gint row);

Select the row. The range is then highlighted, and the bounds are stored in sheet->range.

gtk_sheet_select_column ()

void
gtk_sheet_select_column (GtkSheet *sheet,
                         gint column);

Select the column. The range is then highlighted, and the bounds are stored in sheet->range.

gtk_sheet_select_range ()

void
gtk_sheet_select_range (GtkSheet *sheet,
                        const GtkSheetRange *range);

Highlight the selected range and store bounds in sheet->range

gtk_sheet_clip_range ()

void
gtk_sheet_clip_range (GtkSheet *sheet,
                      const GtkSheetRange *clip_range);

Save selected range to "clipboard".

gtk_sheet_unclip_range ()

void
gtk_sheet_unclip_range (GtkSheet *sheet);

Free clipboard.

gtk_sheet_in_clip ()

gboolean
gtk_sheet_in_clip (GtkSheet *sheet);

Get the clip status of GtkSheet.

gtk_sheet_get_vadjustment ()

GtkAdjustment *
gtk_sheet_get_vadjustment (GtkSheet *sheet);

Get vertical scroll adjustments.

gtk_sheet_get_hadjustment ()

GtkAdjustment *
gtk_sheet_get_hadjustment (GtkSheet *sheet);

Get horizontal scroll adjustments.

gtk_sheet_unselect_range ()

void
gtk_sheet_unselect_range (GtkSheet *sheet);

Unselect the current selected range and clears the bounds in sheet->range.

gtk_sheet_set_active_cell ()

gboolean
gtk_sheet_set_active_cell (GtkSheet *sheet,
                           gint row,
                           gint column);

Set active cell where the cell entry will be displayed. Use (row,col) = (-1,-1) to deactivate active cell.

gtk_sheet_get_active_cell ()

void
gtk_sheet_get_active_cell (GtkSheet *sheet,
                           gint *row,
                           gint *column);

Store the coordinates of the active cell in row,col. If (row<0 || col<0) then there was no active cell in the sheet.

gtk_sheet_set_tab_direction ()

void
gtk_sheet_set_tab_direction (GtkSheet *sheet,
                             GtkDirectionType dir);

Sets a primary movement direction to the Tab, Return and Enter keys, and assigns the opposite direction to the same keys with GDK_SHIFT_MASK.

Transposed movement direction can be accessed with GTK_SHEET_MOD_MASK|GDK_CONTROL_MASK and GTK_SHEET_MOD_MASK|GDK_CONTROL_MASK|GDK_SHIFT_MASK.

All bindings are defined for the GtkSheetClass, so all sheet instances use the same movement directions.

Default: GTK_DIR_TAB_FORWARD.

Since: 3.0.2

gtk_sheet_set_cell ()

void
gtk_sheet_set_cell (GtkSheet *sheet,
                    gint row,
                    gint col,
                    GtkJustification justification,
                    const gchar *text);

Set cell contents and allocate memory if needed.

gtk_sheet_set_cell_text ()

void
gtk_sheet_set_cell_text (GtkSheet *sheet,
                         gint row,
                         gint col,
                         const gchar *text);

Set cell contents and allocate memory if needed. No justifcation is made. attributes and links remain unchanged.

gtk_sheet_cell_get_text ()

gchar *
gtk_sheet_cell_get_text (GtkSheet *sheet,
                         gint row,
                         gint col);

Get cell text.

gtk_sheet_cell_clear ()

void
gtk_sheet_cell_clear (GtkSheet *sheet,
                      gint row,
                      gint column);

Clear cell contents.

gtk_sheet_cell_delete ()

void
gtk_sheet_cell_delete (GtkSheet *sheet,
                       gint row,
                       gint column);

Clear cell contents and remove links.

gtk_sheet_range_clear ()

void
gtk_sheet_range_clear (GtkSheet *sheet,
                       const GtkSheetRange *range);

Clear range contents. If range==NULL the whole sheet will be cleared.

gtk_sheet_range_delete ()

void
gtk_sheet_range_delete (GtkSheet *sheet,
                        const GtkSheetRange *range);

Clear range contents and remove links. FIXME:: if range==NULL whole sheet is deleted?

gtk_sheet_cell_get_state ()

GtkStateType
gtk_sheet_cell_get_state (GtkSheet *sheet,
                          gint row,
                          gint col);

Get status of a cell.

gtk_sheet_link_cell ()

void
gtk_sheet_link_cell (GtkSheet *sheet,
                     gint row,
                     gint col,
                     gpointer link);

Link pointer to a cell.

gtk_sheet_get_link ()

gpointer
gtk_sheet_get_link (GtkSheet *sheet,
                    gint row,
                    gint col);

Get link pointer from a cell.

gtk_sheet_remove_link ()

void
gtk_sheet_remove_link (GtkSheet *sheet,
                       gint row,
                       gint col);

Remove link pointer from a cell.

gtk_sheet_get_pixel_info ()

gboolean
gtk_sheet_get_pixel_info (GtkSheet *sheet,
                          GdkWindow *window,
                          gint x,
                          gint y,
                          gint *row,
                          gint *column);

Get row and column correspondig to the given position within the sheet.

In order to decode clicks into to title area correctly, pass the GdkWindow from the button event. Omitting the window (NULL) defaults to the sheet window.

row and column may return values in the range [-1 .. max+1] depending on wether the position lies within the title area, the sheet cell area or beyond the outermost row/column.

All 9 sheet areas can be reliably determined by evaluating the returned row/column values (title area/cell area/outside).

gtk_sheet_get_cell_area ()

gboolean
gtk_sheet_get_cell_area (GtkSheet *sheet,
                         gint row,
                         gint column,
                         GdkRectangle *area);

Get area of a given cell.

gtk_sheet_set_row_height ()

void
gtk_sheet_set_row_height (GtkSheet *sheet,
                          gint row,
                          guint height);

Set row height.

gtk_sheet_add_column ()

void
gtk_sheet_add_column (GtkSheet *sheet,
                      guint ncols);

Append ncols columns to the right of the sheet.

gtk_sheet_add_row ()

void
gtk_sheet_add_row (GtkSheet *sheet,
                   guint nrows);

Append nrows rows to the end of the sheet.

gtk_sheet_insert_rows ()

void
gtk_sheet_insert_rows (GtkSheet *sheet,
                       guint row,
                       guint nrows);

Insert nrows rows before the given row and pull right.

gtk_sheet_insert_columns ()

void
gtk_sheet_insert_columns (GtkSheet *sheet,
                          guint col,
                          guint ncols);

Insert ncols columns before the given row and pull right.

gtk_sheet_delete_rows ()

void
gtk_sheet_delete_rows (GtkSheet *sheet,
                       guint row,
                       guint nrows);

Delete nrows rows starting from row .

gtk_sheet_delete_columns ()

void
gtk_sheet_delete_columns (GtkSheet *sheet,
                          guint col,
                          guint ncols);

Delete ncols columns starting from col .

gtk_sheet_range_set_background ()

void
gtk_sheet_range_set_background (GtkSheet *sheet,
                                const GtkSheetRange *urange,
                                const GdkColor *color);

Set background color of the given range.

gtk_sheet_range_set_foreground ()

void
gtk_sheet_range_set_foreground (GtkSheet *sheet,
                                const GtkSheetRange *urange,
                                const GdkColor *color);

Set foreground color of the given range.

gtk_sheet_range_set_justification ()

void
gtk_sheet_range_set_justification (GtkSheet *sheet,
                                   const GtkSheetRange *urange,
                                   GtkJustification just);

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.

gtk_sheet_range_set_editable ()

void
gtk_sheet_range_set_editable (GtkSheet *sheet,
                              const GtkSheetRange *urange,
                              gint editable);

Set if cell contents can be edited or not in the given range.

gtk_sheet_range_set_visible ()

void
gtk_sheet_range_set_visible (GtkSheet *sheet,
                             const GtkSheetRange *urange,
                             gboolean visible);

Set if cell contents are visible or not in the given range: accepted values are TRUE or FALSE.

gtk_sheet_range_set_border ()

void
gtk_sheet_range_set_border (GtkSheet *sheet,
                            const GtkSheetRange *urange,
                            gint mask,
                            guint width,
                            gint line_style);

Set cell border style in the given range.

gtk_sheet_range_set_border_color ()

void
gtk_sheet_range_set_border_color (GtkSheet *sheet,
                                  const GtkSheetRange *urange,
                                  const GdkColor *color);

Set border color for the given range.

gtk_sheet_range_set_font ()

void
gtk_sheet_range_set_font (GtkSheet *sheet,
                          const GtkSheetRange *urange,
                          PangoFontDescription *font_desc);

Set font_desc for the given range.

gtk_sheet_get_attributes ()

gboolean
gtk_sheet_get_attributes (GtkSheet *sheet,
                          gint row,
                          gint col,
                          GtkSheetCellAttr *attributes);

Gett cell attributes of the given cell.

gtk_sheet_put ()

GtkSheetChild *
gtk_sheet_put (GtkSheet *sheet,
               GtkWidget *child,
               gint x,
               gint y);

Add widgets to the sheet. The widget is floating in one given position (x,y) regardless of the configurations of rows/columns. This means that cells do not resize depending on the widgets' size. You can resize it yourself or use gtk_sheet_attach_*() You may remove it with gtk_container_remove(GTK_CONTAINER(sheet), GtkWidget *child);

gtk_sheet_attach_floating ()

void
gtk_sheet_attach_floating (GtkSheet *sheet,
                           GtkWidget *widget,
                           gint row,
                           gint col);

The widget is attached to the top-left corner of a cell (row,column) and moves with it when you change width, height, or you delete of add row/columns

gtk_sheet_attach_default ()

void
gtk_sheet_attach_default (GtkSheet *sheet,
                          GtkWidget *widget,
                          gint row,
                          gint col);

Attaches a child widget to the given cell with the 0,0 alignments. Works basically like gtk_table_attach, with the same options, the widget is confined in the cell, and whether it fills the cell, expands with it, or shrinks with it, depending on the options. The child is reallocated each time the column or row changes, keeping attached to the same cell. It's in fact gtk_sheet_attach() with GTK_EXPAND set.

gtk_sheet_attach ()

void
gtk_sheet_attach (GtkSheet *sheet,
                  GtkWidget *widget,
                  gint row,
                  gint col,
                  gint xoptions,
                  gint yoptions,
                  gint xpadding,
                  gint ypadding);