1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19 package org.apache.myfaces.shared.taglib;
20
21 import java.util.logging.Logger;
22
23 import javax.el.ELContext;
24 import javax.el.MethodExpression;
25 import javax.el.ValueExpression;
26 import javax.faces.component.ActionSource2;
27 import javax.faces.component.EditableValueHolder;
28 import javax.faces.component.UICommand;
29 import javax.faces.component.UIComponent;
30 import javax.faces.component.UIGraphic;
31 import javax.faces.component.UIParameter;
32 import javax.faces.component.UISelectBoolean;
33 import javax.faces.component.ValueHolder;
34 import javax.faces.context.FacesContext;
35 import javax.faces.convert.Converter;
36 import javax.faces.event.MethodExpressionActionListener;
37 import javax.faces.event.MethodExpressionValueChangeListener;
38 import javax.faces.validator.MethodExpressionValidator;
39
40
41
42
43 public class UIComponentELTagUtils
44 {
45
46 private static final Logger log = Logger
47 .getLogger(UIComponentELTagUtils.class.getName());
48
49 private UIComponentELTagUtils()
50 {
51 }
52
53
54
55
56 public static void setIntegerProperty(UIComponent component,
57 String propName, ValueExpression value)
58 {
59 setIntegerProperty(component, propName, value, null);
60 }
61
62
63
64
65 public static void setIntegerProperty(UIComponent component,
66 String propName, ValueExpression value, Integer defaultValue)
67 {
68 if (value != null)
69 {
70 if (value.isLiteralText())
71 {
72 component.getAttributes().put(propName,
73 Integer.valueOf(value.getExpressionString()));
74 }
75 else
76 {
77 component.setValueExpression(propName, value);
78 }
79 }
80 else
81 {
82 if (defaultValue != null)
83 {
84 component.getAttributes().put(propName, defaultValue);
85 }
86 }
87 }
88
89
90
91
92 public static void setLongProperty(UIComponent component, String propName,
93 ValueExpression value)
94 {
95 setLongProperty(component, propName, value, null);
96 }
97
98
99
100
101 public static void setLongProperty(UIComponent component, String propName,
102 ValueExpression value, Long defaultValue)
103 {
104 if (value != null)
105 {
106 if (value.isLiteralText())
107 {
108 component.getAttributes().put(propName,
109 Long.valueOf(value.getExpressionString()));
110 }
111 else
112 {
113 component.setValueExpression(propName, value);
114 }
115 }
116 else
117 {
118 if (defaultValue != null)
119 {
120 component.getAttributes().put(propName, defaultValue);
121 }
122 }
123 }
124
125
126
127
128 public static void setStringProperty(UIComponent component,
129 String propName, ValueExpression value)
130 {
131 setStringProperty(component, propName, value, null);
132 }
133
134
135
136
137 public static void setStringProperty(UIComponent component,
138 String propName, ValueExpression value, String defaultValue)
139 {
140 if (value != null)
141 {
142 if (value.isLiteralText())
143 {
144 component.getAttributes().put(propName,
145 value.getExpressionString());
146 }
147 else
148 {
149 component.setValueExpression(propName, value);
150 }
151 }
152 else
153 {
154 if (defaultValue != null)
155 {
156 component.getAttributes().put(propName, defaultValue);
157 }
158 }
159 }
160
161
162
163
164 public static void setBooleanProperty(UIComponent component,
165 String propName, ValueExpression value)
166 {
167 setBooleanProperty(component, propName, value, null);
168 }
169
170
171
172
173 public static void setBooleanProperty(UIComponent component,
174 String propName, ValueExpression value, Boolean defaultValue)
175 {
176 if (value != null)
177 {
178 if (value.isLiteralText())
179 {
180 component.getAttributes().put(propName,
181 Boolean.valueOf(value.getExpressionString()));
182 }
183 else
184 {
185 component.setValueExpression(propName, value);
186 }
187 }
188 else
189 {
190 if (defaultValue != null)
191 {
192 component.getAttributes().put(propName, defaultValue);
193 }
194 }
195 }
196
197
198
199
200 public static void setValueProperty(FacesContext context,
201 UIComponent component, ValueExpression value)
202 {
203 if (value != null)
204 {
205 if (!value.isLiteralText())
206 {
207 component.setValueExpression(
208 org.apache.myfaces.shared.renderkit.JSFAttr.VALUE_ATTR,
209 value);
210 }
211 else if (component instanceof UICommand)
212 {
213 ((UICommand) component).setValue(value.getExpressionString());
214 }
215 else if (component instanceof UIParameter)
216 {
217 ((UIParameter) component).setValue(value.getExpressionString());
218 }
219 else if (component instanceof UISelectBoolean)
220 {
221 ((UISelectBoolean) component).setValue(Boolean.valueOf(value
222 .getExpressionString()));
223 }
224 else if (component instanceof UIGraphic)
225 {
226 ((UIGraphic) component).setValue(value.getExpressionString());
227 }
228
229
230 else if (component instanceof ValueHolder)
231 {
232 ((ValueHolder) component).setValue(value.getExpressionString());
233 }
234 else
235 {
236 log.severe("Component " + component.getClass().getName()
237 + " is no ValueHolder, cannot set value.");
238 }
239 }
240 }
241
242
243
244
245 public static void setConverterProperty(FacesContext context,
246 UIComponent component, ValueExpression value)
247 {
248 if (value != null)
249 {
250 if (component instanceof ValueHolder)
251 {
252 if (value.isLiteralText())
253 {
254 FacesContext facesContext = FacesContext
255 .getCurrentInstance();
256 Converter converter = facesContext.getApplication()
257 .createConverter(value.getExpressionString());
258 ((ValueHolder) component).setConverter(converter);
259 }
260 else
261 {
262 component
263 .setValueExpression(
264 org.apache.myfaces.shared.renderkit.JSFAttr.CONVERTER_ATTR,
265 value);
266 }
267 }
268 else
269 {
270 log.severe("Component " + component.getClass().getName()
271 + " is no ValueHolder, cannot set value.");
272 }
273 }
274 }
275
276
277
278
279 public static void addValidatorProperty(FacesContext context,
280 UIComponent component, MethodExpression validator)
281 {
282 if (validator != null)
283 {
284 if (!(component instanceof EditableValueHolder))
285 {
286 throw new IllegalArgumentException("Component "
287 + component.getClientId(context)
288 + " is no EditableValueHolder");
289 }
290
291 ((EditableValueHolder) component)
292 .addValidator(new MethodExpressionValidator(validator));
293 }
294 }
295
296
297
298
299 public static void setValueBinding(FacesContext context,
300 UIComponent component, String propName, ValueExpression value)
301 {
302 if (value != null)
303 {
304 if (!value.isLiteralText())
305 {
306 component.setValueExpression(propName, value);
307 }
308 else
309 {
310 throw new IllegalArgumentException("Component "
311 + component.getClientId(context) + " attribute "
312 + propName + " must be a value reference, was " + value);
313 }
314 }
315 }
316
317
318
319
320 public static void setActionProperty(FacesContext context,
321 UIComponent component, MethodExpression action)
322 {
323 if (action != null)
324 {
325 if (!(component instanceof ActionSource2))
326 {
327 throw new IllegalArgumentException("Component "
328 + component.getClientId(context)
329 + " is no ActionSource2");
330 }
331
332 ((ActionSource2) component).setActionExpression(action);
333 }
334 }
335
336
337
338
339 public static void addActionListenerProperty(FacesContext context,
340 UIComponent component, MethodExpression actionListener)
341 {
342 if (actionListener != null)
343 {
344 if (!(component instanceof ActionSource2))
345 {
346 throw new IllegalArgumentException("Component "
347 + component.getClientId(context)
348 + " is no ActionSource");
349 }
350
351 ((ActionSource2) component)
352 .addActionListener(new MethodExpressionActionListener(
353 actionListener));
354 }
355 }
356
357
358
359
360 public static void addValueChangedListenerProperty(FacesContext context,
361 UIComponent component, MethodExpression valueChangedListener)
362 {
363 if (valueChangedListener != null)
364 {
365 if (!(component instanceof EditableValueHolder))
366 {
367 throw new IllegalArgumentException("Component "
368 + component.getClientId(context)
369 + " is no EditableValueHolder");
370 }
371
372 ((EditableValueHolder) component)
373 .addValueChangeListener(new MethodExpressionValueChangeListener(
374 valueChangedListener));
375 }
376 }
377
378
379
380
381 public static Object evaluateValueExpression(ELContext elContext,
382 ValueExpression valueExpression)
383 {
384 return valueExpression.isLiteralText() ? valueExpression
385 .getExpressionString() : valueExpression.getValue(elContext);
386 }
387
388
389
390
391 public static Boolean getBooleanValue(ELContext elContext,
392 ValueExpression valueExpression)
393 {
394 if (valueExpression.isLiteralText())
395 {
396 return Boolean.valueOf(valueExpression.getExpressionString());
397 }
398
399 return (Boolean) valueExpression.getValue(elContext);
400 }
401
402 public static Integer getIntegerValue(ELContext elContext,
403 ValueExpression valueExpression)
404 {
405 if (valueExpression.isLiteralText())
406 {
407 return Integer.valueOf(valueExpression.getExpressionString());
408 }
409
410 return (Integer) valueExpression.getValue(elContext);
411 }
412
413 }