Memory-managed wrapper type.

Type class for types which can be safely cast to Container, for instance with toContainer.

Cast to Container, for types for which this is known to be safe. For general casts, use castTo.

A convenience alias for Nothing :: Maybe Container.

Adds widget to container. Typically used for simple containers such as Window, Frame, or Button; for more complicated layout containers such as Box or Grid, this function will pick default packing parameters that may not be correct. So consider functions such as boxPackStart and gridAttach as an alternative to containerAdd 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.

Note that some containers, such as ScrolledWindow or ListBox, may add intermediate children between the added widget and the container.

No description available in the introspection data.

Gets the value of a child property for child and container.

Emits a Widget::child-notify signal for the [child property][child-properties] childProperty on the child.

This is an analogue of objectNotify for child properties.

Also see widgetChildNotify.

Since: 3.2

Emits a Widget::child-notify signal for the [child property][child-properties] specified by pspec on the child.

This is an analogue of objectNotifyByPspec for child properties.

Since: 3.18

Sets a child property for child and container.

Returns the type of the children supported by the container.

Note that this may return G_TYPE_NONE to indicate that no more children can be added, e.g. for a Paned which already has two children.

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.

Most applications should use containerForeach, rather than containerForall.

Invokes callback on each non-internal child of container. See containerForall 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.

Most applications should use containerForeach, rather than containerForall.

Retrieves the border width of the container. See containerSetBorderWidth.

Returns the container’s non-internal children. See containerForall for details on what constitutes an "internal" child.

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 Nothing in focusableWidgets and returns False.

Returns the current focus child widget inside container. This is not the currently focused widget. That can be obtained by calling windowGetFocus.

Since: 2.14

Retrieves the horizontal focus adjustment for the container. See gtk_container_set_focus_hadjustment ().

Retrieves the vertical focus adjustment for the container. See containerSetFocusVadjustment.

Returns a newly created widget path representing all the widget hierarchy from the toplevel down to and including child.

Returns the resize mode for the container. See gtk_container_set_resize_mode ().

When a container receives a call to the draw function, it must send synthetic Widget::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 Widget::draw function, calls containerPropagateDraw once for each child, passing in the cr the container received.

containerPropagateDraw takes care of translating the origin of cr, and deciding whether the draw needs to be sent to the child. It is a convenient and optimized way of getting the same effect as calling widgetDraw on the child directly.

In most cases, a container can simply either inherit the Widget::draw implementation from Container, or do some drawing and then chain to the ::draw implementation from Container.

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 objectRef. If you don’t want to use widget again it’s usually more efficient to simply destroy it directly using widgetDestroy since this will remove it from the container and help break any circular reference count cycles.

No description available in the introspection data.

Sets the border width of the container.

The border width of a container is the amount of space to leave around the outside of the container. The only exception to this is Window; because toplevel windows can’t leave space outside, they leave the space inside. The border is added on all sides of the container. To add space to only one side, use a specific Widget:margin property on the child widget, for example Widget:margin-top.

Sets a focus chain, overriding the one computed automatically by GTK+.

In principle each widget in the chain should be a descendant of the container, but this is not enforced by this method, since it’s allowed to set the focus chain before you pack the widgets, or have a widget in the chain that isn’t always packed. The necessary checks are done when the focus chain is actually traversed.

Sets, or unsets if child is Nothing, the focused child of container.

This function emits the GtkContainer::set_focus_child signal of container. Implementations of Container can override the default behaviour by overriding the class closure of this signal.

This is function is mostly meant to be used by widgets. Applications can use widgetGrabFocus to manually set the focus to a specific widget.

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 scrolledWindowGetHadjustment for a typical way of obtaining the adjustment and containerSetFocusVadjustment for setting the vertical adjustment.

The adjustments have to be in pixel units and in the same coordinate system as the allocation for immediate children of the container.

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 scrolledWindowGetVadjustment for a typical way of obtaining the adjustment and containerSetFocusHadjustment for setting the horizontal adjustment.

The adjustments have to be in pixel units and in the same coordinate system as the allocation for immediate children of the container.

Sets the reallocateRedraws flag of the container to the given value.

Containers requesting reallocation redraws get automatically redrawn if any of their children changed allocation.

Sets the resize mode for the container.

The resize mode of a container determines whether a resize request will be passed to the container’s parent, queued for later execution or executed immediately.

Removes a focus chain explicitly set with containerSetFocusChain.

Construct a GValueConstruct with valid value for the “border-width” property. This is rarely needed directly, but it is used by new.

Get the value of the “border-width” property. When overloading is enabled, this is equivalent to

get container #borderWidth

Set the value of the “border-width” property. When overloading is enabled, this is equivalent to

set container [ #borderWidth := value ]

Set the value of the “child” property to Nothing. When overloading is enabled, this is equivalent to

clear #child

Construct a GValueConstruct with valid value for the “child” property. This is rarely needed directly, but it is used by new.

Set the value of the “child” property. When overloading is enabled, this is equivalent to

set container [ #child := value ]

Construct a GValueConstruct with valid value for the “resize-mode” property. This is rarely needed directly, but it is used by new.

Get the value of the “resize-mode” property. When overloading is enabled, this is equivalent to

get container #resizeMode

Set the value of the “resize-mode” property. When overloading is enabled, this is equivalent to

set container [ #resizeMode := value ]

Type for the callback on the (unwrapped) C side.

No description available in the introspection data.

Connect a signal handler for the “add” signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after container #add callback

Wrap the callback into a Closure.

Generate a function pointer callable from C code, from a C_ContainerAddCallback.

A convenience synonym for Nothing :: Maybe ContainerAddCallback.

Connect a signal handler for the “add” signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on container #add callback

Wrap a ContainerAddCallback into a C_ContainerAddCallback.

Type for the callback on the (unwrapped) C side.

No description available in the introspection data.

Connect a signal handler for the “check-resize” signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after container #checkResize callback

Wrap the callback into a Closure.

Generate a function pointer callable from C code, from a C_ContainerCheckResizeCallback.

A convenience synonym for Nothing :: Maybe ContainerCheckResizeCallback.

Connect a signal handler for the “check-resize” signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on container #checkResize callback

Wrap a ContainerCheckResizeCallback into a C_ContainerCheckResizeCallback.

Type for the callback on the (unwrapped) C side.

No description available in the introspection data.

Connect a signal handler for the “remove” signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after container #remove callback

Wrap the callback into a Closure.

Generate a function pointer callable from C code, from a C_ContainerRemoveCallback.

A convenience synonym for Nothing :: Maybe ContainerRemoveCallback.

Connect a signal handler for the “remove” signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on container #remove callback

Wrap a ContainerRemoveCallback into a C_ContainerRemoveCallback.

Type for the callback on the (unwrapped) C side.

No description available in the introspection data.

Connect a signal handler for the “set-focus-child” signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after container #setFocusChild callback

Wrap the callback into a Closure.

Generate a function pointer callable from C code, from a C_ContainerSetFocusChildCallback.

A convenience synonym for Nothing :: Maybe ContainerSetFocusChildCallback.

Connect a signal handler for the “set-focus-child” signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on container #setFocusChild callback

Wrap a ContainerSetFocusChildCallback into a C_ContainerSetFocusChildCallback.