Funktionerna Back och Navigate

Ändrar vilken skärm som visas.

Översikt

De flesta program innehåller flera skärmar. Använd funktionen Back och Navigate för att ändra vilken skärm som visas. Du kan t.ex. ange egenskapen OnSelect för en knapp till en formel som innehåller funktionen Navigate, om du vill visa en annan skärm när en användare väljer den knappen. I den formeln kan du ange en visuell övergång som t.ex. Fade, för att styra hur den ena skärmen ändras till den andra.

Bakåt och Navigera ändrar bara vilken skärm som visas. Skärmar som inte visas för tillfället fortsätter att fungera i bakgrunden. Du kan skapa formler som refererar till egenskaper för kontrollerna på andra skärmar. En användare kan till exempel ändra värdet för ett skjutreglage på en skärm, navigera till en annan skärm som använder detta värde i en formel och där bestämma hur den påverkar vad som händer på den nya skärmen. Användaren kan sedan gå tillbaka till den ursprungliga skärmen och bekräfta att skjutreglaget har behållit sitt värde.

Sammanhangsvariabler bevaras också när en användare navigerar mellan skärmar. Du kan använda Navigate för att ange en eller flera sammanhangsvariabler för skärmen som formeln visar, vilket är det enda sättet att ange en sammanhangsvariabel utanför skärmen. Du kan använda den här metoden för att skicka parametrar till en skärm. Om du har använt något annat programmeringsverktyg liknar metoden att skicka parametrar till procedurer.

Använd Program-objektets StartScreen-egenskap för att styra vilken vy som ska visas först.

Du kan endast använda båda funktioner i en beteendeformel.

Navigera

Gäller för: Arbetsyteappar Modellbaserade appar

I det första argumentet anger du namnet på den skärm som ska visas.

I det andra argumentet anger du hur den gamla skärmen ska ändras till den nya skärmen:

Övergångsargument	Beskrivning	Demonstration
ScreenTransition.Cover (på engelska)	De nya skärmbilderna till vyn, från höger till vänster, för att täcka den aktuella skärmen.
ScreenTransition.CoverRight	De nya skärmbilderna till vyn, från vänster till höger, för att täcka den aktuella skärmen.
ScreenTransition.Fade (på engelska)	Den nuvarande skärmen tonas bort och den nya skärmen visas.
ScreenTransition.None (Standard)	Den nya skärmen ersätter snabbt den aktuella skärmen.
ScreenTransition.UnCover (på engelska)	Den aktuella skärmen glider ur synvinkeln och rör sig åt höger till vänster för att avslöja den nya skärmen.
ScreenTransition.UnCoverRight	Den aktuella skärmen glider ur synvinkeln och rör sig åt vänster till höger för att avslöja den nya skärmen.

Du kan använda Navigate för att skapa eller uppdatera sammanhangsvariabler för den nya skärmen. Ett valfritt tredje argument är att skicka en post som innehåller namnet på sammanhangsvariabeln som ett kolumnnamn och det nya värdet för sammanhangsvariabeln. Den här posten är samma som den post du använder med funktionen UpdateContext.

Ange egenskapen OnHidden för den gamla skärmen, egenskapen OnVisible för den nya skärmen, eller båda för att göra fler ändringar under övergången. Egenskapen Program.ActiveScreen uppdateras till att återspegla ändringen.

Navigera returnerar normalt sant men returnerar falskt om ett fel påträffas.

Kontextvariabler för navigering förklaras i artikeln navigera mellan skärmar.

Bakåt

Gäller för: Arbetsyteappar

Funktionen Back returnerar till den skärm som visades senast.

För varje anrop navigering spårar programmet skärmen som visades och övergången. Du kan använda efterföljande Tillbaka-anrop hela vägen till skärmen som visades när användaren startade programmet.

När funktionen Back används inverterad övergång som standard. Om en skärm visas via övergången CoverRight använder Tillbaka UnCover (som är till vänster) för att returnera. Fade och None är sina egna motsatser. Skicka ett valfritt argument för tvinga Tillbaka en specifik övergång.

Tillbaka returnerar normalt sant men returnerar falskt om användaren inte har navigerat till en annan skärm sedan appen startades.

Syntax

Tillbaka( [ Övergående ] )

• Övergång - Valfritt. Den visuella övergången som kommer användas mellan den aktuella skärmen och föregående skärm. Se listan över giltiga värden för det här argumentet finns i början av den här artikeln. Som standard är övergången som en skärm returnerar den inversa av övergången som den visades med.

Navigera( Skärm [, Övergångs [, UpdateContextRecord ] ] )

• Skärm - Obligatoriskt. Skärmen som kommer att visas. I stället för skärmen kan du också använda en kontroll som visas på skärmen som du vill navigera till.
• Övergång - Valfritt. Den visuella övergången som kommer användas mellan den nuvarande skärmen och nästa skärm. Se listan över giltiga värden för det här argumentet finns i början av den här artikeln. Standardvärdet är Ingen.
• UpdateContextRecord – valfritt. En post som innehåller namnet på minst en kolumn och ett värde för varje kolumn. Posten uppdaterar sammanhangsvariablerna för den nya skärmen, som om de skickades till funktionen UpdateContext.

Exempel

Steg-för-steg

1. Skapa en tom app.

2. Lägg till en andra skärmbild.

   programmet innehåller två tomma skärmar: Screen1 och Screen2.

3. Ange egenskapen Fill för Screen2 till värdet Gray.

4. På Screen2, lägg till knappen och ange dess egenskap OnSelect till följande formel:

   Navigate( Screen1, ScreenTransition.Cover )
   

5. När du håller ned Alt-tangenten, välj knappen.

   Screen1 visas med en vit bakgrund genom en övergång som täcker till vänster.

6. På Screen1, lägg till knappen och ange dess egenskap OnSelect till följande formel:

   Back()
   

7. När du håller ned Alt-tangenten, välj knappen.

   Den andra skärmen visas med en grå bakgrund med en övergång som täcks av övergången åt höger (inversen för Cover).

8. Markera knappen på varje skärm flera gånger för att studsa framåt och bakåt.

Se även

Använda sammanhangsvariabler