Pannelli

Il ciclo

Un pannello definisce view(state) e, facoltativamente, initial(), on_open(state) e on_action(action, state). Clink chiama initial() una volta per lo stato iniziale, on_open ogni volta che il pannello compare, poi view(state) per costruire l'interfaccia. Un controllo inserisce testo dove stai scrivendo, imposta nuovo stato, oppure indica un'azione che on_action gestisce, e la vista viene ricostruita.

def initial():
    return {"count": 0, "step": 1}

def view(state):
    return vstack([
        text(f"{state['count']}", size=34, weight="bold", align="center"),
        segmented(["1", "5", "10"], value=str(state["step"]), action="step"),
        hstack([
            button("−", "bump", value=-1),
            button("+", "bump", value=1, style="primary"),
        ]),
        button("Type it", "type", icon="keyboard"),
    ])

def on_action(action, value, state):
    if action == "bump":
        state["count"] = state["count"] + value * state["step"]
    elif action == "step":
        state["step"] = int(value)
    elif action == "type":
        insert(str(state["count"]))
        close()
    return state

Calcolatrici, bacheche di snippet, selettori: i tuoi pannelli compaiono dietro il pulsante pannelli della tastiera.

Costruttori

view(state) restituisce nodi creati da queste 19 funzioni. Annidale liberamente: pile e griglie accettano un elenco di figli.

Una semplice stringa vale ovunque valga un nodo: viene disegnata come testo nella dimensione predefinita.

Rispondere a un tocco

Un controllo che deve calcolare qualcosa indica un'action invece di portare un set fisso. Clink chiama allora on_action(action, state), oppure on_action(action, value, state) quando serve il valore che il controllo porta con sé. Lo stato è un normale dizionario: puoi modificarlo sul posto senza restituire nulla, o restituirne uno nuovo.

def initial():
    return {"items": [], "draft": ""}

def view(state):
    return vstack([
        field("draft", placeholder="Add one…", submit="add"),
        scroll([row(item, action="use", value=item) for item in state["items"]]),
    ])

def on_action(action, value, state):
    if action == "add" and value:
        state["items"].append(value)
        state["draft"] = ""
    elif action == "use":
        insert(value)
        close()
    return state

on_open(state) viene eseguita ogni volta che il pannello compare: è lì che un pannello parte da quello che stai scrivendo.

Chiedere alla tastiera

Da on_action e on_open un pannello può chiedere alla tastiera cose che un valore di ritorno non sa esprimere. Ogni chiamata viene annotata e applicata dopo che la tua funzione è terminata, così un pannello non modifica mai il campo mentre la sua vista viene costruita.

def on_action(action, state):
    if action == "quote":
        word = context()["word"]
        replace(len(word), "“" + word + "”")
        haptic("light")
    return state

context() legge quello che sta attorno al cursore: before, selected, after, word, clipboard, locale, language, full_access e time. È un’istantanea presa all’inizio della chiamata, quindi non può cambiarti sotto a metà del rendering.

Lo stato

Lo stato è un normale dizionario e contiene tutto ciò che uno script sa costruire: numeri, stringhe, booleani, None, e liste e dizionari di questi. Ti viene restituito a ogni chiamata, quindi una lista a cui hai aggiunto con un tocco c'è ancora al tocco dopo.

def initial():
    return {"name": ""}

def view(state):
    return vstack([
        field("name", placeholder="Who?"),
        button("Greet", insert="Hi " + state["name"] + "!", style="primary"),
    ])

Ricorda lo stato conserva il contenuto del pannello tra un'apertura e l'altra, e tra le sessioni della tastiera. Lascialo spento per una calcolatrice, accendilo per un elenco.

Lo stato vive finché la tastiera è sullo schermo, e più a lungo quando il pannello ricorda. Un pannello può leggere il testo attorno al cursore con context(); nient'altro su di te.

Limiti

Una tastiera riceve una frazione della memoria di un'app, quindi i pannelli sono limitati anziché considerati affidabili. Ogni rendering ha 2.000.000 passi di interprete, e un ciclo impazzito finisce con un errore a schermo invece che con una tastiera che smette di rispondere.

Un pannello che arriva come file o da un repository viene controllato prima di essere salvato. Deve stare sotto 48.000 byte e 1200 righe, deve definire def view(, ogni import deve nominare uno degli spazi dei nomi isolati, e questi frammenti vengono rifiutati senz'altro:

I pannelli che scrivi nell'app non sono soggetti a quell'elenco. A fermare un ciclo impazzito resta allora solo il budget di passi: lasciagli una via d'uscita.

Posizionamento

Assegna a ogni pannello un proprio pulsante nel selettore, invece di annidarli tutti dietro un unico pulsante Pannelli. I singoli pannelli possono sovrascrivere questa impostazione nel proprio editor.

Predefinito segue quell'interruttore, Indipendente prende sempre un pulsante suo e Raggruppato si annida sempre.

Scriverne uno

1. Apri Pannelli personalizzati in Clink e tocca Nuovo pannello.
2. Scrivi lo script. Accanto gira un'anteprima del pannello vero e gli errori compaiono mentre scrivi.
3. Salva, attiva il pannello, poi apri il pulsante dei pannelli sulla tastiera.

Pannello di condivisione crea un file .clinkpanel, che è JSON. Riaprendolo in Clink viene salvato con un id nuovo, quindi importare due volte lo stesso pannello non sovrascrive mai il primo.