KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > fr > improve > struts > taglib > layout > util > FormUtils


1 /*
2  * (c) Copyright 2001 Improve SA.
3  * All Rights Reserved.
4  */

5 package fr.improve.struts.taglib.layout.util;
6
7 import java.util.ArrayList JavaDoc;
8 import java.util.HashMap JavaDoc;
9 import java.util.List JavaDoc;
10 import java.util.Map JavaDoc;
11 import java.util.StringTokenizer JavaDoc;
12
13 import javax.servlet.http.HttpServletRequest JavaDoc;
14 import javax.servlet.http.HttpSession JavaDoc;
15 import javax.servlet.jsp.PageContext JavaDoc;
16
17 import org.apache.struts.action.ActionForm;
18 import org.apache.struts.taglib.html.Constants;
19
20 import fr.improve.struts.taglib.layout.field.AbstractModeFieldTag;
21
22 /**
23  * Utility methods to deal with form and field.
24  *
25  * @version 1.0
26  * @author
27  */

28 public class FormUtils {
29     /**
30      * Key of the map storing the form display modes.
31      */

32     private static final String JavaDoc FORM_MODE_KEY = "fr.improve.struts.taglib.layout.util.FormUtils.FORM_MODE_KEY";
33     
34     /**
35      * Key of the map storing the user form modes.
36      */

37     private static final String JavaDoc USER_FORM_MODE_KEY = "fr.improve.struts.taglib.layout.util.FormUtils.USER_FORM_MODE_KEY";
38
39     public static final int CREATE_MODE = 0;
40     public static final int EDIT_MODE = 1;
41     public static final int INSPECT_MODE = 2;
42     
43     /**
44      * Key of the map storing the field styleClasses.
45      */

46     private static final String JavaDoc FIELD_STYLECLASS_KEY = "fr.improve.struts.taglib.layout.util.FormUtils.FIELD_STYLECLASS_KEY";
47
48     /**
49      * Key of the map storing the field mode display.
50      */

51     private static final String JavaDoc FIELD_MODE_KEY = "fr.improve.struts.taglib.layout.util.FormUtils.FIELD_MODE_KEY";
52
53     /**
54      * Key of the map storing the label field styles.
55      */

56     private static final String JavaDoc FIELD_STYLE_KEY = "fr.improve.struts.taglib.layout.util.FormUtils.FIELD_STYLE_KEY";
57     
58     /**
59      * Key of the list storing the value field styles.
60      */

61     private static final String JavaDoc FIELD_VALUES_STYLE_KEY = "fr.improve.struts.taglib.layout.util.FormUtils.FIELD_VALUES_STYLE_KEY";
62
63     /**
64      * Utility method to get the form display modes.
65      */

66     private static Map JavaDoc getFormModes(HttpSession JavaDoc in_session) {
67         if (in_session==null) {
68             return new HashMap JavaDoc();
69         }
70         Map JavaDoc lc_map = (Map JavaDoc) in_session.getAttribute(FORM_MODE_KEY);
71         if (lc_map==null) {
72             lc_map = new HashMap JavaDoc();
73             in_session.setAttribute(FORM_MODE_KEY, lc_map);
74         }
75         return lc_map;
76     }
77     
78     /**
79      * Utility method to get the field display modes.
80      */

81     private static Map JavaDoc getFieldModes(HttpSession JavaDoc in_session, ActionForm in_form) {
82         Map JavaDoc lc_mapForm = null;
83         if (in_session!=null) {
84             lc_mapForm = (Map JavaDoc) in_session.getAttribute(FIELD_MODE_KEY);
85         }
86         if (lc_mapForm == null) {
87             lc_mapForm = new HashMap JavaDoc();
88             if (in_session!=null) {
89                 in_session.setAttribute(FIELD_MODE_KEY, lc_mapForm);
90             }
91         }
92         Map JavaDoc lc_mapField = (Map JavaDoc) lc_mapForm.get(in_form.getClass());
93         if (lc_mapField == null) {
94             lc_mapField = new HashMap JavaDoc();
95             lc_mapForm.put(in_form.getClass(), lc_mapField);
96         }
97         return lc_mapField;
98     }
99     
100     /**
101      * Set the form display mode.
102      * Used in user's Action class.
103      */

104     public static void setFormDisplayMode(HttpServletRequest JavaDoc in_request, ActionForm in_form, int in_mode) {
105         if (in_form==null) {
106             throw new IllegalArgumentException JavaDoc("in_form cannot be null");
107         }
108         Map JavaDoc lc_map = getFormModes(in_request.getSession());
109         lc_map.put(in_form.getClass(), new Integer JavaDoc(in_mode));
110         
111         //in_request.getSession().setAttribute(FORM_MODE_KEY,new Integer(in_mode));
112
}
113     
114     /**
115      * Set theform display mode to a user defined mode.
116      *
117      */

118     public static void setFormDisplayMode(HttpServletRequest JavaDoc in_request, ActionForm in_form, String JavaDoc in_mode) {
119         if (in_form==null) {
120             throw new IllegalArgumentException JavaDoc("in_form cannot be null");
121         }
122         if (in_mode==null || in_mode.trim().length()==0) {
123             throw new IllegalArgumentException JavaDoc("in_mode cannot be null or empty");
124         }
125         Map JavaDoc lc_map = getFormModes(in_request.getSession());
126         Integer JavaDoc lc_int = getUserFormMode(in_request, in_mode);
127         lc_map.put(in_form.getClass(), lc_int);
128     }
129     
130     private static Integer JavaDoc getUserFormMode(HttpServletRequest JavaDoc in_request, String JavaDoc in_mode) {
131         Map JavaDoc lc_map = (Map JavaDoc) in_request.getSession().getAttribute(USER_FORM_MODE_KEY);
132         if (lc_map==null) {
133             lc_map = new HashMap JavaDoc();
134             lc_map.put("create", new Integer JavaDoc(CREATE_MODE));
135             lc_map.put("edit", new Integer JavaDoc(EDIT_MODE));
136             lc_map.put("inspect", new Integer JavaDoc(INSPECT_MODE));
137             in_request.getSession().setAttribute(USER_FORM_MODE_KEY, lc_map);
138         }
139         Integer JavaDoc lc_int = (Integer JavaDoc) lc_map.get(in_mode);
140         if (lc_int==null) {
141             lc_int = new Integer JavaDoc(lc_map.size());
142             lc_map.put(in_mode, lc_int);
143         }
144         return lc_int;
145     }
146         
147     /**
148      * Set the field display mode.
149      * Used in user's Action class.
150      */

151     public static void setFieldDisplayMode(HttpServletRequest JavaDoc in_request, ActionForm in_form, String JavaDoc in_fieldName, int in_mode) {
152         if (in_form == null) {
153             throw new IllegalArgumentException JavaDoc("in_form cannot be null");
154         }
155         if (in_fieldName == null) {
156             throw new IllegalArgumentException JavaDoc("in_fieldName cannot be null");
157         }
158         Map JavaDoc lc_field = getFieldModes(in_request.getSession(), in_form);
159         lc_field.put(in_fieldName, new Integer JavaDoc(in_mode));
160     }
161     
162     /**
163      * Get the form display mode
164      */

165     public static int getFormDisplayMode(PageContext JavaDoc in_page) {
166         Object JavaDoc lc_form = in_page.findAttribute(Constants.BEAN_KEY);
167         if (lc_form == null) {
168             // defaut display mode is EDIT.
169
return EDIT_MODE;
170         }
171         return getFormDisplayMode(in_page.getSession(), (ActionForm) lc_form);
172     }
173     
174     /**
175      * Get the field display mode
176      */

177     public static Integer JavaDoc getFieldDisplayMode(PageContext JavaDoc in_page, String JavaDoc in_fieldName) {
178         Object JavaDoc lc_form = in_page.findAttribute(Constants.BEAN_KEY);
179         if (lc_form == null) {
180             // no default value
181
return null;
182         }
183         return getFieldDisplayMode(in_page.getSession(), (ActionForm) lc_form, in_fieldName);
184     }
185     
186     /**
187      * Get the form display mode
188      */

189     public static int getFormDisplayMode(HttpServletRequest JavaDoc in_request, ActionForm in_form) {
190         return getFormDisplayMode(in_request.getSession(), in_form);
191     }
192     
193     /**
194      * Get the field display mode
195      */

196     public static Integer JavaDoc getFieldDisplayMode(HttpServletRequest JavaDoc in_request, ActionForm in_form, String JavaDoc in_fieldName) {
197         return getFieldDisplayMode(in_request.getSession(), in_form, in_fieldName);
198     }
199     
200     /**
201      * Get the form display mode
202      */

203     protected static int getFormDisplayMode(HttpSession JavaDoc in_session, ActionForm in_form) {
204         Map JavaDoc lc_map = getFormModes(in_session);
205         if (in_form==null) {
206             // defaut display mode is EDIT.
207
return EDIT_MODE;
208         }
209         Integer JavaDoc lc_mode = (Integer JavaDoc) lc_map.get(in_form.getClass());
210         if (lc_mode==null) {
211             // defaut display mode is EDIT.
212
return EDIT_MODE;
213         }
214         return lc_mode.intValue();
215     }
216
217     /**
218      * Get the field display mode
219      */

220     protected static Integer JavaDoc getFieldDisplayMode(HttpSession JavaDoc in_session, ActionForm in_form, String JavaDoc in_fieldName) {
221         if (in_form == null) {
222             // no default value
223
return null;
224         }
225         if (in_fieldName == null) {
226             // no default value
227
return null;
228         }
229         Map JavaDoc lc_map = getFieldModes(in_session, in_form);
230         Integer JavaDoc lc_mode = (Integer JavaDoc) lc_map.get(in_fieldName);
231         if (lc_mode == null) {
232             // no default value
233
return null;
234         }
235         return lc_mode;
236     }
237     /**
238      * Compute a field display mode.
239      * Used in custom tags
240      */

241     public static short computeFieldDisplayMode(PageContext JavaDoc in_pageContext, String JavaDoc in_mode) {
242         int lc_formMode = getFormDisplayMode(in_pageContext);
243         if (in_mode==null) {
244             throw new IllegalArgumentException JavaDoc("The specified mode is null");
245         }
246         if (in_mode.indexOf(':')==-1) {
247             // Old format create/edit/inspect
248
if (lc_formMode>=3) {
249                 // Default mode is inspect for user defined mode.
250
return AbstractModeFieldTag.MODE_INSPECT;
251             } else {
252                 int lc_modePosition = lc_formMode*2;
253                 if (in_mode.length()<lc_modePosition) {
254                     throw new IllegalArgumentException JavaDoc("Bad form / field display mode (" + lc_formMode + ";" + in_mode);
255                 }
256                 char lc_char = in_mode.charAt(lc_modePosition);
257                 switch (Character.toUpperCase(lc_char)) {
258                     case 'E': return AbstractModeFieldTag.MODE_EDIT;
259                     case 'I': return AbstractModeFieldTag.MODE_INSPECT;
260                     case 'H': return AbstractModeFieldTag.MODE_HIDDEN;
261                     case 'N': return AbstractModeFieldTag.MODE_NODISPLAY;
262                     case 'S': return AbstractModeFieldTag.MODE_INSPECT_ONLY;
263                     case 'P': return AbstractModeFieldTag.MODE_INSPECT_PRESENT;
264                     case 'R': return AbstractModeFieldTag.MODE_READONLY;
265                     case 'D': return AbstractModeFieldTag.MODE_DISABLED;
266                     case 'C' : return AbstractModeFieldTag.MODE_CELL;
267                 }
268                 throw new IllegalArgumentException JavaDoc("Bad field display mode " + lc_char);
269             }
270         } else{
271             // New format mode:value,mode:value,...
272
StringTokenizer JavaDoc tokenizer = new StringTokenizer JavaDoc(in_mode, ",;:");
273             while (tokenizer.hasMoreTokens()) {
274                 String JavaDoc lc_mode = tokenizer.nextToken();
275                 if (!tokenizer.hasMoreTokens()) {
276                     throw new IllegalArgumentException JavaDoc("The specified mode " + in_mode + " is invalid.");
277                 }
278                 String JavaDoc lc_fieldMode = tokenizer.nextToken();
279                 if (((Integer JavaDoc)getUserFormMode((HttpServletRequest JavaDoc)in_pageContext.getRequest(), lc_mode)).intValue()==lc_formMode) {
280                     switch (Character.toUpperCase(lc_fieldMode.charAt(0))) {
281                     case 'E': return AbstractModeFieldTag.MODE_EDIT;
282                     case 'I': return AbstractModeFieldTag.MODE_INSPECT;
283                     case 'H': return AbstractModeFieldTag.MODE_HIDDEN;
284                     case 'N': return AbstractModeFieldTag.MODE_NODISPLAY;
285                     case 'S': return AbstractModeFieldTag.MODE_INSPECT_ONLY;
286                     case 'P': return AbstractModeFieldTag.MODE_INSPECT_PRESENT;
287                     case 'R': return AbstractModeFieldTag.MODE_READONLY;
288                     case 'D': return AbstractModeFieldTag.MODE_DISABLED;
289                     case 'C' : return AbstractModeFieldTag.MODE_CELL;
290                 }
291                 }
292             }
293             // Mode is not specified, return correct default value.
294
switch (lc_formMode) {
295                 case CREATE_MODE:
296                 case EDIT_MODE:
297                     return AbstractModeFieldTag.MODE_EDIT;
298                 default:
299                     return AbstractModeFieldTag.MODE_INSPECT;
300             }
301         }
302     }
303     
304     /**
305      * Compute a tag visibility.
306      * Used in custom tags.
307      */

308     public static int computeVisibilityMode(PageContext JavaDoc in_pageContext, String JavaDoc in_mode) {
309         int lc_formMode = getFormDisplayMode(in_pageContext);
310         char lc_visible = 'N';
311         if (in_mode == null) {
312             throw new IllegalArgumentException JavaDoc("The specified mode is null");
313         }
314         if (in_mode.indexOf(':')==-1) {
315             // Old format.
316
if(lc_formMode>=3) {
317                 // Default mode is not visible.
318
return AbstractModeFieldTag.MODE_NODISPLAY;
319             } else {
320                 if (in_mode == null || in_mode.length() != 5) {
321                     throw new IllegalArgumentException JavaDoc(
322                         "The specified mode" + in_mode + " is invalid");
323                 }
324                 char lc_displayMode;
325                 switch (lc_formMode) {
326                     case FormUtilsInterface.CREATE_MODE :
327                         lc_displayMode = in_mode.charAt(0);
328                         break;
329                     case FormUtilsInterface.EDIT_MODE :
330                         lc_displayMode = in_mode.charAt(2);
331                         break;
332                     case FormUtilsInterface.INSPECT_MODE :
333                         lc_displayMode = in_mode.charAt(4);
334                         break;
335                     default :
336                         lc_displayMode = 'D';
337                 }
338                 lc_visible = lc_displayMode;
339             }
340         } else {
341             // Get the current mode..
342
StringTokenizer JavaDoc tokenizer = new StringTokenizer JavaDoc(in_mode, ",;:");
343             while (tokenizer.hasMoreTokens()) {
344                 String JavaDoc lc_mode = tokenizer.nextToken();
345                 if (!tokenizer.hasMoreTokens()) {
346                     throw new IllegalArgumentException JavaDoc("The specified mode " + in_mode + " is invalid.");
347                 }
348                 String JavaDoc lc_visibility = tokenizer.nextToken();
349                 if (((Integer JavaDoc)getUserFormMode((HttpServletRequest JavaDoc)in_pageContext.getRequest(), lc_mode)).intValue()==lc_formMode) {
350                     lc_visible = lc_visibility.charAt(0);
351                     break;
352                 }
353             }
354         }
355         
356         if (lc_visible=='D'||lc_visible=='d') {
357             return AbstractModeFieldTag.MODE_EDIT;
358         } else if (lc_visible=='F' || lc_visible=='f') {
359             return AbstractModeFieldTag.MODE_DISABLED;
360         } else if (lc_visible=='C' || lc_visible=='c') {
361             return AbstractModeFieldTag.MODE_CELL;
362         }
363         return AbstractModeFieldTag.MODE_NODISPLAY;
364     }
365     
366     private static Map JavaDoc getFieldStyleClass(HttpServletRequest JavaDoc in_request) {
367         Map JavaDoc lc_map = (Map JavaDoc) in_request.getAttribute(FIELD_STYLECLASS_KEY);
368         if (lc_map==null) {
369             lc_map = new HashMap JavaDoc();
370             in_request.setAttribute(FIELD_STYLECLASS_KEY, lc_map);
371         }
372         return lc_map;
373     }
374     
375     
376     private static Map JavaDoc getFieldStyle(HttpServletRequest JavaDoc in_request) {
377         Map JavaDoc lc_map = (Map JavaDoc) in_request.getAttribute(FIELD_STYLE_KEY);
378         if (lc_map==null) {
379             lc_map = new HashMap JavaDoc();
380             in_request.setAttribute(FIELD_STYLE_KEY, lc_map);
381         }
382         return lc_map;
383     }
384     
385     /**
386      * Override a field styleClass.
387      * Used in user's Action class.
388      */

389     public static void setFieldStyleClass(HttpServletRequest JavaDoc in_request, String JavaDoc in_fieldName, String JavaDoc in_styleClass) {
390         getFieldStyleClass(in_request).put(in_fieldName, in_styleClass);
391     }
392     
393     /**
394      * Override a field style.
395      * Used in user's Action class.
396      */

397     public static void setFieldStyle(HttpServletRequest JavaDoc in_request, String JavaDoc in_fieldName, String JavaDoc in_style) {
398         getFieldStyle(in_request).put(in_fieldName, in_style);
399     }
400
401     /**
402      * Get a field styleClass.
403      * Used in custom tags.
404      */

405     public static String JavaDoc getFieldStyleClass(PageContext JavaDoc in_pageContext, String JavaDoc in_fieldName) {
406         return (String JavaDoc) getFieldStyleClass((HttpServletRequest JavaDoc)in_pageContext.getRequest()).get(in_fieldName);
407     }
408     
409     /**
410      * Get a field style.
411      * Used in custom tags.
412      */

413     public static String JavaDoc getFieldStyle(PageContext JavaDoc in_pageContext, String JavaDoc in_fieldName) {
414         return (String JavaDoc) getFieldStyle((HttpServletRequest JavaDoc)in_pageContext.getRequest()).get(in_fieldName);
415     }
416     
417     /**
418      * Get the style for the current field value.
419      */

420     public static String JavaDoc getFieldValueStyle(PageContext JavaDoc in_pageContext) {
421         List JavaDoc lc_list = (List JavaDoc) in_pageContext.getRequest().getAttribute(FIELD_VALUES_STYLE_KEY);
422         if (lc_list==null || lc_list.isEmpty()) {
423             return "";
424         } else {
425             StringBuffer JavaDoc lc_style = new StringBuffer JavaDoc();
426             for (int i=0;i< lc_list.size();i++) {
427                     lc_style.append(lc_list.get(i));
428             }
429             return lc_style.toString();
430         }
431     }
432     
433     public static void addFieldValueStyle(PageContext JavaDoc in_pageContext, String JavaDoc in_style) {
434         List JavaDoc lc_list = (List JavaDoc) in_pageContext.getRequest().getAttribute(FIELD_VALUES_STYLE_KEY);
435         if (lc_list==null) {
436             lc_list = new ArrayList JavaDoc();
437             in_pageContext.getRequest().setAttribute(FIELD_VALUES_STYLE_KEY, lc_list);
438         }
439         lc_list.add(in_style);
440     }
441     public static void removeFieldValueStyle(PageContext JavaDoc in_pageContext) {
442         List JavaDoc lc_list = (List JavaDoc) in_pageContext.getRequest().getAttribute(FIELD_VALUES_STYLE_KEY);
443         lc_list.remove(lc_list.size()-1);
444     }
445
446 }
447
Popular Tags