Table

The #GtkTable functions allow the programmer to arrange widgets 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.Table.new_, the size of which can later be changed with gtk.table.Table.resize.

Widgets can be added to a table using gtk.table.Table.attach or the more convenient (but slightly less flexible) gtk.table.Table.attachDefaults.

To alter the space next to a specific row, use gtk.table.Table.setRowSpacing, and for a column, gtk.table.Table.setColSpacing. The gaps between all rows or columns can be changed by calling gtk.table.Table.setRowSpacings or gtk.table.Table.setColSpacings respectively. Note that spacing is added between the children, while padding added by gtk.table.Table.attach is added on either side of the widget it belongs to.

gtk.table.Table.setHomogeneous, can be used to set whether all cells in the table will resize themselves to the size of the largest widget in the table.

> #GtkTable has been deprecated. Use #GtkGrid instead. It provides the same > capabilities as GtkTable for arranging widgets in a rectangular grid, but > does support height-for-width geometry management.

class Table : Container {

this(void* ptr, Flag!"Take" take);

static GType _getGType();

GType _gType [@property getter];

Table self();

static TableGidBuilder builder();

uint columnSpacing [@property getter];

uint columnSpacing [@property setter];

bool homogeneous [@property getter];

bool homogeneous [@property setter];

uint nColumns [@property getter];

uint nColumns [@property setter];

uint nRows [@property getter];

uint nRows [@property setter];

uint rowSpacing [@property getter];

uint rowSpacing [@property setter];

this(uint rows, uint columns, bool homogeneous);

void attach(gtk.widget.Widget child, uint leftAttach, uint rightAttach, uint topAttach, uint bottomAttach, gtk.types.AttachOptions xoptions, gtk.types.AttachOptions yoptions, uint xpadding, uint ypadding);

void attachDefaults(gtk.widget.Widget widget, uint leftAttach, uint rightAttach, uint topAttach, uint bottomAttach);

uint getColSpacing(uint column);

uint getDefaultColSpacing();

uint getDefaultRowSpacing();

bool getHomogeneous();

uint getRowSpacing(uint row);

void getSize(uint rows, uint columns);

void resize(uint rows, uint columns);

void setColSpacing(uint column, uint spacing);

void setColSpacings(uint spacing);

void setHomogeneous(bool homogeneous);

void setRowSpacing(uint row, uint spacing);

void setRowSpacings(uint spacing);

}

Constructors

this this(void* ptr, Flag!"Take" take)
this this(uint rows, uint columns, bool homogeneous): Used to create a new table widget. An initial size must be given by specifying how many rows and columns the table should have, although this can be changed later with gtk.table.Table.resize. rows and columns must both be in the range 1 .. 65535. For historical reasons, 0 is accepted as well and is silently interpreted as 1.

Members

Functions

attach void attach(gtk.widget.Widget child, uint leftAttach, uint rightAttach, uint topAttach, uint bottomAttach, gtk.types.AttachOptions xoptions, gtk.types.AttachOptions yoptions, uint xpadding, uint ypadding): Adds a widget to a table. The number of “cells” that a widget will occupy is specified by left_attach, right_attach, top_attach and bottom_attach. These each represent the leftmost, rightmost, uppermost and lowest column and row numbers of the table. (Columns and rows are indexed from zero).
attachDefaults void attachDefaults(gtk.widget.Widget widget, uint leftAttach, uint rightAttach, uint topAttach, uint bottomAttach): As there are many options associated with gtk.table.Table.attach, this convenience function provides the programmer with a means to add children to a table with identical padding and expansion options. The values used for the #GtkAttachOptions are GTK_EXPAND | GTK_FILL, and the padding is set to 0.
getColSpacing uint getColSpacing(uint column): Gets the amount of space between column col, and column col + 1. See gtk.table.Table.setColSpacing.
getDefaultColSpacing uint getDefaultColSpacing(): Gets the default column spacing for the table. This is the spacing that will be used for newly added columns. (See gtk.table.Table.setColSpacings)
getDefaultRowSpacing uint getDefaultRowSpacing(): Gets the default row spacing for the table. This is the spacing that will be used for newly added rows. (See gtk.table.Table.setRowSpacings)
getHomogeneous bool getHomogeneous(): Returns whether the table cells are all constrained to the same width and height. (See gtk_table_set_homogeneous ())
getRowSpacing uint getRowSpacing(uint row): Gets the amount of space between row row, and row row + 1. See gtk.table.Table.setRowSpacing.
getSize void getSize(uint rows, uint columns): Gets the number of rows and columns in the table.
resize void resize(uint rows, uint columns): If you need to change a table’s size after it has been created, this function allows you to do so.
self Table self(): Returns this, for use in with statements.
setColSpacing void setColSpacing(uint column, uint spacing): Alters the amount of space between a given table column and the following column.
setColSpacings void setColSpacings(uint spacing): Sets the space between every column in table equal to spacing.
setHomogeneous void setHomogeneous(bool homogeneous): Changes the homogenous property of table cells, ie. whether all cells are an equal size or not.
setRowSpacing void setRowSpacing(uint row, uint spacing): Changes the space between a given table row and the subsequent row.
setRowSpacings void setRowSpacings(uint spacing): Sets the space between every row in table equal to spacing.

Properties

_gType GType _gType [@property getter]
columnSpacing uint columnSpacing [@property getter]
columnSpacing uint columnSpacing [@property setter]
homogeneous bool homogeneous [@property getter]
homogeneous bool homogeneous [@property setter]
nColumns uint nColumns [@property getter]
nColumns uint nColumns [@property setter]
nRows uint nRows [@property getter]
nRows uint nRows [@property setter]
rowSpacing uint rowSpacing [@property getter]
rowSpacing uint rowSpacing [@property setter]

Static functions

_getGType GType _getGType()
builder TableGidBuilder builder(): Get builder for gtk.table.Table

Inherited Members

From Container

_getGType GType _getGType()
_gType GType _gType [@property getter]
self Container self(): Returns this, for use in with statements.
builder ContainerGidBuilder builder(): Get builder for gtk.container.Container
borderWidth uint borderWidth [@property getter]
borderWidth uint borderWidth [@property setter]
child gtk.widget.Widget child [@property setter]
resizeMode gtk.types.ResizeMode resizeMode [@property getter]
resizeMode gtk.types.ResizeMode resizeMode [@property setter]
add void add(gtk.widget.Widget widget): Adds widget to container. Typically used for simple containers such as #GtkWindow, #GtkFrame, or #GtkButton; for more complicated layout containers such as #GtkBox or #GtkGrid, this function will pick default packing parameters that may not be correct. So consider functions such as gtk.box.Box.packStart and gtk.grid.Grid.attach as an alternative to gtk.container.Container.add in those cases. A widget may be added to only one container at a time; you can’t place the same widget inside two different containers.
checkResize void checkResize()
childGetProperty void childGetProperty(gtk.widget.Widget child, string propertyName, gobject.value.Value value): Gets the value of a child property for child and container.
childNotify void childNotify(gtk.widget.Widget child, string childProperty): Emits a #GtkWidget::child-notify signal for the [child property][child-properties] child_property on the child.
childNotifyByPspec void childNotifyByPspec(gtk.widget.Widget child, gobject.param_spec.ParamSpec pspec): Emits a #GtkWidget::child-notify signal for the [child property][child-properties] specified by pspec on the child.
childSetProperty void childSetProperty(gtk.widget.Widget child, string propertyName, gobject.value.Value value): Sets a child property for child and container.
childType gobject.types.GType childType(): Returns the type of the children supported by the container.
forall void forall(gtk.types.Callback callback): Invokes callback on each direct child of container, including children that are considered “internal” (implementation details of the container). “Internal” children generally weren’t added by the user of the container, but were added by the container implementation itself.
foreach_ void foreach_(gtk.types.Callback callback): Invokes callback on each non-internal child of container. See gtk.container.Container.forall for details on what constitutes an “internal” child. For all practical purposes, this function should iterate over precisely those child widgets that were added to the container by the application with explicit add() calls.
getBorderWidth uint getBorderWidth(): Retrieves the border width of the container. See gtk.container.Container.setBorderWidth.
getChildren gtk.widget.Widget[] getChildren(): Returns the container’s non-internal children. See gtk.container.Container.forall for details on what constitutes an "internal" child.
getFocusChain bool getFocusChain(gtk.widget.Widget[] focusableWidgets): Retrieves the focus chain of the container, if one has been set explicitly. If no focus chain has been explicitly set, GTK+ computes the focus chain based on the positions of the children. In that case, GTK+ stores null in focusable_widgets and returns false.
getFocusChild gtk.widget.Widget getFocusChild(): Returns the current focus child widget inside container. This is not the currently focused widget. That can be obtained by calling gtk.window.Window.getFocus.
getFocusHadjustment gtk.adjustment.Adjustment getFocusHadjustment(): Retrieves the horizontal focus adjustment for the container. See gtk_container_set_focus_hadjustment ().
getFocusVadjustment gtk.adjustment.Adjustment getFocusVadjustment(): Retrieves the vertical focus adjustment for the container. See gtk.container.Container.setFocusVadjustment.
getPathForChild gtk.widget_path.WidgetPath getPathForChild(gtk.widget.Widget child): Returns a newly created widget path representing all the widget hierarchy from the toplevel down to and including child.
getResizeMode gtk.types.ResizeMode getResizeMode(): Returns the resize mode for the container. See gtk_container_set_resize_mode ().
propagateDraw void propagateDraw(gtk.widget.Widget child, cairo.context.Context cr): When a container receives a call to the draw function, it must send synthetic #GtkWidget::draw calls to all children that don’t have their own #GdkWindows. This function provides a convenient way of doing this. A container, when it receives a call to its #GtkWidget::draw function, calls gtk.container.Container.propagateDraw once for each child, passing in the cr the container received.
remove void remove(gtk.widget.Widget widget): Removes widget from container. widget must be inside container. Note that container will own a reference to widget, and that this may be the last reference held; so removing a widget from its container can destroy that widget. If you want to use widget again, you need to add a reference to it before removing it from a container, using gobject.object.ObjectWrap.ref_. If you don’t want to use widget again it’s usually more efficient to simply destroy it directly using gtk.widget.Widget.destroy since this will remove it from the container and help break any circular reference count cycles.
resizeChildren void resizeChildren()
setBorderWidth void setBorderWidth(uint borderWidth): Sets the border width of the container.
setFocusChain void setFocusChain(gtk.widget.Widget[] focusableWidgets): Sets a focus chain, overriding the one computed automatically by GTK+.
setFocusChild void setFocusChild(gtk.widget.Widget child): Sets, or unsets if child is null, the focused child of container.
setFocusHadjustment void setFocusHadjustment(gtk.adjustment.Adjustment adjustment): Hooks up an adjustment to focus handling in a container, so when a child of the container is focused, the adjustment is scrolled to show that widget. This function sets the horizontal alignment. See gtk.scrolled_window.ScrolledWindow.getHadjustment for a typical way of obtaining the adjustment and gtk.container.Container.setFocusVadjustment for setting the vertical adjustment.
setFocusVadjustment void setFocusVadjustment(gtk.adjustment.Adjustment adjustment): Hooks up an adjustment to focus handling in a container, so when a child of the container is focused, the adjustment is scrolled to show that widget. This function sets the vertical alignment. See gtk.scrolled_window.ScrolledWindow.getVadjustment for a typical way of obtaining the adjustment and gtk.container.Container.setFocusHadjustment for setting the horizontal adjustment.
setReallocateRedraws void setReallocateRedraws(bool needsRedraws): Sets the reallocate_redraws flag of the container to the given value.
setResizeMode void setResizeMode(gtk.types.ResizeMode resizeMode): Sets the resize mode for the container.
unsetFocusChain void unsetFocusChain(): Removes a focus chain explicitly set with gtk.container.Container.setFocusChain.
connectAdd gulong connectAdd(T callback, Flag!"After" after): Connect to Add signal.
connectCheckResize gulong connectCheckResize(T callback, Flag!"After" after): Connect to CheckResize signal.
connectRemove gulong connectRemove(T callback, Flag!"After" after): Connect to Remove signal.
connectSetFocusChild gulong connectSetFocusChild(T callback, Flag!"After" after): Connect to SetFocusChild signal.

gtk table classes