Forge-Engine/screens/elements/list_elements.py

import json

import db

from ..rendering.render_element_html import render_element_html
from ..element_types.is_overlay_only import _is_overlay_only_element_type


def list_elements(slug, screen_id, enforce_visibility=False, player_id=db.PLAYER_SHARED):
    """Renvoie TOUS les éléments de l'écran, à plat (parent_id indique
    l'imbrication) — pratique pour construire l'arbre côté appelant. CHAQUE
    élément (premier niveau ou imbriqué) reçoit son propre "rendered_html" :
    celui d'un conteneur/répéteur/groupe de champs inclut, en le générant
    récursivement, le HTML de tout ce qui est posé à l'intérieur — un
    élément imbriqué s'y retrouve donc DEUX FOIS (une fois dans le
    rendered_html de son ancêtre de premier niveau, utilisé pour le rendu
    HTML initial de la page ; une fois dans le sien propre) : c'est ce
    dédoublement délibéré qui permet à play.html (voir applyOpenRowBindings/
    refreshRuntimeData) de régénérer ou patcher UN SEUL élément imbriqué
    (ex. un panneau de détail posé dans un conteneur) sans reconstruire tout
    son ancêtre de premier niveau — potentiellement l'écran entier. Avant ce
    changement, seuls les éléments de premier niveau recevaient un
    rendered_html ; un élément imbriqué n'en avait AUCUN côté client, qui
    retombait donc toujours sur la régénération de son ancêtre de premier
    niveau, quelle que soit la finesse du ciblage côté JS.

    enforce_visibility : True uniquement pour le mode jouable (voir
    full_game_payload.py) — applique la "condition de visibilité" de chaque
    élément (voir visibility_condition.py). Toujours False pour l'éditeur,
    qui doit continuer à montrer/sélectionner un élément même si sa
    condition serait actuellement fausse.

    player_id (état par joueur, Phase 1) : posé dans ctx["_forge_player_id"]
    pour tout le rendu en aval (Répéteur/Jauge/Donnée liée/condition de
    visibilité) — quel joueur consulte cet écran, pour qu'un objet/une
    variable per_player affiche SA valeur (voir db/global_vars/,
    db/rows/)."""
    conn = db.connect(slug)
    rows = conn.execute(
        "SELECT * FROM _screen_elements WHERE screen_id = ? ORDER BY z_index, id", (screen_id,)
    ).fetchall()
    conn.close()
    result = []
    for r in rows:
        d = dict(r)
        d["style"] = json.loads(d["style"] or "{}")
        d["attributes"] = json.loads(d["attributes"] or "{}")
        result.append(d)

    # Descendant d'un exemplaire d'élément de jeu (element_type_id réglé sur
    # un ancêtre) : un ancien enfant copié en base par l'ex-instantiate_
    # template_tree (mécanisme retiré, voir add_element.py) — son contenu
    # vient désormais TOUJOURS en direct de l'écran-modèle au moment du
    # rendu (voir render_element_html.py/_render_element_type_children),
    # jamais de ces lignes, qui peuvent encore traîner en base pour un
    # exemplaire posé avant ce changement. Exclu ici pour ne plus jamais
    # apparaître sélectionnable dans l'arborescence de l'éditeur — sinon
    # ses réglages, plus jamais synchronisés avec le modèle, donnaient
    # l'impression trompeuse que "les propriétés ne sont pas prises en
    # compte" (une taille de texte modifiée dans le modèle ne se reflétant
    # jamais sur cette ligne fantôme, toujours sélectionnable à l'écran).
    by_id = {d["id"]: d for d in result}

    def _has_linked_ancestor(d):
        seen = set()
        parent_id = d.get("parent_id")
        while parent_id and parent_id not in seen:
            seen.add(parent_id)
            parent = by_id.get(parent_id)
            if not parent:
                return False
            if parent.get("element_type_id"):
                return True
            parent_id = parent.get("parent_id")
        return False

    result = [d for d in result if not _has_linked_ancestor(d)]

    children_map = {}
    for d in result:
        if d.get("parent_id"):
            children_map.setdefault(d["parent_id"], []).append(d)
    play_ctx = {"_forge_play_mode": True, "_forge_player_id": player_id} if enforce_visibility else None
    for d in result:
        # Un exemplaire de premier niveau d'un élément de jeu dont le
        # modèle N'EST QU'une superposition : son cadre de positionnement
        # (.canvasElement/.playElement, voir filters/element_style_filter.py)
        # ne doit pas non plus poser de z-index, pour la même raison qu'une
        # superposition posée directement (sinon elle crée un contexte
        # d'empilement CSS qui piège le z-index:9999 de la superposition
        # rendue à l'intérieur — voir element_style_filter.py).
        if d.get("element_type_id") and not d.get("parent_id"):
            d["_overlay_only_instance"] = _is_overlay_only_element_type(slug, d["element_type_id"])
        d["rendered_html"] = render_element_html(d, slug, children_map, play_ctx)
    return result