# Registrazione di un'applicazione

In questo capitolo viene descritto come creare un pacchetto di registrazione per un'applicazione e come registrare l'applicazione nel desktop.

sag.regap.mkr.3
sag.regap.mkr.5
sag.regap.mkr.14
sag.regap.mkr.15
sag.regap.mkr.16
sag.regap.mkr.19
sag.regap.mkr.21
SAG.RegAp.div.19a
sag.regap.mkr.22
sag.regap.mkr.23
sag.regap.mkr.28
sag.regap.mkr.30

Quando un'applicazione è regolarmente registrata nel desktop, essa presenta le seguenti caratteristiche:

- Dispone di un proprio gruppo separato al livello più elevato della Gestione di applicazioni

- Dispone di un'azione per l'avvio dell'applicazione, rappresentata da un'icona all'interno del gruppo

- Opzionalmente, dispone di tipi di dati associati specificamente ai suoi file

La registrazione è un'operazione “non-invasiva” per l'applicazione:

- Non richiede la modifica del file eseguibile. Questo significa che è possibile registrare anche applicazioni già esistenti su un sistema.

- Non richiede lo spostamento dei file propri dell'applicazione (come l'eseguibile e `app-defaults`) in posizioni differenti.

- Può essere eseguita facilmente. Il tool usato per registrare le applicazioni, `dtappintegrate`, prevede un'opzione per annullare gli effetti della procedura e ripristinare la situazione originaria.

La creazione di un pacchetto di registrazione può essere utile nei seguenti casi:

- Per gli amministratori di sistema che desiderino registrare un'applicazione esistente nel desktop.

- Per i programmatori di software che desiderino creare un pacchetto di installazione per un'applicazione predisposta per il desktop.

## Introduzione alla registrazione delle applicazioni

Questa sezione descrive:

- Lo scopo della registrazione delle applicazioni

- Le caratteristiche che la registrazione apporta alle applicazioni

Per un esempio dettagliato della procedura di registrazione di un'applicazione, vedere sag.regap.mkr.30.

### Caratteristiche apportate dalla
registrazione di un'applicazione

La registrazione offre agli utenti un'interfaccia grafica per:

- Localizzare l'applicazione.

  Al momento dell'installazione, l'applicazione viene “registrata” nella Gestione di applicazioni e le viene assegnato un gruppo.

#### Gruppi di applicazioni al livello più elevato della Gestione di applicazioni

- Avviare l'applicazione.

  Il gruppo contiene un'icona che consente, con un doppio clic, di avviare l'applicazione.

#### Gruppo contenente un'icona per l'avvio dell'applicazione

- Identificare ed editare i file di dati. I file di dati dell'applicazione appariranno con una propria icona nella Gestione di file.

  Le icone dei file di dati potranno essere usate per:

  - Avviare (Aprire) l'applicazione

  - Stampare i file di dati

#### Menu a scomparsa di un file di dati con le opzioni “Aprire” e “Stampare”

- Eseguire altre operazioni, ad esempio comprimere, visualizzare o inviare i dati via posta elettronica

### Scopo della registrazione di un'applicazione

Un'applicazione registrata nel desktop possiede determinati file di configurazione che vengono usati per creare la sua interfaccia utente:

- File di definizione dell'azione e del tipo di dati

- File contenenti le immagini per le icone (a mappa di pixel o a mappa di bit)

- Una directory e una serie di file che creano il gruppo dell'applicazione

- Opzionalmente, i file di aiuto del desktop e i file di definizione per il Pannello principale

Per poter essere riconosciuti e utilizzati dal desktop, questi file devono trovarsi in particolari directory specificate nei percorsi di ricerca.

Può essere difficile amministrare un'applicazione quando i suoi file di configurazione sono distribuiti in diverse directory. Per questa ragione, il desktop permette di tenere raggruppati tutti i file di configurazione di un'applicazione in una singola directory. Questo insieme di file viene detto
pacchetto di registrazione.

Se l'applicazione è predisposta per il desktop, essa crea automaticamente un pacchetto di registrazione durante il processo di installazione. Se invece i file di configurazione vengono creati dall'amministratore di sistema, il pacchetto di registrazione dovrà essere creato manualmente.

I file di configurazione del pacchetto di registrazione non sono disponibili nel desktop perché non si trovano nelle directory dei percorsi di ricerca. Il processo che colloca questi file nelle posizioni appropriate viene detto
registrazione, o integrazione, dell'applicazione.

Il desktop comprende un tool, di nome `dtappintegrate`, che esegue la registrazione creando rappresentazioni dei file collegate simbolicamente alle directory appropriate dei percorsi di ricerca.

Molte applicazioni predisposte per il desktop eseguono automaticamente `dtappintegrate` durante il processo di installazione. Nei casi in cui occorra integrare un'applicazione già esistente, il processo dovrà essere avviato manualmente dall'amministratore del sistema dopo la creazione del pacchetto di registrazione.

Quando un'applicazione è registrata nel desktop di un sistema, essa è disponibile a tutti gli utenti di quel sistema. Se il sistema è configurato come server di applicazioni
, essa sarà disponibile anche agli altri sistemi della rete.

Il tool `dtappintegrate` comprende un'opzione che permette di annullare il processo di registrazione mediante la disabilitazione dei collegamenti. Questo offre la possibilità di eliminare facilmente l'applicazione dalla Gestione di applicazioni per spostarla su un altro server o per eseguire un aggiornamento.

## Procedura generale per registrare un'applicazione

Per un esempio dettagliato della procedura da seguire per creare un pacchetto di registrazione, vedere sag.regap.mkr.30.

1. Modificare tutte le risorse dell'applicazione che impostano i font e i colori. Diversamente, i font e i colori dinamici non funzioneranno correttamente.

   Vedere sag.regap.mkr.14.

2. Creare una radice per l'applicazione.

   Vedere sag.regap.mkr.15.

3. Creare la struttura delle directory sotto la radice dell'applicazione.

   Vedere sag.regap.mkr.16.

4. Creare le azioni e i tipi di dati per l'applicazione.

   Vedere sag.regap.mkr.19.

5. Inserire i file di aiuto in una directory appropriata.

   Vedere sag.regap.mkr.21.

6. Collocare i file della documentazione online (biblioteche delle informazioni o BiblioInfo) nella directory appropriata.

   Vedere SAG.RegAp.div.19a.

7. Creare le icone per l'applicazione.

   Vedere sag.regap.mkr.22.

8. Creare il gruppo per l'applicazione.

   Vedere sag.regap.mkr.23.

9. Registrare l'applicazione usando `dtappintegrate`.

   Vedere sag.regap.mkr.28.

## Fase 1: Modifica delle risorse per font e colori

Per un esempio della procedura da seguire per modificare le risorse di un'applicazione, vedere il sag.regap.mkr.31 della sezione sag.regap.mkr.30 a sag.regap.mkr.31.

Il desktop comprende una serie di meccanismi che consentono di impostare e modificare i font dell'interfaccia e i colori delle finestre. Perché l'applicazione utilizzi questi meccanismi correttamente, potrà essere necessario modificare il relativo file `app-defaults`.

### Modifica delle risorse dei font

Questa sezione si riferisce alle applicazioni create con Motif 1.2™ (o versioni successive). La Gestione degli stili non può impostare i font dell'interfaccia per le applicazioni scritte con versioni precedenti di Motif.

La Gestione degli stili del desktop imposterà automaticamente i font dell'interfaccia per le applicazioni create con Motif 1.2 (o versioni successive), salvo i casi in cui l'applicazione specifichi l'uso di font particolari.

La Gestione degli stili utilizza due font:

font di sistema | Usato per etichette, menu, pulsanti e altri elementi di sistema
font utente | Usato per i campi di testo e altre aree editabili

Ogni font dispone di sette dimensioni, numerate da 1 a 7 nel riquadro di dialogo Font. I font della Gestione degli stili sono collegati ai font effettivi del sistema attraverso le risorse impostate in `/usr/dt/app-defaults/`lingua`/Dtstyle`.

Se si desidera che l'applicazione utilizzi i font della Gestione degli stili, eliminare eventuali risorse dell'applicazione che specifichino i font per l'interfaccia. Il desktop imposterà automaticamente le risorse dell'applicazione in modo appropriato:

`FontList` | Impostato sul font di sistema
`XmText*FontList` | Impostato sul font utente
`XmTextField*FontList` | Impostato sul font utente

### Modifica delle risorse dei colori

La Gestione degli stili offre la possibilità di cambiare i colori delle applicazioni in modo dinamico. L'applicazione deve essere un client Motif 1.1 o 1.2. I client scritti con altri toolkit non supportano la modifica dinamica dei colori; le modifiche apportate vengono applicate riavviando l'applicazione client.

Il modo più semplice per usare i colori dinamici forniti dal desktop consiste nell'eliminare tutte le risorse dell'applicazione relative ai colori di sfondo e di primo piano.

## Fase 2: Creazione della radice dell'applicazione

Per un esempio della procedura da seguire per creare la directory radice per un'applicazione del desktop, vedere il sag.regap.mkr.32 della sezione sag.regap.mkr.30 a sag.regap.mkr.32.

I file del pacchetto di registrazione vengono raggruppati sotto una directory detta “radice dell'applicazione”, o
radice_app. La directory radice_app usata per i file di configurazione del desktop può essere la stessa utilizzata come radice_app per l'installazione dell'applicazione o una directory diversa.

Ad esempio, si supponga di avere installato un'applicazione sotto la directory `/usr/BTE`. Questa stessa directory potrà essere utilizzata come radice_app anche per i file di configurazione del desktop. Tuttavia, nei casi in cui occorra integrare nel desktop un'applicazione esistente, si consiglia di creare una radice_app diversa. In questo modo si eviterà che i file di configurazione creati dall'amministratore vengano sovrascritti durante un aggiornamento dell'applicazione.

Ad esempio, si potrà creare come radice_app del desktop una directory di nome `/etc/radiceapp_desktop/BTE`.

## Fase 3: Creazione delle directory del pacchetto di registrazione

Per un esempio della procedura da seguire per creare le directory di un pacchetto di registrazione, vedere il sag.regap.mkr.33 della sezione sag.regap.mkr.30 a sag.regap.mkr.33.

Il pacchetto di registrazione è il gruppo di file di configurazione usato dal desktop per creare un'interfaccia grafica per l'applicazione.

### Contenuto del pacchetto di registrazione

I file di configurazione del desktop includono:

- I file di definizione delle azioni e dei tipi di dati

- I file contenenti le immagini per le icone

- Una directory per il gruppo dell'applicazione e il relativo contenuto

- Opzionalmente: i file di dati dell'aiuto e un file di configurazione per il Pannello principale

Il pacchetto di registrazione viene raggruppato a partire da una directory detta “radice dell'applicazione”, o radice_app.

#### Un pacchetto di registrazione nella directory radice di un'applicazione

Le categorie principali dei campi di configurazione che si trovano sotto la directory radice_app sono le seguenti:

Directory | Contenuto
`types` | File di definizione per azioni e tipi di dati
`help` | File di aiuto del desktop
`icons` | File grafici a mappa di pixel o a mappa di bit usati dalle azioni e dai tipi di dati dell'applicazione
`appmanager` | La directory e i relativi elementi che creano il gruppo dell'applicazione
`infolib` | File di documentazione online organizzati come infolib, librerie e libri

Ognuna di queste categorie comprende directory secondarie per i file dipendenti dalla lingua. I file associati alla lingua predefinita si trovano nella directory C.

#### Come creare il pacchetto di registrazione

1. Creare le directory indicate. Se sono presenti file di configurazione dipendenti dalla lingua, creare una directory separata per ogni lingua. Se l'applicazione è in un'unica lingua, collocare i file nella directory C.

   - radice_app`/dt/appconfig/types/`lingua

   - radice_app`/dt/appconfig/help/`lingua

   - radice_app`/dt/appconfig/icons/`lingua

   - radice_app`/dt/appconfig/appmanager/`lingua/gruppo_app, dove gruppo_app è il nome del gruppo dell'applicazione.

     Ad esempio, la sag.regap.mkr.18 mostra la Gestione di applicazioni contenente il gruppo_app “Multimedia”.

##### Gruppo di applicazioni al livello più elevato della Gestione di applicazioni

Il tool `dtappintegrate` opera solo sui file di configurazione del desktop che si trovano nelle directory `types`, `help` ,`icons` e `appmanager`. L'eseguibile dell'applicazione, `app-defaults`, e i file di catalogo dei messaggi vengono amministrati separatamente.

## Fase 4: Creazione delle azioni e dei tipi di dati per l'applicazione

Per un esempio dettagliato della procedura da seguire per creare le azioni e i tipi di dati per l'applicazione, vedere il sag.regap.mkr.34 della sezione sag.regap.mkr.30 a sag.regap.mkr.34.

Le azioni e i tipi di dati costituiscono l'interfaccia utente per l'applicazione.

- Le azioni costituiscono un'interfaccia utente per il comando con cui avviare l'applicazione.

- I tipi di dati attribuiscono un aspetto e un comportamento personalizzati ai file di dati dell'applicazione.

### Azioni e tipi di dati richiesti da un'applicazione

In genere, le applicazioni richiedono le seguenti azioni e tipi di dati:

- Un'azione per l'avvio dell'applicazione.

- Un tipo di dati per i file di dati dell'applicazione. Quando si crea un tipo di dati, occorre creare anche:

  - Un'azione Aprire per i file di dati dell'applicazione

  - Un'azione Stampare per i file di dati dell'applicazione

- Un tipo di dati per il gruppo dell'applicazione (vedere sag.regap.mkr.25).

Per un'introduzione sul modo in cui le azioni e i tipi di dati vengono usati nel desktop, vedere il sag.intac.mkr.1.

### Posizione dei file di configurazione che definiscono le azioni e i tipi di dati

Le azioni e i tipi di dati vengono definiti in file di configurazione. L'unico requisito per la denominazione di questi file è il suffisso finale`.dt`. Per convenzione, i file vengono generalmente denominati come nome_azione`.dt` o nome_applicazione`.dt`.

Collocare i file che definiscono le azioni e i tipi di dati sotto la directory radice dell'applicazione, in radice_app`/dt/appconfig/types/`lingua. La lingua predefinita è `C`.

#### File di definizione per azioni e tipi di dati

### Metodi per creare le azioni e i tipi di dati

Le definizioni per le azioni e i tipi di dati di un'applicazione possono essere creati in uno dei modi seguenti:

- Usando il programma Creare azione.

  Creare azione fornisce un'interfaccia utente molto semplice con campi di testo in cui inserire le informazioni. Tuttavia, questo tool ha alcune limitazioni.

- Creando le definizioni manualmente.

  Questo metodo richiede la conoscenza della sintassi per la creazione delle definizioni, ma offre l'accesso a tutte le funzionalità disponibili.

### Come creare azioni e tipi di dati usando Creare azione

Questa procedura viene usata per creare un'azione e tipi di dati con l'utility Creare azione.

Per maggiori informazioni su Creare azione, usare l'aiuto online o vedere il sag.dtcra.mkr.1.

1. Aprire il gruppo Applicazioni_desktop e fare doppio clic su Creare azione.

2. Usare Creare azione per definire l'azione e i tipi di dati dell'applicazione.

   Il file di configurazione creato da Creare azione verrà scritto in DirectoryIniziale`/.dt/type/`nome_azione`.dt`. Il file dell'azione (l'eseguibile con lo stesso nome dell'azione) viene collocato nella directory iniziale dell'utente.

3. Provare l'azione usando il file creato nella directory iniziale.

4. Copiare il file di definizione dell'azione DirectoryIniziale`/.dt/type/`nome_azione`.dt` nella directory radice_app`/dt/appconfig/types/`lingua.

5. Dopo avere creato la directory per il gruppo dell'applicazione (vedere la sag.regap.mkr.23), copiare il file dell'azione DirectoryIniziale`/`nome_azione nella directory radice_app`/dt/appconfig/appmanager/`lingua/gruppo_app.

### Come creare azioni e tipi di dati manualmente

1. Creare un file di configurazione che contenga le definizioni per le azioni e i tipi di dati dell'applicazione.

I file con le definizioni per le azioni e i tipi di dati devono essere denominati secondo la convenzione nome. `dt`.

È possibile inserire tutte le definizioni per le azioni e i tipi di dati in un unico file oppure distribuirle su più file. Per ogni file, usare un nome che l'amministratore di sistema possa collegare facilmente all'applicazione.

I nomi delle azioni e dei tipi di dati devono essere formati da una sola parola (senza spazi vuoti). Sono ammessi i caratteri di sottolineatura. Per convenzione, la prima lettera del nome di un'azione o di un tipo di dati è maiuscola. Non usare nomi già esistenti. Usare nomi che l'amministratore di sistema o gli altri utenti possano collegare facilmente all'applicazione.

Se si desidera che l'icona dell'applicazione sia associata ad un nome diverso da quello dell'azione, includere nella definizione dell'azione un campo `LABEL`.

Per maggiori informazioni sulla creazione di azioni e tipi di dati, vedere:

- sag.intac.mkr.1

- sag.dtcra.mkr.1

- sag.cract.mkr.1

- sag.crdt.mkr.1

## Fase 5: Inserimento dei file di aiuto nel pacchetto di registrazione

Per un esempio della procedura da seguire per aggiungere un file di aiuto a un pacchetto di registrazione, vedere il sag.regap.mkr.35 della sezione sag.regap.mkr.30 a sag.regap.mkr.35.

Se l'applicazione comprende un volume di aiuto del desktop
(cioè un volume di aiuto creato con l'Help Developer's Kit del desktop), il file fondamentale del volume di aiuto ( `*.sdl`) dovrà essere collocato nella directory radice_app`/dt/appconfig/help/`lingua.

I file grafici usati dai file di aiuto vengono solitamente collocati nella directory secondaria `graphics`. I grafici devono mantenere la stessa posizione rispetto al file principale del volume di aiuto (`*.sdl`) in cui si trovavano quando è stato creato il volume.

Se l'applicazione non comprende un volume di aiuto, l'
Help Developer's Kit permette di crearne uno.

Per un volume di aiuto sono possibili due livelli di integrazione
:

- Integrazione completa.

  Quando l'aiuto del desktop è integrato in modo completo, il volume è accessibile dall'applicazione — ad esempio, attraverso l'aiuto legato al contesto o il menu Aiuto. L'integrazione completa richiede la modifica degli eseguibili dell'applicazione.

- Integrazione parziale.

  Quando l'aiuto del desktop è integrato in modo parziale, esso è disponibile dal livello più elevato della Gestione dell'aiuto, ma non dalle finestre dell'applicazione. È comunque possibile creare un'azione che consenta di accedere al volume di aiuto dal gruppo dell'applicazione. L'azione dell'esempio seguente visualizza il volume di aiuto del file principale
  `MiaApp.sdl`:

      ACTION ApriAiutoApplicazione
      {
        LABEL        AiutoApp
        ARG_COUNT    0
        TYPE         COMMAND
        WINDOW_TYPE  NO_STDIO
        EXEC_STRING  /usr/dt/bin/dthelpview -helpVolume MiaApp
        DESCRIPTION  Visualizza l'aiuto per l'applicazione MiaApp.
      }

## Fase 6: Inserimento delle biblioteche di informazione nel pacchetto di registrazione

Se l'applicazione comprende documentazione online (creata con l'Information System Developer's Kit del desktop), la biblioteca delle informazioni ( `*.dti`) contenente la documentazione dovrà essere collocato nella directory:

    radice_appt/dt/infolib/lingua

I file grafici usati dai file di libri DocBook (`*.sgm`) vengono solitamente collocati nella directory secondaria `graphics`. I grafici devono mantenere la stessa posizione rispetto al file principale della BiblioInfo (`*.dti`) in cui si trovavano quando è stata creata la BiblioInfo.

Se l'applicazione non comprende della documentazione online, l'Information System Developer's Kit permette di crearne una.

Per una BiblioInfo sono possibili due livelli di integrazione:

- Integrazione completa.

  Quando una BiblioInfo è integrata in modo completo, è accessibile dall'applicazione `DtActionInvoke` per visualizzare un argomento specifico sotto la Gestione delle informazioni. L'integrazione completa richiede la modifica degli eseguibili dell'appicazione.

- Integrazione parziale.

  Quando una BiblioInfo è integrata in modo parziale, essa è disponibile dal livello più elevato della Gestione delle informazioni, ma non dalle finestre dell'applicazione. È comunque possibile creare un'azione che consenta di accedere alla BiblioInfo dal gruppo dell'applicazione. L'azione dell'esempio seguente visualizza la BiblioInfo del file principale `MiaApp.dti`:

      AZIONE ApriBiblioInfoApplicazione
      {
        LABEL           BiblioInfoApp
        ARG_TYPE        BiblioInfo
        TYPE            MAP
        MAP_ACTION      DtLoadInfoLib /usr/dt/infolib/C/MiaAppInfolib.dti
        DESCRIPTION     Avvia la Gestione delle informazioni per visualizzare
                        la documentazione online per l'applicazione MiaApp.
      }

## Fase 7: Creazione delle icone per le applicazioni

Per un esempio delle procedure da seguire per creare i file delle icone per l'applicazione, vedere il sag.regap.mkr.36 della sezione sag.regap.mkr.30 a sag.regap.mkr.36.

Il desktop comprende icone predefinite per le azioni, i tipi di dati e i gruppi di applicazioni. Tuttavia, ogni utente potrà creare nuove icone per le proprie applicazioni.

Le icone vengono collocate nella directory radice_app`/dt/appconfig/icons/`lingua.

### Icone richieste per il desktop

All'interno del desktop, l'applicazione utilizza le seguenti icone:

- Icona dell'azione. È l'icona che permette, con un doppio clic, di avviare l'applicazione (azione). Viene specificata nel campo `ICON` dell'azione che avvia l'applicazione.

  Specificare tre dimensioni: piccola, media e grande.

- Icona del tipo di dati. Questa icona viene usata per rappresentare i file di dati dell'applicazione nella Gestione di file. Viene ricavata dal campo `ICON` della definizione del tipo di dati.

  Se l'applicazione supporta più tipi di dati, specificare un'icona diversa per ogni tipo.

  Specificare due dimensioni: piccola e media.

- Icona del gruppo dell'applicazione. È l'icona che rappresenta la directory al livello più elevato della Gestione di applicazioni. Viene specificata nel campo `ICON` della definizione del tipo di dati per il gruppo dell'applicazione. (Vedere sag.regap.mkr.23.)

  Specificare due dimensioni: piccola e media.

Per ogni icona si potranno includere sia una versione a mappa di pixel che una versione a mappa di bit per supportare la visualizzazione a colori (a otto bit e superiore) e monocromatica (meno di otto bit).

### Convenzioni di denominazione per i file delle icone

`Dimensione` | `Dimensioni in pixel` | `Nome del file a mappa di bit` | `Nome del file a mappa di pixel`
piccola | 16 x 16 | nomebase`.t.bm` | nomebase`.t.pm`
media | 32 x 32 | nomebase`.m.bm` | nomebase`.m.pm`
grande | 48 x 48 | nomebase`.l.bm` | nomebase`.l.pm`

Se non viene specificato alcun file a mappa di bit, il desktop rimapperà i colori della versione a mappa di pixel convertendoli in bianco e nero. Si noti tuttavia che questa mappatura potrebbe non produrre l'effetto desiderato.

Per maggiori informazioni sulle icone, vedere sag.cricn.mkr.3.

## Fase 8: Creazione del gruppo di applicazioni

Per un esempio della procedura da seguire per creare un gruppo di applicazioni, vedere il sag.regap.mkr.37 della sezione sag.regap.mkr.30 a sag.regap.mkr.37.

Una volta create le definizioni per le azioni e i tipi di dati dell'applicazione, occorre creare i file di configurazione per gli elementi che l'utente vedrà effettivamente — il gruppo dell'applicazione e il suo contenuto.

Il gruppo dell'applicazione è una directory che compare al livello più elevato della Gestione di applicazioni (vedere la sag.regap.mkr.4).

La creazione di un gruppo per un'applicazione richiede tre operazioni:

- Creare la directory del gruppo nel pacchetto di registrazione.

- Opzionalmente: configurare il gruppo dell'applicazione in modo che utilizzi un'icona propria. Questo richiede la definizione di un tipo di dati per la directory del gruppo.

- Creare il contenuto del gruppo.

### Creazione della directory per il gruppo di applicazioni

Per creare un gruppo per un'applicazione, creare le directory richieste nel pacchetto di registrazione sotto `appmanager`, come mostrato nella sag.regap.mkr.24.

#### La directory `appmanager`

### Nome del gruppo

Nella sag.regap.mkr.24, <gruppo_app> è il nome del gruppo dell'applicazione.

#### Nome del gruppo dell'applicazione (<gruppo_app>)

Il nome può contenere tutti i caratteri ammessi per i nomi dei file (e delle directory). Si consiglia di usare un nome che descriva l'applicazione.

### Configurazione del gruppo di applicazioni per l'uso di un'icona propria

Il desktop comprende un'icona predefinita per i gruppi di applicazioni. Tuttavia, ogni utente potrà creare icone personalizzate per i propri gruppi.

Per associare un gruppo a un'icona personalizzata, occorrerà creare:

- Un tipo di dati per la directory che compare al livello più elevato della Gestione di applicazioni.

- Le azioni Aprire e Stampare per il tipo di dati.

Ad esempio, si supponga di voler creare un gruppo di applicazioni di nome Multimedia. La definizione per il tipo di dati sotto descritta, collocata in un file di nome radice_app`/dt/appconfig/types/`lingua`/`nome`.dt`, assegna un'icona specifica al gruppo dell'applicazione.

    DATA_ATTRIBUTES GruppoappMultimedia
    {
       ACTIONS       OpenInPlace,OpenNewView
       ICON          Multimedia
       DESCRIPTION   Fare doppio clic per aprire il gruppo \
                     di applicazioni Multimedia
    }
    DATA_CRITERIA CriteriGruppoappMultimedia1
    {
       DATA_ATTRIBUTES_NAME GruppoappMultimedia
       MODE                 d
       PATH_PATTERN         */appmanager/*/Multimedia
    }

La sezione degli attributi della definizione specifica l'icona da utilizzare. La sezione dei criteri specifica che il tipo di dati sarà associato a tutte le directory di nome `Multimedia` in posizione secondaria rispetto a una directory di nome `appmanager`.

La sag.regap.mkr.26 mostra il rapporto che esiste tra il nome del gruppo dell'applicazione e la definizione del tipo di dati. Il campo `PATH_PATTERN` della definizione del tipo di dati collega un'icona specifica al gruppo dell'applicazione.

#### Collegamento tra un gruppo e un'icona specifica

Si dovrà inoltre creare un'azione Aprire e un'azione Stampare per il tipo di dati del gruppo
dell'applicazione:

    ACTION Open
    {
       ARG_TYPE    GruppoappMultimedia
       TYPE        MAP
       MAP_ACTION  OpenAppGroup
    }
    ACTION Print
    {
       ARG_TYPE    GruppoappMultimedia
       TYPE        MAP
       MAP_ACTION  PrintAppGroup
    }

Le azioni OpenAppGroup e PrintAppGroup sono azioni standard predefinite in `/usr/dt/appconfig/types/`lingua`/dtappman.dt`.

### Creazione del contenuto del gruppo di applicazioni

Gli elementi più importanti di un gruppo sono le icone per l'avvio delle applicazioni (icone di azione). Se il gruppo contiene più applicazioni, occorrerà predisporre un'icona per ognuna.

Oltre a queste icone di azione, il gruppo potrà contenere:

- Uno o più file README

- Uno o più esempi di file di dati

- Modelli

- Un'icona su cui fare doppio clic per visualizzare le informazioni di aiuto

- Una pagina di spiegazioni

- Un controllo speciale per il Pannello principale

Il gruppo di applicazioni potrà contenere directory secondarie.

#### Creazione del file dell'azione (icona dell'applicazione)

Il gruppo di un'applicazione deve contenere un'icona che avvii l'applicazione. Se il gruppo contiene più applicazioni, sarà necessaria un'icona per ognuna. Queste icone vengono dette icone delle applicazioni, o icone delle azioni,poiché rappresentano un'azione alla base dell'applicazione.

Per creare l'icona di un'azione occorre creare un file eseguibile con lo stesso nome dell'azione che dovrà essere eseguita:

radice_app`/dt/appconfig/appmanager/`gruppo_app/nome_azione

Il file così creato viene detto
file dell'azione, poiché ha lo scopo di creare una rappresentazione visiva dell'azione sottostante.

Ad esempio, se è stata creata un'azione di nome NuovoEditor che avvia l'applicazione NuovoEditor, si dovrà creare un file eseguibile di nome NuovoEditor. Nella Gestione di file e nella Gestione di applicazioni, il file dell'azione userà l'icona specificata nella definizione dell'azione.

La sag.regap.mkr.27 illustra la relazione che esiste tra la definizione dell'azione, il file dell'azione e ciò che compare effettivamente nella finestra della Gestione di applicazioni.

##### L'icona dell'applicazione è un file del gruppo dell'applicazione

#### File README

Il desktop comprende un tipo di dati README utilizzabile per i file README dell'applicazione. Sono ammesse le seguenti denominazioni:

- `README`

- `readme`

- `README.*`

- `Read.*.Me`

- `read.*.me`

- `READ.*.ME`

#### Creazione di un controllo specifico per il Pannello principale

Nella maggior parte dei casi non sarà necessario definire un controllo per il Pannello principale; l'utente potrà aggiungere l'applicazione al Pannello principale semplicemente rilasciando l'icona dell'azione sul controllo “Installazione icona” di un pannello secondario.

Tuttavia, si potrà creare un file di configurazione speciale per il Pannello principale per consentire agli utenti di installare un controllo che si comporti diversamente dall'icona dell'azione — ad esempio, un controllo che effettui un monitoraggio su un file e cambi aspetto in base allo stato di quel file.

I file di configurazione del Pannello principale si trovano nella directory radice_app`/dt/appconfig/types/`lingua, e per convenzione vengono denominati nella forma nome`.fp`.

Se si crea un file di configurazione contenente un controllo, l'utente potrà aggiungere quel controllo a un pannello secondario rilasciando il file `*.fp` sul controllo “Installazione icona” appropriato.

La definizione mostrata nell'esempio seguente può essere collocata in un file di configurazione del Pannello principale nel gruppo dell'applicazione. Rilasciando questo file sul controllo “Installazione icona” di un pannello secondario, verrà creato un controllo per l'avvio di una singola copia dell'applicazione NuovoEditor. Se NuovoEditor fosse già in esecuzione, la finestra verrebbe spostata in primo piano nello spazio di lavoro corrente.

    CONTROL ControlloNuovoEditor
    {
       TYPE         icon
       ICON         NEFPanel
       PUSH_RECALL  True
       CLIENT_NAME  NEd
       PUSH_ACTION  NEditor
       DROP_ACTION  NEditor
       HELP_STRING  Avvia l'applicazione NuovoEditor.
    }

Per maggiori informazioni su come creare i file di configurazione per il Pannello principale, vedere:

- sag.frpc.mkr.1

- La pagina di spiegazioni relativa a `dtfpfile(4)`

## Fase 9: Registrazione dell'applicazione con l'uso di dtappintegrate

Per un esempio della procedura da seguire per registrare un'applicazione, vedere il sag.regap.mkr.38 della sezione sag.regap.mkr.30 a sag.regap.mkr.38.

Una volta creato un pacchetto di registrazione sotto la directory radice dell'applicazione, si potrà procedere con la registrazione vera e propria dell'applicazione.

La registrazione dell'applicazione crea una serie di collegamenti tra il pacchetto di registrazione e le directory incluse nei percorsi di ricerca del desktop (vedere sag.regap.mkr.29).

### Come registrare un'applicazione con dtappintegrate

Se l'applicazione è predisposta per il desktop, `dtappintegrate` viene in genere eseguito automaticamente alla fine del processo di installazione. Se ciò non avviene, o se sono stati creati nuovi file di configurazione per integrare un'applicazione non predisposta per il desktop, occorrerà avviare `dtappintegrate` manualmente.

1. Effettuare il login come superutente.

2. Eseguire il comando:

   `/usr/dt/bin/dtappintegrate -s radice_app`

   dove radice_app è la directory radice dell'applicazione del desktop. Per maggiori informazioni, vedere la pagina di spiegazioni relativa a `dtappintegrate(1)`.

3. Aprire il gruppo di applicazioni Strumenti_desktop e fare doppio clic su “Ricaricare applicazioni”.

4. Verificare che l'applicazione sia registrata correttamente:

5. Visualizzare il livello più elevato della Gestione di applicazioni e verificare che compaia il nuovo gruppo dell'applicazione.

6. Aprire il gruppo dell'applicazione e fare doppio clic sull'icona dell'azione.

#### Sintassi e opzioni di
dtappintegrate

`dtappintegrate -s` radice_app `[-t` destinazione ] `[-l` lingua ] `[-u]`

`-s` radice_app | Parametro necessario. Specifica la directory radice sotto la quale è stata installata l'applicazione.
`-t` destinazione | Parametro opzionale, il cui valore predefinito è `/etc/dt/appconfig`. Specifica la directory a cui puntano i collegamenti dei file di configurazione del desktop. La directory specificata deve essere inclusa nel percorso di ricerca delle applicazioni.
`-l` lingua | Parametro opzionale, il cui valore predefinito sono tutte le lingue. Specifica i file di configurazione da integrare dipendenti dalla lingua.
`-u` | Parametro opzionale. Annulla l'integrazione dell'applicazione, eliminando tutti i collegamenti creati nel processo di integrazione.

### Effetti dell'integrazione delle applicazioni con dtappintegrate

La funzione di `dtappintegrate` è quella di creare collegamenti tra i file installati e le directory in cui il desktop cercherà i file di configurazione.

#### Azioni e tipi di dati

`dtappintegrate` crea una serie di collegamenti simbolici tra i file delle azioni e dei tipi di dati che si trovano nel pacchetto di registrazione e la directory di sistema inclusa nel percorso di ricerca del database delle azioni. I collegamenti vengono creati tra

radice_app`/dt/appconfig/types/`lingua`/*.dt`

e

`/etc/dt/appconfig/types/`lingua`/*.dt`

#### Biblioteche delle informazioni

`dtappintegrate` crea una serie di collegamenti simbolici tra i file della biblioteca delle informazioni (BiblioInfo) che si trovano nel pacchetto di registrazione e la directory di sistema inclusa nel percorso di ricerca del database delle BiblioInfo. I collegamenti vengono creati tra

    radice_appt/dt/infolib/lingua/*.dti

e

    /etc/dt/infolib/lingua/*.dti

#### File di aiuto

`dtappintegrate` crea collegamenti simbolici tra i file di aiuto del pacchetto di registrazione e la directory di sistema inclusa nel percorso di ricerca dell'aiuto. I collegamenti vengono creati tra

radice_app`/dt/appconfig/help/`lingua/file_aiuto.`sdl`

e

`/etc/dt/appconfig/help/`lingua/file_aiuto.`sdl`

#### File delle icone

`dtappintegrate` crea collegamenti simbolici tra i file delle icone che si trovano nel pacchetto di registrazione e la directory di sistema inclusa nel percorso di ricerca delle icone. I collegamenti vengono creati tra

radice_app`/dt/appconfig/icons/`lingua/file_icone

e

`/etc/dt/appconfig/icons/`lingua/file_icone

#### Gruppo dell'applicazione

Per collocare il gruppo dell'applicazione al livello più elevato della Gestione di applicazioni, `dtappintegrate` crea un collegamento tra la directory del gruppo nel pacchetto di registrazione e la directory di sistema inclusa nel percorso di ricerca delle applicazioni. Il collegamento viene creato tra la directory

radice_app`/dt/appconfig/appmanager/`lingua/gruppo_app

e

`/etc/dt/appconfig/appmanager/`lingua/gruppo_app

## Esempio di creazione di un pacchetto di registrazione

L'esempio seguente crea un pacchetto di registrazione per un'applicazione esistente e non predisposta per il desktop di nome NuovoEditor.

### Alcune informazioni su “NuovoEditor”

Nell'esempio si presume quanto segue:

- NuovoEditor è installato nella directory `/usr/NE`.

- La lingua delle sessioni utente è quella predefinita, cioè `C`.

- Il comando da eseguire per avviare NuovoEditor è:

  `NEd [nomefile]`

  dove nomefile è il nome del file di dati da aprire nella nuova finestra. NuovoEditor crea una finestra propria — non viene cioè eseguito in una finestra di emulazione di terminale.

- NuovoEditor crea e utilizza due tipi di file di dati:

  - File di documentazione, identificati dal suffisso `.ned`. NuovoEditor dispone di un comando per la stampa dei file di dati `.ned`. La sintassi del comando è:

    `NEPrint [-d destinazione] [-s] nomefile`

    dove:

    `-d` destinazione | Specifica la stampante di destinazione.
    `-s` | Specifica l'esecuzione della stampa in forma silente, cioè senza la visualizzazione di un riquadro di dialogo.
    nomefile | Specifica il file da stampare.

  - File di modello, identificati dal suffisso `.mod`. I file di modello non possono essere stampati.

- I file app-defaults di NuovoEditor esistenti e non predisposti per il desktop contengono risorse per i font dell'interfaccia e per i colori di primo piano e di sfondo.

- È stato creato un volume di aiuto online per NuovoEditor usando l'Help Developer's Kit. Nella creazione del volume di aiuto sono stati usati i seguenti file:

  `…/NEAiuto.htg`

  `…/graphics/NE1.xwd`

  `…/graphics/NE2.xwd`

  per generare il file …`/NEAiuto.sdl`.

#### Procedura per la registrazione di “NuovoEditor”

La procedura seguente si riferisce alla registrazione di NuovoEditor.

1. Modificare le risorse per i font e i colori.

   Nel file app-defaults di NuovoEditor, cancellare le risorse che definiscono:

   - I font per il testo.

   - I colori di primo piano e di sfondo.

2. Creare la directory radice per l'applicazione.

   Creare la directory:

   `/radiciapp_desktop/NE`

   Se si tratta di integrare un'applicazione esistente, è opportuno creare la radice dell'applicazione in una posizione diversa da quella usata per l'installazione; diversamente, i file di configurazione creati verranno sovrascritti al primo aggiornamento dell'applicazione.

3. Creare le directory per il pacchetto di registrazione.

   Creare queste directory:

   `/radiciapp_desktop/NE/dt/appconfig/types`

   `/C/radiciapp_desktop/NE/dt/appconfig/help/C`

   `/radiciapp_desktop/NE/dt/appconfig/icons/C`

   `/radiciapp_desktop/NE/dt/appconfig/appmanager/C/NuovoEditor`

4. Creare le azioni e i tipi di dati per l'applicazione.

   1. Creare il file di configurazione con le definizioni delle azioni e dei tipi di dati:

      `/radiciapp_desktop/NE/dt/appconfig/types/C/NE.dt`

   2. Creare la definizione dell'azione per l'avvio di NuovoEditor:

          ACTION NEditor
          {
            WINDOW_TYPE   NO_STDIO
            ICON          NEEsegui
            DESCRIPTION   Per avviare NuovoEditor, fare doppio clic\
                                                    sull'icona o rilasciare sull'icona un file \
                                                    di dati di NuovoEditor.
            EXEC_STRING   /usr/NE/NEd %Arg_1%
          }

   3. Creare il tipo di dati per i file `*.ned`:

          DATA_ATTRIBUTES FileDatiNE
          {
             DESCRIPTION   File di dati di NuovoEditor.
                   ICON          DatiNE
             ACTIONS       Aprire,Stampare
          }

          DATA_CRITERIA CriteriFiledatiNE1
          {
                   DATA_ATTRIBUTES_NAME  FiledatiNE
             NAME_PATTERN          *.ned
             MODE                  f
          }

   4. Creare il tipo di dati per i file `*.mod`:

          DATA_ATTRIBUTES
          FileModelloNE
          {
                  DESCRIPTION  File modello per NuovoEditor.
            ICON         ModNE
            ACTIONS      Aprire
          }
          DATA_CRITERIA CriteriFileModelloNE1
          {
            DATA_ATTRIBUTES_NAME  FileModelloNE
            NAME_PATTERN          *.mod
            MODE                  f
          }

   5. Creare l'azione Aprire per i file `*.ned`.

          ACTION Aprire
          {
            ARG_TYPE     FileDatiNE
            TYPE         MAP
            MAP_ACTION   NEditor
          }

   6. Creare l'azione Stampare per i file `*.ned`.

      Qui di seguito sono riportate alcune azioni Stampare semplici per la stampa dei file di dati. Queste azioni richiedono un valore per la variabile d'ambiente `LPDEST` ed ignorano l'opzione di stampa `-s`. (Se la variabile `LPDEST` non viene impostata, l'azione non verrà eseguita.)

          ACTION Stampare
          {
            ARG_TYPE    FileDatiNE
            TYPE        MAP
            MAP_ACTION  StampareDatiNE
          }

          ACTION StampareDatiNE
          {
                  WINDOW_TYPE  NO_STDIO
            EXEC_STRING  NEPrint -d $LPDEST %Arg_1%
          }

      Gli esempi seguenti presentano un'altra versione dell'azione StampareDatiNE e uno script associato a questa azione. Insieme, questi due elementi possono gestire le situazioni in cui la variabile `LPDEST` non è impostata o in cui è richiesta l'esecuzione silente della stampa.

          ACTION StampareDatiNE
          {
            WINDOW_TYPE   NO_STDIO
            EXEC_STRING   /usr/NE/bin/NEPrint %(File)Arg_1%
          }

      Il contenuto dello script `/usr/NE/bin/NEPrint` è il seguente:

          # NEPrint
          #!/bin/sh
          DEST= ""
          SILENT=""
          if [ $LPDEST ]; then
                  DEST=“-d $LPDEST”
          fi <
          NEPrint $DEST $SILENT $1

   7. Creare l'azione Aprire per i file `*.mod`:

          ACTION Aprire
          {
            ARG_TYPE    FileModelloNE
            TYPE        MAP
            MAP_ACTION  NEditor
          }

   8. Creare l'azione Stampare per i file `*.mod`:

          ACTION Stampare
          {
            ARG_TYPES   FileModelloNE
            TYPE        MAP
            MAP_ACTION  NoPrint
          }

      NoPrint è un'azione predefinita che visualizza un riquadro di dialogo indicante che il file specificato dall'utente non può essere stampato.

5. Collocare i file di aiuto nel pacchetto di registrazione.

   1. Collocare i file di aiuto nelle seguenti directory:

      `/radiciapp_desktop/NE/dt/appconfig/help/C/NEAiuto.sdl`

      `/radiciapp_desktop/NE/dt/appconfig/help/C/graphics/NE1.xwd`

      `/radiciapp_desktop/NE/dt/appconfig/help/C/graphics/NE2.xwd`

   2. Creare il file:

      ``/radiciapp_desktop/NE/dt/appconfig/types/C/NEAiuto.dt` .`

      Inserire nel file la seguente definizione per l'azione:

          ACTION AiutoNE
          {
          WINDOW_TYPE             NO_STDIO
          EXEC_STRING             /usr/dt/bin/dthelpview-helpVolume \
                                                                  NEAiuto.sdl
          DESCRIPTION             Apre il volume di aiuto di NuovoEditor.
          }

6. Creare le icone per l'applicazione.

   Creare le icone desiderate usando l'Editor delle icone. Usare i seguenti criteri per le dimensioni:

   Nome | Dimensione
   nomebase`.t.p` | 16 x 16
   nomebase`.m.pm` | 32 x 32
   nomebase`.l.pm` | 64 x 64

   Creare i file sotto elencati nella directory `/radiciapp_desktop/NE/dt/appconfig/icons/C`:

   - Icone per rappresentare l'azione che avvia l'applicazione: `NEEsegui.t.pm`, `NEEsegui.m.pm`, `NEEsegui.l.pm`

   - Icone per rappresentare i file `*.ned`: `DatiNE.t.pm`, `DatiNE.m.pm`,

   - Icone per rappresentare i file `*.mod`: `ModNE.t.pm`, `ModNE.m.pm`

   - Icone per rappresentare il gruppo dell'applicazione (usate nella fase 7): `AppNE.t.pm`, `AppNE.m.pm`

7. Creare il gruppo dell'applicazione.

   1. Creare la directory.

      `/radiciapp_desktop/NE/dt/appconfig/appmanager/C/NuovoEditor`

   2. Questa fase è opzionale. Il suo scopo è quello di creare un'icona specifica per il gruppo dell'applicazione creando un tipo di dati e le azioni associate per il gruppo dell'applicazione. Omettendo questa operazione, il gruppo dell'applicazione userà l'icona predefinita.

      Aggiungere le seguenti definizioni al file `/radiciapp_desktop/NE/dt/appconfig/types/C/NEd.dt`. La definizione del tipo di dati specifica l'icona da utilizzare per il gruppo dell'applicazione NuovoEditor. Le definizioni delle azioni specificano lo stesso comportamento delle azioni Aprire e Stampare dei gruppi di applicazioni predefiniti.

          DATA_ATTRIBUTES GruppoappNuovoEditor
          {
            ACTIONS   OpenInPlace,OpenNewView
            ICON      AppNE
          }
          DATA_CRITERIA CriteriGruppoappNuovoEditor
          {
            DATA_ATTRIBUTES_NAME  GruppoappNuovoEditor
            MODE                  d
            PATH_PATTERN          */appmanager/*/NuovoEditor
          }
          ACTION Aprire
          {
            ARG_TYPE    GruppoappNuovoEditor
            TYPE        MAP
            MAP_ACTION  OpenAppGroup
          }
          ACTION Stampare
          {
            ARG_TYPE    GruppoappNuovoEditor
            TYPE        MAP
            MAP_ACTION  PrintAppGroup
          }

   3. Creare un'icona da inserire nel gruppo per l'avvio dell'applicazione. Creare il file:

          /radiciapp_desktop/NE/dt/appconfig/appmanager/C/NuovoEditor/NEditor

      e renderlo eseguibile.

   4. Creare nel gruppo dell'applicazione il file di azione per l'apertura del volume di aiuto. Creare il file:

          /radiciapp_desktop/NE/dt/appconfig/appmanager/C/NuovoEditor/AiutoNE

      e renderlo eseguibile.

   5. Se necessario, inserire altri tipi di file nel gruppo dell'applicazione; ad esempio, file “readme”, esempi di file di dati e modelli.

8. Registrare l'applicazione.

   Da una finestra di emulazione di terminale:

   1. Effettuare il login come superutente.

   2. Eseguire il comando:

      `/usr/dt/bin/dtappintegrate -s /radiciapp_desktop/NE`

   3. Aprire il gruppo di applicazioni Strumenti_desktop e fare doppio clic su “Ricaricare applicazioni”.