GTK#

Packing using Tables

Let's take a look at another way of packing - Tables. These can be extremely useful in certain situations. Using tables, we create a grid that we can place widgets in. The widgets may take up as many spaces as we specify. The first thing to look at, of course, is the Table() constructor:

Widget table1 = new Table(    int    rows,
                              int    columns,
                              bool   homogeneous );
The first argument is the number of rows to make in the table, while the second, obviously, is the number of columns. The homogeneous argument has to do with how the table's boxes are sized. If homogeneous is true, the table boxes are resized to the size of the largest widget in the table. If homogeneous is false, the size of a table boxes is dictated by the tallest widget in its same row, and the widest widget in its column. The rows and columns are laid out from 0 to n, where n was the number specified in the call to Table(). So, if you specify rows = 2 and columns = 2, the layout would look something like this:
 0          1          2
0+----------+----------+
 |          |          |
1+----------+----------+
 |          |          |
2+----------+----------+
Note that the coordinate system starts in the upper left hand corner. To place a widget into a box, use the following function:
table1.Attach (        Widget            child,
                       int               left_attach,
                       int               right_attach,
                       int               top_attach,
                       int               bottom_attach,
                       Gtk.AttachOptions xoptions,
                       Gtk.AttachOptions yoptions,
                       int               xpadding,
                       int               ypadding );
The first argument ("child") is the widget you wish to place in the table. The left and right attach arguments specify where to place the widget, and how many boxes to use. If you want a button in the lower right table entry of our 2x2 table, and want it to fill that entry only, left_attach would be = 1, right_attach = 2, top_attach = 1, bottom_attach = 2. Now, if you wanted a widget to take up the whole top row of our 2x2 table, you'd use left_attach = 0, right_attach = 2, top_attach = 0, bottom_attach = 1. The xoptions and yoptions are used to specify packing options and may be bitwise OR'ed together to allow multiple options. These options are: Padding is just like in boxes, creating a clear area around the widget specified in pixels. gtk_table_attach() has a lot of options. So, there's a shortcut:
table1.AttachDefaults(          GtkWidget widget,
                                int       left_attach,
                                int       right_attach,
                                int       top_attach,
                                int       bottom_attach );
The X and Y options default to Gtk.Fill | Gtk.Expand, and X and Y padding are set to 0. The rest of the arguments are identical to the previous function. We also have SetRowSpacing() and SetColSpacing(). These places spacing between the rows at the specified row or column.
table1.SetRowSpacing(  int     row,
                       int     spacing );
and
table1.SetColSpacing (  int     column,
                        int     spacing );
Note that for columns, the space goes to the right of the column, and for rows, the space goes below the row. You can also set a consistent spacing of all rows and/or columns with:
table1.SetRowSpacing( int    spacing );
And,
table1.SetColSpacings(int     spacing );
Note that with these calls, the last row and last column do not get any spacing.