gtk.Table

gtk.Table
Prev	The gtk Class Reference	Next

gtk.Table — layout widgets in a two-dimensional array

Synopsis

class gtk.Table(gtk.Container):
    gtk.Table(rows=1, columns=1, homogeneous=FALSE)
    def resize(rows, columns)
    def attach(child, left_attach, right_attach, top_attach, bottom_attach, xoptions=gtk.EXPAND|gtk.FILL, yoptions=gtk.EXPAND|gtk.FILL, xpadding=0, ypadding=0)
    def set_row_spacing(row, spacing)
    def get_row_spacing(row)
    def set_col_spacing(column, spacing)
    def get_col_spacing(column)
    def set_row_spacings(spacing)
    def get_default_row_spacing()
    def set_col_spacings(spacing)
    def get_default_col_spacing()
    def set_homogeneous(homogeneous)
    def get_homogeneous()

Ancestry

+-- gobject.GObject
  +-- gtk.Object
    +-- gtk.Widget
      +-- gtk.Container
        +-- gtk.Table

gtk.Table Properties

gtk.Object Properties

gtk.Widget Properties

gtk.Container Properties

"column-spacing"	Read-Write	The amount of space between two adjacent columns
"homogeneous"	Read-Write	If `TRUE`, the table cells are all the same width or height
"n-columns"	Read-Write	The number of columns in the table
"n-rows"	Read-Write	The number of rows in the table
"row-spacing"	Read-Write	The amount of space between two adjacent rows

gtk.Table Style Properties

gtk.Widget Style Properties

gtk.Table Child Properties

"bottom-attach"	Read-Write	The lowest row of the child
"left-attach"	Read-Write	The leftmost column of the child
"right-attach"	Read-Write	The rightmost column of the child
"top-attach"	Read-Write	The uppermost row of the child
"x-options"	Read-Write	the horizontal behavior of the child - a combination of: `gtk.EXPAND`, `gtk.SHRINK` and `gtk.FILL`
"x-padding"	Read-Write	Extra space added between the child widget and its left and right neighbors, in pixels
"y-options"	Read-Write	the vertical behavior of the child - a combination of: `gtk.EXPAND`, `gtk.SHRINK` and `gtk.FILL`
"y-padding"	Read-Write	Extra space added between the child widget and its top and bottom neighbors, in pixels

gtk.Table Signal Prototypes

gobject.GObject Signal Prototypes

gtk.Object Signal Prototypes

gtk.Widget Signal Prototypes

gtk.Container Signal Prototypes

Description

The gtk.Table manages a group of widgets that are arranged in rows and columns, making it easy to align many widgets next to each other, horizontally and vertically. Tables are created with a call to gtk.Table(). The size of a table can be changed using the resize() method.

Widgets can be added to a table using the attach() method. To alter the space of the row next to a specific row, use the set_row_spacing() method, and for a column, the set_col_spacing() method. The gaps between all rows or columns can be changed by calling the set_row_spacings() or set_col_spacings() methods respectively. The set_homogeneous() method changes the setting that determines whether all cells in the table will resize themselves to the size of the largest widget in the table.

Constructor

    gtk.Table(rows=1, columns=1, homogeneous=FALSE)

`rows` :	the number of rows
`columns` :	the number of columns
`homogeneous` :	if `TRUE` all table cells will be the same size as the largest cell
Returns :	a new `gtk.Table` widget

Creates a new gtk.Table widget with the number of rows and columns specified by the value of rows and columns respectively. The value of rows and columns must be in the range 0 .. 65535. If homogeneous is TRUE the table cells will all be the same size as the largest cell. If rows or columns are not specified they default to 1.

Methods

gtk.Table.resize

    def resize(rows, columns)

`rows` :	The new number of rows.
`columns` :	The new number of columns.

The resize() method changes the size of the table as specified by the parameters, rows and columns.

gtk.Table.attach

    def attach(child, left_attach, right_attach, top_attach, bottom_attach, xoptions=gtk.EXPAND|gtk.FILL, yoptions=gtk.EXPAND|gtk.FILL, xpadding=0, ypadding=0)

`child` :	the widget to add.
`left_attach` :	the column number to attach the left side of a child widget to.
`right_attach` :	the column number to attach the right side of a child widget to.
`top_attach` :	the row number to attach the top side of a child widget to.
`bottom_attach` :	the row number to attach the bottom side of a child widget to.
`xoptions` :	used to specify the properties of the child widget when the table is resized horizontally.
`yoptions` :	used to specify the properties of the child widget when the table is resized vertically.
`xpadding` :	the amount of padding to add on the left and right of the widget
`ypadding` :	the amount of padding to add above and below the widget

The attach() method adds the widget specified by child to the table. The number of 'cells' that a widget will occupy is specified by:

left_attach - the column to the left of the widget
right_attach - the column to the right of the widget
top_attach - the row above the widget and
bottom_attach - the row below the widget

The xoptions and yoptions determine the expansion properties of the widget in the horizontal and vertical directions respectively (the default value is gtk.FILL|gtk.EXPAND). The value of the options is a combination of:

`gtk.EXPAND`	the table cell should expand to take up any extra space that has been allocated to the table.
`gtk.SHRINK`	the widget should shrink when the table cell shrinks.
`gtk.FILL`	the widget should fill the space allocated to it in the table cell.

The xpadding and ypadding parameters determine the extra padding added around the widget. By default these are 0.

gtk.Table.set_row_spacing

    def set_row_spacing(row, spacing)

`row` :	the row number whose spacing will be changed.
`spacing` :	the number of pixels of added spacing

The set_row_spacing() method sets the spacing in pixels (specified by spacing) between the specified row and the following row.

gtk.Table.get_row_spacing

    def get_row_spacing(row)

`row` :	a row in the table, 0 indicates the first row
Returns :	the row spacing

The get_row_spacing() method returns the amount of space between the specified row, and the following row. See the set_row_spacing() method.

gtk.Table.set_col_spacing

    def set_col_spacing(column, spacing)

`column` :	the column number whose spacing will be changed.
`spacing` :	the number of pixels of added spacing

The set_col_spacing() method sets the spacing in pixels (specified by spacing) between the specified column and the following column.

gtk.Table.get_col_spacing

    def get_col_spacing(column)

`column` :	a column in the table, 0 indicates the first column
Returns :	the column spacing

The get_col_spacing() returns the amount of space between the specified column, and the following column. See the set_col_spacing() method.

gtk.Table.set_row_spacings

    def set_row_spacings(spacing)

spacing : the number of pixels of space to place between every row in the table.

The set_row_spacings() method sets the "row-spacing" property, that determines the space between every row in table, to the value of spacing.

gtk.Table.get_default_row_spacing

    def get_default_row_spacing()

Returns :

the default row spacing

The get_default_row_spacing() method returns the value of the "row-spacing" property that specifies the default row spacing for the table i.e. the spacing that will be used for newly added rows. (See the set_row_spacings())

gtk.Table.set_col_spacings

    def set_col_spacings(spacing)

spacing : the number of pixels of space to place between every column in the table.

The set_col_spacings() method sets the "column-spacing" property, that determines the space between every column in table, to the value of spacing.

gtk.Table.get_default_col_spacing

    def get_default_col_spacing()

Returns :

the default column spacing

The get_default_col_spacing() method returns the value of the "column-spacing" property to the default column spacing for the table i.e. the spacing that will be used for newly added columns. (See the set_col_spacings())

gtk.Table.set_homogeneous

    def set_homogeneous(homogeneous)

homogeneous : if TRUE all cells will be the same size as the largest cell

The set_homogeneous() method sets the "homogeneous" property to the value of homogeneous. If homogeneous is TRUE all cells will be the same size as the largest cell.

gtk.Table.get_homogeneous

    def get_homogeneous()

Returns : TRUE if the cells are all set to the same size

The get_homogeneous() method returns the value of the "homogeneous" property. If the value of "homogeneous" is TRUE all cells are set to the same width and height. (See the set_homogeneous() method)

Prev	Up	Next
gtk.Style	Home	gtk.TearoffMenuItem