Plugin

Automasi

Objek automation pilihan dalam fail .clinkplugin mengisytiharkan acara, keadaan, tetapan, arahan, pratetap dan slot pintasan. Setiap sumbangan mempunyai ID tetap, versi skema yang tepat dan tajuk setempat. Hos membentuk nama plugin/<plugin-id>/<kind>/<id>. Pemalam tidak boleh menggunakan ruang nama teras atau ruang nama pemalam lain.

Cara plugin berfungsi

Panel menggantikan kekunci, dan tindakan berjalan sekali pada sebahagian teks. Plugin tidak mempunyai skrin sendiri pada papan kekunci. Clink memanggil fungsinya pada saat tertentu, contohnya apabila papan kekunci dibuka atau apabila anda selesai menaip perkataan, dan plugin boleh mengemas kini bar ruang atau keadaan tersimpannya sendiri. Tetapannya dipaparkan dalam aplikasi menggunakan pembina yang sama seperti panel. WPM Spacebar di bawah ialah plugin yang lengkap.

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

Plugin memerlukan Clink Pro. Sebelum memasang plugin daripada repositori, Clink meminta anda membenarkan kod daripada repositori itu, sama seperti untuk panel dan tindakan.

on_key dan on_word menerima apa yang anda taip, kerana begitulah cara pengira perkataan berfungsi. PyMini tiada akses rangkaian atau fail, jadi plugin tidak dapat menghantar apa yang anda taip melalui internet, dan data yang disimpannya kekal dalam Clink pada peranti anda.

Plugin pertama anda

Cara paling cepat ialah skrip permulaan yang ditulis aplikasi untuk anda. Ia meletakkan suis di bawah Kekunci > Bar ruang dan, semasa suis hidup, mengira perkataan pada bar ruang. Lima langkah, tiada fail untuk dimuat turun.

1. Buka tab Plugin, hidupkan plugin di bahagian atas, dan ketik + untuk plugin baharu.
2. Editor dibuka pada skrip permulaan. Baca sekali: initial(), settings(), on_action(), on_open() dan on_word() ialah keseluruhannya.
3. Tukar ke Pratonton. Hidupkan suis, kemudian ketik on_open dan on_word beberapa kali dan perhatikan tiruan bar ruang dan konsol.
4. Simpan. Plugin hidup dalam senarai, dan suisnya kini juga berada di bawah Kekunci > Bar ruang.
5. Buka papan kekunci di mana-mana dan taip. Bar ruang mengira bersama.

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

Cangkuk

Takrifkan mana-mana daripada 33 fungsi ini dan tinggalkan yang tidak diperlukan. Setiap satu menerima state sebagai argumen terakhir. Yang bertindak balas kepada sesuatu memulangkan state, sama ada diubah atau tidak. Yang menjawab soalan (elements, draw, effects, cangkuk rupa, haptics, hitboxes, suggestions dan correct) memulangkan jawapannya, dan masih boleh mengubah state di tempatnya.

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

Aplikasi dan papan kekunci berkongsi satu salinan keadaan. Hidupkan suis dalam aplikasi dan suis itu hidup apabila papan kekunci dibuka seterusnya. Apa sahaja yang dikira oleh papan kekunci ada di situ apabila anda membuka tetapan plugin itu nanti. Papan kekunci menyimpan keadaan apabila ditutup, bukan selepas setiap kekunci.

Cadangan semasa pada bar ruang

Baca cadangan utama yang dipaparkan melalui context()["suggestion"]. Langgan peristiwa predictions untuk menerima perubahan dalam info["suggestion"]. Kedua-duanya memerlukan akses kepada data penaipan. on_suggestion berjalan selepas cadangan diterima, bukan apabila ramalan berubah. Panggil space_text(value or None) untuk menetapkan label atau memulihkannya apabila tiada cadangan. Ini mengubah label sahaja, bukan tindakan bar ruang.

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

Keadaan

Keadaan ialah satu dict. initial() membinanya pada kali pertama; selepas itu setiap cangkuk mendapat dict yang sama, mengubahnya, dan memulangkannya. Ia menyimpan apa sahaja yang JSON boleh simpan: nombor, rentetan, senarai, dict bersarang. Aplikasi menyimpannya selepas setiap kawalan yang anda gunakan, papan kekunci semasa ditutup, dan kedua-duanya membaca fail yang sama, jadi ia tidak pernah lama bercanggah.

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

Memulangkan state ialah tabiat yang baik, tetapi tidak wajib: dict itu rujukan, jadi mengubahnya di tempat juga berfungsi. Pulangkan dict lain, seperti initial() di atas, dan itu menjadi keadaan.

Tetapan dan bahagian

settings(state) memulangkan pokok nod yang dibina dengan pembina panel: text, toggle, slider, stepper, segmented, button, row, field dan susun atur. Ia dipaparkan pada halaman plugin dalam tab Plugin. Bungkus sebahagiannya dalam section(anchor, children, title) dan bahagian itu turut dipaparkan pada salah satu skrin tetapan Clink sendiri, di sebelah tetapan yang berkaitan.

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"),
    ])

Kawalan yang paling kerap diperlukan plugin. Setiap satu sama ada menulis nilai baharunya ke dalam keadaan di bawah key, atau menamakan action untuk on_action, atau kedua-duanya. Senarai pembina penuh, termasuk susun atur, ada di halaman panel.

Ke mana bahagian pergi

Sauh ialah ID kad pada salah satu skrin tetapan Clink sendiri. Namakannya dalam section() dan kawalan plugin dilukis tepat di bawah kad itu, dengan nama plugin di atasnya. Cara paling mudah untuk mencarinya: dalam aplikasi, buka Lagi > Pembangun dan hidupkan Tunjukkan ID. Setiap kad mendapat lencana maklumat kecil yang menamakan ID-nya dan menyalinnya apabila diketik; halaman menunjukkan ID mereka pada bar tajuk.

keys.spacebar mempunyai tempatnya sendiri, pada skrin Bar ruang itu sendiri. Bahagian dengan sauh yang tiada dalam senarai ini masih dipaparkan pada halaman plugin, jadi kesilapan taip merugikan anda satu kad, bukan plugin itu.

Pengambilalihan

Apabila plugin mengendalikan salah satu tetapan Clink sendiri, orang itu patut melihatnya, dan kedua-duanya tidak patut bertelagah. claim(control) menyatakan plugin memilikinya: aplikasi menamakan plugin pada kad tetapan itu, dan medan teks bar ruang dikunci selagi ia dipegang. release(control) memulangkannya. Ambil alih dalam on_action yang menghidupkan ciri anda, lepaskan dalam yang mematikannya, dan tetapkan nilai kembali kepada None atau nilai lamanya pada masa yang sama. Plugin yang dimatikan dalam senarai melepaskan semua yang dipegangnya.

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

Dua plugin boleh mengambil alih kawalan yang sama; aplikasi menamakan yang mengambil alih terakhir. Pengambilalihan direkodkan oleh aplikasi, jadi ambil alih daripada on_action, yang berjalan di situ. Pengambilalihan yang dibuat dalam papan kekunci tidak diingati.

Arahan dan bacaan

Plugin boleh menggunakan semua arahan panel, serta enam arahan dan dua bacaan khusus untuknya. Arahan dimasukkan ke dalam baris gilir dan dilaksanakan selepas fungsi anda kembali, jadi tiada apa-apa pada papan kekunci berubah di tengah-tengah panggilan. Bacaan memulangkan nilai seperti keadaannya sejurus sebelum panggilan.

setting(name) dan set_setting(name, value) berkongsi satu senarai nama, dan claim(control) juga menerima mana-mana daripadanya. Boolean dibaca sebagai True atau False, nombor sebagai nombor, pilihan sebagai id-nya. Senarai itu sengaja panjang: plugin boleh bertindak balas kepada, atau mengendalikan, hampir semua yang boleh ditetapkan seseorang dalam aplikasi.

Seperti view() dalam panel, settings() sepatutnya hanya menerangkan kawalan. Arahan yang dipanggil daripadanya diabaikan dan dicatat dalam konsol.

Contoh

Lima plugin kecil, setiap satu lengkap. Tampal satu ke dalam plugin baharu, simpan, dan ia berjalan.

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

Elemen dalam susun atur

Susun atur tersuai dibina daripada kekunci dan elemen: jalur emoji terkini, baris digit, pad kursor. Plugin boleh menambah miliknya sendiri. elements(state) menyatakan apa yang ditawarkan dan draw(id, state) melukisnya, jadi sebuah kekunci boleh menunjukkan apa sahaja yang plugin boleh kira: graf kelajuan menaip, jam, kira detik, atau penunjuk bateri anda sendiri.

Dua cangkuk membina satu. elements(state) menyenaraikan apa yang anda tawarkan, satu entri bagi setiap elemen, dan aplikasi membacanya untuk mengisi palet editor susun atur. draw(id, state) diberi salah satu id itu dan memulangkan apa yang hendak dilukis. Sebuah plugin boleh menawarkan beberapa; draw ditanya setiap satu mengikut namanya.

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")

Wajah elemen ialah pepohon nod, seperti halaman tetapan, tetapi kekunci bukan halaman tetapan: hanya nod yang melukis digunakan, dan apa-apa yang boleh diketik diabaikan. Kekunci itu sudah milik susun atur, jadi tiada tempat untuk butang di dalamnya.

Ukur ia untuk sebuah kekunci. width dikira dalam lebar kekunci: 1 ialah satu huruf dan 3 lebih kurang satu pertiga baris, dan penggunanya boleh mengubah saiznya kemudian. Teks mendapat satu baris dan mengecil supaya muat; warna mengikut warna teks kekunci secara lalai, jadi elemen sepadan dengan kekunci di sekelilingnya melainkan anda minta yang lain. Sparkline menyimpan 120 titik terakhirnya, lebih daripada yang boleh ditunjukkan sebuah kekunci.

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)

Elemen tinggal dalam susun atur tersuai, jadi ada susun atur untuk dibina dahulu. Pratetap tidak boleh memuatkannya: mencabangkan pratetap menjadi susun atur anda sendiri ialah perkara pertama yang ditawarkan editor.

1. Pasang plugin dan hidupkannya. Elemennya muncul sebaik sahaja anda berbuat demikian.
2. Buka Susun Atur, cipta atau cabangkan susun atur tersuai, dan pergi ke Atur.
3. Ketik Elemen, pilih elemen plugin daripada jalur itu, dan tetapkan lebarnya.

Pratonton editor melukis setiap elemen yang ditawarkan skrip, lebih kurang sebesar kekunci yang akan memuatkannya, di bawah model bar ruang. Simpan dan letakkannya sekali, dan papan kekunci melukis benda yang sama.

Elemen hanya menunjukkan apa yang dilukis plugin: mengetiknya tidak melakukan apa-apa, kerana kekunci itu sudah milik susun atur. Susun atur menyimpan elemen itu walaupun pluginnya dimatikan atau dibuang, dan kekunci terisi semula apabila plugin kembali.

Butang dan tombol pada bar atas

Jalur di atas kekunci disusun di Susun Atur > Bar Atas, dan plugin boleh menawarkan kawalannya sendiri untuk jalur itu. bar_items(state) memulangkannya: bar_button(...) untuk sesuatu yang diketuk, bar_knob(...) untuk sesuatu yang dipusing. Senarai itu dibaca apabila papan kekunci dibuka dan sekali lagi selepas setiap ketukan, jadi satu item boleh datang dan pergi mengikut keadaan plugin.

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

Kedua-duanya kembali melalui on_action(action, value, state), dikenali melalui id item, jadi item bar sesuatu plugin dan kawalan tetapannya berkongsi satu cangkuk. Ketukan menghantar None. Tombol menghantar nilainya pada setiap deten selagi jari masih turun dan sekali lagi apabila dilepaskan, jadi plugin boleh mengikuti seretan itu atau menunggu nilai terakhir.

Tombol dengan setting= memusingkan nilai yang app sudah ada, dinamakan daripada senarai Arahan dan bacaan di atas, seperti sound.volume atau haptics.intensity. Nama yang app tidak kenal menjadi KeyError dalam konsol. Julat dan kedudukan permulaan datang daripada kawalan itu, salinan papan kekunci sendiri berubah sambil anda menyeret supaya ketukan berikutnya sudah berada pada aras baharu, dan nilainya disimpan apabila dilepaskan. Tombol kelantangan atau haptik yang dinaikkan daripada sifar turut menghidupkan semula bunyi atau haptik sepanjang seretan itu, supaya setiap deten didengar dan dirasai semasa naik; menyimpan suis itu ialah kerja set_setting plugin sendiri di dalam on_action.

Tombol boleh dilukis dalam Python. art= ialah bahagian yang kekal diam, bezel atau badannya, dan rotor= ialah muka yang berpusing, dari -135 darjah pada minimum hingga +135 darjah pada maksimum. Kedua-duanya menerima bentuk, warna, kecerunan dan bayang yang sama seperti seni kekunci, sehingga enam belas bentuk setiap satu, dan unit="key" menskalakan koordinat kepada dail segi empat sama itu, di mana penunjuk pada y negatif menghala ke atas. Lukisan itu diberi warna teks bar sebagai "text" dan warna penegas tema sebagai "accent". Tinggalkan kedua-duanya dan tombol itu menjadi cincin dengan ikon di dalamnya; penyunting juga boleh memberikan sebarang kemasan terbina dalam kepada tombol yang sudah berada di bar.

Tiada apa-apa yang sampai ke bar itu dengan sendirinya. Item diletakkan dengan tangan, sama seperti menu dan cadangan.

1. Pasang plugin dan hidupkannya. Item barnya muncul serta-merta.
2. Buka Susun Atur > Bar Atas.
3. Tambah butang atau tombol plugin itu dan seret ke tempatnya. Tombol pula boleh dipilihkan kemasannya.

Pembina melangkau kata kunci yang tidak dikenalinya, tanpa ralat. setting=, min=, max=, step=, value=, art= dan rotor= milik bar_knob sahaja, jadi bar_button yang diberi salah satunya tetap dibina sebagai butang biasa dan tiada apa-apa diberitahu: kerja butang tempatnya di dalam on_action. Sebaliknya title= milik butang, dan tombol melangkaunya.

Kesan cahaya

Plugin boleh menambah pencahayaan kekuncinya sendiri. effects(state) memulangkan entri light_effect(...), dan setiap satu muncul dalam apl di bawah Kesan > Daripada pemalam, di sebelah gaya terbina dalam dan kesan yang dibina sendiri oleh pengguna. Kesan ialah data, bukan lukisan: timbunan lapisan yang dianimasikan sendiri oleh papan kekunci. Jadi tiada apa-apa dalam skrip berjalan setiap bingkai, dan permukaan kekunci, huruf, cahaya, kilauan ketika ditekan dan tidur ketika melahu semuanya berfungsi seperti gaya terbina dalam.

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),
        ]),
    ]

Memilih kesan menyalinnya ke dalam tetapan pengguna, jadi ia terus berfungsi walaupun plugin dimatikan. Selagi plugin hidup dan salah satu kesannya sedang berjalan, papan kekunci membaca effects(state) semula ketika dibuka dan kira-kira sekali sesaat selepas itu, lalu menukar apa-apa yang berubah. Begitulah kesan mengikut keadaan, masa atau stats().

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),
        ]),
    ]

Butang effects dalam editor menyenaraikan apa yang ditawarkan skrip. Untuk melihatnya bergerak, simpan plugin, pilih kesan itu di bawah Kesan > Daripada pemalam, dan lihat papan kekunci di bahagian atas skrin itu.

Bundarkan apa-apa yang bergoyang, seperti kadar menaip. Kesan yang kembali berbeza setiap saat akan ditukar setiap saat tanpa faedah. Corak atau kata kunci yang tidak dikenali ialah ValueError dalam konsol editor, dan kesan tanpa lapisan ditinggalkan.

Rupa

Tujuh cangkuk menawarkan pilihan kepada apl: key_styles, themes, popups, animations, backgrounds, trails dan layouts. Setiap satu memulangkan entri yang dibina dengan panggilan di bawah, dan ia muncul di bawah Daripada pemalam di sebelah pilihan terbina dalam. Tema ialah pengecualian: ia mendapat tab Plugin sendiri dalam editor tema. Rupa ialah nombor dan perkataan, bukan kod lukisan, jadi tiada apa-apa dalam skrip berjalan setiap bingkai. Memilih satu menyalinnya ke dalam tetapan orang itu, jadi ia terus berfungsi walaupun pemalam dimatikan, dan memilih pilihan terbina dalam selepas itu mengetepikannya.

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),
        ]),
    ]

Pulangkan nod trail daripada trails(state). Setiap jejak mempunyai palet colors dan lapisan seperti trail_line. Dengan color=-1, garisan mengadunkan warna palet sepanjang leretan. Dayakan pemalam, kemudian pilih jejaknya di bawah Daripada pemalam dalam pemilih jejak. Menyimpan grafik dalam keadaan sahaja tidak melukis jejak.

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)])]

Rupa disalin semasa dipilih, jadi menukar skrip kemudian tidak mengubah rupa yang sudah digunakan; ia perlu dipilih semula. Kata kunci yang salah eja, perkataan di luar senarainya atau teks di tempat nombor ialah ralat dalam konsol editor, dan nombor dikekalkan dalam julat yang digunakan oleh kawalan apl sendiri.

Seni pada kekunci

key_art(state) memulangkan dict daripada nama kekunci kepada lukisan, dan papan kekunci mengecatnya di dalam kekunci itu. Nama kekunci ialah nama yang sama seperti pada haptics, dengan sandaran letters dan keys. Lukisan ialah senarai shape(...), satu bentuk tunggal, satu lapisan art([...]) atau senarai lapisan, dan setiap lapisan beralih ke lukisan berikutnya mengikut jamnya sendiri, jadi satu kekunci boleh membawa dua benda yang bergerak pada kelajuan berbeza.

Lukisan itu dibaca semula selepas setiap peristiwa yang didengari plugin, dan itulah seluruh gelungnya: ubah keadaan dalam on_event(name, info, state), lukis daripadanya dalam key_art(state). events(state) menamakan peristiwa yang dikehendaki dan dibaca sekali semasa plugin dimuatkan. Tanpanya, plugin mendengar semuanya kecuali key, key_down, key_up, predictions dan tick, yang menjalankan skrip pada setiap ketukan atau setiap saat dan perlu diminta. Perubahan shift dan satah melukis semula seni itu sama ada ada yang mendengar atau tidak, dan ia turut sampai ke context().

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)}

Enam belas bentuk bagi satu kekunci, dikira merentas semua lapisannya, dan 64 titik bagi satu laluan; selebihnya digugurkan. Sesuatu bentuk dilukis di dalam kotak width dan height-nya sendiri, dan kotak tanpa ketebalan tidak mengecat apa-apa, jadi garis mendatar perlu height kecilnya sendiri dengan titik-titiknya di tengah kotak itu (height=0.03, points=[[0, 0.5], [1, 0.5]]) atau ia senyap-senyap tidak muncul.

Haptik, kotak sentuh dan pembetulan

haptics(state) dan hitboxes(state) memulangkan dict dengan nama kekunci sebagai kunci: huruf itu sendiri, "space", "delete", "return", "shift" atau "globe", kemudian "letters" untuk mana-mana huruf yang tidak dinamakan dan "keys" untuk semua yang lain. Kekunci yang ditinggalkan oleh pemalam mengekalkan tetapan orang itu sendiri. Kedua-dua jadual dibaca apabila papan kekunci dibuka dan kira-kira sekali sesaat, jadi tiada apa-apa berjalan pada setiap ketikan kerananya.

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

on_touch(key, x, y, state) berjalan selepas setiap ketikan, sebaik ketikan itu diuruskan, dengan tempat pada kekunci di mana jari mendarat. Kedudukan diukur berbanding kekunci seperti yang dilukis, bukan sasarannya yang dialihkan, jadi pemalam boleh mengalihkan setiap kekunci ke arah tempat ia benar-benar ditekan tanpa mengejar alihannya sendiri.

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) meletakkan perkataan di hadapan bar semasa perkataan ditaip. correct(word, fix, state) berjalan sekali bagi setiap perkataan apabila ruang menamatkannya, dengan pembetulan papan kekunci sendiri atau None, walaupun autobetul dimatikan. Pulangkan perkataan untuk memasukkannya, False untuk mengekalkan perkataan seperti yang ditaip, atau None untuk menyerahkannya kepada papan kekunci. Pemalam pertama yang menjawab menang, dan padam sejurus selepas itu membatalkannya seperti autobetul yang lain.

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

Kedua-dua cangkuk tidak berjalan dalam medan kata laluan. Cip pembetulan dalam bar menunjukkan pembetulan papan kekunci sendiri, bukan apa yang akan dipulangkan oleh correct, dan jadual yang diubah dalam on_touch sampai ke papan kekunci pada rentak seterusnya.

Menguji dalam editor

Pratonton editor ialah papan kekunci pengganti. Ia melukis settings(state) secara langsung, mencetuskan mana-mana cangkuk dengan satu ketikan menggunakan perkataan, kekunci atau jenis medan contoh, menunjukkan bar ruang seperti yang ditinggalkan plugin, dan menyenaraikan semua yang diminta plugin daripada papan kekunci. stats() memulangkan nombor rekaan di situ, jadi kadar muncul tanpa menaip.

1. Gunakan kawalan dalam pratonton. Setiap satu menjalankan on_action dan melukis semula.
2. Ketik butang cangkuk mengikut urutan yang akan dilakukan papan kekunci: on_open, kemudian on_word atau on_key beberapa kali, kemudian on_close.
3. Baca konsol. Arahan muncul seperti yang anda tulis, baris print() di bawahnya, dan ralat menamakan barisnya.
4. Muat semula untuk memulakan keadaan dari awal. Menyunting skrip tidak menetapkannya semula dengan sendirinya.

Pratonton tiada dokumen, jadi insert() dan replace() hanya mencatat. Untuk mencubanya, simpan dan taip dalam mana-mana medan dengan papan kekunci terbuka.

Had

Apabila plugin masuk sebagai fail atau daripada repositori, Clink menyemaknya sebelum menyimpannya. Ia mesti kurang daripada 64,000 bait dan 1,600 baris, mentakrifkan sekurang-kurangnya satu cangkuk, hanya mengimport modul yang dibenarkan, dan tidak mengandungi mana-mana yang berikut:

Setiap panggilan cangkuk mendapat 2,000,000 langkah pentafsir, sama seperti pemaparan panel. Namun on_key berjalan pada setiap ketukan kekunci, jadi kerja berat di situ akan memperlahankan penaipan jauh sebelum had itu dicapai.

Fail

Plugin ialah satu dokumen JSON. id kekal stabil merentas kemas kini, version ialah teks bebas yang dipaparkan dalam senarai, icon ialah nama SF Symbol, dan source ialah skrip dengan baris baharu yang dilepaskan. Kongsikannya daripada pemeriksa editor, atau import satu dengan butang anak panah pada tab Plugin.

{
  "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..."
}

Plugin dikongsi sebagai fail .clinkplugin, iaitu dokumen JSON dengan skrip di dalamnya. Plugin diterbitkan melalui repositori dengan cara yang sama seperti panel, dengan folder fail, manifes dan keluaran. Repositori rasmi ialah anti-ltd/clink-plugins.

Apabila sesuatu tidak berlaku

Selalunya ia salah satu daripada ini.