V-Panel/scripts/dashboard_grid.gd

extends Control
class_name DashboardGrid


signal module_placed(module: Control, col: int, row: int)
signal module_removed(module: Control)

@export var cell_min_size: Vector2 = Vector2(300, 240)
@export var cell_spacing: float = 8.0
@export var margin: float = 16.0

var columns: int = 0
var rows: int = 0

var _cells: Array = []  # 2D: _cells[row][col] -> PanelContainer
var _module_positions: Dictionary = {}  # "col,row" -> Control


func _ready() -> void:
    resized.connect(_rebuild_grid)
    _rebuild_grid()


func place_module(module: Control, col: int, row: int) -> void:
    if not _is_valid_cell(col, row):
        return
    var cell: PanelContainer = _cells[row][col]
    _set_cell_child(cell, module)
    _module_positions["%d,%d" % [col, row]] = module
    module_placed.emit(module, col, row)


func remove_module(col: int, row: int) -> void:
    if not _is_valid_cell(col, row):
        return
    var cell: PanelContainer = _cells[row][col]
    var key := "%d,%d" % [col, row]
    for child in cell.get_children():
        cell.remove_child(child)
        if is_instance_valid(child):
            module_removed.emit(child)
            child.queue_free()
    _module_positions.erase(key)


func get_grid_size() -> Vector2i:
    return Vector2i(columns, rows)


func _is_valid_cell(col: int, row: int) -> bool:
    return row >= 0 and row < _cells.size() and col >= 0 and col < _cells[row].size()


func _set_cell_child(cell: PanelContainer, child: Control) -> void:
    for existing in cell.get_children():
        cell.remove_child(existing)
        if is_instance_valid(existing):
            existing.queue_free()
    cell.add_child(child)


func _rebuild_grid() -> void:
    var avail := size - Vector2(margin * 2.0, margin * 2.0)
    if avail.x < cell_min_size.x or avail.y < cell_min_size.y:
        _teardown_cells()
        return

    var new_cols := maxi(1, int(avail.x / (cell_min_size.x + cell_spacing)))
    var new_rows := maxi(1, int(avail.y / (cell_min_size.y + cell_spacing)))

    # Bail out if grid dimensions haven't changed
    if new_cols == columns and new_rows == rows and _cells.size() > 0:
        _layout_cells()
        return

    columns = new_cols
    rows = new_rows

    _save_modules()
    _teardown_cells()
    _build_cells()
    _restore_modules()
    _layout_cells()


func _build_cells() -> void:
    _cells.clear()
    for row in range(rows):
        _cells.append([])
        for col in range(columns):
            var cell := PanelContainer.new()
            cell.name = "Cell_%d_%d" % [col, row]
            cell.mouse_filter = Control.MOUSE_FILTER_PASS
            _style_cell(cell)
            add_child(cell)
            _cells[row].append(cell)


func _style_cell(cell: PanelContainer) -> void:
    var style := StyleBoxFlat.new()
    style.bg_color = Color(0.14, 0.14, 0.18, 1.0)
    style.border_width_left = 1
    style.border_width_top = 1
    style.border_width_right = 1
    style.border_width_bottom = 1
    style.border_color = Color(0.25, 0.25, 0.35, 1.0)
    style.corner_radius_top_left = 6
    style.corner_radius_top_right = 6
    style.corner_radius_bottom_right = 6
    style.corner_radius_bottom_left = 6
    cell.add_theme_stylebox_override("panel", style)
    cell.add_theme_stylebox_override("panel_focused", style)


func _teardown_cells() -> void:
    for child in get_children():
        remove_child(child)
        if is_instance_valid(child):
            child.queue_free()
    _cells.clear()


func _layout_cells() -> void:
    if rows == 0 or columns == 0:
        return

    var inner_w := size.x - margin * 2.0 - cell_spacing
    var inner_h := size.y - margin * 2.0 - cell_spacing
    var gap_x := cell_spacing * (columns - 1)
    var gap_y := cell_spacing * (rows - 1)
    var cell_w := (inner_w - gap_x) / columns
    var cell_h := (inner_h - gap_y) / rows

    for row in range(rows):
        for col in range(columns):
            var cell: PanelContainer = _cells[row][col]
            if not is_instance_valid(cell):
                continue
            var x := margin + cell_spacing + col * (cell_w + cell_spacing)
            var y := margin + cell_spacing + row * (cell_h + cell_spacing)
            cell.set_position(Vector2(x, y))
            cell.set_size(Vector2(cell_w, cell_h))


func _save_modules() -> void:
    _module_positions.clear()
    for row in range(_cells.size()):
        for col in range(_cells[row].size()):
            var cell: PanelContainer = _cells[row][col]
            if cell.get_child_count() > 0:
                var mod := cell.get_child(0)
                cell.remove_child(mod)
                _module_positions["%d,%d" % [col, row]] = mod


func _restore_modules() -> void:
    for key in _module_positions:
        var parts: PackedStringArray = key.split(",")
        var col: int = int(parts[0])
        var row := int(parts[1])
        var module: Control = _module_positions[key]

        if _is_valid_cell(col, row):
            _set_cell_child(_cells[row][col], module)
        else:
            # Place in the last available cell if original position no longer exists
            if _cells.size() > 0 and _cells[0].size() > 0:
                var last_row := _cells.size() - 1
                var last_col: int = _cells[last_row].size() - 1
                _set_cell_child(_cells[last_row][last_col], module)
            else:
                module.queue_free()

    _module_positions.clear()