Pistikprogrammid

Automaatikad

Faili .clinkplugin valikuline automation-objekt deklareerib sündmused, oleku, sätted, käsud, valmisreeglid ja otseteekohad. Igal lisandusel on püsiv ID, täpne skeemiversioon ja tõlgitud pealkirjad. Host loob nimed kujul plugin/<plugin-id>/<kind>/<id>. Pistikprogramm ei saa kasutada süsteemi ega teise pistikprogrammi nimeruumi.

Kuidas pistikprogrammid töötavad

Paneel asendab klahvid ja toiming käivitub üks kord tekstilõigu peal. Pistikprogrammil pole klaviatuuril oma ekraani. Clink kutsub selle funktsioone kindlatel hetkedel, näiteks kui klaviatuur avaneb või kui sa sõna lõpetad, ja pistikprogramm saab uuendada tühikuklahvi või oma salvestatud olekut. Selle seaded joonistatakse rakenduses samade ehitajatega, mida kasutavad paneelid. Allpool olev WPM Spacebar on terviklik pistikprogramm.

def initial():
    return {"on": False}

def settings(state):
    return section("keys.spacebar", [
        toggle("Show typing speed", state["on"], action="toggle"),
    ], title="WPM Spacebar")

def on_action(action, value, state):
    state["on"] = value
    if value:
        claim("spacebar.text")
    else:
        release("spacebar.text")
        space_text(None)
    return state

def on_word(word, state):
    if state["on"]:
        space_text(f"{stats()['wpm']} wpm")
    return state

Pistikprogrammide kasutamiseks on vaja Clink Pro liikmesust. Enne hoidlast pistikprogrammi paigaldamist küsib Clink, kas lubad selle hoidla koodi, täpselt nagu paneelide ja toimingute puhul.

on_key ja on_word saavad teksti, mida sa tipid, sest nii sõnaloendur töötab. PyMini-l pole ligipääsu võrgule ega failidele, seega ei saa pistikprogramm sinu tipitud teksti interneti kaudu saata, ja mida see salvestab, jääb Clinki juurde sinu seadmesse.

Sinu esimene pistikprogramm

Kõige kiirem algus on alustusskript, mille rakendus sinu eest kirjutab. See paneb lüliti jaotisse Klahvid > Tühikuklahv ja loeb lüliti sees olles tühikuklahvil sõnu. Viis sammu, midagi pole vaja alla laadida.

1. Ava vahekaart Pistikprogrammid, lülita pistikprogrammid üleval sisse ja puuduta uue loomiseks +.
2. Redaktor avaneb alustusskriptiga. Loe see korra läbi: initial(), settings(), on_action(), on_open() ja on_word() ongi kõik.
3. Lülitu eelvaatele. Lülita lüliti sisse, puuduta seejärel paar korda on_open ja on_word ning jälgi tühikuklahvi makettiat ja konsooli.
4. Salvesta. Pistikprogramm on loendis sees ja selle lüliti asub nüüd ka jaotises Klahvid > Tühikuklahv.
5. Ava klaviatuur ükskõik kus ja tipi. Tühikuklahv loeb kaasa.

def initial():
    return {"on": False, "words": 0}

def settings(state):
    return section("keys.spacebar", [
        toggle("Count words on the space bar", state["on"], action="toggle"),
    ], title="Word count")

def on_action(action, value, state):
    if action == "toggle":
        state["on"] = value
        if value:
            claim("spacebar.text")
        else:
            release("spacebar.text")
            space_text(None)
    return state

def on_open(state):
    state["words"] = 0
    if state["on"]:
        space_text("0 words")
    return state

def on_word(word, state):
    state["words"] += 1
    if state["on"]:
        space_text(f"{state['words']} words")
    return state

Haagid

Määratle ükskõik millised neist 33 funktsioonist ja jäta välja need, mida sul vaja pole. Igaüks saab viimase argumendina väärtuse state. Need, mis millelegi reageerivad, tagastavad state'i, muudetult või muutmata. Need, mis vastavad küsimusele (elements, draw, effects, välimuse haagid, haptics, hitboxes, suggestions ja correct), tagastavad oma vastuse ja võivad sealjuures state'i kohapeal muuta.

def on_key(key, state):
    if key == " " and setting("language") == "en":
        state["spaces"] = state.get("spaces", 0) + 1
    return state

def on_close(state):
    haptic("light")
    return state

Rakendusel ja klaviatuuril on olekust üks ühine koopia. Lülita rakenduses lüliti sisse ja see on sees, kui klaviatuur järgmine kord avaneb. Kõik, mida klaviatuur loendab, on olemas, kui avad järgmine kord pistikprogrammi seaded. Klaviatuur salvestab oleku sulgemisel, mitte iga klahvi järel.

Praegune soovitus tühikuklahvil

Peamise kuvatava soovituse saad lugeda avaldisega context()["suggestion"]. Telli sündmus predictions, et saada muudatused väljal info["suggestion"]. Mõlemad vajavad ligipääsu sisestusandmetele. on_suggestion käivitub soovituse valimisel, mitte soovituste muutumisel. Kutsu space_text(value or None), et määrata klahvi tekst või taastada see, kui soovitusi pole. Tühikuklahvi vajutamise toiming ei muutu.

def initial():
    return {}

def events(state):
    return ["predictions"]

def on_open(state):
    space_text(context()["suggestion"] or None)
    return state

def on_event(name, info, state):
    if name == "predictions":
        space_text(info["suggestion"] or None)
    return state

def on_close(state):
    space_text(None)
    return state

Olek

Olek on üks sõnastik. initial() ehitab selle esimesel korral; edaspidi saab iga haak sama sõnastiku, muudab seda ja annab tagasi. See mahutab kõike, mida JSON mahutab: arve, sõnu, loendeid, pesastatud sõnastikke. Rakendus salvestab selle pärast iga kasutatud juhtelementi, klaviatuur sulgemisel, ja mõlemad loevad sama faili, nii et nad ei ole kaua eriarvamusel.

def initial():
    return {"session": 0, "total": 0, "longest": ""}

def on_open(state):
    state["session"] = 0        # starts over each time the keyboard opens
    return state

def on_word(word, state):
    state["session"] += 1
    state["total"] += 1         # survives, it is saved when the keyboard closes
    if len(word) > len(state["longest"]):
        state["longest"] = word
    return state

def settings(state):
    return vstack([
        text(f"{state['total']:,} words so far"),
        text(f"Longest: {state['longest'] or '...'}", size=13, color="gray"),
        button("Start over", "reset", style="destructive"),
    ])

def on_action(action, value, state):
    if action == "reset":
        return initial()
    return state

Oleku tagastamine on harjumus, mida tasub hoida, kuid see pole rangelt nõutav: sõnastik on viide, seega töötab ka kohapeal muutmine. Tagasta teine sõnastik, nagu ülal initial(), ja sellest saab olek.

Seaded ja jaotised

settings(state) tagastab paneeliehitajatega tehtud sõlmepuu: text, toggle, slider, stepper, segmented, button, row, field ja paigutused. See ilmub pistikprogrammi lehel vahekaardil Pistikprogrammid. Kui mähid osa sellest section(anchor, children, title) sisse, ilmub see osa ka ühel Clinki enda seadete ekraanil, selle seade kõrval, millega see seotud on.

def settings(state):
    return vstack([
        text("Counts words as you type.", size=13),
        section("keys.spacebar", [
            toggle("Count on the space bar", state["on"], action="toggle"),
            stepper(state["goal"], min=10, max=500, step=10, label="Goal", key="goal"),
        ], title="Word count"),
    ])

Juhtelemendid, mida pistikprogramm kõige sagedamini vajab. Igaüks kirjutab oma uue väärtuse olekusse key alla või nimetab action-i on_action jaoks, või mõlemat. Täielik ehitajate loend koos paigutustega on paneelide lehel.

Kuhu jaotised lähevad

Ankur on Clinki enda seadeteekraani kaardi ID. Nimeta see section()-is ja pistikprogrammi juhtelemendid joonistatakse otse selle kaardi alla, pistikprogrammi nimi nende kohal. Lihtsaim viis ankru leidmiseks: ava rakenduses Rohkem > Arendaja ja lülita sisse Näita ID-sid. Iga kaart saab väikese infomärgi, mis nimetab tema ID ja kopeerib selle puudutusel; lehed näitavad enda oma tiitliribal.

keys.spacebar on oma koht tühikuklahvi ekraanil endal. Jaotis ankruga, mida selles loendis pole, kuvatakse ikkagi pistikprogrammi lehel, seega maksab kirjaviga sulle ühe kaardi, mitte pistikprogrammi.

Ülevõtmised

Kui pistikprogramm juhib mõnda Clinki enda seadet, peaks inimene seda nägema ja need kaks ei tohiks vaielda. claim(control) ütleb, et pistikprogramm omab seda: rakendus nimetab pistikprogrammi selle seade kaardil ja tühikuklahvi teksti väli on lukus, kuni see on hõivatud. release(control) annab selle tagasi. Võta üle selles on_action-is, mis su funktsiooni sisse lülitab, vabasta selles, mis välja lülitab, ja sea väärtus samal ajal tagasi None-iks või endiseks. Loendis välja lülitatud pistikprogramm vabastab kõik, mida see hoidis.

def on_action(action, value, state):
    if action == "toggle":
        state["on"] = value
        if value:
            claim("spacebar.text")
            space_text("...")
        else:
            release("spacebar.text")
            space_text(None)      # hand the person's own text back
    return state

Kaks pistikprogrammi võivad sama juhtelemendi üle võtta; rakendus nimetab selle, kes tegi seda viimasena. Ülevõtmised salvestab rakendus, seega võta üle on_action-is, mis seal töötab. Klaviatuuri sees tehtud ülevõtmist ei jäeta meelde.

Käsud ja lugemised

Pistikprogrammid saavad kasutada kõiki paneelikäske ning lisaks kuut oma käsku ja kahte lugemist. Käsud pannakse järjekorda ja rakendatakse pärast seda, kui sinu funktsioon on naasnud, nii et klaviatuuril ei muutu midagi poole kutse pealt. Lugemised tagastavad väärtused sellistena, nagu need olid vahetult enne kutset.

setting(name) ja set_setting(name, value) jagavad üht nimede loendit ja claim(control) võtab samuti ükskõik millise neist. Tõeväärtusi loetakse kui True või False, arve kui arve, valikuid kui nende id. Loend on meelega pikk: pistikprogramm võib reageerida peaaegu kõigele, mida inimene rakenduses seada saab, või seda juhtida.

Nagu paneeli view(), peaks ka settings() ainult juhtelemente kirjeldama. Sealt kutsutud käske eiratakse ja need logitakse konsooli.

Näited

Viis väikest pistikprogrammi, igaüks täielik. Kleebi üks uude pistikprogrammi, salvesta ja see töötab.

def initial():
    return {"on": True}

def settings(state):
    return section("keys.spacebar", [
        toggle("Language on the space bar", state["on"], action="toggle"),
    ], title="Language badge")

def on_action(action, value, state):
    if action != "toggle":
        return state
    state["on"] = value
    if value:
        claim("spacebar.text")
        space_text(setting("language").upper())
    else:
        release("spacebar.text")
        space_text(None)
    return state

def on_open(state):
    if state["on"]:
        space_text(setting("language").upper())
    return state

def on_language(code, state):
    if state["on"]:
        space_text(code.upper())
    return state

SHORTCUTS = {"omw": "on my way", "brb": "be right back", "ty": "thank you"}

def on_key(key, state):
    if key != " ":
        return state
    words = context()["before"].split()
    if words and words[-1] in SHORTCUTS:
        # the space is already in the text, so it goes too and comes back after
        replace(len(words[-1]) + 1, SHORTCUTS[words[-1]] + " ")
    return state

def initial():
    return {"goal": 200, "count": 0}

def settings(state):
    return vstack([
        stepper(state["goal"], min=50, max=2000, step=50, label="Words per session", key="goal"),
        progress(state["count"], total=state["goal"], label=f"{state['count']} of {state['goal']}"),
    ])

def on_open(state):
    state["count"] = 0
    return state

def on_word(word, state):
    state["count"] += 1
    if state["count"] == state["goal"]:
        haptic("medium")
        banner("Goal reached")
    return state

def initial():
    return {"muted": False, "was_on": True}

def on_field(kind, state):
    # a password or a number field is not a place for key sounds
    quiet = kind in ("password", "number", "phone")
    if quiet and not state["muted"]:
        state["was_on"] = setting("sound.enabled")
        state["muted"] = True
        set_setting("sound.enabled", False)
    elif not quiet and state["muted"]:
        state["muted"] = False
        if state["was_on"]:
            set_setting("sound.enabled", True)
    return state

NAMES = ["sam", "ana", "team"]

def on_key(key, state):
    typing = context()["before"].split(" ")[-1]
    if typing.startswith("@"):
        start = typing[1:].lower()
        suggest([n for n in NAMES if n.startswith(start)])
        state["showing"] = True
    elif state.get("showing"):
        suggest([])                 # the mention is over, give the bar back
        state["showing"] = False
    return state

def on_swipe(direction, state):
    if direction == "left":
        delete_word()
    elif direction == "right":
        press("space")              # the space bar's own path, so it autocorrects
    elif direction == "up":
        pick_suggestion("center")
    elif direction == "up_left":
        pick_suggestion("left")
    elif direction == "up_right":
        pick_suggestion("right")
    return state

Elemendid paigutuses

Kohandatud paigutus koosneb klahvidest ja elementidest: hiljutiste emojide riba, numbririda, kursoripadi. Pistikprogramm võib lisada omi. elements(state) ütleb, mida ta pakub, ja draw(id, state) joonistab ühe, nii et klahv võib näidata kõike, mida pistikprogramm oskab arvutada: kirjutamiskiiruse graafikut, kella, taimerit või oma aku näitu.

Kaks haaki ehitavad ühe. elements(state) loetleb, mida sa pakud, ühe kirje elemendi kohta, ja rakendus loeb seda paigutuse redaktori paleti jaoks. draw(id, state) saab ühe neist ID-dest ja tagastab, mida joonistada. Pistikprogramm võib pakkuda mitut; draw'lt küsitakse iga kohta eraldi.

POINTS = 30

def initial():
    return {"history": []}

def elements(state):
    return [element("sparkline", "WPM sparkline", icon="waveform.path.ecg", width=3)]

def on_tick(state):
    history = state["history"]
    history.append(stats()["wpm"])
    state["history"] = history[-POINTS:]
    return state

def draw(id, state):
    rate = state["history"][-1] if state["history"] else 0
    return hstack([
        sparkline(state["history"], min=0, max=max(60, max(state["history"] or [0])), fill=True),
        text(f"{rate}", size=12, weight="semibold"),
    ], spacing=5, align="center")

Nägu on sõlmepuu nagu seadete lehtki, aga klahv pole seadete leht: kasutatakse ainult joonistavaid sõlmi ja kõik puudutatav jäetakse vahele. Klahv kuulub juba paigutusele, nii et sinna sisse nuppu ei mahu.

Mõõda see klahvi järgi. width on klahvilaiustes: 1 on täht ja 3 umbes kolmandik reast, ning inimene saab seda hiljem muuta. Tekst saab ühe rea ja kahaneb, et mahtuda; värvid järgivad vaikimisi klahvi enda teksti värvi, nii et element sobib ümbritsevate klahvidega, kui sa teist ei palu. Sparkline hoiab viimased 120 punkti, rohkem kui klahv näidata jõuab.

import time

def elements(state):
    return [element("clock", "Clock", icon="clock", width=2)]

def draw(id, state):
    return text(time.format("HH:mm"), size=15, weight="semibold")

GOAL = 200

def initial():
    return {"words": 0}

def elements(state):
    return [element("goal", "Word goal", icon="target", width=2)]

def on_open(state):
    state["words"] = 0
    return state

def on_word(word, state):
    state["words"] += 1
    return state

def draw(id, state):
    return vstack([
        text(f"{state['words']}/{GOAL}", size=11),
        progress(state["words"], total=GOAL),
    ], spacing=2)

Elemendid elavad kohandatud paigutustes, nii et esmalt tuleb paigutus teha. Eelseaded neid hoida ei saa: eelseade haarutamine omaenda paigutuseks on esimene asi, mida redaktor pakub.

1. Paigalda pistikprogramm ja lülita see sisse. Selle elemendid ilmuvad kohe.
2. Ava Paigutus, loo või haaruta kohandatud paigutus ja mine jaotisse Korralda.
3. Puuduta Element, vali ribalt pistikprogrammi element ja määra selle laius.

Redaktori eelvaade joonistab kõik elemendid, mida skript pakub, umbes selle klahvi suuruses, kuhu need lähevad, tühikuklahvi makett selle kohal. Salvesta ja paiguta kord ning klaviatuur joonistab sedasama.

Element näitab ainult seda, mida pistikprogramm joonistab: puudutus ei tee midagi, sest klahv kuulub juba paigutusele. Paigutus hoiab elemendi alles ka siis, kui pistikprogramm on väljas või eemaldatud, ja klahv täitub uuesti, kui see naaseb.

Nupud ja kettad ülemisel ribal

Klahvide kohal olevat riba pannakse kokku jaotises Paigutus > Ülemine riba ja pistikprogramm võib sellele oma juhtelemendid pakkuda. bar_items(state) tagastab need: bar_button(...) on puudutamiseks, bar_knob(...) keeramiseks. Loend loetakse klaviatuuri avamisel ja uuesti pärast iga puudutust, nii et element võib pistikprogrammi olekuga tulla ja minna.

def initial():
    return {"width": 2.0}

def bar_items(state):
    return [
        bar_button("sig", "Sign off", icon="signature", title="Sign off"),
        bar_knob("volume", "Key volume", icon="speaker.wave.2", setting="sound.volume"),
        bar_knob("width", "Trail width", icon="scribble", min=1, max=6, step=0.5, value=state["width"]),
    ]

def on_action(action, value, state):
    if action == "sig":
        insert(" sent from Clink")
    elif action == "width":
        state["width"] = value
    return state

Mõlemad tulevad tagasi konksu on_action(action, value, state) kaudu, elemendi id järgi, nii et pistikprogrammi ribaelemendid ja selle sätted jagavad üht konksu. Puudutus saadab None. Ketas saadab oma väärtuse igal astmel, kuni sõrm on all, ja veel korra lahtilaskmisel, nii et pistikprogramm võib liikumist jälgida või oodata viimast väärtust.

setting=-iga ketas keerab sätet, mis rakendusel juba olemas on; nimi tuleb ülalt jaotise Käsud ja lugemised loendist, näiteks sound.volume või haptics.intensity. Nimi, mida rakendus ei tunne, annab konsoolis KeyError-i. Vahemik ja algasend tulevad sellest juhtelemendist, klaviatuuri enda koopia muutub juba lohistades, nii et järgmine klahvivajutus on juba uuel tasemel, ja väärtus salvestatakse lahtilaskmisel. Helitugevuse või haptika ketas, mis keeratakse nullist üles, lülitab heli või haptika lohistamise ajaks tagasi sisse, et astmeid oleks üles liikudes kuulda ja tunda; selle lüliti salvestab pistikprogramm ise, kutsudes on_action-is välja set_setting.

Ketast saab joonistada Pythonis. art= on osa, mis paigal püsib, raam või korpus, ja rotor= on pöörlev esikülg, miinimumis -135 kraadi ja maksimumis +135 kraadi. Mõlemad võtavad samu kujundeid, värve, üleminekuid ja varje nagu klahvigraafika, kuni kuusteist kujundit kummaski, ja unit="key" skaleerib koordinaadid ruudukujulisele numbrilauale, kus negatiivse y-ga osuti näitab üles. Joonistus saab riba tekstivärvi nimega "text" ja teema rõhuvärvi nimega "accent". Kui jätad mõlemad välja, on ketas rõngas ja ikoon selle sees; redaktoris saab ribal olevale kettale valida ka mis tahes sisseehitatud viimistluse.

Ribale ei jõua miski iseenesest. Element pannakse sinna käsitsi, täpselt nagu menüü ja soovitused.

1. Paigalda pistikprogramm ja lülita see sisse. Selle ribaelemendid ilmuvad kohe.
2. Ava Paigutus > Ülemine riba.
3. Lisa pistikprogrammi nupp või ketas ja lohista see oma kohale. Kettale saab lisaks valida viimistluse.

Ehitajad jätavad võtmesõna, mida nad ei tunne, vahele ilma veateateta. setting=, min=, max=, step=, value=, art= ja rotor= kuuluvad ainult bar_knob-ile, nii et bar_button, millele mõni neist antakse, ehitatakse ikka lihtsaks nupuks ja midagi ei öelda: nupu töö käib on_action-is. Teistpidi kuulub title= nupule ja ketas jätab selle vahele.

Valgusefektid

Pistikprogramm saab lisada oma klahvivalgustuse. effects(state) tagastab light_effect(...) kirjed ja igaüks neist ilmub rakenduses jaotisse Efektid > Pistikprogrammidest, sisseehitatud stiilide ja inimeste enda ehitatud efektide kõrvale. Efekt on andmed, mitte joonistus: kihtide virn, mida klaviatuur ise animeerib. Skriptis ei jookse seega midagi iga kaadri kohta, ja klahvipinnad, tähed, kuma, vajutuse sähvatus ja jõudeolekus uinumine töötavad nagu sisseehitatud stiilidel.

COLORS = ["#00e5ff", "#7c4dff", "#ff4081"]

def effects(state):
    return [
        light_effect("tide", "Tide", colors=COLORS, layers=[
            light_layer("solid", low=0.2, high=0.2),
            light_layer("wave", moves="both", speed=0.8, size=1.5,
                        direction="up"),
        ]),
    ]

def effects(state):
    return [
        light_effect("scanner", "Scanner", layers=[
            light_layer("wave", moves="color", speed=0.3),
            light_layer("sweep", mix="multiply", speed=1.2, size=1.5),
        ]),
    ]

Efekti valimine kopeerib selle inimese seadetesse, nii et see töötab edasi ka välja lülitatud pistikprogrammiga. Kui pistikprogramm on sees ja mõni selle efekt töötab, loeb klaviatuur effects(state) avamisel ja seejärel umbes kord sekundis uuesti ning võtab üle, mis muutus. Nii järgib efekt olekut, kellaaega või stats() väärtusi.

def effects(state):
    # Rounded, so the effect only changes when the pace really does.
    tempo = round(0.3 + min(stats()["wpm"], 120) / 40, 1)
    return [
        light_effect("tempo", "Tempo", colors=["#ff3d7f", "#ffb000"], layers=[
            light_layer("wave", moves="both", speed=tempo, low=0.15),
        ]),
    ]

Redaktori nupp effects näitab, mida skript pakub. Et efekti liikumas näha, salvesta pistikprogramm, vali efekt jaotises Efektid > Pistikprogrammidest ja vaata selle ekraani ülaosas olevat klaviatuuri.

Ümarda kõik, mis rabeleb, näiteks trükkimiskiirus. Efekt, mis tuleb igal sekundil erinevana tagasi, vahetatakse igal sekundil asjata välja. Tundmatu muster või märksõna on redaktori konsoolis ValueError ja kihtideta efekt jäetakse välja.

Välimused

Seitse haaki pakuvad äpile valikuid: key_styles, themes, popups, animations, backgrounds, trails ja layouts. Igaüks tagastab allolevate väljakutsetega ehitatud kirjeid ning need ilmuvad jaotisse Pistikprogrammidest sisseehitatud valikute kõrvale. Erand on teemad: need saavad teemaredaktoris oma vahekaardi Pistikprogrammid. Välimus koosneb arvudest ja sõnadest, mitte joonistuskoodist, nii et skriptis ei käivitu midagi iga kaadri kohta. Valimine kopeerib selle inimese seadetesse, nii et see töötab ka välja lülitatud pistikprogrammiga, ja hiljem sisseehitatud valiku tegemine paneb selle kõrvale.

def animations(state):
    return [
        entrance("swoop", "Swoop", y=90, scale=0.94, tilt=-20,
                 response=0.5, damping=0.72),
        press_animation("dip", "Dip", scale=0.93, y=2),
        letter_animation("bounce", "Bounce", y=-7, scale=1.12,
                         anchor="bottom"),
        transition("glide", "Glide", x=0.3, scale=0.96),
    ]

def backgrounds(state):
    return [
        background("snowfall", "Snowfall", colors=["#ffffff", "#cfe8ff"], layers=[
            particles(shape="dot", count=70, size=2.2, speed=28,
                      direction="down", spread=12, wobble=10, life=9),
            particles(shape="glow", count=0, size=3, life=1,
                      burst=8, burst_speed=90),
        ]),
    ]

Tagasta funktsioonist trails(state) trail-sõlmed. Igal jäljel on colors-värvipalett ja kihid, näiteks trail_line. Väärtusega color=-1 lähevad paleti värvid piki libistusjälge sujuvalt üksteiseks üle. Lülita pistikprogramm sisse ja vali selle jälg jäljevalija jaotisest Pistikprogrammidest. Joonistusandmete salvestamine olekusse ei joonista jälge.

def trails(state):
    return [trail("rainbow", "Rainbow", colors=["#ff0000", "#ff8800", "#ffff00", "#00cc44", "#0066ff", "#9900ff"],
        layers=[trail_line(width=1.3, tail_width=0.2, color=-1)])]

Välimus kopeeritakse valimise hetkel, nii et skripti hilisem muutmine ei muuda välimust, mida keegi juba kasutab; see tuleb uuesti valida. Valesti kirjutatud märksõna, loendist väljas olev sõna või tekst arvu kohal on viga redaktori konsoolis ning arvud hoitakse äpi enda juhtelementide vahemikes.

Graafika klahvidel

key_art(state) tagastab sõnastiku klahvinimedest graafikasse ja klaviatuur maalib selle klahvikübara sisse. Klahvinimed on samad, mida kasutab haptics, koos letters ja keys tagavaradega. Graafika on kas shape(...) loend, üksik kujund, kiht art([...]) või kihtide loend, ja iga kiht sulandub järgmisse joonistusse oma kella järgi, nii et üks klahv võib kanda kaht eri kiirusel liikuvat asja.

Graafika loetakse uuesti pärast iga sündmust, mida pistikprogramm kuuleb, ja kogu ring ongi see: muuda olekut konksus on_event(name, info, state) ja joonista sellest konksus key_art(state). events(state) nimetab soovitud sündmused ja loetakse korra pistikprogrammi laadimisel. Ilma selleta kuuleb pistikprogramm kõike peale sündmuste key, key_down, key_up, predictions ja tick, mis käivitavad skripti iga vajutuse või iga sekundi järel ja mida tuleb eraldi küsida. Suurtähe- ja tasandimuutused joonistavad graafika uuesti sõltumata sellest, kas keegi kuulab, ja jõuavad ka context()-isse.

def initial():
    return {"shift": "off"}

def events(state):
    return ["shift"]

def on_event(name, info, state):
    state["shift"] = info["state"]
    return state

def key_art(state):
    if state["shift"] != "locked":
        return {}
    lamp = shape("circle", anchor="top_right", x=-7, y=7, size=5,
                 fill="accent", shadow=shadow("accent", radius=4))
    return {"shift": art([lamp], animate=0.12)}

Kuusteist kujundit klahvi kohta, kokku üle kõigi selle kihtide, ja 64 punkti tee kohta; ülejäänu jäetakse välja. Kujund joonistatakse kasti sisse, mille määravad tema enda width ja height, ja ilma paksuseta kast ei maali midagi, nii et rõhtjoon vajab oma väikest height-i, mille keskelt punktid läbi lähevad (height=0.03, points=[[0, 0.5], [1, 0.5]]), muidu jääb see vaikselt ilmumata.

Haptika, tabamustsoonid ja parandused

haptics(state) ja hitboxes(state) tagastavad sõnastikud, mille võtmed on klahvinimed: täht ise, "space", "delete", "return", "shift" või "globe", seejärel "letters" iga nimetamata tähe jaoks ja "keys" kõige muu jaoks. Klahvid, mille pistikprogramm välja jätab, säilitavad inimese enda seaded. Mõlemat tabelit loetakse klaviatuuri avamisel ja umbes kord sekundis, nii et nende pärast ei käivitu midagi iga klahvivajutuse peale.

def haptics(state):
    return {
        "space": "heavy",
        "return": "rigid",
        "delete": feel(intensity=0.45, sharpness=0.9),
    }

on_touch(key, x, y, state) käivitub pärast iga puudutust, kui see on juba käsitletud, koos kohaga klahvil, kuhu sõrm maandus. Asukohta mõõdetakse joonistatud klahvi, mitte selle nihutatud sihtmärgi suhtes, nii et pistikprogramm saab nihutada iga klahvi sinna, kuhu seda tegelikult vajutatakse, ilma et ajaks taga iseenda nihet.

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

def on_touch(key, x, y, state):
    if len(key) != 1:
        return state
    n, ax, ay = state["keys"].get(key, [0, 0.0, 0.0])
    n = min(n + 1, 50)
    ax += (x - ax) / n
    ay += (y - ay) / n
    state["keys"][key] = [n, ax, ay]
    return state

def hitboxes(state):
    boxes = {}
    for key in state["keys"]:
        n, x, y = state["keys"][key]
        if n >= 12:
            boxes[key] = hitbox(x=round(x * 0.6, 2), y=round(y * 0.6, 2))
    return boxes

suggestions(word, state) paneb sõnad riba algusesse, kuni sõna trükitakse. correct(word, fix, state) käivitub iga sõna kohta korra, kui tühik selle lõpetab, koos klaviatuuri enda paranduse või None'iga, ka siis, kui automaatparandus on väljas. Tagasta sõna, et see sisestada, False, et jätta sõna trükitud kujule, või None, et jätta otsus klaviatuurile. Võidab esimene vastanud pistikprogramm ja kohe järgnev kustutamine võtab selle tagasi nagu iga automaatparanduse.

SHORT = {"brb": "be right back", "omw": "on my way", "idk": "I don't know"}

def suggestions(word, state):
    long = SHORT.get(word.lower())
    return [long] if long else []

def correct(word, fix, state):
    if len(word) > 1 and word.isupper():
        return False
    return None

Kumbki haak ei käivitu paroolväljadel. Riba paranduskiip näitab klaviatuuri enda parandust, mitte seda, mida correct tagastaks, ja on_touch'is muudetud tabel jõuab klaviatuurini järgmisel taktil.

Testimine redaktoris

Redaktori eelvaade on asendusklaviatuur. See joonistab settings(state) reaalajas, käivitab puudutusega iga haagi näidissõna, klahvi või väljatüübiga, näitab tühikuklahvi nii, nagu pistikprogramm selle jättis, ja loetleb kõik, mida pistikprogramm klaviatuurilt palus. stats() tagastab seal väljamõeldud arve, nii et kiirus ilmub ilma tippimata.

1. Kasuta eelvaate juhtelemente. Igaüks käivitab on_action ja joonistab uuesti.
2. Puuduta haakide nuppe samas järjekorras, nagu klaviatuur seda teeks: on_open, siis paar korda on_word või on_key, siis on_close.
3. Loe konsooli. Käsud ilmuvad nii, nagu sa need kirjutasid, print()-read nende all, ja viga nimetab oma rea.
4. Lae uuesti, et olek nullida. Skripti muutmine ei nulli seda iseenesest.

Eelvaates pole dokumenti, seega insert() ja replace() ainult logivad. Nende proovimiseks salvesta ja tipi avatud klaviatuuriga mis tahes väljale.

Piirid

Kui pistikprogramm tuleb failina või hoidlast, kontrollib Clink seda enne salvestamist. See peab olema alla 64 000 baidi ja 1600 rea, määratlema vähemalt ühe haagi, importima ainult lubatud mooduleid ega tohi sisaldada ühtegi järgmistest:

Iga haagikutse saab 2 000 000 interpretaatorisammu, sama palju kui paneeli joonistamine. on_key käivitub aga iga klahvivajutuse peale, nii et raske töö seal aeglustab tippimist ammu enne, kui see piir kätte jõuab.

Fail

Pistikprogramm on üks JSON-dokument. id püsib uuenduste vahel sama, version on vaba tekst, mida loendis näidatakse, icon on SF Symboli nimi ja source on skript, milles reavahetused on varjestatud. Jaga seda redaktori inspektorist või impordi üks vahekaardi Pistikprogrammid noolenupuga.

{
  "id": "word-count",
  "name": "Word count",
  "icon": "text.word.spacing",
  "summary": "Counts words on the space bar",
  "version": "1.0",
  "author": "You",
  "enabled": true,
  "source": "def initial():\n    return {\"on\": False}\n..."
}

Pistikprogramme jagatakse .clinkplugin-failidena, mis on JSON-dokumendid, mille sees on skript. Need avaldatakse hoidla kaudu samamoodi nagu paneelid: failide kaust, manifest ja väljalase. Ametlik hoidla on anti-ltd/clink-plugins.

Kui midagi ei juhtu

Enamasti on see üks neist.