| GTK-EXTRA - Reference Manual

| Home

# GtkSheet

## Name

GtkSheet - a spreadsheet widget for gtk+

## Synopsis

    GtkType
    gtk_sheet_get_type
    (void);
    GtkType
    gtk_sheet_range_get_type
    (void);
    GtkWidget*
    gtk_sheet_new
    (guint rows,
    guint columns,
    const gchar *title);
    void
    gtk_sheet_construct
    (GtkSheet *sheet,
    guint rows,
    guint columns,
    const gchar *title);
    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);
    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);
    void
    gtk_sheet_set_hadjustment
    (GtkSheet *sheet,
    GtkAdjustment *adjustment);
    void
    gtk_sheet_set_vadjustment
    (GtkSheet *sheet,
    GtkAdjustment *adjustment);
    void
    gtk_sheet_change_entry
    GtkSheet *sheet, GtkType entry_type);
    GtkWidget *
    gtk_sheet_get_entry
    (GtkSheet *sheet);
    gint
    gtk_sheet_get_state
    (GtkSheet *sheet);
    guint
    gtk_sheet_get_columns_count
    (GtkSheet *sheet);
    guint
    gtk_sheet_get_rows_count
    (GtkSheet *sheet);
    void
    gtk_sheet_get_visible_range
    (GtkSheet *sheet,
    GtkSheetRange *range);
    void
    gtk_sheet_set_selection_mode
    GtkSheet *sheet, gint mode);
    void
    gtk_sheet_set_title
    (GtkSheet *sheet,
     const gchar *title);
    void
    gtk_sheet_freeze
    (GtkSheet *sheet);
    void
    gtk_sheet_thaw
    (GtkSheet *sheet);
    void
    gtk_sheet_set_foreground
    (GtkSheet *sheet,
    GdkColor *fg_color);
    void
    gtk_sheet_set_background
    (GtkSheet *sheet,
    GdkColor *bg_color);
    void
    gtk_sheet_range_set_background
    (GtkSheet *sheet,
    const GtkSheetRange *range,
    const GdkColor *color);
    void
    gtk_sheet_range_set_foreground
    (GtkSheet *sheet,
    const GtkSheetRange *range,
    const GdkColor *color);
    void
    gtk_sheet_show_grid
    (GtkSheet *sheet,
    gboolean show);
    gboolean
    gtk_sheet_grid_visible
    (GtkSheet *sheet);
    void
    gtk_sheet_set_column_title
    (GtkSheet * sheet,
    gint column,
    const gchar * title);
    void
    gtk_sheet_set_row_title
    (GtkSheet * sheet,
    gint row,
    const gchar * title);
    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);
    void
    gtk_sheet_row_button_justify
    (GtkSheet *sheet,
    gint row,
    GtkJustification justification);
    void
    gtk_sheet_column_button_justify
    (GtkSheet *sheet,
    gint row,
    GtkJustification justification);
    void
    gtk_sheet_moveto
    (GtkSheet * sheet,
    gint row,gint column,
    gfloat row_align,gfloat col_align);
    void
    gtk_sheet_set_row_titles_width
    (GtkSheet *sheet,
    guint width);
    void
    gtk_sheet_set_column_titles_height
    (GtkSheet *sheet,
    guint height);
    void
    gtk_sheet_show_column_titles
    (GtkSheet *sheet,
    guint height);
    void
    gtk_sheet_show_row_titles
    (GtkSheet *sheet);
    void
    gtk_sheet_hide_column_titles
    (GtkSheet *sheet);
    void
    gtk_sheet_hide_row_titles
    (GtkSheet *sheet);
    void
    gtk_sheet_column_set_sensitivity
    (GtkSheet *sheet,
    gint column,
    gboolean sensitive);
    void
    gtk_sheet_columns_set_sensitivity
    (GtkSheet *sheet,
    gboolean sensitive);
    void
    gtk_sheet_row_set_sensitivity
    (GtkSheet *sheet,
    gint row,
    gboolean sensitive);
    void
    gtk_sheet_row_set_sensitivity
    (GtkSheet *sheet,
    gboolean sensitive);
    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);
    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);
    void
    gtk_sheet_select_row
    (GtkSheet * sheet,
    gint row);
    void
    gtk_sheet_select_column
    (GtkSheet * sheet,
    gint column);
    void
    gtk_sheet_clip_range
    (GtkSheet *sheet,
    const GtkSheetRange *range);
    void
    gtk_sheet_unclip_range
    (GtkSheet *sheet);
    GtkAdjustment *
    gtk_sheet_get_vadjustment
    (GtkSheet * sheet);
    GtkAdjustment *
    gtk_sheet_get_hadjustment
    (GtkSheet * sheet);
    void
    gtk_sheet_select_range
    (GtkSheet *sheet,
    const GtkSheetRange *range);
    void
    gtk_sheet_unselect_range
    (GtkSheet *sheet);
    gboolean
    gtk_sheet_set_active_cell
    (GtkSheet *sheet,
    gint row, gint column);
    void
    gtk_sheet_get_active_cell
    (GtkSheet *sheet,
    gint *row, gint *column);
    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);
    gchar *
    gtk_sheet_cell_get_text
    (GtkSheet *sheet,
    gint row, gint col);
    void
    gtk_sheet_cell_clear
    (GtkSheet *sheet,
    gint row, gint col);
    void
    gtk_sheet_cell_delete
    (GtkSheet *sheet,
    gint row, gint col);
    void
    gtk_sheet_range_clear
    (GtkSheet *sheet,
    const GtkSheetRange *range);
    void
    gtk_sheet_range_delete
    (GtkSheet *sheet,
    const GtkSheetRange *range);
    GtkStateType
    gtk_sheet_cell_get_state
    (GtkSheet *sheet,
    gint row, gint col);
    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);
    gboolean
    gtk_sheet_get_pixel_info
    (GtkSheet * sheet,
    gint x,gint y,
    gint * row,gint * column);
    gboolean
    gtk_sheet_get_cell_area
    (GtkSheet *sheet,
    gint row,gint column,
    GdkRectangle *area);
    void
    gtk_sheet_set_column_width
    (GtkSheet * sheet,
    gint column,
    guint width);
    void
    gtk_sheet_set_row_height
    (GtkSheet * sheet,
    gint row,
    guint height);
    void
    gtk_sheet_add_column
    (GtkSheet *sheet,
    guint ncols);
    void
    gtk_sheet_add_row
    (GtkSheet *sheet,
    guint nrows);
    void
    gtk_sheet_insert_rows
    (GtkSheet *sheet,
    guint row,
    guint nrows);
    void
    gtk_sheet_insert_columns
    (GtkSheet *sheet,
    guint col,
    guint ncols);
    void
    gtk_sheet_delete_rows
    (GtkSheet *sheet,
    guint row,
    guint nrows);
    void
    gtk_sheet_delete_columns
    (GtkSheet *sheet,
    guint col,
    guint ncols);
    void
    gtk_sheet_range_set_background
    (GtkSheet *sheet,
    const GtkSheetRange *range,
    const GdkColor *color);
    void
    gtk_sheet_range_set_foreground
    (GtkSheet *sheet,
    const GtkSheetRange *range,
    const GdkColor *color);
    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);
    void
    gtk_sheet_range_set_editable
    (GtkSheet *sheet,
    const GtkSheetRange *range,
    gint editable);
    void
    gtk_sheet_range_set_visible
    (GtkSheet *sheet,
     const GtkSheetRange *range,
    gboolean visible);
    void
    gtk_sheet_range_set_border
    (GtkSheet *sheet,
    const GtkSheetRange *range,
    gint mask,
    guint width,
    gint line_style);
    void
    gtk_sheet_range_set_border_color
    GtkSheet *sheet,
    const GtkSheetRange *range,
    const GdkColor  *color);
    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_move_child
    (GtkSheet *sheet,
    GtkWidget *widget,
    gint x, gint y);
    void
    gtk_sheet_attach
    (GtkSheet *sheet,
    GtkWidget *widget,
    gint row, gint col,
    gint xoptions,
    gint yoptions,
    gint xpadding,
    gint ypadding);
    void
    gtk_sheet_attach_default
    (GtkSheet *sheet,
    GtkWidget *widget,
    gint row, gint col);
    void
    gtk_sheet_attach_floating
    (GtkSheet *sheet,
    GtkWidget *widget,
    gint row, gint col);
    GtkSheetChild *
    gtk_sheet_get_child_at
    (GtkSheet *sheet,
    gint row, gint col);
    void
    gtk_sheet_button_attach
    (GtkSheet *sheet,
    GtkWidget *widget,gint row, gint col,
    gfloat x_align, gfloat y_align);
| From GkExtra 1.0 these functions will be used instead of sheet flags
    void
    gtk_sheet_set_autoresize
    (GtkSheet *sheet, gboolean autoresize);
    gboolean
    gtk_sheet_autoresize
    (GtkSheet *sheet);
    void
    gtk_sheet_set_autoscroll
    (GtkSheet *sheet, gboolean autoscroll);
    gboolean
    gtk_sheet_autoscroll
    (GtkSheet *sheet);
    void
    gtk_sheet_set_clip_text
    (GtkSheet *sheet, gboolean clip_text);
    gboolean
    gtk_sheet_clip_text
    (GtkSheet *sheet);
    void
    gtk_sheet_set_locked
    (GtkSheet *sheet, gboolean lock);
    void
    gtk_sheet_locked
    (GtkSheet *sheet);
    void
    gtk_sheet_rows_set_resizable
    (GtkSheet *sheet, gboolean resizable);
    gboolean
    gtk_sheet_rows_resizable
    (GtkSheet *sheet);
    void
    gtk_sheet_columns_set_resizable
    (GtkSheet *sheet, gboolean resizable);
    gboolean
    gtk_sheet_columns_resizable
    (GtkSheet *sheet);
    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);
    void
    gtk_sheet_set_justify_entry
    (GtkSheet *sheet, gboolean justify);
    gboolean
    gtk_sheet_justify_entry
    (GtkSheet *sheet);
| These flags are obsolete.Use the functions mentioned above.
    GTK_SHEET_AUTORESIZE(sheet)
| OBSOLETE from GtkExtra >0.99.17
    GTK_SHEET_ROW_FROZEN(sheet)
| OBSOLETE from GtkExtra >0.99.17
    GTK_SHEET_COLUMN_FROZEN(sheet)
| OBSOLETE from GtkExtra >0.99.17
    GTK_SHEET_CLIP_TEXT(sheet)
| OBSOLETE from GtkExtra >0.99.17
    GTK_SHEET_AUTO_SCROLL(sheet)
| OBSOLETE from GtkExtra >0.99.17
    GTK_SHEET_JUSTIFY_ENTRY(sheet)
| OBSOLETE from GtkExtra >0.99.17
    GTK_SHEET_ROW_TITLES_VISIBLE(sheet)
| OBSOLETE from GtkExtra >0.99.17
    GTK_SHEET_COL_TITLES_VISIBLE(sheet)
| OBSOLETE from GtkExtra >0.99.17

##

## Object Hierarchy

     GtkObject
       +----GtkWidget
             +----GtkContainer
                  +-----GtkSheet ???

##

##
Args

## Signal Prototypes

    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);

## Description

#### GtkSheet is a spreadsheet widget written by Adrian Feiguin.(thanks Adrian for this great library)
GtkSheet is a matrix widget for GTK+. It consists of an scrollable grid of cells where you can allocate text.
Cell contents can be edited interactively through a specially designed entry, GtkItemEntry.
It is also a container subclass, allowing you to display buttons, curves, pixmaps and any other widget in it.
You can also set many attributes as: border, foreground and background color, text justification, and more.
The testgtksheet program shows how easy is to create a spreadsheet-like GUI using this widget set.

##
Details
structures

struct _GtkSheetChild ; struct _GtkSheetButton; struct _GtkSheetCellBorder ; struct _GtkSheetCellAttr ; struct _GtkSheetCell ; struct _GtkSheetRow ; struct _GtkSheetRange ; struct _GtkSheetRow ; struct _GtkSheetColumn ; struct _GtkSheet ;

### gtk_sheet_get_type ()

    GtkType gtk_sheet_get_type (void);

Returns : |

### gtk_sheet_range_get_type ()

    GtkType gtk_sheet_range_get_type (void);

Returns : |

### gtk_sheet_new ()

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

Creates a new sheet. The resulted widget must be cast as GTK_SHEET(widget) when it's passed as argument to other functions.

Returns : | a new sheet
rows | number of rows
columns | number of columns
title | the title of the sheet

### gtk_sheet_construct ()

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

Initialize the sheet structure.

`sheet` | A GtkSheet widget
rows | number of rows
columns | number of columns
title | the title of the sheet

### gtk_sheet_new_browser ()

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

Creates a new browser sheet. Its cells can not be edited

rows | number of rows
columns | number of columns
title | the title of the sheet

### gtk_sheet_construct_browser()

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

Initialize the browser sheet structure.(a sheet with non-editable cells).

`sheet` | A GtkSheet widget
rows | number of rows
columns | number of columns
title | the title of the sheet

### gtk_sheet_new_with_custom_entry ()

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

Creates a new sheet with custom entry

rows | number of rows
columns | number of columns
title | the title of the sheet
entry_type | type of cellentry widget contained by default

### gtk_sheet_construct_with_custom_entry ()

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

Initialize a custom entry sheet structure.

rows | number of rows
columns | number of columns
title | the title of the sheet
entry_type | type of cellentry widget contained by default

### gtk_sheet_set_hadjustment ()

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

Change horizontal scroll adjustments

sheet | a GtkSheet Widget
adjustment | horizontal GtkAdjustment

### gtk_sheet_set_vadjustment ()

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

Change vertical scroll adjustments

sheet | a GtkSheet Widget
adjustment | vertical GtkAdjustment

### gtk_sheet_change_entry ()

    void gtk_sheet_change_entry	(GtkSheet *sheet, GtkType entry_type);

Changes the current entry of the cell.

sheet | a GtkSheet Widget
entry | GtkType entry of the cell

### gtk_sheet_get_entry ()

    GtkWidget *gtk_sheet_get_entry	(GtkSheet *sheet);

Returns sheet's entry widget

sheet | a GtkSheet Widget

### gtk_sheet_get_entry_widget ()

    GtkWidget *gtk_sheet_get_entry_widget (GtkSheet *sheet);

Returns sheet's entry widget

sheet | a GtkSheet Widget

### gtk_sheet_get_state ()

    gint gtk_sheet_get_state (GtkSheet *sheet);

Returns sheet->state
Added by Steven Rostedt <steven.rostedt@lmco.com>

state | /* sheet->state */ enum {GTK_SHEET_NORMAL, GTK_SHEET_ROW_SELECTED, GTK_SHEET_COLUMN_SELECTED, GTK_SHEET_RANGE_SELECTED};

### gtk_sheet_get_columns_count ()

    guint gtk_sheet_get_columns_count (GtkSheet *sheet);

Returns the number of the columns of the sheet.
Added by Murray Cumming

sheet | a GtkSheet Widget
Returns | the number of columns of the sheet

### gtk_sheet_get_rows_count ()

    guint gtk_sheet_get_rowa_count (GtkSheet *sheet);

Returns the number of the rows of the sheet.
Added by Murray Cumming

sheet | a GtkSheet Widget
Returns | the number of rows of the sheet

### gtk_sheet_get_visible_range ()

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

Returns sheet's ranges in a GkSheet Range structure

sheet | a GtkSheet Widget
range | the selected range of the sheet struct _GtkSheetRange { gint row0,col0; /* upper-left cell */ gint rowi,coli; /* lower-right cell */ };

### gtk_sheet_set_selection_mode ()

    void gtk_sheet_set_selection_mode (GtkSheet *sheet, gint mode);

Sets the selection mode of the cells in a sheet.

sheet | a GtkSheet Widget
mode | GTK_SELECTION_SINGLE or GTK_SELECTION_BROWSE

### gtk_sheet_set_title ()

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

Set sheet title.

sheet | a GtkSheet Widget
title | the title of the sheet

### gtk_sheet_freeze ()

    void gtk_sheet_freeze (GtkSheet *sheet);

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

sheet | a GtkSheet Widget

### 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 efficent way than if you made them on a unfrozen sheet .

sheet | a GtkSheet Widget

### gtk_sheet_set_background ()

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

Set the background color of all sheet.

sheet | a GtkSheet Widget
bg_color | GdkColor of background

### gtk_sheet_set_foreground ()

    void gtk_sheet_set_forekground (GtkSheet *sheet,GdkColor *fg_color);

Set the foreground color of all sheet.

sheet | a GtkSheet Widget
fg_color | GdkColor of foreground

### gtk_sheet_range_set_background ()

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

Set the background color of a range of cells.

sheet | a GtkSheet Widget
range | GtkSheetRange to be colored
color | GdkColor of background

### gtk_sheet_range_set_foreground ()

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

Set the foreground color(text color) of a range of cells.

sheet | a GtkSheet Widget
range | GtkSheetRange to be colored
color | GdkColor of foreground(text)

        GtkSheetRange range;
        GdkColor color_bg,color_fg;

        sheet=gtk_sheet_new(10,3,"table");
        range.row0=0;range.rowi=9;
        range.col0=1;range.coli=1;

        gdk_color_parse("ghost white", &color_bg);
     	 gdk_color_alloc(gtk_widget_get_colormap(sheet), &color_bg);
    	 gtk_sheet_range_set_background(GTK_SHEET(sheet), &range, &color_bg);

        gdk_color_parse("Red", &color_fg);
        gdk_color_alloc(gtk_widget_get_colormap(sheet), &color_fg);
        gtk_sheet_range_set_foreground(GTK_SHEET(sheet), &range, &color_fg);

### gtk_sheet_set_grid ()

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

Change the color of the grid.

sheet | a GtkSheet Widget
color | GdkColor of the grid

### gtk_sheet_show_grid ()

    void gtk_sheet_show_grid	(GtkSheet *sheet,gboolean show);

Show/hide the grid

sheet | a GtkSheet Widget
show | TRUE or FALSE

### gtk_sheet_grid_visible ()

    gboolean gtk_sheet_grid_visible (GtkSheet *sheet);

Is the grid visible?

sheet | a GtkSheet Widget
Returns | TRUE or FALSE

### gtk_sheet_set_column_title ()

    void gtk_sheet_set_column_title (GtkSheet * sheet,gint column,const gchar * title);

Sets the title of the column.This is in fact an internal label associated with the column.
The real title(visible) is shown with gtk_sheet_column_button_add_label().

sheet | a GtkSheet Widget
title | internal title of the column

### gtk_sheet_set_row_title ()

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

Sets the title of the row.This is in fact an internal label associated with the row.
The real title(visible) is shown with gtk_sheet_column_button_add_label().

sheet | a GtkSheet Widget
title | internal title of the row

### 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.

sheet | a GtkSheet Widget
label | button label

### gtk_sheet_column_button_add_label ()

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

Set button label
It is used to set a column title

sheet | a GtkSheet Widget
label | 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.

sheet | a GtkSheet Widget
row | row to be justified
justification | GTK_JUSTIFY_LEFT, RIGHT, CENTER

### gtk_sheet_column_button_justify ()

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

Set the justification(alignment) of the column buttons.

sheet | a GtkSheet Widget
column | column to be justified
justification | GTK_JUSTIFY_LEFT, RIGHT, CENTER

### gtk_sheet_moveto ()

    void gtk_sheet_moveto (GtkSheet * sheet,gint row,gint column,gfloat row_align,gfloat 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.0 being top or left,
1.0 being bottom or right; if row or column is negative then there is no change .

sheet | a GtkSheet Widget
row | starting row
column | startting column

### gtk_sheet_set_row_titles_width ()

    void gtk_sheet_set_row_titles_width(GtkSheet *sheet, guint width);

Resize row titles .

sheet | a GtkSheet Widget
width | width

### gtk_sheet_set_column_titles_height ()

    void gtk_sheet_set_column_titles_height(GtkSheet *sheet, guint height);

Resize column titles height

sheet | a GtkSheet Widget
height | height

### gtk_sheet_show_column_titles ()

    void gtk_sheet_show_column_titles	(GtkSheet *sheet);

Show column titles window

sheet | a GtkSheet Widget

### gtk_sheet_show_row_titles ()

    void gtk_sheet_show_row_titles (GtkSheet *sheet);

Show row titles window

sheet | a GtkSheet Widget

### gtk_sheet_hide_column_titles ()

    void gtk_sheet_hide_column_titles	(GtkSheet *sheet);

Hide column titles window

sheet | a GtkSheet Widget

### gtk_sheet_hide_row_titles ()

    void gtk_sheet_hide_row_titles(GtkSheet *sheet);

Hide row titles window

sheet | a GtkSheet Widget

### gtk_sheet_column_set_sensitivity ()

    void gtk_sheet_column_set_sensitivity	(GtkSheet *sheet, gint column, gboolean sensitive);

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

sheet | a GtkSheet Widget
column | column number
sensitive | TRUE or FALSE

### gtk_sheet_columns_set_sensitivity ()

    void gtk_sheet_columns_set_sensitivity(GtkSheet *sheet, gboolean sensitive);

Set sensitivity for all column buttons

sheet | a GtkSheet Widget
sensitive | TRUE or FALSE

### 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 .

sheet | a GtkSheet Widget
row | row number
sensitive | TRUE or FALSE

### gtk_sheet_row_set_sensitivity ()

    void gtk_sheet_rows_set_sensitivity (GtkSheet *sheet, gboolean sensitive);

Set sensitivity for all row buttons

sheet | a GtkSheet Widget
sensitive | TRUE or FALSE

### gtk_sheet_column_set_visibility ()

    void gtk_sheet_column_set_visibility	(GtkSheet *sheet, gint column, gboolean visible);

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

sheet | a GtkSheet Widget
column | column number
visible | TRUE or FALSE

### gtk_sheet_column_label_set_visibility ()

    void gtk_sheet_column_label_set_visibility(GtkSheet *sheet, gint column, gboolean visible);

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

sheet | a GtkSheet Widget
column | column number
visible | TRUE or FALSE

### gtk_sheet_columns_labels_set_visibility ()

    void gtk_sheet_columns_labels_set_visibility (GtkSheet *sheet, gboolean visible);

Set column labels visibility. The default value is TRUE. If FALSE, the column labels are hidden

sheet | a GtkSheet Widget
visible | TRUE or FALSE

### gtk_sheet_row_set_visibility ()

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

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

sheet | a GtkSheet Widget
row | row number
visible | TRUE or FALSE

### gtk_sheet_row_label_set_visibility ()

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

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

sheet | a GtkSheet Widget
row | row number
visible | TRUE or FALSE

### gtk_sheet_rows_labels_set_visibility ()

    void gtk_sheet_rows_labels_set_visibility (GtkSheet *sheet, gboolean visible);

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

sheet | a GtkSheet Widget
visible | TRUE or FALSE

### 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

sheet | a GtkSheet Widget
row | row number

### 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

sheet | a GtkSheet Widget
column | column number

### gtk_sheet_clip_range ()

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

Save selected range to "clipboard"

sheet | a GtkSheet Widget
range | GtkSheetRange to be saved

### gtk_sheet_unclip_range ()

    void gtk_sheet_unclip_range	(GtkSheet *sheet);

Free clipboard

sheet | a GtkSheet Widget

### gtk_sheet_get_vadjustment ()

    GtkAdjustment * gtk_sheet_get_vadjustment	(GtkSheet * sheet);

Get vertical scrollbars adjustment

sheet | a GtkSheet Widget

### gtk_sheet_get_hadjustment ()

    GtkAdjustment * gtk_sheet_get_hadjustment (GtkSheet * sheet);

Get horizontal scrollbars adjustment

sheet | a GtkSheet Widget

### gtk_sheet_select_range ()

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

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

sheet | a GtkSheet Widget
range | GtkSheetRange to be selected

### gtk_sheet_unselect_range ()

    void gtk_sheet_unselect_range	(GtkSheet *sheet);

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

sheet | a GtkSheet Widget

### gtk_sheet_set_active_cell ()

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

Set active cell where the entry will be displayed .
It returns FALSE if current cell can't be deactivated or requested cell can't be activated

`sheet` | A GtkSheet widget
row | cell row number
column | cell column number

### gtk_sheet_get_active_cell ()

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

Store in row and col the coordinates of the active cell.

`sheet` | A GtkSheet widget
row | cell row number
column | cell column number

### 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

`sheet` | A GtkSheet widget
row | cell row number
co | cell column number
justification | GTK_JUSTIFY_LEFT, RIGHT, CENTER
text | pointer to the text string

### 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.

`sheet` | A GtkSheet widget
row | cell row number
col | cell column number

### gtk_sheet_cell_get_text ()

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

Get cell contents

`sheet` | A GtkSheet widget
row | cell row number
col | cell column number

### gtk_sheet_cell_clear ()

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

Clear cell contents

`sheet` | A GtkSheet widget
row | cell row number
col | cell column number

### gtk_sheet_cell_delete ()

    void gtk_sheet_cell_delete	(GGtSheet *sheet, gint row, gint col);

Clear cell contents and remove links

`sheet` | A GtkSheet widget
row | cell row number
col | cell column number

### 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

`sheet` | A GtkSheet widget
range | GtkSheetRange to be cleared

### gtk_sheet_range_delete ()

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

Clear range contents and remove links

`sheet` | A GtkSheet widget
range | GtkSheetRange

### gtk_sheet_cell_get_state ()

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

Get cell state: GTK_STATE_NORMAL, GTK_STATE_SELECTED

`sheet` | A GtkSheet widget
row | cell row number
col | cell column number

### gtk_sheet_link_cell ()

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

Link pointer to a cell

`sheet` | A GtkSheet widget
row | cell row number
col | cell column number
link | pointer linked to the cell

### gtk_sheet_get_link ()

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

Get the linked pointer from a cell.

`sheet` | A GtkSheet widget
row | cell row number
col | cell column number
link | pointer linked to the cell

### gtk_sheet_remove_link ()

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

Remove the pointer linked to a cell.

`sheet` | A GtkSheet widget
row | cell row number
col | cell column number

### gtk_sheet_get_pixel_info ()

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

Get row and column correspondig to the given position in the screen

`sheet` | A GtkSheet widget
*row | cell row number
*col | cell column number
x,y | coordinates

### 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

`sheet` | A GtkSheet widget
row | cell row number
col | cell column number
area | GdkRectangle area of the cell

### gtk_sheet_set_column_width ()

    void gtk_sheet_set_column_width (GtkSheet * sheet,gint column,guint width);

Set column width

`sheet` | A GtkSheet widget
col | cell column number
width | the width of the column

### gtk_sheet_set_row_height ()

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

Set row height

`sheet` | A GtkSheet widget
row | row column number
height | the height of the row

### gtk_sheet_add_column ()

    void gtk_sheet_add_column	(GtkSheet *sheet, guint ncols);

Append ncols columns to the end of the sheet

`sheet` | A GtkSheet widget
ncols | number of columns

### gtk_sheet_add_row ()

    void gtk_sheet_add_row	(GtkSheet *sheet, guint nrows);

Append nrows rows to the end of the sheet

`sheet` | A GtkSheet widget
nrows | number of rows

### 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

`sheet` | A GtkSheet widget
rows | row number after which we insert
nrows | number of rows to be inserted

### gtk_sheet_insert_columns ()

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

Insert ncols columns before the given col and pull down

`sheet` | A GtkSheet widget
col | column number after which we insert
ncols | number of columns to be inserted

### gtk_sheet_delete_rows ()

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

Delete nrows rows starting in row

`sheet` | A GtkSheet widget
row | row number after which we delete
nrows | number of rows to be deleted

### gtk_sheet_delete_columns ()

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

Delete ncols columns starting in col

`sheet` | A GtkSheet widget
col | col number after which we delete
ncols | number of cols to be deleted

### gtk_sheet_range_set_background ()

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

Set background color of the given range

`sheet` | A GtkSheet widget
range | GtkSheetRange to be bakcground-ed
color | GdkColor of the background

### gtk_sheet_range_set_foreground ()

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

Set foreground (text) color of the given range

`sheet` | A GtkSheet widget
range | GtkSheetRange to be bakcground-ed
color | GdkColor of the background

### gtk_sheet_range_set_justification ()

    void gtk_sheet_range_set_justification	(GtkSheet *sheet, const GtkSheetRange *range, GtkJustification justification);

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

`sheet` | A GtkSheet widget
range | GtkSheetRange to be justified
justification | GTK_JUSTIFY_LEFT, RIGHT, CENTER

### gtk_sheet_column_set_justification ()

    void gtk_sheet_column_set_justification   (GtkSheet *sheet,gint column,GtkJustification justification);

Set column justification (GTK_JUSTIFY_LEFT, RIGHT, CENTER)
The default value is GTK_JUSTIFY_LEFT. If autoformat is on, the default justification for numbers is GTK_JUSTIFY_RIGHT

`sheet` | A GtkSheet widget
column | column to be justified
justification | GTK_JUSTIFY_LEFT, RIGHT, CENTER

### gtk_sheet_range_set_editable ()

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

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

`sheet` | A GtkSheet widget
range | GtkSheetRange to be set editable
editable | TRUE or FALSE

### gtk_sheet_range_set_visible ()

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

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

`sheet` | A GtkSheet widget
range | GtkSheetRange to be set visible
visible | TRUE or FALSE

### gtk_sheet_range_set_border ()

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

Set cell border style in the given range.

`sheet` | A GtkSheet widget
range | GtkSheetRange where we set border style
mask | CELL_LEFT_BORDER, CELL_RIGHT_BORDER, CELL_TOP_BORDER,CELL_BOTTOM_BORDER
width | width of the border line in pixels
line_style | GdkLineStyle line_style for the border line

### gtk_sheet_range_set_border_color ()

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

Set border color for the given range

`sheet` | A GtkSheet widget
range | GtkSheetRange where we set border color
color | GdkColor of the border

### gtk_sheet_range_set_font ()

    void gtk_sheet_range_set_font	(GtkSheet *sheet, const GtkSheetRange *range, GdkFont *font);

Set font for the given range

`sheet` | A GtkSheet widget
range | GtkSheetRange where we set font
font | GdkFont

### gtk_sheet_get_attributes ()

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

Gett cell attributes of the given cell

`sheet` | A GtkSheet widget
row | cell row number
col | cell column number
attributes | GtkSheetCellAttr of the given range
Return | TRUE means that the cell is currently allocated

### gtk_sheet_put ()

    GtkSheetChild *gtk_sheet_put 	(GtkSheet *sheet, GtkWidget *widget, 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);

`sheet` | A GtkSheet widget
widget | GtkWidget to be put
x | x coord at which we put the widget
y | y coord at which we put the widget

### gtk_sheet_move_child ()

    void gtk_sheet_move_child (GtkSheet *sheet, GtkWidget *widget, gint x, gint y);

Move widgets added with gtk_sheet_put() in the sheet

`sheet` | A GtkSheet widget
widget | GtkWidget to be put
x | x coord at which we move the widget
y | y coord at which we move the widget

### gtk_sheet_attach ()

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

Attaches a child widget to the given cell with the given alignments.
W orks 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 , if GTK_EXPAND is set.
The child is reallocated each time the column or row changes, keeping attached to the same cell.

`sheet` | A GtkSheet widget
widget | GtkWidget to be put
row | row number
col | column number
xoptions | if set GTK_EXPAND cell will expand/shrink on x direction
yoptions | if set GTK_EXPAND cell will expand/shrink on y direction
x_align | x coordinate of the alignment
y_align | y coordinate of the alignment

### 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,
W orks 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.

`sheet` | A GtkSheet widget
widget | GtkWidget to be put
row | row number
col | column number

### 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

`sheet` | A GtkSheet widget
widget | GtkWidget to be put
row | row number
col | column number

### gtk_sheet_get_child_at ()

    GtkSheetChild *gtk_sheet_get_child_at	(GtkSheet *sheet, gint row, gint col);

Returns the child attached at row,col

`sheet` | A GtkSheet widget
row | row number
col | column number

### gtk_sheet_button_attach ()

    void  gtk_sheet_button_attach (GtkSheet *sheet,
                                   GtkWidget *widget,gint row, gint col,
                                   gfloat x_align, gfloat y_align);

Button attach works like cell attach but for the buttons.

`sheet` | A GtkSheet widget
row | row number
col | column number
x_align,y_align | The x,y coord in the buton where we insert the widget

### gtk_sheet_set_autoresize ()

    void gtk_sheet_set_autoresize (GtkSheet *sheet, gboolean autoresize);

The cells will be autoresized as you type text if autoresize=TRUE.
If you want the cells to be autoresized when you pack widgets look at gtk_sheet_attach_*()

`sheet` | A GtkSheet widget
autoresize | TRUE or FALSE

### gtk_sheet_autoresize ()

    gboolean gtk_sheet_autoresize (GtkSheet *sheet);

Get the autoresize flag status.

`sheet` | A GtkSheet widget
Returns | TRUE or FALSE

### gtk_sheet_set_autoscroll ()

    void gtk_sheet_set_autoscroll (GtkSheet *sheet, gboolean autoscroll);

The table will be automatically scrolled when you reach the last line/col in current window if autoscroll=TRUE.

`sheet` | A GtkSheet widget
autoscroll | TRUE or FALSE

### gtk_sheet_autoscroll ()

    gboolean gtk_sheet_autoscroll (GtkSheet *sheet);

Get the autoresize flag status

`sheet` | A GtkSheet widget
Returns | TRUE or FALSE

### gtk_sheet_set_clip_text ()

    void gtk_sheet_set_clip_text (GtkSheet *sheet, gboolean clip_text);

Clip text in cell

`sheet` | A GtkSheet widget
clip_text | TRUE or FALSE

### gtk_sheet_clip_text ()

    gboolean gtk_sheet_clip_text (GtkSheet *sheet);

Get the clip flag status

`sheet` | A GtkSheet widget
Returns | TRUE or FALSE

### gtk_sheet_set_locked ()

    void gtk_sheet_set_locked (GtkSheet *sheet, gboolean lock);

Lock the table .

`sheet` | A GtkSheet widget
lock | TRUE or FALSE

### gtk_sheet_locked ()

    void gtk_sheet_locked (GtkSheet *sheet);

Get the lock flag status

`sheet` | A GtkSheet widget

### gtk_sheet_rows_set_resizable ()

    void gtk_sheet_rows_set_resizable (GtkSheet *sheet, gboolean resizable);

Rows are resizable if resizable=TRUE

`sheet` | A GtkSheet widget
resizable | TRUE or FALSE

### gtk_sheet_rows_resizable ()

    gboolean  gtk_sheet_rows_resizable  (GtkSheet *sheet);

Get the resizability flag status

`sheet` | A GtkSheet widget
Returns | TRUE or FALSE

### gtk_sheet_columns_set_resizable ()

    void gtk_sheet_columns_set_resizable (GtkSheet *sheet, gboolean resizable);

Columns are resizable if resizable=TRUE

`sheet` | A GtkSheet widget
resizable | TRUE or FALSE

### gtk_sheet_columns_resizable ()

    gboolean gtk_sheet_columns_resizable (GtkSheet *sheet);

Get the resizability flag status

`sheet` | A GtkSheet widget
Returns | TRUE or FALSE

### gtk_sheet_show_column_titles ()

    void gtk_sheet_show_column_titles (GtkSheet *sheet);

Show column titles

`sheet` | A GtkSheet widget

### gtk_sheet_hide_column_titles ()

    void gtk_sheet_hide_column_titles (GtkSheet *sheet);

Hide column titles

`sheet` | A GtkSheet widget

### gtk_sheet_show_row_titles ()

    void gtk_sheet_show_row_titles (GtkSheet *sheet);

Show row titles

`sheet` | A GtkSheet widget

### gtk_sheet_hide_row_titles ()

    void gtk_sheet_hide_row_titles (GtkSheet *sheet);

Hide row titles

`sheet` | A GtkSheet widget

### gtk_sheet_column_titles_visible ()

    gboolean gtk_sheet_column_titles_visible (GtkSheet *sheet);

Get the column titles visibility

`sheet` | A GtkSheet widget
Returns | TRUE or FALSE

### gtk_sheet_row_titles_visible ()

    gboolean gtk_sheet_row_titles_visible (GtkSheet *sheet);

Get the row titles visibility

`sheet` | A GtkSheet widget
Returns | TRUE or FALSE

### gtk_sheet_set_justify_entry ()

    void gtk_sheet_set_justify_entry (GtkSheet *sheet, gboolean justify);

Justify cell text

`sheet` | A GtkSheet widget
justify | TRUE or FALSE

### gtk_sheet_justify_entry ()

    gboolean gtk_sheet_justify_entry (GtkSheet *sheet);

Get the jusfication flag status

`sheet` | A GtkSheet widget
Returns | TRUE or FALSE

### GTK_SHEET_AUTORESIZE ()

    #define GTK_SHEET_AUTORESIZE(sheet)

Resize column if text width is greater than column width

`sheet` | A GtkSheet widget

### GTK_SHEET_ROW_FROZEN ()

    #define GTK_SHEET_ROW_FROZEN(sheet)

Set rows to be resizeable

`sheet` | A GtkSheet widget

### GTK_SHEET_COLUMN_FROZEN ()

    #define GTK_SHEET_COLUMN_FROZEN(sheet)

Set cols to be resizeable

`sheet` | A GtkSheet widget

### GTK_SHEET_CLIP_TEXT ()

    #define GTK_SHEET_CLIP_TEXT(sheet)

Clip text to cell

`sheet` | A GtkSheet widget

### GTK_SHEET_AUTO_SCROLL ()

    #define GTK_SHEET_AUTO_SCROLL(sheet)

The table will be automatically scrolled when you reach the last line/col in current window.

`sheet` | A GtkSheet widget

### GTK_SHEET_JUSTIFY_ENTRY ()

    #define GTK_SHEET_JUSTIFY_ENTRY(sheet)

Justify text in cells.

`sheet` | A GtkSheet widget

### GTK_SHEET_ROW_TITLES_VISIBLE ()

    #define GTK_SHEET_ROW_TITLES_VISIBLE(sheet)

Show row titles

`sheet` | A GtkSheet widget

### GTK_SHEET_COL_TITLES_VISIBLE ()

    #define GTK_SHEET_COL_TITLES_VISIBLE(sheet)

Show column titles

`sheet` | A GtkSheet widget

##

##

## Signals

## The "set_scroll_adjustments" signal

    void (*set_scroll_adjustments) (GtkSheet *sheet,GtkAdjustment *hadjustment,GtkAdjustment *vadjustment);

`sheet` | the object which received the signal.
`hadjustemnt` |
vadjustment |

## The "select_row" signal

    void (*select_row) (GtkSheet *sheet, gint row);

Should be connected if you wish to perform an action whenever a row is selected.

`sheet` | the object which received the signal.
`row` | number of selected row

## The "select_column" signal

    void (*select_column) (GtkSheet *sheet, gint column);

Should be connected if you wish to perform an action whenever a column is selected.

`sheet` | the object which received the signal.
`column` | number of selected column

## The "select_range" signal

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

Should be connected if you wish to perform an action whenever a range is selected.

`sheet` | the object which received the signal.
`range` | selected range

## The "clip_range" signal

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

Should be connected if you wish to perform an action whenever a range is clipping

`sheet` | the object which received the signal.
`range` | clipping range

## The "resize_range" signal

    void (*resize_range) (GtkSheet *sheet,GtkSheetRange *old_range,GtkSheetRange *new_range);

Should be connected if you wish to perform an action whenever a range is resized

`sheet` | the object which received the signal.
`range` | resized range

## The "move_range" signal

    void (*move_range) (GtkSheet *sheet, GtkSheetRange *old_range, GtkSheetRange *new_range);

Should be connected if you wish to perform an action whenever a range is moved

`sheet` | the object which received the signal.
`range` | moved range

## The "traverse" signal

The "traverse" is emited before "deactivate_cell" and allows to veto the movement. In such case, the entry will remain in the site
and the other signals will not be emited.

`sheet` | the object which received the signal.
`row,column` |
*new_row,*new_column |

## The "deactivate" signal

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

Should be connected if you wish to perform an action whenever a cell is deactivated(you click on other cell or start a new selection)

`sheet` | the object which received the signal.
`row,column` | the deactivated cell

## The "activate" signal

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

Should be connected if you wish to perform an action whenever a cell is activated(you click on it)

`sheet` | the object which received the signal.
`row,column` | the activated cell

## The "set_cell" signal

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

The "set_cell" is emited when clicking on a non-empty cell.

`sheet` | the object which received the signal.
`row,column` | the activated cell

## The "clear_cell" signal

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

The "clear_cell" is emited when the content of the cell is erased

`sheet` | the object which received the signal.
`row,column` | the cleared cell

## The "changed" signal

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

"changed" is emited when typing into the active cell, changing its content.
It is emitted after each key press in cell and after deactivating cell.

`sheet` | the object which received the signal.
`row,column` | the changed cell

## The "new_column_width" signal

    void (*new_column_width) (GtkSheet *sheet,gint col,guint width);

"new_column_width" is emited when the width of a column is modified

`sheet` | the object which received the signal.
`col` | modified column
width | new width

## The "new_row_height" signal

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

"new_row_height" is emited when the height of a row is modified

`sheet` | the object which received the signal.
`row` | modified row
height | new height

##

| Home |  |