docs/status__feed__manager_8gd_source.html

extends RefCounted


var messages := []

var last_message := ""

var node_prefix := "StatusFeed"


func push(message:String, now_ms:int, options:Dictionary = {}) -> void:

    message = _normalize(message)

    if message == "":

        return

    if bool(options.get("dedupe_last", true)) and message == last_message:

        return

    last_message = message

    var until_ms = now_ms + int(options.get("duration_ms", 3600))

    for entry in messages:

        if entry is Dictionary and str(entry.get("text", "")) == message:

            entry["until"] = until_ms

            return

    messages.push_front({

        "text": message,

        "until": until_ms

    })

    var limit = int(options.get("history_limit", 4))

    while messages.size() > limit:

        messages.pop_back()


func render(parent:Control, now_ms:int, rect:Rect2, options:Dictionary = {}) -> void:

    if parent == null:

        return

    node_prefix = str(options.get("node_prefix", node_prefix))

    expire(now_ms)

    if messages.is_empty():

        clear_nodes(parent)

        return

    var max_entries = int(options.get("max_entries", 4))

    var gap = float(options.get("gap", 6.0))

    var padding = float(options.get("padding", 8.0))

    var line_height = float(options.get("line_height", 18.0))

    var max_lines = int(options.get("max_lines", 4))

    var font_size = int(options.get("font_size", 13))

    var y = rect.position.y

    var rendered_count = min(max_entries, messages.size())

    for index in range(rendered_count):

        var entry = messages[index]

        if not entry is Dictionary:

            continue

        var wrapped = wrap_text(str(entry.get("text", "")), rect.size.x - padding * 2.0, options)

        var height = padding * 2.0 + float(wrapped.get("line_count", 1)) * line_height

        var alpha = max(float(options.get("min_alpha", 0.42)), float(options.get("alpha", 0.82)) - float(index) * float(options.get("alpha_step", 0.12)))

        var bg = _panel_node(parent, _indexed_name("%sPanel" % node_prefix, index))

        bg.position = Vector2(rect.position.x, y)

        bg.size = Vector2(rect.size.x, height)

        bg.color = Color(str(options.get("background", "#0a0d10")))

        bg.color.a = alpha

        bg.mouse_filter = Control.MOUSE_FILTER_IGNORE

        bg.visible = true

        var label = _label_node(parent, _indexed_name("%sText" % node_prefix, index))

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

        label.position = bg.position + Vector2(padding, padding * 0.6)

        label.size = Vector2(rect.size.x - padding * 2.0, height - padding)

        label.clip_contents = true

        label.autowrap_mode = TextServer.AUTOWRAP_OFF

        label.max_lines_visible = max_lines

        label.add_theme_font_size_override("font_size", font_size)

        label.mouse_filter = Control.MOUSE_FILTER_IGNORE

        label.visible = true

        y += height + gap

    _hide_unused_nodes(parent, rendered_count)


func expire(now_ms:int) -> void:

    for index in range(messages.size() - 1, -1, -1):

        var entry = messages[index]

        if not entry is Dictionary or now_ms > int(entry.get("until", 0)):

            messages.remove_at(index)

    if messages.is_empty():

        last_message = ""


func clear_nodes(parent:Node) -> void:

    if parent == null:

        return

    _hide_unused_nodes(parent, 0)


func get_messages() -> Array:

    return messages.duplicate(true)


func set_messages(value:Array) -> void:

    messages = value.duplicate(true)


func wrap_text(message:String, width:float, options:Dictionary = {}) -> Dictionary:

    var chars_per_line = max(12, int(floor(width / float(options.get("char_width", 8.0)))))

    var max_lines = int(options.get("max_lines", 4))

    var lines := []

    var current := ""

    for raw_word in _normalize(message).split(" ", false):

        var word = str(raw_word)

        if current == "":

            current = word

        elif current.length() + 1 + word.length() <= chars_per_line:

            current += " " + word

        else:

            lines.append(current)

            current = word

    if current != "":

        lines.append(current)

    if lines.size() > max_lines:

        lines = lines.slice(0, max_lines)

        lines[max_lines - 1] = str(lines[max_lines - 1]).trim_suffix(".") + "..."

    return {

        "text": "\n".join(lines),

        "line_count": max(1, lines.size())

    }


func _normalize(message:String) -> String:

    return " ".join(message.replace("\n", " ").split(" ", false)).strip_edges()


func _indexed_name(base_name:String, index:int) -> String:

    return base_name if index == 0 else "%s%d" % [base_name, index]


func _panel_node(parent:Control, node_name:String) -> ColorRect:

    var node = parent.get_node_or_null(node_name)

    if node is ColorRect:

        return node

    var created = ColorRect.new()

    created.name = node_name

    created.mouse_filter = Control.MOUSE_FILTER_IGNORE

    parent.add_child(created)

    return created


func _label_node(parent:Control, node_name:String) -> Label:

    var node = parent.get_node_or_null(node_name)

    if node is Label:

        return node

    var created = Label.new()

    created.name = node_name

    created.mouse_filter = Control.MOUSE_FILTER_IGNORE

    parent.add_child(created)

    return created


func _hide_unused_nodes(parent:Node, used_count:int) -> void:

    for child in parent.get_children():

        var child_name = str(child.name)

        if not child_name.begins_with(node_prefix):

            continue

        var index = _node_index(child_name)

        if index >= used_count and child is CanvasItem:

            child.visible = false


func _node_index(child_name:String) -> int:

    var suffix = child_name.trim_prefix("%sPanel" % node_prefix)

    if child_name.begins_with("%sText" % node_prefix):

        suffix = child_name.trim_prefix("%sText" % node_prefix)

    return int(suffix) if suffix.is_valid_int() else 0