Une application Web est souvent constituée de plusieurs écrans contenant chacun un formulaire. Il est courant d’avoir besoin de manipuler le mode d’affichage des champs de ces formulaires : ces champs peuvent par exemple tantôt être éditables tantôt non éditables, en fonction des actions effectuées par l’utilisateur.

L’objectif de cet article est de récapituler les principes d’utilisation des outils proposés par Struts-Layout permettant de gérer ces modes d’affichage.

Notons avant tout qu’on distingue deux types de modes d’affichage pour un formulaire donné :

• le mode d’affichage du formulaire
• le mode d’affichage des champs de ce formulaire

Chaque champ d’un formulaire possède un mode d’affichage : par exemple, une zone de saisie de texte peut-être en mode édition ou en mode lecture seule. Il y a 8 modes d’affichage possibles :

• EDIT (E)
• INSPECT (I)
• HIDDEN (H)
• NODISPLAY (N)
• INSPECT_ONLY (S)
• INSPECT_PRESENT (P)
• DISABLED (D)
• READONLY (R)

Il est possible de changer le mode d’affichage d’un champ particulier, de plusieurs manières qui sont présentées dans la suite de cet article.

La notion de mode d’affichage des formulaires permet de spécifier si le formulaire doit être affiché avec l’optique de créer, modifier ou consulter des informations. Ainsi, cette notion permet de définir le mode d’affichage des champs d’un formulaire en fonction du mode d’affichage de ce formulaire.

Un formulaire peut prendre 3 modes d’affichage :

• CREATE
• EDIT
• INSPECT

Dans cette partie nous présentons les différentes façons de manipuler le mode d’affichage d’un champ particulier d’un formulaire.

Un formulaire est composé de champs de saisie dont on peut indiquer le mode d’affichage par défaut pour chaque mode d’affichage du formulaire (via l’attribut mode) :

<layout:form>
   <layout:text property="login" mode="E,E,R" />
</layout:form>

Dans l’exemple ci-dessus, le champ login sera par défaut éditable si le formulaire est en mode CREATE ou EDIT, mais sera en lecture seule si le formulaire est en mode INSPECT.

En effet, d’une manière générale, le format de l’attribut mode d’un champ est : X,Y,Z, où :

• X est le mode d’affichage du champ lorsque le formulaire est en mode CREATE
• Y est le mode d’affichage du champ lorsque le formulaire est en mode EDIT
• Z est le mode d’affichage du champ lorsque le formulaire est en mode INSPECT

Il s’agit là d’un moyen simple pour contrôler le mode d’affichage des formulaires et de leurs champs. Mais il s’agit là d’un moyen statique, qui ne permet donc pas de changer le mode d’affichage du champ en fonction de certains critères (droits d’accès de l’utilisateur par exemple).

Il est également possible de changer dynamiquement le mode d’affichage d’un champ, depuis une action Struts par exemple.

Il suffit d’appeler la méthode setFieldDisplayMode(in_request, in_form, in_fieldName, in_mode) de la classe fr.improve.struts.taglib.layout.util.FormUtils.

Notons que cette méthode stocke le mode d’affichage du champ au niveau de la session.

Dans cette partie nous présentons les différentes façons de manipuler le mode d’affichage d’un formulaire.

Il suffit d’appeler la méthode setFormDisplayMode(in_request, in_form, in_mode) de la classe fr.improve.struts.taglib.layout.util.FormUtils.

Notons que cette méthode stocke le mode d’affichage du formulaire au niveau de la session.

Présentons désormais comment mettre en oeuvre une politique fine des modes d’affichage.

Lors de l’affichage d’un tag <layout> représentant un champ, Struts-Layout appelle automatiquement la méthode getFieldDisplayMode(in_pageContext, in_fieldName) d’une certaine classe afin de déterminer quel mode d’affichage à appliquer. Cette classe est nommée FormUtils.

Prenons un exemple classique. On souhaite mettre en oeuvre la politique d’affichage suivante :

• si le formulaire est en mode CREATE ou EDIT, alors on interroge une méthode dédiée du formulaire afin de savoir quel mode d’affichage appliquer pour le champ
• si le formulaire est en mode INSPECT, le champ doit être affiché en mode INSPECT.

Pour ce faire, on procède en deux étapes.

Tous les formulaires Struts étendent la classe org.apache.struts.action.ActionForm.

Au lieu de faire hériter directement de cette classe tous nos formulaires, faisons-les hériter d’une classe qu’on nommera MyForm.

Cette classe doit :

• étendre la classe org.apache.struts.action.ActionForm
• définir une méthode qu’on nommera getFieldDisplayMode(in_fieldName) dont le rôle est de déterminer le mode d’affichage d’un champ du formulaire dont on lui passe le nom en paramètre. En pratique, cette méthode sera appelée par le FormUtils.

En voici la forme :

public class MyForm extends ActionForm {
   protected static final short MODE_DEFAULT   = -1;
   protected static final short MODE_EDIT      = AbstractModeFieldTag.MODE_EDIT;
   protected static final short MODE_HIDDEN    = AbstractModeFieldTag.MODE_HIDDEN;
   protected static final short MODE_INSPECT   = AbstractModeFieldTag.MODE_INSPECT;
   protected static final short MODE_READONLY  = AbstractModeFieldTag.MODE_READONLY;
   protected static final short MODE_DISABLED  = AbstractModeFieldTag.MODE_DISABLED;
   protected static final short MODE_NODISPLAY = AbstractModeFieldTag.MODE_NODISPLAY;
 
   public short getFieldDisplayMode(String in_fieldName) {
      return MODE_DEFAULT;
   }
}

Prenons comme exemple un formulaire nommé MyLoginForm contenant un champ nommé “login”, qui doit toujours être caché :

public class MyLoginForm extends MyForm {
 
   protected String login;
 
   public String getLogin() {
      return this.login;
   }
 
   public String setLogin(String in_login) {
      this.login = in_login;
   }
 
   public short getFieldDisplayMode(String in_fieldName) {
 
      if ("login".equals(in_fieldName)) {
         return MODE_HIDDEN;					
      }
      
      return super.getFieldDisplayMode(in_fieldName);
   
   }
   
}

Autre exemple, où le champ “login” doit être éditable si un certain champ “topLogin” vaut true et doit être non éditable sinon :

public class MyLoginForm2 extends MyForm {
 
   protected String login;
 
   public String getLogin() {
      return this.login;
   }
 
   public String setLogin(String in_login) {
      this.login = in_login;
   }
 
   public short getFieldDisplayMode(String in_fieldName) {
 
      if ("login".equals(in_fieldName)) {
         if (topLogin) {
            return MODE_EDIT;					
         }
         else {
            return MODE_READONLY;					
         }
      }
      
      return super.getFieldDisplayMode(in_fieldName);
   
   }
   
}

Il s’agit d’écrire une classe, qu’on nommera fr.test.MyFormUtils, qui doit :

• étendre la classe fr.improve.struts.taglib.layout.util.BasicFormUtils
• être référencée dans le fichier de configuration de Struts-Layout (par défaut, Struts-Layout_default.properties), de la manière suivante :

formutils.class = fr.test.MyFormUtils
 

Il reste donc à implémenter la méthode getFieldDisplayMode(in_pageContext, in_fieldName) selon la politique souhaitée :

public class MyFormUtils extends BasicFormUtils  {
	
   public Integer getFieldDisplayMode(PageContext in_pageContext, String in_fieldName) {
		
      // Récupération du formulaire     
      Object lc_object = in_pageContext.findAttribute(Constants.BEAN_KEY);
	
      MyForm lc_form = (MyForm) lc_object;
		
      // Récupération du mode d'affichage du formulaire      
      int lc_formMode = FormUtils.getFormDisplayMode(in_pageContext);
		
      if (lc_formMode == FormUtils.CREATE_MODE || lc_formMode == FormUtils.EDIT_MODE) {	
         // Récupération du mode d'affichage du champ
         short lc_fieldMode = lc_form.getFieldDisplayMode(in_fieldName);	
         if (lc_fieldMode == MyForm.MODE_DEFAULT) {
            return super.getFieldDisplayMode(in_pageContext, in_fieldName);
         } 
	 else {
            return new Integer(lc_fieldMode);
         }
      } 
		
      else { // if (lc_formMode == FormUtils.INSPECT_MODE) {
         return new Integer(MyForm.MODE_INSPECT);
      } 
   
   }
 
}

On notera que par défaut, si on ne crée pas de classe comme MyFormUtils, c’est la classe mère FormUtils fournie qui sera appelée.

Le moyen présenté dans la partie précédente permet de contrôler assez facilement le mode d’affichage d’un champ du formulaire de manière dynamique.

Lors de leur interprétation, la plupart des tags de champs de saisie interrogent la méthode getFieldDisplayMode(in_fieldName) afin de savoir quel mode d’affichage utiliser.

Cependant, il existe des tags qui n’appellent pas cette méthode : le tag <layout:collectionInput>, par exemple. Alors, comment contrôler leur mode d’affichage de ces champs là ?

Pour ce faire, il suffit de renseigner l’attribut policy du tag en lui donnant le nom d’une politique d’affichage que l’on va définir dans la méthode getAuthorizedDisplayMode(in_policy, in_name, in_property, in_pageContext) d’une classe définie à cet effet. Cette classe, qu’on nommera par exemple fr.test.MyPolicy, doit :

• étendre la classe fr.improve.struts.taglib.layout.policy.AbstractPolicy
• être référencée dans le fichier de configuration de Struts-Layout (par défaut, Struts-Layout_default.properties), de la manière suivante :

policy.class = fr.test.MyPolicy
 

Si l’attribut policy est renseigné, cette méthode sera automatiquement appelée lors de l’interprétation du tag, et le nom de la politique sera transmis en paramètre (paramètre in_policy). La propriété associée au tag sera indiquée par le paramètre in_property.

Le code de cette méthode est de la même forme que celui de la méthode exposée dans la partie précédente.