Common Desktop Environment: Användarhandbok för systemadministratörer

Skapa en exekveringssträng för COMMAND-funktioner

Minimikraven för en COMMAND-funktion är två fält - ACTION och EXEC_STRING.

ACTION funktionsnamn
 {
     EXEC_STRING exekveringssträng
 }

Exekveringssträngen är den viktigaste delen av en COMMAND-funktionsdefinition. Den använder syntax som liknar den på kommandoraden i ett terminalfönster, men innehåller ytterligare syntax för hantering av fil- och strängargument.

Generella egenskaper för exekveringssträngar

Exekveringssträngar kan innehålla:

Fil och icke-filargument
Skalsyntax
Absoluta sökvägar eller namn på körbara filer

Funktionsargument

Ett argument är information som är nödvändig för att ett kommando eller program ska kunna köras. Kommandoraden nedan kan du t ex använda för att öppna en fil i Textredigeraren:

dtpad filnamn

I det här kommandot är filnamn ett filargument till kommandot dtpad.

Funktioner kan, på samma sätt som program och kommadon, ha argument. Det finns två typer av data som en COMMAND-funktion kan använda:

Filer
Strängdata

Använda skal i exekveringssträngar

I de flesta fall finns funktioner och deras program i samma system. Eftersom den normala värddatorn för exekvering av en funktion är databasvärden, behövs ingen särskild syntax.

Exempel:

EXEC_STRING				\
 		/bin/sh -c \
 		'tar -tvf %(File)Arg_1% 2>&1 | \${PAGER:-more};\
 		echo "\\n*** Välj Stäng på Fönster-menyn för att stänga ***"'

Skapa en funktion som kör ett fjärrprogram

Om ditt program finns i en mapp som är listad i variabeln PATH, kan du ange den körbara filens enkla namn. Om programmet finns någon annanstans måste du använda den absoluta sökvägen till den körbara filen.

Skapa funktioner som inte använder argument

Använd samma syntax i fältet EXEC_STRING som du skulle göra på kommandoraden.

Exempel

Den här körbara strängen är en del av funktionen som startar X-klienten xcutsel.
```
EXEC_STRING xcutsel
```

Den här körbara strängen startar klienten xclock med en digital klocka. Kommandoraden omfattar ett kommandoradsalternativ men kräver inga argument.
```
EXEC_STRING xclock -digital
```

Skapa funktioner som accepterar släppta filer

Använd följande syntax för filargumentet:

%Arg_n%

eller

%(Fil)Arg_n%

(File) är valfritt eftersom argument för Arg_n antas (som standard) vara filer. (I "Tolka filargument som en sträng" beskrivs hur du använder syntaxen %(String)Arg_n%.

Med den här syntaxen kan användarna släppa ett datafilobjekt på funktionsikonen för att starta funktionen med filargumentet. Den ersätter det n:te argumentet på kommandoraden. Filen kan vara en lokal fil eller en fjärrfil.

Exempel

Exekveringssträngen kör wc -w med en släppt fil som parametern --load.
```
	EXEC_STRING wc -w %Arg_1%
```

I det här exemplet visas en del av en definition för en funktion som bara arbetar med mappargument. När mappen släpps på funktionsikonen, visas en lista över alla filer i mappen som har läs- och skrivbehörighet.
```
	ACTION  List_Writable_Files
 	{
 	    ARG_TYPE     FOLDER
 	    EXEC_STRING /bin/sh -c 's -l %Arg_1% | grep rw-'
 	    ...
 	}
```

Skapa en funktion som frågar efter ett filargument

Använd följande syntax för filargumentet:

%(File)"ledtext"%

Den här syntaxen skapar en funktion som visar en ledtext för ett filnamn när användaren dubbelklickar på funktionsikonen.

Den här exekveringssträngen visar t ex en dialogruta som frågar efter filargumentet till kommandot wc --w:

EXEC_STRING wc -w %(File)"Räknar ord i filen:"%

Skapa funktioner som accepterar eller frågar efter en släppt fil

Använd följande syntax för filargumentet:

%Arg_n"ledtext"%

eller

%(File)Arg_n"ledtext"%

Syntaxen skapar en funktion som:

Accepterar en släppt fil som filargument.

Visar en dialogruta som frågar efter ett filnamn när användaren dubbelklickar på funktionsikonen.

Den här exekveringssträngen utför t ex lp -oraw på en släppt fil. Om funktionen startas genom att någon dubbelklickar på ikonen visas en dialogruta som frågar efter filnamnet.
```
EXEC_STRING lp -oraw %Arg_1"Fil att skriva ut:"%
```

Skapa en funktion som frågar efter icke-filargument

Använd följande syntax för icke-filparametern:

%"ledtext"%

eller

(String)%"ledtext"%

(String) är valfritt eftersom text inom citattecken normalt tolkas som strängdata. Den här syntaxen visar en dialogruta som frågar efter icke-fildata. Använd inte syntaxen för att fråga efter ett filnamn.

Den här exekveringssträngen kör t ex kommandot xwd och frågar efter ett värde som ska läggas till varje bildpunkt:

EXEC_STRING xwd -add %"Lägg till värde:"% -out %Arg_1"Filnamn:"%

Tolka filargument som en sträng

Använd följande syntax för argumentet:

%(String)Arg_n%

Den här exekveringssträngen skriver t ex ut en fil med en titel som innehåller filnamn, med hjälp av kommandot lp -ttitel filnamn.

EXEC_STRING lp -t%(String)Arg_1% %(File)Arg_1"Fil som ska skrivas ut:"%

Skalmöjligheter för funktioner

Ange skalet i exekveringssträngen:

/bin/sh -c 'kommando'
/bin/ksh -c 'kommando'
/bin/csh -c 'kommando'

Exempel

Den här exekveringssträngen illustrerar en funktion som använder skalprogramkoppling.
```
	EXEC_STRING /bin/sh -c 'ps | lp'
```

Det här är en mer komplicerad exekveringssträng som kräver skalbearbetning och accepterar filargument.
```
	EXEC_STRING /bin/sh -c 'tbl %Arg_1"Hjälpfil (man):"% | troff -man'
```

Den här exekveringssträngen kräver att argumentet ska vara en komprimerad fil. Funktionen packar upp filen och skriver ut den med lp -oraw.
```
	EXEC_STRING				/bin/sh -c 'cat %Arg_1 "Fil som ska skrivas ut:"% | \
 					uncompress | lp -oraw'
```

Denna exekveringssträng startar ett skalskript:
```
	EXEC_STRING /usr/local/bin/StartGnuClient
```

Skapa COMMAND-funktioner för flera filargument

Funktioner kan använda något av följande tre sätt att hantera flera filargument:

Funktionen utförs en gång för varje argument: När en EXEC_STRING innehåller ett enstaka filargument och flera filargument tillhandahålls genom att flera filer släpps på funktionsikonen, körs funktionen separat för varje filargument.

Om det t ex finns flera filargument för följande funktionsdefinition:
```
	ACTION DisplayScreenImage
	{ 	
 			EXEC_STRING					xwud -in %Arg_1%
 		...
 	}
```
körs funktionen DisplayScreenImage upprepade gånger.

Funktionen kan använda två eller flera icke utbytbara filargument, exempelvis:
```
	xsetroot -cursor markörfil maskeringsfil  
```
som kräver två unika filer i en viss ordning.

Funktionen kan utföra samma kommando för varje filargument, exempelvis:
```
	pr fil [fil ...]  
```
som skriver ut en eller flera filer.

Skapa en funktion för icke utbytbara argument

Använd någon av följande syntaxer:

Om du vill att funktionen ska fråga efter filnamnen använder du den här syntaxen för varje filargument:
```
	%(File)"ledtext"%
```
Använd en särskild ledtext för varje argument.

Följande exekveringssträng frågar efter två filer.
```
	EXEC_STRING				xsetroot -cursor %(File)"Markörbitmapp:"% \
 								%(File)"Maskbitmapp:"%
```

Om följande syntax används för filargument, accepteras släppta filer:
```
	 %Arg_n%
```
Använd olika värden på n för varje argument. Exempel:
```
	EXEC_STRING				diff %Arg_1% %Arg_2%
```

Skapa COMMAND-funktioner för utbytbara filargument

Använd någon av följande syntaxer:

Om du vill skapa en funktion som accepterar släppta filer och som skapar ett kommando av formen kommando fil 1 fil 2 ..., ska följande syntax för filargument användas:
```
	%Args%
```

Om du vill skapa en funktion som accepterar flera släppta filer, eller visar en ledtext för en enstaka fil när du dubbelklickar på den, använder du följande syntax för filargumenten:
```
	%Arg_1"ledtext"% %Args%
```
Funktionen startar kommandot i formatet: kommando fil 1 fil 2 ....

Exempel

Den här exekveringssträngen skapar en funktion som kör:
```
	pr fil 1 fil 2
```
med flera filargument.
```
	EXEC_STRING pr %Args%
```

Den här exekveringssträngen skapar en funktion som liknar den i föregående exempel, med undantaget att den visar en ledtext när du dubbelklickar (inga filargument).
```
	EXEC_STRING  pr %Arg_1"Fil(er) som ska skrivas ut:"% %Args%
```

Skapa funktioner för flera släppta filer

För att acceptera flera argument för släppta filer och köra en kommandorad i formatet:

kommando fil 1 fil 2 ...

använder du syntaxen:

%Args%

Exempel

Den här exekveringssträngen kör skriptet Checkout för flera filer:

	EXEC_STRING				/usr/local/bin/Checkout \  								%Arg_1"Vilken fil ska hämtas ut?"% %Args%

Den här exekveringssträngen kör lp -oraw med flera filer.

	EXEC_STRING				lp -oraw %Arg_1"Fil som ska skrivas ut:"% %Args%