Personnalisation de votre projet HATS

Après avoir suivi les étapes du Création d'un projet HATS de base, votre projet HATS ressemble encore beaucoup à l'application hôte d'origine. Il est temps à présent de le personnaliser. Vous allez pouvoir effectuer les opérations de personnalisation ci-après.

Il existe aussi d'autres tâches évoluées de personnalisation. Elles sont répertoriées dans Réalisation d'autres tâches de personnalisation et décrites plus en détail dans les documents HATS - Guide d'utilisation et d'administration, HATS Web Application Programmer's Guide et HATS Rich Client Platform Programmer's Guide.

Principes de fonctionnement d'une application HATS

Pour comprendre la finalité des techniques de personnalisation décrites dans le présent chapitre, et les relations qui existent entre elles, vous devez tout d'abord comprendre comment une application HATS traite un écran hôte pour le convertir en interface graphique. Lorsqu'un utilisateur accède à une application HATS, une demande est envoyée à l'application HATS, qui s'exécute sur WebSphere Application Server, , WebSphere Portal ou une plateforme client enrichi. L'application HATS achemine la demande vers l'application hôte et reçoit en retour un écran hôte. Elle transforme cet écran hôte grâce à la personnalisation que vous avez définie dans le projet HATS, puis envoie cette transformation à l'utilisateur. A chaque fois que l'utilisateur interagit avec l'application HATS, ce processus se répète.

L'application HATS détermine elle-même comment convertir chaque écran hôte à partir d'un certain nombre de règles. Les applications HATS peuvent contenir une liste d'événements d'écran (personnalisations d'écran et combinaisons d'écrans), qui indique les critères de correspondance avec les écrans hôte. Chaque événement d'écran répertorie également les actions qui doivent être effectuées lorsqu'une correspondance est détectée. L'application HATS compare chaque écran hôte à son ensemble ordonné d'événements d'écran et, lorsque la première correspondance est détectée, exécute les actions indiquées. Il n'est pas nécessaire que vous définissiez une conversion pour chacun des écrans de l'application hôte. S'il n'existe aucun événement d'écran correspondant à un écran hôte, HATS effectue les actions définies pour l'événement d'écran sans correspondance, qui, par défaut, applique la transformation par défaut. Pour plus de détails, voir Utilisation des événements d'écran.

Ressources HATS

Chaque projet HATS contient différents types de ressource (artefacts). Ces types de ressource sont répertoriés sous le nom du projet dans la vue Projets HATS de HATS Toolkit. La présente section définit les principaux types de ressource. Pour connaître les définitions des autres ressources HATS, voir Glossaire.

Connexion
Une connexion est un jeu de paramètre, stocké dans un fichier .hco, utilisé par HATS pour la connexion à une application hôte. Pour plus d'informations sur les connexions, voir HATS - Guide d'utilisation et d'administration.
Evénement d'écran
Un événement d'écran est un événement HATS déclenché lorsqu'un écran hôte est reconnu par des critères de reconnaissance d'écran spécifiques. Il existe deux types d'événement d'écran : les personnalisations d'écran et les combinaisons d'écrans.
Personnalisation d'écran
Une personnalisation d'écran est un type d'événement d'écran conçu pour effectuer un ensemble d'actions lorsqu'un écran hôte est reconnu. Une définition de personnalisation d'écran, stockée dans un fichier .evnt, inclut un ensemble de critères qui définissent la correspondance des écrans hôte, ainsi qu'une liste d'actions à effectuer lorsqu'un écran hôte correspond à ces critères. Les personnalisations d'écran sont décrites dans Utilisation des événements d'écran.
Combinaison d'écrans
Une combinaison d'écrans est un type d'événement d'écran conçu pour rassembler des données à partir d'écrans hôte consécutifs et similaires, les combiner et les afficher dans une seule page de sortie. La définition d'une combinaison d'écrans, stockée dans un fichier .evnt, inclut un ensemble de critères de reconnaissance d'écran indiquant les écrans de début et de fin de la combinaison, le mode d'accès d'un écran à l'autre, ainsi que le composant et le widget à utiliser pour la reconnaissance et le rendu des données rassemblées à partir de chaque écran. Les combinaisons d'écran sont décrites dans Utilisation des événements d'écran.
Capture d'écran
Une capture d'écran est une représentation XML d'un écran hôte, stockée dans un fichier .hsc, utilisée pour créer ou personnaliser une personnalisation d'écran, une combinaison d'écrans, une transformation ou une règle globale. Les captures d'écran sont utiles, car elles permettent de personnaliser une application, même si celle-ci n'est pas connectée à l'hôte.
Macro
Une macro, stockée dans un fichier .hma, automatise les interactions avec l'hôte. Elle peut envoyer des commandes à l'hôte, indiquer des données dans les zones d'entrée, extraire des données de l'hôte et être utilisée pour accéder à des écrans à la place de l'utilisateur. Les macros sont décrites dans le document HATS - Guide d'utilisation et d'administration.
Modèle
Un modèle, stocké dans un fichier .jsp (pour les projets Web) ou dans un fichier .java (pour les projets client enrichi), contrôle la présentation et le style de base (par exemple, les couleurs et les polices) de l'application. Il définit également l'aspect des zones communes à la plupart des pages de l'interface graphique, telles que les bannières et les zones de navigation. Les modèles sont décrits dans Mise à jour du modèle du projet.
Transformation
Une transformation, stockée dans un fichier .jsp (pour les projets Web) ou dans un fichier .java (pour les projets client enrichi), définit le mode d'extraction et d'affichage des composants hôte via des widgets dans l'interface graphique. Les transformations sont décrites dans Gestion des transformations.

Utilisation de l'écran de terminal hôte

Au cours du développement de votre projet HATS, vous serez souvent amené à accéder aux écrans de votre application hôte. Pour ce faire, vous utiliserez l'écran de terminal hôte HATS pour vous connecter à votre application hôte, interagir avec elle et l'utiliser pour les tâches suivantes :

Chacune de ces tâches est décrite dans les sections qui suivent.

Remarque :
Vous utilisez également le terminal hôte lors de la création de traces de simulation hôte que vous pourrez utiliser hors ligne quand vous ne serez pas connecté à l'hôte. Pour plus d'informations, voir Utilisation de la simulation hôte dans HATS - Guide d'utilisation et d'administration.

Pour ouvrir une session de terminal hôte, sélectionnez un projet dans la vue Projets HATS, puis cliquez sur l'icône Afficher l'écran de terminal hôte HATS dans la barre d'outils principale. Vous pouvez également cliquer à l'aide du bouton droit de la souris sur un projet, sélectionner, dans le menu contextuel, Afficher l'écran du terminal hôte, puis choisir la connexion à utiliser. Si vous maintenez la session hôte active, vous pouvez l'utiliser, au cours de la personnalisation du projet, pour créer des événements d'écran et des transformations à partir d'écrans actifs. Vous pouvez également, si vous préférez, accéder seulement à quelques écrans de l'application hôte et cliquer sur l'icône Créer une capture d'écran dans la barre d'outils du terminal hôte afin de créer des captures d'écran à partir desquelles vous pourrez créer des événements d'écran et des transformations.

Le tableau 2 répertorie les icônes qui figurent sur l'écran du terminal hôte.

Tableau 2. Icônes de l'écran de terminal hôte HATS
Icône Description
Créer une personnalisation d'écran HATS
Création d'une personnalisation d'écran HATS à partir de l'écran en cours. La liste déroulante comporte les personnalisations d'écran dont les critères de reconnaissance correspondent à cet écran.
Créer une combinaison d'écrans HATS
Création d'une combinaison d'écrans HATS à partir de l'écran en cours. La liste déroulante comporte les combinaisons d'écrans dont les critères de reconnaissance correspondent à cet écran.
Connecter
Connexion de la session hôte (désactivée lorsque la connexion est déjà établie)
Déconnecter
Déconnexion de la session hôte (activée uniquement lorsque la connexion est établie)
Capture d'écran
Capture d'écran
Créer une transformation HATS
Création d'une transformation HATS à partir de l'écran en cours.
Affichage de macro
Affichage d'une macro. Sélectionnez une macro dans la liste déroulante.
Exécution de macro
Exécution d'une macro. Sélectionnez une macro dans la liste déroulante.
Enregistrer une macro
Début d'enregistrement d'une macro
Arrêter une macro
Arrêt d'enregistrement d'une macro
Sauvegarder une macro
Sauvegarde de la macro enregistrée
Exécuter pas à pas
Exécution pas à pas (F5) de chaque action de macro à des fins de débogage
Exécuter jusqu'à la ligne suivante
Exécution jusqu'à la ligne suivante (F6) dans les écrans de macro à des fins de débogage
Revenir en arrière
Retour en arrière (F7) dans la macro à des fins de débogage
Reprendre
Reprise de l'exécution de la macro (F8)
Définir les critères de reconnaissance d'écran
Définition des critères de reconnaissance d'écran associés à une macro
Action Ajouter une invite
Ajout d'une invite dans la macro en cours (icône activée uniquement dans le cadre de l'enregistrement d'une macro)
Action Ajouter une extraction
Ajout d'une extraction dans la macro en cours (icône activée uniquement dans le cadre de l'enregistrement d'une macro)
Enregistrer une boucle
Enregistrement d'une boucle dans la macro en cours (icône activée uniquement dans le cadre de l'enregistrement d'une macro)
Actions Ajouter une invite pour toutes les zones
Ajout d'invites dans la macro en cours pour toutes les zones de l'écran (icône activée uniquement dans le cadre de l'enregistrement d'une macro)
Actions Ajouter une extraction pour toutes les zones
Ajout d'extractions dans la macro en cours pour toutes les zones de l'écran (icône activée uniquement dans le cadre de l'enregistrement d'une macro)
Afficher/Masquer le bloc de touches
Affichage/masquage du bloc de touches dans la fenêtre du terminal hôte
Afficher/masquer la zone d'informations système
Affichage/masquage de la zone d'informations système
Remarque :
Lorsque vous visualisez le terminal hôte via HATS Toolkit, il est possible qu'en raison de différentes actions, telles que la réduction de la fenêtre du terminal ou le passage à une autre perspective, la fenêtre du terminal ne soit plus activée et ne puisse plus revenir au premier plan. Cliquez dans la fenêtre du terminal à l'emplacement du curseur pour restaurer son affichage.

Prévisualisation de l'écran hôte

Pour avoir un aperçu de l'affichage de l'écran hôte lorsque l'application HATS est exécutée dans un environnement de production, cliquez sur l'onglet Prévisualiser l'écran hôte en haut de la fenêtre Terminal hôte. Cette fonction lance une recherche dans la liste des événements d'écran, en respectant l'ordre indiqué pour le projet, et applique l'événement d'écran correspondant. S'il n'existe aucun événement d'écran correspondant défini pour l'écran en cours, le modèle du projet et les règles de rendu par défaut sont appliquées à l'écran.

Utilisation de captures d'écran

Une autre méthode de gestion des écrans hôte consiste à naviguer dans plusieurs écrans du terminal hôte et à capturer des représentations de ces écrans à l'aide de l'icône Création de capture d'écran, représentée dans le tableau ci-dessus. Une fois les écrans hôte capturés, vous pouvez les utiliser sans avoir à vous connecter à l'ordinateur hôte. Vous devez générer des captures d'écran pour modifier des options de rendu par défaut ou créer des règles globales.

Les captures d'écran que vous créez sont stockées dans le dossier Captures d'écran de votre projet. Pour utiliser une capture d'écran, développez le dossier dans la vue Projets HATS, puis cliquez deux fois sur la capture d'écran afin de lancer l'éditeur. L'éditeur de capture d'écran affiche l'écran hôte. Cliquez sur l'onglet Prévisualisation, situé dans la partie inférieure de la fenêtre, afin de voir la transformation qui serait appliquée à cet écran dans le cadre de votre projet.

Cliquez sur l'onglet Ecran hôte dans la partie inférieure de la fenêtre afin de retourner à l'écran hôte. Vous pouvez utiliser les icônes de la barre d'outils qui figure dans la partie supérieure de l'éditeur pour créer une personnalisation d'écran, une combinaison d'écrans ou une transformation à partir de la capture d'écran. L'événement d'écran ou la transformation prend par défaut le nom de la capture d'écran.

Mise à jour du modèle du projet

Dans la plupart des cas, les pages affichées par une application HATS se composent de deux éléments :

Un modèle permet de contrôler la présentation globale de l'application. Il s'agit d'un fichier JSP, dans les projets Web HATS, ou d'une classe composite SWT (Standard Widgets Toolkit) Java™, dans les projets client enrichi HATS.

Pour consulter des exemples d'écrans transformés, voir Exemple HATS. Dans l'exemple Web, l'écran transformé comporte trois zones principales : une bannière de titre graphique, une barre de navigation verticale qui contient les boutons du bloc de touches application, et la zone d'information hôte. Dans l'exemple client enrichi, l'écran transformé comporte une bannière horizontale, une barre d'outils, qui contient les boutons du bloc de touches application, et la zone d'information hôte. Le modèle fournit une présentation cohérente pour les pages d'une application et vous permet de personnaliser votre application HATS. Il peut être réutilisé dans plusieurs applications.

Même si chacun des écrans de votre application utilise normalement le même modèle, vous pouvez toujours définir un événement d'écran qui applique une transformation utilisant un modèle différent. Ce nouveau modèle s'applique alors aux écrans correspondant à l'événement d'écran. (Pour plus d'informations sur les événements d'écran, voir Utilisation des événements d'écran.)

Vous pouvez modifier un modèle fourni par HATS ou en créer un nouveau. A l'aide de l'assistant de création de modèle, vous pouvez créer un modèle vide, un modèle basé sur l'un des modèles fournis avec HATS ou une page Web (pour les projets Web uniquement). Dans le cas de projets Web HATS, vous pouvez créer un modèle basé sur le site Web de votre entreprise.

Pour remplacer le modèle de votre projet HATS, procédez comme indiqué ci-après.

  1. Dans la vue Projets HATS, cliquez sur le signe plus Signe plus pour développer les ressources du projet.
  2. Cliquez deux fois sur Paramètres du projet afin d'ouvrir l'éditeur de projet.
  3. Cliquez sur l'onglet Modèle située dans la partie inférieure de la fenêtre de l'éditeur afin d'afficher la page correspondante.
  4. Sélectionnez, parmi les modèles fournis avec HATS Toolkit, celui qui se rapproche le plus de la présentation que vous voulez affecter à votre application. Sauvegardez vos changements.
  5. A l'aide de l'éditeur, modifiez le modèle. Pour ouvrir l'éditeur, développez le projet dans la vue Projets HATS. Dans le cas de projets Web, développez les dossiers Contenu Web et Modèles. Dans le cas de projets client enrichi, développez les dossiers Client enrichi et Modèles. Cliquez deux fois sur le nom du modèle que vous souhaitez modifier.

Vous pouvez également modifier le modèle du projet par défaut en développant le dossier Modèles. Cliquez à l'aide du bouton droit de la souris sur le modèle de votre choix et sélectionnez Définir en tant que modèle par défaut.

Pour plus d'informations sur la création et l'édition des modèles, voir HATS - Guide d'utilisation et d'administration

Edition du rendu par défaut

Le rendu par défaut assure la transformation des écrans hôte qui n'ont pas été personnalisés de manière individuelle. Le rendu par défaut modifie les composants hôte de l'écran en widgets dans l'interface graphique. Certains composants hôte sont mis en correspondance avec des widgets spécifiques pour être convertis dans la transformation par défaut. Une liste par défaut d'éléments mis en correspondance est établie pour les projets. Il s'agit d'une liste de paramètres de rendu. Vous pouvez modifier un paramètre de rendu selon vos souhaits.

Les éléments de la liste de paramètres de rendu sont traités selon leur ordre dans la liste. Une fois qu'un élément de cette liste est appliqué à une zone de l'écran hôte, cette dernière est consommée et ne sera plus traitée.

Pour accéder aux paramètres de rendu par défaut, procédez comme indiqué ci-après.

  1. Dans la vue Projets HATS, localisez le nom du projet. Si la liste des ressources associées à ce projet n'est pas déjà développée, cliquez sur le signe plus Signe plus pour la développer.
  2. Cliquez deux fois sur Paramètres de projet.
  3. Dans la partie inférieure de la fenêtre d'édition, cliquez sur l'onglet Rendu.
  4. Dans la liste des éléments de rendu, cliquez sur Rendu par défaut. La liste des paramètres de rendu apparaît dans le tableau, dans la partie supérieure, à droite. Les boutons situés à côté du tableau permettent d'ajouter, de supprimer ou d'éditer des paramètres.
  5. Dans le tableau supérieur, sélectionnez les paramètres de rendu que vous souhaitez modifier. Les éléments de mappage contenus dans ces paramètres s'affichent dans le tableau, dans la partie inférieure, à droite.

Comme vous pouvez le constater, plusieurs éléments sont définis dans des paramètres de rendu. Une case à cocher se trouve en regard de chaque élément. Lorsqu'une case est cochée, l'élément correspondant devient actif et il est utilisé par la transformation par défaut si HATS détecte le composant sur l'écran. Si vous voulez pas utiliser un certain élément dans le projet, vous pouvez désélectionner la case correspondante au lieu de supprimer complètement l'élément. Les boutons situés à côté du tableau permettent d'ajouter, de supprimer ou d'éditer des éléments. Les boutons Vers le haut et Vers le bas permettent de réorganiser les éléments de rendu.

Pour définir des éléments de rendu par défaut supplémentaires, procédez comme indiqué ci-après.

  1. Les nouveaux éléments de rendu par défaut se créent à partir d'une capture d'écran. Commencez par créer une capture d'écran, en suivant les instructions précisées dans Utilisation de l'écran de terminal hôte, pour chaque élément de rendu par défaut que vous envisagez de créer.
  2. Cliquez sur Ajouter pour ajouter un nouvel élément dans la liste.
  3. Dans la fenêtre Nouvel élément de rendu par défaut, indiquez un nom unique et éventuellement une description pour l'élément.
  4. Dans la boîte de dialogue Sélectionner une zone d'écran, procédez comme indiqué ci-après.
    1. Sélectionnez une capture d'écran établie précédemment contenant un composant auquel vous souhaitez affecter un widget.
    2. Dans le graphique de l'écran sélectionné, tracez un rectangle autour de la zone d'écran contenant ce composant. Par exemple, maintenez le bouton gauche de la souris enfoncé et déplacez la souris jusqu'à ce que le rectangle comprenne toute la région définie.
    3. Cliquez sur Suivant.
  5. Dans la boîte de dialogue Options de rendu, procédez comme indiqué ci-après.
    1. Sélectionnez le composant dans la liste. Si nécessaire, cliquez sur l'icône Paramètres de composant Paramètres de composant pour modifier les paramètres par défaut.
    2. Sélectionnez dans la liste le widget que vous souhaitez affecter en tant que widget par défaut pour le composant. Si nécessaire, cliquez sur l'icône Paramètres de widget Paramètres de widget pour modifier les paramètres par défaut.
    3. Cliquez sur Fin.

Pour plus d'informations sur le rendu par défaut, voir HATS - Guide d'utilisation et d'administration.

Création de règles globales

Les règles globales permettent de transformer des zones d'entrée spécifiques en fonction de certains critères. Elles s'appliquent à la fois aux écrans personnalisés et aux écrans rendus via le rendu par défaut. Vous pouvez les définir au niveau du projet, mais aussi au niveau de l'écran, ce qui vous permet de mieux contrôler leur application.

Chaque élément de règle globale est défini dans un fragment de transformation, qui peut être inclus dans d'autres transformations. Vous pouvez éditer les fragments de transformation comme des transformations, à l'aide de toutes les options disponibles avec les transformations.

Pour plus d'informations sur les règles globales, voir HATS - Guide d'utilisation et d'administration.

Utilisation des événements d'écran

Un événement HATS est une ressource qui effectue un ensemble d'actions en fonction d'un certain état atteint. Il existe deux types d'événement HATS : les événements d'application et les événements d'écran. Pour plus d'informations sur les événements d'application, voir HATS - Guide d'utilisation et d'administration. Un événement d'écran est un événement HATS déclenché lorsqu'un écran hôte est reconnu par des critères de reconnaissance d'écran spécifiques. Il existe deux types d'événement d'écran : les personnalisations d'écran et les combinaisons d'écrans.

Une personnalisation d'écran est un événement d'écran HATS conçu pour effectuer un ensemble d'actions lorsqu'un écran hôte est reconnu. Une personnalisation d'écran peut ainsi reconnaître un écran et le transformer en interface graphique pour l'utilisateur, ou exécuter une macro qui ignorera l'écran. La définition d'une personnalisation d'écran inclut un ensemble de critères de reconnaissance d'écran et une liste des actions à effectuer lorsqu'un écran hôte correspond aux critères de reconnaissance d'écran. Les règles globales au niveau de l'écran et les paramètres de remplacement de texte y figurent également. L'assistant Création d'une personnalisation d'écran permet de créer une personnalisation d'écran.

Une combinaison d'écrans est un événement d'écran HATS conçu pour rassembler des données à partir d'écrans hôte consécutifs et similaires, les combiner et les afficher dans une seule page de sortie. Une combinaison d'écrans peut ainsi reconnaître un écran qui ne contient que des données de sortie partielles et accéder à tous les écrans suivants pour rassembler les données restantes et les afficher pour l'utilisateur. La définition d'une combinaison d'écrans inclut un ensemble de critères de reconnaissance d'écran précisant les écrans de début et de fin à combiner, le mode d'accès d'un écran à l'autre, ainsi que le composant et le widget à employer pour la reconnaissance et le rendu des données rassemblées à partir de chaque écran. Elle comporte également une liste des actions à effectuer une ou plusieurs fois, les règles globales au niveau de l'écran et les paramètres de remplacement de texte. L'assistant de création d'une combinaison d'écrans permet de créer une combinaison d'écrans.

Les actions pouvant être effectuées dans un événement d'écran sont répertoriées ci-après. Pour plus de détails, voir HATS - Guide d'utilisation et d'administration.

Création d'une personnalisation d'écran

Pour créer une personnalisation d'écran, procédez comme indiqué ci-après.

  1. Sélectionnez un projet dans la vue Projets HATS et développez ses ressources.
  2. Pour créer la personnalisation d'écran à partir d'un terminal hôte actif, affichez ce dernier, accédez à l'écran à utiliser et cliquez sur l'icône Créer une personnalisation d'écran HATS dans la barre d'outils du terminal hôte. Pour créer la personnalisation d'écran à partir d'une capture d'écran, cliquez à l'aide du bouton droit de la souris sur la capture d'écran concernée dans l'arborescence et sélectionnez Nouveau HATS > Personnalisation d'écran. La personnalisation d'écran est créée à partir de la capture d'écran ou de l'écran de terminal hôte sélectionné et prend par défaut le nom de la capture d'écran ou un nom généré à partir du texte figurant sur l'écran de terminal hôte. Quelle que soit la méthode utilisée, l'assistant Création d'une personnalisation d'écran est lancé.
  3. Sur la page Personnalisation d'écran, procédez comme indiqué ci-après.
  4. Sur la page Critères de reconnaissance d'écran, procédez comme indiqué ci-après.
  5. Sur la page Actions, procédez comme indiqué ci-après.

Il n'est pas obligatoire que vous définissiez complètement la personnalisation d'écran. Vous pourrez l'éditer ultérieurement et modifier ses critères de reconnaissance et ses actions.

Création d'une combinaison d'écrans

Pour créer une combinaison d'écrans, procédez comme indiqué ci-après.

  1. Sélectionnez un projet dans la vue Projets HATS et développez ses ressources.
  2. Pour créer la combinaison d'écrans à partir d'un terminal hôte actif, afficher ce dernier, accédez à l'écran à utiliser et cliquez sur l'icône Créer une combinaison d'écrans HATS dans la barre d'outils du terminal hôte. Pour créer la combinaison d'écrans à partir d'une capture d'écran, cliquez à l'aide du bouton droit de la souris sur la capture d'écran concernée dans l'arborescence et sélectionnez Nouveau HATS > Combinaison d'écrans. La combinaison d'écrans est créée à partir de la capture d'écran ou de l'écran de terminal hôte sélectionné et prend par défaut le nom de la capture d'écran ou un nom généré à partir du texte figurant sur l'écran de terminal hôte. Quelle que soit la méthode utilisée, l'assistant de création d'une combinaison d'écrans est lancé.
  3. Sur la page Combinaison d'écrans, procédez comme indiqué ci-après.
  4. Sur la page Critères de reconnaissance de l'écran de début, procédez comme indiqué ci-après.
  5. Sur la page Zone d'écran, procédez comme indiqué ci-après.
  6. Sur la page Options de rendu, procédez comme indiqué ci-après.
  7. Sur la page Navigation d'écran, procédez comme indiqué ci-après.
  8. Sur la page Critères de reconnaissance de l'écran de fin, procédez comme indiqué ci-après.
  9. Sur la page Action, procédez comme indiqué ci-après.

Il n'est pas obligatoire que vous définissiez complètement la combinaison d'écrans. Vous pourrez l'éditer ultérieurement et modifier ses critères de reconnaissance et ses actions.

Tri et activation des événements d'écran

Votre application HATS vérifie chacun des écrans hôte entrant par rapport à une liste triée d'événements d'écran. Il est essentiel que les événements d'écran d'un projet soient correctement triés. Vous pouvez ainsi avoir un événement d'écran qui reconnaît quelques écrans spécifiques et un second événement d'écran qui reconnaît davantage d'écrans plus généraux. Si le second événement est indiqué avant le premier, il risque d'être appliqué à l'un des écrans auxquels vous souhaitez que le premier événement d'écran, plus spécifique, soit appliqué.

L'éditeur Paramètres de projet permet de modifier l'ordre des événements d'écran ou de consulter l'ordre dans lequel ils sont utilisés. Après avoir créé les événements d'écran du projet, cliquez deux fois sur Paramètres de projet dans la vue Projets HATS. Dans l'éditeur, cliquez sur l'onglet Evénements. Vérifiez la liste des événements d'écran et, si vous le souhaitez, modifiez leur ordre à l'aide des boutons Vers le haut et Vers le bas. L'événement d'écran à vérifier en premier doit figurer en début de liste.

Cochez ou désélectionnez les case situées en regard de chaque événement d'écran de la liste pour activer ou désactiver les événements d'écran. Lorsqu'une case est cochée, l'événement d'écran correspondant devient actif. Si vous désélectionnez la case, l'application HATS n'utilisera pas l'événement d'écran associé. La désactivation de certains événements d'écran peut s'avérer utile pendant le test et le débogage, car cela permet d'améliorer les performances si de nombreux événements d'écran ne sont pas utilisés.

Remarque :
Vous pouvez également établir une liste de priorités concernant les écrans suivants au sein d'un événement d'écran pour améliorer les performances. Pour plus d'informations, voir HATS - Guide d'utilisation et d'administration.

Gestion des transformations

Une transformation définit le mode de conversion d'un écran hôte en page d'interface graphique. Elle indique comment doit être traitée chaque partie de l'écran hôte.

Composants hôte et widgets

Dans les applications hôte, les données peuvent être présentées sous de nombreuses formes, telles que des menus, des tableaux et des invites de commande. On parle alors de composants hôte. L'application HATS convertit ces composants en éléments graphiques, ou widgets, pour pouvoir afficher ces données dans l'interface graphique.

HATS est livré avec un ensemble de composants hôte par défaut qui représentent les méthodes de présentation de données les plus courantes, auxquels sont associés des widgets. Ces composants hôte et widgets sont présentés dans le tableau 3. Lorsque vous développez une application HATS, vous sélectionnez une zone de l'écran hôte, un composant hôte (chargé de la recherche d'un contenu spécifique dans cette zone), ainsi qu'un widget (chargé du rendu de la sortie du composant hôte).

Par exemple, si une application hôte comporte un menu dans lequel l'utilisateur doit effectuer une ou plusieurs sélections, vous pouvez configurer l'application HATS afin qu'elle affiche ce menu dans une interface graphique sous la forme d'une liste déroulante. Vous pourriez aussi décider que ce menu doit prendre la forme d'une liste de boutons d'option, à partir de laquelle l'utilisateur doit effectuer un choix, ou d'une liste de liens ou de boutons. Vous pouvez même développer un composant personnalisé ou un widget.

Tableau 3. Composants hôte de HATS et widgets correspondants
Composant hôte Widget
Ligne de commande
Zone de liste déroulante plateforme client enrichi uniquement 
Liste déroulante (entrée de données)
Liste
Incrustation
Bouton d'option (entrée de données)
Zone de saisie
Zone
Zone
Touche de fonction
Bouton
Tableau de boutons
Liste déroulante (sélection)
Lien
Bouton d'option (sélection)
Barre d'outils plateforme client enrichi uniquement 
Mot clé DDS HTML DDS
Libellé
Zone d'entrée
Calendrier  Web uniquement 
Case à cocher
Zone de liste déroulante plateforme client enrichi uniquement 
Liste déroulante (entrée de données)
Liste
Incrustation
Bouton d'option (entrée de données)
Zone de saisie
Zone d'entrée avec
conseils
Zone de liste déroulante plateforme client enrichi uniquement 
Liste déroulante (entrée de données)
Liste
Incrustation
Bouton d'option (entrée de données)
Sélection d'option
Case à cocher
Zone de liste déroulante plateforme client enrichi uniquement 
Liste déroulante (entrée de données)
Lien (sélection)
Liste
Incrustation
Bouton d'option (sélection)
Zone de saisie
Stylet (attention)
Bouton
Lien
Bouton d'option (sélection)
Stylet (sélection)
Case à cocher
Zone de la barre de défilement (ENPTUI)
Barre de défilement (ENPTUI)
Zone de sélection (ENPTUI)
Bouton
Case à cocher
Lien
Bouton d'option (sélection)
Liste de sélection
Bouton
Tableau de boutons
Liste déroulante (sélection)
Lien
Bouton d'option (sélection)
Barre d'outils plateforme client enrichi uniquement 
Sous-fichier
Sous-fichier (case à cocher)
Sous-fichier (liste déroulante)
Sous-fichier (menu en incrustation)
Tableau
Diagramme (barres horizontales)
Diagramme (linéaire)
Diagramme (barres verticales)
Tableau
Tableau
(zone)
Diagramme (barres horizontales)
Diagramme (linéaire)
Diagramme (barres verticales)
Tableau
Tableau
(visuel)
Diagramme (barres horizontales)
Diagramme (linéaire)
Diagramme (barres verticales)
Tableau
Texte
Libellé
Adresse URL
Lien

Utilisation des transformations par HATS

Une transformation HATS est un outil puissant qui contient toutes les informations nécessaires à la conversion des composants d'écrans hôte en widgets dans les pages d'interface graphique. Elle ne peut cependant être utilisée qu'en association avec un événement d'écran. L'événement d'écran, décrit dans Utilisation des événements d'écran, comporte une liste d'actions à entreprendre lorsqu'un écran hôte correspond à ses critères de reconnaissance d'écran. L'application d'une transformation à l'écran hôte fait partie des actions qui peuvent être entreprises.

Le moyen le plus simple d'associer une transformation à un événement d'écran est de créer la transformation en même temps que l'événement d'écran.

Création d'une transformation

Il existe de nombreuses façons de créer une transformation. Lorsque vous créez un événement d'écran et que vous appliquez une transformation dans le cadre des actions, HATS crée par défaut une transformation du même nom, à partir du même écran hôte, et l'associe à cet événement d'écran. La transformation, ainsi baptisée et associée à un écran hôte, a donc été créée sans recours à un assistant.

Vous pouvez également créer une transformation au moyen des méthodes décrites ci-après.

Quelle que soit la méthode utilisée, l'assistant de création d'une transformation est lancé. Si vous créez une transformation directement à partir d'une capture d'écran ou d'un terminal hôte, vous devrez l'associer ultérieurement à un événement d'écran que vous éditerez afin d'y ajouter la transformation en tant qu'action. Cette opération est décrite dans le document HATS - Guide d'utilisation et d'administration.

L'assistant de création d'une transformation vous invite à sélectionner le projet cible, à saisir un nom pour la transformation, à indiquer un module (pour les projets client enrichi) et à préciser l'écran à employer comme base. L'assistant crée la transformation et l'ouvre dans l'éditeur de transformation afin que vous puissiez y ajouter des composants hôte et des widgets.

Edition d'une transformation

Lorsque vous éditez une transformation, vous pouvez utiliser l'option Composants HATS de la vue Palette de l'Page Designer pour déplacer de nouveaux composants sur la page. Vous pouvez utiliser la vue Propriétés pour modifier les paramètres des composants en cours. Pour plus d'informations sur l'édition des transformations dans les projets Web HATS, voir Editing transformations for Web projects dans HATS - Guide d'utilisation et d'administration.

Pour éditer une transformation dans le cas des projets Web HATS, vous pouvez utiliser, outre la vue Palette, les icônes de la barre d'outils principale ainsi que les options du menu Outils HATS, dans la barre de menus. Le tableau ci-après répertorie les icônes disponibles dans la barre d'outils principale.

Tableau 4. Icônes de la barre d'outils principale de l'éditeur de transformation HATS
Icône Description
Insérer un composant hôte
Insertion d'un composant hôte dans la transformation
Editer un composant hôte
Edition d'un composant hôte
Insérer le rendu par défaut
Insertion du rendu par défaut d'un écran ou d'un écran partiel dans la transformation
Editer le rendu par défaut
Edition du rendu par défaut

Dans le cas des projets Web HATS, vous pouvez également faire appel aux fonctions du menu Outils HATS, qui se trouve dans la barre de menus, pour insérer des éléments dans une transformation lorsque vous l'éditez. Ces fonctions sont décrites dans le tableau ci-après.

Fonction d'insertion Description
Insérer un dossier à onglets Insère un dossier à onglets.
Insérer une touche macro Ajoute un bouton, un lien ou une liste déroulante pour permettre à l'utilisateur final d'exécuter une macro.
Insérer une variable globale Insère une variable globale, telle qu'un texte ou une invite de variable globale avec des zones d'entrée.
Insérer une zone d'informations système Insère la zone d'informations système qui affiche les attributs de terminal.
Insérer le bloc de touches hôte > Bloc de touches par défaut Ajoute le bloc de touches hôte par défaut.
Insérer le bloc de touches hôte > Bloc de touches personnalisé Ajoute un bloc de touches hôte personnalisé contenant uniquement les touches que vous avez sélectionnées.
Insérer le bloc de touches hôte > Touche individuelle Ajoute la touche hôte individuelle que vous avez sélectionnée.
Insérer le bloc de touches application > Bloc de touches par défaut Ajoute le bloc de touches application par défaut.
Insérer le bloc de touches application > Bloc de touches personnalisé Ajoute au modèle de votre page Web un bloc de touches application personnalisé contenant les touches que vous avez sélectionnées.
Insérer le bloc de touches application > Touche individuelle Ajoute au modèle de votre page Web la touche application individuelle que vous avez sélectionnée.
Insérer tous les composants hôte Insère tous les composants hôte détectés dans une capture d'écran sélectionnée.
Insérer un écran stocké Insère un écran que vous avez enregistré lors de l'association de plusieurs écrans hôte.
Insérer des propriétés d'objet d'intégration > Entrée Insère d'entrées issues d'une page JSP d'objet d'intégration.
Insérer des propriétés d'objet d'intégration > Sortie Insère de sorties issues d'une page JSP d'objet d'intégration.
Insérer le servlet de réacheminement vers l'application HATS Ajoute un bouton qui réachemine des informations de contrôle JSP vers l'application HATS démarrée par l'utilisateur.

Pour les projets du client enrichi HATS, si l'éditeur d'application client Java (VE) est installé avec Rational SDP, vous pouvez utiliser l'éditeur visuel pour éditer vos transformations. L'éditeur visuel vous permet d'utiliser les options HATS ci-après de la vue Palette. Pour plus d'informations sur l'édition des transformations dans les projets HATS client enrichi, voir Edition des transformations pour les projets de client enrichi dans HATS - Guide d'utilisation et d'administration.

Option Description
Composant Lance l'assistant d'insertion d'un composant hôte pour insérer le rendu d'un composant spécifique.
Rendu par défaut Lance l'assistant d'insertion du rendu par défaut pour insérer un composite de rendu par défaut.
Touche macro Lance l'assistant Insertion d'une touche macro pour insérer un bouton ou un lien qui exécute une macro lorsque l'utilisateur clique dessus.
Variable globale Lance l'assistant Insertion de variable globale pour afficher la valeur d'une variable globale ou inviter l'utilisateur à en indiquer une.
Touche hôte Lance l'assistant d'insertion d'une touche hôte pour insérer un bouton ou un lien qui envoie une touche hôte lorsque l'utilisateur clique dessus.
Touche d'application Lance l'assistant d'insertion d'une touche d'application pour insérer un bouton ou un lien associé à une fonction d'une touche de l'application.

L'utilisation de ces fonctions dans l'éditeur de transformation est décrite dans le document HATS - Guide d'utilisation et d'administration.

Réalisation d'autres tâches de personnalisation

Vous pouvez également effectuer les types de personnalisation suivants dans votre projet HATS.

Affichage des touches de fonction

De nombreux écrans hôte comportent une liste de touches de fonction avec un libellé. Vous pouvez choisir d'afficher ces touches sous forme graphique dans l'application HATS. Pour plus d'informations sur l'affichage des touches de fonction, reportez-vous à la description du bloc de touches hôte dans le document HATS - Guide d'utilisation et d'administration.

Remplacement de chaînes de texte de l'écran hôte

L'application HATS peut remplacer des chaînes de texte des écrans hôte par une sortie différente sur les pages d'interface graphique. Il doit s'agir de chaînes de texte protégées, c'est-à-dire de chaînes de texte qui sont utilisées uniquement à l'écran et jamais transmises en entrée à l'application hôte. Vous pouvez, par exemple, remplacer la chaîne de texte utilisée comme libellé de zone ou comme invite. Vous pouvez remplacer un texte par un autre texte, du code HTML  Web uniquement  ou des images. Le support des expression régulières Java peut être utilisé dans le cadre de l'algorithme de remplacement de texte. Il est possible de remplacer des chaînes de texte par un bouton ou un lien qui envoie une touche hôte.

Le remplacement de texte peut se définir de plusieurs manières dans un projet :

Si vous définissez un remplacement de texte pour le même texte dans les paramètres du projet et dans un événement d'écran avec des résultats de remplacement différents, la définition de l'événement d'écran est prioritaire. Si vous définissez un remplacement de texte pour le même texte dans un événement d'écran et une balise de composant, le remplacement défini au niveau de la balise de composant est prioritaire.

Un remplacement de texte qui utilise une autre chaîne de texte tente de conserver la présentation d'écran d'origine. Si le texte de remplacement est plus long que le texte à remplacer, il est tronqué en fonction de la taille de la zone du texte d'origine. Toutefois, si de l'espace est disponible entre la zone du texte de remplacement et le composant hôte suivant, la chaîne de remplacement utilise cet espace pour insérer les caractères supplémentaires.

Un remplacement de texte par des chaînes HTML  Web uniquement  ou des images ne protège pas la présentation d'écran d'origine car la taille de la zone d'origine peut s'avérer insuffisante. Le résultat de formatage dans l'interface graphique risque d'être insatisfaisant.

Remarque :
Le widget Zone possède une option qui permet de rendre un résultat caractère par caractère. Si vous utilisez le widget Zone avec cette option définie pour rendre la section de l'écran hôte remplacée par une image, vous obtiendrez un formatage insatisfaisant.

Lorsque vous remplacez du texte par n'importe quel élément de remplacement choisi, vérifiez bien vos remplacements de texte afin de vous assurer qu'ils ne généreront pas de résultats inattendus.

Pour plus d'informations sur le remplacement de texte, voir HATS - Guide d'utilisation et d'administration.

Utilisation de macros

Vous pouvez enregistrer une macro pour créer une série d'opérations à effectuer automatiquement, telles que la saisie d'informations dans certaines zones d'entrée ou la sélection d'options de menu. Par exemple, pour accéder à une application hôte, un utilisateur doit se connecter au système à l'aide d'un ID utilisateur et d'un mot de passe. La connexion au système favorise l'utilisation d'une macro, car le projet peut faire défiler les écrans de connexion pour l'utilisateur de l'application. De plus, vous pouvez éditer la macro à l'aide de Visual Macro Editor pour ajouter un chemin conditionnel à prendre si l'ID ou le mot de passe utilisateur ont expiré.

Pour enregistrer une macro de connexion simple, procédez comme indiqué ci-après.

  1. Mettez en évidence un projet dans la vue Projets HATS et cliquez sur l'icône Afficher l'écran terminal hôte HATS ( Icône Afficher l'écran terminal hôte HATS).
  2. Dans l'écran du terminal hôte qui affiche l'écran de connexion, cliquez sur l'icône Enregistrer une macro ( Icône Enregistrer une macro).
  3. Sur le panneau Enregistrer une macro, sélectionnez le projet cible, affectez un nom à la macro, par exemple maconnexion, et indiquez éventuellement une description. Cliquez sur Fin.
  4. Dans le panneau Définition du premier écran de la macro, vous pouvez nommer l'écran ou accepter le nom proposé par défaut. Pour cet exemple, prenons le nom logon. Sélectionnez une zone d'écran à utiliser pour reconnaître l'écran. Etant donné qu'un écran de connexion contient généralement du texte statique, vous pouvez sélectionner n'importe quelle partie du texte affiché. Vous remarquerez que la case Chaînes est cochée. Sélectionnez l'option A une position spécifiée parmi les critères d'emplacement de la chaîne, car le texte sélectionné doit toujours occuper le même emplacement. Les zones Ligne et Colonne contiennent les coordonnées de la zone d'écran sélectionnée. Cliquez sur Suivant.
  5. Dans le panneau Critères de reconnaissance pour l'écran, le texte qui permet de reconnaître l'écran est prédéfini pour vous, à l'aide des informations collectées à partir de l'écran précédent. Cliquez sur Fin.
  6. Dans l'écran du terminal hôte affichant l'écran de connexion, entrez l'ID utilisateur et le mot de passe requis et appuyez sur Entrée. A gauche de l'écran hôte, la progression de la macro s'affiche dans le volet Navigateur de macro.
  7. D'autres écrans peuvent s'afficher au cours de la connexion à un hôte, que l'utilisateur n'a pas nécessairement besoin de voir. Procédez à la connexion comme vous le feriez habituellement jusqu'à ce que vous accédiez à un écran permettant l'accès à l'application hôte du projet. Cet écran peut contenir du texte explicite indiquant la possibilité d'accéder à une application (par exemple, Connexion terminée ou Menu principal).
  8. Cliquez sur l'icône Arrêt de macro ( Icône Arrêt de macro).
  9. Dans le panneau Définition de l'écran d'exit de la macro, affectez un nom à l'écran d'exit, tel que écranfinal. Cette fois, vous définissez des critères de reconnaissance pour le dernier écran de la macro. Il s'agit plus vraisemblablement de l'écran comportant le texte Connexion terminée ou Menu principal. Vous pouvez sélectionner ce texte et l'utiliser pour reconnaître l'écran d'exit de la macro. Si le texte que vous sélectionnez est censé figurer toujours au même emplacement sur l'écran, sélectionnez l'option A une position spécifiée dans les critères de position de la chaîne. Sinon, sélectionnez l'option N'importe où sur l'écran. Cliquez sur Suivant.
  10. Dans le panneau Critères de reconnaissance pour l'écran, le texte qui permet de reconnaître l'écran est prédéfini pour vous, à l'aide des informations collectées à partir de l'écran précédent. Cliquez sur Fin.
  11. Vous avez enregistré une macro qui permet à un utilisateur de se connecter au système. Pour ajouter cette macro à votre projet, cliquez sur l'icône Sauvegarde de macro ( Icône Sauvegarde de macro).
  12. Vous pouvez maintenant fermer ou réduire l'écran du terminal hôte, et visualiser la macro nommée maconnexion dans le dossier Macros du projet, dans la vue Projets HATS.

Vous pouvez exécuter la macro maconnexion comme une action dans une personnalisation d'écran pour qu'un utilisateur se connecte au système hôte.

Pour plus d'informations sur l'enregistrement et l'utilisation des macros, voir HATS - Guide d'utilisation et d'administration et HATS Advanced Macro Guide.

Utilisation d'artefacts de Host Publisher

Vous pouvez importer des applications IBM® WebSphere Host Publisher, des objets d'intégration et des macros dans un projet HATS à l'aide des options du menu Fichier > Importer > HATS. Vous pouvez également créer des pages Web directement à partir d'objets d'intégration importés. Pour plus d'informations sur l'importation et l'utilisation des artefacts de Host Publisher, voir HATS - Guide d'utilisation et d'administration. Pour plus d'informations sur la programmation à l'aide d'objets d'intégration de Host Publisher ou sur leur personnalisation, voir HATS Web Application Programmer's Guide.

Création de connexions d'arrière-plan

Lorsque vous créez un projet, vous définissez une connexion à l'hôte pour traiter toutes les transformations. Vous pouvez définir des connexions d'arrière-plan à différents hôtes pour exécuter des objets d'intégration et des macros. La sécurité SSL (Secure Sockets Layer), Web Express Logon (WEL), le regroupement de connexion et les listes d'utilisateurs sont des fonctions prises en charge avec ces connexions. Pour plus d'informations sur la définition de connexions, voir HATS - Guide d'utilisation et d'administration.

Définition de variables globales

Vous pouvez définir des variables globales qui recevront des données provenant, par exemple, d'une zone de l'écran, afin de les rendre disponibles pour des opérations de logique applicative, des transformations et des invites de macro. Pour plus d'informations sur les variables globales, voir HATS - Guide d'utilisation et d'administration.

Application d'une logique applicative

Vous pouvez définir l'appel d'une méthode Java, en tant qu'action à entreprendre dans un événement d'écran, afin d'exécuter une logique applicative. Pour ajouter une logique applicative dans le projet HATS, accédez à la vue Projets HATS, cliquez à l'aide du bouton droit de la souris sur le projet et sélectionnez Nouveau HATS > Logique applicative. Un assistant vous invite à indiquer un projet cible, un nom de classe et un nom de module. Une classe de raccord est alors créée dans le répertoire Source du projet. Pour plus d'informations sur l'ajout d'une logique applicative dans un projet HATS, voir HATS Web Application Programmer's Guide ou HATS Rich Client Platform Programmer's Guide, selon les cas.

Utilisation du support clavier

Outre la représentation des boutons d'application hôte dans la conception de l'écran, vous pouvez permettre aux utilisateurs d'interagir avec l'application hôte par l'intermédiaire du clavier. Pour plus d'informations, voir HATS - Guide d'utilisation et d'administration.

Création d'objets d'intégration et projets EJB

Vous pouvez créer des objets d'intégration à partir des macros des projets Web HATS et des projets EJB HATS. Les projets EJB HATS ne contiennent aucun dossier pour les personnalisations d'écran, les combinaisons d'écrans, les captures d'écran ou le contenu Web. Ils ne comportent que des connexions, des macros et des objets d'intégration. Pour plus d'informations sur les objets d'intégration et la création des projets EJB, voir HATS Web Application Programmer's Guide .

Les objets d'intégration peuvent être utilisés dans les services Web et les portlets. Voir HATS Web Application Programmer's Guide pour plus de détails.

Vous pouvez également créer des pages Web du modèle 1, Struts, ou JSF Web pour exécuter vos objets d'intégration. Voir HATS - Guide d'utilisation et d'administration pour plus de détails.

Utilisation du support d'impression

Vous pouvez ajouter dans votre projet HATS un support pour l'affichage et l'impression en mode local de fichiers de l'application hôte. Voir HATS - Guide d'utilisation et d'administration pour plus de détails.

Avance automatique

La fonction d'avance automatique permet de faire avancer automatiquement la mise en évidence à la zone d'entrée suivante de l'interface graphique lorsqu'un utilisateur remplit une zone d'entrée. Lorsque cette fonction est activée, le comportement de la mise en évidence de l'interface graphique est similaire à celui des mouvements du curseur dans un émulateur de terminal classique ; lorsqu'une zone de l'écran hôte est remplie par un utilisateur, le curseur se déplace automatiquement au début de la zone d'entrée suivante. Pour activer cette fonction sur chaque page de l'application HATS, ouvrez l'éditeur Paramètres de projet, cliquez sur l'onglet Autre, sélectionnez Paramètres client, puis cochez la case Activer l'avance de zone automatique.

Pour les applications Web, vous pouvez désactiver individuellement cette fonction pour chaque transformation en ajoutant les lignes suivantes juste après la balise </HATS:Form> dans le fichier de transformation. Pour activer cette fonction de manière sélective, indiquez true à la place de false.

<script> 
autoAdvance = false;
</script>

Pour les applications client enrichi, vous pouvez désactiver cette fonction de manière sélective pour une transformation individuelle en remplaçant la méthode needsAutoAdvanceSupport dans la transformation individuelle, comme indiqué ci-après. Pour activer cette fonction de manière sélective, indiquez true à la place de false.

public boolean needsAutoAdvanceSupport(boolean preferredValue) {
return false;
}

Pour plus d'informations sur la fonction d'avance automatique, voir HATS - Guide d'utilisation et d'administration.