# Aktionenmanuell erstellenAktionen manuell erstellen

Es gibt zwei Möglichkeiten, Aktionen zu erstellen:

- mit der Desktop-Anwendung “Aktion erstellen”

- durch das manuelle Erstellen einer Aktionsdefinition

Um eine Aktion manuell zu erstellen, ist es erforderlich, eine Datenbankdatei zu bearbeiten. In diesem Kapitel wird beschrieben, wie Aktionsdefinitionen manuell erstellt werden.

SAG.CrAct.mkr.2
SAG.CrAct.mkr.4
SAG.CrAct.mkr.13
SAG.CrAct.mkr.24
SAG.CrAct.mkr.29
SAG.CrAct.mkr.32
SAG.CrAct.mkr.34
SAG.CrAct.mkr.37
SAG.CrAct.mkr.39
SAG.CrAct.mkr.40

## Weiterführende Informationen

- Eine Einführung in Aktionen kann SAG.IntAc.mkr.1 entnommen werden.

- Informationen zur Verwendung von 'Aktion erstellen' können SAG.dtCrA.mkr.1 entnommen werden.

- Referenzinformationen zu Aktionsdefinitionen können der Hilfeseite `dtactionfile(4)` entnommen werden.

## Gründe, eine Aktion manuell zu erstellen

Es gibt drei grundlegende Arten von Aktionen:

- `COMMAND`

- `MAP`

- `TT_MSG`

Mit dem Werkzeug 'Aktion erstellen' können bestimmte Arten von Befehls- (`COMMAND`) und Zuordnungsaktionen ( `MAP`) erstellt werden. Alle ToolTalk- Meldungsaktionen (`TT_MSG`) müssen manuell erstellt werden.

Weitere Informationen können dem Abschnitt SAG.dtCrA.mkr.3 entnommen werden.

###
Befehlsaktionen

Eine Befehlsaktion (COMMAND) führt einen Befehl aus, der eine Anwendung oder ein Dienstprogramm startet, führt eine Shell-Prozedur aus oder führt einen Betriebssystembefehl aus. Die Definition der Aktion enthält den auszuführenden Befehl (`EXEC_STRING`).

Das Werkzeug 'Aktion erstellen' kann verwendet werden, um die gebräuchlichsten Befehlsaktionen auszuführen. Aber es gibt Situationen, in denen die Aktion manuell erstellt werden muß. Beispielsweise muß eine Befehlsaktion manuell erstellt werden, wenn folgendes für die Aktion angegeben ist:

- Mehrere Dateiargumente, mit einer anderen Eingabeaufforderung für jedes Argument.

- Aktionsaufruf —die Fähigkeit von Aktionen, andere Aktionen aufzurufen.

- Argumentanzahlabhängiges Verhalten—die Fähigkeit, eine Aktion zu erstellen, die bei einer unterschiedlichen Anzahl von Dateiargumenten unterschiedliches Verhalten zeigt.

- Ein Rechner für die Ausführung auf fernen Systemen—die Fähigkeit, eine Anwendung auf einem anderen System als demjenigen, das die Aktionsdefinition enthält, auszuführen.

- Benutzeränderung—die Fähigkeit, die Aktion als ein anderer Benutzer auszuführen (zum Beispiel, sich als Benutzer `root' anzumelden und die Aktion als `root' auszuführen).

###
Zuordnungsaktionen

Bei einer Zuordnungsaktion (MAP) handelt es sich um eine Aktion, die einer anderen Aktion zugeordnet wird, statt direkt einen Befehl oder eine ToolTalk- Meldung anzugeben.

Die Zuordnung ermöglicht dem Benutzer, alternative Namen für Aktionen anzugeben. Beispielsweise startet eine integrierte Befehlsaktion mit dem Namen IconEditor den Symboleditor. Die Datenbank enthält auch eine Aktion 'Öffnen', die in der Definition auf Bitmap- und Pixmap-Dateien eingeschränkt ist (durch das Feld `ARG_TYPE`), die der Aktion IconEditor zugeordnet ist. Dadurch kann der Benutzer den Symboleditor starten, indem er eine Bitmap- oder Pixmap-Datei im Dateimanager auswählt und dann im Menü 'Ausgewählt' die Option 'Öffnen' wählt.

'Aktion erstellen' stellt eine eingeschränkte Zuordnungsfunktion für die Aktionen 'Öffnen' und 'Drucken' zur Verfügung. Alle anderen Zuordnungsaktionen müssen manuell erstellt werden.

###
ToolTalk-Meldungsaktionen

ToolTalk-Meldungsaktionen (`TT_MSG`) senden eine ToolTalk-Meldung. Sämtliche ToolTalk-Meldungsaktionen müssen manuell erstellt werden.

## Aktionen manuell erstellen: Allgemeine Schritte

In diesem Abschnitt wird erläutert, wie eine Konfigurationsdatei für eine Aktionsdefinition erstellt wird.

### Konfigurationsdateien für Aktionen

Konfigurationsdateien, die Aktionsdefinitionen enthalten, müssen folgenden Anforderungen entsprechen:

- Die Dateien müssen die Namenskonventionname`.dt` einhalten.

- Die Dateien müssen sich im Datenbanksuchpfad (für Aktionen und Datentypen) befinden. Der Standardpfad ist:

  Persönliche Aktionen | Standardverzeichnis`/.dt/types`
  Systemweite Aktionen | `/etc/dt/appconfig/types/`sprache
  Integrierte Aktionen | `/usr/dt/appconfig/types/`sprache. Dieses Verzeichnis sollte nicht verwendet werden.

Informationen zur Änderung des Suchpfads für Aktionen und Datentypen können dem Abschnitt SAG.Datab.mkr.6 entnommen werden.

### Aktionen manuell erstellen

1. Eine bereits vorhandene Datenbankdatei öffnen oder eine neue erstellen. Siehe hierzu den vorangegangenen Abschnitt SAG.CrAct.mkr.5.

2. Die Aktionsdefinition mit folgender Syntax erstellen:

       ACTION aktion_name
       {
          TYPE  aktion_typ
          aktion_feld
          …
       }

   wobei die Parameter folgende Bedeutung haben:

   aktion_name | Name, mit dem die Aktion ausgeführt wird.
   aktion_typ | `COMMAND` (Standard), `MAP` oder `TT_MSG`.
   aktion_feld | Eines der erforderlichen oder wahlfreien Felder für diesen Aktionstyp. Alle Felder bestehen aus einem Schlüsselwort und einem Wert. Viele der Aktionsfelder werden in diesem Kapitel behandelt. Weitere Informationen können der Hilfeseite `dtactionfile(4)` entnommen werden.

3. Die Datei sichern.

4. Soll das Aktionssymbol über ein eindeutiges Abbild verfügen, die Symbole für die Aktion erstellen. Die Standardpositionen für Symbole sind:

   - Persönliche Symbole: Standardverzeichnis`/.dt/icons`

   - Systemweite Symbole: `/etc/dt/appconfig/icons/`sprache. Der Standardwert für sprache ist C.

     Weitere Informationen können dem Abschnitt SAG.FrPC.mkr.12 entnommen werden.

5. 'Aktionen erneut laden' in der Gruppe von Anwendungen 'Desktop-Werkzeuge' doppelklicken.

6. Eine Aktionsdatei für die Aktion erstellen. Die Aktionsdatei erstellt ein Symbol im Dateimanager oder Anwendungsmanager, das die Aktion darstellt. (Dient die Aktion dazu, eine Anwendung zu starten, wird das Symbol als
   Anwendungssymbol bezeichnet).

   Um die Aktionsdatei zu erstellen, muß der Benutzer eine ausführbare Datei mit demselben Namen wie aktion_name erstellen. Der Benutzer kann die Datei in jedes Verzeichnis stellen, für das er Schreibberechtigung hat. Es können beliebig viele Aktionsdateien erstellt werden.

### Beispiel für das Erstellen einer Befehlsaktion

Mit den folgenden Schritten wird eine persönliche Aktion erstellt, die eine Telefax-Anwendung auf einem fernen System AppServerA startet. Der Befehl zum Starten der Telefax-Anwendung lautet:

`/usr/fax/bin/faxcompose [dateiname]`

1. Die Datei Standardverzeichnis`/.dt/types/Fax.dt` erstellen.

2. Die folgende Aktionsdefinition in die Datei einfügen:

       ACTION FaxComposer
       {
          TYPE          COMMAND
          ICON          fax
          WINDOW_TYPE   NO_STDIO
          EXEC_STRING   /usr/fax/bin/faxcompose -c %Arg_1%
          EXEC_HOST     AppServerA
          DESCRIPTION   Führt ein Faxerstellungsprogramm aus
       }

   Die Felder `WINDOW_TYPE` und `EXEC_STRING` beschreiben das Verhalten der Aktion.

   `WINDOW_TYPE` | Das Schlüsselwort `NO_STDIO` gibt an, daß die Aktion nicht in einem Terminal-Emulator-Fenster ausgeführt werden muß. Weitere Informationen hierzu können dem Abschnitt sag.cract.mkr.25 entnommen werden.
   `EXEC_STRING` | Die Syntax `%Arg_1%` akzeptiert eine übergebene Datei. Wird auf dem Aktionssymbol doppeltgeklickt, öffnet die Aktion ein leeres Telefaxerstellungsfenster. Weitere Informationen hierzu können dem Abschnitt sag.cract.mkr.13 entnommen werden.

3. Die Datei sichern.

4. Mit dem Symboleditor folgende Symbolbilddateien im Verzeichnis Standardverzeichnis`/.dt/icons` erstellen:

   - `fax.m.pm`, Größe 32 auf 32 Pixel

   - `fax.t.pm`, Größe 16 auf 16 Pixel

5. 'Aktionen erneut laden' in der Gruppe von Anwendungen 'Desktop-Werkzeuge' doppelklicken.

6. Eine ausführbare Datei mit dem Namen `FaxComposer` in einem Verzeichnis, für das Schreibberechtigung besteht (zum Beispiel im Standardverzeichnis), erstellen.

### Beispiel für das Erstellen einer Zuordnungsaktion

Angenommen, die meisten Dateien, die der Benutzer telefaxt, werden mit Text Editor erstellt und sind vom Datentyp TEXTFILE (Dateien mit der Erweiterung `*.txt`):

Mit folgenden Schritten wird ein Menüelement 'Fax' zum Menü 'Ausgewählt' des Datentyps hinzugefügt.

1. Die Datei Standardverzeichnis`/.dt/types/Fax.dt`, die im vorhergehenden Beispiel erstellt wurde, öffnen.

2. Die folgende Zuordnungsaktionsdefinition der Datei hinzufügen:

       ACTION Fax
       {
          ARG_TYPE     TEXTFILE
          TYPE         MAP
          MAP_ACTION   FaxComposer
       }

3. Die Datei sichern.

4. Die Definition für Datenattribute für TEXTFILE aus `/usr/dt/appconfig/types/`sprache`/dtpad.dt` in eine neue Datei Standardverzeichnis`/.dt/types/textfile.dt` kopieren. Die Aktion Fax zum Feld `ACTIONS` hinzufügen.

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

5. Die Datei sichern.

6. Den Anwendungsmanager öffnen und 'Aktionen erneut laden' in der Gruppe von Anwendungen 'Desktop-Werkzeuge' doppelklicken.

### Datenbank für Aktionen und Datentypen erneut laden

Damit neue oder bearbeitete Aktionsdefinitionen wirksam werden können, muß das Desktop die Datenbank erneut lesen.

- Die Gruppe von Anwendungen 'Desktop-Werkzeuge' öffnen und 'Aktionen erneut laden' doppelklicken.

- Oder: folgenden Befehl ausführen:

  `dtaction ReloadActions`

`
ReloadActions' ist der Name der Aktion, deren Symbol die Bezeichnung 'Aktionen erneut laden' trägt.

Die Aktionsdatenbank wird ebenfalls erneut gelesen, wenn der Benutzer

- sich anmeldet

- die Arbeitsbereichssteuerung erneut

- eine Aktion im Fenster 'Aktion erstellen' durch Auswahl von 'Speichern' im Menü 'Datei' sichert.

###
Aktionsdateien (Symbole) für eine Aktion erstellen

Bei einer
Aktionsdatei handelt es sich um eine sichtbare Darstellung der Aktion im Dateimanager oder Anwendungsmanager.

#### Aktionsdateien (auch Aktionssymbole oder Anwendungssymbole genannt) im Anwendungsmanager

Da das Symbol einer Aktionsdatei eine Aktion darstellt, wird es manchmal als
Aktionssymbol bezeichnet. Wird durch die zugrundeliegende Aktion eine Anwendung gestartet, wird das Aktionsdateisymbol als Anwendungssymbol bezeichnet.

Durch Doppelklicken des Aktionssymbols wird die Aktion ausgeführt. Das Aktionssymbol kann auch als Übergabebereich definiert sein.

#### Aktionsdateien (Aktionssymbol) erstellen

- Eine ausführbare Datei mit demselben Namen wie dem
  Aktionsnamen erstellen. Der Inhalt der Datei ist nicht wichtig.

Sieht die Aktionsdefinition beispielsweise folgendermaßen aus,

    ACTION MyFavoriteApp
    {
       EXEC_STRING   Mfa -file %Arg_1%
       DESCRIPTION   Runs MyFavoriteApp
       ICON          Mfapp
    }

dann handelt es sich bei der Aktionsdatei um eine ausführbare Datei mit dem Namen `MyFavoriteApp`. Im Dateimanager und im Anwendungsmanager verwendet die Datei `MyFavoriteApp` das Symbolbild `Mfapp.`größe`.`typ. Durch Doppelklicken auf dem Symbol für `MyFavoriteApp` wird die Zeile EXEC_STRING der Aktion ausgeführt und der Inhalt des Felds
`DESCRIPTION` (Führt `MyFavoriteApp` aus) wird als Kontexthilfe des Symbols angezeigt.

####
Aktionsbezeichnungen

Enthält die Aktionsdefinition ein Feld `LABEL`, wird die Aktionsdatei im Dateimanager und im Anwendungsmanager mit der in diesem Feld angegebenen Bezeichnung versehen, statt mit dem Dateinamen (aktion_name). Enthält die Aktionsdefinition beispielsweise

    ACTION MyFavoriteApp
    {
       LABEL   Favorite Application
       …
    }

dann erhält das Aktionssymbol die Bezeichnung 'Favorite Application.'

### Das von der Aktion verwendete Symbolbild angeben

Im Feld `ICON` wird das für die Aktionssymbole der Aktion im Dateimanager und im Anwendungsmanager verwendete Symbol angegeben.

Wird kein Symbol angegeben, verwendet das System die standardmäßigen Aktionssymbolabbilddateien
`/usr/dt/appconfig/icons/`sprache`/Dtactn.*`.

#### Standardaktionssymbolbild

Das Standardaktionssymbol kann geändert werden, indem folgende Ressource gesetzt wird:

    *actionIcon: symbol_datei_name

wobei für symbol_datei_name sowohl ein Dateiname ohne Pfad als auch ein absoluter Pfad verwendet werden kann.

Als Wert für das Feld `ICON` können zwei verschiedene Namen eingegeben werden:

- ein Dateiname ohne Pfad

  Bei dem
  Dateinamen ohne Pfad handelt es sich um den Namen der Datei, die das Symbolbild enthält, ohne die Erweiterungen für Größe (`m`und `t`) und Abbildtyp (`bm` und `pm`). Beispielsweise lautet bei Dateien mit den Namen `GameIcon.m.pm` und `GameIcon.t.pm` der Dateiname ohne Pfad `GameIcon`.

  Verwendet der Benutzer den Dateinamen ohne Pfad, müssen die Symboldateien in ein Verzeichnis im Symbolsuchpfad gestellt werden:

  - Persönliche Symbole: Standardverzeichnis`/.dt/icons`

  - Systemweite Symbole: `/etc/dt/appconfig/icons/`sprache

- ein absoluter Pfad zu der Symboldatei, einschließlich des vollständigen Dateinamens.

  Der absolute Pfad sollte nur verwendet werden, wenn die Symboldatei sich nicht im Symbolsuchpfad befindet. Befindet sich die Symboldatei `GameIcon.m.pm` im Verzeichnis `/doc/projects`, das nicht im Symbolsuchpfad steht, wird als Wert für das Feld `ICON` `/doc/projects/GameIcon.m.pm` eingegeben.

SAG.CrAct.mkr.11 enthält zu erstellende Symbolgrößen und die entsprechenden Dateinamen.

### Symbolnamen und -größen für Aktionssymbole

Größe in Pixel | Bitmap-Name | Pixmap-Name
48 x 48 | name`.l.bm` | name`.l.pm`
32 x 32 | name`.m.bm` | name`.m.pm`
16 x 16 | name`.t.bm` | name`.t.pm`

### Eine bereits vorhandene Aktionsdefinition ändern

Alle auf dem System zur Verfügung stehenden Aktionen, einschließlich der integrierten Aktionen, können geändert werden.

Bei der Änderung der Datenbank für integrierte Aktionen sollte vorsichtig vorgegangen werden. Die integrierten Aktionen sind genau auf die Desktop-Anwendungen abgestimmt.

1. Die Position der Definition der zu ändernden Aktion feststellen.

   Die Standardpositionen für Aktionsdefinitionen sind:

   - Integrierte Aktionen: `/usr/dt/appconfig/types/`sprache

   - Systemweite Aktionen: `/etc/dt/appconfig/types/`sprache

   - Persönliche Aktionen: Standardverzeichnis`/.dt/types`

     Für das System sind möglicherweise weitere zusätzliche Positionen definiert. Um eine Liste der Positionen, die das System für Aktionen verwendet, anzuzeigen, folgenden Befehl ausführen:

     `dtsearchpath -v`

     Das System verwendet die unter
     `DTDATABASESEARCHPATH` aufgelisteten Verzeichnisse.

2. Falls erforderlich, den Text der Aktionsdefinition in eine neue oder bereits vorhandene Datei in einem der folgenden Verzeichnisse kopieren:

   - Systemweite Aktionen: `/etc/dt/appconfig/types/`sprache

   - Persönliche Aktionen: Standardverzeichnis`/.dt/types`

     Integrierte Aktionen müssen kopiert werden, da Dateien im Verzeichnis `/usr/dt/appconfig/types/`sprache nicht bearbeitet werden sollten.

3. Die Aktionsdefinition bearbeiten. Anschließend die Datei sichern.

4. 'Aktionen erneut laden' in der Gruppe von Anwendungen 'Desktop- Werkzeuge' doppelklicken.

### Vorrang bei Aktionsdefinitionen

Wenn der Benutzer eine Aktion aufruft, durchsucht das System die Datenbank nach einem übereinstimmenden Aktionsnamen. Ist mehr als eine Aktion mit diesem Namen vorhanden, verwendet das System Vorrangregeln, um zu entscheiden, welche Aktion verwendet wird.

- Werden keine anderen Vorrangregeln angewendet, wird der Vorrang auf der Grundlage der Position der Definition zugeordnet. In der folgenden Liste sind die Aktionen entsprechend ihrem Rang von hoch nach niedrig geordnet:

  - Persönliche Aktionen (Standardverzeichnis`/.dt/types`)

  - Systemweite Aktionen (`/etc/dt/appconfig/types/`sprache)

  - Systemweite Aktionen an einem anderen Rechner (hostname:`/etc/dt/appconfig/types/`sprache). Bei den fernen Rechnern, die durchsucht werden, handelt es sich um diejenigen, die im Anwendungssuchpfad aufgelistet sind.

  - Integrierte Aktionen (`/usr/dt/appconfig/types/`sprache)

- Innerhalb eines vorgegebenen Verzeichnisses werden die `*.dt`-Dateien in alphabetischer Reihenfolge gelesen.

- Aktionen, die durch die Felder `
  ARG_CLASS`, `
  ARG_TYPE`, `
  ARG_MODE` oder `
  ARG_COUNT` eingeschränkt sind, haben Vorrang vor nicht eingeschränkten Aktionen. (Der Standardwert für diese vier Felder ist `*`.)

  Sind mehr als eine Einschränkung vorhanden, lautet die Rangfolge von hoch nach niedrig:

  - `ARG_CLASS`

  - `ARG_TYPE`

  - `ARG_MODE`

  - `ARG_COUNT`

    Ist mehr als ein eingeschränktes Feld `ARG_COUNT` vorhanden, lautet die Rangfolge von hoch nach niedrig:

  - Spezifischer ganzzahliger Wert n

  - <n

  - >n

  - *

Als Beispiel sollen die folgenden Abschnitte aus Aktionsdefinitionen betrachtet werden.

    ACTION EditGraphics
    # EditGraphics-1
    {
       ARG_TYPE   XWD
       …
    }

    ACTION EditGraphics
    # EditGraphics-2
    {
       ARG_COUNT  0
       …
    }

    ACTION EditGraphics
    # EditGraphics-3
    {
       ARG_TYPE   *
       …
    }

Durch Doppelklicken des Aktionssymbols `EditGraphics' wird EditGraphics-2 gestartet, da kein Argument angegeben ist und `ARG_COUNT 0` Vorrang hat. Wird ein Dateiargument vom Typ XWD angegeben, wird EditGraphics-1 verwendet, weil hier XWD `ARG_TYPE` angegeben ist. Für alle anderen Dateiargumente wird EditGraphics-3 verwendet.

## Ausführungszeile für eine Befehlsaktion erstellen

Für eine Befehlsaktion ( `
COMMAND`) sind mindestens zwei Felder notwendig, `ACTION` und `EXEC_STRING`.

    ACTION aktion_name
    {
       EXEC_STRING  ausführung_zeichenfolge
    }

Bei der Ausführungszeile (`EXEC_STRING`) handelt es sich um den wichtigsten Teil einer Befehlsaktionsdefinition ( `COMMAND`). Die verwendete Syntax gleicht der Befehlszeile, die in einem Terminal-Fenster ausgeführt wird, enthält aber zusätzliche Syntax für Datei- und Zeichenfolgenargumente.

###
Allgemeine Merkmale von Ausführungszeilen

Ausführungszeilen können enthalten:

- Dateiargumente und Parameter

- Shell-Syntax

- Absolute Pfade oder Namen ausführbarer Dateien

#### Aktionsargumente

Bei einem Argument handelt es sich um eine Information, die für die korrekte Ausführung eines Befehls oder einer Anwendung erforderlich ist. Als Beispiel soll die Befehlszeile betrachtet werden, über die eine Datei im Text Editor geöffnet werden könnte:

`dtpad dateiname`

In diesem Befehl ist dateiname ein Dateiargument des Befehls `dtpad`.

Aktionen können, wie Anwendungen und Befehle, über Argumente verfügen. Eine Befehlsaktion kann zwei verschiedene Arten von Daten verwenden:

- Dateien

- Zeichenfolgedaten

#### Shells in Ausführungszeilen
verwenden

Die Ausführungszeile wird direkt und nicht über eine Shell ausgeführt. Aber der Benutzer kann auch explizit eine Shell in der Ausführungszeile aufrufen.

Beispiel:

    EXEC_STRING \
             /bin/sh -c \
             'tar -tvf %(File)Arg_1% 2>&1 | \${PAGER:-more};\
             echo "\\n*** Zum Schließen im Fenstermenü Schließen\
             auswählen ***"'

#### Name oder absoluter Pfad der ausführbaren Datei

Befindet sich die Anwendung in einem Verzeichnis, das in der Variablen
PATH aufgelistet ist, kann der einfache, ausführbare Name verwendet werden. Befindet sich die Anwendung in einem anderen Verzeichnis, muß der
absolute Pfad zu der ausführbaren Datei verwendet werden.

### Aktionen ohne Argumente erstellen

Dieselbe Syntax für `EXEC_STRING` verwenden, mit der die Anwendung auch über die Befehlszeile gestartet wird.

#### Beispiele

- Die folgende Ausführungszeile ist Teil einer Aktion, die den X-Client `xcutsel` startet.

  `EXEC_STRING xcutsel`

- Die folgende Ausführungszeile startet den Client `xclock` mit einer Digitaluhr. Die Befehlszeile enthält eine Befehlszeilenoption, aber es werden keine Argumente benötigt.

  `EXEC_STRING xclock -digital`

### Aktionen erstellen, die übergebene Dateien akzeptieren

Folgende Syntax für das Dateiargument verwenden:

    %Arg_n%

oder

    %(File)Arg_n%

`(File)` kann, muß aber nicht angegeben werden, da von Argumenten für `Arg_n` (standardmäßig) angenommen wird, daß es sich um Dateien handelt. (Weitere Informationen zur Verwendung der Syntax `%(String)Arg_n%` können dem Abschnitt SAG.CrAct.mkr.19 entnommen werden.)

Diese Syntax ermöglicht dem Benutzer, ein Datendateiobjekt an das Aktionssymbol zu übergeben und die Aktion mit diesem Dateiargument zu starten. Das nte Argument wird in die Befehlszeile übernommen. Bei der Datei kann es sich um eine lokale Datei oder um eine Datei in einem anderen System handeln.

#### Beispiele

- Die folgende Ausführungszeile führt `wc -w` aus und verwendet eine übergebene Datei als den Parameter.

  `EXEC_STRING wc -w %Arg_1%`

- Das folgende Beispiel zeigt einen Teil einer Definition für eine Aktion, die nur für Verzeichnisargumente definiert ist. Wird ein Verzeichnis an das Aktionssymbol übergeben, zeigt die Aktion eine Liste aller Dateien in dem Verzeichnis an, für die Lese-/Schreibberechtigung vorliegt.

      ACTION Lesbare_Dateien_auflisten
      {
         ARG_TYPE      FOLDER
         EXEC_STRING   /bin/sh -c 'ls -l %Arg_1% | grep rw-'
         …
      }

### Aktionen erstellen, die Dateiargumente anfordern

Folgende Syntax für das Dateiargument verwenden:

    %(File)"prompt"%

Mit dieser Syntax wird eine Aktion erstellt, die eine Aufforderung, einen Dateinamen einzugeben, anzeigt, wenn der Benutzer auf dem Aktionssymbol doppeltklickt.

Die folgende Ausführungszeile zeigt beispielsweise ein Dialogfenster an, in dem der Benutzer aufgefordert wird, das Dateiargument des Befehls `wc -w` einzugeben:

    EXEC_STRING wc -w %(File)"Wörter in Datei zählen:"%

### Aktionen erstellen, die übergebene Dateien akzeptieren oder anfordern

Folgende Syntax für das Dateiargument verwenden:

    %Arg_n"prompt"%

oder

    %(File)Arg_n"prompt"%

Mit dieser Syntax wird eine Aktion erstellt, die

- eine übergebene Datei als Dateiargument akzeptiert.

- ein Dialogfenster anzeigt, in dem der Benutzer aufgefordert wird, einen Dateinamen einzugeben, wenn der Benutzer auf dem Aktionssymbol doppeltklickt.

Beispielsweise führt die folgende Ausführungszeile den Befehl `lp -oraw` an einer übergebenen Datei aus. Wird die Aktion durch Doppelklicken auf dem Symbol gestartet, erscheint ein Dialogfenster mit der Aufforderung, den Dateinamen einzugeben.

    EXEC_STRING lp -oraw %Arg_1"Datei drucken:"%

### Aktion erstellen, die Parameter anfordert

Folgende Syntax für den Parameter verwenden:

    %"prompt"%

oder

    %(String)"prompt"%

Die Angabe`(String)` ist optional, da Text in Anführungszeichen standardmäßig als Zeichenfolge interpretiert wird. Mit dieser Syntax wird ein Dialogfenster angezeigt, das eine Aufforderung enthält, einen Parameter einzugeben. Diese Syntax nicht verwenden, wenn ein Dateiname eingegeben werden muß.

Beispielsweise führt die folgende Ausführungszeile den Befehl `xwd` aus und fordert zur Eingabe eines Werts auf, der jedem Pixel hinzugefügt werden soll:

    EXEC_STRING xwd -add %"Wert hinzufügen:"% -out %Arg_1"Dateiname:"%

### Dateiargumente als Zeichenfolge interpretieren

Folgende Syntax für das Dateiargument verwenden:

    %(String)Arg_n%

Beispielsweise druckt folgende Ausführungszeile mit dem Befehl `lp -t` banner dateiname eine Datei mit einem Deckblatt, das den Dateinamen enthält.

    EXEC_STRING lp -t%(String)Arg_1% %(File)Arg_1"Datei drucken:"%

### Shell-Funktionen in einer Aktion zur Verfügung stellen

Die Shell in der Ausführungszeile angeben:

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

#### Beispiele

- Die folgende Ausführungszeile zeigt eine Aktion, die mit Shell-Piping arbeitet:

    EXEC_STRING /bin/sh -c 'ps | lp'

- Die folgende Ausführungszeile ist komplexer. Ein Shell-Prozeß ist erforderlich und ein Dateiargument wird akzeptiert:

    EXEC_STRING /bin/sh -c 'tbl %Arg_1"Hilfeseite:"% | troff -man'

- Für die folgende Ausführungszeile ist es erforderlich, daß es sich bei dem Argument um eine komprimierte Datei handelt. Die Aktion dekomprimiert die Datei und druckt sie mit dem Befehl `lp -oraw`:

    EXEC_STRING  /bin/sh -c 'cat %Arg_1 "Datei drucken:"% | \
                 uncompress | lp -oraw'

- Die folgende Ausführungszeile startet eine Shell-Prozedur:

    EXEC_STRING /usr/local/bin/StartGnuClient

### Befehlsaktionen mit mehreren Dateiargumenten erstellen

Aktionen verarbeiten mehrere Dateiargumente auf drei verschiedene Weisen:

- Die Aktion kann wiederholt ausgeführt werden, jeweils einmal für jedes Argument. Enthält eine Zeile `EXEC_STRING` ein einziges Dateiargument, und es werden mehrere Dateiargumente zur Verfügung gestellt, indem mehrere Dateien an das Aktionssymbol übergeben werden, wird die Aktion für jedes einzelne Dateiargument ausgeführt.

  Werden beispielsweise mehrere Dateiargumente an folgende Aktionsdefinition übergeben:

      ACTION DisplayScreenImage
      {
         EXEC_STRING   xwud -in %Arg_1%
         …
      }

  wird die Aktion DisplayScreenImage wiederholt ausgeführt.

- Die Aktion kann zwei oder mehrere nicht austauschbare Dateiargumente verwenden. Beispielsweise erfordert

  `xsetroot -cursor zeigerdatei maskendatei`

  zwei eindeutige Dateien in einer bestimmten Reihenfolge.

- Die Aktion kann denselben Befehl sequentiell an jedem Dateiargument ausführen. Beispielsweise druckt

  `pr datei [datei …]`

  eine oder mehrere Dateien in einem Druckjob.

#### Eine Aktion mit nicht austauschbaren Dateiargumenten erstellen

Eine der folgenden Syntaxkonventionen verwenden:

- Soll die Aktion zur Eingabe der Dateinamen auffordern, folgende Syntax für jedes Dateiargument verwenden:

  `%(File)'prompt'%`

  Für jedes Argument eine andere Zeichenfolge prompt verwenden.

  Beispielsweise fordert die folgende Ausführungszeile zur Eingabe von zwei Dateinamen auf:

      EXEC_STRING  xsetroot -cursor %(File)"Zeiger Bitmap:"% \
                   %(File)"Maske Bitmap:"%

- Damit übergebene Dateien akzeptiert werden, folgende Syntax für jedes Dateiargument verwenden:

  ``%Arg_n%``

  wobei für jedes Argument verschiedene Werte n verwendet werden. Zum Beispiel:

  `EXEC_STRING diff %Arg_1% %Arg_2%`

#### Aktionen mit austauschbaren Dateiargumenten erstellen

Eine der folgenden Syntaxkonventionen verwenden:

- Um eine Aktion zu erstellen, die übergebene Dateien akzeptiert und einen Befehl in der Form Befehl datei 1 datei 2 … absetzt, folgende Syntax für die Dateiargumente verwenden:

  `%Args%`

- Um eine Aktion zu erstellen, die mehrere übergebene Dateien akzeptiert oder bei Doppelklicken eine Eingabeaufforderung anzeigt, in der zur Eingabe eines einzelnen Dateinamens aufgefordert wird, folgende Syntax für die Dateiargumente verwenden:

  `%Arg_1'prompt'% %Args%`

  Die Aktion setzt den Befehl in der Form `Befehl datei1 datei 2` …. ab.

##### Beispiele

- Die folgende Ausführungszeile erstellt eine Aktion, die folgenden Befehl

`pr datei1 datei2`

mit mehreren Dateiargumenten ausführt:

    EXEC_STRING pr %Args%

- Die folgende Ausführungszeile erstellt eine Aktion, ähnlich dem vorhergehenden Beispiel, bei der jedoch eine Eingabeaufforderung angezeigt wird, wenn das Aktionssymbol angeklickt wird. (Keine Dateiargumente):

    EXEC_STRING pr %Arg_1"Datei(en) drucken:"% %Args%

#### Aktionen für mehrere übergebene Dateien erstellen

Um mehrere übergebene Dateiargumente zu akzeptieren und eine Befehlszeile in der Form

    Befehl datei1 datei2 …

auszuführen, folgende Syntax verwenden:

    %Args%

##### Beispiele

- Die folgende Ausführungszeile führt eine Prozedur namens Checkout für mehrere Dateien aus:

    EXEC_STRING   /usr/local/bin/Checkout \
                  %Arg_1"Welche Datei entnehmen?"% %Args%

- Die folgende Ausführungszeile führt `lp -oraw` mit mehreren Dateien aus:

    EXEC_STRING lp -oraw %Arg_1"Datei drucken:"% %Args%

## Fensterunterstützung und Terminal-Emulatoren für Befehlsaktionen

Befehlsaktionen unterstützen Fenster auf dem Desktop auf verschiedene Weise:

- Verfügt die Anwendung über ein eigenes Fenster, muß beim Schreiben der Aktion keine zusätzliche Fensterunterstützung zur Verfügung gestellt werden. Diese Option wird ebenfalls verwendet, wenn eine Aktion einen Befehl ausführt, für den keine direkte Eingabe durch den Benutzer erforderlich ist und der keine Ausgabe hat.

- Muß die Anwendung in einem emulierten Terminalfenster ausgeführt werden, muß die Aktion so geschrieben werden, daß zunächst ein Fenster geöffnet wird und dann die Anwendung ausgeführt wird. Verschiedene Terminal-Optionen stehen zur Verfügung.

### Fensterunterstützung für die Aktion angeben

Das Feld `WINDOW_TYPE` verwenden, um die Art von Fensterunterstützung anzugeben, die für die Aktion erforderlich ist.

WINDOW_TYPE | Welche Fensterunterstützung steht zur Verfügung?
`NO_STDIO` | Keine. `NO_STDIO` wird verwendet, wenn die Anwendung über ein eigenes Fenster verfügt, oder wenn der Befehl keine sichtbare Ausgabe produziert.
`PERM_TERMINAL` | Permanentes emuliertes Terminalfenster. Die Aktion öffnet ein Terminal-Fenster, das offen bleibt, bis es vom Benutzer explizit geschlossen wird. Der Benutzer kann in diesem Fenster Daten eingeben. Diesen Fenstertyp für Befehle verwenden, für die eine Eingabe erforderlich ist und die eine Ausgabe produzieren, anschließend das Fenster schließen (zum Beispiel für `ls` verzeichnis).
`TERMINAL` | Temporäres emuliertes Terminalfenster. Die Aktion öffnet ein Terminal-Fenster, das geschlossen wird, sobald der Befehl beendet ist. Diesen Fenstertyp für Befehle mit Gesamtanzeige verwenden (zum Beispiel für `vi`).

### Befehlszeilenoptionen für den Terminal-Emulator angeben

Das Feld `TERM_OPTS` in der Aktionsdefinition verwenden, um Befehlszeilenoptionen für den Terminal-Emulator anzugeben.

Beispielsweise fordert die folgende Aktion zur Angabe des ausführenden Rechners auf:

    ACTION OpenTermOnSystemUserChooses
    {
       WINDOW_TYPE     PERM_TERMINAL
       EXEC_HOST       %(String)"Fernes Terminal an:"%
       TERM_OPTS       -title %(String)"Fenstertitel:"%
       EXEC_STRING     $SHELL
    }

### Andere Standard-Terminal-Emulatoren angeben

Der Standard-Terminal-Emulator für Aktionen ist `dtterm`. Der Benutzer kann auch einen anderen Terminal-Emulator wählen. Der Standard-Terminal- Emulator wird verwendet, wenn für die Aktion kein anderer Terminal- Emulator explizit angegeben ist.

Der Terminal-Emulator für Aktionen muß über folgende Befehlszeilenoptionen verfügen:

- `-title` fenster_titel

- `-e` Befehl

Der Standard-Terminal-Emulator für Aktionen wird durch zwei Ressourcen bestimmt:

- Die Ressource `localTerminal` gibt den Terminal-Emulator an, der von lokalen Anwendungen verwendet wird.

  `*localTerminal: terminal`

  Beispiel:

  *localTerminal: xterm

- Die Ressource `remoteTerminal` gibt den Terminal-Emulator an, der von Anwendungen auf fernen Systemen verwendet wird.

    *remoteTerminal: host:terminal [,host:terminal…]

Beispiel:

    *remoteTerminal: sysibm1:/usr/bin/xterm,syshp2:/usr/bin/yterm

##
Aktionen auf bestimmte Argumente einschränken

Durch Einschränkung einer Aktion auf einen bestimmten Argumenttyp wird eine Feinanpassung einer Aktion erzielt. Beispielsweise ist es sinnvoll, eine Aktion, die eine Anzeigefunktion für PostScript-Dateien aufruft, auf PostScript-Dateiargumente einzuschränken. Ist eine solche Einschränkung gesetzt, zeigt die Aktion eine Fehlermeldung an, wenn eine Datei angegeben wird, die nicht im PostScript-Format ist.

Aktionen können auf der Grundlage folgender Merkmale eingeschränkt werden:

- dem Datentyp des Dateiarguments.

- der Anzahl der Dateiargumente. Zum Beispiel, keine Argumente im Gegensatz zu einem oder mehreren Argumenten. Dadurch wird unterschiedliches Verhalten bei Übergabe und Doppelklicken bei einem Aktionssymbol bewirkt.

- dem Schreib-/Lesemodus des Arguments.

### Aktionen auf einen angegebenen Datentyp einschränken

Das Feld `ARG_TYPE` wird verwendet, um die Datentypen anzugeben, für die die Aktion gültig ist. Den Datenattributnamen verwenden.

Es können mehrere Datentypen angegeben werden. Die Einträge mit Kommas voneinander trennen.

In der folgenden Aktionsdefinition wird angenommen, ein Datentyp Gif wurde erstellt:

    ACTION Open_Gif
    {
       TYPE           COMMAND
       LABEL          "Gif anzeigen"
       WINDOW_TYPE    NO_STDIO
       ARG_TYPE       Gif
       ICON           xgif
       DESCRIPTION    Zeigt Gif-Dateien an
       EXEC_STRING    xgif
    }

### Aktionen auf der Grundlage der Argumentanzahl einschränken

Das Feld `ARG_COUNT` wird verwendet, um die Anzahl der Argumente anzugeben, die die Aktion akzeptieren kann. Gültige Werte sind:

* | (Standard) Eine beliebige Anzahl von Argumenten. Andere Werte haben Vorrang vor *.
n | Jede positive ganze Zahl, einschließlich 0.
>n | Mehr als n Argumente.
<n | Weniger als n Argumente.

`ARG_COUNT` wird unter anderem verwendet, um unterschiedliches Aktionssymbolverhalten zu bewirken, je nachdem ob der Benutzer auf dem Symbol doppelt klickt oder eine Datei übergibt. Weitere Informationen hierzu enthält der nächste Abschnitt SAG.CrAct.mkr.31.

### Unterschiedliches Verhalten bei Doppelklicken und Übergabe zur Verfügung stellen

Die folgende Prozedur wird verwendet, um eine Aktion zu erstellen, die eine übergebene Datei akzeptiert, aber die nicht zur Angabe einer Datei auffordert, wenn auf dem Aktionssymbol doppeltgeklickt wird.

1. Eine Aktionsdefinition für die Funktionalität für Doppelklicken erstellen.

   Im Feld `ARG_COUNT` 0 Argumente angeben. Die Syntax für `EXEC_STRING` verwenden, die kein übergebenes Argument akzeptiert.

2. Eine zweite Aktionsdefinition für die Funktionalität für Übergabe erstellen.

   Im Feld `ARG_COUNT` >0 Argumente angeben. Eine Syntax für `EXEC_STRING` verwenden, die ein übergebenes Argument akzeptiert.

Angenommen, die folgenden zwei Befehlszeilen können verwendet werden, um einen Editor mit dem Namen `vedit` zu starten:

- Um den Editor ohne Dateiargument zu starten:

  `vedit`

- Um den Editor mit einem Dateiargument, das als schreibgeschütztes Dokument geöffnet wird, zu starten:

  `vedit -R dateiname`

Die folgenden zwei Aktionen stellen die Funktionalität für Übergabe und Doppelklicken für eine Aktion mit dem Namen Vedit zur Verfügung. Die erste Aktion hat Vorrang, wenn die Datenbank nach einer Entsprechung durchsucht wird, da `ARG_COUNT 0` genauer spezifiziert ist als das implizierte `ARG_COUNT *` der Definition der Funktionalität für Übergabe.

    # Funktionalität für Doppelklicken
    ACTION Vedit
    {
       TYPE          COMMAND
       ARG_COUNT     0
       WINDOW_TYPE   PERM_TERMINAL
       EXEC_STRING   vedit
    }

    # Funktionalität für Übergabe
    ACTION Vedit
    {
       TYPE          COMMAND
       WINDOW_TYPE   PERM_TERMINAL
       EXEC_STRING   vedit -R %Arg_1%
    }

### Aktionen auf der Grundlage des Argumentmodus einschränken

Das Feld `ARG_MODE` wird verwendet, um den Schreib-/Lesemodus des Arguments anzugeben. Gültige Werte sind:

* | (Standard) Jeder Modus
!w | keine Schreibberechtigung
w | Schreibberechtigung

## Aktionen erstellen, die Anwendungen auf fernen Systemen ausführen

Wenn von Aktionen und Ausführung auf fernen Systemen die Rede ist, werden zwei Begriffe häufig verwendet:

Datenbank-Rechner | Das System, das die Aktionsdefinition enthält
Ausführender Rechner | Das System, auf dem die ausführbare Datei ausgeführt wird

Meistens befinden sich Aktionen und deren Anwendungen auf demselben System. Da der ausführende Rechner für eine Aktion standardmäßig der Datenbank-Rechner ist, ist eine spezielle Syntax nicht erforderlich.

Handelt es sich jedoch bei ausführendem Rechner und Datenbank-Rechner um verschiedene Rechner, muß in der Aktionsdefinition angegeben werden, wo die Ausführungszeile ausgeführt werden soll.

Die Fähigkeit, die Position von Aktionen und Anwendungen in anderen Systemen festzustellen, ist Bestandteil der Client/Server-Architektur des Desktops. Weiterführende Informationen zu Anwendungen im Netzwerk können dem Abschnitt SAG.ClSrv.mkr.15 entnommen werden.

### Aktionen erstellen, die Anwendungen an einem anderen Rechner ausführen

Das Feld `EXEC_HOST` in der Aktionsdefinition wird verwendet, um die Position der Anwendung anzugeben.

Gültige Werte für `EXEC_HOST` sind:

`%DatabaseHost%` | Der Rechner, auf dem die Aktion definiert ist.
`%LocalHost%` | Der Rechner, auf dem die Aktion aufgerufen wird (der Session-Server).
`%DisplayHost%` | Der Rechner, auf dem der X-Server ausgeführt wird (nicht zulässig für Xstations).
`%SessionHost%` | Der Rechner, auf dem der steuernde Anmeldemanager ausgeführt wird.
hostname | Der benannte Rechner. Dieser Wert wird in Umgebungen verwendet, in denen die Aktion immer auf einem bestimmten Rechner aufgerufen werden soll.
%'prompt'% | Fordert den Benutzer bei jedem Aufrufen des Befehls zur Eingabe des Rechnernamens auf.

Der Standardwert ist `%DatabaseHost%`, `%LocalHost%`.
Daher versucht die Aktion, wenn das Feld `EXEC_HOST` übergangen wird, zunächst, den Befehl auf dem Rechner auszuführen, der die Aktionsdefinition enthält. Schlägt dies fehl, versucht die Aktion den Befehl auf dem Session-Server auszuführen.

#### Beispiele

- Im folgenden Beispiel wird als Rechner `ddsyd` angegeben:

    EXEC_HOST ddsyd

- In diesem Beispiel wird der Benutzer aufgefordert, einen Rechnernamen einzugeben:

    EXEC_HOST %"Host enthält Anwendung:"%

- In diesem Beispiel wird angegeben, daß die Aktion zunächst versucht, die Anwendung auf dem Rechner, der die Aktionsdefinition enthält, auszuführen. Schlägt dies fehl, wird die Aktion versuchen, die Anwendung auf dem Rechner `ddsyd` auszuführen.

    EXEC_HOST %DatabaseHost%, ddsyd

## Variablen in Definitionen für Aktionen und Datentypen verwenden

In Definitionsdateien für Aktionen und Datentypen können Zeichenfolgevariablen und Umgebungsvariablen verwendet werden.

### Zeichenfolgevariablen in einer Aktion verwenden

Eine Zeichenfolgevariablendefinition ist wirksam von der Position der Definition bis zum Ende der Datei. Es gibt keine globalen Zeichenfolgevariablen für die Datenbank.

Existieren sowohl eine Zeichenfolgevariable als auch eine Umgebungsvariable mit demselben Namen, hat die Zeichenfolgevariable Vorrang.

#### Eine Zeichenfolgevariable definieren

- Folgende Syntax verwenden:

  `set variable_name=wert`

Variablennamen können jedes alphanumerische Zeichen sowie Unterstriche (_) enthalten. Jede Variablendefinition muß sich auf einer eigenen Zeile befinden.

Beispiel:

    set Remote_Application_Server=sysapp
    set Remote_File_Server=sysdata

#### Auf eine Zeichenfolgevariable verweisen

- Folgende Syntax verwenden:

  `$[{]variable_name[}]`

Beispiel:

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

### Umgebungsvariablen in Aktionen und Datentypen verwenden

- Auf eine Umgebungsvariable mit folgender Syntax verweisen:

  `$[{]variable[}].`

Die Variable wird erweitert (durch ihren Wert ersetzt), wenn die Datenbank geladen wird. Existieren sowohl eine Zeichenfolgevariable als auch eine Umgebungsvariable mit demselben Namen, hat die Zeichenfolgevariable Vorrang.

Beispielsweise druckt folgende Ausführungszeile eine Datei mit einem Deckblatt, das den Namen der Datei enthält:

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

## Aktionen über eine Befehlszeile aufrufen

Das Desktop stellt den Befehl `dtaction` zur Verfügung, mit dem Aktionen über eine Befehlszeile ausgeführt werden können. Mit `dtaction` können Aktionen von folgenden Positionen aus ausgeführt werden:

- Prozeduren

- anderen Aktionen

- der Befehlszeile eines Terminal-Emulators

### Syntax von dtaction

`dtaction [-user benutzer_name] [-execHost hostname] aktion_name [argument [argument]…]`

`-user` benutzer_name | Stellt die Fähigkeit zur Verfügung, die Aktion als ein anderer Benutzer auszuführen. Wird `dtaction` von einem anderen als dem durch benutzer_name angegebenen Benutzer aufgerufen, wird dieser zur Eingabe des Kennworts aufgefordert.
`-execHost` hostname | Nur für Befehlsaktionen. Hier wird der Rechner angegeben, auf dem der Befehl ausgeführt wird.
argument | Argumente für die Aktion, normalerweise Dateiargumente.

Der Client `dtaction` verfügt über weitere Befehlszeilenoptionen. Weitere Informationen hierzu können der Hilfeseite `dtaction(1)` entnommen werden.

### Aktionen erstellen, die andere Aktionen ausführen

In der Zeile `EXEC_STRING` die Aktion `dtaction` verwenden.

Beispielsweise verwendet die folgende Aktion eine integrierte Aktion mit dem Namen Spell (die Aktion trägt im Anwendungsmanager die Bezeichnung ``Check Spelling''). Die neue Aktion führt den Text Editor und die Aktion Spell aus und zeigt Rechtschreibfehler in einem separaten Terminal-Emulator- Fenster an.

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

### Aktionen erstellen, die als andere Benutzer ausgeführt werden

In `EXEC_STRING`folgende Syntax verwenden:

`EXEC_STRING dtaction -user benutzer_name aktion_name [datei_argument]`

Der neue Benutzer (benutzer_name) muß durch einen der folgenden Mechanismen Zugriff auf die Anzeige des Systems erhalten:

- Leseberechtigung für die Datei `.Xauthority` des angemeldeten Benutzers

- Oder, xhost-Berechtigung

Die beiden folgenden Aktionen ermöglichen dem Benutzer, sich als Root anzumelden und eine Datei app-defaults zu bearbeiten.

    ACTION AppDefaults
    {
       WINDOW_TYPE    NO_STDIO
       EXEC_STRING    /usr/dt/bin/dtaction -user root \
                      EditAppDefaults %Arg_1"Datei:"%
    }
    ACTION EditAppDefaults
    {
       WINDOW_TYPE    TERMINAL
       EXEC_STRING    /bin/sh -c 'chmod +w %Arg_1%; \
                      vi %Arg_1%; chmod -w %Arg_1%'
    }

## Sprachenabhängige Aktionen erstellen

Der Suchpfad für Datentypen enthält sprachenabhängige Positionen. Das Desktop verwendet den Wert `LANG`, um festzulegen, welche Positionen nach Datentypdefinitionen durchsucht werden sollen.

### Positionen für sprachenabhängige Aktionen

Sprachenabhängige Aktionsdefinitionen müssen in die korrekten sprachenabhängigen Verzeichnisse im Aktionssuchpfad gestellt werden.

Der Standardsuchpfad ist:

- Persönliche Aktionen: Standardverzeichnis`/.dt/types`

- Systemweite Aktionen: `/etc/dt/appconfig/types/`sprache

- Integrierte Aktionen: `/usr/dt/appconfig/types/`sprache

### Eine bereits vorhandene Aktion sprachenabhängig einrichten

1. Eine Datei in dem entsprechenden sprachenabhängigen Verzeichnis erstellen (zum Beispiel in `/etc/dt/appconfig/types/japanese`).

2. Die Aktionsdefinition in die sprachenabhängige Konfigurationsdatei kopieren.

   Beispielsweise kann der Benutzer eine Aktionsdefinition aus

   `app_root/dt/appconfig/types/C/datei.dt`

   in folgende Datei kopieren:

   `app_root/dt/appconfig/types/japanese/neuedatei.dt`

3. Ein Feld `LABEL` hinzufügen oder ein bereits vorhandenes Feld `LABEL` ändern.

       LABEL zeichenfolge

   Anwendungsmanager und Dateimanager verwenden die für LABEL gesetzte Zeichenfolge, um das Symbol der Aktion zu identifizieren.

4. Die folgenden Felder in der Aktionsdefinition können sprachenabhängig eingerichtet werden.

   - Symbole sprachenabhängig einrichten: `ICON`

   - Kontexthilfe sprachenabhängig einrichten: `DESCRIPTION`

   - Eingabeaufforderungen sprachenabhängig einrichten: jeder Text in Anführungszeichen in der Zeile `EXEC_STRING`

## Aktionen für ToolTalk-Anwendungen erstellen

Folgende Informationen gelten nur für Anwendungen, die das Senden von Nachrichten mit ToolTalk unterstützen.

Mit dem Aktionstyp `TT_MSG` eine Aktion erstellen, die eine ToolTalk-Nachricht sendet.

    ACTION aktion_name
    {
       TYPE   TT_MSG
       …
    }

### Felder 'addressing' und 'disposition'

- Das ToolTalk-Feld `addressing` ist immer auf `TT_PROCEDURE` gesetzt.

- Das ToolTalk-Feld `disposition` wird standardmäßig auf die Spezifikation im statischen Nachrichtenmuster gesetzt.

### Nicht unterstützte Nachrichten

Die folgenden Nachrichten werden nicht von Aktionen vom Typ `TT_MSG` unterstützt:

- Objektbezogene Nachrichten in ToolTalk

- Kontextargumente in Nachrichten

### Schlüsselwörter für ToolTalk-Nachrichtenaktionen

Schlüsselwort | Verwendung
`TT_CLASS` | Definiert den Wert des ToolTalk-Meldungsfelds `class`.
`TT_SCOPE` | Definiert den Wert des ToolTalk-Meldungsfelds `scope`.
`TT_OPERATION` | Definiert den Wert des ToolTalk-Meldungsfelds `operation`.
`TT_FILE` | Definiert den Wert des ToolTalk-Meldungsfelds `file`.
`TT_ARGn_MODE` | Definiert den Wert des ToolTalk-Attributs `mode` für das nte Meldungsargument.
`TT_ARGn_VTYPE` | Definiert den Wert des ToolTalk-Attributs `vtype` des nten Meldungsarguments.
`TT_ARGn_VALUE` | Definiert den Wert des nten Meldungsarguments.