enum GtkSheetAttrType

typedef enum {
  GTK_SHEET_FOREGROUND,
  GTK_SHEET_BACKGROUND,
  GTK_SHEET_FONT,
  GTK_SHEET_JUSTIFICATION,
  GTK_SHEET_BORDER,
  GTK_SHEET_BORDER_COLOR,
  GTK_SHEET_IS_EDITABLE,
  GTK_SHEET_IS_VISIBLE
} GtkSheetAttrType;

GTK_TYPE_SHEET_RANGE

#define GTK_TYPE_SHEET_RANGE (gtk_sheet_range_get_type ())

GTK_SHEET_IS_LOCKED()

#define GTK_SHEET_IS_LOCKED(sheet)       gtk_sheet_locked(sheet)

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)

struct GtkSheet

struct GtkSheet;

struct GtkSheetChild

struct GtkSheetChild {
  GtkWidget *widget;
  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 GtkSheetRow

struct GtkSheetRow {
 gchar *name;
 gint height;
 gint top_ypixel;
 guint16 requisition;

 GtkSheetButton button;
 gboolean is_sensitive;
 gboolean is_visible;
};

struct GtkSheetColumn

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 GtkSheetCell

struct GtkSheetCell {
  GdkRectangle area;
  gint row;
  gint col;

  GtkSheetCellAttr *attributes;

  gchar *text;
  gpointer link;
};

struct GtkSheetRange

struct GtkSheetRange {
  gint row0,col0; /* upper-left cell */
  gint rowi,coli; /* lower-right cell */
};

struct GtkSheetButton

struct GtkSheetButton {
  GtkStateType state;
  gchar *label;

  gboolean label_visible;
  GtkSheetChild *child;

  GtkJustification justification;
};

struct GtkSheetCellAttr

struct GtkSheetCellAttr {
  GtkJustification justification;
  GdkFont *font;
  PangoFontDescription *font_desc;
  GdkColor foreground;
  GdkColor background;
  GtkSheetCellBorder border;
  gboolean is_editable;
  gboolean is_visible;
};

struct GtkSheetCellBorder

struct GtkSheetCellBorder {
  gint8 mask;
  guint width;
  GdkLineStyle line_style;
  GdkCapStyle cap_style;
  GdkJoinStyle join_style;
  GdkColor color;
};

gtk_sheet_range_get_type ()

GtkType             gtk_sheet_range_get_type            (void);

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

gtk_sheet_new_browser ()

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

gtk_sheet_construct_browser ()

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

gtk_sheet_new_with_custom_entry ()

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

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

gtk_sheet_set_hadjustment ()

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

gtk_sheet_set_vadjustment ()

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

gtk_sheet_change_entry ()

void                gtk_sheet_change_entry              (GtkSheet *sheet,
                                                         GtkType entry_type);

gtk_sheet_get_entry ()

GtkWidget *         gtk_sheet_get_entry                 (GtkSheet *sheet);

gtk_sheet_get_entry_widget ()

GtkWidget *         gtk_sheet_get_entry_widget          (GtkSheet *sheet);

gtk_sheet_get_state ()

gint                gtk_sheet_get_state                 (GtkSheet *sheet);

gtk_sheet_get_columns_count ()

guint               gtk_sheet_get_columns_count         (GtkSheet *sheet);

gtk_sheet_get_rows_count ()

guint               gtk_sheet_get_rows_count            (GtkSheet *sheet);

gtk_sheet_get_visible_range ()

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

gtk_sheet_set_selection_mode ()

void                gtk_sheet_set_selection_mode        (GtkSheet *sheet,
                                                         gint mode);

gtk_sheet_set_autoresize ()

void                gtk_sheet_set_autoresize            (GtkSheet *sheet,
                                                         gboolean autoresize);

gtk_sheet_autoresize ()

gboolean            gtk_sheet_autoresize                (GtkSheet *sheet);

gtk_sheet_set_autoscroll ()

void                gtk_sheet_set_autoscroll            (GtkSheet *sheet,
                                                         gboolean autoscroll);

gtk_sheet_autoscroll ()

gboolean            gtk_sheet_autoscroll                (GtkSheet *sheet);

gtk_sheet_set_clip_text ()

void                gtk_sheet_set_clip_text             (GtkSheet *sheet,
                                                         gboolean clip_text);

gtk_sheet_clip_text ()

gboolean            gtk_sheet_clip_text                 (GtkSheet *sheet);

gtk_sheet_set_justify_entry ()

void                gtk_sheet_set_justify_entry         (GtkSheet *sheet,
                                                         gboolean justify);

gtk_sheet_justify_entry ()

gboolean            gtk_sheet_justify_entry             (GtkSheet *sheet);

gtk_sheet_set_locked ()

void                gtk_sheet_set_locked                (GtkSheet *sheet,
                                                         gboolean lock);

gtk_sheet_locked ()

gboolean            gtk_sheet_locked                    (GtkSheet *sheet);

gtk_sheet_set_title ()

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

gtk_sheet_freeze ()

void                gtk_sheet_freeze                    (GtkSheet *sheet);

gtk_sheet_thaw ()

void                gtk_sheet_thaw                      (GtkSheet *sheet);

gtk_sheet_set_background ()

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

gtk_sheet_set_grid ()

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

gtk_sheet_show_grid ()

void                gtk_sheet_show_grid                 (GtkSheet *sheet,
                                                         gboolean show);

gtk_sheet_grid_visible ()

gboolean            gtk_sheet_grid_visible              (GtkSheet *sheet);

gtk_sheet_set_column_title ()

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

gtk_sheet_get_column_title ()

const gchar *       gtk_sheet_get_column_title          (GtkSheet *sheet,
                                                         gint column);

gtk_sheet_set_row_title ()

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

gtk_sheet_get_row_title ()

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

gtk_sheet_row_button_add_label ()

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

gtk_sheet_column_button_add_label ()

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

gtk_sheet_row_button_get_label ()

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

gtk_sheet_column_button_get_label ()

const gchar *       gtk_sheet_column_button_get_label   (GtkSheet *sheet,
                                                         gint column);

gtk_sheet_row_button_justify ()

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

gtk_sheet_column_button_justify ()

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

gtk_sheet_moveto ()

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

gtk_sheet_set_row_titles_width ()

void                gtk_sheet_set_row_titles_width      (GtkSheet *sheet,
                                                         guint width);

gtk_sheet_set_column_titles_height ()

void                gtk_sheet_set_column_titles_height  (GtkSheet *sheet,
                                                         guint height);

gtk_sheet_show_column_titles ()

void                gtk_sheet_show_column_titles        (GtkSheet *sheet);

gtk_sheet_show_row_titles ()

void                gtk_sheet_show_row_titles           (GtkSheet *sheet);

gtk_sheet_hide_column_titles ()

void                gtk_sheet_hide_column_titles        (GtkSheet *sheet);

gtk_sheet_hide_row_titles ()

void                gtk_sheet_hide_row_titles           (GtkSheet *sheet);

gtk_sheet_column_titles_visible ()

gboolean            gtk_sheet_column_titles_visible     (GtkSheet *sheet);

gtk_sheet_row_titles_visible ()

gboolean            gtk_sheet_row_titles_visible        (GtkSheet *sheet);

gtk_sheet_column_set_sensitivity ()

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

gtk_sheet_columns_set_sensitivity ()

void                gtk_sheet_columns_set_sensitivity   (GtkSheet *sheet,
                                                         gboolean sensitive);

gtk_sheet_columns_set_resizable ()

void                gtk_sheet_columns_set_resizable     (GtkSheet *sheet,
                                                         gboolean resizable);

gtk_sheet_columns_resizable ()

gboolean            gtk_sheet_columns_resizable         (GtkSheet *sheet);

gtk_sheet_row_set_sensitivity ()

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

gtk_sheet_rows_set_sensitivity ()

void                gtk_sheet_rows_set_sensitivity      (GtkSheet *sheet,
                                                         gboolean sensitive);

gtk_sheet_rows_set_resizable ()

void                gtk_sheet_rows_set_resizable        (GtkSheet *sheet,
                                                         gboolean resizable);

gtk_sheet_rows_resizable ()

gboolean            gtk_sheet_rows_resizable            (GtkSheet *sheet);

gtk_sheet_column_set_visibility ()

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

gtk_sheet_column_label_set_visibility ()

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

gtk_sheet_columns_labels_set_visibility ()

void                gtk_sheet_columns_labels_set_visibility
                                                        (GtkSheet *sheet,
                                                         gboolean visible);

gtk_sheet_row_set_visibility ()

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

gtk_sheet_row_label_set_visibility ()

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

gtk_sheet_rows_labels_set_visibility ()

void                gtk_sheet_rows_labels_set_visibility
                                                        (GtkSheet *sheet,
                                                         gboolean visible);

gtk_sheet_select_row ()

void                gtk_sheet_select_row                (GtkSheet *sheet,
                                                         gint row);

gtk_sheet_select_column ()

void                gtk_sheet_select_column             (GtkSheet *sheet,
                                                         gint column);

gtk_sheet_clip_range ()

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

gtk_sheet_unclip_range ()

void                gtk_sheet_unclip_range              (GtkSheet *sheet);

gtk_sheet_in_clip ()

gboolean            gtk_sheet_in_clip                   (GtkSheet *sheet);

gtk_sheet_get_vadjustment ()

GtkAdjustment *     gtk_sheet_get_vadjustment           (GtkSheet *sheet);

gtk_sheet_get_hadjustment ()

GtkAdjustment *     gtk_sheet_get_hadjustment           (GtkSheet *sheet);

gtk_sheet_select_range ()

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

gtk_sheet_unselect_range ()

void                gtk_sheet_unselect_range            (GtkSheet *sheet);

gtk_sheet_set_active_cell ()

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

gtk_sheet_get_active_cell ()

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

gtk_sheet_set_cell ()

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

gtk_sheet_set_cell_text ()

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

gtk_sheet_cell_get_text ()

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

gtk_sheet_cell_clear ()

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

gtk_sheet_cell_delete ()

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

gtk_sheet_range_clear ()

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

gtk_sheet_range_delete ()

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

gtk_sheet_cell_get_state ()

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

gtk_sheet_link_cell ()

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

gtk_sheet_get_link ()

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

gtk_sheet_remove_link ()

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

gtk_sheet_get_pixel_info ()

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

gtk_sheet_get_cell_area ()

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

gtk_sheet_set_column_width ()

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

gtk_sheet_set_row_height ()

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

gtk_sheet_add_column ()

void                gtk_sheet_add_column                (GtkSheet *sheet,
                                                         guint ncols);

gtk_sheet_add_row ()

void                gtk_sheet_add_row                   (GtkSheet *sheet,
                                                         guint nrows);

gtk_sheet_insert_rows ()

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

gtk_sheet_insert_columns ()

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

gtk_sheet_delete_rows ()

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

gtk_sheet_delete_columns ()

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

gtk_sheet_range_set_background ()

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

gtk_sheet_range_set_foreground ()

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

gtk_sheet_range_set_justification ()

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

gtk_sheet_column_set_justification ()

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

gtk_sheet_range_set_editable ()

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

gtk_sheet_range_set_visible ()

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

gtk_sheet_range_set_border ()

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

gtk_sheet_range_set_border_color ()

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

gtk_sheet_range_set_font ()

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

gtk_sheet_get_attributes ()

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

gtk_sheet_put ()

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

gtk_sheet_attach_floating ()

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

gtk_sheet_attach_default ()

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

gtk_sheet_attach ()

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

gtk_sheet_move_child ()

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

gtk_sheet_get_child_at ()

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

gtk_sheet_button_attach ()

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

The "activate" signal

gboolean            user_function                      (GtkSheet *sheet,
                                                        gint      arg1,
                                                        gint      arg2,
                                                        gpointer  user_data)      : Run Last

The "changed" signal

void                user_function                      (GtkSheet *sheet,
                                                        gint      arg1,
                                                        gint      arg2,
                                                        gpointer  user_data)      : Run Last

The "clear-cell" signal

void                user_function                      (GtkSheet *sheet,
                                                        gint      arg1,
                                                        gint      arg2,
                                                        gpointer  user_data)      : Run Last

The "clip-range" signal

void                user_function                      (GtkSheet      *sheet,
                                                        GtkSheetRange *arg1,
                                                        gpointer       user_data)      : Run Last

The "deactivate" signal

gboolean            user_function                      (GtkSheet *sheet,
                                                        gint      arg1,
                                                        gint      arg2,
                                                        gpointer  user_data)      : Run Last

The "move-range" signal

void                user_function                      (GtkSheet      *sheet,
                                                        GtkSheetRange *arg1,
                                                        GtkSheetRange *arg2,
                                                        gpointer       user_data)      : Run Last

The "new-column-width" signal

void                user_function                      (GtkSheet *sheet,
                                                        gint      arg1,
                                                        gint      arg2,
                                                        gpointer  user_data)      : Run Last

The "new-row-height" signal

void                user_function                      (GtkSheet *sheet,
                                                        gint      arg1,
                                                        gint      arg2,
                                                        gpointer  user_data)      : Run Last

The "resize-range" signal

void                user_function                      (GtkSheet      *sheet,
                                                        GtkSheetRange *arg1,
                                                        GtkSheetRange *arg2,
                                                        gpointer       user_data)      : Run Last

The "select-column" signal

void                user_function                      (GtkSheet *sheet,
                                                        gint      column,
                                                        gpointer  user_data)      : Run Last

A column has been selected.

The "select-range" signal

void                user_function                      (GtkSheet      *sheet,
                                                        GtkSheetRange *arg1,
                                                        gpointer       user_data)      : Run Last

The "select-row" signal

void                user_function                      (GtkSheet *sheet,
                                                        gint      row,
                                                        gpointer  user_data)      : Run Last

A row has been selected.

The "set-cell" signal

void                user_function                      (GtkSheet *sheet,
                                                        gint      arg1,
                                                        gint      arg2,
                                                        gpointer  user_data)      : Run Last

The "set-scroll-adjustments" signal

void                user_function                      (GtkSheet      *sheet,
                                                        GtkAdjustment *arg1,
                                                        GtkAdjustment *arg2,
                                                        gpointer       user_data)      : Run Last

The "traverse" signal

gboolean            user_function                      (GtkSheet *sheet,
                                                        gint      arg1,
                                                        gint      arg2,
                                                        gpointer  arg3,
                                                        gpointer  arg4,
                                                        gpointer  user_data)      : Run Last