Ressources de l'interface utilisateur

Le package org.eclipse.jface.resource définit des classes qui permettent aux plug-ins de gérer les ressources de l'interface utilisateur, telles que les polices et les icônes.

De nombreux points d'extension du plan de travail permettent aux plug-ins de fournir les icônes qui peuvent être utilisées pour montrer leurs contributions dans le plan de travail. Les systèmes d'exploitation de l'interface graphique supportant en mémoire un nombre limité d'images ou de polices simultanées, les ressources de l'interface utilisateur d'un plug-in doivent être attentivement gérées et parfois partagées entre plusieurs widgets.

Plusieurs références aux icônes ont déjà été abordées dans le plug-in de l'outil readme. Certaines de ces icônes sont spécifiées dans les marques du fichier plugin.xml.

<extension
   point="org.eclipse.ui.views">
	<category
	   id="org.eclipse.ui.examples.readmetool"
	   name="%Views.category">
	</category>
	<view
	   id="org.eclipse.ui.examples.readmetool.views.SectionsView"
	   name="%Views.ReadmeSections"
	   icon="icons/view16/sections.png"
	   category="org.eclipse.ui.examples.readmetool"
	   class="org.eclipse.ui.examples.readmetool.ReadmeSectionsView">
	</view>
</extension>

Nous avons également abordé le code qui décrit les images à la volée. Ci-dessous figure la méthode ReadmeEditorActionBarContributor de l'outil readme.

public ReadmeEditorActionBarContributor() {
      	...
	action1 = new EditorAction(MessageUtil.getString("Editor_Action1"));
	action1.setToolTipText(MessageUtil.getString("Readme_Editor_Action1"));
	action1.setDisabledImageDescriptor(ReadmeImages.EDITOR_ACTION1_IMAGE_DISABLE);
	action1.setImageDescriptor(ReadmeImages.EDITOR_ACTION1_IMAGE_ENABLE);
	...

JFace fournit les classes de support de base qui permettent aux plug-ins de gérer leurs icônes et polices sans s'inquiéter du moment où les objets graphiques de la plate-forme correspondants sont créés et détruits. Ces classes de support sont utilisées directement par les plug-ins comme illustré ci-dessus, ou indirectement lorsque le plan de travail utilise les classes pour obtenir les images décrites dans les marques du point d'extension.

Descripteurs et registres d'images

La classe SWT Image représente une image de la perspective du système d'exploitation. La plupart des systèmes d'exploitation de l'interface graphique étant limités sur le nombre d'images pouvant être ouvertes simultanément, les plug-ins doivent faire très attention lors de leur création et s'assurer également qu'ils les suppriment correctement lorsqu'ils n'en ont plus besoin. En utilisant les classes JFace ImageDescriptor et ImageRegistry à la place d'une image SWT, les plug-ins peuvent généralement éviter de créer, gérer et supprimer ces images directement.

Descripteur d'image

La classe ImageDescriptor peut être utilisée comme description abrégée d'une image. Elle spécifie tout ce qui est nécessaire pour créer une image, par exemple une URL ou un nom de fichier permettant d'obtenir l'image. ImageDescriptors n'attribue pas d'image réelle de la plate-forme, à moins que cela soit spécifiquement demandé à l'aide de la méthode createImage().

Les descripteurs d'image constituent la meilleure stratégie lorsque votre code est structuré de telle sorte qu'il définisse toutes les icônes à un seul endroit et les affectent là où elles sont nécessaires. Ces descripteurs peuvent être créés à n'importe quel moment quelles que soient les ressources du système d'exploitation, rendant pratique leur création dans le code d'initialisation.

Registre d'images

La classe ImageRegistry est utilisée pour conserver une liste des images désignées. Les clients peuvent ajouter des descripteurs d'image ou des images SWT directement à la liste. Lorsqu'une image est demandée par son nom à partir du registre, ce dernier renvoie l'image si elle a été créée ou en crée une à partir du descripteur. Ceci permet aux clients du registre de partager les images.

Les images ajoutées au registre ou qui en sont extraites, ne doivent par être supprimées par un client. Le registre est responsable de la suppression d'une image du fait que les images sont partagées par plusieurs clients. Il supprime les images lorsque le système de l'interface utilisateur graphique de la plate-forme est arrêté.

Schémas de plug-in pour l'utilisation des images

Spécification de l'image dans le fichier plugin.xml

Si possible, spécifiez l'icône des objets de l'interface utilisateur de votre plug-in dans le fichier plugin.xml. Un grand nombre des points d'extension du plan de travail inclut des paramètres de configuration pour un fichier d'icônes. En définissant vos icônes dans votre contribution d'extension dans le fichier plugin.xml, vous laissez la plate-forme décider de la stratégie à adopter pour la gestion des images. Les icônes étant généralement conservées dans le répertoire du plug-in, vous pouvez ainsi spécifier les icônes et gérer les fichiers à un seul endroit.

Les autres schémas doivent être envisagés uniquement lorsque vous ne pouvez pas spécifier l'icône dans la contribution de votre extension.

Création explicite

Créer explicitement une image est la meilleure stratégie lorsque l'image n'est pas utilisée fréquemment et qu'elle n'est pas partagée. L'image peut être créée directement dans SWT et supprimée une fois son utilisation terminée.

Les images peuvent aussi être créées de manière explicite en utilisant ImageDescriptor et en appelant la méthode createImage(). Comme dans le premier cas, la méthode dispose() de l'image doit être appelée lorsque cette dernière n'est plus utile. Par exemple, si une boîte de dialogue crée une image lorsqu'elle est ouverte, elle doit la supprimer lorsqu'elle se referme.

Registre d'images

Lorsqu'une image est utilisée fréquemment dans un plug-in et partagée par de nombreux objets différents dans l'interface utilisateur, il est utile de consigner le descripteur de l'image dans une méthode ImageRegistry. Les images contenues dans le registre seront partagées par tout objet requérant une image par le même nom. Vous ne devez pas supprimer les images du registre du fait qu'elles sont partagées par d'autres objets.

L'ajout d'une image au registre est la meilleure stratégie lorsque l'image est utilisée fréquemment, peut-être tout au long de la durée de vie du plug-in, et qu'elle est partagée par de nombreux objets. L'utilisation du registre présente cependant l'inconvénient que les images qu'il contient ne sont supprimées qu'une fois l'interface graphique arrêtée. Comme le nombre d'images de la plate-forme (SWT) pouvant être ouvertes simultanément est limité, les plug-ins doivent veiller à ne pas enregistrer un trop grand nombre d'icônes dans un registre.

La classe AbstractUIPlugin inclut un protocole permettant de créer un registre d'images à la taille du plug-in.

Fournisseurs de libellé

Lorsqu'une icône est utilisée fréquemment pour afficher des articles dans un afficheur particulier, elle peut être partagée par des articles similaires dans l'afficheur à l'aide d'un fournisseur de libellé. Ce dernier étant responsable pour tout objet du retour d'une image dans un afficheur, il peut contrôler la création de l'image et le partage des images entre les objets dans l'afficheur.

Le fournisseur de libellé peut utiliser l'une des techniques expliquées précédemment pour produire une image. Si vous parcourez les diverses implémentations de getImage() dans les sous-classes LabelProvider, vous verrez une variété d'approches, incluant la mise en mémoire cache d'une seule icône pour les objets et la gestion d'une table d'images par type. Les images créées par un fournisseur de libellé doivent être supprimées dans la méthode dispose() du fournisseur qui est appelée lorsque l'afficheur est fermé.

L'utilisation d'un fournisseur de libellé est un bon compromis entre la création explicite et le registre d'images. Tout comme le registre d'images, elle promeut le partage des icônes, tout en maintenant le contrôle sur la création et la suppression de l'image réelle.

Classe d'image à la taille du plug-in

Lors de la mise au point d'un plug-in, il est courant d'expérimenter tous ces schémas différents de création d'image. Il peut s'avérer utile d'isoler la prise de décision concernant la création d'image dans une classe distincte et d'inciter tous les clients à utiliser la classe pour obtenir toutes les images. De cette façon, la séquence de création peut être réglée pour refléter les caractéristiques des performances réelles du plug-in. 

ResourceManager

La classe ResourceManager permet de conserver un mappage des ImageDescriptors et Images, de sorte qu'une image peut être réutilisée via son descripteur. Lorsqu'une image est demandée par son descripteur à partir du registre, ce dernier renvoie l'image si elle a été créée ou en crée une à partir du descripteur. Ceci permet aux clients du registre de partager les images.

Le ResourceManager de niveau supérieur est un DeviceResourceManager créé sur un Display. Le ResourceManager défini par JFaceResources.getResources() est un DeviceResourceManager et peut être utilisé comme ResourceManager de niveau supérieur. Si vous avez besoin d'un ResourceManager avec un cycle de vie plus court que le DeviceResourceManager, vous pouvez créer un LocalResourceManager en tant qu'enfant puis, le supprimer lorsque vous n'en avez plus besoin.

Un DeviceResourceManager est supprimé lorsque le Display utilisé pour le créer est supprimé, de sorte qu'aucun code de gestion spécial n'est requis.

Les images ajoutées au gestionnaire ou qui en sont extraites, ne doivent pas être supprimées par un client. Le gestionnaire est responsable de la suppression d'une image car les images sont partagées par plusieurs clients. Il supprime les images lorsque le ResourceManager qui s'y raccroche est supprimé.

Registre de polices

Les polices constituent une autre ressource limitée des systèmes d'exploitation de la plate-forme. La création et la suppression des polices sont identiques à celles des images, nécessitant des compromis de vitesse et d'espace similaires. En règle générale, les polices sont allouées dans SWT en demandant une police par le nom dépendant de la plate-forme.

La classe FontRegistry gère une table de polices par leurs noms. Elle gère l'attribution et la suppression de la police.

En règle générale, les plug-ins doivent éviter d'allouer ou de décrire des polices avec les noms spécifiques à la plate-forme. Bien que le registre de polices soit utilisé à l'intérieur de JFace, il n'est généralement pas utilisé par les plug-in. La classe JFaceResources doit être utilisée pour accéder aux polices courantes.

Il est très fréquent de permettre aux utilisateurs de spécifier leurs préférences pour les polices de l'application dans une page de préférences. Dans ce cas, la classe FontFieldEditor doit être utilisée pour obtenir le nom de la police de l'utilisateur et FontRegistry peut être utilisé pour conserver la police. La classe FontFieldEditor est utilisée uniquement dans les pages de préférences.

JFaceResources

La classe JFaceResources contrôle l'accès aux polices et aux images de plate-forme courantes. Elle gère un registre interne d'images et de polices, de sorte que les clients partagent les polices et les images désignées.

Il existe de nombreuses techniques utilisées dans le plan de travail et d'autres plug-in pour partager les images quand cela est nécessaire. Le registre d'images JFaceResources n'est pas largement utilisé dans le code du plug-in et du plan de travail.

L'utilisation des polices est beaucoup plus simple. Le plan de travail et la plupart des plug-ins utilisent la classe JFaceResources pour demander les polices par le nom logique. Des méthodes, telles que getDialogFont() et getDefaultFont() sont fournies de sorte que les plug-ins puissent utiliser les polices attendues dans leur interface utilisateur.