Solaris Common Desktop Environment: Handbok för avancerade användare och systemadministratörer

Skapa en exekveringssträng för COMMAND-åtgärder

Minimikraven för en COMMAND-åtgärd är två fält: ACTION och EXEC_STRING.

ACTIONåtgärdsnamn
 {
     EXEC_STRING exekveringssträng
 }

Exekveringssträngen är den viktigaste delen av en COMMAND-åtgärdsdefinition. 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:

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

Åtgärdsargument

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.

Åtgärder kan, på samma sätt som program och kommandon, ha argument. Det finns två typer av data som en COMMAND-åtgärd 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.

Till exempel:

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

Skapa en funktion som kör ett fjärrprogram

Om ditt program finns i en katalog 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 åtgärder som inte använder argument

Använd samma syntax för EXEC_STRING som du skulle använda för att starta programmet från kommandoraden.

Exempel

Den här exekveringssträngen är en del av åtgärden som startar X-klienten xcutsel.
```
EXEC_STRING xcutsel
```

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

Skapa åtgärder som accepterar släppta filer

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

%Arg_n%

eller

%(File)Arg_n%

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

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

Exempel

Den här 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 åtgärd som bara arbetar med katalogargument. När katalogen släpps på åtgärdsikonen, visas en lista över alla filer i katalogen 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 åtgärd som frågar efter ett filargument

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

%(File)"ledtext"%

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

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äkna ord i filen:"%

Skapa åtgärder 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 åtgärd som:

Accepterar en släppt fil som filargument.

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

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

Skapa en åtgärd 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 i 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 filnamnet med hjälp av kommandot lp -ttitelfilnamn.

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

Skalmöjligheter för åtgärder

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 åtgärd 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"Man-sida:"% | troff -man'
```

Den här exekveringssträngen kräver att argumentet ska vara en komprimerad fil. Åtgärden expanderar 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-åtgärder för flera filargument

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

Åtgärden kan utföras 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å åtgärdsikonen, körs åtgärden separat för varje filargument.

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

Åtgärden kan använda två eller flera icke utbytbara filargument: Till exempel:
```
	xsetroot -cursor markörfil maskfil  
```
som kräver två unika filer i en viss ordning.

Åtgärden kan utföra samma kommando för varje filargument i tur och ordning. Till exempel:
```
	pr fil [fil …]  
```
som skriver ut en eller flera filer.

Skapa en åtgärd för icke utbytbara argument

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

Om du vill att åtgärden 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%
```
olika värden på n för varje argument. Till exempel:
```
	EXEC_STRING				diff %Arg_1% %Arg_2%
```

Skapa en åtgärd med utbytbara filargument

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

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

Om du vill skapa en åtgärd 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%
```
Åtgärden utfärdar kommandot i följande form: kommandofil 1 fil 2 ….

Exempel

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

Den här exekveringssträngen skapar en åtgärd 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 åtgärder 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"Fil som ska checkas 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%