Bereiche

Die Schleife

Ein Panel definiert view(state) und optional initial(), on_open(state) und on_action(action, state). Clink ruft initial() einmal für den Startzustand auf, on_open bei jedem Erscheinen des Panels und dann view(state), um die Oberfläche zu bauen. Ein Bedienelement fügt entweder Text dort ein, wo du schreibst, setzt neuen Zustand oder benennt eine Aktion für on_action – und die Ansicht wird neu gebaut.

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

Taschenrechner, Snippet-Boards, Picker: deine Panels erscheinen hinter der Panel-Taste der Tastatur.

Bausteine

view(state) gibt Knoten zurück, die diese 19 Funktionen erzeugen. Verschachtle sie frei: Stapel und Raster nehmen eine Liste von Kindern.

Ein schlichter String funktioniert überall dort, wo ein Knoten funktioniert: er erscheint als Text in der Standardgröße.

Auf eine Berührung reagieren

Ein Bedienelement, das etwas berechnen muss, nennt ein action statt ein festes set zu tragen. Clink ruft dann on_action(action, state) auf – oder on_action(action, value, state), wenn du den Wert des Bedienelements brauchst. Der Zustand ist ein gewöhnliches Dictionary: Du kannst ihn direkt ändern und nichts zurückgeben, oder ein neues zurückgeben.

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) läuft jedes Mal, wenn das Panel erscheint – dort holt sich ein Panel seinen Anfangswert aus dem, was du gerade schreibst.

Die Tastatur bitten

Aus on_action und on_open heraus kann ein Panel die Tastatur um Dinge bitten, die ein Rückgabewert nicht ausdrücken kann. Jeder Aufruf wird notiert und erst nach dem Ende deiner Funktion ausgeführt – ein Panel bearbeitet das Feld also nie, während seine eigene Ansicht entsteht.

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

context() liest, was um die Einfügemarke herum steht: before, selected, after, word, clipboard, locale, language, full_access und time. Es ist eine Momentaufnahme vom Beginn des Aufrufs und kann sich mitten im Rendern nicht unter dir ändern.

Zustand

Der Zustand ist ein gewöhnliches Dictionary und enthält alles, was ein Skript bauen kann: Zahlen, Zeichenketten, Wahrheitswerte, None sowie Listen und Dictionaries davon. Er wird dir bei jedem Aufruf zurückgereicht – eine Liste, an die du bei einer Berührung angehängt hast, ist bei der nächsten noch da.

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

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

Zustand merken behält den Inhalt des Panels zwischen zwei Aufrufen – und über Tastatursitzungen hinweg. Für einen Rechner aus lassen, für eine Liste einschalten.

Der Zustand lebt, solange die Tastatur auf dem Bildschirm ist – und länger, wenn sich das Panel erinnert. Ein Panel kann mit context() den Text rund um den Cursor lesen; sonst nichts über dich.

Grenzen

Eine Tastatur bekommt einen Bruchteil des Speichers einer App, deshalb sind Panels begrenzt statt vertraut. Jeder Aufbau bekommt 2.000.000 Interpreter-Schritte, und eine entlaufene Schleife endet mit einem Fehler auf dem Bildschirm statt mit einer Tastatur, die nicht mehr antwortet.

Ein Panel, das als Datei oder aus einem Repository kommt, wird vor dem Speichern geprüft. Es muss unter 48.000 Bytes und 1.200 Zeilen bleiben, es muss def view( definieren, jedes import muss einen der abgeschotteten Namensräume nennen – und diese Fragmente werden rundweg abgelehnt:

Panels, die du in der App schreibst, unterliegen dieser Liste nicht. Dann hält nur noch das Schrittbudget eine ausufernde Schleife auf – gib ihr also einen Ausweg.

Platzierung

Gib jedem Panel einen eigenen Button im Picker, statt sie alle hinter einem Panels-Button zu verschachteln. Einzelne Panels können das in ihrem Editor überschreiben.

Standard folgt diesem Schalter, Eigenständig bekommt immer eine eigene Taste, und Gruppiert verschachtelt immer.

Eines schreiben

1. Öffne Eigene Panels in Clink und tippe auf Neues Panel.
2. Schreib das Skript. Daneben läuft eine Vorschau des echten Panels, und Fehler erscheinen beim Tippen.
3. Sichern, das Panel einschalten, dann auf der Tastatur die Panel-Taste öffnen.

Teilen-Panel schreibt eine .clinkpanel-Datei, also JSON. Öffnest du sie wieder in Clink, wird sie mit frischer ID gesichert: dasselbe Panel zweimal zu importieren überschreibt das erste nie.