## GtkSheet

GtkSheet — spreadsheet widget for gtk2

## Synopsis

    #include <gtkextra.h>

    enum                GtkSheetAttrType;
    #define             GTK_TYPE_SHEET_RANGE
    #define             GTK_SHEET_IS_LOCKED                 (sheet)
    #define             GTK_SHEET_ROW_FROZEN                (sheet)
    #define             GTK_SHEET_COLUMN_FROZEN             (sheet)
    #define             GTK_SHEET_AUTORESIZE                (sheet)
    #define             GTK_SHEET_CLIP_TEXT                 (sheet)
    #define             GTK_SHEET_ROW_TITLES_VISIBLE        (sheet)
    #define             GTK_SHEET_COL_TITLES_VISIBLE        (sheet)
    #define             GTK_SHEET_AUTO_SCROLL               (sheet)
    #define             GTK_SHEET_JUSTIFY_ENTRY             (sheet)
                        GtkSheet;
                        GtkSheetChild;
                        GtkSheetRow;
                        GtkSheetColumn;
                        GtkSheetCell;
                        GtkSheetRange;
                        GtkSheetButton;
                        GtkSheetCellAttr;
                        GtkSheetCellBorder;
    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);
    GtkWidget *         gtk_sheet_get_entry_widget          (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_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_justify_entry         (GtkSheet *sheet,
                                                             gboolean justify);
    gboolean            gtk_sheet_justify_entry             (GtkSheet *sheet);
    void                gtk_sheet_set_locked                (GtkSheet *sheet,
                                                             gboolean lock);
    gboolean            gtk_sheet_locked                    (GtkSheet *sheet);
    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_background            (GtkSheet *sheet,
                                                             GdkColor *bg_color);
    void                gtk_sheet_set_grid                  (GtkSheet *sheet,
                                                             GdkColor *grid_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);
    const gchar *       gtk_sheet_get_column_title          (GtkSheet *sheet,
                                                             gint column);
    void                gtk_sheet_set_row_title             (GtkSheet *sheet,
                                                             gint row,
                                                             const gchar *title);
    const gchar *       gtk_sheet_get_row_title             (GtkSheet *sheet,
                                                             gint row);
    void                gtk_sheet_row_button_add_label      (GtkSheet *sheet,
                                                             gint row,
                                                             const gchar *label);
    void                gtk_sheet_column_button_add_label   (GtkSheet *sheet,
                                                             gint column,
                                                             const gchar *label);
    const gchar *       gtk_sheet_row_button_get_label      (GtkSheet *sheet,
                                                             gint row);
    const gchar *       gtk_sheet_column_button_get_label   (GtkSheet *sheet,
                                                             gint column);
    void                gtk_sheet_row_button_justify        (GtkSheet *sheet,
                                                             gint row,
                                                             GtkJustification justification);
    void                gtk_sheet_column_button_justify     (GtkSheet *sheet,
                                                             gint column,
                                                             GtkJustification justification);
    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);
    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_column_set_sensitivity    (GtkSheet *sheet,
                                                             gint column,
                                                             gboolean sensitive);
    void                gtk_sheet_columns_set_sensitivity   (GtkSheet *sheet,
                                                             gboolean sensitive);
    void                gtk_sheet_columns_set_resizable     (GtkSheet *sheet,
                                                             gboolean resizable);
    gboolean            gtk_sheet_columns_resizable         (GtkSheet *sheet);
    void                gtk_sheet_row_set_sensitivity       (GtkSheet *sheet,
                                                             gint row,
                                                             gboolean sensitive);
    void                gtk_sheet_rows_set_sensitivity      (GtkSheet *sheet,
                                                             gboolean sensitive);
    void                gtk_sheet_rows_set_resizable        (GtkSheet *sheet,
                                                             gboolean resizable);
    gboolean            gtk_sheet_rows_resizable            (GtkSheet *sheet);
    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);
    gboolean            gtk_sheet_in_clip                   (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);
    void                gtk_sheet_range_set_font            (GtkSheet *sheet,
                                                             const GtkSheetRange *range,
                                                             PangoFontDescription *font);
    gboolean            gtk_sheet_get_attributes            (GtkSheet *sheet,
                                                             gint row,
                                                             gint col,
                                                             GtkSheetCellAttr *attributes);
    GtkSheetChild *     gtk_sheet_put                       (GtkSheet *sheet,
                                                             GtkWidget *widget,
                                                             gint x,
                                                             gint y);
    void                gtk_sheet_attach_floating           (GtkSheet *sheet,
                                                             GtkWidget *widget,
                                                             gint row,
                                                             gint col);
    void                gtk_sheet_attach_default            (GtkSheet *sheet,
                                                             GtkWidget *widget,
                                                             gint row,
                                                             gint col);
    void                gtk_sheet_attach                    (GtkSheet *sheet,
                                                             GtkWidget *widget,
                                                             gint row,
                                                             gint col,
                                                             gint xoptions,
                                                             gint yoptions,
                                                             gint xpadding,
                                                             gint ypadding);
    void                gtk_sheet_move_child                (GtkSheet *sheet,
                                                             GtkWidget *widget,
                                                             gint x,
                                                             gint y);
    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);

## Object Hierarchy

      GObject
       +----GInitiallyUnowned
             +----GtkObject
                   +----GtkWidget
                         +----GtkContainer
                               +----GtkSheet

## Implemented Interfaces

GtkSheet implements GtkBuildable and AtkImplementorIface.

## Signals

      "activate"                                       : Run Last
      "changed"                                        : Run Last
      "clear-cell"                                     : Run Last
      "clip-range"                                     : Run Last
      "deactivate"                                     : Run Last
      "move-range"                                     : Run Last
      "new-column-width"                               : Run Last
      "new-row-height"                                 : Run Last
      "resize-range"                                   : Run Last
      "select-column"                                  : Run Last
      "select-range"                                   : Run Last
      "select-row"                                     : Run Last
      "set-cell"                                       : Run Last
      "set-scroll-adjustments"                         : Run Last
      "traverse"                                       : Run Last

## Description

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

## Details

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

`sheet` : |

### GTK_SHEET_ROW_FROZEN()

    #define GTK_SHEET_ROW_FROZEN(sheet)      !gtk_sheet_rows_resizable(sheet)

`sheet` : |

### GTK_SHEET_COLUMN_FROZEN()

    #define GTK_SHEET_COLUMN_FROZEN(sheet)   !gtk_sheet_columns_resizable(sheet)

`sheet` : |

### GTK_SHEET_AUTORESIZE()

    #define GTK_SHEET_AUTORESIZE(sheet)      gtk_sheet_autoresize(sheet)

`sheet` : |

### GTK_SHEET_CLIP_TEXT()

    #define GTK_SHEET_CLIP_TEXT(sheet)       gtk_sheet_clip_text(sheet)

`sheet` : |

### GTK_SHEET_ROW_TITLES_VISIBLE()

    #define GTK_SHEET_ROW_TITLES_VISIBLE(sheet)   gtk_sheet_row_titles_visible(sheet)

`sheet` : |

### GTK_SHEET_COL_TITLES_VISIBLE()

    #define GTK_SHEET_COL_TITLES_VISIBLE(sheet)   gtk_sheet_column_titles_visible(sheet)

`sheet` : |

### GTK_SHEET_AUTO_SCROLL()

    #define GTK_SHEET_AUTO_SCROLL(sheet)     gtk_sheet_autoscroll(sheet)

`sheet` : |

### GTK_SHEET_JUSTIFY_ENTRY()

    #define GTK_SHEET_JUSTIFY_ENTRY(sheet)   gtk_sheet_justify_entry(sheet)

`sheet` : |

### GtkSheet

    typedef struct _GtkSheet GtkSheet;

### GtkSheetChild

    typedef struct {
      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;
    } GtkSheetChild;

### GtkSheetRow

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

     GtkSheetButton button;
     gboolean is_sensitive;
     gboolean is_visible;
    } GtkSheetRow;

### GtkSheetColumn

    typedef struct {
     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;
    } GtkSheetColumn;

### GtkSheetCell

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

      GtkSheetCellAttr *attributes;

      gchar *text;
      gpointer link;
    } GtkSheetCell;

### GtkSheetRange

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

### GtkSheetButton

    typedef struct {
      GtkStateType state;
      gchar *label;

      gboolean label_visible;
      GtkSheetChild *child;

      GtkJustification justification;
    } GtkSheetButton;

### GtkSheetCellAttr

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

### GtkSheetCellBorder

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

### 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 widget with the given number of rows and columns.

`rows` : | initial number of rows
`columns` : | initial number of columns
`title` : | sheet title
Returns : | the new sheet widget

### gtk_sheet_construct ()

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

`sheet` : |
`rows` : |
`columns` : |
`title` : |

### gtk_sheet_new_browser ()

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

`rows` : |
`columns` : |
`title` : |
Returns : |

### gtk_sheet_construct_browser ()

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

`sheet` : |
`rows` : |
`columns` : |
`title` : |

### gtk_sheet_new_with_custom_entry ()

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

`rows` : |
`columns` : |
`title` : |
`entry_type` : |
Returns : |

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

`sheet` : |
`rows` : |
`columns` : |
`title` : |
`entry_type` : |

### gtk_sheet_set_hadjustment ()

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

`sheet` : |
`adjustment` : |

### gtk_sheet_set_vadjustment ()

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

`sheet` : |
`adjustment` : |

### gtk_sheet_change_entry ()

    void                gtk_sheet_change_entry              (GtkSheet *sheet,
                                                             GtkType entry_type);

`sheet` : |
`entry_type` : |

### gtk_sheet_get_entry ()

    GtkWidget *         gtk_sheet_get_entry                 (GtkSheet *sheet);

`sheet` : |
Returns : |

### gtk_sheet_get_entry_widget ()

    GtkWidget *         gtk_sheet_get_entry_widget          (GtkSheet *sheet);

`sheet` : |
Returns : |

### gtk_sheet_get_state ()

    gint                gtk_sheet_get_state                 (GtkSheet *sheet);

`sheet` : |
Returns : |

### gtk_sheet_get_columns_count ()

    guint               gtk_sheet_get_columns_count         (GtkSheet *sheet);

`sheet` : |
Returns : |

### gtk_sheet_get_rows_count ()

    guint               gtk_sheet_get_rows_count            (GtkSheet *sheet);

`sheet` : |
Returns : |

### gtk_sheet_get_visible_range ()

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

`sheet` : |
`range` : |

### gtk_sheet_set_selection_mode ()

    void                gtk_sheet_set_selection_mode        (GtkSheet *sheet,
                                                             gint mode);

`sheet` : |
`mode` : |

### gtk_sheet_set_autoresize ()

    void                gtk_sheet_set_autoresize            (GtkSheet *sheet,
                                                             gboolean autoresize);

`sheet` : |
`autoresize` : |

### gtk_sheet_autoresize ()

    gboolean            gtk_sheet_autoresize                (GtkSheet *sheet);

`sheet` : |
Returns : |

### gtk_sheet_set_autoscroll ()

    void                gtk_sheet_set_autoscroll            (GtkSheet *sheet,
                                                             gboolean autoscroll);

`sheet` : |
`autoscroll` : |

### gtk_sheet_autoscroll ()

    gboolean            gtk_sheet_autoscroll                (GtkSheet *sheet);

`sheet` : |
Returns : |

### gtk_sheet_set_clip_text ()

    void                gtk_sheet_set_clip_text             (GtkSheet *sheet,
                                                             gboolean clip_text);

`sheet` : |
`clip_text` : |

### gtk_sheet_clip_text ()

    gboolean            gtk_sheet_clip_text                 (GtkSheet *sheet);

`sheet` : |
Returns : |

### gtk_sheet_set_justify_entry ()

    void                gtk_sheet_set_justify_entry         (GtkSheet *sheet,
                                                             gboolean justify);

`sheet` : |
`justify` : |

### gtk_sheet_justify_entry ()

    gboolean            gtk_sheet_justify_entry             (GtkSheet *sheet);

`sheet` : |
Returns : |

### gtk_sheet_set_locked ()

    void                gtk_sheet_set_locked                (GtkSheet *sheet,
                                                             gboolean lock);

`sheet` : |
`lock` : |

### gtk_sheet_locked ()

    gboolean            gtk_sheet_locked                    (GtkSheet *sheet);

`sheet` : |
Returns : |

### gtk_sheet_set_title ()

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

`sheet` : |
`title` : |

### gtk_sheet_freeze ()

    void                gtk_sheet_freeze                    (GtkSheet *sheet);

`sheet` : |

### gtk_sheet_thaw ()

    void                gtk_sheet_thaw                      (GtkSheet *sheet);

`sheet` : |

### gtk_sheet_set_background ()

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

`sheet` : |
`bg_color` : |

### gtk_sheet_set_grid ()

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

`sheet` : |
`grid_color` : |

### gtk_sheet_show_grid ()

    void                gtk_sheet_show_grid                 (GtkSheet *sheet,
                                                             gboolean show);

`sheet` : |
`show` : |

### gtk_sheet_grid_visible ()

    gboolean            gtk_sheet_grid_visible              (GtkSheet *sheet);

`sheet` : |
Returns : |

### gtk_sheet_set_column_title ()

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

`sheet` : |
`column` : |
`title` : |

### gtk_sheet_get_column_title ()

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

`sheet` : |
`column` : |
Returns : |

### gtk_sheet_set_row_title ()

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

`sheet` : |
`row` : |
`title` : |

### gtk_sheet_get_row_title ()

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

`sheet` : |
`row` : |
Returns : |

### gtk_sheet_row_button_add_label ()

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

`sheet` : |
`row` : |
`label` : |

### gtk_sheet_column_button_add_label ()

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

`sheet` : |
`column` : |
`label` : |

### gtk_sheet_row_button_get_label ()

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

`sheet` : |
`row` : |
Returns : |

### gtk_sheet_column_button_get_label ()

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

`sheet` : |
`column` : |
Returns : |

### gtk_sheet_row_button_justify ()

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

`sheet` : |
`row` : |
`justification` : |

### gtk_sheet_column_button_justify ()

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

`sheet` : |
`column` : |
`justification` : |

### gtk_sheet_moveto ()

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

`sheet` : |
`row` : |
`column` : |
`row_align` : |
`col_align` : |

### gtk_sheet_set_row_titles_width ()

    void                gtk_sheet_set_row_titles_width      (GtkSheet *sheet,
                                                             guint width);

`sheet` : |
`width` : |

### gtk_sheet_set_column_titles_height ()

    void                gtk_sheet_set_column_titles_height  (GtkSheet *sheet,
                                                             guint height);

`sheet` : |
`height` : |

### gtk_sheet_show_column_titles ()

    void                gtk_sheet_show_column_titles        (GtkSheet *sheet);

`sheet` : |

### gtk_sheet_show_row_titles ()

    void                gtk_sheet_show_row_titles           (GtkSheet *sheet);

`sheet` : |

### gtk_sheet_hide_column_titles ()

    void                gtk_sheet_hide_column_titles        (GtkSheet *sheet);

`sheet` : |

### gtk_sheet_hide_row_titles ()

    void                gtk_sheet_hide_row_titles           (GtkSheet *sheet);

`sheet` : |

### gtk_sheet_column_titles_visible ()

    gboolean            gtk_sheet_column_titles_visible     (GtkSheet *sheet);

`sheet` : |
Returns : |

### gtk_sheet_row_titles_visible ()

    gboolean            gtk_sheet_row_titles_visible        (GtkSheet *sheet);

`sheet` : |
Returns : |

### gtk_sheet_column_set_sensitivity ()

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

`sheet` : |
`column` : |
`sensitive` : |

### gtk_sheet_columns_set_sensitivity ()

    void                gtk_sheet_columns_set_sensitivity   (GtkSheet *sheet,
                                                             gboolean sensitive);

`sheet` : |
`sensitive` : |

### gtk_sheet_columns_set_resizable ()

    void                gtk_sheet_columns_set_resizable     (GtkSheet *sheet,
                                                             gboolean resizable);

`sheet` : |
`resizable` : |

### gtk_sheet_columns_resizable ()

    gboolean            gtk_sheet_columns_resizable         (GtkSheet *sheet);

`sheet` : |
Returns : |

### gtk_sheet_row_set_sensitivity ()

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

`sheet` : |
`row` : |
`sensitive` : |

### gtk_sheet_rows_set_sensitivity ()

    void                gtk_sheet_rows_set_sensitivity      (GtkSheet *sheet,
                                                             gboolean sensitive);

`sheet` : |
`sensitive` : |

### gtk_sheet_rows_set_resizable ()

    void                gtk_sheet_rows_set_resizable        (GtkSheet *sheet,
                                                             gboolean resizable);

`sheet` : |
`resizable` : |

### gtk_sheet_rows_resizable ()

    gboolean            gtk_sheet_rows_resizable            (GtkSheet *sheet);

`sheet` : |
Returns : |

### gtk_sheet_column_set_visibility ()

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

`sheet` : |
`column` : |
`visible` : |

### gtk_sheet_column_label_set_visibility ()

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

`sheet` : |
`column` : |
`visible` : |

### gtk_sheet_columns_labels_set_visibility ()

    void                gtk_sheet_columns_labels_set_visibility
                                                            (GtkSheet *sheet,
                                                             gboolean visible);

`sheet` : |
`visible` : |

### gtk_sheet_row_set_visibility ()

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

`sheet` : |
`row` : |
`visible` : |

### gtk_sheet_row_label_set_visibility ()

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

`sheet` : |
`row` : |
`visible` : |

### gtk_sheet_rows_labels_set_visibility ()

    void                gtk_sheet_rows_labels_set_visibility
                                                            (GtkSheet *sheet,
                                                             gboolean visible);

`sheet` : |
`visible` : |

### gtk_sheet_select_row ()

    void                gtk_sheet_select_row                (GtkSheet *sheet,
                                                             gint row);

`sheet` : |
`row` : |

### gtk_sheet_select_column ()

    void                gtk_sheet_select_column             (GtkSheet *sheet,
                                                             gint column);

`sheet` : |
`column` : |

### gtk_sheet_clip_range ()

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

`sheet` : |
`range` : |

### gtk_sheet_unclip_range ()

    void                gtk_sheet_unclip_range              (GtkSheet *sheet);

`sheet` : |

### gtk_sheet_in_clip ()

    gboolean            gtk_sheet_in_clip                   (GtkSheet *sheet);

`sheet` : |
Returns : |

### gtk_sheet_get_vadjustment ()

    GtkAdjustment *     gtk_sheet_get_vadjustment           (GtkSheet *sheet);

`sheet` : |
Returns : |

### gtk_sheet_get_hadjustment ()

    GtkAdjustment *     gtk_sheet_get_hadjustment           (GtkSheet *sheet);

`sheet` : |
Returns : |

### gtk_sheet_select_range ()

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

`sheet` : |
`range` : |

### gtk_sheet_unselect_range ()

    void                gtk_sheet_unselect_range            (GtkSheet *sheet);

`sheet` : |

### gtk_sheet_set_active_cell ()

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

`sheet` : |
`row` : |
`column` : |
Returns : |

### gtk_sheet_get_active_cell ()

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

`sheet` : |
`row` : |
`column` : |

### gtk_sheet_set_cell ()

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

`sheet` : |
`row` : |
`col` : |
`justification` : |
`text` : |

### gtk_sheet_set_cell_text ()

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

`sheet` : |
`row` : |
`col` : |
`text` : |

### gtk_sheet_cell_get_text ()

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

`sheet` : |
`row` : |
`col` : |
Returns : |

### gtk_sheet_cell_clear ()

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

`sheet` : |
`row` : |
`col` : |

### gtk_sheet_cell_delete ()

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

`sheet` : |
`row` : |
`col` : |

### gtk_sheet_range_clear ()

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

`sheet` : |
`range` : |

### gtk_sheet_range_delete ()

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

`sheet` : |
`range` : |

### gtk_sheet_cell_get_state ()

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

`sheet` : |
`row` : |
`col` : |
Returns : |

### gtk_sheet_link_cell ()

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

`sheet` : |
`row` : |
`col` : |
`link` : |

### gtk_sheet_get_link ()

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

`sheet` : |
`row` : |
`col` : |
Returns : |

### gtk_sheet_remove_link ()

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

`sheet` : |
`row` : |
`col` : |

### gtk_sheet_get_pixel_info ()

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

`sheet` : |
`x` : |
`y` : |
`row` : |
`column` : |
Returns : |

### gtk_sheet_get_cell_area ()

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

`sheet` : |
`row` : |
`column` : |
`area` : |
Returns : |

### gtk_sheet_set_column_width ()

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

`sheet` : |
`column` : |
`width` : |

### gtk_sheet_set_row_height ()

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

`sheet` : |
`row` : |
`height` : |

### gtk_sheet_add_column ()

    void                gtk_sheet_add_column                (GtkSheet *sheet,
                                                             guint ncols);

`sheet` : |
`ncols` : |

### gtk_sheet_add_row ()

    void                gtk_sheet_add_row                   (GtkSheet *sheet,
                                                             guint nrows);

`sheet` : |
`nrows` : |

### gtk_sheet_insert_rows ()

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

`sheet` : |
`row` : |
`nrows` : |

### gtk_sheet_insert_columns ()

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

`sheet` : |
`col` : |
`ncols` : |

### gtk_sheet_delete_rows ()

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

`sheet` : |
`row` : |
`nrows` : |

### gtk_sheet_delete_columns ()

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

`sheet` : |
`col` : |
`ncols` : |

### gtk_sheet_range_set_background ()

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

`sheet` : |
`range` : |
`color` : |

### gtk_sheet_range_set_foreground ()

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

`sheet` : |
`range` : |
`color` : |

### gtk_sheet_range_set_justification ()

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

`sheet` : |
`range` : |
`justification` : |

### gtk_sheet_column_set_justification ()

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

`sheet` : |
`column` : |
`justification` : |

### gtk_sheet_range_set_editable ()

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

`sheet` : |
`range` : |
`editable` : |

### gtk_sheet_range_set_visible ()

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

`sheet` : |
`range` : |
`visible` : |

### gtk_sheet_range_set_border ()

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

`sheet` : |
`range` : |
`mask` : |
`width` : |
`line_style` : |

### gtk_sheet_range_set_border_color ()

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

`sheet` : |
`range` : |
`color` : |

### gtk_sheet_range_set_font ()

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

`sheet` : |
`range` : |
`font` : |

### gtk_sheet_get_attributes ()

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

`sheet` : |
`row` : |
`col` : |
`attributes` : |
Returns : |

### gtk_sheet_put ()

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

`sheet` : |
`widget` : |
`x` : |
`y` : |
Returns : |

### gtk_sheet_attach_floating ()

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

`sheet` : |
`widget` : |
`row` : |
`col` : |

### gtk_sheet_attach_default ()

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

`sheet` : |
`widget` : |
`row` : |
`col` : |

### gtk_sheet_attach ()

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

`sheet` : |
`widget` : |
`row` : |
`col` : |
`xoptions` : |
`yoptions` : |
`xpadding` : |
`ypadding` : |

### gtk_sheet_move_child ()

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

`sheet` : |
`widget` : |
`x` : |
`y` : |

### gtk_sheet_get_child_at ()

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

`sheet` : |
`row` : |
`col` : |
Returns : |

### gtk_sheet_button_attach ()

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

`sheet` : |
`widget` : |
`row` : |
`col` : |

## Signal Details

### The `"activate"` signal

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

`sheet` : | the object which received the signal.
`arg1` : |
`arg2` : |
`user_data` : | user data set when the signal handler was connected.
Returns : |

### The `"changed"` signal

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

`sheet` : | the object which received the signal.
`arg1` : |
`arg2` : |
`user_data` : | user data set when the signal handler was connected.

### The `"clear-cell"` signal

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

`sheet` : | the object which received the signal.
`arg1` : |
`arg2` : |
`user_data` : | user data set when the signal handler was connected.

### The `"clip-range"` signal

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

`sheet` : | the object which received the signal.
`arg1` : |
`user_data` : | user data set when the signal handler was connected.

### The `"deactivate"` signal

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

`sheet` : | the object which received the signal.
`arg1` : |
`arg2` : |
`user_data` : | user data set when the signal handler was connected.
Returns : |

### The `"move-range"` signal

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

`sheet` : | the object which received the signal.
`arg1` : |
`arg2` : |
`user_data` : | user data set when the signal handler was connected.

### The `"new-column-width"` signal

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

`sheet` : | the object which received the signal.
`arg1` : |
`arg2` : |
`user_data` : | user data set when the signal handler was connected.

### The `"new-row-height"` signal

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

`sheet` : | the object which received the signal.
`arg1` : |
`arg2` : |
`user_data` : | user data set when the signal handler was connected.

### The `"resize-range"` signal

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

`sheet` : | the object which received the signal.
`arg1` : |
`arg2` : |
`user_data` : | user data set when the signal handler was connected.

### The `"select-column"` signal

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

A column has been selected.

`sheet` : | the sheet widget that emitted the signal
`column` : | the newly selected column index
`user_data` : | user data set when the signal handler was connected.

### The `"select-range"` signal

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

`sheet` : | the object which received the signal.
`arg1` : |
`user_data` : | user data set when the signal handler was connected.

### The `"select-row"` signal

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

A row has been selected.

`sheet` : | the sheet widget that emitted the signal
`row` : | the newly selected row index
`user_data` : | user data set when the signal handler was connected.

### The `"set-cell"` signal

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

`sheet` : | the object which received the signal.
`arg1` : |
`arg2` : |
`user_data` : | user data set when the signal handler was connected.

### The `"set-scroll-adjustments"` signal

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

`sheet` : | the object which received the signal.
`arg1` : |
`arg2` : |
`user_data` : | user data set when the signal handler was connected.

### The `"traverse"` signal

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

`sheet` : | the object which received the signal.
`arg1` : |
`arg2` : |
`arg3` : |
`arg4` : |
`user_data` : | user data set when the signal handler was connected.
Returns : |