test

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

Kapitel 12 Skapa funktioner manuellt

Det finns två sätt att skapa funktioner:

När du skapar en funktion manuellt måste du redigera en databasfil. Det här kapitlet beskriver hur du skapar funktionsdefinitioner manuellt.

När funktioner måste skapas manuellt

Det finns tre grundtyper av funktioner:

Verktyget Skapa funktion är utformat för att skapa vissa typer av COMMAND- och MAP-funktioner. Alla TT_MSG-funktioner måste skapas manuellt.

Mer information finns i "Begränsningar i Skapa funktion".

COMMAND-funktioner

En kommandofunktion utför ett kommando som startar ett program eller ett hjälpmedel, kör en kommandofil i skal eller utför ett operativsystemkommando. Definitionen för funktionen innehåller kommandot som ska köras (EXEC_STRING).

Verktyget Skapa funktion kan användas till att skapa de vanligaste typerna av kommandofunktioner. Det kan dock finnas situationer där du måste skapa funktionen manuellt. Du måste exempelvis skapa en COMMAND-funktion manuellt om funktionen anger:

MAP-funktioner

En tilldelningsfunktion är en funktion som tilldelas en annan funktion i stället för att den direkt anger ett kommando eller ToolTalk-meddelande.

Med tilldelning kan du ange alternativa namn på funktioner. En inbyggd kommandofunktion med namnet IconEditor startar Ikonredigeraren. Databasen innehåller också en Öppna-funktion (i definitionen begränsad till bitmapps- och bildpunktsfiler (av fältet ARG_TYPE )) som tilldelats funktionen IconEditor. På så sätt kan användaren starta Ikonredigeraren genom att markera en bitmapps- eller bildpunktsfil i Filhanteraren och därefter välja Öppna på Markera-menyn.

Skapa funktion erbjuder begränsad tilldelning för Öppna- och Skriv ut-funktioner. Alla andra tilldelningsfunktioner måste skapas manuellt.

TT_MSG-funktioner (ToolTalk-meddelanden)

TT_MSG-funktioner skickar ToolTalk-meddelanden. Alla TT_MSG-funktioner måste skapas manuellt.

Skapa en funktion manuellt: Generella steg

Det här avsnittet beskriver hur du skapar en konfigurationsfil för en funktionsdefinition.

Konfigurationsfiler för funktioner

Konfigurationsfiler som innehåller funktionsdefinitioner måste uppfylla följande krav:

Mer information om hur du ändrar sökväg för funktioner och datatyper finns i "Ange värde för en sökväg".

Skapa en funktion manuellt

  1. Öppna en befintlig databasfil eller skapa en ny.

    Se föregående avsnitt, "Konfigurationsfiler för funktioner".

  2. Skapa en funktionsdefinition med syntaxen: 

    	ACTION funktionsnamn
 	{
 		TYPE		funktionstyp
 		funktionsfält
 		...
 	}

    där:

    funktionsnamn är namnet som används för att köra funktionen.

    funktionstyp är COMMAND (standard), MAP, eller TT_MSG.

    funktionsfält är ett av de nödvändiga eller valfria fälten för den här typen av funktion. Alla fält består av ett nyckelord och ett värde.

    Många av funktionsfälten beskrivs i det här kapitlet. Du får mer information i direkthjälpen (man) för dtactionfile(4).

  3. Spara filen

  4. Om du vill att funktionsikonen ska ha en unik bild skapar du en ikon till funktionen. Standardadressen för ikoner är:

    • Egna ikoner: Hemmapp/.dt/icons

    • Systemtäckande ikoner: /etc/dt/appconfig/icons/språk. Standardvärdet för språk är C.

      Mer information finns i "Ange funktionens ikonbild".

  5. Dubbelklicka på Ladda om funktioner i programgruppen Skrivbordsverktyg.

  6. Skapa funktionsfilen för funktionen. Funktionsfilen skapar en ikon i Filhanteraren eller Programhanteraren som representerar funktionen. (Om funktionen är skriven för att starta ett program kallas ikonen för programikon.)

    Om du vill skapa en funktionsfil skapar du en körbar fil med samma namn som ett funktionsnamn. Du kan placera den här filen i en valfri mapp, som du har skrivbehörighet till. Du kan skapa så många funktionsfiler du vill.

Exempel på hur du skapar en COMMAND-funktion

I följande steg skapas en egen funktion som startar ett faxprogram i fjärrsystemet ProgServerA. Kommandot som startar faxprogrammet är:

/usr/fax/bin/faxcompose [filnamn]

  1. Skapa filen Hemmapp/.dt/types/Fax.dt.

  2. Placera följande funktionsdefinition i filen: 

    	ACTION Faxassistent
 	{
 		TYPE					COMMAND
 		ICON					fax
 		WINDOW_TYPE			NO_STDIO
 		EXEC_STRING			/usr/fax/bin/faxcompose -c %Arg_1%
 		EXEC_HOST     	 	ProgServerA
 		DESCRIPTION    	Kör Faxassistenten
    	}

    Fälten WINDOW_TYPE och EXEC_STRING beskriver funktionens beteende.

    WINDOW_TYPE - nyckelordet NO_STDIO anger att funktionen inte behöver köras i ett terminalemulatorfönster.

    Se "Ange fönsterstöd för funktionen".

    EXEC_STRING - syntaxen %Arg_1% accepterar en släppt fil. Om någon dubbelklickar på funktionsikonen, öppnar funktionen ett tomt faxassistentfönster.

    Se "Skapa en exekveringssträng för COMMAND-funktioner".

  3. Spara filen

  4. Skapa följande ikonbildsfiler i Hemmapp/.dt/icons med hjälp av Ikonredigeraren:

    • fax.m.pm, 32 gånger 32 bildpunkter

    • fax.t.pm, 16 gånger 16 bildpunkter

  5. Dubbelklicka på Ladda om funktioner i programgruppen Skrivbordsverktyg.

  6. Skapa en körbar fil med namnet Faxassistent i en mapp som du har skrivbehörighet till (t ex hemmappen).

Exempel på hur du skapar en MAP-funktion

Anta att de flesta filer du faxar skapas med Textredigeraren och är av datatypen TEXTFILE (filer med namnet *.txt).

Stegen nedan lägger till menyalternativet ''Fax'' på datatypens Markera-meny.

  1. Öppna filen Hemmapp/.dt/types/Fax.dt som skapades i föregående exempel.

  2. Lägg till den här tilldelningsdefinitionen i filen:

    	ACTION Fax
 	{
 		ARG_TYPE			TEXTFILE
 		TYPE				MAP
 		MAP_ACTION		Faxassistent
 	}

  3. Spara filen

  4. Kopiera dataattributsdefinition för TEXTFILE från /usr/dt/appconfig/types/språk/dtpad.dt till den nya filen Hemmapp/.dt/types/textfile.dt. Lägg till funktionen Fax i fältet ACTIONS.

    	DATA_ATTRIBUTES TEXTFILE
 	{
 		ACTIONS			Open,Print,Fax
 		ICON				Dtpenpd
 		...
 	}

  5. Spara filen

  6. Öppna Programhanteraren och dubbelklicka på Ladda om funktioner i programgruppen Skrivbordsverktyg.

Starta om databasen för funktioner och datatyper

För att nya och redigerade funktionsdefinitioner ska träda i kraft måste skrivbordet läsa om databasen.

    Öppna programgruppen Skrivbordsverktyg och dubbelklicka på Ladda om funktioner.

    Eller också kör du kommandot:

    	dtaction ReloadActions

    ReloadActions är namnet på den funktion vars ikon heter ''Ladda om funktioner''.

    Funktionsdatabasen läses också om när användaren:

    • Loggar in

    • Startar om arbetsytehanteraren

    • Sparar en funktion i fönstret Skapa funktion genom att välja Spara på Fil-menyn.

Skapa funktionsfil (ikon) för funktion

En funktionsfil är en fil som skapas för att visuellt representera funktionen i Filhanteraren och Programhanteraren.

Figur 12-1 Funktionsfiler (funktionsikoner) i Programhanteraren

Graphic

Eftersom en funktionsfils ikon representerar en funktion, kallas den ibland funktionsikon. Om den underliggande funktionen startar ett program, kallas funktionsfilsikonen för programikon.

Om du dubbelklickar på funktionsikonen körs funktionen. Funktionsikonen kan också vara ett släppområde.

Skapa en funktionsfil (funktionsikon)

    Skapa en körbar fil med samma namn som funktionsnamnet. Innehållet i filen har ingen betydelse.

Om funktionsdefinitionen är:

ACTION  Favoritprogram
 {
 	EXEC_STRING				Fav-fil %Arg_1%
 	DESCRIPTION				Kör Favoritprogram
 	ICON						Favp
 }

blir funktionsfilen en körbar fil med namnet Favoritprogram. I Filhanteraren och Programhanteraren använder filen Favoritprogram ikonbilden Favp.storlek.typ. Om du dubbelklickar på ikonen för Favoritprogram körs funktionens exekveringssträng, och ikonens objekthjälp får innehållet i fältet DESCRIPTION ("Kör Favoritprogram").

Funktionsnamn

Om funktionsdefinitionen innehåller fältet LABEL, får funktionsfilen innehållet i detta fält som namn i Filhanteraren och Programhanteraren i stället för filnamnet (funktionsnamn). Om funktionsdefinitionen t ex innehåller:

ACTION  Favoritprogram
 {
 	LABEL      Mitt favoritprogram
 	...
 }

kommer funktionsikonen att heta "Mitt favoritprogram".

Ange funktionens ikonbild

Använd fältet ICON för att ange vilken ikonbild som ska användas i Filhanteraren och Programhanteraren för den funktionsikon som skapas för funktionen.

Om du inte anger någon ikon används bildfilerna för standardfunktionsikoner /usr/dt/appconfig/icons/språk/Dtactn.*.

Figur 12-2 Standardbild för funktionsikon

Graphic

Standardfunktionsikonen ändras med resursen: 

*actionIcon:    ikonfilnamn

där ikonfilnamn kan vara ett basnamn eller en absolut sökväg.

Värdet på fältet ICON kan vara:

Tabell 12-1 Ikonnamn och storlek på funktionsikoner

Storlek i bildpunkter 

Bitmappsnamn 

Bildpunktsmönsternamn 

48 gånger 48 

namn.l.bm

namn.l.pm

32 gånger 32 

namn.m.bm

namn.m.pm

16 gånger 16 

namn.t.bm

namn.t.pm

Ändra en befintlig funktionsdefinition

Du kan ändra alla funktioner som finns tillgängliga i systemet, inklusive inbyggda funktioner.

Obs!

Var försiktig när du ändrar databasen för inbyggda funktioner. De inbyggda funktionerna är utformade speciellt för att fungera med skrivbordsprogrammen.

  1. Sök reda på funktionsdefinitionen till funktionen du vill ändra.

    Standardsökvägen för funktionsdefinitioner är:

    • Inbyggda funktioner: /usr/dt/appconfig/types/språk

    • Systemtäckande funktioner: /etc/dt/appconfig/types/språk

    • Egna funktioner: Hemmapp/.dt/types

      Det kan finnas fler sökvägar i systemet. Om du vill visa en lista med de sökvägar som systemet använder för funktioner, skriver du kommandot: 

      	dtsearchpath -v

      Systemet använder mapparna som listas under DTDATABASESEARCHPATH.

  2. Om det behövs kopierar du texten till funktionsdefinitionen till en ny eller befintlig fil i någon av dessa mappar:

    • Systemtäckande funktioner: /etc/dt/appconfig/types/språk

    • Egna funktioner: Hemmapp/.dt/types

      Du måste kopiera inbyggda funktioner eftersom du inte bör redigera filer i mappen /usr/dt/appconfig/types/språk.

  3. Redigera funktionsdefinitionen.

  4. När du är färdig med redigeringen sparar du filen.

  5. Dubbelklicka på Ladda om funktioner i programgruppen Skrivbordsverktyg.

Prioritet i funktionsdefinitioner

När användarna anropar en funktion söker systemet i databasen efter ett matchande funktionsnamn. När det finns fler än en funktion med samma namn används prioritetsregler för att bestämma vilken funktion som ska användas.

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:

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:

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

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

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:

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

Skapa COMMAND-funktioner för flera filargument

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

Skapa en funktion för icke utbytbara argument

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

Skapa COMMAND-funktioner för utbytbara filargument

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

Exempel

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

Fönsterstöd och terminalemulatorer för COMMAND-funktioner

Det finns flera sätt på vilka funktionen COMMAND stödjer fönster på skrivbordet

Ange fönsterstöd för funktionen

Använd fältet WINDOW_TYPE för att ange den typ av fönsterstöd som krävs av funktionen enligt Tabell 12-2.

Tabell 12-2 Fältet WINDOW_TYPE och tillgängligt fönsterstöd

WINDOW_TYPE

Tillgängligt fönsterstöd 

NO_STDIO

Inget. Använd NO_STDIO om programmet har ett eget fönster eller om kommandot inte har synliga utdata.

PERM_TERMINAL

Permanent terminalemulatorfönster. Funktionen öppnar ett terminalfönster som är öppet tills användaren stänger det. Användaren kan skriva data i fönstret. Används tillsammans med kommandon som tar emot vissa indata, skapar vissa utdata och sedan avslutas (t ex ls mapp).

TERMINAL

Temporärt terminalemulatorfönster. Funktionen öppnar ett terminalfönster som stängs så fort kommandot är färdigt. Används tillsammans med fullskärmskommandon (t ex vi).

Ange kommandoradsalternativ för terminalemulatorn

Använd fältet TERM_OPTS i funktionsdefinitionen för att ange kommandoradsalternativ för terminalemulatorn.

Följande funktion frågar t ex efter värddatorn för exekvering:

ACTION ÖppnaTermPåValfrittSystem
 {
 	WINDOW_TYPE					PERM_TERMINAL
 	EXEC_HOST    				%(String)"Fjärrterminal på:"%
 	TERM_OPTS    				-title %(String)"fönstertitel:"%
 	EXEC_STRING  				$SHELL
 }

Ange en annan standardterminalemulator

Standardterminalemulator för funktioner är dtterm. Du kan ändra detta till en annan terminalemulator. Standardterminalemulatorn används när funktionen inte särskilt anger vilken terminalemulator som ska användas.

Terminalemulatorn som används av funktionerna måste ha dessa kommandoradsalternativ:

Begränsa funktioner för vissa argument

När du begränsar en funktion till en viss typ av argument förfinas funktionen. Du bör t ex begränsa en funktion som startar en läsare för PostScript-filer till endast PostScript-filargument. Med en sådan begränsning returnerar funktionen ett felmeddelande om en icke-PostScript-fil anges.

Du kan begränsa funktioner baserat på:

Begränsa funktioner till en viss datatyp

Använd fältet ARG_TYPE för att ange vilken datatyp som funktionen gäller för. Använd datanamnsattributet.

Du kan ange en lista med datatyper. Avgränsa posterna med kommatecken.

Följande funktionsdefinition antar att en gif-datatyp har skapats.

ACTION Open_Gif
 {
 	TYPE					COMMAND
 	LABEL					"Visa gif"
 	WINDOW_TYPE			NO_STDIO
 	ARG_TYPE				Gif
 	ICON					xgif
 	DESCRIPTION			Visar gif-filer
 	EXEC_STRING			xgif
 }

Begränsa funktioner med antalet argument

Använd fältet ARG_COUNT för att ange hur många argument som funktionen ska acceptera. Giltiga värden är:

* (Standard) - valfritt antal argument. Andra värden har företräde före *.

n - valfritt positivt heltal, inklusive 0.

>n - fler än n argument.

<n - färre än n argument.

Använd ARG_COUNT för att ange olika metoder för funktionsikoner, beroende på om användaren dubbelklickar på ikonen eller släpper en fil på den. Se även nästa avsnitt "Ange metod för dubbelklickning och släppfunktionen".

Ange metod för dubbelklickning och släppfunktionen

Använd följande procedur för att skapa en funktion som accepterar en släppt fil, men inte frågar efter en fil när någon dubbelklickar på funktionsikonen.

  1. Skapa en funktionsdefinition för dubbelklickningsfunktionalitet.

    Använd fältet ARG_COUNT för att ange 0-argument. Använd en syntax för EXEC_STRING som inte accepterar släppta argument.

  2. Skapa en andra funktionsdefinition för släppfunktionen.

    Använd fältet ARG_COUNT för att ange >0-argument. Använd en syntax för EXEC_STRING som accepterar en släppt fil.

    Anta att följande två kommandorader kan användas för att starta en redigerare med namnet vedit:

    • Starta redigeraren utan filargument:

      	vedit

    • Starta redigeraren med ett filargument som öppnas som skrivskyddat dokument:

      	vedit -R filnamn

      Följande två funktioner skapar släpp- och dubbelklickningsfunktionalitet för en funktion som heter Vedit. Den första funktionen prioriteras när databasen letar efter en matchning, eftersom ARG_COUNT 0 är mer specifik än ARG_COUNT * i definitionen av släppfunktionaliteten.

      # Dubbelklickningsfunktionalitet  
 ACTION Vedit
 {
 	TYPE						COMMAND
 	ARG_COUNT				0
 	WINDOW_TYPE				PERM_TERMINAL
 	EXEC_STRING				vedit
 }

 # Släppfunktionalitet
 ACTION Vedit
 {
 	TYPE						COMMAND
 	WINDOW_TYPE				PERM_TERMINAL
 	EXEC_STRING				vedit -R %Arg_1%
 }

Begränsa funktioner baserat på argumentläge

Använd fältet ARG_MODE för att ange läs- och skrivläge för argumentet. Giltiga värden är:

* (Standard) - valfritt läge

!w - icke skrivbar

w - skrivbar

Skapa funktioner som kör program i fjärrsystem

När funktioner och fjärrexekvering behandlas finns det två termer som ofta används:

databasvärd - systemet som innehåller funktionsdefinitionen

körvärd - systemet där den körbara filen körs

I de flesta situationer finns funktioner och deras program i samma system. Eftersom databasvärden är standardkörvärd för en funktion, krävs ingen särskild syntax.

När värddatorn för exekvering däremot är en annan än databasvärden, måste funktionsdefinitionen ange var exekveringssträngen ska köras.

Möjligheten att placera funktioner och program på olika system är en del av skrivbordets klient/server-arkitektur. Mer information om nätverksprogram finns i "Administrera programtjänster".

Skapa en funktion som kör ett fjärrprogram

Använd fältet EXEC_HOST i funktionsdefinitionen för att ange platsen för programmet.

Giltiga värden för EXEC_HOST är:

%DatabaseHost% - värddatorn där funktionen har definierats.

%LocalHost% - värddatorn där funktionen startas (sessionsservern).

%DisplayHost% - värddatorn som kör X-hanteraren (ej tillåtet för X-terminaler).

%SessionHost% - värddatorn där den kontrollerande Inloggningshanteraren körs.

värddatornamn - den namngivna värddatorn. Använd det här värdet för miljöer där funktionen alltid ska anropas på en viss värddator.

%"ledtext"% - frågar användaren efter värddatornamnet varje gång funktionen startas.

Standardvärdet är %DatabaseHost%, %LocalHost%. Det innebär att när fältet EXEC_HOST utelämnas försöker dock funktionen först köra kommandot på den värddator som innehåller funktionsdefinitionen. Om detta misslyckas försöker funktionen köra kommandot på sessionsservern.

Exempel

Använda variabler i funktions- och datatypsdefinitioner

Du kan ta med strängvariabler och miljövariabler i filer med funktions- och datatyper.

Använda strängvariabler i en funktion

En strängvariabeldefinition gäller från definitionens adress till slutet av filen. Det finns inga globala strängvariabler för databasen.

Om en strängvariabel har samma namn som en miljövariabel har strängvariabeln företräde.

Definiera en strängvariabel

    Använd syntaxen:

	set variabelnamn=värde

Variabelnamn kan innehålla alla alfanumeriska tecken samt understreck (_). Varje variabeldefinition måste stå på en separat rad.

Exempel:

set Remote_Application_Server=sysapp
set Remote_File_Server=sysdata

Referera till en strängvariabel

    Använd syntaxen:

	$[{]variabelnamn[}]

Exempel:

EXEC-HOST			$Remote_Application_Server
CWD					/net/${Remote_File_Server}/doc/project

Använda miljövariabler i funktioner och datatyper

    Referera till en miljövariabel med syntaxen:

	$[{]variabel[}].

Variabeln ersätts med dess värde när databasen laddas. Om en strängvariabel och en miljövariabel har samma namn används strängvariabeln.

Den här exekveringssträngen skriver exempelvis ut en fil med loginnamnet på försättsbladet. 

EXEC-STRING lp -t$LOGNAME %(File)Arg_1%

Starta funktioner från en kommandorad

På skrivbordet finns kommandot dtaction som används för att köra funktioner från kommandoraden. Du använder dtaction för att köra funktioner från:

Syntax för dtaction 

dtaction [-user användarnamn] [-execHost värddatornamn] \
 funktionsnamn [argument [argument]...]

-user användarnamn - ger dig möjlighet att köra funktionen som en annan användare. Om dtaction anropas av en annan användare än användarnamn, ombeds användaren ange lösenord.

-execHost värddatornamn - för COMMAND-funktionen enbart. Anger värddatorn där kommandot kommer att köras.

argument - argument till funktionen. Vanligen filargument.

Klienten dtaction har ytterligare kommandoradsalternativ. Mer information finns i direkthjälpen (man) för dtaction(1).

Skapa en funktion som kör en annan funktion

Använd dtaction i funktionens EXEC_STRING.

Följande funktion använder t ex det inbyggda funktionsnamnet Spell (funktionen "Kontrollera stavning" i Programhanteraren). Den nya funktionen kör Textredigeraren och funktionen Spell, samt visar stavfel i ett separat terminalemulatorfönster.

ACTION EditAndSpell
 {
 	WINDOW_TYPE				NO_STDIO
 	EXEC_STRING				/bin/sh -c 'dtaction Spell \
 								%Arg_1"File:"%; dtpad %Arg_1%'
 }

Skapa funktioner som kör som andra användare

Använd följande syntax i fältet EXEC_STRING: 

EXEC_STRING   dtaction -user användardnamn funktionsnamn [filargument]

Användaren (användardnamn) måste ha skärmbehörighet för systemet via någon av följande mekanismer:

Skapa språkanpassade funktioner

Sökvägen till datatyper omfattar språkberoende adresser. Skrivbordet använder värdet på LANG för att bestämma sökta adresser för datatypsdefinitioner.

Adresser för språkanpassade funktioner

Språkanpassade funktionsdefinitioner måste placeras i rätt språkberoende mapp i funktionens sökväg.

Standardsökvägen är:

Språkanpassa en befintlig funktion

  1. Skapa en fil i rätt språkberoende mapp (t ex i /etc/dt/appconfig/types/sv).

  2. Anta att du kopierar funktionsdefinitionen från 

    	programrot/dt/appconfig/types/C/fil.dt

    till

    	programrot/dt/appconfig/types/sv/nyfil.dt

  3. Lägg till fältet LABEL eller ändra det befintliga fältet LABEL.

    	LABEL			sträng

    Programhanteraren och Filhanteraren använder namnsträngen för att identifiera funktionens ikon.

  4. Språkanpassa något av följande fält i funktionsdefinitionen:

    • Språkanpassade ikoner: ICON

    • Språkanpassad objekthjälp: DESCRIPTION

    • Språkanpassade ledtexter: all text inom citattecken i EXEC_STRING

Skapa funktioner för ToolTalk-program

Obs!

Följande information gäller bara för program som stöder ToolTalk-meddelanden.

Använd funktionstypen TT_MSG för att skapa en funktion som skickar ett ToolTalk-meddelande. 

ACTION funktionsnamn
{
 	TYPE		TT_MSG
 	...
	}

Fälten addressing och disposition

Meddelanden som inte stöds

Följande stöds inte av TT_MSG-typfunktioner:

Nyckelord för TT_MSG -funktioner

Tabell 12-3 visar nyckelord och användning för TT_MSG-funktioner.

Tabell 12-3 TT_MSG Funktionsnyckelord och användning

Nyckelord 

Användning 

TT_CLASS

Definierar värdet på ToolTalk-meddelandefältet class 

TT_SCOPE

Definierar värdet på ToolTalk-meddelandefältet scope 

TT_OPERATION

Definierar värdet på ToolTalk-meddelandefältet operation 

TT_FILE

Definierar värdet på ToolTalk-meddelandefältet file 

TT_ARGn_MODE

Definierar värdet på ToolTalk-attributet mode för det n:te meddelandeargumentet

TT_ARGn_VTYPE

Definierar värdet på ToolTalk-attributet vtype för det n:te meddelandeargumentet

TT_ARGn_VALUE

Definierar värdet på det n:te meddelandeargumentet