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.
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.
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.
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.
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.
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.
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.
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.
pour développer les ressources du projet.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
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.
pour la développer.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.
pour modifier les paramètres par
défaut.
pour modifier les paramètres par
défaut.Pour plus d'informations sur le rendu par défaut, voir HATS - Guide d'utilisation et d'administration.
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.
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.
Pour créer une personnalisation d'écran, 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.
Pour créer une combinaison d'écrans, 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.
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.
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.
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.
| 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 |
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.
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.
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.
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.
Vous pouvez également effectuer les types de personnalisation suivants dans votre projet HATS.
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.
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.
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.
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.
).
).
).
).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.
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.
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.
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.
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.
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.
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.
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.
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.