Een scherm laten reageren

Doel

Een getekend scherm iets laten doen: een kop die de naam zegt die iemand heeft getypt, een paneel dat verschijnt wanneer een vakje wordt aangevinkt, een knop Opslaan die pas aangaat wanneer het formulier is ingevuld.

Niets daarvan is een plaatje, en niets daarvan is code die je in een bestand schrijft. Het is toestand — het handjevol dingen dat verandert terwijl iemand het scherm gebruikt — en koppelingen, expressies van één regel die die toestand lezen.

Stap 1 — Geef het scherm wat toestand

1. Open het scherm in de designer (Schermen → selecteer er een → Ontwerp).
2. Klik op het schermframe zelf — het buitenste vak — en open het tabblad Scherm in de inspector rechts.
3. Druk onder Schermtoestand op Een toestandsveld toevoegen.
4. Typ een naam — bijvoorbeeld requester — en een beginwaarde.

De beginwaarde is een expressie, geen ingetypte waarde, dus een leeg vak begint als "" (twee aanhalingstekens), een selectievakje als false, en een teller als 0. Het is dezelfde taal als al het andere op dit scherm, en daarom is er maar één ding om te leren.

Voeg er zoveel toe als het scherm nodig heeft. De meeste schermen hebben er twee of drie nodig.

Waarom toestand bij het scherm hoort

Omdat twee besturingselementen hetzelfde veld lezen. Als toestand hoorde bij het vak waarvandaan je hem toevallig toevoegde, zou het verwijderen van dat vak het veld meenemen — en al het andere dat het las, zou stilletjes ophouden te werken.

Stap 2 — Koppel een eigenschap

1. Selecteer een willekeurig object op het canvas.
2. Kies op het tabblad Scherm, onder Koppelingen, een eigenschap bij Een eigenschap koppelen.
3. Er verschijnt een editor met een voorbeeld erin. Vervang het door je expressie.

Vier eigenschappen kunnen worden gekoppeld:

Eigenschap	Bepaalt	Op
Tekst	wat het zegt — de woorden van een kop, het label van een knop, de tijdelijke aanduiding van een vak	alles
Getoond	of het überhaupt op het scherm staat	alles
Ingeschakeld	of een besturingselement mag worden gebruikt	besturingselementen
Waarde	wat een besturingselement bevat	besturingselementen

Al het andere aan een object — waar het staat, hoe groot, welke kleur — heb je getekend, en tekenen is de betere manier om dat allemaal te zeggen.

Voorbeelden die echt werk doen:

state.requester                        the Text of a heading
"Hello, " + state.requester            the same, with words around it
state.showDetails                      the Shown of a panel
!state.showDetails                     the Shown of the line that says it is empty
state.requester != ""                  the Enabled of a Save button
screen.width > 700                     the Shown of something a narrow window has no room for

De editor is de BS Lang-editor van het platform, dus hij onderstreept wat hij niet begrijpt en biedt aanvullingen aan terwijl je typt. Staat de onderstreping er, wijs haar dan aan om te lezen waarom.

Stap 3 — Laat een besturingselement terugschrijven

Koppel de Waarde van een tekstvak aan state.requester, en typen erin stelt state.requester in. Al het andere dat dat veld leest, volgt meteen — de begroeting, de knop Opslaan, alles.

Dat is alles wat een scherm levendig laat aanvoelen, en er is geen handler voor nodig.

Eén regel: terugschrijven gebeurt alleen wanneer de Waarde een gewoon toestandspad is — state.requester, of state.form.name. Als ze berekend is (state.first + " " + state.last), toont het besturingselement de waarde en is het alleen-lezen, omdat er geen manier is om vanuit wat iemand typte terug te rekenen naar de twee velden waar het vandaan kwam.

Stap 4 — Laat iets gebeuren wanneer op een knop wordt gedrukt

1. Selecteer de knop.
2. Kies onder Wanneer dit gebeurt de gebeurtenis Ingedrukt bij Een gebeurtenis afhandelen.
3. Schrijf wat er moet gebeuren — één instructie per regel:

notify("Ticket raised for " + getState("requester"));
setState("requester", "");
setState("showDetails", false);

Wat een handler kan aanroepen:

Aanroep	Doet
setState("name", value)	wijzigt de toestand van het scherm — al het andere dat hem leest, volgt
getState("name")	leest hem terug, zodat je kunt rekenen met wat er staat
loadRecords("table", "field")	laadt rijen uit een tabel in een toestandsveld — zie hieronder
getRecord("table", id, "field")	laadt één record op basis van de id
createRecord("table", { … }, "field")	slaat een nieuw record op; het derde argument is optioneel
updateRecord("table", id, { … })	wijzigt de velden die je noemt op één record
deleteRecord("table", id)	verwijdert één record
callApi("GET", "psl/v1/overview", { … }, "field")	vraagt een Custom API en bewaart het antwoord — zie Cijfers uit een Custom API
notify("…") / notifyError("…")	vertelt het de persoon die het scherm gebruikt
showModal("Card") / closeModal()	toont een overlaykaart boven het scherm — zie stap 5
openStartDrawer("Card") / closeStartDrawer()	schuift er een in vanaf de beginrand
openEndDrawer("Card") / closeEndDrawer()	en vanaf de eindrand
openDropdown("Card") / closeDropdown()	opent er een naast wat er werd ingedrukt
setVisualState("name")	zet het dichtstbijzijnde object boven deze handler met een getekende toestand in die toestand; "" gaat terug naar Normaal — zie Een ontwerp hergebruiken met componenten
openUrl("…", "newTab")	gaat naar een webadres; laat het tweede argument weg om in dit venster te blijven
navigate("Screen")	gaat naar een ander scherm van deze app — via de naam op het frame
reloadSurfaces()	toont elke ingebedde tabel of elk ingebed formulier op dit scherm opnieuw, met verse gegevens

Een handler is een klein programma, geen expressie. Hij mag dingen wijzigen — daar is hij juist voor — en hij kan zoveel regels hebben als nodig. Dat is het verschil met een koppeling, die alleen leest.

De andere gebeurtenissen zijn er wanneer je ze nodig hebt: Twee keer ingedrukt, Waarde gewijzigd (op een besturingselement), Krijgt focus, Verliest focus, Aanwijzer komt erop, Aanwijzer gaat eraf, en — op het schermframe zelf — Scherm wordt geopend, dat één keer wordt uitgevoerd, nadat de toestand bestaat.

Teken een toestand om alleen het uiterlijk te wijzigen

Een handler die alleen iets herkleurt, kost werk bij elke beweging van de aanwijzer. Een getekende toestand kost helemaal niets, omdat de browser het doet. Zie Een ontwerp hergebruiken met componenten.

Naar een ander scherm van de app gaan

Een app bevat meerdere schermen, en navigate gaat ertussen heen en weer:

navigate("Details");
navigate("Details", { id: getState("chosen") });

De naam is de naam op het frame van het scherm, precies zoals je hem daar typte — hernoem het frame en elke navigate die de oude naam noemt, werkt niet meer, wat het scherm je vertelt wanneer erop wordt gedrukt in plaats van stilletjes te mislukken.

Wat de overgang overleeft, en wat niet. Het scherm dat je verlaat, wordt gesloten: de toestand is weg, dus wie terugkomt, krijgt een verse — een half ingevuld formulier hoort niet nog half ingevuld te zijn, en een scherm dat bij aankomst rijen laadde, laadt ze opnieuw. Wat meereist, is wat je overhandigt: het tweede argument komt aan als screen.params, dus screen.params.id op het volgende scherm leest wat je stuurde.

Het is altijd screen.params. Een kortere params bestaat niet, en de code-editor onderstreept die.

De adresbalk volgt je. Elk scherm heeft een eigen URL, dus de knop Terug van de browser brengt je naar het vorige scherm, opnieuw laden komt terug op hetzelfde, en een link die je kopieert, opent daar. Overhandigde waarden reizen niet op die manier — wie aankomt via Terug, via opnieuw laden of via een geplakte link, opent het scherm zonder screen.params — dus behandel ze als een overdracht tussen twee schermen, niet als iets wat een link kan meedragen.

Records lezen en schrijven

Vijf aanroepen, en samen maken ze van een tekening een toepassing.

Een lijst lezen:

loadRecords("par_ticket", "tickets");
loadRecords("par_ticket", "tickets", 20);
loadRecords("par_ticket", "tickets", { top: 20, where: { par_status: "Open" }, orderBy: "par_name" });

De rijen komen terecht in het toestandsveld dat je noemde, en al het andere op het scherm weet al wat het ermee moet doen — een tabel herhaalt over state.tickets, een bijschrift leest state.tickets.length(). Zie Eén rij tekenen, één per record krijgen.

Het derde argument is ofwel hoeveel er maximaal, ofwel de hele vraag: top, where, orderBy en descending. where vergelijkt alleen op gelijkheid, en elk paar dat je schrijft, moet overeenkomen. Heb je meer nodig — een bereik, "bevat", een of — bouw dan een weergave met de querydesigner en teken het scherm daartegen, in plaats van het hier in één regel te persen.

Eén lezen:

getRecord("par_ticket", screen.params.id, "ticket");

Dat is de tegenhanger van navigate("Details", { id: row.id }) — het lijstscherm geeft de id door, en het detailscherm haalt het record erachter op. Bestaat dat record niet meer, dan blijft het veld zoals het was in plaats van te worden leeggemaakt, zodat de koppelingen eronder blijven werken.

Schrijven:

createRecord("par_ticket", { par_name: getState("title"), par_status: "Open" });
createRecord("par_ticket", { par_name: getState("title") }, "created");
updateRecord("par_ticket", getState("ticket").id, { par_status: "Closed" });
deleteRecord("par_ticket", getState("ticket").id);

Het derde argument van createRecord is optioneel en vaak de moeite waard: het platform antwoordt met het record dat het heeft opgeslagen, inclusief id, dus met getState("created").id opent of wijzigt het scherm daarna wat het net heeft gemaakt. Zonder dat argument is er geen manier om die id te weten te komen.

De veldnamen zijn de logische namen van de kolommen van de tabel — par_name, niet Name — dezelfde die de Tabelontwerper toont.

Zeg achteraf iets

Niets vertelt de persoon die het scherm gebruikt dat een schrijfactie is gelukt, dus zeg het zelf: createRecord(…); notify("Ticket raised");. Weigert het platform de schrijfactie — een verplicht veld, een machtiging — dan toont het scherm de reden die het gaf, en daarom is die melding het lezen waard in plaats van vervangen. De rest van die klik stopt dan, zodat een notify of navigate na de schrijfactie alleen gebeurt als die gelukt is.

Wat een scherm mag doen, wordt op de server beslist

Elk van deze aanroepen wordt gecontroleerd aan de hand van de machtigingen van wie de app gebruikt, bij elke aanroep. Een knop Verwijderen verbergen verbergt een knop; het houdt niets tegen.

Teken een link om iemand naar een pagina te sturen

openUrl is voor wanneer het scherm beslist waarheen — na het opslaan, of op basis van wat er werd gekozen. Wanneer de bestemming gewoon vaststaat, teken dan een link: middelklik, rechtsklik → Openen in nieuw tabblad, en de lijst met links van een schermlezer werken allemaal op een echte link en op niets anders. Zie Een Studio-app tekenen.

Cijfers uit een Custom API

Een cijfer — de boekingen van vandaag, de omzet van deze maand — is een periode en een som, vaak over meerdere tabellen, en daar kan loadRecords niet om vragen. Reken het uit in een Custom API en roep die aan vanaf het scherm:

callApi("GET", "psl/v1/overview", { date: "2026-10-06" }, "figures");

Het adres is dat van de API zelf binnen de omgeving: haar uitgeversvoorvoegsel, haar versie en haar route. Bij GET gaan de invoerwaarden mee als querystring, bij POST en de andere als body. Het antwoord komt in het statusveld dat u noemt, zodat een tekst die aan state.figures.bookingsToday is gebonden het toont. De API draait met de rechten van wie het scherm gebruikt.

Niet op een portal

Een portalpagina leest de tabellen die haar portal opsomt en noemt nooit een API; callApi toont daar een melding in plaats van een antwoord.

Wanneer het vak te klein is: de codepagina

Een koppeling is één regel en hoort naast het ding dat ze bepaalt. Een handler groeit — en na de derde if is de kleine editor in het paneel een brievenbus.

Selecteer eerst het object en druk dan op Code schrijven in de werkbalk (de knop </>). De designer wordt bedekt — de pagina eromheen blijft staan — door een lijst met alles wat op dat object scriptbaar is, langs de zijkant, en één editor met ruimte om te schrijven. De lijst bevat de koppelingen, de handlers, de toestandsvelden van het scherm en de eigen eigenschappen van een component. Ongeschreven items staan er ook in, en dat is het snelste antwoord op "wat zou ik hierop kunnen zetten?".

De lijst zegt welke zijn geschreven, zodat je er nooit een hoeft te openen om dat te weten:

Naast de naam	Betekent
Een groene stip, naam vet	Geschreven, en het klopt
Een rode stip, naam vet	Geschreven, en er zit een fout in — open het en de editor onderstreept waar
Een holle stip, naam gedimd	Nog niets geschreven

Zolang de codepagina open is, is het toetsenbord van de editor. Een t typen typt een t; het grijpt niet naar het gereedschap Tekst achter de pagina.

Druk op Ontwerp om terug te gaan — dezelfde knop die je terugbrengt vanuit een voorbeeld, op dezelfde plek bovenaan de pagina. De tekening is precies zoals je haar achterliet: dezelfde selectie, dezelfde zoom. En het is hoe dan ook hetzelfde document, dus een handler die je hier schrijft, verschijnt daar in het paneel.

Gebeurt er niets wanneer je erop drukt, dan zegt een melding waarom, en er zijn maar drie redenen:

De melding	Wat te doen
Er is niets geselecteerd — of meer dan één ding	Selecteer precies één object
Code wordt op het component zelf geschreven	Je hebt een kopie (een exemplaar) of een variant geselecteerd. Rechtsklik → Naar hoofdcomponent gaan en schrijf het daar — elke kopie krijgt het
Dit object hoort bij de grafische elementen van het scherm	Geef eerst op het tabblad Scherm aan wat het is — een knop, een tekstvak — en dan heeft het handlers om te schrijven

Een component wordt op zijn hoofdkopie geschreven. Selecteer het frame waaruit het component bestaat — niet een kopie ervan op een scherm — en de lijst biedt Ingedrukt en de rest, precies zoals voor al het andere. Daar hoort het gedrag van een component: schrijf het één keer, en elke kopie op elk scherm doet het.

Stap 5 — Vraag het eerst, in een modaal venster, een vervolgkeuzelijst of een zijpaneel

Een overlaykaart is een stuk scherm dat er niet is tot een handler het toont.

1. Teken de inhoud één keer, als component. Een kaart met een vraag en twee knoppen is een component als elk ander — zie Een ontwerp hergebruiken met componenten — zodat dezelfde bevestiging kan worden gebruikt op elk scherm dat er een nodig heeft. Teken haar naast je scherm, waar ruimte is.

2. Selecteer het component en vink Een overlaykaart aan op het tabblad Grafisch. Dat is de hele instelling: het wordt niet meer op het scherm getekend, en wordt iets wat een handler kan tonen.

3. Toon het vanuit een handler, via de eigen naam van het component:

   Aanroep	Waar het verschijnt	Goed voor
   showModal("Confirm card")	gecentreerd boven het scherm, met een achtergrond	een vraag die beantwoord moet worden voordat er iets anders gebeurt
   openDropdown("Menu card")	vast aan het ding waarop werd gedrukt	een klein menu, een hint, een kort formulier
   openStartDrawer("Filters card")	volledige hoogte, schuift in vanaf de beginrand	filters, een menu in een smal venster
   openEndDrawer("Details card")	volledige hoogte, vanaf de eindrand	een detailpaneel

4. Sluit het met closeModal(), closeDropdown(), closeStartDrawer() of closeEndDrawer() — bijvoorbeeld vanuit een knop erin. Een zijpaneel heeft geen eigen sluitknop: teken er een in de kaart, zoals de menu's van de voorbeelden doen. Escape en een klik naast het zijpaneel sluiten het nog steeds.

Een kaart die moet worden beantwoord

Onder het vinkje Een overlaykaart staat een tweede: Moet worden beantwoord. Staat het aan, dan werken klikken buiten de kaart, op Escape drukken en de sluitknop allemaal niet meer zolang ze open is — en de sluitknop wordt helemaal niet getoond, omdat een besturingselement dat zichtbaar aanwezig is en niets doet, leest als een vastgelopen pagina voor wie er twee keer op drukt.

Laat het uit, tenzij de kaart iets vraagt wat weglopen niet kan beantwoorden. Een overlay die iemand per ongeluk opende, hoort te sluiten zoals ze openging; de enige soort die dat niet mag, is de soort die bestaat om een antwoord te krijgen — "deze vier records verwijderen?", "dit record is door iemand anders gewijzigd, welke behouden?" — waar op de achtergrond klikken geen antwoord is en toch als een antwoord leest.

Teken je eigen uitweg. Een verplichte kaart weigert elke manier van sluiten die het platform biedt, dus ze heeft een eigen knop nodig die closeModal(), closeStartDrawer() of closeEndDrawer() uitvoert. Zet die vooraan en zonder nadruk, zoals een Annuleren naast een Verwijderen staat.

Een vervolgkeuzelijst negeert het. Een menu dat niet kan worden gesloten door weg te klikken, houdt de pagina gevangen, en een vervolgkeuzelijst is nooit de manier waarop een vraag wordt gesteld.

Een vervolgkeuzelijst opent tegen wat de handler uitvoerde. Er valt niets te kiezen: zet openDropdown("Menu card") op de knop, en het menu verschijnt naast die knop.

Waar ertegen, dat kun je zeggen — openDropdown("Menu card", "bottom-end"):

Plaatsing	Waar de kaart komt
"bottom" (de standaard)	onder de knop, erop gecentreerd
"bottom-start" / "bottom-end"	eronder, uitgelijnd met de begin- / eindrand
"top", "top-start", "top-end"	erboven — voor een besturingselement onderaan een scherm

end, niet right. Een kaart die met bottom-end wordt geopend, hangt in het Engels aan de rechterrand van de knop en in het Perzisch en Arabisch aan de linkerrand, wat dezelfde regel is die de zijpanelen volgen: één script zet het menu in elke taal aan de juiste kant. "bottom-right" schrijven zou een scherm opleveren dat in het Perzisch achterstevoren staat zonder dat iets het zegt — dus het is geen plaatsing, en een handler die erom vraagt, krijgt dat te horen.

Je geeft een voorkeur op, geen belofte: is er onder geen ruimte, dan opent het menu toch erboven. Een menu dat van het scherm af loopt, is erger dan een menu aan de andere kant.

Hoe breed het is, is hoe breed je het tekende. De eigen breedte van de kaart is de breedte van het zijpaneel en van het modale venster — maak de kaart dus zo groot als je het paneel wilt hebben.

Er is er één van elk, en een tweede kaart tonen vervangt de eerste. Een scherm kan maar één modaal venster tegelijk open hebben, en daarom valt er niets te declareren: de hosts zijn er altijd en je handler zegt wat er in een ervan komt.

De rand van een zijpaneel volgt de taal, niet de tekening. Begin is links voor iemand die Engels leest en rechts voor iemand die Perzisch of Arabisch leest — het hele scherm spiegelt, omdat in een app wat je tekende de omlijsting is.

Esc, de achtergrond en een klik erbuiten sluiten allemaal een overlay, en de focus gaat terug naar wat haar opende. Niets daarvan hoef je in te stellen.

Stap 6 — Bekijk een voorbeeld

Druk op Voorbeeld. Het voorbeeld is de echte runtime — hetzelfde component dat de shell koppelt, geen benadering ervan — dus wat je ziet, is wat iemand die de app gebruikt ziet.

Typ in de vakken. Kijk hoe de rest van het scherm volgt.

Regels die je moet kennen

Een koppeling leest alleen. Ze wordt opnieuw uitgevoerd telkens wanneer wat ze leest verandert, dus een koppeling die iets wijzigde, zou zichzelf steeds opnieuw starten. De designer weigert er een bij het opslaan en vertelt je welk object en welke eigenschap — alles wat iets wijzigt, hoort in een handler.

"Getoond" verwijdert, het verbergt niet. Een element waarvan Getoond onwaar is, staat helemaal niet op de pagina: er tabt niets naartoe, geen schermlezer kondigt het aan, en Ctrl+F vindt het niet. Dat is bijna altijd wat je bedoelde.

Niets hiervan is beveiliging. Een verborgen knop is een verborgen knop. Wat iemand echt mag doen, wordt op de server beslist, elke keer, wat het scherm ook toont.

Wat een koppeling vandaag kan zien

Naam	Is
state	de eigen toestand van het scherm, uit stap 1
screen	screen.width en screen.height — het oppervlak, zodat een scherm kan reageren op een smal venster — en screen.name, het scherm waarop je bent, zodat een balk die op elk scherm staat zijn eigen pagina kan markeren
ui	ui.theme (light of dark), ui.locale (en, fa, ar) en ui.dir (ltr of rtl) — de eigen instellingen van de lezer
user	wie er is aangemeld: user.name, user.email en user.photo (leeg als er geen foto is, dus koppel de Shown van een afbeelding aan user.photo != "") — genoeg voor een begroeting of een bovenbalk, en bewust niet hun rollen
screen.params	wat het scherm dat je hierheen stuurde, heeft overhandigd — navigate("Details", { id })

Records komen er via een handler, niet via een eigen naam. loadRecords en getRecord zetten ze in de eigen toestand van het scherm, dus een koppeling leest state.tickets zoals al het andere — er is geen tweede plek om te kijken. Wat er echt nog niet is, zijn de opgeslagen weergaven van het platform: een scherm noemt een tabel en een where, geen weergave.

Wat een koppeling kan berekenen

Een koppeling is een expressie, dus ze kan geen lus maken en geen setState aanroepen. Vier kleine functies dekken wat een bijschrift naast rekenwerk meestal nodig heeft:

Functie	Geeft
text(value)	de waarde als woorden, zodat een getal in een zin kan — "of " + text(state.total)
num(value)	de woorden als getal — wat een vervolgkeuzelijst teruggeeft, klaar om mee te rekenen; 0 als het er geen is
first(list, { field: value, … })	de eerste rij van een geladen lijst waarvan de velden die waarden bevatten, of null — first(state.budgets, { par_department: state.department, par_category: state.category })
format(value, "integer" | "number" | "percent")	een getal zoals jouw taal het schrijft — format(174500, "integer") is 174,500 in het Engels en Perzische cijfers in het Perzisch
translate({ en: "…", fa: "…", ar: "…" })	de woorden voor de taal van de lezer, met Engels als terugval — zie Twee talen

Met first volgt een bijschrift een kiezer naar de rij die die noemt. Laad de tabel één keer, bij Scherm wordt geopend; dan volgt "Available: £" + format(first(state.budgets, { … }).par_remainingbudget, "integer") twee vervolgkeuzelijsten waar ze ook heen gaan, zonder handler. Een geladen rij draagt een keuzekolom als label, en een vervolgkeuzelijst geeft het label terug dat ze aanbood, dus de twee komen overeen. Vang het geval af waarin niets overeenkomt met een voorwaarde — first(…) == null ? "Choose a line" : … — want een veld lezen van null laat de koppeling mislukken, en && vangt dat niet af: beide kanten van een && worden altijd geëvalueerd.

Een bereik is werk voor een handler. first vergelijkt waarden exact; "de schijf waarvan het minimum en maximum dit bedrag omsluiten" is een lus, en een lus hoort in de handler Waarde gewijzigd van het besturingselement, die wat hij vond naar de toestand schrijft zodat het bijschrift het kan lezen. Het voorbeeld studio-capital-planning in samples/solutions doet beide op één scherm.

Twee talen op één scherm

Koppel de Tekst van een tekst aan translate(...), met elke taal naast het Engels:

translate({ en: "Opening times", fa: "ساعات کار" })

en geef de pagina een knop die wisselt: if (ui.locale == "fa") { setLanguage("en"); } else { setLanguage("fa"); }. setLanguage wijzigt de taal van het platform, niet alleen die van het scherm: ze wordt onthouden, en in het Perzisch of Arabisch spiegelt de hele pagina, omdat elke positie die een scherm tekent begin en eind is in plaats van links en rechts. ui.dir zegt in welke richting de pagina leest, zodat een pijl de goede kant op kan wijzen.

Een taal die het object niet heeft, valt terug op het Engels, dus een pagina die half vertaald is, leest in het Engels in plaats van als lege plekken. Het voorbeeld portal-pages-and-navigation is zo geschreven, elk woord ervan.

Iets wat vanzelf gebeurt: de timer

Geef een object een handler Timer tikt en koppel zijn Timerinterval (ms) — dan voert het die handler om de zoveel milliseconden uit zolang het object op de pagina staat:

Timer interval (ms):   state.held ? 0 : 5000
Timer ticks:           setState("slide", (getState("slide") + 1) % 3);

Nul, of niets, betekent gestopt — dus pauzeren is deel van de koppeling, en een carrousel die stilstaat terwijl je hem aanwijst, zet held in zijn handlers Aanwijzer komt erop en Aanwijzer gaat eraf. Minder dan 250 wordt verhoogd naar 250. Een object dat verborgen is, tikt niet. De carrousel in de componentbibliotheek, en op de startpagina van portal-pages-and-navigation, is zo gebouwd.

Problemen oplossen

• "Een koppeling op … kon niet worden uitgevoerd" — de expressie is geldig, maar iets wat ze noemt, is er niet. De meest voorkomende oorzaak is een toestandsveld dat anders gespeld is dan in de koppeling: controleer de lijst Schermtoestand van het schermframe.
• Ik kan niet in het vak typen. — de Waarde ervan is een berekende expressie, dus het is bewust alleen-lezen. Koppel het in plaats daarvan aan een gewoon toestandsveld, en bereken het andere ergens anders.
• Er gebeurt niets wanneer ik typ. — het vak heeft geen koppeling Waarde. Een vak zonder koppeling houdt wat er wordt getypt en vertelt het aan niemand.
• De knop Opslaan gaat nooit aan. — controleer zijn expressie Ingeschakeld tegen een lege waarde: state.requester != "" is pas waar zodra er iets is getypt.
• Op de knop drukken doet niets. — een uitgeschakeld besturingselement ontvangt helemaal geen druk, dus controleer eerst de koppeling Ingeschakeld; controleer daarna of de handler op Ingedrukt staat en niet op een gebeurtenis die hier nooit optreedt (Scherm wordt geopend hoort bij het schermframe, Waarde gewijzigd bij een besturingselement).
• "Een handler op … kon niet worden uitgevoerd" — de handler is geldige BS Lang, maar iets wat hij noemt, is er niet. De meest voorkomende oorzaak is setState op een veld dat het scherm nooit heeft gedeclareerd.
• "createRecord("…") failed: …" — het platform weigerde de schrijfactie, en wat na de dubbele punt volgt, is zijn eigen reden: een verplicht veld zonder inhoud, een waarde die geen van de keuzes is, of een machtiging die je niet hebt. Controleer eerst de veldnamen in de Tabelontwerper — een verkeerd gespelde logische naam is de meest voorkomende oorzaak.
• Er laadt niets, en niets klaagt. — je zit in Voorbeeld, waar geen omgeving achter zit. De recordaanroepen doen daar bewust niets. Open de app vanuit de shell om echte records te zien.
• showModal("…") doet niets. — de naam moet exact overeenkomen met de naam van het component, en bij het component moet Een overlaykaart zijn aangevinkt. Een kaart die is verwijderd of hernoemd, laat handlers achter die haar noemen, en die doen dan stilletjes niets in plaats van het scherm te breken.
• De kaart verschijnt op het scherm in plaats van in een modaal venster. — Een overlaykaart is niet aangevinkt. Tot dat gebeurt, wordt het component getekend waar je het neerzette, zoals elk ander component.
• "Twee componenten heten allebei …" — een kaart wordt getoond via de naam van haar component, dus twee die één naam delen, is een vraag die showModal niet kan beantwoorden. Hernoem er een.

Probeer het

Importeer de voorbeeldoplossing Ticket Triage. Het is deze pagina, gebouwd: drie toestandsvelden, overal gekoppelde eigenschappen, een toestand die het voorbeeld zelf een naam gaf, een modaal venster dat het eerst vraagt voordat het ticket wordt aangemaakt, en een pop-over die opent vanuit een eigen knop.