# Enregistrement d'une application

Ce chapitre explique comment créer le module d'enregistrement d'une application et enregistrer l'application sur le Bureau.

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

Une fois entièrement enregistrée dans le Bureau, l'application possède:

- son propre groupe d'applications au niveau supérieur du Gestionnaire d'applications

- une action qui lance l'application. L'action est représentée par une icône dans le groupe d'applications

- éventuellement, des types de données pour ces fichiers de données.

L'enregistrement ne constitue pas une opération “invasive” pour l'application:

- elle n'implique pas la modification de l'exécutable de l'application. De ce fait, vous pouvez enregistrer des applications existantes sur un système

- elle ne requiert pas le déplacement d'un des fichiers de l'application (tels que le fichier exécutable et `app-defaults`) vers un autre endroit

- elle peut être annulée facilement. L'outil `dtappintegrate`, utilisé pour enregistrer les applications, fournit une option de ligne de commande permettant d'inverser le processus.

La création de modules d'enregistrement est nécessaire dans les cas suivants:

- enregistrement d'applications existantes sur le Bureau (administration du système)

- création de modules d'installation pour des applications adaptées au Bureau CDE (développement)

## Généralités sur l'enregistrement des applications

Cette section explique:

- les fonctions offertes à votre application par l'enregistrement ;

- l'objectif de l'enregistrement des applications.

Pour un exemple détaillé d'enregistrement d'une application existante, reportez-vous à la section SAG.RegAp.mkr.30.

### Fonctions offertes par
l'enregistrement des applications

L'enregistrement d'applications offre aux utilisateurs un outil graphique de localisation des applications.

- Localisez les applications.

  Lors de son installation, votre application est enregistrée dans le Gestionnaire d'applications et possède son propre groupe d'applications.

#### Groupes d'applications au niveau supérieur du Gestionnaire d'applications

- Lancez votre application.

  Le groupe de votre application comporte une icône sur laquelle l'utilisateur cliquera deux fois pour lancer l'application.

#### Groupe d'applications contenant une icône permettant de lancer l'application

- Identifiez et manipulez les fichiers de données. Les fichiers de données de l'application possèdent une seule icône dans le Gestionnaire de fichiers.

  L'utilisateur peut se servir des icônes des fichiers de données pour:

  - lancer (ouvrir) l'application,

  - imprimer les fichiers de données.

#### Menu instantané d'un fichier de données contenant les options ''Ouvrir'' et ''Imprimer''

- Vous pouvez ensuite effectuer d'autres opérations (envoi, compression, visualisation ou reproduction sonore de données).

### Objectif de l'enregistrement d'applications

Une application enregistrée possède certains fichiers de configuration utilisés par le Bureau pour fournir à l'interface utilisateur de l'application:

- des fichiers de définitions des actions et des types de données

- des fichiers d'images d'icônes (pixmaps ou bitmaps)

- un répertoire et des fichiers qui créent le groupe d'applications

- éventuellement, des fichiers d'aide et des fichiers de définition du Tableau de bord.

Afin que ces fichiers soient reconnus et utilisés par le Bureau, ils doivent figurer dans certains répertoires indiqués par les chemins de recherche du Bureau.

Il est parfois difficile de gérer une application lorsque ses fichiers de configuration sont éparpillés dans différents répertoires. C'est pourquoi le Bureau permet à une application de rassembler tous ses fichiers de configuration dans un seul répertoire. Ce regroupement de fichiers est appelé
module d'enregistrement.

Si l'application est adaptée au Bureau CDE, son module d'installation comporte un module d'enregistrement. Si vous êtes l'administrateur système et créez vous-même les fichiers de configuration, vous pouvez également créer ce module.

Le Bureau ne peut pas accéder aux fichiers de configuration du module d'enregistrement car ces derniers ne sont pas situés dans les répertoires du chemin de recherche adéquats. Le processus consistant à les mettre aux emplacements corrects s'appelle
l'enregistrement, ou l'intégration de l'application.

Le Bureau fournit un utilitaire, `dtappintegrate`, qui effectue l'enregistrement en créant des liens symboliques des fichiers dans les répertoires des chemins de recherche appropriés.

De nombreuses applications adaptées au Bureau CDE exécuteront automatiquement `dtappintegrate` lors de l'installation. Si vous êtes l'administrateur système et intégrez une application existante, vous pouvez l'exécuter vous-même après avoir créé le module d'enregistrement.

Lorsqu'une application est enregistrée sur le Bureau d'un système, elle est accessible à tous les utilisateurs du système. Si le système est configuré en tant que
serveur d'applications du Bureau, l'application sera également accessible aux autres systèmes du réseau.

L'utilitaire `dtappintegrate` offre une option de ligne de commande permettant d'inverser le processus en supprimant les liens. Il est ainsi plus facile de supprimer l'application du Gestionnaire d'applications et de la déplacer vers un autre serveur d'applications ou de la mettre à jour.

## Etapes générales d'enregistrement d'une application

Pour un exemple détaillé de création d'un module d'application, reportez-vous à la section SAG.RegAp.mkr.30.

1. Modifiez les ressources de l'application qui définissent les polices et les couleurs. Sinon, les polices et les couleurs dynamiques du Bureau ne s'afficheront pas correctement.

   Voir SAG.RegAp.mkr.14.

2. Créez un emplacement racine pour l'application.

   Voir SAG.RegAp.mkr.15.

3. Créez la structure du répertoire sous la racine de l'application.

   Voir SAG.RegAp.mkr.16.

4. Créez les actions et les types de données de l'application.

   Voir SAG.RegAp.mkr.19.

5. Placez les fichiers d'aide dans le répertoire approprié.

   Voir SAG.RegAp.mkr.21.

6. Placez les fichiers de documentation en ligne (infolib) dans le répertoire approprié.

   See SAG.RegAp.div.19a.

7. Créez les icônes de l'application

   Voir SAG.RegAp.mkr.22.

8. Créez le groupe de l'application.

   Voir SAG.RegAp.mkr.23.

9. à l'aide de `dtappintegrate`.

   Voir SAG.RegAp.mkr.28.

## Etape 1: Modification des ressources polices et couleurs

Pour un exemple de modification des ressources d'une application, reportez-vous à l' SAG.RegAp.mkr.6 de la section SAG.RegAp.mkr.30, SAG.RegAp.mkr.31.

Le Bureau fournit des mécanismes de définition et de manipulation des polices d'interface et des couleurs de fenêtres. Pour qu'une application utilise correctement ces mécanismes, il peut être nécessaire de modifier son fichier `app-defaults`.

### Modification des ressources polices

Cette section concerne les applications créées à l'aide d'Motif version 1.2 (ou suivantes). Le Gestionnaire de configuration ne peut définir des polices d'interface pour les applications rédigées avec des versions antérieures d'Motif.

Le Gestionnaire de configuration du Bureau définit des polices d'interface pour les applications créées avec Motif version 1.2 (ou suivantes) si l'application ne requiert pas de polices spécifiques.

Le Gestionnaire de configuration propose deux types de police:

Police système | Utilisée par les zones système telles que les libellés, menus et boutons
Police utilisateur | Utilisée pour les zones modifiables telles que les zones de texte

Chaque police est disponible dans sept tailles, numérotées de 1 à 7 dans la boîte de dialogue Polices. Les polices du Gestionnaire de configuration sont liées aux polices réelles du système par l'intermédiaire du jeu de ressources du Gestionnaire de configuration définies dans `/usr/dt/app-defaults/`langue`/Dtstyle`.

Si vous souhaitez que l'application utilise les polices du Gestionnaire de configuration, supprimez les ressources de l'application comportant des références à des polices spécifiques. Le Bureau définira alors automatiquement les ressources de l'application.

`FontList` | Police système
`XmText*FontList` | Police utilisateur
`XmTextField*FontList` | Police utilisateur

### Modification des ressources couleurs

Le Gestionnaire de configuration permet de modifier de façon dynamique les couleurs des applications. L'application doit être un client Motif 1.1 ou 1.2. Les programmes clients rédigés avec d'autres outils de développement ne peuvent pas modifier leurs couleurs dynamiquement. Ces modifications prennent effet lors de la réinitialisation du client.

La manière la plus simple d'utiliser les couleurs du Bureau consiste à supprimer toutes les ressources couleurs des applications, qu'il s'agisse des couleurs d'avant- ou d'arrière-plan.

## Etape 2: Création du répertoire racine d'une application

Pour un exemple de création du répertoire racine d'une application du Bureau, reportez-vous à l' SAG.RegAp.mkr.7 de la section SAG.RegAp.mkr.30, SAG.RegAp.mkr.32.

Les fichiers du module d'enregistrement de l'application sont regroupés dans un répertoire appelé racine de l'application, ou
racine_app. Le répertoire racine_app utilisé pour les fichiers de configuration du Bureau peut être identique au répertoire racine_app d'installation de l'application ou d'un autre emplacement.

Supposons, par exemple, qu'une application est installée dans le répertoire `/usr/BTE`. Ce même répertoire peut être utilisé comme répertoire racine_app des fichiers de configuration du Bureau. Cependant, si vous intégrez une application “non CDE” existante, il est recommandé de créer un répertoire racine de bureau différent, afin d'éviter que les fichiers de configuration en cours de création ne soient écrasés lors de la mise à jour de l'application.

Par exemple, un administrateur système peut souhaiter créer un répertoire `/etc/desktop_approots/BTE` comme répertoire racine du Bureau.

## Etape 3: Création des répertoires du module d'enregistrement

Pour un exemple de création des répertoires du module d'enregistrement d'une application, reportez-vous à l'SAG.RegAp.mkr.8 de la section SAG.RegAp.mkr.30, SAG.RegAp.mkr.33.

Le module d'enregistrement correspond au groupe de fichiers de configuration utilisés par le Bureau afin de fournir une interface graphique à l'application.

### Contenu du module d'enregistrement

Les fichiers de configuration du Bureau comprennent:

- les fichiers de définitions des actions et des types de données

- les fichiers d'images d'icônes

- un répertoire de groupe d'applications et son contenu

- éventuellement, les fichiers de données d'aide et un fichier de configuration du Tableau de bord.

Le module d'enregistrement est regroupé sous un répertoire de premier niveau, appelé racine de l'application ( racine_app).

#### Un module d'enregistrement sous le répertoire racine d'une application

Les principales catégories de zones de configuration dans le répertoire racine_app sont:

Sous-répertoire | Contenu
`types` | Fichiers de définitions des actions et des types de données.
`help` | Fichiers d'aide du Bureau.
`icons` | Fichiers d'images bitmaps et pixmaps utilisés par les actions et les types de données de l'application.
`appmanager` | Le répertoire et le contenu qui créent le groupe d'applications.
`biblinfo` | Les fichiers de documentation en ligne sont divisés en biblinfos, rayons et livres

Chacune de ces catégories comporte des sous-répertoires pour les fichiers dépendant de la langue. Les fichiers de langue par défaut sont placés dans le répertoire `C`.

#### Pour créer un module d'enregistrement

- Créez ces répertoires. Si vous avez des fichiers de configuration dépendant de la langue, créez un répertoire distinct pour chaque langue. Si vous ne proposez qu'une seule langue, placez les fichiers dans le répertoire `C`.

  - racine_app`/dt/appconfig/types/`langue

  - racine_app`/dt/appconfig/help/`langue

  - racine_app`/dt/appconfig/icons/`langue

  - `racine_app/dt/appconfig/appmanager/langue/groupe_app`, où groupe_app est le nom du groupe d'applications.

    Par exemple, la SAG.RegAp.mkr.18 affiche le Gestionnaire d'applications contenant un groupe dont groupe_app est “Outils_Media”.

##### Groupe d'applications au premier niveau du Gestionnaire d'applications

L'outil `dtappintegrate` fonctionne uniquement sur les fichiers de configuration du Bureau dans les répertoires `types`, `help`, `icons`, et `appmanager`. Le fichier exécutable binaire de l'application, `app-defaults`, et les fichiers de messages de catalogues sont gérés séparément.

## Etape 4: Création des actions et des types de données de l'application

Pour un exemple de création d'actions et de types de données pour une application, reportez-vous à l' SAG.RegAp.mkr.9 de la section SAG.RegAp.mkr.30, SAG.RegAp.mkr.34.

Les actions et les types de données fournissent une interface utilisateur à l'application.

- Les actions constituent une interface utilisateur pour la commande de lancement de l'application.

- Les types de données servent à personnaliser la présentation et le comportement des fichiers de données de l'application.

### Actions et types de données requis par une application

Les applications type requièrent les définitions d'actions et de types de données suivantes:

- une action qui ouvre l'application;

- un type de données pour les fichiers de l'application. Si vous créez un type de données, vous allez également créer:

  - une action Ouvrir pour les fichiers de données de l'application

  - une action Imprimer pour les fichiers de données de l'application

- un type de données pour le groupe d'applications (voir la section SAG.RegAp.mkr.25).

Pour une présentation sur l'utilisation des actions et des types de données du Bureau, reportez-vous au SAG.IntAc.mkr.1.

### Emplacement des fichiers de configuration des définitions d'actions et de types de données

Les actions et les types de données sont définis dans les fichiers de configuration. La seule exigence de dénomination pour les fichiers comportant des définitions d'actions et de types de données est qu'ils doivent inclure l'extension `.dt`. Selon les conventions, vous pouvez nommer le fichier nom_action`.dt` ou nom_application`.dt`.

Placez les fichiers contenant les actions et types de données sous la racine de l'application, dans le répertoire racine_app`/dt/appconfig/types/`langue. La langue par défaut est `C`.

#### Fichiers de définitions des actions et des types de données

### Comment créer des actions et des types de données

Deux méthodes permettent de créer les définitions d'actions et de types de données d'une application:

- Avec l'outil “Créer action”.

  Cet outil offre une interface d'un usage convivial. Cependant, il comporte certaines limites.

- Manuellement.

  Vous devez alors connaître la syntaxe de création des définitions, mais vous pouvez accéder à l'ensemble des fonctionnalités disponibles.

### Création d'actions et de types de données à l'aide de ”Créer action”

Cette procédure utilise l'outil “Créer action” pour créer une action et des types de données pour l'application.

Pour plus de détails sur “Créer action”, utilisez son aide en ligne ou reportez-vous au SAG.dtCrA.mkr.1.

1. Ouvrez le groupe d'applications “App_Bureau” et cliquez deux fois sur “Créer action”.

2. Utilisez cet outil pour créer les définitions d'actions et de types de données pour l'application et son type de données.

   Le fichier de configuration créé par l'outil est écrit dans RépPersonnel`/.dt/type/`nom_action`.dt`. Le fichier d'actions (fichier exécutable portant le même nom que l'action) est placé dans votre répertoire personnel.

3. Testez l'action en cliquant deux fois sur l'icône du fichier d'actions créé dans votre répertoire personnel.

4. Copiez le fichier de définitions d'actions RépPersonnel`/.dt/type/`nom_action`.dt` vers racine_app`/dt/appconfig/types/`langue.

5. Après la création du répertoire du groupe d'applications (voir SAG.RegAp.mkr.23), copiez le fichier d'actions RépPersonnel`/`nom_action dans le répertoire `racine_app/dt/appconfig/appmanager/langue/groupe_app`.

### Création manuelle d'actions et de types de données

- Créez un fichier de configuration contenant les définitions d'actions et de types de données de l'application.

Les fichiers d'actions et de types de données doivent respecter les conventions de dénomination nom`.dt`.

Vous pouvez placer vos définitions d'actions et de types de données dans un ou plusieurs fichiers. Pour chaque fichier, utilisez un nom que les administrateurs système associeront facilement à l'application.

Les noms des actions et des types de données doivent être en un seul “mot” (sans espace). Vous pouvez utiliser un caractère de soulignement. Par convention, la première lettre de l'action ou du type de données est en majuscules. N'utilisez pas un nom d'action ou de fichier existant. Utilisez un nom que les administrateurs système et les utilisateurs confirmés associeront facilement à votre application.

Si vous préférez assigner à l'icône de l'application un nom différent de celui de l'action, insérez une zone `LABEL` dans la définition de l'action.

Pour plus de détails sur la création d'actions et de types de données, reportez-vous aux chapitres indiqués ci-dessous.

- SAG.IntAc.mkr.1

- SAG.dtCrA.mkr.1

- SAG.CrAct.mkr.1

- SAG.CrDT.mkr.1

## Etape 5: Insertion des fichiers d'aide dans le module d'enregistrement

Pour un exemple d'ajout de fichiers d'aide à un module d'enregistrement, reportez-vous à l'SAG.RegAp.mkr.10 de la section SAG.RegAp.mkr.30, SAG.RegAp.mkr.35.

Si l'application comporte un
volume d'aide du Bureau (créé avec le kit du développeur de l'aide du Bureau), le fichier maître du volume d'aide (`*.sdl`) doit être placé dans le répertoire racine_app`/appconfig/help/`langue.

Les graphiques utilisés par les fichiers d'aide sont généralement placés dans un sous-répertoire `graphics`. Ils doivent se trouver dans le même répertoire lié au fichier du volume d'aide (`*.sdl`) que lors de la création du volume d'aide.

Si l'application ne comporte pas de volume d'aide, vous pouvez en créer un si vous disposez du
kit du développeur du Bureau CDE.

Il existe deux niveaux d'intégration d'un
volume d'aide:

- Intégration totale

  Lorsque l'aide du Bureau est totalement intégrée, l'utilisateur peut accéder au volume d'aide à partir de l'application — par exemple à partir de l'aide sur l'élément et du menu Aide. L'intégration totale implique la modification des exécutables de l'application.

- Intégration partielle

  Lorsque l'aide du Bureau est partiellement intégrée, l'utilisateur peut y accéder à partir du premier niveau du Gestionnaire d'aide. Cependant, il ne peut accéder au volume d'aide à partir des fenêtres de l'application. Vous pouvez créer une action pour accéder à l'aide à partir du groupe d'applications. L'action de l'exemple suivant affiche le volume d'aide situé dans le
  fichier maître de l'aide `MonApp.sdl`
  :

      ACTION OuvrirAideMonApp
      {
         LABEL        AideMonApp
         ARG_COUNT    0
         TYPE         COMMAND
         WINDOW_TYPE  NO_STDIO
         EXEC_STRING  /usr/dt/bin/dthelpview -helpVolume MonApp
         DESCRIPTION  Affiche l'aide sur l'application MonApp.
      }

## Etape 6: Insertion des bibliothèques d'informations dans le module d'enregistrement

Si l'application comprend la documentation en ligne (créée à l'aide du Kit du développeur du système d'information du bureau), la bibliothèque d'informations (`*.dti`) qui contient la documentation devra être placée dans le répertoire :

    app_root/dt/infolib/language

Les graphiques utilisés dans les fichiers du livre DocBook (`*.sgm`) sont généralement placés dans un sous- répertoire `graphics` Ils doivent se trouver dans le même répertoire lié au fichier de la bibliothèque d'informations (biblinfo) (`*.dti`) que lors de la création d'une biblinfo.

Si l'application ne comporte pas de documentation en ligne, vous pouvez la créer à l'aide du Kit du développeur du système information.

Il existe deux niveaux d'intégration d'une bibliothèque d'informations (biblinfo):

- Intégration totale

  Lorsqu'une biblinfo est totalement intégrée, l'utilisateur peut y accéder à partir de l'application en utilisant `DtActionInvoke` pour afficher un sujet spécifique dans le Gestionnaire de l'information. L'intégration totale demande la modification des fichiers d'exécution de l'application.

- Intégration partielle

  Lorsqu'une biblinfo est partiellement intégrée, l'utilisateur peut y accéder à partir du niveau supérieur du Gestionnaire de l'information. Cependant, il ne peut y accéder à partir des fenêtres de l'application. Vous pouvez créer une action pour accéder à la biblinfo à partir du groupe d'application. L'action de l'exemple suivant affiche le volume de la biblinfo située dans la bibliothèque d'informations `MyApp.dti`:

      ACTION OpenMyAppInfolib
      {
         LABEL                    MyAppInfolib
         ARG_TYPE            InfoLib
         TYPE                      MAP
         MAP_ACTION      DtLoadInfoLib /usr/dt/infolib/C/MyAppInfolib.dti
         DESCRIPTION      Fait appel au Gestionnaire de l'information pour afficher la documentation
                           en ligne de l'application MyApp.
      }

## Etape 7: Création d'icônes pour l'application

Pour un exemple de création de fichiers d'icônes pour une application, reportez-vous à l'SAG.RegAp.mkr.11 de la section SAG.RegAp.mkr.30, SAG.RegAp.mkr.36.

Le Bureau fournit des icônes par défaut pour les actions, les types de données et les groupes d'applications. Cependant, vous pouvez souhaiter créer des icônes propres à l'application.

Les icônes sont placées dans le répertoire racine_app`/dt/appconfig/icons/`langue.

### Icônes requises pour le Bureau

L'application utilise ces images d'icônes sur le Bureau:

- Icône d'action. Il s'agit de l'icône sur laquelle vous cliquez deux fois pour lancer votre application (action). Elle est répertoriée dans la zone `ICON` de l'action qui lance l'application.

  Elle existe en trois tailles: petite, moyenne et grande.

- Icône de type de données. Cette icône est utilisée pour représenter les fichiers de données de l'application dans le Gestionnaire de fichiers. Elle est répertoriée dans la zone `ICON` de la définition du type de données.

  Si votre application prend en charge différents types de données, vous devez attribuer une icône différente à chaque type.

  Elle existe en deux tailles: petite et moyenne.

- Icône de groupe d'applications. Il s'agit de l'icône qui représente le répertoire au premier niveau du Gestionnaire d'applications. Elle est listée dans la zone `ICON` de la définition du type de données du groupe d'applications (voir SAG.RegAp.mkr.23).

  Elle existe en deux tailles: petite et moyenne.

Vous devrez peut-être indiquer les versions pixmap et bitmap de chaque icône pour permettre le support des écrans couleur (8 bits et plus) et monochromes (moins de 8 bits).

### Conventions de dénomination des fichiers d'icônes

`Taille` | `Dimensions en pixels` | `Nom bitmap` | `Nom pixmap`
Petite | 16 x 16 | nom_base`.t.bm` | nom_base`.t.pm`
Moyenne | 32 x 32 | nom_base`.m.bm` | nom_base`.m.pm`
Grande | 48 x 48 | nom_base`.l.bm` | nom_base`.l.pm`

Si vous ne disposez pas des fichiers bitmap, le Bureau fait correspondre les spécifications couleur des fichiers pixmap en noir et blanc. Cependant, cette correspondance risque de pas produire donner l'apparence souhaitée.

Pour plus de détails, reportez-vous à la section SAG.CrIcn.mkr.3.

## Etape 8: Création du groupe d'applications

Pour un exemple de création d'un groupe d'applications, reportez-vous à l' SAG.RegAp.mkr.12 de la section SAG.RegAp.mkr.30, SAG.RegAp.mkr.37.

Une fois que vous avez créé les définitions d'actions et de types de données de l'application, vous devez créer les fichiers de configuration qui vont supporter la création de ce que l'utilisateur voit réellement — le groupe d'applications et son contenu.

Le groupe d'applications est un répertoire situé au premier niveau du Gestionnaire d'applications (reportez-vous à la SAG.RegAp.mkr.4).

Il existe trois étapes pour la création du groupe d'applications :

- Créez le répertoire du groupe d'applications dans le module d'enregistrement.

- Facultatif: configurez le groupe d'applications afin qu'il utilise une icône unique. Cela implique la création de la définition du type de données du groupe d'applications.

- Créez le contenu du groupe d'applications.

### Création du répertoire du groupe d'applications

Pour créer un groupe d'applications, créez les répertoires dans le module d'enregistrement sous `appmanager`, comme indiqué à la SAG.RegAp.mkr.24.

#### Le répertoire `appmanager`.

### Nom du groupe d'applications

Dans la SAG.RegAp.mkr.24, <groupe_app> correspond au nom du groupe d'applications.

#### Nom du groupe d'applications (<groupe_app>)

Le nom peut être un nom de fichier (répertoire) valide quelconque. Utilisez de préférence un nom explicite.

### Configuration du groupe d'applications avec un nom d'icône unique

Le Bureau fournit une icône de groupe d'applications par défaut. Toutefois, vous souhaiterez probablement attribuer au groupe d'applications une icône personnalisée.

Pour attribuer une icône unique au groupe d'applications, vous devez créer:

- un type de données pour le répertoire apparaissant au premier niveau du Gestionnaire d'applications;

- les actions Ouvrir et Imprimer pour le type de données.

Supposons, par exemple, que vous souhaitez créer un groupe d'applications appelé Outils_Media. La définition de types de données suivante, placée dans un fichier `racine_app/dt/appconfig/types/langue/nom.dt`, attribue une icône unique à l'icône du groupe d'applications.

    DATA_ATTRIBUTES Media_ToolsAppgroup
    {
       ACTIONS           OpenInPlace,OpenNewView
       ICON              MediaTools
       DESCRIPTION       Cliquez deux fois pour ouvrir le \
                         groupe d'applications Outils_Media
    }
    DATA_CRITERIA Media_ToolsAppgroupCriteria1
    {
       DATA_ATTRIBUTES_NAME  Media_ToolsAppgroup
       MODE                  d
       PATH_PATTERN          */appmanager/*/Outils_Media
    }

La section des attributs de la définition indique l'icône à utiliser. La section des critères indique que le type de données est défini dans un répertoire appelé `Outils_Media`, lui-même un sous-répertoire d'un répertoire appelé `appmanager`.

La SAG.RegAp.mkr.26 illustre la relation entre le nom du groupe d'applications et la définition du type de données. La zone `PATH_PATTERN` de la définition du type de données associe une icône unique au groupe d'applications.

#### Attribution d'une icône unique à un groupe d'applications

Vous devez également créer une action Ouvrir et une action Imprimer pour le
type de données du groupe d'applications:

    ACTION Ouvrir
    {
       ARG_TYPE    Media_ToolsAppGroup
       TYPE        MAP
       MAP_ACTION  OpenAppGroup
    }
    ACTION Imprimer
    {
       ARG_TYPE    Media_ToolsAppGroup
       TYPE        MAP
       MAP_ACTION  PrintAppGroup
    }

Les actions OpenAppGroup et PrintAppGroup sont des actions intégrées définies dans `/usr/dt/appconfig/types/`langue`/dtappman.dt`.

### Création du contenu du groupe d'applications

L'élément le plus important du groupe d'applications est l'icône permettant de lancer l'application (icône d'action). Si le groupe d'applications comporte une série d'applications, il existe, en général, une icône par application.

Outre la ou les icônes d'action, le groupe d'applications peut contenir:

- un ou plusieurs fichiers README,

- un ou plusieurs fichiers de données échantillon,

- des modèles,

- une icône sur laquelle l'utilisateur peut cliquer deux fois pour visualiser l'aide,

- une page de manuel,

- une icône spécialisée pour le Tableau de bord.

Le groupe d'applications peut contenir des sous-répertoires.

#### Création du fichier d'action (Icône de l'application)

Le groupe d'applications doit contenir une icône permettant de lancer l'application. Si le groupe comporte une série d'applications, une icône doit exister pour chacune d'entre elles. Ces icônes s'appellent icônes d'application ou icônes d'action, puisqu'elles représentent une action sous-jacente.

Pour définir une icône d'action, vous devez créer un fichier exécutable dont le nom doit être identique à celui de l'action à exécuter.

    racine_app/dt/appconfig/appmanager/groupe_app/nom_action

Le fichier est appelé
fichier d'action, car son but est de créer une représentation visuelle de l'action sous-jacente.

Par exemple, si vous avez créé une action BestTextEditor qui exécute l'application BestTextEditor, vous devez créer un fichier exécutable portant le nom BestTextEditor. Dans le Gestionnaire de fichiers et le Gestionnaire d'applications, le fichier d'action utilisera l'icône d'image indiquée dans la définition de l'action.

La SAG.RegAp.mkr.27 illustre la relation entre la définition de l'action, le fichier d'action et l'entrée réelle dans la fenêtre du Gestionnaire d'applications.

##### L'icône d'application est un fichier du groupe d'applications

#### Fichiers Read Me

Le Bureau fournit un type de données README à utiliser pour les fichiers README de votre application. Utilisez l'une des conventions de dénomination suivantes:

- `README`

- `readme`

- `README.*`

- `Read.*.Me`

- `read.*.me`

- `READ.*.ME`

#### Création d'une icône spécialisée du Tableau de bord

Dans la plupart des cas, il n'est pas nécessaire de définir une icône pour le Tableau de bord; l'utilisateur peut en effet ajouter l'application au Tableau de bord en faisant glisser son icône d'action sur l'icône “Installer une icône” d'un panneau secondaire.

Vous pouvez créer un fichier de configuration du Tableau de bord contenant une définition d'icône de votre application permettant aux utilisateurs d'installer une icône d'un comportement différent de celui de l'icône d'action — par exemple, si l'icône contrôle un fichier et change d'aspect lorsque ce fichier est modifié.

Les fichiers de configuration du Tableau de bord sont placés dans le répertoire racine_app`/dt/appconfig/types/`langue. La convention de dénomination est nom`.fp`.

Si vous disposez d'un fichier de configuration comportant une icône, l'utilisateur peut l'ajouter à un panneau secondaire en faisant glisser le fichier `*.fp` sur l'icône “Installer une icône” du panneau secondaire.

Par exemple, la définition suivante peut être placée dans un fichier de configuration du Tableau de bord du groupe d'applications. Si l'utilisateur fait glisser ce fichier sur l'icône ”Installer une icône” d'un panneau secondaire, une icône est créée dans ce dernier et exécute une seule instance de l'application BestTextEditor. Si BestTextEditor est déjà lancé, la fenêtre est déplacée sur le haut de la pile de fenêtres de l'espace de travail courant.

    CONTROL BestTextEditorControl
    {
       TYPE         icon
       ICON         BTEFPanel
       PUSH_RECALL  True
       CLIENT_NAME  BTEd
       PUSH_ACTION  BTEditor
       DROP_ACTION  BTEditor
       HELP_STRING  Lance l'application BestTextEditor.
    }

Pour plus de détails sur la création des fichiers de configuration du Tableau de bord, reportez-vous:

- au SAG.FrPC.mkr.1,

- à la page de manuel `dtfpfile(4)`.

## Etape 9: Enregistrement de l'application à l'aide de
dtappintegrate

Pour un exemple d'enregistrement d'une application, reportez-vous à l' SAG.RegAp.mkr.13 de la section SAG.RegAp.mkr.30, SAG.RegAp.mkr.38.

Une fois que vous avez créé un module d'enregistrement sous la racine d'une application, vous pouvez commencer l'enregistrement réel de l'application.

L'enregistrement de l'application crée des liens entre le module d'enregistrement et les répertoires situés dans les chemins de recherche du Bureau (reportez-vous à la section SAG.RegAp.mkr.29).

### Enregistrement d'une application à l'aide de dtappintegrate

Si l'application est adaptée au Bureau CDE, `dtappintegrate` est généralement exécuté automatiquement comme étape finale du processus d'installation. S'il n'est pas exécuté automatiquement, ou si vous avez créé les fichiers de configuration pour intégrer une application “non CDE”, vous pouvez alors lancer `dtappintegrate` manuellement.

1. Connectez-vous en tant qu'utilisateur root.

2. Exécutez la commande:

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

   où racine_app est le répertoire racine de l'application du Bureau. Pour plus de détails, reportez-vous à la page de manuel `dtappintegrate(1)`.

3. Ouvrez le groupe d'applications Outils_Bureau et cliquez deux fois sur Recharger applications.

4. Vérifiez que l'application est correctement enregistrée :

5. Affichez le premier niveau du Gestionnaire d'applications. Le nouveau groupe d'applications doit apparaître dans celui-ci.

6. Ouvrez le groupe d'applications et cliquez deux fois sur l'icône d'action.

#### Syntaxe et options de
dtappintegrate

`dtappintegrate -s` racine_app `[-t` chemin_cible `] [-l` langue ] `[-u]`

`-s` racine_app | Paramètre requis. Indique la racine sous laquelle l'application a été installée.
`-t` chemin_cible | Paramètre facultatif. A pour valeur par défaut l'emplacement du système `/etc/dt/appconfig.` Indique l'emplacement auquel les fichiers de configuration du Bureau sont liés. Vous devez utiliser un emplacement dans le chemin de recherche de l'application.
`-l` langue | Paramètre facultatif. A pour valeur par défaut toutes les langues. Indique les fichiers de configuration du Bureau dépendant de la langue à intégrer.
`-u` | Paramètre facultatif. Annule l'intégration de l'application, en supprimant tous les liens établis lors de l'intégration.

### Intégration des applications par dtappintegrate

`dtappintegrate` configure des liens entre les fichiers installés et les emplacements où le Bureau recherche les fichiers de configuration.

#### Actions et types de données

`dtappintegrate` crée des liens symboliques entre les fichiers de définitions d'actions et de types de données du module d'enregistrement et le répertoire de niveau système, à travers le chemin de recherche d'aide de bases de données d'actions. Pour ce faire, il crée des liens entre

racine_app`/dt/appconfig/types/` langue`/*.dt`

et

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

#### Fichiers d'aide

`dtappintegrate` crée des liens symboliques entre les fichiers d'aide du module d'enregistrement et le répertoire de niveau système, à travers le chemin de recherche d'aide. Pour ce faire, il crée des liens entre

racine_app`/dt/appconfig/help/`langue/fichier_aide`.sdl`

et

`/etc/dt/appconfig/help/`langue/fichier_aide`.sdl`

#### Bibliothèques d'informations

`dtappintegrate` crée des liens symboliques entre les bibliothèques d'information (biblinfos) du module d'enregistrement et le répertoire de niveau système, à travers le chemin de recherche biblinfo. Pour ce faire, il crée des liens entre

    app_root/dt/infolib/language/*.dti

to

    /etc/dt/infolib/language/*.dti

#### Fichiers d'icônes

`dtappintegrate` crée des liens symboliques entre les fichiers d'icônes du module d'enregistrement et le répertoire de niveau système, à travers le chemin de recherche d'icônes. Pour ce faire, il crée des liens entre

racine_app`/dt/appconfig/icons/`langue/fichiers_icône

et

`/etc/dt/appconfig/icons/`langue/fichiers_icône

#### Groupe d'applications

Pour placer le groupe de l'application au premier niveau du Gestionnaire d'applications, `dtappintegrate` crée un lien entre le répertoire du groupe d'applications du module d'enregistrement et l'emplacement de niveau système à travers le chemin de recherche d'applications. Pour ce faire, il crée des liens entre

racine_app`/dt/appconfig/appmanager/`langue/groupe_app

et

`/etc/dt/appconfig/appmanager/`langue/groupe_app

## Exemple de création d'un module d'enregistrement

Les étapes suivantes créent un module d'enregistrement pour une application non CDE appelée BestTextEditor.

### Informations sur ”BestTextEditor”

L'exemple s'appuie sur les hypothèses suivantes à propos de l'application (fictive) BestTextEditor:

- elle est installée dans le répertoire `/usr/BTE`

- la langue de session de l'utilisateur est la valeur par défaut, C

- la syntaxe de lancement de BestTextEditor est:

      BTEd [nom_fichier]

  où nom_fichier est le nom du fichier de données à ouvrir dans la nouvelle fenêtre. BestTextEditor crée sa propre fenêtre — c'est-à-dire qu'elle ne s'exécute pas dans une fenêtre d'émulateur de terminal.

- BestTextEditor crée et utilise deux type de fichiers de données:

  - Fichiers de documentation. Ils utilisent la convention de dénomination `*.bte`. BestTextEditor dispose d'une ligne de commande pour l'impression de ses fichiers de données `.bte`. La syntaxe de cette commande est:

        BTEPrint [-d destination] [-s] nom_fichier

    où:

  - `-d` destination | Indique l'imprimante de destination.
    `-s` | Indique une impression directe. La boîte de dialogue Imprimer de l'application ne s'affiche pas.
    nom_fichier | Indique le fichier à imprimer.

  - Fichiers modèles. Ils utilisent la convention de dénomination `*.tpl`. Les fichiers modèles ne peuvent être imprimés.

- Les fichiers app-defaults existant pour BestTextEditor, qui ne figurent pas dans le Bureau, contiennent des ressources pour les polices d'interface et les couleurs de premier plan et d'arrière-plan.

- Un volume d'aide en ligne pour BestTextEditor a été créé à l'aide du kit du développeur du Bureau CDE. Lors de sa construction, ce volume a utilisé les fichiers source suivants:

  `…/BTEHelp.htg`

  `…/graphics/BTE1.xwd`

  `…/graphics/BTE2.xwd`

  et génère le fichier `…/BTEHelp.sdl`.

#### Etapes d'enregistrement de ''BestTextEditor''

Les étapes ci-dessous permettent d'enregistrer BestTextEditor.

1. Modification des ressources polices et couleurs

   Dans le fichier app-defaults de BestTextEditor, supprimez les ressources qui définissent:

   - les polices de texte,

   - les couleurs d'avant- et d'arrière-plan.

2. Création de la racine de l'application

   Créez le répertoir:

   `/desktop_approots/BTE`

   Si vous intégrez une application existante, vous devez créer un répertoire racine différent du répertoire d'installation de l'application, faute de perdre les fichiers de configuration créés lorsque vous mettrez l'application à jour.

3. Création des répertoires du module d'enregistrement

   Créez les répertoires suivants:

       /desktop_approots/BTE/dt/appconfig/types/C
       /desktop_approots/BTE/dt/appconfig/help/C
       /desktop_approots/BTE/dt/appconfig/icons/C
       /desktop_approots/BTE/dt/appconfig/appmanager/C/BestTextEditor

4. Création des actions et des types de données de l'application

   1. Créez le fichier de configuration des définitions d'actions et de types de données:

          /desktop_approots/BTE/dt/appconfig/types/C/BTE.dtn

   2. Créez la définition d'action pour l'exécution de BestTextEditor:

          ACTION BTEditor
          {
             WINDOW_TYPE   NO_STDIO
             ICON          BTERun
             DESCRIPTION   Cliquez deux fois sur cette icône ou posez\
                           dessus un fichier de données pour exécuter\
                           BestTextEditor.
             EXEC_STRING   /usr/BTE/BTEd %Arg_1%
          }

   3. Créez le type de données des fichiers `*.bte`:

          DATA_ATTRIBUTES BTEDataFile
          {
             DESCRIPTION    Fichier de données de BestTextEditor.
             ICON           BTEData
             ACTIONS        Ouvrir,Imprimer
          }
          DATA_CRITERIA BTEDataFileCriteria1
          {
             DATA_ATTRIBUTES_NAME  BTEDataFile
             NAME_PATTERN         *.bte
             MODE                 f
          }

   4. Créez le type de données des fichiers `*.tpl`:

          DATA_ATTRIBUTES BTETemplateFile
          {
             DESCRIPTION    Fichier modèles de BestTextEditor.
             ICON           BTETempl
             ACTIONS        Ouvrir
          }
          DATA_CRITERIA BTETemplateFileCriteria1
          {
             DATA_ATTRIBUTES_NAME  BTETemplateFile
             NAME_PATTERN          *.tpl
             MODE                  f
          }

   5. Créez l'action Ouvrir pour les fichiers `*.bte`.

          ACTION Ouvrir
          {
             ARG_TYPE   BTEDataFile
             TYPE       MAP
             MAP_ACTION BTEditor
          }

   6. Créez l'action Imprimer pour les fichiers `*.bte`.

      Des actions Imprimer simples figurent ci-dessous. Ces actions requièrent la saisie d'une valeur pour la variable d'environnement `LPDEST` et ne tiennent pas compte de l'option d'impression `-s`. Si `LPDEST` n'est pas définie, l'action peut échouer.

          ACTION Imprimer
          {
             ARG_TYPE    BTEDataFile
             TYPE        MAP
             MAP_ACTION  BTEPrintData
          }
          ACTION BTEPrintData
          {
             WINDOW_TYPE  NO_STDIO
             EXEC_STRING  BTEPrint -d $LPDEST %Arg_1%
          }

      Voici une autre version de l'action BTEPrintData et du script l'accompagnant. Ensemble, ils gèrent les situations où `LPDEST` n'est pas définie et lorsque l'impression directe est demandée.

          ACTION BTEPrintData
          {
             WINDOW_TYPE  NO_STDIO
             EXEC_STRING  /usr/BTE/bin/BTEenvprint %(File)Arg_1%
          }

      Le contenu du script `/usr/BTE/bin/BTEenvprint` est :

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

   7. Créez l'action Ouvrir pour les fichiers `*.tpl`:

          ACTION Ouvrir
          {
             ARG_TYPE   BTETemplateFile
             TYPE       MAP
             MAP_ACTION BTEditor
          }

   8. Créez l'action Imprimer pour les fichiers `*.tpl`:

          ACTION Imprimer
          {
             ARG_TYPES   BTETemplateFile
             TYPE        MAP
             MAP_ACTION  NoPrint
          }

      NoPrint est une action intégrée qui affiche une boîte de dialogue indiquant à l'utilisateur que le fichier ne peut être imprimé.

5. Insertion des fichiers d'aide dans le module d'enregistrement

   1. Placez les fichiers d'aide aux emplacements suivants:

          /desktop_approots/BTE/dt/appconfig/help/C/BTEHelp.sdl
          /desktop_approots/BTE/dt/appconfig/help/C/graphics/BTE1.xwd
          /desktop_approots/BTE/dt/appconfig/help/C/graphics/BTE2.xwd

   2. Créez le fichier:

      `/desktop_approots/BTE/dt/appconfig/types/C/BTEhelp.dt`.

      Placez la définition d'action ci-dessous dans le fichier:

          ACTION BTEHelp
          {
             WINDOW_TYPE   NO_STDIO
             EXEC_STRING   /usr/dt/bin/dthelpview -helpVolume \BTEHelp.sdl
             DESCRIPTION   Ouvre le volume d'aide de BestTextEditor.
          }

6. Créations d'icônes pour l'application

   Utilisez l'Editeur d'icônes. Voici quelques indications relatives à la taille:

   Nom | Taille
   nom_base`.t.pm` | 16 x 16
   nom_base`.m.pm` | 32 x 32
   nom_base`.l.pm` | 64 x 64

   Créez ces fichiers d'icônes dans le répertoire `/desktop_approots/BTE/dt/appconfig/icons/C`:

   - Icônes représentant l'action: `BTERun.t.pm`, `BTERun.m.pm`, `BTERun.l.pm`

   - Icônes représentant les fichiers `*.bte`: `BTEData.t.pm`, `BTEData.m.pm`,

   - Icônes représentant les fichiers `*.tpl`: `BTETempl.t.pm`, `BTETempl.m.pm`

   - Icônes représentant le groupe d'applications (utilisé à l'étape 7): `BTEApp.t.pm`, `BTEApp.m.pm`

7. Création du groupe d'applications

   1. Si cela n'est pas déjà fait, créez le répertoire:

      `/desktop_approots/BTE/dt/appconfig/appmanager/C/BestTextEditor`

   2. Cette étape est facultative. Elle attribue une icône unique au groupe d'applications en créant pour ce dernier un type de données et les actions associées. Si vous omettez cette étape, le groupe d'applications utilisera l'icône par défaut.

      Ajoutez les définitions de types de données et d'actions suivantes au fichier `/desktop_approots/BTE/dt/appconfig/types/C/BTE.dt`. Le type de données indique l'icône que le groupe d'applications BestTextEditor utilisera. Les actions proposent le même comportement Ouvrir et Imprimer que les groupes d'applications intégrés.

          DATA_ATTRIBUTES BestTextEditorAppGroup
          {
             ACTIONS  OpenInPlace,OpenNewView
             ICON     BTEApp
          }
          DATA_CRITERIA BestTextEditorAppGroupCriterial
          {
             DATA_ATTRIBUTES_NAME BestTextEditorAppGroup
             MODE                 d
             PATH_PATTERN         */appmanager/*/BestTextEditor
          }
          ACTION Ouvrir
          {
             ARG_TYPE    BestTextEditorAppGroup
             TYPE        MAP
             MAP_ACTION  OpenAppGroup
          }
          ACTION Imprimer
          {
             ARG_TYPE   BestTextEditorAppGroup
             TYPE       MAP
             MAP_ACTION PrintAppGroup
          }

   3. Créez, dans le groupe d'applications, une icône qui lancera l'application. Pour ce faire, créez le fichier:

          /desktop_approots/BTE/dt/appconfig/appmanager/C/BestTextEditor/BTEditor

      et faites-en un fichier exécutable.

   4. Créez le fichier d'action du groupe d'applications qui ouvrira le volume d'aide. Pour ce faire, créez le fichier:

          /desktop_approots/BTE/dt/appconfig/appmanager/C/BestTextEditor/BTEHelp

      et faites-en un fichier exécutable.

   5. Placez les autres fichiers dans le groupe d'applications, par exemple les fichiers ”read me”, de données échantillons et modèles.

8. Enregistrement de l'application

   Dans une fenêtre d'émulateur de terminal:

   1. Connectez-vous en tant qu'utilisateur root.

   2. Exécutez la commande:

      `/usr/dt/bin/dtappintegrate -s /desktop_approots/BTE`

   3. Ouvrez le groupe d'applications Outils_Bureau et cliquez deux fois sur Recharger applications.