org.layout

Class Layout

java.lang.Object

org.layout.Layout

public final class Layout
extends java.lang.Object

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	Layout.LayoutItem

Field Summary

Fields

Modifier and Type	Field and Description
static int	LAY_ANY a special mask passed to lay_find_item() (currently does not exist, was not ported from oui)
static int	LAY_INVALID_ID
static int	LAY_ITEM_BOX_MASK bit 0-4
static int	LAY_ITEM_BOX_MODEL_MASK bit 0-2
static int	LAY_ITEM_COMPARE_MASK which flag bits will be compared
static int	LAY_ITEM_FIXED_MASK bit 11-12
static int	LAY_ITEM_HFIXED horizontal size has been explicitly set (bit 11)
static int	LAY_ITEM_INSERTED item has been inserted (bit 10)
static int	LAY_ITEM_LAYOUT_MASK bit 5-9
static int	LAY_ITEM_VFIXED vertical size has been explicitly set (bit 12)
static int	LAY_USERMASK these bits, starting at bit 16, can be safely assigned by the application, e.g.

Constructor Summary

Constructors

Constructor and Description
Layout()

Method Summary

Modifier and Type	Method and Description
static void	layAppend(@NotNull LayoutContext ctx, int earlier, int later) lay_append inserts an item as a sibling after another item.
static void	layArrange(@NotNull LayoutContext ctx, int item, int dim)
static void	layCalcSize(@NotNull LayoutContext ctx, int item, int dim)
static void	layClearItemBreak(@NotNull LayoutContext ctx, int item) Performing a layout on items where wrapping is enabled in the parent container can cause flags to be modified during the calculations.
static int	layFirstChild(@NotNull LayoutContext ctx, int id) Get the id of first child of an item, if any.
static float[]	layGetMarginsLTRB(@NotNull LayoutContext ctx, int item, float[] dst) Get the margins that were set by setMargins.
static float[]	layGetRect(@NotNull LayoutContext ctx, int id, float[] dst) Returns the calculated rectangle of an item.
static float	layGetRectHeight(@NotNull LayoutContext ctx, int id)
static float	layGetRectWidth(@NotNull LayoutContext ctx, int id)
static float	layGetRectX(@NotNull LayoutContext ctx, int id)
static float	layGetRectY(@NotNull LayoutContext ctx, int id)
static float	layGetSizeX(@NotNull LayoutContext ctx, int item) Gets the horizontal size of an item that was set with setSize
static float[]	layGetSizeXY(@NotNull LayoutContext ctx, int item, float[] dst) Gets the size of an item that was set with setSize.
static float	layGetSizeY(@NotNull LayoutContext ctx, int item) Gets the vertical size of an item that was set with setSize
static void	layInsert(@NotNull LayoutContext ctx, int parent, int child) Inserts an item into another item, forming a parent - child relationship.
static int	layItem(@NotNull LayoutContext ctx) Create a new item, which can just be thought of as a rectangle.
static int	layItemsCapacity(@NotNull LayoutContext ctx) Returns the number of items the context can hold without performing a reallocation.
static int	layItemsCount(@NotNull LayoutContext ctx) Returns the number of items that have been created in a context.
static int	layLastChild(@NotNull LayoutContext ctx, int parent)
static int	layNextSibling(@NotNull LayoutContext ctx, int id) Get the id of the next sibling of an item, if any.
static void	layPush(@NotNull LayoutContext ctx, int parent, int newChild) Like lay_insert, but puts the new item as the first child in a parent instead of as the last.
static void	layReserveItemsCapacity(@NotNull LayoutContext ctx, int count) Reserve enough heap memory to contain `count` items without needing to reallocate.
static void	layResetContext(@NotNull LayoutContext ctx) Clears all of the items in a context, setting its count to 0.
static void	layRunContext(@NotNull LayoutContext ctx) Performs the layout calculations, starting at the root item (id 0).
static void	layRunItem(@NotNull LayoutContext ctx, int item) Like lay_run_context(), this procedure will run layout calculations -- however, it lets you specify which item you want to start from.
static void	laySetBehave(@NotNull LayoutContext ctx, int item, int flags) Set the flags on an item which determines how it behaves as a child inside of a parent item.
static void	laySetContain(@NotNull LayoutContext ctx, int item, int flags) Set the flags on an item which determines how it behaves as a parent.
static void	laySetMargins(@NotNull LayoutContext ctx, int item, float left, float top, float right, float bottom) Get the margins that were set by lay_set_margins.
static void	laySetSize(@NotNull LayoutContext ctx, int item, float width, float height) Sets the size of an item

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

LAY_INVALID_ID

public static final int LAY_INVALID_ID

See Also:

Constant Field Values

LAY_USERMASK

public static final int LAY_USERMASK

these bits, starting at bit 16, can be safely assigned by the application, e.g. as item types, other event types, drop targets, etc. this is not yet exposed via API functions, you'll need to get/set these by directly accessing item pointers. (In reality we have more free bits than this, TODO) TODO fix int/unsigned size mismatch (clang issues warning for this), should be all bits as 1 instead of INT_MAX

See Also:

Constant Field Values

LAY_ANY

public static final int LAY_ANY

a special mask passed to lay_find_item() (currently does not exist, was not ported from oui)

See Also:

Constant Field Values

LAY_ITEM_BOX_MODEL_MASK

public static final int LAY_ITEM_BOX_MODEL_MASK

bit 0-2

See Also:

Constant Field Values

LAY_ITEM_BOX_MASK

public static final int LAY_ITEM_BOX_MASK

bit 0-4

See Also:

Constant Field Values

LAY_ITEM_LAYOUT_MASK

public static final int LAY_ITEM_LAYOUT_MASK

bit 5-9

See Also:

Constant Field Values

LAY_ITEM_INSERTED

public static final int LAY_ITEM_INSERTED

item has been inserted (bit 10)

See Also:

Constant Field Values

LAY_ITEM_HFIXED

public static final int LAY_ITEM_HFIXED

horizontal size has been explicitly set (bit 11)

See Also:

Constant Field Values

LAY_ITEM_VFIXED

public static final int LAY_ITEM_VFIXED

vertical size has been explicitly set (bit 12)

See Also:

Constant Field Values

LAY_ITEM_FIXED_MASK

public static final int LAY_ITEM_FIXED_MASK

bit 11-12

See Also:

Constant Field Values

LAY_ITEM_COMPARE_MASK

public static final int LAY_ITEM_COMPARE_MASK

which flag bits will be compared

See Also:

Constant Field Values

Constructor Detail

Layout

public Layout()

Method Detail

layReserveItemsCapacity

public static void layReserveItemsCapacity(@NotNull
                                           @NotNull LayoutContext ctx,
                                           int count)

Reserve enough heap memory to contain `count` items without needing to reallocate. The initial lay_init_context() call does not allocate any heap memory, so if you init a context and then call this once with a large enough number for the number of items you'll create, there will not be any further reallocations.

layResetContext

public static void layResetContext(@NotNull
                                   @NotNull LayoutContext ctx)

Clears all of the items in a context, setting its count to 0. Use this when you want to re-declare your layout starting from the root item. This does not free any memory or perform allocations. It's safe to use the context again after calling this. You should probably use this instead of init/destroy if you are recalculating your layouts in a loop.

layRunContext

public static void layRunContext(@NotNull
                                 @NotNull LayoutContext ctx)

Performs the layout calculations, starting at the root item (id 0). After calling this, you can use lay_get_rect() to query for an item's calculated rectangle. If you use procedures such as lay_append() or lay_insert() after calling this, your calculated data may become invalid if a reallocation occurs. You should prefer to recreate your items starting from the root instead of doing fine-grained updates to the existing context. However, it's safe to use lay_set_size on an item, and then re-run lay_run_context. This might be useful if you are doing a resizing animation on items in a layout without any contents changing.

layRunItem

public static void layRunItem(@NotNull
                              @NotNull LayoutContext ctx,
                              int item)

Like lay_run_context(), this procedure will run layout calculations -- however, it lets you specify which item you want to start from. lay_run_context() always starts with item 0, the first item, as the root. Running the layout calculations from a specific item is useful if you want need to iteratively re-run parts of your layout hierarchy, or if you are only interested in updating certain subsets of it. Be careful when using this -- it's easy to generated bad output if the parent items haven't yet had their output rectangles calculated, or if they've been invalidated (e.g. due to re-allocation).

layClearItemBreak

public static void layClearItemBreak(@NotNull
                                     @NotNull LayoutContext ctx,
                                     int item)

Performing a layout on items where wrapping is enabled in the parent container can cause flags to be modified during the calculations. If you plan to call lay_run_context or lay_run_item multiple times without calling lay_reset, and if you have a container that uses wrapping, and if the width or height of the container may have changed, you should call lay_clear_item_break on all of the children of a container before calling lay_run_context or lay_run_item again. If you don't, the layout calculations may perform unnecessary wrapping. This requirement may be changed in the future. Calling this will also reset any manually-specified breaking. You will need to set the manual breaking again, or simply not call this on any items that you know you wanted to break manually. If you clear your context every time you calculate your layout, or if you don't use wrapping, you don't need to call this.

layItemsCount

public static int layItemsCount(@NotNull
                                @NotNull LayoutContext ctx)

Returns the number of items that have been created in a context.

layItemsCapacity

public static int layItemsCapacity(@NotNull
                                   @NotNull LayoutContext ctx)

Returns the number of items the context can hold without performing a reallocation.

layItem

public static int layItem(@NotNull
                          @NotNull LayoutContext ctx)

Create a new item, which can just be thought of as a rectangle. Returns the id (handle) used to identify the item.

layLastChild

public static int layLastChild(@NotNull
                               @NotNull LayoutContext ctx,
                               int parent)

layInsert

public static void layInsert(@NotNull
                             @NotNull LayoutContext ctx,
                             int parent,
                             int child)

Inserts an item into another item, forming a parent - child relationship. An item can contain any number of child items. Items inserted into a parent are put at the end of the ordering, after any existing siblings.

layAppend

public static void layAppend(@NotNull
                             @NotNull LayoutContext ctx,
                             int earlier,
                             int later)

lay_append inserts an item as a sibling after another item. This allows inserting an item into the middle of an existing list of items within a parent. It's also more efficient than repeatedly using lay_insert(ctx, parent, new_child) in a loop to create a list of items in a parent, because it does not need to traverse the parent's children each time. So if you're creating a long list of children inside of a parent, you might prefer to use this after using lay_insert to insert the first child.

layPush

public static void layPush(@NotNull
                           @NotNull LayoutContext ctx,
                           int parent,
                           int newChild)

Like lay_insert, but puts the new item as the first child in a parent instead of as the last.

laySetSize

public static void laySetSize(@NotNull
                              @NotNull LayoutContext ctx,
                              int item,
                              float width,
                              float height)

Sets the size of an item

layGetSizeX

public static float layGetSizeX(@NotNull
                                @NotNull LayoutContext ctx,
                                int item)

Gets the horizontal size of an item that was set with setSize

layGetSizeY

public static float layGetSizeY(@NotNull
                                @NotNull LayoutContext ctx,
                                int item)

Gets the vertical size of an item that was set with setSize

layGetSizeXY

public static float[] layGetSizeXY(@NotNull
                                   @NotNull LayoutContext ctx,
                                   int item,
                                   float[] dst)

Gets the size of an item that was set with setSize. Output will be written to provided array, which should have size of at least 2 elements

laySetBehave

public static void laySetBehave(@NotNull
                                @NotNull LayoutContext ctx,
                                int item,
                                int flags)

Set the flags on an item which determines how it behaves as a child inside of a parent item. For example, setting LAY_VFILL will make an item try to fill up all available vertical space inside of its parent.

laySetContain

public static void laySetContain(@NotNull
                                 @NotNull LayoutContext ctx,
                                 int item,
                                 int flags)

Set the flags on an item which determines how it behaves as a parent. For example, setting LAY_COLUMN will make an item behave as if it were a column -- it will lay out its children vertically.

laySetMargins

public static void laySetMargins(@NotNull
                                 @NotNull LayoutContext ctx,
                                 int item,
                                 float left,
                                 float top,
                                 float right,
                                 float bottom)

Get the margins that were set by lay_set_margins. The _ltrb version writes the output values to the specified addresses instead of returning the values in a lay_vec4. l: left, t: top, r: right, b: bottom

layGetMarginsLTRB

public static float[] layGetMarginsLTRB(@NotNull
                                        @NotNull LayoutContext ctx,
                                        int item,
                                        float[] dst)

Get the margins that were set by setMargins. Output will be written to provided array, which should have size of at least 4 elements

layFirstChild

public static int layFirstChild(@NotNull
                                @NotNull LayoutContext ctx,
                                int id)

Get the id of first child of an item, if any. Returns LAY_INVALID_ID if there is no child.

layNextSibling

public static int layNextSibling(@NotNull
                                 @NotNull LayoutContext ctx,
                                 int id)

Get the id of the next sibling of an item, if any. Returns LAY_INVALID_ID if there is no next sibling.

layGetRectX

public static float layGetRectX(@NotNull
                                @NotNull LayoutContext ctx,
                                int id)

layGetRectY

public static float layGetRectY(@NotNull
                                @NotNull LayoutContext ctx,
                                int id)

layGetRectWidth

public static float layGetRectWidth(@NotNull
                                    @NotNull LayoutContext ctx,
                                    int id)

layGetRectHeight

public static float layGetRectHeight(@NotNull
                                     @NotNull LayoutContext ctx,
                                     int id)

layGetRect

public static float[] layGetRect(@NotNull
                                 @NotNull LayoutContext ctx,
                                 int id,
                                 float[] dst)

Returns the calculated rectangle of an item. This is only valid after calling lay_run_context and before any other reallocation occurs. Otherwise, the result will be undefined. Output will be written to given array which should have a size of at least 4 elements. The array components are: 0: x starting position, 1: y starting position 2: width, 3: height

layCalcSize

public static void layCalcSize(@NotNull
                               @NotNull LayoutContext ctx,
                               int item,
                               int dim)

layArrange

public static void layArrange(@NotNull
                              @NotNull LayoutContext ctx,
                              int item,
                              int dim)