Coverage Report

Coverage Report - org.apache.myfaces.taglib.core.ViewTag

Classes in this File

Line Coverage

Branch Coverage

Complexity

ViewTag

0/72

0/42

3.7

 /*
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  * to you under the Apache License, Version 2.0 (the
  * "License"); you may not use this file except in compliance
  * with the License.  You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  * KIND, either express or implied.  See the License for the
  * specific language governing permissions and limitations
  * under the License.
  */
 package org.apache.myfaces.taglib.core;
 
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 import org.apache.myfaces.application.jsp.ViewResponseWrapper;
 import org.apache.myfaces.shared_impl.util.LocaleUtils;
 
 import javax.el.ELContext;
 import javax.el.MethodExpression;
 import javax.el.ValueExpression;
 import javax.faces.FacesException;
 import javax.faces.component.UIComponent;
 import javax.faces.component.UIViewRoot;
 import javax.faces.context.FacesContext;
 import javax.faces.render.RenderKitFactory;
 import javax.faces.webapp.UIComponentELTag;
 import javax.servlet.jsp.JspException;
 import javax.servlet.jsp.jstl.core.Config;
 import java.io.IOException;
 import java.util.Locale;
 
 /**
  * @author Manfred Geiler (latest modification by $Author: skitching $)
  * @author Bruno Aranda (JSR-252)
  * @version $Revision: 684465 $ $Date: 2008-08-10 06:38:21 -0500 (Sun, 10 Aug 2008) $
  */
 public class ViewTag
         extends UIComponentELTag
 {
     private static final Log log = LogFactory.getLog(ViewTag.class);
 
     public String getComponentType()
     {
         return UIViewRoot.COMPONENT_TYPE;
     }
 
     public String getRendererType()
     {
         return null;
     }
 
     private ValueExpression _locale;
     private ValueExpression _renderKitId;
 
     private MethodExpression _beforePhase;
     private MethodExpression _afterPhase;
 
     public void setLocale(ValueExpression locale)
     {
         _locale = locale;
     }
 
     public void setRenderKitId(ValueExpression renderKitId)
     {
         _renderKitId = renderKitId;
     }
 
     public void setBeforePhase(MethodExpression beforePhase)
     {
         _beforePhase = beforePhase;
     }
 
     public void setAfterPhase(MethodExpression afterPhase)
     {
         _afterPhase = afterPhase;
     }
 
     public int doStartTag() throws JspException
     {
         if (log.isTraceEnabled()) log.trace("entering ViewTag.doStartTag");
 
         FacesContext facesContext = FacesContext.getCurrentInstance();
         Object response = facesContext.getExternalContext().getResponse();
         if (response instanceof ViewResponseWrapper)
         {
             try
             {
                 pageContext.getOut().flush();
                 ((ViewResponseWrapper) response).flushToWrappedResponse();
             }
             catch (IOException e)
             {
                 throw new JspException("Can't write content above <f:view> tag"
                         + " " + e.getMessage());
             }
         }
 
         int retVal = super.doStartTag();
 
         Config.set(pageContext.getRequest(),
                        Config.FMT_LOCALE,
                        facesContext.getViewRoot().getLocale());
 
         if (log.isTraceEnabled()) log.trace("leaving ViewTag.doStartTag");
         return retVal;
     }
 
     public int doEndTag() throws JspException
     {
         if (log.isTraceEnabled()) log.trace("entering ViewTag.doEndTag");
         int retVal = super.doEndTag();
 
         if (log.isTraceEnabled()) log.trace("leaving ViewTag.doEndTag");
         return retVal;
     }
 
     public int doAfterBody() throws JspException
     {
         if (log.isTraceEnabled()) log.trace("entering ViewTag.doAfterBody");
 
         UIComponent verbatimComp = createVerbatimComponentFromBodyContent();
         
         if (verbatimComp != null)
         {
             FacesContext.getCurrentInstance().getViewRoot().getChildren()
                 .add(verbatimComp);
         }
 
         if (log.isTraceEnabled()) log.trace("leaving ViewTag.doAfterBody");
         return EVAL_PAGE;
     }
 
     protected void setProperties(UIComponent component)
     {
         super.setProperties(component);
 
         FacesContext facesContext = FacesContext.getCurrentInstance();
         ELContext elContext = facesContext.getELContext();
 
         UIViewRoot viewRoot = (UIViewRoot) component;
 
         // locale
         if (_locale != null)
         {
             Locale locale;
             if (_locale.isLiteralText())
             {
                 locale = LocaleUtils.toLocale(_locale.getValue(elContext).toString());
             }
             else
             {
                 component.setValueExpression("locale", _locale);
 
                 Object localeValue = _locale.getValue(elContext);
                 
                 if (localeValue instanceof Locale)
                 {
                     locale = (Locale) localeValue;
                 }
                 else if (localeValue instanceof String)
                 {
                     locale = LocaleUtils.toLocale((String) localeValue);
                 }
                 else
                 {
                      if (localeValue != null)
                      {
                          throw new IllegalArgumentException(
                                  "Locale or String class expected. Expression: " + _locale
                                  + ". Return class: " + localeValue.getClass().getName());
                      }
 
                      throw new IllegalArgumentException(
                                  "Locale or String class expected. Expression: " + _locale
                                  + ". Return value null");
                 }
             }
             viewRoot.setLocale(locale);
             Config.set(pageContext.getRequest(),
                        Config.FMT_LOCALE,
                        locale);
         }
 
         // renderkitId
         if (_renderKitId != null)
         {
             if (_renderKitId.isLiteralText())
             {
                 viewRoot.setRenderKitId(_renderKitId.getValue(elContext).toString());
             }
             else
             {
                 viewRoot.setValueExpression("renderKitId", _renderKitId);
                 viewRoot.setRenderKitId(null);
             }
         }
         else if (viewRoot.getRenderKitId() == null)
         {
             String defaultRenderKitId = facesContext.getApplication().getDefaultRenderKitId();
 
             if (defaultRenderKitId != null)
             {
                 viewRoot.setRenderKitId(defaultRenderKitId);
             }
             else
             {
                 viewRoot.setRenderKitId(RenderKitFactory.HTML_BASIC_RENDER_KIT);
             }
         }
 
 
         // beforePhase
         if (_beforePhase != null)
         {
             if (_beforePhase.isLiteralText())
             {
                 throw new FacesException("Invalid method expression for attribute 'beforePhase' in the view tag: "
                         +_beforePhase.getExpressionString());
             }
             
             viewRoot.setBeforePhaseListener(_beforePhase);
             
         }
 
         // afterPhase
         if (_afterPhase != null)
         {
             if (_afterPhase.isLiteralText())
             {
                 throw new FacesException("Invalid method expression for attribute 'beforePhase' in the view tag: "
                         +_afterPhase.getExpressionString());
             }
             
             viewRoot.setAfterPhaseListener(_afterPhase);
             
         }
     }
 }

1		/*
2		* Licensed to the Apache Software Foundation (ASF) under one
3		* or more contributor license agreements. See the NOTICE file
4		* distributed with this work for additional information
5		* regarding copyright ownership. The ASF licenses this file
6		* to you under the Apache License, Version 2.0 (the
7		* "License"); you may not use this file except in compliance
8		* with the License. You may obtain a copy of the License at
9		*
10		* http://www.apache.org/licenses/LICENSE-2.0
11		*
12		* Unless required by applicable law or agreed to in writing,
13		* software distributed under the License is distributed on an
14		* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
15		* KIND, either express or implied. See the License for the
16		* specific language governing permissions and limitations
17		* under the License.
18		*/
19		package org.apache.myfaces.taglib.core;
20
21		import org.apache.commons.logging.Log;
22		import org.apache.commons.logging.LogFactory;
23		import org.apache.myfaces.application.jsp.ViewResponseWrapper;
24		import org.apache.myfaces.shared_impl.util.LocaleUtils;
25
26		import javax.el.ELContext;
27		import javax.el.MethodExpression;
28		import javax.el.ValueExpression;
29		import javax.faces.FacesException;
30		import javax.faces.component.UIComponent;
31		import javax.faces.component.UIViewRoot;
32		import javax.faces.context.FacesContext;
33		import javax.faces.render.RenderKitFactory;
34		import javax.faces.webapp.UIComponentELTag;
35		import javax.servlet.jsp.JspException;
36		import javax.servlet.jsp.jstl.core.Config;
37		import java.io.IOException;
38		import java.util.Locale;
39
40		/**
41		* @author Manfred Geiler (latest modification by $Author: skitching $)
42		* @author Bruno Aranda (JSR-252)
43		* @version $Revision: 684465 $ $Date: 2008-08-10 06:38:21 -0500 (Sun, 10 Aug 2008) $
44		*/
45	0	public class ViewTag
46		extends UIComponentELTag
47		{
48	0	private static final Log log = LogFactory.getLog(ViewTag.class);
49
50		public String getComponentType()
51		{
52	0	return UIViewRoot.COMPONENT_TYPE;
53		}
54
55		public String getRendererType()
56		{
57	0	return null;
58		}
59
60		private ValueExpression _locale;
61		private ValueExpression _renderKitId;
62
63		private MethodExpression _beforePhase;
64		private MethodExpression _afterPhase;
65
66		public void setLocale(ValueExpression locale)
67		{
68	0	_locale = locale;
69	0	}
70
71		public void setRenderKitId(ValueExpression renderKitId)
72		{
73	0	_renderKitId = renderKitId;
74	0	}
75
76		public void setBeforePhase(MethodExpression beforePhase)
77		{
78	0	_beforePhase = beforePhase;
79	0	}
80
81		public void setAfterPhase(MethodExpression afterPhase)
82		{
83	0	_afterPhase = afterPhase;
84	0	}
85
86		public int doStartTag() throws JspException
87		{
88	0	if (log.isTraceEnabled()) log.trace("entering ViewTag.doStartTag");
89
90	0	FacesContext facesContext = FacesContext.getCurrentInstance();
91	0	Object response = facesContext.getExternalContext().getResponse();
92	0	if (response instanceof ViewResponseWrapper)
93		{
94		try
95		{
96	0	pageContext.getOut().flush();
97	0	((ViewResponseWrapper) response).flushToWrappedResponse();
98		}
99	0	catch (IOException e)
100		{
101	0	throw new JspException("Can't write content above <f:view> tag"
102		+ " " + e.getMessage());
103	0	}
104		}
105
106	0	int retVal = super.doStartTag();
107
108	0	Config.set(pageContext.getRequest(),
109		Config.FMT_LOCALE,
110		facesContext.getViewRoot().getLocale());
111
112	0	if (log.isTraceEnabled()) log.trace("leaving ViewTag.doStartTag");
113	0	return retVal;
114		}
115
116		public int doEndTag() throws JspException
117		{
118	0	if (log.isTraceEnabled()) log.trace("entering ViewTag.doEndTag");
119	0	int retVal = super.doEndTag();
120
121	0	if (log.isTraceEnabled()) log.trace("leaving ViewTag.doEndTag");
122	0	return retVal;
123		}
124
125		public int doAfterBody() throws JspException
126		{
127	0	if (log.isTraceEnabled()) log.trace("entering ViewTag.doAfterBody");
128
129	0	UIComponent verbatimComp = createVerbatimComponentFromBodyContent();
130
131	0	if (verbatimComp != null)
132		{
133	0	FacesContext.getCurrentInstance().getViewRoot().getChildren()
134		.add(verbatimComp);
135		}
136
137	0	if (log.isTraceEnabled()) log.trace("leaving ViewTag.doAfterBody");
138	0	return EVAL_PAGE;
139		}
140
141		protected void setProperties(UIComponent component)
142		{
143	0	super.setProperties(component);
144
145	0	FacesContext facesContext = FacesContext.getCurrentInstance();
146	0	ELContext elContext = facesContext.getELContext();
147
148	0	UIViewRoot viewRoot = (UIViewRoot) component;
149
150		// locale
151	0	if (_locale != null)
152		{
153		Locale locale;
154	0	if (_locale.isLiteralText())
155		{
156	0	locale = LocaleUtils.toLocale(_locale.getValue(elContext).toString());
157		}
158		else
159		{
160	0	component.setValueExpression("locale", _locale);
161
162	0	Object localeValue = _locale.getValue(elContext);
163
164	0	if (localeValue instanceof Locale)
165		{
166	0	locale = (Locale) localeValue;
167		}
168	0	else if (localeValue instanceof String)
169		{
170	0	locale = LocaleUtils.toLocale((String) localeValue);
171		}
172		else
173		{
174	0	if (localeValue != null)
175		{
176	0	throw new IllegalArgumentException(
177		"Locale or String class expected. Expression: " + _locale
178		+ ". Return class: " + localeValue.getClass().getName());
179		}
180
181	0	throw new IllegalArgumentException(
182		"Locale or String class expected. Expression: " + _locale
183		+ ". Return value null");
184		}
185		}
186	0	viewRoot.setLocale(locale);
187	0	Config.set(pageContext.getRequest(),
188		Config.FMT_LOCALE,
189		locale);
190		}
191
192		// renderkitId
193	0	if (_renderKitId != null)
194		{
195	0	if (_renderKitId.isLiteralText())
196		{
197	0	viewRoot.setRenderKitId(_renderKitId.getValue(elContext).toString());
198		}
199		else
200		{
201	0	viewRoot.setValueExpression("renderKitId", _renderKitId);
202	0	viewRoot.setRenderKitId(null);
203		}
204		}
205	0	else if (viewRoot.getRenderKitId() == null)
206		{
207	0	String defaultRenderKitId = facesContext.getApplication().getDefaultRenderKitId();
208
209	0	if (defaultRenderKitId != null)
210		{
211	0	viewRoot.setRenderKitId(defaultRenderKitId);
212		}
213		else
214		{
215	0	viewRoot.setRenderKitId(RenderKitFactory.HTML_BASIC_RENDER_KIT);
216		}
217		}
218
219
220		// beforePhase
221	0	if (_beforePhase != null)
222		{
223	0	if (_beforePhase.isLiteralText())
224		{
225	0	throw new FacesException("Invalid method expression for attribute 'beforePhase' in the view tag: "
226		+_beforePhase.getExpressionString());
227		}
228
229	0	viewRoot.setBeforePhaseListener(_beforePhase);
230
231		}
232
233		// afterPhase
234	0	if (_afterPhase != null)
235		{
236	0	if (_afterPhase.isLiteralText())
237		{
238	0	throw new FacesException("Invalid method expression for attribute 'beforePhase' in the view tag: "
239		+_afterPhase.getExpressionString());
240		}
241
242	0	viewRoot.setAfterPhaseListener(_afterPhase);
243
244		}
245	0	}
246		}