docs/inventory__list_8gd_source.html

extends RefCounted


const DEFAULT_COLORS := {

    "surface": Color("#202a34"),

    "surface_selected": Color("#18212a"),

    "border": Color("#33404d"),

    "text": Color("#eef3f8"),

    "muted": Color("#aab6c4"),

    "accent": Color("#f2c86b"),

    "boost": Color("#55d878")

}

const DENSITY_PRESETS := {

    "compact": {

        "row_height": 58.0,

        "header_height": 38.0,

        "filter_height": 36.0,

        "section_gap": 5,

        "row_gap": 3

    },

    "comfortable": {

        "row_height": 76.0,

        "header_height": 46.0,

        "filter_height": 40.0,

        "section_gap": 6,

        "row_gap": 4

    },

    "large": {

        "row_height": 92.0,

        "header_height": 52.0,

        "filter_height": 46.0,

        "section_gap": 8,

        "row_gap": 5

    }

}


var root:VBoxContainer

var filter_row:HBoxContainer

var header_row:HBoxContainer

var scroll_frame:PanelContainer

var scroll:ScrollContainer

var rows:VBoxContainer

var content_margin:MarginContainer

var columns := []

var filters := []

var options := {}

var colors := DEFAULT_COLORS.duplicate(true)

var total_rows_created:int = 0

var total_rows_reused:int = 0

var pass_rows_created:int = 0

var pass_rows_reused:int = 0

var last_hidden:int = 0


func create(parent:Node, insert_index:int, next_options:Dictionary = {}) -> VBoxContainer:

    options = _options_with_density(next_options)

    columns = options.get("columns", [])

    filters = options.get("filters", [])

    colors = DEFAULT_COLORS.duplicate(true)

    for key in options.get("colors", {}).keys():

        colors[key] = options["colors"][key]

    root = VBoxContainer.new()

    root.name = str(options.get("name", "InventoryList"))

    root.size_flags_horizontal = Control.SIZE_EXPAND_FILL

    root.add_theme_constant_override("separation", int(options.get("section_gap", 6)))

    parent.add_child(root)

    parent.move_child(root, insert_index)

    _build_filters()

    _build_header()

    _build_scroll()

    return root


func render(records:Array, state:Dictionary = {}) -> void:

    if root == null:

        return

    pass_rows_created = 0

    pass_rows_reused = 0

    last_hidden = 0

    _style_filters(str(state.get("filter", "all")))

    _style_header(str(state.get("sort_key", "")), bool(state.get("sort_ascending", true)))

    var existing_rows:Array = rows.get_children()

    for index in range(records.size()):

        var row:Button = null

        if index < existing_rows.size() and existing_rows[index] is Button:

            row = existing_rows[index]

            pass_rows_reused += 1

            total_rows_reused += 1

        else:

            row = _create_row_shell()

            rows.add_child(row)

            pass_rows_created += 1

            total_rows_created += 1

        _configure_row(row, records[index])

        row.visible = true

    for index in range(records.size(), existing_rows.size()):

        var row = existing_rows[index]

        if row is CanvasItem:

            row.visible = false

            last_hidden += 1


func set_minimum_height(height:float) -> void:

    if scroll != null:

        scroll.custom_minimum_size.y = height


func set_available_height(height:float) -> void:

    if root == null:

        return

    var target_height:float = maxf(0.0, height)

    root.custom_minimum_size.y = target_height

    var chrome_height:float = 0.0

    var visible_sections:int = 0

    for section in [filter_row, header_row]:

        if section is Control and section.visible:

            chrome_height += _section_minimum_height(section)

            visible_sections += 1

    if scroll_frame != null and scroll_frame.visible:

        visible_sections += 1

    var gap:float = float(root.get_theme_constant("separation")) * float(max(0, visible_sections - 1))

    var scroll_height:float = maxf(0.0, target_height - chrome_height - gap)

    if scroll_frame != null:

        scroll_frame.custom_minimum_size.y = scroll_height

    if scroll != null:

        scroll.custom_minimum_size.y = scroll_height


func _section_minimum_height(section:Control) -> float:

    if section == null:

        return 0.0

    var height:float = section.custom_minimum_size.y

    for child in section.get_children():

        if child is Control and child.visible:

            height = maxf(height, child.custom_minimum_size.y)

    return height


func set_density(density_id:String) -> void:

    var density_options:Dictionary = _density_options(density_id)

    if density_options.is_empty():

        return

    options["density"] = density_id

    for key in density_options.keys():

        options[key] = density_options[key]

    if filter_row != null:

        filter_row.add_theme_constant_override("separation", int(options.get("filter_gap", 6)))

        for button in filter_row.get_children():

            if button is Button:

                button.custom_minimum_size.y = float(options.get("filter_height", 40.0))

    if header_row != null:

        for child in header_row.get_children():

            if child is Control:

                child.custom_minimum_size.y = float(options.get("header_height", 46.0))

    if rows != null:

        rows.add_theme_constant_override("separation", int(options.get("row_gap", 4)))

        for row in rows.get_children():

            if row is Button:

                row.custom_minimum_size.y = float(options.get("row_height", 76.0))


func set_font_sizes(row_size:int, header_size:int = -1, filter_size:int = -1) -> void:

    options["font_size"] = row_size

    options["header_font_size"] = header_size if header_size > 0 else row_size

    options["filter_font_size"] = filter_size if filter_size > 0 else row_size

    if rows == null:

        return

    _style_filters(str(options.get("active_filter", "all")))

    _style_header(str(options.get("active_sort_key", "")), bool(options.get("active_sort_ascending", true)))

    for row in rows.get_children():

        _apply_font_size_recursive(row, row_size)


func set_enabled(enabled:bool) -> void:

    if root == null:

        return

    root.mouse_filter = Control.MOUSE_FILTER_STOP if enabled else Control.MOUSE_FILTER_IGNORE

    for row in rows.get_children():

        if row is Button:

            row.disabled = not enabled


func set_visible(visible:bool) -> void:

    if root != null:

        root.visible = visible


func get_stats() -> Dictionary:

    var row_count:int = 0

    var visible_count:int = 0

    if rows != null:

        row_count = rows.get_child_count()

        for row in rows.get_children():

            if row is CanvasItem and row.visible:

                visible_count += 1

    return {

        "rows": row_count,

        "visible_rows": visible_count,

        "hidden_last_pass": last_hidden,

        "pass_rows_created": pass_rows_created,

        "pass_rows_reused": pass_rows_reused,

        "total_rows_created": total_rows_created,

        "total_rows_reused": total_rows_reused

    }


func get_cache_stats() -> Dictionary:

    return get_stats()


func _build_filters() -> void:

    if filters.is_empty():

        return

    filter_row = HBoxContainer.new()

    filter_row.name = "Filters"

    filter_row.size_flags_horizontal = Control.SIZE_EXPAND_FILL

    filter_row.add_theme_constant_override("separation", int(options.get("filter_gap", 6)))

    root.add_child(filter_row)

    for filter in filters:

        var button = Button.new()

        button.name = "%sFilter" % str(filter.get("id", "all")).capitalize()

        button.text = str(filter.get("label", "Filter"))

        button.custom_minimum_size = Vector2(0, float(options.get("filter_height", 40.0)))

        button.size_flags_horizontal = Control.SIZE_EXPAND_FILL

        button.focus_mode = Control.FOCUS_NONE

        var filter_id = str(filter.get("id", "all"))

        var callback = options.get("filter_callback", Callable())

        if callback.is_valid():

            button.pressed.connect(func(): callback.call(filter_id))

        filter_row.add_child(button)


func _options_with_density(next_options:Dictionary) -> Dictionary:

    var merged:Dictionary = {}

    var density_options:Dictionary = _density_options(str(next_options.get("density", "comfortable")))

    for key in density_options.keys():

        merged[key] = density_options[key]

    for key in next_options.keys():

        merged[key] = next_options[key]

    return merged


func _density_options(density_id:String) -> Dictionary:

    if not DENSITY_PRESETS.has(density_id):

        return {}

    return DENSITY_PRESETS[density_id].duplicate(true)


func _build_header() -> void:

    header_row = HBoxContainer.new()

    header_row.name = "Header"

    header_row.size_flags_horizontal = Control.SIZE_EXPAND_FILL

    header_row.add_theme_constant_override("separation", 0)

    root.add_child(header_row)

    for column in columns:

        var button = Button.new()

        button.name = "%sHeader" % str(column.get("key", "column")).capitalize()

        button.text = str(column.get("label", "Column"))

        button.custom_minimum_size = Vector2(0, float(options.get("header_height", 46.0)))

        button.size_flags_horizontal = Control.SIZE_EXPAND_FILL

        button.size_flags_stretch_ratio = float(column.get("ratio", 1.0))

        button.focus_mode = Control.FOCUS_NONE

        var sort_key = str(column.get("sort_key", column.get("key", "")))

        var sortable = bool(column.get("sortable", true)) and sort_key != ""

        var callback = options.get("sort_callback", Callable())

        if sortable and callback.is_valid():

            button.pressed.connect(func(): callback.call(sort_key))

        else:

            button.disabled = true

        header_row.add_child(button)

    var spacer = Control.new()

    spacer.name = "ScrollbarPad"

    spacer.custom_minimum_size = Vector2(float(options.get("scrollbar_padding", 38)), float(options.get("header_height", 46.0)))

    header_row.add_child(spacer)


func _build_scroll() -> void:

    scroll_frame = PanelContainer.new()

    scroll_frame.name = "ScrollFrame"

    scroll_frame.size_flags_horizontal = Control.SIZE_EXPAND_FILL

    scroll_frame.size_flags_vertical = Control.SIZE_EXPAND_FILL

    scroll_frame.add_theme_stylebox_override("panel", _make_box(colors.get("surface"), colors.get("border"), int(options.get("frame_radius", 0))))

    root.add_child(scroll_frame)


    scroll = ScrollContainer.new()

    scroll.name = "Scroll"

    scroll.custom_minimum_size = Vector2(0, float(options.get("height", 320.0)))

    scroll.size_flags_horizontal = Control.SIZE_EXPAND_FILL

    scroll.size_flags_vertical = Control.SIZE_EXPAND_FILL

    scroll.horizontal_scroll_mode = ScrollContainer.SCROLL_MODE_DISABLED

    scroll.vertical_scroll_mode = ScrollContainer.SCROLL_MODE_SHOW_ALWAYS

    scroll.follow_focus = true

    scroll.add_theme_constant_override("scrollbar_minimum_size", int(options.get("scrollbar_width", 34)))

    scroll_frame.add_child(scroll)


    content_margin = MarginContainer.new()

    content_margin.name = "ContentMargin"

    content_margin.size_flags_horizontal = Control.SIZE_EXPAND_FILL

    content_margin.add_theme_constant_override("margin_left", int(options.get("scrollbar_content_padding", 4)))

    content_margin.add_theme_constant_override("margin_top", int(options.get("scrollbar_content_padding", 4)))

    content_margin.add_theme_constant_override("margin_bottom", int(options.get("scrollbar_content_padding", 4)))

    content_margin.add_theme_constant_override("margin_right", int(options.get("scrollbar_padding", 38)))

    scroll.add_child(content_margin)


    rows = VBoxContainer.new()

    rows.name = "Rows"

    rows.size_flags_horizontal = Control.SIZE_EXPAND_FILL

    rows.add_theme_constant_override("separation", int(options.get("row_gap", 4)))

    content_margin.add_child(rows)

    var bar = scroll.get_v_scroll_bar()

    if bar != null:

        bar.custom_minimum_size.x = int(options.get("scrollbar_width", 34))


func _style_filters(active_filter:String) -> void:

    options["active_filter"] = active_filter

    if filter_row == null:

        return

    for button in filter_row.get_children():

        if not button is Button:

            continue

        var active = str(button.name).to_lower().begins_with(active_filter)

        _apply_button_style(button, active, true)


func _style_header(sort_key:String, sort_ascending:bool) -> void:

    options["active_sort_key"] = sort_key

    options["active_sort_ascending"] = sort_ascending

    if header_row == null:

        return

    for index in range(columns.size()):

        var button = header_row.get_child(index)

        if not button is Button:

            continue

        var column = columns[index]

        var key = str(column.get("sort_key", column.get("key", "")))

        var active = key == sort_key

        var label = str(column.get("label", "Column"))

        if active:

            label += " v" if sort_ascending else " ^"

        button.text = label

        _apply_button_style(button, active, false)


func _create_row_shell() -> Button:

    var row = Button.new()

    row.text = ""

    row.clip_text = true

    row.size_flags_horizontal = Control.SIZE_EXPAND_FILL

    row.focus_mode = Control.FOCUS_ALL

    row.pressed.connect(func(): _emit_row_selected(row))

    row.focus_entered.connect(func(): _emit_row_selected(row))

    return row


func _configure_row(row:Button, record:Dictionary) -> void:

    row.name = "Row_%s" % str(record.get("id", "item"))

    row.set_meta("record_id", str(record.get("id", "")))

    row.tooltip_text = str(record.get("tooltip", ""))

    row.custom_minimum_size = Vector2(0, float(options.get("row_height", 76.0)))

    row.disabled = bool(record.get("disabled", false))

    var selected = bool(record.get("selected", false))

    var border = record.get("border_color", colors.get("border"))

    if selected:

        border = colors.get("accent")

    row.add_theme_stylebox_override("normal", _make_box(colors.get("surface_selected") if selected else colors.get("surface"), border, 0))

    row.add_theme_stylebox_override("hover", _make_box(colors.get("surface_selected"), colors.get("accent"), 0))

    row.add_theme_stylebox_override("pressed", _make_box(colors.get("surface_selected"), colors.get("accent"), 0))

    row.add_theme_stylebox_override("disabled", _make_box(colors.get("surface"), border.darkened(0.25), 0))

    for child in row.get_children():

        row.remove_child(child)

        child.queue_free()


    var margin = MarginContainer.new()

    margin.set_anchors_preset(Control.PRESET_FULL_RECT)

    margin.offset_left = 6

    margin.offset_top = 5

    margin.offset_right = -6

    margin.offset_bottom = -5

    margin.mouse_filter = Control.MOUSE_FILTER_IGNORE

    row.add_child(margin)


    var cells = HBoxContainer.new()

    cells.size_flags_horizontal = Control.SIZE_EXPAND_FILL

    cells.add_theme_constant_override("separation", 0)

    cells.mouse_filter = Control.MOUSE_FILTER_IGNORE

    margin.add_child(cells)

    for index in range(columns.size()):

        cells.add_child(_build_cell(record, columns[index], index))

    _apply_font_size_recursive(row, int(options.get("font_size", 16)))


func _emit_row_selected(row:Button) -> void:

    var callback = options.get("select_callback", Callable())

    if callback.is_valid():

        callback.call(str(row.get_meta("record_id", "")))


func _build_cell(record:Dictionary, column:Dictionary, index:int) -> Control:

    var key = str(column.get("key", ""))

    var values = record.get("values", {})

    var cell = HBoxContainer.new()

    cell.size_flags_horizontal = Control.SIZE_EXPAND_FILL

    cell.size_flags_vertical = Control.SIZE_EXPAND_FILL

    cell.size_flags_stretch_ratio = float(column.get("ratio", 1.0))

    cell.add_theme_constant_override("separation", 5)

    cell.mouse_filter = Control.MOUSE_FILTER_IGNORE

    if index == 0 and record.get("icon", null) != null:

        var icon = TextureRect.new()

        icon.texture = record.get("icon")

        icon.custom_minimum_size = Vector2(34, 34)

        icon.stretch_mode = TextureRect.STRETCH_KEEP_ASPECT_CENTERED

        icon.expand_mode = TextureRect.EXPAND_IGNORE_SIZE

        icon.mouse_filter = Control.MOUSE_FILTER_IGNORE

        cell.add_child(icon)

    var value = values.get(key, {})

    var label = Label.new()

    label.text = str(value.get("text", ""))

    label.autowrap_mode = TextServer.AUTOWRAP_WORD_SMART if bool(column.get("wrap", false)) else TextServer.AUTOWRAP_OFF

    label.max_lines_visible = int(column.get("lines", 1))

    label.clip_text = true

    label.text_overrun_behavior = TextServer.OVERRUN_TRIM_ELLIPSIS

    label.vertical_alignment = VERTICAL_ALIGNMENT_CENTER

    label.horizontal_alignment = int(column.get("align", value.get("align", HORIZONTAL_ALIGNMENT_LEFT)))

    label.size_flags_horizontal = Control.SIZE_EXPAND_FILL

    label.size_flags_vertical = Control.SIZE_EXPAND_FILL

    label.add_theme_color_override("font_color", value.get("color", colors.get("text")))

    label.mouse_filter = Control.MOUSE_FILTER_IGNORE

    cell.add_child(label)

    return cell


func _apply_button_style(button:Button, active:bool, rounded:bool) -> void:

    var border = colors.get("accent") if active else colors.get("border")

    button.add_theme_stylebox_override("normal", _make_box(colors.get("surface"), border, 0 if not rounded else 4))

    button.add_theme_stylebox_override("hover", _make_box(colors.get("surface_selected"), colors.get("accent"), 0 if not rounded else 4))

    button.add_theme_stylebox_override("pressed", _make_box(colors.get("surface_selected"), colors.get("accent"), 0 if not rounded else 4))

    button.add_theme_color_override("font_color", colors.get("text"))

    var size_key = "filter_font_size" if rounded else "header_font_size"

    var font_size = int(options.get(size_key, options.get("font_size", 16)))

    button.add_theme_font_size_override("font_size", font_size)

    button.add_theme_font_size_override("font_hover_size", font_size)

    button.add_theme_font_size_override("font_pressed_size", font_size)


func _make_box(bg:Color, border:Color, radius:int) -> StyleBoxFlat:

    var style = StyleBoxFlat.new()

    style.bg_color = bg

    style.border_color = border

    style.set_border_width_all(1)

    style.set_corner_radius_all(radius)

    style.content_margin_left = 6

    style.content_margin_right = 6

    style.content_margin_top = 6

    style.content_margin_bottom = 6

    return style


func _apply_font_size_recursive(node:Node, font_size:int) -> void:

    if node is Control:

        node.add_theme_font_size_override("font_size", font_size)

        if node is Button:

            node.add_theme_font_size_override("font_hover_size", font_size)

            node.add_theme_font_size_override("font_pressed_size", font_size)

    for child in node.get_children():

        _apply_font_size_recursive(child, font_size)

inventory_list.int
int
Definition inventory_list.gd:52

inventory_list.float
float
Definition inventory_list.gd:115