# accionescrear manualmenteCreación manual de acciones

Existen dos procedimientos para crear acciones:

- Utilizar la aplicación de escritorio Crear Acción

- Crear manualmente una definición de acción

Para crear una acción manualmente es necesario editar un archivo de la base de datos. Este capítulo describe cómo crear definiciones de acciones manualmente.

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

## Consultas adicionales

- Para obtener una introducción a las acciones, consulte el SAG.IntAc.mkr.1.

- Para obtener información sobre cómo utilizar Crear Acción, consulte el SAG.dtCrA.mkr.1.

- Para obtener información de consulta sobre las definiciones de acciones, consulte la página de manual `dtactionfile(4)`.

## Razones por las que debe crear una acción manualmente

Existen tres tipos básicos de acciones:

- `COMMAND`

- `MAP`

- `TT_MSG`

La herramienta Crear Acción está diseñada para crear determinados tipos de acciones `COMMAND` y `MAP`. Todas las acciones `TT_MSG` deben crearse manualmente.

Para obtener más información, consulte la sección SAG.dtCrA.mkr.3.

###
Acciones COMMAND

Una acción command ejecuta un mandato que inicia una aplicación o utilidad, ejecuta un script de shell o ejecuta un mandato de sistema operativo. La definición de la acción incluye el mandato que se debe ejecutar (`EXEC_STRING`).

La herramienta Crear Acción puede utilizarse para crear los tipos más comunes de acciones de mandatos. Sin embargo, pueden existir situaciones en las que se deba crear manualmente la acción; por ejemplo, deberá crear un acción `COMMAND` manualmente si la acción especifica:

- Argumentos de varios archivos con un indicador diferente para cada argumento.

- Invocación de acción: la capacidad de las acciones de invocar otras acciones.

- Comportamiento dependiente de la cuenta de argumentos: la capacidad de crear una acción que tiene comportamientos muy diferentes para diferentes números de argumentos de archivo.

- Un host de ejecución remota: la capacidad de ejecutar una aplicación en un sistema distinto del que contiene la definición de la acción.

- Un cambio de usuario: la capacidad de ejecutar la acción como si se tratara de un usuario diferente (por ejemplo, solicitar la contraseña root y luego ejecutar como root).

###
Acciones MAP

Una acción map es una acción que ''establece una correspondencia'' con otra acción en lugar de especificar directamente un mandato o un mensaje de ToolTalk.

El establecimiento de correspondencia proporciona la posibilidad de especificar nombres alternativos para las acciones. Por ejemplo, una acción de mandato incorporada llamada EditorIconos inicia el Editor de iconos. La base de datos también incluye una acción Abrir, cuya definición la restringe a los archivos de mapas de bits y de mapas de pixels (mediante el campo `ARG_TYPE`), que establece una correspondencia con la acción EditorIconos. Esto permite que el usuario inicie el Editor de iconos seleccionando un archivo de mapas de bits o de mapas de pixels del Gestor de archivos y luego eligiendo Abrir en el menú Seleccionado.

Crear Acción proporciona un establecimiento de correspondencia limitado para las acciones Abrir e Imprimir. Todas las otras acciones de establecer correspondencia deben crearse manualmente.

###
Acciones TT_MSG (Mensaje de ToolTalk)

Las acciones `TT_MSG` envían un mensaje de ToolTalk. Todas las acciones `TT_MSG` deben crearse manualmente.

## Creación manual de una acción: Pasos generales

Esta sección explica cómo crear un archivo de configuración para una definición de acción.

### Archivos de configuración para las acciones

Los archivos de configuración que contienen definiciones de acciones deben satisfacer estos requisitos:

- Los archivos deben utilizar el convenio de denominación nombre`.dt`

- Los archivos deben estar ubicados en la ruta de búsqueda de bases de datos (acciones y tipos de acciones). La ruta de búsqueda predeterminada es:

  Acciones personales | DirectorioInicio`/.dt/types`
  Acciones accesibles en el sistema | `/etc/dt/appconfig/types/`idioma
  Acciones incorporadas | `/usr/dt/appconfig/types/`idioma. Este directorio no se deberá utilizar.

Para obtener información sobre cómo modificar la ruta de búsqueda de acciones o tipos de datos, consulte la sección SAG.Datab.mkr.6.

### Crear una acción manualmente

1. Abra un archivo existente de la base de datos o cree uno nuevo. Consulte la sección anterior, SAG.CrAct.mkr.5.

2. Cree la definición de acción utilizando la sintaxis:

       ACTION nombre_acción
       {
          TYPE  tipo_acción
          campo_acción
          …
       }

   donde:

   nombre_acción | Nombre utilizado para ejecutar la acción.
   tipo_acción | `COMMAND` (valor predeterminado), `MAP` o `TT_MSG.`
   campo_acción | Uno de los campos necesarios u opcionales para este tipo de acción. Todos los campos constan de una palabra clave y de un valor. En este capítulo se tratan muchos de los campos de acción. Para obtener más información, consulte la página de manual `dtactionfile(4)`.

3. Guarde el archivo.

4. Si desea que el icono de acción tenga una imagen exclusiva, cree los iconos para la acción. La ubicación predeterminada para los iconos es:

   - Iconos personales: DirectorioInicio`/.dt/icons`

   - Iconos accesibles en el sistema: `/etc/dt/appconfig/icons/`idioma. El idioma predeterminado es C.

     Para obtener más información, consulte la sección SAG.FrPC.mkr.12.

5. Pulse dos veces Recargar acciones en el grupo de aplicaciones Herramientas_Escritorio.

6. Cree un archivo de acción para la acción. El archivo de acción crea en el Gestor de archivos o el Gestor de aplicaciones un icono que representa la acción. (Si se escribe la acción para iniciar una aplicación, el icono se denomina
   icono de aplicación .)

   Para crear el archivo de acción, cree un archivo ejecutable con el mismo nombre que nombre_acción. Puede poner el archivo en cualquier directorio en el que tenga permiso de escritura. Puede crear tantos archivos de acciones como desee.

### Ejemplo de creación de una acción COMMAND

Los siguientes pasos crean una acción personal que inicia una aplicación de fax en el sistema remoto AppServerA. El mandato para iniciar la aplicación de fax es:

    /usr/fax/bin/faxcompose [nombre de archivo]

1. Cree el archivo DirectorioInicio`/.dt/types/Fax.dt`.

2. Ponga la siguiente definición de acción en el archivo:

       ACTION FaxComposer
       {
          TYPE         COMMAND
          ICON         fax
          WINDOW_TYPE  NO_STDIO
          EXEC_STRING  /usr/fax/bin/faxcompose -c %Arg_1% EXEC_HOST AppServerA
          DESCRIPTION  Ejecuta el compositor fax
       }

   Los campos `WINDOW_TYPE` y `EXEC_STRING` describen el comportamiento de la acción.

   `WINDOW_TYPE` | La palabra clave `NO_STDIO` especifica que la acción no tiene que ejecutarse en una ventana de emulador de terminal. Consulte la sección sag.cract.mkr.25.
   `EXEC_STRING` | La sintaxis `%Arg_1%` acepta un archivo soltado. Si se pulsa dos veces la acción, ésta abre una ventana vacía de componente de fax. Consulte la sección sag.cract.mkr.13.

3. Guarda el archivo.

4. Utilice el Editor de iconos para crear los siguientes archivos de imágenes de iconos en el directorio DirectorioInicio`/.dt/icons`:

   - `fax.m.pm`, 32 por 32 pixels de tamaqo

   - `fax.t.pm`, 16 por 16 pixels de tamaqo

5. Pulse dos veces Recargar acciones en el grupo de aplicaciones Herramientas_Escritorio.

6. Cree un archivo ejecutable llamando`FaxComposer` en un directorio en el que tenga permiso de escritura (por ejemplo, el directorio de inicio)

### Ejemplo de creación de una acción MAP

Suponga que la mayor parte de los archivos que envía por fax se crean con el Editor de textos y son del tipo de datos TEXTFILE (archivos llamados *`.txt`).

Estos pasos añaden un elemento de menú ''Fax'' al menú Seleccionado del tipo de datos.

1. Abra el archivo DirectorioInicio`/.dt/types/Fax.dt` que se ha creado en el ejemplo anterior.

2. Añada esta definición de acción de establecer correspondencia al archivo:

       ACTION Fax
       {
          ARG_TYPE   TEXTFILE
          TYPE       MAP
          MAP_ACTION FaxComposer
       }

3. Guarde el archivo.

4. Copie la definición de atributos de datos para TEXTFILE de /`usr/dt/appconfig/types/`idioma`/dtpad.dt` en un nuevo archivo DirectorioInicio`/.dt/types/textfile.dt`. Añada la acción Fax al campo `ACTIONS`.

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

5. Guarde el archivo.

6. Abra el Gestor de aplicaciones y pulse dos veces Recargar acciones en el grupo de aplicaciones Herramientas_Escritorio.

### Recargar la base de datos de acciones/tipos de datos

Para que las definiciones de acciones nuevas o editadas entren en vigor, el escritorio debe volver a leer la base de datos.

- Abra el grupo de aplicaciones Herramientas_Escritorio y pulse dos veces Recargar acciones.

- O ejecute el mandato:

  `dtaction RecargarAcciones`

RecargarAcciones es el nombre de la acción cuyo icono está etiquetado como ''Recargar Acciones''.

La base de datos de acciones también se vuelve a leer cuando el usuario:

- Inicia la sesión

- Reinicia el Gestor de espacio de trabajo

- Guarda una acción en la ventana Crear acción si se elige Guardar en el menú Archivo

###
Creación de un archivo de acción (icono) para una acción

Un
archivo de acción es un archivo creado para proporcionar una representación visual de la acción en el Gestor de archivos o el Gestor de aplicaciones.

#### Archivos de acción (también llamados iconos de acción o iconos de aplicación) en el Gestor de aplicaciones

Puesto que el icono de un archivo de acción representa una acción, a veces se denomina
icono de acción. Si la acción subyacente inicia una aplicación, el icono del archivo de acción se denomina icono de aplicación.

Si se pulsa dos veces el icono de acción se ejecuta la acción. El icono de acción también puede ser una zona de soltar.

#### Crear un archivo de acción (icono de acción)

- Cree un archivo ejecutable con el mismo nombre que el
  nombre de la acción. El contenido del archivo no tiene importancia.

Por ejemplo, si la definición de acción es:

    ACTION MyFavoriteApp
    {
       EXEC_STRING  Maf -file %Arg_1%
       DESCRIPTION  Ejecutar MiAplFavorita
       ICON         Maplf
    }

el archivo de acción será un archivo ejecutable llamado `MiAplFavorita`. En el Gestor de archivos y el Gestor de aplicaciones, el archivo `MiAplFavorita` utilizará la imagen de icono `Maplf.`tamaño`.`tipo. Si pulsa dos veces el icono de `MiAplFavorita`, se ejecutará la cadena de ejecución de la acción y la Ayuda sobre el tema del icono será el contenido del
campo `DESCRIPTION` (`Ejecutar MiAplFavorita`).

####
Etiquetas de acción

Si la definición de acción incluye el campo `LABEL`, el archivo de acción se etiquetará en el Gestor de archivos y el Gestor de aplicaciones con el contenido de este campo en lugar del nombre de archivo (nombre_acción ). Por ejemplo, si la definición de acción incluye:

    ACTION MyFavoriteApp
    {
       LABEL Aplicación favorita
       …
    }

el icono de acción se etiquetará ''Aplicación favorita''.

### Especificación de la imagen de icono utilizada por una acción

Utilice el campo `ICON` para especificar el icono utilizado en el Gestor de archivos y el Gestor de aplicaciones para los iconos de acción creados para la acción.

Si no especifica ningún icono, el sistema utilizará los archivos de imágenes de iconos de acción predeterminados
`/usr/dt/appconfig/icons/`idioma`/Dtactn.*`.

#### Imagen del icono de acción predeterminado

El icono de acción predeterminado puede cambiarse utilizando el recurso:

    *actionIcon: nombre_archivo_icono

donde nombre_archivo_icono puede ser un nombre base o una ruta absoluta.

El valor del campo `ICON` puede ser:

- Un nombre de archivo base.

  El
  nombre de archivo base es el nombre del archivo que contiene la imagen de icono menos los sufijos del nombre de archivo para el tamaños ( `m` y `t`) y el tipo de imagen (`bm` y `pm`). Por ejemplo, si los archivos se llaman `IconoJuegos.m.pm` e `IconoJuegos.t.pm`, utilice `IconoJuegos`.

  Si utiliza el nombre de archivo base, los archivos de iconos deben ponerse en un directorio de la ruta de búsqueda de iconos:

  - Iconos personales: DirectorioInicio`/.dt/icons`

  - Iconos accesibles en el sistema: `/etc/dt/appconfig/icons/`idioma

- Una ruta absoluta al archivo de iconos, que incluya el nombre de archivo completo.

  Sólo deberá utilizar la ruta absoluta si el archivo de iconos no está ubicado en la ruta de búsqueda de iconos. Por ejemplo, si el archivo de iconos `IconoJuegos.m.pm` está ubicado en el directorio `/doc/projects`, que no está en la ruta de búsqueda de iconos, el valor del campo `ICON` será `/doc/projects/IconoJuegos.m.pm`.

La SAG.CrAct.mkr.11 lista los tamaños de iconos que deberá crear y los correspondientes nombres de archivo.

### Nombres y tamaños de iconos para los iconos de acción

`Tamaño en pixels` | `Nombre de mapa de bits` | `Nombre de mapa de pixels`
48 por 48 | nombre`.l.bm` | nombre`.l.pm`
32 por 32 | nombre`.m.bm` | nombre`.m.pm`
16 por 16 | nombre`.t.bm` | nombre`.t.pm`

### Modificar una definición de acción existente

Se puede modificar cualquiera de las acciones disponibles en el sistema, incluidas las acciones incorporadas.

Tenga cuidado al modificar la base de datos de acciones incorporadas. Las acciones incorporadas están diseñadas para funcionar correctamente con las aplicaciones de escritorio.

1. Localice la definición de la acción que desea modificar.

   Las ubicaciones predeterminadas para las definiciones de acciones son:

   - Acciones incorporadas: `/usr/dt/appconfig/types/`idioma

   - Acciones accesibles en el sistema: `/etc/dt/appconfig/types/`idioma

   - Acciones personales: DirectorioInicio`/.dt/types`

     Puede que el sistema incluya ubicaciones adicionales. Para ver una lista de las ubicaciones que el sistema utiliza para las acciones, ejecute el mandato:

     dtsearchpath -v

     El sistema utiliza los directorios listados en
     `DTDATABASESEARCHPATH`.

2. Si es necesario, copie el texto de la definición de acción en un archivo nuevo o en uno existente de uno de estos directorios:

   - Acciones accesibles en el sistema: `/etc/dt/appconfig/types/`idioma

   - Acciones personales: DirectorioInicio`/.dt/types`

     Debe copiar las acciones incorporadas puesto que no debe editar los archivos del directorio `/usr/dt/appconfig/types/`idioma.

3. Edite la definición de acción. Cuando haya terminado, guarde el archivo.

4. Pulse dos veces Recargar acciones en el grupo de aplicaciones Herramientas_Escritorio.

### Prioridad en las definiciones de acciones

Cuando el usuario invoca una acción, el sistema busca en la base de datos un nombre de acción que coincida. Cuando existe más de una acción con dicho nombre, el sistema utiliza las reglas de prioridad para decidir cuál debe utilizar.

- Si no es aplicable ninguna otra regla de prioridad, la prioridad se basa en la ubicación de la definición. La siguiente lista está ordenada de la prioridad más alta a la prioridad más baja:

  - Acciones personales (DirectorioInicio`/.dt/types`)

  - Acciones locales accesibles en el sistema (`/etc/dt/appconfig/types/`idioma)

  - Acciones remotas accesibles en el sistema (nombre de host:`/etc/dt/appconfig/types/`idioma). Los hosts remotos en los que se realiza la búsqueda son los listados en la ruta de búsqueda de aplicaciones.

  - Acciones incorporadas (`/usr/dt/appconfig/types/`idioma)

- Dentro de un directorio determinado, los archivos `*.dt` se leen por orden alfabético.

- Las acciones restringidas por `
  ARG_CLASS`, `
  ARG_TYPE`, `
  ARG_MODE` o `
  ARG_COUNT` tienen prioridad sobre las acciones no restringidas. (El valor predeterminado para estos cuatro campos es `*`.)

  Cuando sea aplicable más de una restricción, el orden de prioridad de alta a baja es:

  - `ARG_CLASS`

  - `ARG_TYPE`

  - `ARG_MODE`

  - `ARG_COUNT`

    Cuando existe más de un `ARG_COUNT` restringido, el orden de prioridad de alta a baja es:

  - Valor de entero específico n

  - <n

  - >n

  - *

Por ejemplo, examinemos las siguientes partes de las definiciones de acción:

    ACTION EditGraphics
    # EditGraphics-1
    {
       ARG_TYPE XWD
       …
    }

    ACTION EditGraphics
    # EditGraphics-2
    {
       ARG_COUNT 0
       …
    }

    ACTION EditGraphics
    # EditGraphics-3
    {
      ARG_TYPE *
       …
    }

Si se pulsa dos veces el icono de acción EditarGráficos se inicia EditarGráficos-2 porque no se ha proporcionado ningún argumento y `ARG_COUNT` `0` tiene prioridad. Si se proporciona un argumento de archivo de tipo XWD, se utilizará EditarGráficos-1 porque especificaba el `ARG_TYPE` XWD. EditarGráficos-3 se utiliza para todos los otros argumentos de archivo.

## Creación de la cadena de ejecución para una acción COMMAND

Los requisitos mínimos para una acción `
COMMAND` son dos campos: `ACTION` y `EXEC_STRING`.

    ACTION nombre_acción
    {
       EXEC_STRING  cadena_ejecución
    }

La cadena de ejecución es la parte más importante de una definición de acción `COMMAND`. Utiliza una sintaxis similar a la de la línea de mandatos que se ejecutaría en un ventana Terminal pero incluye una sintaxis adicional para manejar argumentos de archivo y de cadena.

###
Características generales de las cadenas de ejecución

Las cadenas de ejecución pueden incluir:

- Argumentos de archivo y no de archivo

- Sintaxis de shell

- Rutas absolutas o nombres de ejecutables

#### Argumentos de acción

Un argumento es la información que un mandato o una aplicación necesita para ejecutarse correctamente. Por ejemplo, examinemos la línea de mandatos que se podría utilizar para abrir un archivo en el Editor de textos:

    dtpad nombre de archivo

En este mandato nombre de archivo es un argumento de archivo del mandato `dtpad`.

Las acciones, al igual que las aplicaciones y los mandatos, pueden tener argumentos. Existen dos tipos de datos que una acción `COMMAND` puede utilizar:

- Archivos

- Datos de cadena

#### Utilización de shells en cadenas de ejecución

La cadena de ejecución se ejecuta directamente, en lugar de hacerlo a través de un shell. Sin embargo, se puede invocar un shell de forma explícita en la cadena de ejecución.

Por ejemplo:

    EXEC_STRING \
       /bin/sh -c \
       'tar -tvf %(File)Arg_1% 2>&1 | \${PAGER:-more};\
       echo \\n*** Seleccione Cerrar en el menú Ventana para cerrar *** '

#### Nombre o ruta absoluta del ejecutable

Si la aplicación está ubicada en un directorio listado en la
variable `PATH`, se puede utilizar el nombre simple del ejecutable. Si la aplicación está en otro lugar, se deberá utilizar la
ruta absoluta al archivo ejecutable.

### Creación de una acción que no utiliza argumentos

Utilice la misma sintaxis para `EXEC_STRING` que la que utilizaría para iniciar la aplicación desde una línea de mandatos.

#### Ejemplos

- Esta cadena de ejecución forma parte de una acción que inicia el cliente de X `xcutsel`.

  `EXEC_STRING xcutsel`

- Esta cadena de ejecución inicia el cliente `xclock` con un reloj digital. La línea de mandatos incluye una opción de línea de mandatos pero no necesita ningún argumento.

  `EXEC_STRING xclock -digital`

### Creación de una acción que acepta un archivo soltado

Utilice esta sintaxis para el argumento de archivo:

    %Arg_n%

o

    %(File)Arg_n%

`(File)` es opcional, puesto que se supone (valor predeterminado) que los argumentos proporcionados en `Arg_`n son archivos. (Consulte la sección SAG.CrAct.mkr.19 para conocer el uso de la sintaxis `%(String)Arg_n%`. )

Esta sintaxis permite al usuario soltar un objeto de archivo de datos en el icono de acción para iniciar la acción con dicho argumento de archivo. Sustituye el argumento n en la línea de mandatos. El archivo puede ser local o remoto.

#### Ejemplos

- Esta cadena de ejecución ejecuta `wc -w` utilizando un archivo soltado como parámetro.

  `EXEC_STRING wc -w %Arg_1%`

- Este ejemplo muestra una parte de una definición de una acción que sólo funciona con argumentos de directorio. Cuando se suelta un directorio sobre el icono de acción, la acción muestra una lista de todos los archivos del directorio que tienen permiso de lectura-escritura.

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

### Creación de una acción que solicita un argumento de archivo

Utilice esta sintaxis para el argumento de archivo:

`%(File)"solicitud"%`

Esta sintaxis crea una acción que muestra una solicitud de nombre de archivo cuando el usuario pulsa dos veces el icono de acción.

Por ejemplo, esta cadena de ejecución muestra un cuadro de diálogo que solicita el argumento de archivo del mandato `wc -w`:

    EXEC_STRING wc -w %(File)"Contar palabras en archivo:"%

### Creación de una acción que acepta un archivo soltado o solicita uno

Utilice esta sintaxis para el argumento de archivo:

`%Arg_n"solicitud"%`

o

`%(File)Arg_n"solicitud"%`

Esta sintaxis produce una acción que:

- Acepta un archivo soltado como argumento de archivo.

- Muestra un cuadro de diálogo que solicita un nombre de archivo cuando el usuario pulsa dos veces el icono de acción.

Por ejemplo, esta cadena de ejecución realiza `lp -oraw` en un archivo soltado. Si la acción se inicia al pulsar dos veces el icono, aparece un cuadro de diálogo que solicita el nombre de archivo.

    EXEC_STRING lp -oraw %Arg_1"Archivo a imprimir:"%

### Creación de una acción que solicita un argumento no de archivo

Utilice esta sintaxis para el parámetro que no es de archivo:

`%"solicitud"%`

o

`%(String)"solicitud” %`

`(Cadena)` es opcional, puesto que el texto entre comillas se interpreta, de forma predeterminada, como si fueran datos de la cadena. Esta sintaxis muestra un cuadro de diálogo que solicita datos que no sean de archivo; no utilice esta sintaxis cuando se solicite un nombre de archivo.

Por ejemplo, esta cadena de ejecución ejecuta el mandato `xwd` y solicita que se añada un valor a cada pixel:

    EXEC_STRING xwd -add % "Añadir valor:"% -out %Arg_1"Nombre de archivo:"%

### Interpretación de un argumento de archivo como si se tratara de una cadena

Utilice esta sintaxis para el argumento:

`%(Cadena)Arg_n%`

Por ejemplo, esta cadena de ejecución imprime un archivo con un mensaje de cabecera que contiene el nombre de archivo, utilizando el mandato `lp -t` cabecera nombre de archivo.

    EXEC_STRING lp -t%(String)Arg_1% %(File)Arg_1"Archivo a imprimir:"%

### Cómo proporcionar posibilidades de shell en una acción

Especifique el shell en la cadena de ejecución:

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

#### Ejemplos

- Esta cadena de ejecución ilustra una acción que utiliza conductos de shell.

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

- Ésta es una cadena de ejecución más compleja que requiere el proceso de shell y acepta un argumento de archivo.

    EXEC_STRING /bin/sh -c 'tbl %Arg_1"Página Man:"% | troff -man'

- Esta cadena de ejecución requiere que el argumento sea un archivo comprimido. La acción descomprime el archivo y lo imprime utilizando `lp -oraw`.

    EXEC_STRING /bin/sh -c 'cat %Arg_1"Archivo a imprimir:"% | \
     uncompress | lp -oraw'

- Esta cadena de ejecución inicia un script de shell.

    EXEC_STRING /usr/local/bin/StartGnuClient

### Creación de acciones COMMAND para múltiples argumentos de archivo

Existen tres procedimientos para que las acciones manejen múltiples argumentos de archivo:

- Se puede ejecutar la acción repetidamente, una vez para cada argumento. Cuando `EXEC_STRING` contiene un único argumento de archivo y se proporcionan múltiples argumentos de archivo al soltar varios archivos sobre el icono de acción, la acción se ejecuta por separado para cada argumento de archivo.

  Por ejemplo, si se proporcionan múltiples argumentos de archivo a la siguiente definición de acción:

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

  La acción MostrarImagenPantalla se ejecuta repetidamente.

- La acción puede utilizar dos o más argumentos de archivo no intercambiables. Por ejemplo:

  `xsetroot -cursor archivo de cursor archivo de máscara`

  necesita dos únicos archivos en un orden determinado.

- La acción puede realizar el mismo mandato de forma secuencial en cada argumento de archivo. Por ejemplo:

  `pr archivo [archivo …]`

  imprimirá uno o muchos archivos en un trabajo de impresión.

#### Creación de una acción para argumentos no intercambiables

Utilice uno de los siguientes convenios de sintaxis:

- Si desea que la acción solicite los nombres de archivo, utilice esta sintaxis para cada argumento de archivo:

  `%(File)"solicitud"%`

  Utilice una cadena solicitud diferente para cada argumento.

  Por ejemplo, esta cadena de ejecución solicita dos archivos.

      EXEC_STRING xsetroot -cursor %(File) Mapa de bits de cursor: % \
            %(File) Mapa de bits de máscara: %

- Para aceptar archivos soltados, utilice esta sintaxis para cada argumento de archivo:

  `%Arg_n%`

  utilizando distintos valores de n para cada argumento. Por ejemplo:

      EXEC_STRING diff %Arg_1% %Arg_2%

#### Creación de una acción con argumentos de archivo intercambiables

Utilice uno de los siguientes convenios de sintaxis:

- Para crear una acción que acepte archivos soltados y emita un mandato con el formato mandato archivo 1 archivo 2 …, utilice esta sintaxis para los argumentos de archivo:

  `%Args%`

- Para crear una acción que acepte varios archivos soltados o muestre una solicitud de un único archivo cuando se pulse dos veces, utilice esta sintaxis para los argumentos de archivo:

  `%Arg_1"solicitud"% %Args%`

  La acción emitirá el mandato con el formato: `mandato archivo1 archivo2 ….`

##### Ejemplos

- Esta cadena de ejecución crea una acción que ejecuta:

`pr archivo1 archivo2`

con múltiples argumentos de archivo.

    EXEC_STRING pr %Args%

- Esta cadena de ejecución crea una acción similar a la del ejemplo anterior, excepto en que la acción muestra una solicitud cuando se pulsa dos veces (sin argumentos de archivo).

    EXEC_STRING pr %Arg_1"Archivo(s) a imprimir:"% %Args%

#### Creación de una acción para múltiples archivos soltados

Para aceptar argumentos de múltiples archivos soltados y ejecutar una línea de mandatos con el formato:

    mandato archivo1 archivo
    2 …

utilice la sintaxis:

    %Args%

##### Ejemplos

- Esta cadena de ejecución ejecuta un script llamado Checkout para múltiples archivos:

    EXEC_STRING  /usr/local/bin/Checkout \
           %Arg_1"¿Comprobar qué archivo?"% %Args%

- Esta cadena de ejecución ejecuta `lp -oraw` con múltiples archivos:

    EXEC_STRING lp -oraw %Arg_1"Archivo a imprimir:"% %Args%

## Soporte de ventanas y emuladores de terminal para acciones COMMAND

Existen varios procedimientos para que las acciones `COMMAND` soporten ventanas en el escritorio.

- Si la aplicación tiene su propia ventana, se puede escribir la acción de forma que no proporcione soporte de ventanas adicional. Esta opción también se utiliza cuando una acción ejecuta un mandato que no requiere entrada directa del usuario y no tiene salida.

- Si la aplicación debe ejecutarse en una ventana de emulador de terminal, se puede escribir la acción de forma que abra una ventana y luego ejecute la aplicación. Existen varias opciones de terminal.

### Especificación del soporte de ventana para la acción

Utilice el campo `WINDOW_TYPE` para especificar el tipo de soporte de ventanas necesario para la acción.

WINDOW_TYPE | Soporte de ventanas proporcionado
`NO_STDIO` | Ninguno. Utilice `NO_STDIO` si la aplicación tiene su propia ventana o el mandato no tiene salida visible.
`PERM_TERMINAL` | Ventana de emulador de terminal permanente. La acción abre una ventana de terminal que permanece abierta hasta que el usuario la cierra explícitamente. El usuario puede entrar datos en la ventana. Utilícelo con mandatos que toman entrada, producen una salida y luego terminan (por ejemplo, `ls` directorio).
`TERMINAL` | Ventana de emulador de terminal temporal. La acción abre una ventana de terminal que se cierra tan pronto como se completa el mandato. Utilícelo con mandatos de pantalla completa (por ejemplo, `vi`).

### Especificación de opciones de línea de mandatos para el emulador de terminal

Utilice el campo `TERM_OPTS` de la definición de acción para especificar opciones de línea de mandatos para el emulador de terminal.

Por ejemplo, la siguiente acción solicita el host de ejecución:

    ACTION OpenTermOnSystemUserChooses
    {
       WINDOW_TYPE  PERM_TERMINAL
       EXEC_HOST   %(String)"Terminal remota activada:"%
       TERM_OPTS   -title %(String)"Título de ventana:"%
       EXEC_STRING  $SHELL
    }

### Especificación de un emulador de terminal predeterminado diferente

El emulador de terminal predeterminado utilizado por las acciones es `dtterm`. Se puede cambiar este emulador de terminal por otro. El emulador de terminal predeterminado se utiliza cuando la acción no especifica explícitamente el emulador de terminal que se debe utilizar.

El emulador de terminal utilizado por las acciones debe tener estas opciones de línea de mandatos:

- `-title` título_ventana

- `-e` mandato

Dos recursos determinan el emulador de terminal predeterminado utilizado por las acciones:

- El recurso `localTerminal` especifica el emulador de terminal utilizado por las aplicaciones locales.

      *localTerminal: terminal

  Por ejemplo:

      *localTerminal: xterm

- El recurso `remoteTerminal` especifica el emulador de terminal utilizado por las aplicaciones remotas.

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

Por ejemplo:

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

##
Restricción de acciones a determinados argumentos

Si se restringe una acción a un determinado tipo de argumento, la acción se perfecciona. Por ejemplo, es útil restringir una acción que invoca un visor de archivos PostScript sólo a los argumentos de archivos PostScript; con la restricción, la acción devolverá un diálogo de error si se especifica un archivo que no es PostScript.

Puede restringir acciones basándose en:

- El tipo de datos del argumento de archivo.

- El número de argumentos de archivo (por ejemplo, ningún argumento contra a uno o más argumentos. Esto proporciona un comportamiento diferente al soltar y pulsar dos veces sobre el icono de acción).

- El modo de lectura/escritura del argumento.

### Restricción de una acción a un tipo de datos especificado

Utilice el campo `ARG_TYPE` para especificar los tipos de datos para los que es válida la acción. Utilice el nombre de atributo de los datos.

Puede entrar una lista de tipos de datos, separando las entradas con comas.

Por ejemplo, en la siguiente definición de acción se supone que se ha creado un tipo de datos Gif.

    ACTION Open_Gif
    {
       TYPE        COMMAND
       LABEL       Mostrar Gif
       WINDOW_TYPE NO_STDIO
       ARG_TYPE    Gif
       ICON        xgif
       DESCRIPTION Muestra archivos gif
       EXEC_STRING xgif
    }

### Restricción de una acción basándose en el número de argumentos

Utilice el campo `ARG_COUNT` para especificar el número de argumentos que puede aceptar la acción. Los valores válidos son:

* | (Valor predeterminado) Cualquier número de argumentos. Otros valores tienen prioridad sobre *.
n | Cualquier entero no negativo, incluido 0.
>n | Más de n argumentos.
<n | Más de n argumentos.

Una de las finalidades del uso de `ARG_COUNT` es proporcionar un comportamiento diferente del icono de acción, en función de si el usuario pulsa dos veces el icono o suelta un archivo sobre él. Consulte la sección siguiente SAG.CrAct.mkr.31.

### Proporcionar un comportamiento diferente al pulsar dos veces y al soltar

Utilice este procedimiento para crear una acción que acepte un archivo soltado pero que no solicite un archivo cuando se pulse dos veces el icono de acción.

1. Cree una definición de acción para las funciones de doble pulsación.

   Utilice el campo `ARG_COUNT` para especificar `0` argumentos. Utilice una sintaxis para `EXEC_STRING` que no acepte un argumento soltado.

2. Cree una segunda definición de acción para las funciones de soltar.

   Utilice el campo `ARG_COUNT` para especificar `>0` argumentos. Utilice una sintaxis para `EXEC_STRING` que acepte un archivo soltado.

Por ejemplo, supongamos que las dos líneas de mandatos siguientes pueden utilizarse para iniciar un editor llamado `vedit`:

- Para iniciar el editor sin ningún argumento de archivo:

  vedit

- Para iniciar el editor con un argumento de archivo que se abre como documento de sólo lectura:

  `vedit -R nombre de archivo`

Las dos acciones siguientes crean funciones de soltar y pulsar dos veces para una acción llamada Vedit. La primera acción tiene prioridad cuando se busca una coincidencia en la base de datos, puesto que `ARG_COUNT 0` es más específica que la `ARG_COUNT *` implícita de la definición de funciones de soltar.

    # Funciones de pulsar dos veces
    ACTION Vedit
    {
       TYPE        COMMAND
       ARG_COUNT   0
       WINDOW_TYPE PERM_TERMINAL
       EXEC_STRING vedit
    }

    # Funciones de soltar
    ACTION Vedit
    {
       TYPE        COMMAND
       WINDOW_TYPE PERM_TERMINAL
       EXEC_STRING vedit -R %Arg_1%
    }

### Restricción de una acción basándose en el modo del argumento

Utilice el campo `ARG_MODE` para especificar el modo de lectura/escritura del argumento. Los valores válidos son:

* | (Valor predeterminado) Cualquier modo
!w | No se puede escribir
w | Se puede escribir

## Creación de acciones que ejecutan aplicaciones en sistemas remotos

Cuando se tratan las acciones y la ejecución remota, se utilizan con frecuencia dos términos:

host de base de datos | Sistema que contiene la definición de acción
host de ejecución | Sistema en que se ejecuta el archivo ejecutable

En la mayoría de situaciones, las acciones y sus aplicaciones están ubicadas en el mismo sistema; dado que el host de ejecución predeterminado para una acción es el host de la base de datos, no se requiere ninguna sintaxis especial.

Sin embargo, cuando el host de ejecución es diferente del host de la base de datos, la definición de acción debe especificar dónde debe ejecutarse la cadena de ejecución.

La capacidad para localizar acciones y aplicaciones en sistema diferentes forma parte de la arquitectura de cliente/servidor del escritorio. Para obtener una descripción más completa de las aplicaciones de red, consulte la sección SAG.ClSrv.mkr.15.

### Creación de una acción que ejecuta una aplicación remota

Utilice el campo `EXEC_HOST` de la definición de acción para especificar la ubicación de la aplicación.

Los valores válidos para `EXEC_HOST` son:

`%DatabaseHost%` | Host donde se define la acción.
`%LocalHost%` | Host donde se invoca la acción (el servidor de sesiones).
`%DisplayHost%` | Host que ejecuta el servidor de X (no permitido para terminales X).
`%SessionHost%` | Host donde se está ejecutando el Gestor de inicio de sesión de control.
nombre de host | Host mencionado. Utilice este valor para entornos en los que la acción debe invocarse siempre en un host determinado.
`%"`solicitud`"%` | Solicita el nombre de host al usuario cada vez que se invoca la acción.

El valor predeterminado es `%DatabaseHost%`, `%LocalHost%`.
De este modo, cuando se omite el campo `EXEC_HOST`, primero la acción intenta ejecutar el mandato en el host que contiene la definición de acción. Si esto falla, la acción intenta ejecutar el mandato en el servidor de sesiones.

#### Ejemplos

- Este campo especifica el host `ddsyd`:

    EXEC_HOST ddsyd

- El campo solicita un nombre de host:

    EXEC_HOST % Host que contiene aplicación: %

- Este campo especifica que la acción intentará ejecutar la aplicación en el host que contiene la definición de acción. Si esto falla, la acción intentará ejecutar la aplicación en el host `ddsyd`.

    EXEC_HOST %DatabaseHost%, ddsyd

## Utilización de variables en las definiciones de acción y de tipo de datos

Se pueden incluir variables de cadena y variables de entorno en los archivos de definición de acciones y de tipos de datos.

### Utilización de variables de cadena en una acción

Una definición de variable de cadena permanece en vigor desde la ubicación de la definición hasta el fin del archivo. No existen variables de cadena globales para la base de datos.

Si una variable de cadena y una variable de entorno tienen el mismo nombre, tiene prioridad la variable de cadena.

#### Definir una variable de cadena

- Utilice la sintaxis:

  `set nombre_variable=valor`

Los nombres de variables pueden contener cualquier carácter alfanumérico y subrayado (`_`). Cada definición de variable debe estar en una línea separada.

Por ejemplo:

    set Remote_Application_Server=sysapp
    set Remote_File_Server=sysdata

#### Hacer referencia a una variable de cadena

- Utilice la sintaxis:

  `$[{]nombre_variable[}]`

Por ejemplo:

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

### Utilización de variables de entorno en las acciones y los tipos de datos

- Haga referencia a una variable de entorno utilizando la sintaxis:

  `$[{]variable[}]`.

La variable se amplía (se sustituye por su valor) cuando se carga la base de datos. Si una variable de cadena y una variable de entorno tienen el mismo nombre, tiene prioridad la variable de cadena.

Por ejemplo, esta cadena de ejecución imprime un archivo con un mensaje de cabecera que contiene el nombre de inicio de sesión.

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

## Invocación de acciones desde una línea de mandatos

El escritorio proporciona el mandato `dtaction` para ejecutar acciones desde una línea de mandatos. `dtaction` se puede utilizar para ejecutar acciones desde:

- Scripts

- Otras acciones

- Una línea de mandatos de emulador de terminal

### Sintaxis de dtaction

`dtaction [-user nombre_usuario] [-execHost nombre de host] nombre_acción [argumento [argument]…]`

`-user` nombre_usuario | Proporciona la posibilidad de ejecutar la acción como si se tratara de un usuario diferente. Si un usuario invoca `dtaction` y dicho usuario no es nombre_usuario, se muestra una solicitud de contraseña.
`-execHost` nombre de host | Sólo para acciones `COMMAND`; especifica el host en el que se ejecutará el mandato.
argumento | Argumentos para la acción; generalmente argumentos de archivo.

El cliente de `dtaction` tiene opciones adicionales de línea de mandatos. Para obtener más información, consulte la página de manual `dtaction(1)`.

### Creación de una acción que ejecuta otra acción

Utilice `dtaction` en el `EXEC_STRING` de la acción.

Por ejemplo, la siguiente acción utiliza una acción incorporada llamada Ortografía (la acción se etiqueta como ''Verificar Ortografía'' en el Gestor de aplicaciones). La nueva acción ejecuta el Editor de textos y la acción Ortografía, mostrando los errores de ortografía en una ventana separada del emulador de terminal.

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

### Creación de una acción que se ejecuta como un usuario diferente

Utilice la siguiente sintaxis en `EXEC_STRING`:

`EXEC_STRING dtaction -user nombre_usuario nombre_acción [argumento_archivo]`

El nuevo usuario (nombre_usuario) debe tener acceso para mostrar en el sistema, mediante uno de los siguientes mecanismos:

- Permiso de lectura en el archivo `.Xauthority` del usuario de inicio de sesión

- O, permiso de `xhost`

Por ejemplo, las dos acciones siguientes proporcionan la posibilidad de convertirse en root y editar un archivo app-defaults.

    ACTION AppDefaults
    {
       WINDOW_TYPE  NO_STDIO
       EXEC_STRING  /usr/dt/bin/dtaction -user root\
                    EditAppDefaults %Arg_1 Archivo: %
    }

    ACTION EditAppDefaults
    {
       WINDOW_TYPE  TERMINAL
       EXEC_STRING  /bin/sh -c 'chmod +w %Arg_1%;\
                    vi %Arg_1%; chmod -w %Arg_1%'
    }

## Creación de acciones de entorno nacional

La ruta de búsqueda de tipos de datos incluye ubicaciones que dependen del idioma. El escritorio utiliza el valor de `LANG` para determinar las ubicaciones en las que se deben buscar las definiciones de tipos de datos.

### Ubicaciones de las acciones de entorno nacional

Las definiciones de acciones de entorno nacional deben ponerse en los directorios dependientes del idioma adecuados de la ruta de búsqueda de acciones.

La ruta de búsqueda predeterminada es:

- Acciones personales: DirectorioInicio`/.dt/types`

- Acciones accesibles en el sistema: `/etc/dt/appconfig/types/`idioma

- Acciones incorporadas: `/usr/dt/appconfig/types/`idioma

### Establecer el entorno nacional para una acción existente

1. Cree un archivo en el directorio adecuado dependiente del idioma (por ejemplo, en `/etc/dt/appconfig/types/japanese`) .

2. Copie la definición de acción en el archivo de configuración dependiente del idioma.

   Por ejemplo, puede copiar una definición de acción de

   `apl_raíz/dt/appconfig/types/C/archivo.dt`

   en

   `apl_raíz/dt/appconfig/types/japanese/nuevoarchivo.dt`

3. Añada un campo `LABEL` o modifique el campo `LABEL` existente.

   `LABEL cadena`

   El Gestor de aplicaciones y el Gestor de archivos utilizan la cadena de etiqueta para identificar el icono de la acción.

4. Establezca el entorno nacional para cualquiera de los siguientes campos en la definición de acción:

   - Para iconos de entorno nacional: `ICON`

   - Para ayuda sobre el tema de entorno de nacional: `DESCRIPTION`

   - Para indicadores de solicitud de entorno nacional: cualquier texto entre comillas en `EXEC_STRING`

## Creación de acciones para aplicaciones de ToolTalk

La información siguiente sólo es aplicable a las aplicaciones que soportan mensajes de ToolTalk.

Utilice el tipo de acción `TT_MSG` para crear una acción que envía un mensaje de ToolTalk.

    ACTION nombre_acción
    {
       TYPE  TT_MSG
       …
    }

### Campos addressing y disposition

- El campo `addressing` de ToolTalk se establece siempre en `TT_PROCEDURE`.

- El campo `disposition` de ToolTalk toma como valor predeterminado la especificación del patrón estático del mensaje.

#### Mensajes no soportados

Las acciones de tipo `TT_MSG` no soportan lo siguiente:

- Mensajes orientados a objetos de ToolTalk

- Argumentos de contexto en mensajes

#### Palabras clave para las acciones TT_MSG

Palabra clave | Uso
`TT_CLASS` | Define el valor del campo `class` del mensaje de ToolTalk
`TT_SCOPE` | Define el valor del campo `scope` del mensaje de ToolTalk
`TT_OPERATION` | Define el valor del campo `operation` del mensaje de ToolTalk.
`TT_FILE` | Define el valor del campo `file` del mensaje de ToolTalk
`TT_ARGn_MODE` | Define el valor del atributo `mode` de ToolTalk para el nésimo argumento de mensaje
`TT_ARGn_VTYPE` | Define el valor del atributo `vtype` de ToolTalk del nésimo argumento de mensaje
`TT_ARGn_VALUE` | Define el valor del nésimo argumento de mensaje