resources/scripts/views/list.lua - master - d.vision/division_engine_cpp

resources/scripts/views/list.lua
131 строка5 KB
den163
Added SDF font support
05 дек 2024, 01:01
05 дек 2024, 01:01a1df803
local constrained_size = require 'constrained_size'
local constraints = require 'constraints'
local multi_child_view = require 'views.multi_child_view'
local rect = require 'rect'
local vec2 = require 'vec2'

---@class list.options
---@field children view[]
---@field direction 'horizontal'|'vertical'?

---@class list : multi_child_view, list.options
---@overload fun(options: list.options): list
---@diagnostic disable-next-line: assign-type-mismatch
local list = multi_child_view:inherit 'list'

---@class list.state: multi_child_view.state
list.state = multi_child_view.state:inherit 'list.state'

---@param options list.options
function list:__call(options)
    local list = list:new(options)

    list.children = options.children or {}
    list.direction = options.direction or 'horizontal'

    return list
end

---@param constraints constraints
---@param view list
function list.state:layout(constraints, view)
    return constrained_size.unconstrained()
end

---@param render_rect rect
---@param view list
function list.state:render(render_rect, view)
    local render_rect_size = render_rect:size()
    local child_count = #view.children
    local size_per_unconstrainted_child = self:__calculate_size_per_unconstrained_child(
        render_rect, view)

    local offset = vec2(0)
    local child_constraints = constraints.new(vec2(0), render_rect_size)

    for i = 1, child_count do
        local child_view = view.children[i]
        local child_state = self.child_states[i]
        local child_size = child_state:layout(child_constraints, child_view)
        local top_left = vec2(render_rect:left() + offset.x, render_rect:top() - offset.y)

        if view:__is_unconstrained_by_direction(child_size) then
            local child_rect = rect.from_top_left(top_left, size_per_unconstrainted_child)
            child_state:render(child_rect, child_view)

            if view.direction == 'horizontal' then
                offset.x = offset.x + size_per_unconstrainted_child.x
            else
                offset.y = offset.y + size_per_unconstrainted_child.y
            end
        else
            local child_rect = rect.from_top_left(
                top_left,
                child_size:to_vec2_or(render_rect_size)
            )
            child_state:render(child_rect, child_view)

            if view.direction == 'horizontal' then
                offset.x = offset.x + child_size.width
            else
                offset.y = offset.y + child_size.height
            end
        end
    end
end

---@private
---@param render_rect rect
---@param view list
function list.state:__calculate_size_per_unconstrained_child(render_rect, view)
    local render_rect_size = render_rect:size()
    local child_count = #view.children
    local available_size = render_rect_size:copy()
    local all_constrained_children_size = vec2(0)
    local constrainted_child_count = 0

    for i = 1, child_count do
        local child_view = view.children[i]
        local child_state = self.child_states[i]
        local child_constraints = constraints.new(vec2(0), available_size)
        local child_size = child_state:layout(child_constraints, child_view)

        if view:__is_unconstrained_by_direction(child_size) == false then
            if view.direction == 'horizontal' then
                local width = child_size.width
                available_size.x = available_size.x - width
                all_constrained_children_size.x = all_constrained_children_size.x + width
            else
                local height = child_size.height
                available_size.y = available_size.y - height
                all_constrained_children_size.y = all_constrained_children_size.y + height
            end

            constrainted_child_count = constrainted_child_count + 1
        end
    end

    local unconstrained_child_count = child_count - constrainted_child_count
    local unconstrained_children_size = render_rect_size - all_constrained_children_size
    local size_per_unconstrainted_child = render_rect_size:copy()

    if view.direction == 'horizontal' then
        size_per_unconstrainted_child.x =
            unconstrained_children_size.x / unconstrained_child_count
    else
        size_per_unconstrainted_child.y =
            unconstrained_children_size.y / unconstrained_child_count
    end

    return size_per_unconstrainted_child
end

---@package
---@param size constrained_size
function list:__is_unconstrained_by_direction(size)
    return
        (self.direction == 'horizontal' and size.width_unconstrained) or
        (self.direction == 'vertical' and size.height_unconstrained)
end

return list