Merge branch 'main' of ps.run:autorec

[autorec] / src / layout.h

#ifndef LAY_INCLUDE_HEADER\r
#define LAY_INCLUDE_HEADER\r
\r
// Do this:\r
//\r
//   #define LAY_IMPLEMENTATION\r
//\r
// in exactly one C or C++ file in your project before you include layout.h.\r
// Your includes should look like this:\r
//\r
//   #include ...\r
//   #include ...\r
//   #define LAY_IMPLEMENTATION\r
//   #include "layout.h"\r
//\r
// All other files in your project should not define LAY_IMPLEMENTATION.\r
\r
#include <stdint.h>\r
\r
#ifndef LAY_EXPORT\r
#define LAY_EXPORT extern\r
#endif\r
\r
// Users of this library can define LAY_ASSERT if they would like to use an\r
// assert other than the one from assert.h.\r
#ifndef LAY_ASSERT\r
#include <assert.h>\r
#define LAY_ASSERT assert\r
#endif\r
\r
// 'static inline' for things we always want inlined -- the compiler should not\r
// even have to consider not inlining these.\r
#if defined(__GNUC__) || defined(__clang__)\r
#define LAY_STATIC_INLINE __attribute__((always_inline)) static inline\r
#elif defined(_MSC_VER)\r
#define LAY_STATIC_INLINE __forceinline static\r
#else\r
#define LAY_STATIC_INLINE inline static\r
#endif\r
\r
typedef uint32_t lay_id;\r
#if LAY_FLOAT == 1\r
typedef float lay_scalar;\r
#else\r
typedef int16_t lay_scalar;\r
#endif\r
\r
#define LAY_INVALID_ID UINT32_MAX\r
\r
// GCC and Clang allow us to create vectors based on a type with the\r
// vector_size extension. This will allow us to access individual components of\r
// the vector via indexing operations.\r
#if defined(__GNUC__) || defined(__clang__)\r
\r
// Using floats for coordinates takes up more space than using int16. 128 bits\r
// for a four-component vector.\r
#ifdef LAY_FLOAT\r
typedef float lay_vec4 __attribute__ ((__vector_size__ (16), aligned(4)));\r
typedef float lay_vec2 __attribute__ ((__vector_size__ (8), aligned(4)));\r
// Integer version uses 64 bits for a four-component vector.\r
#else\r
typedef int16_t lay_vec4 __attribute__ ((__vector_size__ (8), aligned(2)));\r
typedef int16_t lay_vec2 __attribute__ ((__vector_size__ (4), aligned(2)));\r
#endif // LAY_FLOAT\r
\r
// Note that we're not actually going to make any explicit use of any\r
// platform's SIMD instructions -- we're just using the vector extension for\r
// more convenient syntax. Therefore, we can specify more relaxed alignment\r
// requirements. See the end of this file for some notes about this.\r
\r
// MSVC doesn't have the vetor_size attribute, but we want convenient indexing\r
// operators for our layout logic code. Therefore, we force C++ compilation in\r
// MSVC, and use C++ operator overloading.\r
#elif defined(_MSC_VER)\r
struct lay_vec4 {\r
    lay_scalar xyzw[4];\r
    const lay_scalar& operator[](int index) const\r
    { return xyzw[index]; }\r
    lay_scalar& operator[](int index)\r
    { return xyzw[index]; }\r
};\r
struct lay_vec2 {\r
    lay_scalar xy[2];\r
    const lay_scalar& operator[](int index) const\r
    { return xy[index]; }\r
    lay_scalar& operator[](int index)\r
    { return xy[index]; }\r
};\r
#endif // __GNUC__/__clang__ or _MSC_VER\r
\r
typedef struct lay_item_t {\r
    uint32_t flags;\r
    lay_id first_child;\r
    lay_id next_sibling;\r
    lay_vec4 margins;\r
    lay_vec2 size;\r
} lay_item_t;\r
\r
typedef struct lay_context {\r
    lay_item_t *items;\r
    lay_vec4 *rects;\r
    lay_id capacity;\r
    lay_id count;\r
} lay_context;\r
\r
// Container flags to pass to lay_set_container()\r
typedef enum lay_box_flags {\r
    // flex-direction (bit 0+1)\r
\r
    // left to right\r
    LAY_ROW = 0x002,\r
    // top to bottom\r
    LAY_COLUMN = 0x003,\r
\r
    // model (bit 1)\r
\r
    // free layout\r
    LAY_LAYOUT = 0x000,\r
    // flex model\r
    LAY_FLEX = 0x002,\r
\r
    // flex-wrap (bit 2)\r
\r
    // single-line\r
    LAY_NOWRAP = 0x000,\r
    // multi-line, wrap left to right\r
    LAY_WRAP = 0x004,\r
\r
\r
    // justify-content (start, end, center, space-between)\r
    // at start of row/column\r
    LAY_START = 0x008,\r
    // at center of row/column\r
    LAY_MIDDLE = 0x000,\r
    // at end of row/column\r
    LAY_END = 0x010,\r
    // insert spacing to stretch across whole row/column\r
    LAY_JUSTIFY = 0x018\r
\r
    // align-items\r
    // can be implemented by putting a flex container in a layout container,\r
    // then using LAY_TOP, LAY_BOTTOM, LAY_VFILL, LAY_VCENTER, etc.\r
    // FILL is equivalent to stretch/grow\r
\r
    // align-content (start, end, center, stretch)\r
    // can be implemented by putting a flex container in a layout container,\r
    // then using LAY_TOP, LAY_BOTTOM, LAY_VFILL, LAY_VCENTER, etc.\r
    // FILL is equivalent to stretch; space-between is not supported.\r
} lay_box_flags;\r
\r
// child layout flags to pass to lay_set_behave()\r
typedef enum lay_layout_flags {\r
    // attachments (bit 5-8)\r
    // fully valid when parent uses LAY_LAYOUT model\r
    // partially valid when in LAY_FLEX model\r
\r
    // anchor to left item or left side of parent\r
    LAY_LEFT = 0x020,\r
    // anchor to top item or top side of parent\r
    LAY_TOP = 0x040,\r
    // anchor to right item or right side of parent\r
    LAY_RIGHT = 0x080,\r
    // anchor to bottom item or bottom side of parent\r
    LAY_BOTTOM = 0x100,\r
    // anchor to both left and right item or parent borders\r
    LAY_HFILL = 0x0a0,\r
    // anchor to both top and bottom item or parent borders\r
    LAY_VFILL = 0x140,\r
    // center horizontally, with left margin as offset\r
    LAY_HCENTER = 0x000,\r
    // center vertically, with top margin as offset\r
    LAY_VCENTER = 0x000,\r
    // center in both directions, with left/top margin as offset\r
    LAY_CENTER = 0x000,\r
    // anchor to all four directions\r
    LAY_FILL = 0x1e0,\r
    // When in a wrapping container, put this element on a new line. Wrapping\r
    // layout code auto-inserts LAY_BREAK flags as needed. See GitHub issues for\r
    // TODO related to this.\r
    //\r
    // Drawing routines can read this via item pointers as needed after\r
    // performing layout calculations.\r
    LAY_BREAK = 0x200\r
} lay_layout_flags;\r
\r
enum {\r
    // these bits, starting at bit 16, can be safely assigned by the\r
    // application, e.g. as item types, other event types, drop targets, etc.\r
    // this is not yet exposed via API functions, you'll need to get/set these\r
    // by directly accessing item pointers.\r
    //\r
    // (In reality we have more free bits than this, TODO)\r
    //\r
    // TODO fix int/unsigned size mismatch (clang issues warning for this),\r
    // should be all bits as 1 instead of INT_MAX\r
    LAY_USERMASK = 0x7fff0000,\r
\r
    // a special mask passed to lay_find_item() (currently does not exist, was\r
    // not ported from oui)\r
    LAY_ANY = 0x7fffffff\r
};\r
\r
enum {\r
    // extra item flags\r
\r
    // bit 0-2\r
    LAY_ITEM_BOX_MODEL_MASK = 0x000007,\r
    // bit 0-4\r
    LAY_ITEM_BOX_MASK       = 0x00001F,\r
    // bit 5-9\r
    LAY_ITEM_LAYOUT_MASK = 0x0003E0,\r
    // item has been inserted (bit 10)\r
    LAY_ITEM_INSERTED   = 0x400,\r
    // horizontal size has been explicitly set (bit 11)\r
    LAY_ITEM_HFIXED      = 0x800,\r
    // vertical size has been explicitly set (bit 12)\r
    LAY_ITEM_VFIXED      = 0x1000,\r
    // bit 11-12\r
    LAY_ITEM_FIXED_MASK  = LAY_ITEM_HFIXED | LAY_ITEM_VFIXED,\r
\r
    // which flag bits will be compared\r
    LAY_ITEM_COMPARE_MASK = LAY_ITEM_BOX_MODEL_MASK\r
        | (LAY_ITEM_LAYOUT_MASK & ~LAY_BREAK)\r
        | LAY_USERMASK\r
};\r
\r
LAY_STATIC_INLINE lay_vec4 lay_vec4_xyzw(lay_scalar x, lay_scalar y, lay_scalar z, lay_scalar w)\r
{\r
#if (defined(__GNUC__) || defined(__clang__)) && !defined(__cplusplus)\r
    return (lay_vec4){x, y, z, w};\r
#else\r
    lay_vec4 result;\r
    result[0] = x;\r
    result[1] = y;\r
    result[2] = z;\r
    result[3] = w;\r
    return result;\r
#endif\r
}\r
\r
// Call this on a context before using it. You must also call this on a context\r
// if you would like to use it again after calling lay_destroy_context() on it.\r
LAY_EXPORT void lay_init_context(lay_context *ctx);\r
\r
// Reserve enough heap memory to contain `count` items without needing to\r
// reallocate. The initial lay_init_context() call does not allocate any heap\r
// memory, so if you init a context and then call this once with a large enough\r
// number for the number of items you'll create, there will not be any further\r
// reallocations.\r
LAY_EXPORT void lay_reserve_items_capacity(lay_context *ctx, lay_id count);\r
\r
// Frees any heap allocated memory used by a context. Don't call this on a\r
// context that did not have lay_init_context() call on it. To reuse a context\r
// after destroying it, you will need to call lay_init_context() on it again.\r
LAY_EXPORT void lay_destroy_context(lay_context *ctx);\r
\r
// Clears all of the items in a context, setting its count to 0. Use this when\r
// you want to re-declare your layout starting from the root item. This does not\r
// free any memory or perform allocations. It's safe to use the context again\r
// after calling this. You should probably use this instead of init/destroy if\r
// you are recalculating your layouts in a loop.\r
LAY_EXPORT void lay_reset_context(lay_context *ctx);\r
\r
// Performs the layout calculations, starting at the root item (id 0). After\r
// calling this, you can use lay_get_rect() to query for an item's calculated\r
// rectangle. If you use procedures such as lay_append() or lay_insert() after\r
// calling this, your calculated data may become invalid if a reallocation\r
// occurs.\r
//\r
// You should prefer to recreate your items starting from the root instead of\r
// doing fine-grained updates to the existing context.\r
//\r
// However, it's safe to use lay_set_size on an item, and then re-run\r
// lay_run_context. This might be useful if you are doing a resizing animation\r
// on items in a layout without any contents changing.\r
LAY_EXPORT void lay_run_context(lay_context *ctx);\r
\r
// Like lay_run_context(), this procedure will run layout calculations --\r
// however, it lets you specify which item you want to start from.\r
// lay_run_context() always starts with item 0, the first item, as the root.\r
// Running the layout calculations from a specific item is useful if you want\r
// need to iteratively re-run parts of your layout hierarchy, or if you are only\r
// interested in updating certain subsets of it. Be careful when using this --\r
// it's easy to generated bad output if the parent items haven't yet had their\r
// output rectangles calculated, or if they've been invalidated (e.g. due to\r
// re-allocation).\r
LAY_EXPORT void lay_run_item(lay_context *ctx, lay_id item);\r
\r
// Performing a layout on items where wrapping is enabled in the parent\r
// container can cause flags to be modified during the calculations. If you plan\r
// to call lay_run_context or lay_run_item multiple times without calling\r
// lay_reset, and if you have a container that uses wrapping, and if the width\r
// or height of the container may have changed, you should call\r
// lay_clear_item_break on all of the children of a container before calling\r
// lay_run_context or lay_run_item again. If you don't, the layout calculations\r
// may perform unnecessary wrapping.\r
//\r
// This requirement may be changed in the future.\r
//\r
// Calling this will also reset any manually-specified breaking. You will need\r
// to set the manual breaking again, or simply not call this on any items that\r
// you know you wanted to break manually.\r
//\r
// If you clear your context every time you calculate your layout, or if you\r
// don't use wrapping, you don't need to call this.\r
LAY_EXPORT void lay_clear_item_break(lay_context *ctx, lay_id item);\r
\r
// Returns the number of items that have been created in a context.\r
LAY_EXPORT lay_id lay_items_count(lay_context *ctx);\r
\r
// Returns the number of items the context can hold without performing a\r
// reallocation.\r
LAY_EXPORT lay_id lay_items_capacity(lay_context *ctx);\r
\r
// Create a new item, which can just be thought of as a rectangle. Returns the\r
// id (handle) used to identify the item.\r
LAY_EXPORT lay_id lay_item(lay_context *ctx);\r
\r
// Inserts an item into another item, forming a parent - child relationship. An\r
// item can contain any number of child items. Items inserted into a parent are\r
// put at the end of the ordering, after any existing siblings.\r
LAY_EXPORT void lay_insert(lay_context *ctx, lay_id parent, lay_id child);\r
\r
// lay_append inserts an item as a sibling after another item. This allows\r
// inserting an item into the middle of an existing list of items within a\r
// parent. It's also more efficient than repeatedly using lay_insert(ctx,\r
// parent, new_child) in a loop to create a list of items in a parent, because\r
// it does not need to traverse the parent's children each time. So if you're\r
// creating a long list of children inside of a parent, you might prefer to use\r
// this after using lay_insert to insert the first child.\r
LAY_EXPORT void lay_append(lay_context *ctx, lay_id earlier, lay_id later);\r
\r
// Like lay_insert, but puts the new item as the first child in a parent instead\r
// of as the last.\r
LAY_EXPORT void lay_push(lay_context *ctx, lay_id parent, lay_id child);\r
\r
// Gets the size that was set with lay_set_size or lay_set_size_xy. The _xy\r
// version writes the output values to the specified addresses instead of\r
// returning the values in a lay_vec2.\r
LAY_EXPORT lay_vec2 lay_get_size(lay_context *ctx, lay_id item);\r
LAY_EXPORT void lay_get_size_xy(lay_context *ctx, lay_id item, lay_scalar *x, lay_scalar *y);\r
\r
// Sets the size of an item. The _xy version passes the width and height as\r
// separate arguments, but functions the same.\r
LAY_EXPORT void lay_set_size(lay_context *ctx, lay_id item, lay_vec2 size);\r
LAY_EXPORT void lay_set_size_xy(lay_context *ctx, lay_id item, lay_scalar width, lay_scalar height);\r
\r
// Set the flags on an item which determines how it behaves as a parent. For\r
// example, setting LAY_COLUMN will make an item behave as if it were a column\r
// -- it will lay out its children vertically.\r
LAY_EXPORT void lay_set_contain(lay_context *ctx, lay_id item, uint32_t flags);\r
\r
// Set the flags on an item which determines how it behaves as a child inside of\r
// a parent item. For example, setting LAY_VFILL will make an item try to fill\r
// up all available vertical space inside of its parent.\r
LAY_EXPORT void lay_set_behave(lay_context *ctx, lay_id item, uint32_t flags);\r
\r
// Get the margins that were set by lay_set_margins. The _ltrb version writes\r
// the output values to the specified addresses instead of returning the values\r
// in a lay_vec4.\r
// l: left, t: top, r: right, b: bottom\r
LAY_EXPORT lay_vec4 lay_get_margins(lay_context *ctx, lay_id item);\r
LAY_EXPORT void lay_get_margins_ltrb(lay_context *ctx, lay_id item, lay_scalar *l, lay_scalar *t, lay_scalar *r, lay_scalar *b);\r
\r
// Set the margins on an item. The components of the vector are:\r
// 0: left, 1: top, 2: right, 3: bottom.\r
LAY_EXPORT void lay_set_margins(lay_context *ctx, lay_id item, lay_vec4 ltrb);\r
\r
// Same as lay_set_margins, but the components are passed as separate arguments\r
// (left, top, right, bottom).\r
LAY_EXPORT void lay_set_margins_ltrb(lay_context *ctx, lay_id item, lay_scalar l, lay_scalar t, lay_scalar r, lay_scalar b);\r
\r
// Get the pointer to an item in the buffer by its id. Don't keep this around --\r
// it will become invalid as soon as any reallocation occurs. Just store the id\r
// instead (it's smaller, anyway, and the lookup cost will be nothing.)\r
LAY_STATIC_INLINE lay_item_t *lay_get_item(const lay_context *ctx, lay_id id)\r
{\r
    LAY_ASSERT(id != LAY_INVALID_ID && id < ctx->count);\r
    return ctx->items + id;\r
}\r
\r
// Get the id of first child of an item, if any. Returns LAY_INVALID_ID if there\r
// is no child.\r
LAY_STATIC_INLINE lay_id lay_first_child(const lay_context *ctx, lay_id id)\r
{\r
    const lay_item_t *pitem = lay_get_item(ctx, id);\r
    return pitem->first_child;\r
}\r
\r
// Get the id of the next sibling of an item, if any. Returns LAY_INVALID_ID if\r
// there is no next sibling.\r
LAY_STATIC_INLINE lay_id lay_next_sibling(const lay_context *ctx, lay_id id)\r
{\r
    const lay_item_t *pitem = lay_get_item(ctx, id);\r
    return pitem->next_sibling;\r
}\r
\r
// Returns the calculated rectangle of an item. This is only valid after calling\r
// lay_run_context and before any other reallocation occurs. Otherwise, the\r
// result will be undefined. The vector components are:\r
// 0: x starting position, 1: y starting position\r
// 2: width, 3: height\r
LAY_STATIC_INLINE lay_vec4 lay_get_rect(const lay_context *ctx, lay_id id)\r
{\r
    LAY_ASSERT(id != LAY_INVALID_ID && id < ctx->count);\r
    return ctx->rects[id];\r
}\r
\r
// The same as lay_get_rect, but writes the x,y positions and width,height\r
// values to the specified addresses instead of returning them in a lay_vec4.\r
LAY_STATIC_INLINE void lay_get_rect_xywh(\r
        const lay_context *ctx, lay_id id,\r
        lay_scalar *x, lay_scalar *y, lay_scalar *width, lay_scalar *height)\r
{\r
    LAY_ASSERT(id != LAY_INVALID_ID && id < ctx->count);\r
    lay_vec4 rect = ctx->rects[id];\r
    *x = rect[0];\r
    *y = rect[1];\r
    *width = rect[2];\r
    *height = rect[3];\r
}\r
\r
#undef LAY_EXPORT\r
#undef LAY_STATIC_INLINE\r
\r
#endif // LAY_INCLUDE_HEADER\r
\r
// Notes about the use of vector_size merely for syntax convenience:\r
//\r
// The current layout calculation procedures are not written in a way that\r
// would benefit from SIMD instruction usage.\r
//\r
// (Passing 128-bit float4 vectors using __vectorcall *might* get you some\r
// small benefit in very specific situations, but is unlikely to be worth the\r
// hassle. And I believe this would only be needed if you compiled the library\r
// in a way where the compiler was prevented from using inlining when copying\r
// rectangle/size data.)\r
//\r
// I might go back in the future and just use regular struct-wrapped arrays.\r
// I'm not sure if relying the vector thing in GCC/clang and then using C++\r
// operator overloading in MSVC is worth the annoyance of saving a couple of\r
// extra characters on each array access in the implementation code.\r
\r
#ifdef LAY_IMPLEMENTATION\r
\r
#include <stddef.h>\r
#include <stdbool.h>\r
\r
// Users of this library can define LAY_REALLOC to use a custom (re)allocator\r
// instead of stdlib's realloc. It should have the same behavior as realloc --\r
// first parameter type is a void pointer, and its value is either a null\r
// pointer or an existing pointer. The second parameter is a size_t of the new\r
// desired size. The buffer contents should be preserved across reallocations.\r
//\r
// And, if you define LAY_REALLOC, you will also need to define LAY_FREE, which\r
// should have the same behavior as free.\r
#ifndef LAY_REALLOC\r
#include <stdlib.h>\r
#define LAY_REALLOC(_block, _size) realloc(_block, _size)\r
#define LAY_FREE(_block) free(_block)\r
#endif\r
\r
// Like the LAY_REALLOC define, LAY_MEMSET can be used for a custom memset.\r
// Otherwise, the memset from string.h will be used.\r
#ifndef LAY_MEMSET\r
#include <string.h>\r
#define LAY_MEMSET(_dst, _val, _size) memset(_dst, _val, _size)\r
#endif\r
\r
#if defined(__GNUC__) || defined(__clang__)\r
#define LAY_FORCE_INLINE __attribute__((always_inline)) inline\r
#ifdef __cplusplus\r
#define LAY_RESTRICT __restrict\r
#else\r
#define LAY_RESTRICT restrict\r
#endif // __cplusplus\r
#elif defined(_MSC_VER)\r
#define LAY_FORCE_INLINE __forceinline\r
#define LAY_RESTRICT __restrict\r
#else\r
#define LAY_FORCE_INLINE inline\r
#ifdef __cplusplus\r
#define LAY_RESTRICT\r
#else\r
#define LAY_RESTRICT restrict\r
#endif // __cplusplus\r
#endif\r
\r
// Useful math utilities\r
static LAY_FORCE_INLINE lay_scalar lay_scalar_max(lay_scalar a, lay_scalar b)\r
{ return a > b ? a : b; }\r
static LAY_FORCE_INLINE lay_scalar lay_scalar_min(lay_scalar a, lay_scalar b)\r
{ return a < b ? a : b; }\r
static LAY_FORCE_INLINE float lay_float_max(float a, float b)\r
{ return a > b ? a : b; }\r
static LAY_FORCE_INLINE float lay_float_min(float a, float b)\r
{ return a < b ? a : b; }\r
\r
void lay_init_context(lay_context *ctx)\r
{\r
    ctx->capacity = 0;\r
    ctx->count = 0;\r
    ctx->items = NULL;\r
    ctx->rects = NULL;\r
}\r
\r
void lay_reserve_items_capacity(lay_context *ctx, lay_id count)\r
{\r
    if (count >= ctx->capacity) {\r
        ctx->capacity = count;\r
        const size_t item_size = sizeof(lay_item_t) + sizeof(lay_vec4);\r
        ctx->items = (lay_item_t*)LAY_REALLOC(ctx->items, ctx->capacity * item_size);\r
        const lay_item_t *past_last = ctx->items + ctx->capacity;\r
        ctx->rects = (lay_vec4*)past_last;\r
    }\r
}\r
\r
void lay_destroy_context(lay_context *ctx)\r
{\r
    if (ctx->items != NULL) {\r
        LAY_FREE(ctx->items);\r
        ctx->items = NULL;\r
        ctx->rects = NULL;\r
    }\r
}\r
\r
void lay_reset_context(lay_context *ctx)\r
{ ctx->count = 0; }\r
\r
static void lay_calc_size(lay_context *ctx, lay_id item, int dim);\r
static void lay_arrange(lay_context *ctx, lay_id item, int dim);\r
\r
void lay_run_context(lay_context *ctx)\r
{\r
    LAY_ASSERT(ctx != NULL);\r
\r
    if (ctx->count > 0) {\r
        lay_run_item(ctx, 0);\r
    }\r
}\r
\r
void lay_run_item(lay_context *ctx, lay_id item)\r
{\r
    LAY_ASSERT(ctx != NULL);\r
\r
    lay_calc_size(ctx, item, 0);\r
    lay_arrange(ctx, item, 0);\r
    lay_calc_size(ctx, item, 1);\r
    lay_arrange(ctx, item, 1);\r
}\r
\r
// Alternatively, we could use a flag bit to indicate whether an item's children\r
// have already been wrapped and may need re-wrapping. If we do that, in the\r
// future, this would become deprecated and we could make it a no-op.\r
\r
void lay_clear_item_break(lay_context *ctx, lay_id item)\r
{\r
    LAY_ASSERT(ctx != NULL);\r
    lay_item_t *pitem = lay_get_item(ctx, item);\r
    pitem->flags = pitem->flags & ~(uint32_t)LAY_BREAK;\r
}\r
\r
lay_id lay_items_count(lay_context *ctx)\r
{\r
    LAY_ASSERT(ctx != NULL);\r
    return ctx->count;\r
}\r
\r
lay_id lay_items_capacity(lay_context *ctx)\r
{\r
    LAY_ASSERT(ctx != NULL);\r
    return ctx->capacity;\r
}\r
\r
lay_id lay_item(lay_context *ctx)\r
{\r
    lay_id idx = ctx->count++;\r
\r
    if (idx >= ctx->capacity) {\r
        ctx->capacity = ctx->capacity < 1 ? 32 : (ctx->capacity * 4);\r
        const size_t item_size = sizeof(lay_item_t) + sizeof(lay_vec4);\r
        ctx->items = (lay_item_t*)LAY_REALLOC(ctx->items, ctx->capacity * item_size);\r
        const lay_item_t *past_last = ctx->items + ctx->capacity;\r
        ctx->rects = (lay_vec4*)past_last;\r
    }\r
\r
    lay_item_t *item = lay_get_item(ctx, idx);\r
    // We can either do this here, or when creating/resetting buffer\r
    LAY_MEMSET(item, 0, sizeof(lay_item_t));\r
    item->first_child = LAY_INVALID_ID;\r
    item->next_sibling = LAY_INVALID_ID;\r
    // hmm\r
    LAY_MEMSET(&ctx->rects[idx], 0, sizeof(lay_vec4));\r
    return idx;\r
}\r
\r
static LAY_FORCE_INLINE\r
void lay_append_by_ptr(\r
        lay_item_t *LAY_RESTRICT pearlier,\r
        lay_id later, lay_item_t *LAY_RESTRICT plater)\r
{\r
    plater->next_sibling = pearlier->next_sibling;\r
    plater->flags |= LAY_ITEM_INSERTED;\r
    pearlier->next_sibling = later;\r
}\r
\r
lay_id lay_last_child(const lay_context *ctx, lay_id parent)\r
{\r
    lay_item_t *pparent = lay_get_item(ctx, parent);\r
    lay_id child = pparent->first_child;\r
    if (child == LAY_INVALID_ID) return LAY_INVALID_ID;\r
    lay_item_t *pchild = lay_get_item(ctx, child);\r
    lay_id result = child;\r
    for (;;) {\r
        lay_id next = pchild->next_sibling;\r
        if (next == LAY_INVALID_ID) break;\r
        result = next;\r
        pchild = lay_get_item(ctx, next);\r
    }\r
    return result;\r
}\r
\r
void lay_append(lay_context *ctx, lay_id earlier, lay_id later)\r
{\r
    LAY_ASSERT(later != 0); // Must not be root item\r
    LAY_ASSERT(earlier != later); // Must not be same item id\r
    lay_item_t *LAY_RESTRICT pearlier = lay_get_item(ctx, earlier);\r
    lay_item_t *LAY_RESTRICT plater = lay_get_item(ctx, later);\r
    lay_append_by_ptr(pearlier, later, plater);\r
}\r
\r
void lay_insert(lay_context *ctx, lay_id parent, lay_id child)\r
{\r
    LAY_ASSERT(child != 0); // Must not be root item\r
    LAY_ASSERT(parent != child); // Must not be same item id\r
    lay_item_t *LAY_RESTRICT pparent = lay_get_item(ctx, parent);\r
    lay_item_t *LAY_RESTRICT pchild = lay_get_item(ctx, child);\r
    LAY_ASSERT(!(pchild->flags & LAY_ITEM_INSERTED));\r
    // Parent has no existing children, make inserted item the first child.\r
    if (pparent->first_child == LAY_INVALID_ID) {\r
        pparent->first_child = child;\r
        pchild->flags |= LAY_ITEM_INSERTED;\r
    // Parent has existing items, iterate to find the last child and append the\r
    // inserted item after it.\r
    } else {\r
        lay_id next = pparent->first_child;\r
        lay_item_t *LAY_RESTRICT pnext = lay_get_item(ctx, next);\r
        for (;;) {\r
            next = pnext->next_sibling;\r
            if (next == LAY_INVALID_ID) break;\r
            pnext = lay_get_item(ctx, next);\r
        }\r
        lay_append_by_ptr(pnext, child, pchild);\r
    }\r
}\r
\r
void lay_push(lay_context *ctx, lay_id parent, lay_id new_child)\r
{\r
    LAY_ASSERT(new_child != 0); // Must not be root item\r
    LAY_ASSERT(parent != new_child); // Must not be same item id\r
    lay_item_t *LAY_RESTRICT pparent = lay_get_item(ctx, parent);\r
    lay_id old_child = pparent->first_child;\r
    lay_item_t *LAY_RESTRICT pchild = lay_get_item(ctx, new_child);\r
    LAY_ASSERT(!(pchild->flags & LAY_ITEM_INSERTED));\r
    pparent->first_child = new_child;\r
    pchild->flags |= LAY_ITEM_INSERTED;\r
    pchild->next_sibling = old_child;\r
}\r
\r
lay_vec2 lay_get_size(lay_context *ctx, lay_id item)\r
{\r
    lay_item_t *pitem = lay_get_item(ctx, item);\r
    return pitem->size;\r
}\r
\r
void lay_get_size_xy(\r
        lay_context *ctx, lay_id item,\r
        lay_scalar *x, lay_scalar *y)\r
{\r
    lay_item_t *pitem = lay_get_item(ctx, item);\r
    lay_vec2 size = pitem->size;\r
    *x = size[0];\r
    *y = size[1];\r
}\r
\r
void lay_set_size(lay_context *ctx, lay_id item, lay_vec2 size)\r
{\r
    lay_item_t *pitem = lay_get_item(ctx, item);\r
    pitem->size = size;\r
    uint32_t flags = pitem->flags;\r
    if (size[0] == 0)\r
        flags &= ~(uint32_t)LAY_ITEM_HFIXED;\r
    else\r
        flags |= LAY_ITEM_HFIXED;\r
    if (size[1] == 0)\r
        flags &= ~(uint32_t)LAY_ITEM_VFIXED;\r
    else\r
        flags |= LAY_ITEM_VFIXED;\r
    pitem->flags = flags;\r
}\r
\r
void lay_set_size_xy(\r
        lay_context *ctx, lay_id item,\r
        lay_scalar width, lay_scalar height)\r
{\r
    lay_item_t *pitem = lay_get_item(ctx, item);\r
    pitem->size[0] = width;\r
    pitem->size[1] = height;\r
    // Kinda redundant, whatever\r
    uint32_t flags = pitem->flags;\r
    if (width == 0)\r
        flags &= ~(uint32_t)LAY_ITEM_HFIXED;\r
    else\r
        flags |= LAY_ITEM_HFIXED;\r
    if (height == 0)\r
        flags &= ~(uint32_t)LAY_ITEM_VFIXED;\r
    else\r
        flags |= LAY_ITEM_VFIXED;\r
    pitem->flags = flags;\r
}\r
\r
void lay_set_behave(lay_context *ctx, lay_id item, uint32_t flags)\r
{\r
    LAY_ASSERT((flags & LAY_ITEM_LAYOUT_MASK) == flags);\r
    lay_item_t *pitem = lay_get_item(ctx, item);\r
    pitem->flags = (pitem->flags & ~(uint32_t)LAY_ITEM_LAYOUT_MASK) | flags;\r
}\r
\r
void lay_set_contain(lay_context *ctx, lay_id item, uint32_t flags)\r
{\r
    LAY_ASSERT((flags & LAY_ITEM_BOX_MASK) == flags);\r
    lay_item_t *pitem = lay_get_item(ctx, item);\r
    pitem->flags = (pitem->flags & ~(uint32_t)LAY_ITEM_BOX_MASK) | flags;\r
}\r
void lay_set_margins(lay_context *ctx, lay_id item, lay_vec4 ltrb)\r
{\r
    lay_item_t *pitem = lay_get_item(ctx, item);\r
    pitem->margins = ltrb;\r
}\r
void lay_set_margins_ltrb(\r
        lay_context *ctx, lay_id item,\r
        lay_scalar l, lay_scalar t, lay_scalar r, lay_scalar b)\r
{\r
    lay_item_t *pitem = lay_get_item(ctx, item);\r
    // Alternative, uses stack and addressed writes\r
    //pitem->margins = lay_vec4_xyzw(l, t, r, b);\r
    // Alternative, uses rax and left-shift\r
    //pitem->margins = (lay_vec4){l, t, r, b};\r
    // Fewest instructions, but uses more addressed writes?\r
    pitem->margins[0] = l;\r
    pitem->margins[1] = t;\r
    pitem->margins[2] = r;\r
    pitem->margins[3] = b;\r
}\r
\r
lay_vec4 lay_get_margins(lay_context *ctx, lay_id item)\r
{ return lay_get_item(ctx, item)->margins; }\r
\r
void lay_get_margins_ltrb(\r
        lay_context *ctx, lay_id item,\r
        lay_scalar *l, lay_scalar *t, lay_scalar *r, lay_scalar *b)\r
{\r
    lay_item_t *pitem = lay_get_item(ctx, item);\r
    lay_vec4 margins = pitem->margins;\r
    *l = margins[0];\r
    *t = margins[1];\r
    *r = margins[2];\r
    *b = margins[3];\r
}\r
\r
// TODO restrict item ptrs correctly\r
static LAY_FORCE_INLINE\r
lay_scalar lay_calc_overlayed_size(\r
        lay_context *ctx, lay_id item, int dim)\r
{\r
    const int wdim = dim + 2;\r
    lay_item_t *LAY_RESTRICT pitem = lay_get_item(ctx, item);\r
    lay_scalar need_size = 0;\r
    lay_id child = pitem->first_child;\r
    while (child != LAY_INVALID_ID) {\r
        lay_item_t *pchild = lay_get_item(ctx, child);\r
        lay_vec4 rect = ctx->rects[child];\r
        // width = start margin + calculated width + end margin\r
        lay_scalar child_size = rect[dim] + rect[2 + dim] + pchild->margins[wdim];\r
        need_size = lay_scalar_max(need_size, child_size);\r
        child = pchild->next_sibling;\r
    }\r
    return need_size;\r
}\r
\r
static LAY_FORCE_INLINE\r
lay_scalar lay_calc_stacked_size(\r
        lay_context *ctx, lay_id item, int dim)\r
{\r
    const int wdim = dim + 2;\r
    lay_item_t *LAY_RESTRICT pitem = lay_get_item(ctx, item);\r
    lay_scalar need_size = 0;\r
    lay_id child = pitem->first_child;\r
    while (child != LAY_INVALID_ID) {\r
        lay_item_t *pchild = lay_get_item(ctx, child);\r
        lay_vec4 rect = ctx->rects[child];\r
        need_size += rect[dim] + rect[2 + dim] + pchild->margins[wdim];\r
        child = pchild->next_sibling;\r
    }\r
    return need_size;\r
}\r
\r
static LAY_FORCE_INLINE\r
lay_scalar lay_calc_wrapped_overlayed_size(\r
        lay_context *ctx, lay_id item, int dim)\r
{\r
    const int wdim = dim + 2;\r
    lay_item_t *LAY_RESTRICT pitem = lay_get_item(ctx, item);\r
    lay_scalar need_size = 0;\r
    lay_scalar need_size2 = 0;\r
    lay_id child = pitem->first_child;\r
    while (child != LAY_INVALID_ID) {\r
        lay_item_t *pchild = lay_get_item(ctx, child);\r
        lay_vec4 rect = ctx->rects[child];\r
        if (pchild->flags & LAY_BREAK) {\r
            need_size2 += need_size;\r
            need_size = 0;\r
        }\r
        lay_scalar child_size = rect[dim] + rect[2 + dim] + pchild->margins[wdim];\r
        need_size = lay_scalar_max(need_size, child_size);\r
        child = pchild->next_sibling;\r
    }\r
    return need_size2 + need_size;\r
}\r
\r
// Equivalent to uiComputeWrappedStackedSize\r
static LAY_FORCE_INLINE\r
lay_scalar lay_calc_wrapped_stacked_size(\r
        lay_context *ctx, lay_id item, int dim)\r
{\r
    const int wdim = dim + 2;\r
    lay_item_t *LAY_RESTRICT pitem = lay_get_item(ctx, item);\r
    lay_scalar need_size = 0;\r
    lay_scalar need_size2 = 0;\r
    lay_id child = pitem->first_child;\r
    while (child != LAY_INVALID_ID) {\r
        lay_item_t *pchild = lay_get_item(ctx, child);\r
        lay_vec4 rect = ctx->rects[child];\r
        if (pchild->flags & LAY_BREAK) {\r
            need_size2 = lay_scalar_max(need_size2, need_size);\r
            need_size = 0;\r
        }\r
        need_size += rect[dim] + rect[2 + dim] + pchild->margins[wdim];\r
        child = pchild->next_sibling;\r
    }\r
    return lay_scalar_max(need_size2, need_size);\r
}\r
\r
static void lay_calc_size(lay_context *ctx, lay_id item, int dim)\r
{\r
    lay_item_t *pitem = lay_get_item(ctx, item);\r
\r
    lay_id child = pitem->first_child;\r
    while (child != LAY_INVALID_ID) {\r
        // NOTE: this is recursive and will run out of stack space if items are\r
        // nested too deeply.\r
        lay_calc_size(ctx, child, dim);\r
        lay_item_t *pchild = lay_get_item(ctx, child);\r
        child = pchild->next_sibling;\r
    }\r
\r
    // Set the mutable rect output data to the starting input data\r
    ctx->rects[item][dim] = pitem->margins[dim];\r
\r
    // If we have an explicit input size, just set our output size (which other\r
    // calc_size and arrange procedures will use) to it.\r
    if (pitem->size[dim] != 0) {\r
        ctx->rects[item][2 + dim] = pitem->size[dim];\r
        return;\r
    }\r
\r
    // Calculate our size based on children items. Note that we've already\r
    // called lay_calc_size on our children at this point.\r
    lay_scalar cal_size;\r
    switch (pitem->flags & LAY_ITEM_BOX_MODEL_MASK) {\r
    case LAY_COLUMN|LAY_WRAP:\r
        // flex model\r
        if (dim) // direction\r
            cal_size = lay_calc_stacked_size(ctx, item, 1);\r
        else\r
            cal_size = lay_calc_overlayed_size(ctx, item, 0);\r
        break;\r
    case LAY_ROW|LAY_WRAP:\r
        // flex model\r
        if (!dim) // direction\r
            cal_size = lay_calc_wrapped_stacked_size(ctx, item, 0);\r
        else\r
            cal_size = lay_calc_wrapped_overlayed_size(ctx, item, 1);\r
        break;\r
    case LAY_COLUMN:\r
    case LAY_ROW:\r
        // flex model\r
        if ((pitem->flags & 1) == (uint32_t)dim) // direction\r
            cal_size = lay_calc_stacked_size(ctx, item, dim);\r
        else\r
            cal_size = lay_calc_overlayed_size(ctx, item, dim);\r
        break;\r
    default:\r
        // layout model\r
        cal_size = lay_calc_overlayed_size(ctx, item, dim);\r
        break;\r
    }\r
\r
    // Set our output data size. Will be used by parent calc_size procedures.,\r
    // and by arrange procedures.\r
    ctx->rects[item][2 + dim] = cal_size;\r
}\r
\r
static LAY_FORCE_INLINE\r
void lay_arrange_stacked(\r
            lay_context *ctx, lay_id item, int dim, bool wrap)\r
{\r
    const int wdim = dim + 2;\r
    lay_item_t *pitem = lay_get_item(ctx, item);\r
\r
    const uint32_t item_flags = pitem->flags;\r
    lay_vec4 rect = ctx->rects[item];\r
    lay_scalar space = rect[2 + dim];\r
\r
    float max_x2 = (float)(rect[dim] + space);\r
\r
    lay_id start_child = pitem->first_child;\r
    while (start_child != LAY_INVALID_ID) {\r
        lay_scalar used = 0;\r
        uint32_t count = 0; // count of fillers\r
        uint32_t squeezed_count = 0; // count of squeezable elements\r
        uint32_t total = 0;\r
        bool hardbreak = false;\r
        // first pass: count items that need to be expanded,\r
        // and the space that is used\r
        lay_id child = start_child;\r
        lay_id end_child = LAY_INVALID_ID;\r
        while (child != LAY_INVALID_ID) {\r
            lay_item_t *pchild = lay_get_item(ctx, child);\r
            const uint32_t child_flags = pchild->flags;\r
            const uint32_t flags = (child_flags & LAY_ITEM_LAYOUT_MASK) >> dim;\r
            const uint32_t fflags = (child_flags & LAY_ITEM_FIXED_MASK) >> dim;\r
            const lay_vec4 child_margins = pchild->margins;\r
            lay_vec4 child_rect = ctx->rects[child];\r
            lay_scalar extend = used;\r
            if ((flags & LAY_HFILL) == LAY_HFILL) {\r
                ++count;\r
                extend += child_rect[dim] + child_margins[wdim];\r
            } else {\r
                if ((fflags & LAY_ITEM_HFIXED) != LAY_ITEM_HFIXED)\r
                    ++squeezed_count;\r
                extend += child_rect[dim] + child_rect[2 + dim] + child_margins[wdim];\r
            }\r
            // wrap on end of line or manual flag\r
            if (wrap && (\r
                    total && ((extend > space) ||\r
                    (child_flags & LAY_BREAK)))) {\r
                end_child = child;\r
                hardbreak = (child_flags & LAY_BREAK) == LAY_BREAK;\r
                // add marker for subsequent queries\r
                pchild->flags = child_flags | LAY_BREAK;\r
                break;\r
            } else {\r
                used = extend;\r
                child = pchild->next_sibling;\r
            }\r
            ++total;\r
        }\r
\r
        lay_scalar extra_space = space - used;\r
        float filler = 0.0f;\r
        float spacer = 0.0f;\r
        float extra_margin = 0.0f;\r
        float eater = 0.0f;\r
\r
        if (extra_space > 0) {\r
            if (count > 0)\r
                filler = (float)extra_space / (float)count;\r
            else if (total > 0) {\r
                switch (item_flags & LAY_JUSTIFY) {\r
                case LAY_JUSTIFY:\r
                    // justify when not wrapping or not in last line,\r
                    // or not manually breaking\r
                    if (!wrap || ((end_child != LAY_INVALID_ID) && !hardbreak))\r
                        spacer = (float)extra_space / (float)(total - 1);\r
                    break;\r
                case LAY_START:\r
                    break;\r
                case LAY_END:\r
                    extra_margin = extra_space;\r
                    break;\r
                default:\r
                    extra_margin = extra_space / 2.0f;\r
                    break;\r
                }\r
            }\r
        }\r
#ifdef LAY_FLOAT\r
        // In floating point, it's possible to end up with some small negative\r
        // value for extra_space, while also have a 0.0 squeezed_count. This\r
        // would cause divide by zero. Instead, we'll check to see if\r
        // squeezed_count is > 0. I believe this produces the same results as\r
        // the original oui int-only code. However, I don't have any tests for\r
        // it, so I'll leave it if-def'd for now.\r
        else if (!wrap && (squeezed_count > 0))\r
#else\r
        // This is the original oui code\r
        else if (!wrap && (extra_space < 0))\r
#endif\r
            eater = (float)extra_space / (float)squeezed_count;\r
\r
        // distribute width among items\r
        float x = (float)rect[dim];\r
        float x1;\r
        // second pass: distribute and rescale\r
        child = start_child;\r
        while (child != end_child) {\r
            lay_scalar ix0, ix1;\r
            lay_item_t *pchild = lay_get_item(ctx, child);\r
            const uint32_t child_flags = pchild->flags;\r
            const uint32_t flags = (child_flags & LAY_ITEM_LAYOUT_MASK) >> dim;\r
            const uint32_t fflags = (child_flags & LAY_ITEM_FIXED_MASK) >> dim;\r
            const lay_vec4 child_margins = pchild->margins;\r
            lay_vec4 child_rect = ctx->rects[child];\r
\r
            x += (float)child_rect[dim] + extra_margin;\r
            if ((flags & LAY_HFILL) == LAY_HFILL) // grow\r
                x1 = x + filler;\r
            else if ((fflags & LAY_ITEM_HFIXED) == LAY_ITEM_HFIXED)\r
                x1 = x + (float)child_rect[2 + dim];\r
            else // squeeze\r
                x1 = x + lay_float_max(0.0f, (float)child_rect[2 + dim] + eater);\r
\r
            ix0 = (lay_scalar)x;\r
            if (wrap)\r
                ix1 = (lay_scalar)lay_float_min(max_x2 - (float)child_margins[wdim], x1);\r
            else\r
                ix1 = (lay_scalar)x1;\r
            child_rect[dim] = ix0; // pos\r
            child_rect[dim + 2] = ix1 - ix0; // size\r
            ctx->rects[child] = child_rect;\r
            x = x1 + (float)child_margins[wdim];\r
            child = pchild->next_sibling;\r
            extra_margin = spacer;\r
        }\r
\r
        start_child = end_child;\r
    }\r
}\r
\r
static LAY_FORCE_INLINE\r
void lay_arrange_overlay(lay_context *ctx, lay_id item, int dim)\r
{\r
    const int wdim = dim + 2;\r
    lay_item_t *pitem = lay_get_item(ctx, item);\r
    const lay_vec4 rect = ctx->rects[item];\r
    const lay_scalar offset = rect[dim];\r
    const lay_scalar space = rect[2 + dim];\r
    \r
    lay_id child = pitem->first_child;\r
    while (child != LAY_INVALID_ID) {\r
        lay_item_t *pchild = lay_get_item(ctx, child);\r
        const uint32_t b_flags = (pchild->flags & LAY_ITEM_LAYOUT_MASK) >> dim;\r
        const lay_vec4 child_margins = pchild->margins;\r
        lay_vec4 child_rect = ctx->rects[child];\r
\r
        switch (b_flags & LAY_HFILL) {\r
        case LAY_HCENTER:\r
            child_rect[dim] += (space - child_rect[2 + dim]) / 2 - child_margins[wdim];\r
            break;\r
        case LAY_RIGHT:\r
            child_rect[dim] += space - child_rect[2 + dim] - child_margins[dim] - child_margins[wdim];\r
            break;\r
        case LAY_HFILL:\r
            child_rect[2 + dim] = lay_scalar_max(0, space - child_rect[dim] - child_margins[wdim]);\r
            break;\r
        default:\r
            break;\r
        }\r
\r
        child_rect[dim] += offset;\r
        ctx->rects[child] = child_rect;\r
        child = pchild->next_sibling;\r
    }\r
}\r
\r
static LAY_FORCE_INLINE\r
void lay_arrange_overlay_squeezed_range(\r
        lay_context *ctx, int dim,\r
        lay_id start_item, lay_id end_item,\r
        lay_scalar offset, lay_scalar space)\r
{\r
    int wdim = dim + 2;\r
    lay_id item = start_item;\r
    while (item != end_item) {\r
        lay_item_t *pitem = lay_get_item(ctx, item);\r
        const uint32_t b_flags = (pitem->flags & LAY_ITEM_LAYOUT_MASK) >> dim;\r
        const lay_vec4 margins = pitem->margins;\r
        lay_vec4 rect = ctx->rects[item];\r
        lay_scalar min_size = lay_scalar_max(0, space - rect[dim] - margins[wdim]);\r
        switch (b_flags & LAY_HFILL) {\r
            case LAY_HCENTER:\r
                rect[2 + dim] = lay_scalar_min(rect[2 + dim], min_size);\r
                rect[dim] += (space - rect[2 + dim]) / 2 - margins[wdim];\r
                break;\r
            case LAY_RIGHT:\r
                rect[2 + dim] = lay_scalar_min(rect[2 + dim], min_size);\r
                rect[dim] = space - rect[2 + dim] - margins[wdim];\r
                break;\r
            case LAY_HFILL:\r
                rect[2 + dim] = min_size;\r
                break;\r
            default:\r
                rect[2 + dim] = lay_scalar_min(rect[2 + dim], min_size);\r
                break;\r
        }\r
        rect[dim] += offset;\r
        ctx->rects[item] = rect;\r
        item = pitem->next_sibling;\r
    }\r
}\r
\r
static LAY_FORCE_INLINE\r
lay_scalar lay_arrange_wrapped_overlay_squeezed(\r
        lay_context *ctx, lay_id item, int dim)\r
{\r
    const int wdim = dim + 2;\r
    lay_item_t *pitem = lay_get_item(ctx, item);\r
    lay_scalar offset = ctx->rects[item][dim];\r
    lay_scalar need_size = 0;\r
    lay_id child = pitem->first_child;\r
    lay_id start_child = child;\r
    while (child != LAY_INVALID_ID) {\r
        lay_item_t *pchild = lay_get_item(ctx, child);\r
        if (pchild->flags & LAY_BREAK) {\r
            lay_arrange_overlay_squeezed_range(ctx, dim, start_child, child, offset, need_size);\r
            offset += need_size;\r
            start_child = child;\r
            need_size = 0;\r
        }\r
        const lay_vec4 rect = ctx->rects[child];\r
        lay_scalar child_size = rect[dim] + rect[2 + dim] + pchild->margins[wdim];\r
        need_size = lay_scalar_max(need_size, child_size);\r
        child = pchild->next_sibling;\r
    }\r
    lay_arrange_overlay_squeezed_range(ctx, dim, start_child, LAY_INVALID_ID, offset, need_size);\r
    offset += need_size;\r
    return offset;\r
}\r
\r
static void lay_arrange(lay_context *ctx, lay_id item, int dim)\r
{\r
    lay_item_t *pitem = lay_get_item(ctx, item);\r
\r
    const uint32_t flags = pitem->flags;\r
    switch (flags & LAY_ITEM_BOX_MODEL_MASK) {\r
    case LAY_COLUMN | LAY_WRAP:\r
        if (dim != 0) {\r
            lay_arrange_stacked(ctx, item, 1, true);\r
            lay_scalar offset = lay_arrange_wrapped_overlay_squeezed(ctx, item, 0);\r
            ctx->rects[item][2 + 0] = offset - ctx->rects[item][0];\r
        }\r
        break;\r
    case LAY_ROW | LAY_WRAP:\r
        if (dim == 0)\r
            lay_arrange_stacked(ctx, item, 0, true);\r
        else\r
            // discard return value\r
            lay_arrange_wrapped_overlay_squeezed(ctx, item, 1);\r
        break;\r
    case LAY_COLUMN:\r
    case LAY_ROW:\r
        if ((flags & 1) == (uint32_t)dim) {\r
            lay_arrange_stacked(ctx, item, dim, false);\r
        } else {\r
            const lay_vec4 rect = ctx->rects[item];\r
            lay_arrange_overlay_squeezed_range(\r
                ctx, dim, pitem->first_child, LAY_INVALID_ID,\r
                rect[dim], rect[2 + dim]);\r
        }\r
        break;\r
    default:\r
        lay_arrange_overlay(ctx, item, dim);\r
        break;\r
    }\r
    lay_id child = pitem->first_child;\r
    while (child != LAY_INVALID_ID) {\r
        // NOTE: this is recursive and will run out of stack space if items are\r
        // nested too deeply.\r
        lay_arrange(ctx, child, dim);\r
        lay_item_t *pchild = lay_get_item(ctx, child);\r
        child = pchild->next_sibling;\r
    }\r
}\r
\r
#endif // LAY_IMPLEMENTATION