class new in Git master
#include <Magnum/Ui/SnapLayouter.h>
AbstractSnapLayout Base for SnapLayouter layout creation helpers.
Combines SnapLayouter together with a reference to AbstractUserInterface in order to create AbstractAnchor instances to directly feed into AbstractWidget constructors. Similarly to Anchor and Widget, the BasicSnapLayout template and the SnapLayout typedef then restrict the type to a concrete user interface instance such as UserInterface.
This class is just a transient helper to aid with laying out nodes relative to each other. After they're created, the AbstractSnapLayout instance isn't needed for anything anymore and can be removed. For snapping individual nodes you can use the stateless snap() functions instead.
Derived classes
-
template<class UserInterface>class BasicSnapLayout new in Git master
- Templated base for SnapLayouter layout creation helpers.
Constructors, destructors, conversion operators
- AbstractSnapLayout(AbstractUserInterface& ui, SnapLayouter& layouter, Snaps snapFirst, NodeHandle target, Snaps snapNext) explicit
- Constructor.
- AbstractSnapLayout(const AbstractSnapLayout&) deleted
- Copying is not allowed.
- AbstractSnapLayout(AbstractSnapLayout&&) defaulted noexcept
- Move constructor.
Public functions
- auto operator=(const AbstractSnapLayout&) -> AbstractSnapLayout& deleted
- Copying is not allowed.
- auto operator=(AbstractSnapLayout&&) -> AbstractSnapLayout& defaulted noexcept
- Move assignment.
- auto ui() const -> AbstractUserInterface&
- User interface instance the nodes are created in.
- auto layouter() const -> SnapLayouter&
- Layouter instance.
- auto parent() const -> NodeHandle
- Node to which all created nodes are parented.
- auto snapFirst() const -> Snaps
- How to snap the first layout.
- auto snapNext() const -> Snaps
- How to snap the next layouts.
- auto targetFirst() const -> NodeHandle
- Target node for the first layout.
- auto targetNext() const -> NodeHandle
- Target node for the next layout.
- auto operator()(const Vector2& size, NodeFlags flags = {}) -> AbstractAnchor
- Create a layouted node.
- auto operator()(const Vector2& offset, const Vector2& size, NodeFlags flags = {}) -> AbstractAnchor
- Create a layouted node with custom offset.
Function documentation
Magnum:: Ui:: AbstractSnapLayout:: AbstractSnapLayout(AbstractUserInterface& ui,
SnapLayouter& layouter,
Snaps snapFirst,
NodeHandle target,
Snaps snapNext) explicit
Constructor.
Parameters | |
---|---|
ui | User interface instance |
layouter | Layouter instance |
snapFirst | How to snap the first layout |
target | Target to which to snap the first layout |
snapNext | How to snap the next layouts |
The snapFirst
is used for creating the first ever layout, relative to target
. After that, the following layouts are all snapped to the previous created one according to snapNext
.
Since it makes little sense to layout multiple root nodes relative to each other, the target
is expected to be a valid non-null handle. If snapFirst
snaps inside of the node, the target
is used as a parent of the newly created nodes, if snapFirst
snaps outside of the node, the parent of target
is used as a parent of the newly created nodes, in which case target
is also expected to not be a root node.
Layouting a root node relative to the user interface itself is possible with snap(AbstractUserInterface&, SnapLayouter&, Snaps, const Vector2&, const Vector2&, NodeFlags) and overloads.
NodeHandle Magnum:: Ui:: AbstractSnapLayout:: parent() const
Node to which all created nodes are parented.
Never a NodeHandle::
NodeHandle Magnum:: Ui:: AbstractSnapLayout:: targetFirst() const
Target node for the first layout.
Used as a target for layouting the first node according to snapFirst(). Each subsequent nodes is then targeted to the previously created one, which is exposed in targetNext(). Never a NodeHandle::
NodeHandle Magnum:: Ui:: AbstractSnapLayout:: targetNext() const
Target node for the next layout.
Contains a handle of the latest created node, which is then used as a target for layouting the next node according to snapNext(). If NodeHandle::
AbstractAnchor Magnum:: Ui:: AbstractSnapLayout:: operator()(const Vector2& size,
NodeFlags flags = {})
Create a layouted node.
Parameters | |
---|---|
size | Desired node size |
flags | Flags to create the node with |
Returns | Anchor containing the new node and associated layout |
Creates a node parented to parent() with an associated layout. The size
is ignored in horizontal / vertical direction if the layout is snapped to the whole width / height of the target node. Calls AbstractUserInterface::
AbstractAnchor Magnum:: Ui:: AbstractSnapLayout:: operator()(const Vector2& offset,
const Vector2& size,
NodeFlags flags = {})
Create a layouted node with custom offset.
Compared to operator()(const Vector2&, NodeFlags) the offset
is added to the offset calculated by the layout.