Stack

The GtkStack widget is a container which only shows one of its children at a time. In contrast to GtkNotebook, GtkStack does not provide a means for users to change the visible child. Instead, the #GtkStackSwitcher widget can be used with GtkStack to provide this functionality.

Transitions between pages can be animated as slides or fades. This can be controlled with gtk.stack.Stack.setTransitionType. These animations respect the #GtkSettings:gtk-enable-animations setting.

The GtkStack widget was added in GTK+ 3.10.

CSS nodes

GtkStack has a single CSS node named stack.

class Stack : Container {

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

static GType _getGType();

GType _gType [@property getter];

Stack self();

static StackGidBuilder builder();

bool hhomogeneous [@property getter];

bool hhomogeneous [@property setter];

bool homogeneous [@property getter];

bool homogeneous [@property setter];

bool interpolateSize [@property getter];

bool interpolateSize [@property setter];

uint transitionDuration [@property getter];

uint transitionDuration [@property setter];

bool transitionRunning [@property getter];

gtk.types.StackTransitionType transitionType [@property getter];

gtk.types.StackTransitionType transitionType [@property setter];

bool vhomogeneous [@property getter];

bool vhomogeneous [@property setter];

gtk.widget.Widget visibleChild [@property getter];

gtk.widget.Widget visibleChild [@property setter];

string visibleChildName [@property getter];

string visibleChildName [@property setter];

void addNamed(gtk.widget.Widget child, string name);

void addTitled(gtk.widget.Widget child, string name, string title);

gtk.widget.Widget getChildByName(string name);

bool getHhomogeneous();

bool getHomogeneous();

bool getInterpolateSize();

uint getTransitionDuration();

bool getTransitionRunning();

gtk.types.StackTransitionType getTransitionType();

bool getVhomogeneous();

gtk.widget.Widget getVisibleChild();

string getVisibleChildName();

void setHhomogeneous(bool hhomogeneous);

void setHomogeneous(bool homogeneous);

void setInterpolateSize(bool interpolateSize);

void setTransitionDuration(uint duration);

void setTransitionType(gtk.types.StackTransitionType transition);

void setVhomogeneous(bool vhomogeneous);

void setVisibleChild(gtk.widget.Widget child);

void setVisibleChildFull(string name, gtk.types.StackTransitionType transition);

void setVisibleChildName(string name);

}

Constructors

this this(void* ptr, Flag!"Take" take)
this this(): Creates a new #GtkStack container.

Members

Functions

addNamed void addNamed(gtk.widget.Widget child, string name): Adds a child to stack. The child is identified by the name.
addTitled void addTitled(gtk.widget.Widget child, string name, string title): Adds a child to stack. The child is identified by the name. The title will be used by #GtkStackSwitcher to represent child in a tab bar, so it should be short.
getChildByName gtk.widget.Widget getChildByName(string name): Finds the child of the #GtkStack with the name given as the argument. Returns null if there is no child with this name.
getHhomogeneous bool getHhomogeneous(): Gets whether stack is horizontally homogeneous. See gtk.stack.Stack.setHhomogeneous.
getHomogeneous bool getHomogeneous(): Gets whether stack is homogeneous. See gtk.stack.Stack.setHomogeneous.
getInterpolateSize bool getInterpolateSize(): Returns wether the #GtkStack is set up to interpolate between the sizes of children on page switch.
getTransitionDuration uint getTransitionDuration(): Returns the amount of time (in milliseconds) that transitions between pages in stack will take.
getTransitionRunning bool getTransitionRunning(): Returns whether the stack is currently in a transition from one page to another.
getTransitionType gtk.types.StackTransitionType getTransitionType(): Gets the type of animation that will be used for transitions between pages in stack.
getVhomogeneous bool getVhomogeneous(): Gets whether stack is vertically homogeneous. See gtk.stack.Stack.setVhomogeneous.
getVisibleChild gtk.widget.Widget getVisibleChild(): Gets the currently visible child of stack, or null if there are no visible children.
getVisibleChildName string getVisibleChildName(): Returns the name of the currently visible child of stack, or null if there is no visible child.
self Stack self(): Returns this, for use in with statements.
setHhomogeneous void setHhomogeneous(bool hhomogeneous): Sets the #GtkStack to be horizontally homogeneous or not. If it is homogeneous, the #GtkStack will request the same width for all its children. If it isn't, the stack may change width when a different child becomes visible.
setHomogeneous void setHomogeneous(bool homogeneous): Sets the #GtkStack to be homogeneous or not. If it is homogeneous, the #GtkStack will request the same size for all its children. If it isn't, the stack may change size when a different child becomes visible.
setInterpolateSize void setInterpolateSize(bool interpolateSize): Sets whether or not stack will interpolate its size when changing the visible child. If the #GtkStack:interpolate-size property is set to true, stack will interpolate its size between the current one and the one it'll take after changing the visible child, according to the set transition duration.
setTransitionDuration void setTransitionDuration(uint duration): Sets the duration that transitions between pages in stack will take.
setTransitionType void setTransitionType(gtk.types.StackTransitionType transition): Sets the type of animation that will be used for transitions between pages in stack. Available types include various kinds of fades and slides.
setVhomogeneous void setVhomogeneous(bool vhomogeneous): Sets the #GtkStack to be vertically homogeneous or not. If it is homogeneous, the #GtkStack will request the same height for all its children. If it isn't, the stack may change height when a different child becomes visible.
setVisibleChild void setVisibleChild(gtk.widget.Widget child): Makes child the visible child of stack.
setVisibleChildFull void setVisibleChildFull(string name, gtk.types.StackTransitionType transition): Makes the child with the given name visible.
setVisibleChildName void setVisibleChildName(string name): Makes the child with the given name visible.

Properties

_gType GType _gType [@property getter]
hhomogeneous bool hhomogeneous [@property getter]: Get hhomogeneous property.
hhomogeneous bool hhomogeneous [@property setter]: Set hhomogeneous property.
homogeneous bool homogeneous [@property getter]
homogeneous bool homogeneous [@property setter]
interpolateSize bool interpolateSize [@property getter]
interpolateSize bool interpolateSize [@property setter]
transitionDuration uint transitionDuration [@property getter]
transitionDuration uint transitionDuration [@property setter]
transitionRunning bool transitionRunning [@property getter]
transitionType gtk.types.StackTransitionType transitionType [@property getter]
transitionType gtk.types.StackTransitionType transitionType [@property setter]
vhomogeneous bool vhomogeneous [@property getter]: Get vhomogeneous property.
vhomogeneous bool vhomogeneous [@property setter]: Set vhomogeneous property.
visibleChild gtk.widget.Widget visibleChild [@property getter]
visibleChild gtk.widget.Widget visibleChild [@property setter]
visibleChildName string visibleChildName [@property getter]
visibleChildName string visibleChildName [@property setter]

Static functions

_getGType GType _getGType()
builder StackGidBuilder builder(): Get builder for gtk.stack.Stack

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 stack classes