Layout (layout-java 1.2.0 API)

java.lang.Object
- io.github.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

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()

Constructors
Constructor and Description
`Layout()`

Method Summary

All Methods Static Methods Concrete Methods
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`	`layGetGrow(@NotNull LayoutContext ctx, int item)` Gets the grow factor of an item which was set with setGrow
`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`	`laySetGrow(@NotNull LayoutContext ctx, int item, float grow)` Set flex grow factor of an item.
`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.
  - laySetGrow
```
public static void laySetGrow(@NotNull
                              @NotNull LayoutContext ctx,
                              int item,
                              float grow)
```
    Set flex grow factor of an item. When combined with HFILL/VFILL/FILL grow factor defines weight of an item when parent distributes free space between children. For example, if all items have grow factor of 1, the remaining space in the container will be distributed equally to all children. If one the children has grow factor of 2, that child will take up twice as much of the space as either one of the others. Grow factor of 0 (by default) will be interpreted as 1. Negative values are invalid.
  - layGetGrow
```
public static float layGetGrow(@NotNull
                               @NotNull LayoutContext ctx,
                               int item)
```
    Gets the grow factor of an item which was set with setGrow
  - 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)
```

Class Layout

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

LAY_INVALID_ID

LAY_USERMASK

LAY_ANY

LAY_ITEM_BOX_MODEL_MASK

LAY_ITEM_BOX_MASK

LAY_ITEM_LAYOUT_MASK

LAY_ITEM_INSERTED

LAY_ITEM_HFIXED

LAY_ITEM_VFIXED

LAY_ITEM_FIXED_MASK

LAY_ITEM_COMPARE_MASK

Constructor Detail

Layout

Method Detail

layReserveItemsCapacity

layResetContext

layRunContext

layRunItem

layClearItemBreak

layItemsCount

layItemsCapacity

layItem

layLastChild

layInsert

layAppend

layPush

laySetGrow

layGetGrow

laySetSize

layGetSizeX

layGetSizeY

layGetSizeXY

laySetBehave

laySetContain

laySetMargins

layGetMarginsLTRB

layFirstChild

layNextSibling

layGetRectX

layGetRectY

layGetRectWidth

layGetRectHeight

layGetRect

layCalcSize

layArrange