#include <Magnum/Ui/SnapLayout.h>
template<class UserInterface>
Magnum::Ui::BasicSnapLayout class new in Git master

Layout using SnapLayouter.

Restricts AbstractSnapLayout to a concrete user interface instance. Meant to be used through concrete a typedef such as SnapLayout. See the base class documentation for more information.

Base classes

class AbstractSnapLayout new in Git master
Base for layouts using SnapLayouter.

Derived classes

template<class UserInterface>
class BasicSnapLayoutColumn new in Git master
Column layout using SnapLayouter.
template<class UserInterface>
class BasicSnapLayoutColumnFill new in Git master
Filled column layout using SnapLayouter.
template<class UserInterface>
class BasicSnapLayoutColumnLeft new in Git master
Left-aligned column layout using SnapLayouter.
template<class UserInterface>
class BasicSnapLayoutColumnRight new in Git master
Right-aligned column layout using SnapLayouter.
template<class UserInterface>
class BasicSnapLayoutRow new in Git master
Row layout using SnapLayouter.
template<class UserInterface>
class BasicSnapLayoutRowBottom new in Git master
Bottom-aligned row layout using SnapLayouter.
template<class UserInterface>
class BasicSnapLayoutRowFill new in Git master
Filled row layout using SnapLayouter.
template<class UserInterface>
class BasicSnapLayoutRowTop new in Git master
Top-aligned row layout using SnapLayouter.

Public static functions

static auto child(SnapLayouter& layouter, const BasicAnchor<UserInterface>& parent, const Vector2& nodeSize = {}, NodeFlags nodeFlags = {}, LayoutHandle layoutBefore = LayoutHandle::Null, SnapLayoutFlags layoutFlags = {}) -> BasicSnapLayout<UserInterface>
Create a child layout.
static auto child(SnapLayouter& layouter, const BasicAnchor<UserInterface>& parent, const Vector2& nodeSize, LayoutHandle layoutBefore, SnapLayoutFlags layoutFlags = {}) -> BasicSnapLayout<UserInterface>
static auto child(SnapLayouter& layouter, const BasicAnchor<UserInterface>& parent, const Vector2& nodeSize, NodeFlags nodeFlags, SnapLayoutFlags layoutFlags) -> BasicSnapLayout<UserInterface>
static auto child(SnapLayouter& layouter, const BasicAnchor<UserInterface>& parent, const Vector2& nodeSize, SnapLayoutFlags layoutFlags) -> BasicSnapLayout<UserInterface>
static auto child(SnapLayouter& layouter, const BasicAnchor<UserInterface>& parent, const Vector2& nodeSize, NodeFlags nodeFlags, LayouterDataHandle layoutBefore, SnapLayoutFlags layoutFlags = {}) -> BasicSnapLayout<UserInterface>
Create a child layout, ordered before given layout assuming the layout belongs to the same layouter.
static auto child(SnapLayouter& layouter, const BasicAnchor<UserInterface>& parent, const Vector2& nodeSize, LayouterDataHandle layoutBefore, SnapLayoutFlags layoutFlags = {}) -> BasicSnapLayout<UserInterface>
static auto child(const BasicAnchor<UserInterface>& parent, const Vector2& nodeSize = {}, NodeFlags nodeFlags = {}, LayoutHandle layoutBefore = LayoutHandle::Null, SnapLayoutFlags layoutFlags = {}) -> BasicSnapLayout<UserInterface>
Create a child layout using the default layouter in given user interface.
static auto child(const BasicAnchor<UserInterface>& parent, const Vector2& nodeSize, LayoutHandle layoutBefore, SnapLayoutFlags layoutFlags = {}) -> BasicSnapLayout<UserInterface>
static auto child(const BasicAnchor<UserInterface>& parent, const Vector2& nodeSize, NodeFlags nodeFlags, SnapLayoutFlags layoutFlags) -> BasicSnapLayout<UserInterface>
static auto child(const BasicAnchor<UserInterface>& parent, const Vector2& nodeSize, SnapLayoutFlags layoutFlags) -> BasicSnapLayout<UserInterface>
static auto child(const BasicAnchor<UserInterface>& parent, const Vector2& nodeSize, NodeFlags nodeFlags, LayouterDataHandle layoutBefore, SnapLayoutFlags layoutFlags = {}) -> BasicSnapLayout<UserInterface>
Create a child layout using the default layouter in given user interface, ordered before given layout assuming the layout belongs to the same layouter.
static auto child(const BasicAnchor<UserInterface>& parent, const Vector2& nodeSize, LayouterDataHandle layoutBefore, SnapLayoutFlags layoutFlags = {}) -> BasicSnapLayout<UserInterface>
static auto root(UserInterface& ui, SnapLayouter& layouter, Snaps snap, const Vector2& nodeSize = {}, NodeFlags nodeFlags = {}, SnapLayoutFlags layoutFlags = {}) -> BasicSnapLayout<UserInterface>
Create an explicitly snapped root layout.
static auto root(UserInterface& ui, SnapLayouter& layouter, Snaps snap, const Vector2& nodeSize, SnapLayoutFlags layoutFlags) -> BasicSnapLayout<UserInterface>
static auto root(UserInterface& ui, Snaps snap, const Vector2& nodeSize = {}, NodeFlags nodeFlags = {}, SnapLayoutFlags layoutFlags = {}) -> BasicSnapLayout<UserInterface>
Create an explicitly snapped root layout using the default layouter in given user interface.
static auto root(UserInterface& ui, Snaps snap, const Vector2& nodeSize, SnapLayoutFlags layoutFlags) -> BasicSnapLayout<UserInterface>
static auto child(SnapLayouter& layouter, Snaps snap, const BasicAnchor<UserInterface>& parent, const Vector2& nodeSize = {}, NodeFlags nodeFlags = {}, SnapLayoutFlags layoutFlags = {}) -> BasicSnapLayout<UserInterface>
Create an explicitly snapped child layout.
static auto child(SnapLayouter& layouter, Snaps snap, const BasicAnchor<UserInterface>& parent, const Vector2& nodeSize, SnapLayoutFlags layoutFlags) -> BasicSnapLayout<UserInterface>
static auto child(Snaps snap, const BasicAnchor<UserInterface>& parent, const Vector2& nodeSize = {}, NodeFlags nodeFlags = {}, SnapLayoutFlags layoutFlags = {}) -> BasicSnapLayout<UserInterface>
Create an explicitly snapped child layout using the default layouter in given user interface.
static auto child(Snaps snap, const BasicAnchor<UserInterface>& parent, const Vector2& nodeSize, SnapLayoutFlags layoutFlags) -> BasicSnapLayout<UserInterface>
static auto sibling(SnapLayouter& layouter, Snaps snap, const BasicAnchor<UserInterface>& target, const Vector2& nodeSize = {}, NodeFlags nodeFlags = {}, SnapLayoutFlags layoutFlags = {}) -> BasicSnapLayout<UserInterface>
Create an explicitly snapped sibling layout.
static auto sibling(SnapLayouter& layouter, Snaps snap, const BasicAnchor<UserInterface>& target, const Vector2& nodeSize, SnapLayoutFlags layoutFlags) -> BasicSnapLayout<UserInterface>
static auto sibling(Snaps snap, const BasicAnchor<UserInterface>& target, const Vector2& nodeSize = {}, NodeFlags nodeFlags = {}, SnapLayoutFlags layoutFlags = {}) -> BasicSnapLayout<UserInterface>
Create an explicitly snapped sibling layout using the default layouter in given user interface.
static auto sibling(Snaps snap, const BasicAnchor<UserInterface>& target, const Vector2& nodeSize, SnapLayoutFlags layoutFlags) -> BasicSnapLayout<UserInterface>

Constructors, destructors, conversion operators

BasicSnapLayout(SnapLayouter& layouter, const BasicAnchor<UserInterface>& anchor) explicit
Construct with creating or reusing layout on an existing node.
BasicSnapLayout(const BasicAnchor<UserInterface>& anchor) explicit
Construct with creating or reusing layout on an existing node.
BasicSnapLayout(SnapLayouter& layouter, const BasicAnchor<UserInterface>& anchor, LayoutHandle before, SnapLayoutFlags flags = {}) explicit
Construct a layout on an existing node.
BasicSnapLayout(SnapLayouter& layouter, const BasicAnchor<UserInterface>& anchor, SnapLayoutFlags layoutFlags) explicit
BasicSnapLayout(SnapLayouter& layouter, const BasicAnchor<UserInterface>& anchor, LayouterDataHandle before, SnapLayoutFlags flags = {}) explicit
Construct a layout on an existing node, ordered before given layout assuming the layout belongs to the same layouter.
BasicSnapLayout(const BasicAnchor<UserInterface>& anchor, LayoutHandle before, SnapLayoutFlags flags = {}) explicit
Construct a layout on an existing node.
BasicSnapLayout(const BasicAnchor<UserInterface>& anchor, SnapLayoutFlags layoutFlags) explicit
BasicSnapLayout(const BasicAnchor<UserInterface>& anchor, LayouterDataHandle before, SnapLayoutFlags flags = {}) explicit
Construct a layout on an existing node, ordered before given layout assuming the layout belongs to the same layouter.
BasicSnapLayout(SnapLayouter& layouter, const BasicAnchor<UserInterface>& anchor, Snaps snap, LayoutHandle snapTarget, SnapLayoutFlags flags = {}) explicit
Construct an explicitly snapped layout on an existing node.
BasicSnapLayout(SnapLayouter& layouter, const BasicAnchor<UserInterface>& anchor, Snaps snap, LayouterDataHandle snapTarget, SnapLayoutFlags flags = {}) explicit
Construct an explicitly snapped layout on an existing node, assuming the target belongs to the same layouter.
BasicSnapLayout(const BasicAnchor<UserInterface>& anchor, Snaps snap, LayoutHandle snapTarget, SnapLayoutFlags flags = {}) explicit
Construct an explicitly snapped layout on an existing node.
BasicSnapLayout(const BasicAnchor<UserInterface>& anchor, Snaps snap, LayouterDataHandle snapTarget, SnapLayoutFlags flags = {}) explicit
Construct an explicitly snapped layout on an existing node, assuming the target belongs to the same layouter.
operator BasicAnchor<UserInterface>() const
Widget positioning anchor.

Public functions

auto ui() const -> UserInterface&
User interface instance.
auto child(const Vector2& nodeSize = {}, NodeFlags nodeFlags = {}, LayoutHandle layoutBefore = LayoutHandle::Null, SnapLayoutFlags layoutFlags = {}) -> BasicSnapLayout<UserInterface>
Create a child layout.
auto child(const Vector2& nodeSize, LayoutHandle layoutBefore, SnapLayoutFlags layoutFlags = {}) -> BasicSnapLayout<UserInterface>
auto child(const Vector2& nodeSize, NodeFlags nodeFlags, SnapLayoutFlags layoutFlags) -> BasicSnapLayout<UserInterface>
auto child(const Vector2& nodeSize, SnapLayoutFlags layoutFlags) -> BasicSnapLayout<UserInterface>
auto child(const Vector2& nodeSize, NodeFlags nodeFlags, LayouterDataHandle layoutBefore, SnapLayoutFlags layoutFlags = {}) -> BasicSnapLayout<UserInterface>
Create a child layout, ordered before given layout assuming the layout belongs to the same layouter.
auto child(const Vector2& nodeSize, LayouterDataHandle layoutBefore, SnapLayoutFlags layoutFlags = {}) -> BasicSnapLayout<UserInterface>
auto child(Snaps snap, const Vector2& nodeSize = {}, NodeFlags nodeFlags = {}, SnapLayoutFlags layoutFlags = {}) -> BasicSnapLayout<UserInterface>
Create an explicitly snapped child layout.
auto child(Snaps snap, const Vector2& nodeSize, SnapLayoutFlags layoutFlags) -> BasicSnapLayout<UserInterface>
auto sibling(Snaps snap, const Vector2& nodeSize = {}, NodeFlags nodeFlags = {}, SnapLayoutFlags layoutFlags = {}) -> BasicSnapLayout<UserInterface>
Create an explicitly snapped sibling layout.
auto sibling(Snaps snap, const Vector2& nodeSize, SnapLayoutFlags layoutFlags) -> BasicSnapLayout<UserInterface>

Function documentation

template<class UserInterface _1>
static BasicSnapLayout<UserInterface> Magnum::Ui::BasicSnapLayout<_1>::child(SnapLayouter& layouter, const BasicAnchor<UserInterface>& parent, const Vector2& nodeSize = {}, NodeFlags nodeFlags = {}, LayoutHandle layoutBefore = LayoutHandle::Null, SnapLayoutFlags layoutFlags = {})

Create a child layout.

Like AbstractSnapLayout::child(SnapLayouter&, const AbstractAnchor&, const Vector2&, NodeFlags, LayoutHandle, SnapLayoutFlags) but returning a concrete layout instance. Use child(const BasicAnchor<UserInterface>&, const Vector2&, NodeFlags, LayoutHandle, SnapLayoutFlags) to use the default SnapLayouter instance available through UserInterface::snapLayouter(). If you have an exising layout instance, there's child(const Vector2&, NodeFlags, LayoutHandle, SnapLayoutFlags) which is equivalent to this function.

template<class UserInterface _1>
static BasicSnapLayout<UserInterface> Magnum::Ui::BasicSnapLayout<_1>::child(SnapLayouter& layouter, const BasicAnchor<UserInterface>& parent, const Vector2& nodeSize, LayoutHandle layoutBefore, SnapLayoutFlags layoutFlags = {})

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

template<class UserInterface _1>
static BasicSnapLayout<UserInterface> Magnum::Ui::BasicSnapLayout<_1>::child(SnapLayouter& layouter, const BasicAnchor<UserInterface>& parent, const Vector2& nodeSize, NodeFlags nodeFlags, SnapLayoutFlags layoutFlags)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

template<class UserInterface _1>
static BasicSnapLayout<UserInterface> Magnum::Ui::BasicSnapLayout<_1>::child(SnapLayouter& layouter, const BasicAnchor<UserInterface>& parent, const Vector2& nodeSize, SnapLayoutFlags layoutFlags)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

template<class UserInterface _1>
static BasicSnapLayout<UserInterface> Magnum::Ui::BasicSnapLayout<_1>::child(SnapLayouter& layouter, const BasicAnchor<UserInterface>& parent, const Vector2& nodeSize, NodeFlags nodeFlags, LayouterDataHandle layoutBefore, SnapLayoutFlags layoutFlags = {})

Create a child layout, ordered before given layout assuming the layout belongs to the same layouter.

Like AbstractSnapLayout::child(SnapLayouter&, const AbstractAnchor&, const Vector2&, NodeFlags, LayouterDataHandle, SnapLayoutFlags) but returning a concrete layout instance. If you have an exising layout instance, there's child(const Vector2&, NodeFlags, LayouterDataHandle, SnapLayoutFlags) which is equivalent to this function.

template<class UserInterface _1>
static BasicSnapLayout<UserInterface> Magnum::Ui::BasicSnapLayout<_1>::child(SnapLayouter& layouter, const BasicAnchor<UserInterface>& parent, const Vector2& nodeSize, LayouterDataHandle layoutBefore, SnapLayoutFlags layoutFlags = {})

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

template<class UserInterface _1>
static BasicSnapLayout<UserInterface> Magnum::Ui::BasicSnapLayout<_1>::child(const BasicAnchor<UserInterface>& parent, const Vector2& nodeSize = {}, NodeFlags nodeFlags = {}, LayoutHandle layoutBefore = LayoutHandle::Null, SnapLayoutFlags layoutFlags = {})

Create a child layout using the default layouter in given user interface.

Like AbstractSnapLayout::child(SnapLayouter&, const AbstractAnchor&, const Vector2&, NodeFlags, LayoutHandle, SnapLayoutFlags) but using the default SnapLayouter instance available through UserInterface::snapLayouter(), and returning a concrete layout instance. Expects that the user interface referenced in parent contains a SnapLayouter instance.

If you have an exising layout instance, there's child(const Vector2&, NodeFlags, LayoutHandle, SnapLayoutFlags) which is equivalent to this function.

template<class UserInterface _1>
static BasicSnapLayout<UserInterface> Magnum::Ui::BasicSnapLayout<_1>::child(const BasicAnchor<UserInterface>& parent, const Vector2& nodeSize, LayoutHandle layoutBefore, SnapLayoutFlags layoutFlags = {})

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

template<class UserInterface _1>
static BasicSnapLayout<UserInterface> Magnum::Ui::BasicSnapLayout<_1>::child(const BasicAnchor<UserInterface>& parent, const Vector2& nodeSize, NodeFlags nodeFlags, SnapLayoutFlags layoutFlags)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

template<class UserInterface _1>
static BasicSnapLayout<UserInterface> Magnum::Ui::BasicSnapLayout<_1>::child(const BasicAnchor<UserInterface>& parent, const Vector2& nodeSize, SnapLayoutFlags layoutFlags)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

template<class UserInterface _1>
static BasicSnapLayout<UserInterface> Magnum::Ui::BasicSnapLayout<_1>::child(const BasicAnchor<UserInterface>& parent, const Vector2& nodeSize, NodeFlags nodeFlags, LayouterDataHandle layoutBefore, SnapLayoutFlags layoutFlags = {})

Create a child layout using the default layouter in given user interface, ordered before given layout assuming the layout belongs to the same layouter.

Like AbstractSnapLayout::child(SnapLayouter&, const AbstractAnchor&, const Vector2&, NodeFlags, LayouterDataHandle, SnapLayoutFlags) but using the default SnapLayouter instance available through UserInterface::snapLayouter(), and returning a concrete layout instance. Expects that the user interface referenced in parent contains a SnapLayouter instance.

If you have an exising layout instance, there's child(const Vector2&, NodeFlags, LayouterDataHandle, SnapLayoutFlags) which is equivalent to this function.

template<class UserInterface _1>
static BasicSnapLayout<UserInterface> Magnum::Ui::BasicSnapLayout<_1>::child(const BasicAnchor<UserInterface>& parent, const Vector2& nodeSize, LayouterDataHandle layoutBefore, SnapLayoutFlags layoutFlags = {})

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

template<class UserInterface _1>
static BasicSnapLayout<UserInterface> Magnum::Ui::BasicSnapLayout<_1>::root(UserInterface& ui, SnapLayouter& layouter, Snaps snap, const Vector2& nodeSize = {}, NodeFlags nodeFlags = {}, SnapLayoutFlags layoutFlags = {})

Create an explicitly snapped root layout.

Like AbstractSnapLayout::root(AbstractUserInterface&, SnapLayouter&, Snaps, const Vector2&, NodeFlags, SnapLayoutFlags) but returning a concrete layout instance. Use root(UserInterface&, Snaps, const Vector2&, NodeFlags, SnapLayoutFlags) to use the default SnapLayouter instance available through UserInterface::snapLayouter().

template<class UserInterface _1>
static BasicSnapLayout<UserInterface> Magnum::Ui::BasicSnapLayout<_1>::root(UserInterface& ui, SnapLayouter& layouter, Snaps snap, const Vector2& nodeSize, SnapLayoutFlags layoutFlags)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

template<class UserInterface _1>
static BasicSnapLayout<UserInterface> Magnum::Ui::BasicSnapLayout<_1>::root(UserInterface& ui, Snaps snap, const Vector2& nodeSize = {}, NodeFlags nodeFlags = {}, SnapLayoutFlags layoutFlags = {})

Create an explicitly snapped root layout using the default layouter in given user interface.

Like AbstractSnapLayout::root(AbstractUserInterface&, SnapLayouter&, Snaps, const Vector2&, NodeFlags, SnapLayoutFlags) but using the default SnapLayouter instance available through UserInterface::snapLayouter(), and returning a concrete layout instance. Expects that ui contains a SnapLayouter instance.

template<class UserInterface _1>
static BasicSnapLayout<UserInterface> Magnum::Ui::BasicSnapLayout<_1>::root(UserInterface& ui, Snaps snap, const Vector2& nodeSize, SnapLayoutFlags layoutFlags)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

template<class UserInterface _1>
static BasicSnapLayout<UserInterface> Magnum::Ui::BasicSnapLayout<_1>::child(SnapLayouter& layouter, Snaps snap, const BasicAnchor<UserInterface>& parent, const Vector2& nodeSize = {}, NodeFlags nodeFlags = {}, SnapLayoutFlags layoutFlags = {})

Create an explicitly snapped child layout.

Like AbstractSnapLayout::child(SnapLayouter&, Snaps, const AbstractAnchor&, const Vector2&, NodeFlags, SnapLayoutFlags) but returning a concrete layout instance. Use child(Snaps, const BasicAnchor<UserInterface>&, const Vector2&, NodeFlags, SnapLayoutFlags) to use the default SnapLayouter instance available through UserInterface::snapLayouter(). If you have an existing layout instance, there's child(Snaps, const Vector2&, NodeFlags, SnapLayoutFlags) which is equivalent to this function.

template<class UserInterface _1>
static BasicSnapLayout<UserInterface> Magnum::Ui::BasicSnapLayout<_1>::child(SnapLayouter& layouter, Snaps snap, const BasicAnchor<UserInterface>& parent, const Vector2& nodeSize, SnapLayoutFlags layoutFlags)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

template<class UserInterface _1>
static BasicSnapLayout<UserInterface> Magnum::Ui::BasicSnapLayout<_1>::child(Snaps snap, const BasicAnchor<UserInterface>& parent, const Vector2& nodeSize = {}, NodeFlags nodeFlags = {}, SnapLayoutFlags layoutFlags = {})

Create an explicitly snapped child layout using the default layouter in given user interface.

Like AbstractSnapLayout::child(SnapLayouter&, Snaps, const AbstractAnchor&, const Vector2&, NodeFlags, SnapLayoutFlags) but using the default SnapLayouter instance available through UserInterface::snapLayouter(), and returning a concrete layout instance. Expects that the user interface referenced in parent contains a SnapLayouter instance.

If you have an existing layout instance, there's child(Snaps, const Vector2&, NodeFlags, SnapLayoutFlags) which is equivalent to this function.

template<class UserInterface _1>
static BasicSnapLayout<UserInterface> Magnum::Ui::BasicSnapLayout<_1>::child(Snaps snap, const BasicAnchor<UserInterface>& parent, const Vector2& nodeSize, SnapLayoutFlags layoutFlags)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

template<class UserInterface _1>
static BasicSnapLayout<UserInterface> Magnum::Ui::BasicSnapLayout<_1>::sibling(SnapLayouter& layouter, Snaps snap, const BasicAnchor<UserInterface>& target, const Vector2& nodeSize = {}, NodeFlags nodeFlags = {}, SnapLayoutFlags layoutFlags = {})

Create an explicitly snapped sibling layout.

Like AbstractSnapLayout::sibling(SnapLayouter&, Snaps, const AbstractAnchor&, const Vector2&, NodeFlags, SnapLayoutFlags) but returning a concrete layout instance. Use sibling(Snaps, const BasicAnchor<UserInterface>&, const Vector2&, NodeFlags, SnapLayoutFlags) to use the default SnapLayouter instance available through UserInterface::snapLayouter(). If you have an existing layout instance, there's sibling(Snaps, const Vector2&, NodeFlags, SnapLayoutFlags) which is equivalent to this function.

template<class UserInterface _1>
static BasicSnapLayout<UserInterface> Magnum::Ui::BasicSnapLayout<_1>::sibling(SnapLayouter& layouter, Snaps snap, const BasicAnchor<UserInterface>& target, const Vector2& nodeSize, SnapLayoutFlags layoutFlags)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

template<class UserInterface _1>
static BasicSnapLayout<UserInterface> Magnum::Ui::BasicSnapLayout<_1>::sibling(Snaps snap, const BasicAnchor<UserInterface>& target, const Vector2& nodeSize = {}, NodeFlags nodeFlags = {}, SnapLayoutFlags layoutFlags = {})

Create an explicitly snapped sibling layout using the default layouter in given user interface.

Like AbstractSnapLayout::sibling(SnapLayouter&, Snaps, const AbstractAnchor&, const Vector2&, NodeFlags, SnapLayoutFlags) but using the default SnapLayouter instance available through UserInterface::snapLayouter(), and returning a concrete layout instance. Expects that the user interface referenced in target contains a SnapLayouter instance.

template<class UserInterface _1>
static BasicSnapLayout<UserInterface> Magnum::Ui::BasicSnapLayout<_1>::sibling(Snaps snap, const BasicAnchor<UserInterface>& target, const Vector2& nodeSize, SnapLayoutFlags layoutFlags)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

template<class UserInterface _1>
Magnum::Ui::BasicSnapLayout<_1>::BasicSnapLayout(SnapLayouter& layouter, const BasicAnchor<UserInterface>& anchor) explicit

Construct with creating or reusing layout on an existing node.

Like AbstractSnapLayout::AbstractSnapLayout(SnapLayouter&, const AbstractAnchor&) but accepting a concrete anchor instance.

template<class UserInterface _1>
Magnum::Ui::BasicSnapLayout<_1>::BasicSnapLayout(const BasicAnchor<UserInterface>& anchor) explicit

Construct with creating or reusing layout on an existing node.

Like AbstractSnapLayout::AbstractSnapLayout(SnapLayouter&, const AbstractAnchor&) but using the default SnapLayouter instance available through UserInterface::snapLayouter() and accepting a concrete anchor instance. Expects that the user interface referenced in anchor contains a SnapLayouter instance.

template<class UserInterface _1>
Magnum::Ui::BasicSnapLayout<_1>::BasicSnapLayout(SnapLayouter& layouter, const BasicAnchor<UserInterface>& anchor, LayoutHandle before, SnapLayoutFlags flags = {}) explicit

Construct a layout on an existing node.

Like AbstractSnapLayout::AbstractSnapLayout(SnapLayouter&, const AbstractAnchor&, LayoutHandle, SnapLayoutFlags) but accepting a concrete anchor instance.

template<class UserInterface _1>
Magnum::Ui::BasicSnapLayout<_1>::BasicSnapLayout(SnapLayouter& layouter, const BasicAnchor<UserInterface>& anchor, SnapLayoutFlags layoutFlags) explicit

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

template<class UserInterface _1>
Magnum::Ui::BasicSnapLayout<_1>::BasicSnapLayout(SnapLayouter& layouter, const BasicAnchor<UserInterface>& anchor, LayouterDataHandle before, SnapLayoutFlags flags = {}) explicit

Construct a layout on an existing node, ordered before given layout assuming the layout belongs to the same layouter.

Like AbstractSnapLayout::AbstractSnapLayout(SnapLayouter&, const AbstractAnchor&, LayouterDataHandle, SnapLayoutFlags) but accepting a concrete anchor instance.

template<class UserInterface _1>
Magnum::Ui::BasicSnapLayout<_1>::BasicSnapLayout(const BasicAnchor<UserInterface>& anchor, LayoutHandle before, SnapLayoutFlags flags = {}) explicit

Construct a layout on an existing node.

Like AbstractSnapLayout::AbstractSnapLayout(SnapLayouter&, const AbstractAnchor&, LayoutHandle, SnapLayoutFlags) but using the default SnapLayouter instance available through UserInterface::snapLayouter() and accepting a concrete anchor instance. Expects that the user interface referenced in anchor contains a SnapLayouter instance.

template<class UserInterface _1>
Magnum::Ui::BasicSnapLayout<_1>::BasicSnapLayout(const BasicAnchor<UserInterface>& anchor, SnapLayoutFlags layoutFlags) explicit

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

template<class UserInterface _1>
Magnum::Ui::BasicSnapLayout<_1>::BasicSnapLayout(const BasicAnchor<UserInterface>& anchor, LayouterDataHandle before, SnapLayoutFlags flags = {}) explicit

Construct a layout on an existing node, ordered before given layout assuming the layout belongs to the same layouter.

Like AbstractSnapLayout::AbstractSnapLayout(SnapLayouter&, const AbstractAnchor&, LayouterDataHandle, SnapLayoutFlags) but using the default SnapLayouter instance available through UserInterface::snapLayouter() and accepting a concrete anchor instance. Expects that the user interface referenced in anchor contains a SnapLayouter instance.

template<class UserInterface _1>
Magnum::Ui::BasicSnapLayout<_1>::BasicSnapLayout(SnapLayouter& layouter, const BasicAnchor<UserInterface>& anchor, Snaps snap, LayoutHandle snapTarget, SnapLayoutFlags flags = {}) explicit

Construct an explicitly snapped layout on an existing node.

Like AbstractSnapLayout::AbstractSnapLayout(SnapLayouter&, const AbstractAnchor&, Snaps, LayoutHandle, SnapLayoutFlags) but accepting a concrete anchor instance.

template<class UserInterface _1>
Magnum::Ui::BasicSnapLayout<_1>::BasicSnapLayout(SnapLayouter& layouter, const BasicAnchor<UserInterface>& anchor, Snaps snap, LayouterDataHandle snapTarget, SnapLayoutFlags flags = {}) explicit

Construct an explicitly snapped layout on an existing node, assuming the target belongs to the same layouter.

Like AbstractSnapLayout::AbstractSnapLayout(SnapLayouter&, const AbstractAnchor&, Snaps, LayouterDataHandle, SnapLayoutFlags) but accepting a concrete anchor instance.

template<class UserInterface _1>
Magnum::Ui::BasicSnapLayout<_1>::BasicSnapLayout(const BasicAnchor<UserInterface>& anchor, Snaps snap, LayoutHandle snapTarget, SnapLayoutFlags flags = {}) explicit

Construct an explicitly snapped layout on an existing node.

Like AbstractSnapLayout::AbstractSnapLayout(SnapLayouter&, const AbstractAnchor&, Snaps, LayoutHandle, SnapLayoutFlags) but using the default SnapLayouter instance available through UserInterface::snapLayouter() and accepting a concrete anchor instance. Expects that the user interface referenced in anchor contains a SnapLayouter instance.

template<class UserInterface _1>
Magnum::Ui::BasicSnapLayout<_1>::BasicSnapLayout(const BasicAnchor<UserInterface>& anchor, Snaps snap, LayouterDataHandle snapTarget, SnapLayoutFlags flags = {}) explicit

Construct an explicitly snapped layout on an existing node, assuming the target belongs to the same layouter.

Like AbstractSnapLayout::AbstractSnapLayout(SnapLayouter&, const AbstractAnchor&, Snaps, LayouterDataHandle, SnapLayoutFlags) but using the default SnapLayouter instance available through UserInterface::snapLayouter() and accepting a concrete anchor instance. Expects that the user interface referenced in anchor contains a SnapLayouter instance.

template<class UserInterface _1>
BasicSnapLayout<UserInterface> Magnum::Ui::BasicSnapLayout<_1>::child(const Vector2& nodeSize = {}, NodeFlags nodeFlags = {}, LayoutHandle layoutBefore = LayoutHandle::Null, SnapLayoutFlags layoutFlags = {})

Create a child layout.

Like AbstractSnapLayout::child(const Vector2&, NodeFlags, LayoutHandle, SnapLayoutFlags) but returning a concrete layout instance.

template<class UserInterface _1>
BasicSnapLayout<UserInterface> Magnum::Ui::BasicSnapLayout<_1>::child(const Vector2& nodeSize, LayoutHandle layoutBefore, SnapLayoutFlags layoutFlags = {})

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

template<class UserInterface _1>
BasicSnapLayout<UserInterface> Magnum::Ui::BasicSnapLayout<_1>::child(const Vector2& nodeSize, NodeFlags nodeFlags, SnapLayoutFlags layoutFlags)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

template<class UserInterface _1>
BasicSnapLayout<UserInterface> Magnum::Ui::BasicSnapLayout<_1>::child(const Vector2& nodeSize, SnapLayoutFlags layoutFlags)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

template<class UserInterface _1>
BasicSnapLayout<UserInterface> Magnum::Ui::BasicSnapLayout<_1>::child(const Vector2& nodeSize, NodeFlags nodeFlags, LayouterDataHandle layoutBefore, SnapLayoutFlags layoutFlags = {})

Create a child layout, ordered before given layout assuming the layout belongs to the same layouter.

Like AbstractSnapLayout::child(const Vector2&, NodeFlags, LayouterDataHandle, SnapLayoutFlags) but returning a concrete layout instance.

template<class UserInterface _1>
BasicSnapLayout<UserInterface> Magnum::Ui::BasicSnapLayout<_1>::child(const Vector2& nodeSize, LayouterDataHandle layoutBefore, SnapLayoutFlags layoutFlags = {})

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

template<class UserInterface _1>
BasicSnapLayout<UserInterface> Magnum::Ui::BasicSnapLayout<_1>::child(Snaps snap, const Vector2& nodeSize = {}, NodeFlags nodeFlags = {}, SnapLayoutFlags layoutFlags = {})

Create an explicitly snapped child layout.

Like AbstractSnapLayout::child(Snaps, const Vector2&, NodeFlags, SnapLayoutFlags) but returning a concrete layout instance.

template<class UserInterface _1>
BasicSnapLayout<UserInterface> Magnum::Ui::BasicSnapLayout<_1>::child(Snaps snap, const Vector2& nodeSize, SnapLayoutFlags layoutFlags)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

template<class UserInterface _1>
BasicSnapLayout<UserInterface> Magnum::Ui::BasicSnapLayout<_1>::sibling(Snaps snap, const Vector2& nodeSize = {}, NodeFlags nodeFlags = {}, SnapLayoutFlags layoutFlags = {})

Create an explicitly snapped sibling layout.

Like AbstractSnapLayout::sibling(Snaps, const Vector2&, NodeFlags, SnapLayoutFlags) but returning a concrete layout instance.

template<class UserInterface _1>
BasicSnapLayout<UserInterface> Magnum::Ui::BasicSnapLayout<_1>::sibling(Snaps snap, const Vector2& nodeSize, SnapLayoutFlags layoutFlags)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.