Coverage Report

Coverage Report - org.apache.myfaces.shared.renderkit.html.HtmlMessageRendererBase

Classes in this File

Line Coverage

Branch Coverage

Complexity

HtmlMessageRendererBase

0/157

0/120

5.125

 /*
  * 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.shared.renderkit.html;
 
 import java.io.IOException;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 import java.util.logging.Logger;
 
 import javax.faces.application.FacesMessage;
 import javax.faces.component.UIComponent;
 import javax.faces.component.UIMessage;
 import javax.faces.component.UIViewRoot;
 import javax.faces.component.behavior.ClientBehavior;
 import javax.faces.component.behavior.ClientBehaviorHolder;
 import javax.faces.component.html.HtmlMessage;
 import javax.faces.context.FacesContext;
 import javax.faces.context.ResponseWriter;
 
 import org.apache.myfaces.shared.renderkit.JSFAttr;
 import org.apache.myfaces.shared.renderkit.RendererUtils;
 
 public abstract class HtmlMessageRendererBase
         extends HtmlRenderer
 {
     //private static final Log log = LogFactory.getLog(HtmlMessageRendererBase.class);
     private static final Logger log = Logger.getLogger(HtmlMessageRendererBase.class.getName());
 
     protected abstract String getSummary(FacesContext facesContext,
                                          UIComponent message,
                                          FacesMessage facesMessage,
                                          String msgClientId);
 
     protected abstract String getDetail(FacesContext facesContext,
                                         UIComponent message,
                                         FacesMessage facesMessage,
                                         String msgClientId);
 
 
     protected void renderMessage(FacesContext facesContext,
                                  UIComponent message)
             throws IOException
     {
         renderMessage(facesContext, message, false);
     }
 
     protected void renderMessage(FacesContext facesContext, UIComponent message, 
             boolean alwaysRenderSpan) throws IOException
     {
         renderMessage(facesContext, message, alwaysRenderSpan, false);
     }
     
     /**
      * @param facesContext
      * @param message
      * @param alwaysRenderSpan if true will render a span even if there is no message
      */
     protected void renderMessage(FacesContext facesContext, UIComponent message, 
             boolean alwaysRenderSpan, boolean renderDivWhenNoMessagesAndIdSet) throws IOException
     {
         String forAttr = getFor(message);
         if (forAttr == null)
         {
             log.severe("Attribute 'for' of UIMessage must not be null");
             return;
         }
 
         UIComponent forComponent = message.findComponent(forAttr);
         if (forComponent == null)
         {
             log.severe("Could not render Message. Unable to find component '" 
                     + forAttr + "' (calling findComponent on component '" 
                     + message.getClientId(facesContext) 
                     + "'). If the provided id was correct, wrap the message and its " 
                     + "component into an h:panelGroup or h:panelGrid.");
             return;
         }
 
         String clientId = forComponent.getClientId(facesContext);
 
         Iterator<FacesMessage> messageIterator = facesContext.getMessages(clientId);
         if (!messageIterator.hasNext())
         {
             // No associated message, nothing to render
             if (alwaysRenderSpan)
             {
                 ResponseWriter writer = facesContext.getResponseWriter();
                 writer.startElement(HTML.SPAN_ELEM, message);
                 writer.writeAttribute(HTML.ID_ATTR, clientId + "_msgFor", null);
                 HtmlRendererUtils.renderHTMLStringAttribute(writer, message, JSFAttr.STYLE_ATTR, HTML.STYLE_ATTR);
                 HtmlRendererUtils.renderHTMLStringAttribute(writer, message, JSFAttr.STYLE_CLASS_ATTR, HTML.CLASS_ATTR);
                 writer.endElement(HTML.SPAN_ELEM);
             }
             else if (renderDivWhenNoMessagesAndIdSet && message.getId() != null && 
                     !message.getId().startsWith(UIViewRoot.UNIQUE_ID_PREFIX))
             {
                 // show span anyways in case there's a client side update, ie: ajax
                 ResponseWriter writer = facesContext.getResponseWriter();
                 writer.startElement(HTML.SPAN_ELEM, message);
                 writer.writeAttribute(HTML.ID_ATTR, message.getClientId(facesContext), null);
                 writer.endElement(HTML.SPAN_ELEM);
             }
             return;
         }
         
         // get first message
         FacesMessage facesMessage = (FacesMessage) messageIterator.next();
         
         // check for the redisplay attribute and for the messages which have already been rendered
         if(!isRedisplay(message)) 
         {
             while(facesMessage.isRendered())
             {
                 if(messageIterator.hasNext()) 
                 {
                     // get the next message
                     facesMessage = (FacesMessage) messageIterator.next();
                 }
                 else 
                 {
                     // no more message to be rendered
                     return; 
                 }
             }
         }
 
         // and render it
         renderSingleFacesMessage(facesContext, message, facesMessage, clientId);
     }
 
 
     protected void renderSingleFacesMessage(FacesContext facesContext,
                                             UIComponent message,
                                             FacesMessage facesMessage,
                                             String messageClientId)
             throws IOException
     {
         renderSingleFacesMessage(facesContext, message, facesMessage, messageClientId,true);
     }
     
     protected void renderSingleFacesMessage(FacesContext facesContext,
             UIComponent message,
             FacesMessage facesMessage,
             String messageClientId,
             boolean renderId)
     throws IOException
     {
         renderSingleFacesMessage(facesContext, message, facesMessage, messageClientId, renderId, true);
     }
 
     protected void renderSingleFacesMessage(FacesContext facesContext,
             UIComponent message,
             FacesMessage facesMessage,
             String messageClientId,
             boolean renderId,
             boolean renderStyleAndStyleClass)
     throws IOException
     {
         Map<String, List<ClientBehavior>> behaviors = null;
         if (message instanceof ClientBehaviorHolder)
         {
             behaviors = ((ClientBehaviorHolder) message).getClientBehaviors();
         }
         boolean wrapSpan = (message.getId() != null && !message.getId().startsWith(UIViewRoot.UNIQUE_ID_PREFIX)) 
             || (behaviors != null && !behaviors.isEmpty());
 
         renderSingleFacesMessage(facesContext, message, facesMessage, messageClientId, 
                 renderId, renderStyleAndStyleClass, wrapSpan);
     }
     
     protected void renderSingleFacesMessage(FacesContext facesContext,
                                             UIComponent message,
                                             FacesMessage facesMessage,
                                             String messageClientId,
                                             boolean renderId,
                                             boolean renderStyleAndStyleClass,
                                             boolean wrapSpan)
             throws IOException
     {
         // determine style and style class
         String[] styleAndClass = HtmlMessageRendererBase.getStyleAndStyleClass(
                 message, facesMessage.getSeverity());
         String style = styleAndClass[0];
         String styleClass = styleAndClass[1];
 
         String summary = getSummary(facesContext, message, facesMessage, messageClientId);
         String detail = getDetail(facesContext, message, facesMessage, messageClientId);
 
         String title = getTitle(message);
         boolean tooltip = isTooltip(message);
 
         boolean showSummary = isShowSummary(message) && (summary != null);
         boolean showDetail = isShowDetail(message) && (detail != null);
         
         if (title == null && tooltip)
         {
             if (showDetail)
             {
                 title = detail;
             }
             else if (detail != null)
             {
                 title = detail;
             }
             else
             {
                 title = summary;
             }
         }
 
         ResponseWriter writer = facesContext.getResponseWriter();
 
         boolean span = false;
 
         Map<String, List<ClientBehavior>> behaviors = null;
         if (message instanceof ClientBehaviorHolder)
         {
             behaviors = ((ClientBehaviorHolder) message).getClientBehaviors();
             // If there is a behavior registered, force wrapSpan
             wrapSpan = wrapSpan || !behaviors.isEmpty();
         }
         
         if ( wrapSpan )
         {
             span = true;
 
             writer.startElement(HTML.SPAN_ELEM, message);
 
             if (behaviors != null && !behaviors.isEmpty())
             {
                 //force id rendering, because the client behavior could require it
                 writer.writeAttribute(HTML.ID_ATTR, message.getClientId(facesContext),null);
             }
             else if (renderId)
             {
                 HtmlRendererUtils.writeIdIfNecessary(writer, message, facesContext);
             }
             if (message instanceof ClientBehaviorHolder)
             {
                 behaviors = ((ClientBehaviorHolder) message).getClientBehaviors();
                 if (behaviors.isEmpty() && isCommonPropertiesOptimizationEnabled(facesContext))
                 {
                     CommonPropertyUtils.renderEventProperties(writer, 
                             CommonPropertyUtils.getCommonPropertiesMarked(message), message);
                 }
                 else
                 {
                     if (isCommonEventsOptimizationEnabled(facesContext))
                     {
                         CommonEventUtils.renderBehaviorizedEventHandlers(facesContext, writer, 
                                CommonPropertyUtils.getCommonPropertiesMarked(message),
                                CommonEventUtils.getCommonEventsMarked(message), message, behaviors);
                     }
                     else
                     {
                         HtmlRendererUtils.renderBehaviorizedEventHandlers(facesContext, writer, message, behaviors);
                     }
                 }
                 HtmlRendererUtils.renderHTMLAttributes(writer, message, 
                         HTML.UNIVERSAL_ATTRIBUTES_WITHOUT_STYLE_AND_TITLE);
             }
             else
             {
                 HtmlRendererUtils.renderHTMLAttributes(writer, message, 
                         HTML.MESSAGE_PASSTHROUGH_ATTRIBUTES_WITHOUT_TITLE_STYLE_AND_STYLE_CLASS);
             }
         }
         else
         {
             span = HtmlRendererUtils.renderHTMLAttributesWithOptionalStartElement(
                     writer, message, HTML.SPAN_ELEM, 
                     HTML.MESSAGE_PASSTHROUGH_ATTRIBUTES_WITHOUT_TITLE_STYLE_AND_STYLE_CLASS);
         }
 
         span |= HtmlRendererUtils.renderHTMLAttributeWithOptionalStartElement(
                 writer, message, HTML.SPAN_ELEM, HTML.TITLE_ATTR, title, span);
         if (renderStyleAndStyleClass)
         {
             span |= HtmlRendererUtils.renderHTMLAttributeWithOptionalStartElement(
                     writer, message, HTML.SPAN_ELEM, HTML.STYLE_ATTR, style, span);
             span |= HtmlRendererUtils.renderHTMLAttributeWithOptionalStartElement(
                     writer, message, HTML.SPAN_ELEM, HTML.STYLE_CLASS_ATTR, styleClass, span);
             // Remember if renderStyleAndStyleClass is true, it means style and styleClass
             // are rendered on the outer tag, and in that sense, role attribute should
             // be rendered there too.
             span |= HtmlRendererUtils.renderHTMLAttributeWithOptionalStartElement(
                     writer, message, HTML.ROLE_ATTR, HTML.ROLE_ATTR, 
                     message.getAttributes().get(HTML.ROLE_ATTR), span);
         }
 
         if (showSummary && !(title == null && tooltip))
         {
             writer.writeText(summary, null);
             if (showDetail)
             {
                 writer.writeText(" ", null);
             }
         }
 
         if (showDetail)
         {
             writer.writeText(detail, null);
         }
 
         if (span)
         {
             writer.endElement(org.apache.myfaces.shared.renderkit.html.HTML.SPAN_ELEM);
         }
         
         // note that this FacesMessage already has been rendered 
         facesMessage.rendered();
     }
 
 
     public static String[] getStyleAndStyleClass(UIComponent message,
                                                  FacesMessage.Severity severity)
     {
         String style = null;
         String styleClass = null;
         if (message instanceof HtmlMessage)
         {
             if (severity == FacesMessage.SEVERITY_INFO)
             {
                 style = ((HtmlMessage) message).getInfoStyle();
                 styleClass = ((HtmlMessage) message).getInfoClass();
             }
             else if (severity == FacesMessage.SEVERITY_WARN)
             {
                 style = ((HtmlMessage) message).getWarnStyle();
                 styleClass = ((HtmlMessage) message).getWarnClass();
             }
             else if (severity == FacesMessage.SEVERITY_ERROR)
             {
                 style = ((HtmlMessage) message).getErrorStyle();
                 styleClass = ((HtmlMessage) message).getErrorClass();
             }
             else if (severity == FacesMessage.SEVERITY_FATAL)
             {
                 style = ((HtmlMessage) message).getFatalStyle();
                 styleClass = ((HtmlMessage) message).getFatalClass();
             }
 
             if (style == null)
             {
                 style = ((HtmlMessage) message).getStyle();
             }
 
             if (styleClass == null)
             {
                 styleClass = ((HtmlMessage) message).getStyleClass();
             }
         }
         else
         {
             Map<String, Object> attr = message.getAttributes();
             if (severity == FacesMessage.SEVERITY_INFO)
             {
                 style = (String) attr.get(org.apache.myfaces.shared.renderkit.JSFAttr.INFO_STYLE_ATTR);
                 styleClass = (String) attr.get(org.apache.myfaces.shared.renderkit.JSFAttr.INFO_CLASS_ATTR);
             }
             else if (severity == FacesMessage.SEVERITY_WARN)
             {
                 style = (String) attr.get(org.apache.myfaces.shared.renderkit.JSFAttr.WARN_STYLE_ATTR);
                 styleClass = (String) attr.get(org.apache.myfaces.shared.renderkit.JSFAttr.WARN_CLASS_ATTR);
             }
             else if (severity == FacesMessage.SEVERITY_ERROR)
             {
                 style = (String) attr.get(org.apache.myfaces.shared.renderkit.JSFAttr.ERROR_STYLE_ATTR);
                 styleClass = (String) attr.get(org.apache.myfaces.shared.renderkit.JSFAttr.ERROR_CLASS_ATTR);
             }
             else if (severity == FacesMessage.SEVERITY_FATAL)
             {
                 style = (String) attr.get(org.apache.myfaces.shared.renderkit.JSFAttr.FATAL_STYLE_ATTR);
                 styleClass = (String) attr.get(org.apache.myfaces.shared.renderkit.JSFAttr.FATAL_CLASS_ATTR);
             }
 
             if (style == null)
             {
                 style = (String) attr.get(org.apache.myfaces.shared.renderkit.JSFAttr.STYLE_ATTR);
             }
 
             if (styleClass == null)
             {
                 styleClass = (String) attr.get(org.apache.myfaces.shared.renderkit.JSFAttr.STYLE_CLASS_ATTR);
             }
         }
 
         return new String[]{style, styleClass};
     }
 
     protected String getFor(UIComponent component)
     {
         if (component instanceof UIMessage)
         {
             return ((UIMessage) component).getFor();
         }
  
         return (String) component.getAttributes().get(JSFAttr.FOR_ATTR);
         
     }
 
     protected String getTitle(UIComponent component)
     {
         if (component instanceof HtmlMessage)
         {
             return ((HtmlMessage) component).getTitle();
         }
 
         return (String) component.getAttributes().get(JSFAttr.TITLE_ATTR);
         
     }
 
     protected boolean isTooltip(UIComponent component)
     {
         if (component instanceof HtmlMessage)
         {
             return ((HtmlMessage) component).isTooltip();
         }
 
         return org.apache.myfaces.shared.renderkit.RendererUtils.getBooleanAttribute(component, 
                 org.apache.myfaces.shared.renderkit.JSFAttr.TOOLTIP_ATTR, false);
         
     }
 
     protected boolean isShowSummary(UIComponent component)
     {
         if (component instanceof UIMessage)
         {
             return ((UIMessage) component).isShowSummary();
         }
 
         return org.apache.myfaces.shared.renderkit.RendererUtils.getBooleanAttribute(component, 
                 org.apache.myfaces.shared.renderkit.JSFAttr.SHOW_SUMMARY_ATTR, false);
         
     }
 
     protected boolean isShowDetail(UIComponent component)
     {
         if (component instanceof UIMessage)
         {
             return ((UIMessage) component).isShowDetail();
         }
 
         return RendererUtils.getBooleanAttribute(component, 
                 org.apache.myfaces.shared.renderkit.JSFAttr.SHOW_DETAIL_ATTR, false);
         
     }
     
     protected boolean isRedisplay(UIComponent component)
     {
         if (component instanceof UIMessage)
         {
             return ((UIMessage) component).isRedisplay();
         }
 
         return org.apache.myfaces.shared.renderkit.RendererUtils.getBooleanAttribute(component, 
                 org.apache.myfaces.shared.renderkit.JSFAttr.REDISPLAY_ATTR, true);
         
     }
 
 }

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.shared.renderkit.html;
20
21		import java.io.IOException;
22		import java.util.Iterator;
23		import java.util.List;
24		import java.util.Map;
25		import java.util.logging.Logger;
26
27		import javax.faces.application.FacesMessage;
28		import javax.faces.component.UIComponent;
29		import javax.faces.component.UIMessage;
30		import javax.faces.component.UIViewRoot;
31		import javax.faces.component.behavior.ClientBehavior;
32		import javax.faces.component.behavior.ClientBehaviorHolder;
33		import javax.faces.component.html.HtmlMessage;
34		import javax.faces.context.FacesContext;
35		import javax.faces.context.ResponseWriter;
36
37		import org.apache.myfaces.shared.renderkit.JSFAttr;
38		import org.apache.myfaces.shared.renderkit.RendererUtils;
39
40	0	public abstract class HtmlMessageRendererBase
41		extends HtmlRenderer
42		{
43		//private static final Log log = LogFactory.getLog(HtmlMessageRendererBase.class);
44	0	private static final Logger log = Logger.getLogger(HtmlMessageRendererBase.class.getName());
45
46		protected abstract String getSummary(FacesContext facesContext,
47		UIComponent message,
48		FacesMessage facesMessage,
49		String msgClientId);
50
51		protected abstract String getDetail(FacesContext facesContext,
52		UIComponent message,
53		FacesMessage facesMessage,
54		String msgClientId);
55
56
57		protected void renderMessage(FacesContext facesContext,
58		UIComponent message)
59		throws IOException
60		{
61	0	renderMessage(facesContext, message, false);
62	0	}
63
64		protected void renderMessage(FacesContext facesContext, UIComponent message,
65		boolean alwaysRenderSpan) throws IOException
66		{
67	0	renderMessage(facesContext, message, alwaysRenderSpan, false);
68	0	}
69
70		/**
71		* @param facesContext
72		* @param message
73		* @param alwaysRenderSpan if true will render a span even if there is no message
74		*/
75		protected void renderMessage(FacesContext facesContext, UIComponent message,
76		boolean alwaysRenderSpan, boolean renderDivWhenNoMessagesAndIdSet) throws IOException
77		{
78	0	String forAttr = getFor(message);
79	0	if (forAttr == null)
80		{
81	0	log.severe("Attribute 'for' of UIMessage must not be null");
82	0	return;
83		}
84
85	0	UIComponent forComponent = message.findComponent(forAttr);
86	0	if (forComponent == null)
87		{
88	0	log.severe("Could not render Message. Unable to find component '"
89		+ forAttr + "' (calling findComponent on component '"
90		+ message.getClientId(facesContext)
91		+ "'). If the provided id was correct, wrap the message and its "
92		+ "component into an h:panelGroup or h:panelGrid.");
93	0	return;
94		}
95
96	0	String clientId = forComponent.getClientId(facesContext);
97
98	0	Iterator<FacesMessage> messageIterator = facesContext.getMessages(clientId);
99	0	if (!messageIterator.hasNext())
100		{
101		// No associated message, nothing to render
102	0	if (alwaysRenderSpan)
103		{
104	0	ResponseWriter writer = facesContext.getResponseWriter();
105	0	writer.startElement(HTML.SPAN_ELEM, message);
106	0	writer.writeAttribute(HTML.ID_ATTR, clientId + "_msgFor", null);
107	0	HtmlRendererUtils.renderHTMLStringAttribute(writer, message, JSFAttr.STYLE_ATTR, HTML.STYLE_ATTR);
108	0	HtmlRendererUtils.renderHTMLStringAttribute(writer, message, JSFAttr.STYLE_CLASS_ATTR, HTML.CLASS_ATTR);
109	0	writer.endElement(HTML.SPAN_ELEM);
110	0	}
111	0	else if (renderDivWhenNoMessagesAndIdSet && message.getId() != null &&
112		!message.getId().startsWith(UIViewRoot.UNIQUE_ID_PREFIX))
113		{
114		// show span anyways in case there's a client side update, ie: ajax
115	0	ResponseWriter writer = facesContext.getResponseWriter();
116	0	writer.startElement(HTML.SPAN_ELEM, message);
117	0	writer.writeAttribute(HTML.ID_ATTR, message.getClientId(facesContext), null);
118	0	writer.endElement(HTML.SPAN_ELEM);
119		}
120	0	return;
121		}
122
123		// get first message
124	0	FacesMessage facesMessage = (FacesMessage) messageIterator.next();
125
126		// check for the redisplay attribute and for the messages which have already been rendered
127	0	if(!isRedisplay(message))
128		{
129	0	while(facesMessage.isRendered())
130		{
131	0	if(messageIterator.hasNext())
132		{
133		// get the next message
134	0	facesMessage = (FacesMessage) messageIterator.next();
135		}
136		else
137		{
138		// no more message to be rendered
139	0	return;
140		}
141		}
142		}
143
144		// and render it
145	0	renderSingleFacesMessage(facesContext, message, facesMessage, clientId);
146	0	}
147
148
149		protected void renderSingleFacesMessage(FacesContext facesContext,
150		UIComponent message,
151		FacesMessage facesMessage,
152		String messageClientId)
153		throws IOException
154		{
155	0	renderSingleFacesMessage(facesContext, message, facesMessage, messageClientId,true);
156	0	}
157
158		protected void renderSingleFacesMessage(FacesContext facesContext,
159		UIComponent message,
160		FacesMessage facesMessage,
161		String messageClientId,
162		boolean renderId)
163		throws IOException
164		{
165	0	renderSingleFacesMessage(facesContext, message, facesMessage, messageClientId, renderId, true);
166	0	}
167
168		protected void renderSingleFacesMessage(FacesContext facesContext,
169		UIComponent message,
170		FacesMessage facesMessage,
171		String messageClientId,
172		boolean renderId,
173		boolean renderStyleAndStyleClass)
174		throws IOException
175		{
176	0	Map<String, List<ClientBehavior>> behaviors = null;
177	0	if (message instanceof ClientBehaviorHolder)
178		{
179	0	behaviors = ((ClientBehaviorHolder) message).getClientBehaviors();
180		}
181	0	boolean wrapSpan = (message.getId() != null && !message.getId().startsWith(UIViewRoot.UNIQUE_ID_PREFIX))
182		\|\| (behaviors != null && !behaviors.isEmpty());
183
184	0	renderSingleFacesMessage(facesContext, message, facesMessage, messageClientId,
185		renderId, renderStyleAndStyleClass, wrapSpan);
186	0	}
187
188		protected void renderSingleFacesMessage(FacesContext facesContext,
189		UIComponent message,
190		FacesMessage facesMessage,
191		String messageClientId,
192		boolean renderId,
193		boolean renderStyleAndStyleClass,
194		boolean wrapSpan)
195		throws IOException
196		{
197		// determine style and style class
198	0	String[] styleAndClass = HtmlMessageRendererBase.getStyleAndStyleClass(
199		message, facesMessage.getSeverity());
200	0	String style = styleAndClass[0];
201	0	String styleClass = styleAndClass[1];
202
203	0	String summary = getSummary(facesContext, message, facesMessage, messageClientId);
204	0	String detail = getDetail(facesContext, message, facesMessage, messageClientId);
205
206	0	String title = getTitle(message);
207	0	boolean tooltip = isTooltip(message);
208
209	0	boolean showSummary = isShowSummary(message) && (summary != null);
210	0	boolean showDetail = isShowDetail(message) && (detail != null);
211
212	0	if (title == null && tooltip)
213		{
214	0	if (showDetail)
215		{
216	0	title = detail;
217		}
218	0	else if (detail != null)
219		{
220	0	title = detail;
221		}
222		else
223		{
224	0	title = summary;
225		}
226		}
227
228	0	ResponseWriter writer = facesContext.getResponseWriter();
229
230	0	boolean span = false;
231
232	0	Map<String, List<ClientBehavior>> behaviors = null;
233	0	if (message instanceof ClientBehaviorHolder)
234		{
235	0	behaviors = ((ClientBehaviorHolder) message).getClientBehaviors();
236		// If there is a behavior registered, force wrapSpan
237	0	wrapSpan = wrapSpan \|\| !behaviors.isEmpty();
238		}
239
240	0	if ( wrapSpan )
241		{
242	0	span = true;
243
244	0	writer.startElement(HTML.SPAN_ELEM, message);
245
246	0	if (behaviors != null && !behaviors.isEmpty())
247		{
248		//force id rendering, because the client behavior could require it
249	0	writer.writeAttribute(HTML.ID_ATTR, message.getClientId(facesContext),null);
250		}
251	0	else if (renderId)
252		{
253	0	HtmlRendererUtils.writeIdIfNecessary(writer, message, facesContext);
254		}
255	0	if (message instanceof ClientBehaviorHolder)
256		{
257	0	behaviors = ((ClientBehaviorHolder) message).getClientBehaviors();
258	0	if (behaviors.isEmpty() && isCommonPropertiesOptimizationEnabled(facesContext))
259		{
260	0	CommonPropertyUtils.renderEventProperties(writer,
261		CommonPropertyUtils.getCommonPropertiesMarked(message), message);
262		}
263		else
264		{
265	0	if (isCommonEventsOptimizationEnabled(facesContext))
266		{
267	0	CommonEventUtils.renderBehaviorizedEventHandlers(facesContext, writer,
268		CommonPropertyUtils.getCommonPropertiesMarked(message),
269		CommonEventUtils.getCommonEventsMarked(message), message, behaviors);
270		}
271		else
272		{
273	0	HtmlRendererUtils.renderBehaviorizedEventHandlers(facesContext, writer, message, behaviors);
274		}
275		}
276	0	HtmlRendererUtils.renderHTMLAttributes(writer, message,
277		HTML.UNIVERSAL_ATTRIBUTES_WITHOUT_STYLE_AND_TITLE);
278		}
279		else
280		{
281	0	HtmlRendererUtils.renderHTMLAttributes(writer, message,
282		HTML.MESSAGE_PASSTHROUGH_ATTRIBUTES_WITHOUT_TITLE_STYLE_AND_STYLE_CLASS);
283		}
284		}
285		else
286		{
287	0	span = HtmlRendererUtils.renderHTMLAttributesWithOptionalStartElement(
288		writer, message, HTML.SPAN_ELEM,
289		HTML.MESSAGE_PASSTHROUGH_ATTRIBUTES_WITHOUT_TITLE_STYLE_AND_STYLE_CLASS);
290		}
291
292	0	span \|= HtmlRendererUtils.renderHTMLAttributeWithOptionalStartElement(
293		writer, message, HTML.SPAN_ELEM, HTML.TITLE_ATTR, title, span);
294	0	if (renderStyleAndStyleClass)
295		{
296	0	span \|= HtmlRendererUtils.renderHTMLAttributeWithOptionalStartElement(
297		writer, message, HTML.SPAN_ELEM, HTML.STYLE_ATTR, style, span);
298	0	span \|= HtmlRendererUtils.renderHTMLAttributeWithOptionalStartElement(
299		writer, message, HTML.SPAN_ELEM, HTML.STYLE_CLASS_ATTR, styleClass, span);
300		// Remember if renderStyleAndStyleClass is true, it means style and styleClass
301		// are rendered on the outer tag, and in that sense, role attribute should
302		// be rendered there too.
303	0	span \|= HtmlRendererUtils.renderHTMLAttributeWithOptionalStartElement(
304		writer, message, HTML.ROLE_ATTR, HTML.ROLE_ATTR,
305		message.getAttributes().get(HTML.ROLE_ATTR), span);
306		}
307
308	0	if (showSummary && !(title == null && tooltip))
309		{
310	0	writer.writeText(summary, null);
311	0	if (showDetail)
312		{
313	0	writer.writeText(" ", null);
314		}
315		}
316
317	0	if (showDetail)
318		{
319	0	writer.writeText(detail, null);
320		}
321
322	0	if (span)
323		{
324	0	writer.endElement(org.apache.myfaces.shared.renderkit.html.HTML.SPAN_ELEM);
325		}
326
327		// note that this FacesMessage already has been rendered
328	0	facesMessage.rendered();
329	0	}
330
331
332		public static String[] getStyleAndStyleClass(UIComponent message,
333		FacesMessage.Severity severity)
334		{
335	0	String style = null;
336	0	String styleClass = null;
337	0	if (message instanceof HtmlMessage)
338		{
339	0	if (severity == FacesMessage.SEVERITY_INFO)
340		{
341	0	style = ((HtmlMessage) message).getInfoStyle();
342	0	styleClass = ((HtmlMessage) message).getInfoClass();
343		}
344	0	else if (severity == FacesMessage.SEVERITY_WARN)
345		{
346	0	style = ((HtmlMessage) message).getWarnStyle();
347	0	styleClass = ((HtmlMessage) message).getWarnClass();
348		}
349	0	else if (severity == FacesMessage.SEVERITY_ERROR)
350		{
351	0	style = ((HtmlMessage) message).getErrorStyle();
352	0	styleClass = ((HtmlMessage) message).getErrorClass();
353		}
354	0	else if (severity == FacesMessage.SEVERITY_FATAL)
355		{
356	0	style = ((HtmlMessage) message).getFatalStyle();
357	0	styleClass = ((HtmlMessage) message).getFatalClass();
358		}
359
360	0	if (style == null)
361		{
362	0	style = ((HtmlMessage) message).getStyle();
363		}
364
365	0	if (styleClass == null)
366		{
367	0	styleClass = ((HtmlMessage) message).getStyleClass();
368		}
369		}
370		else
371		{
372	0	Map<String, Object> attr = message.getAttributes();
373	0	if (severity == FacesMessage.SEVERITY_INFO)
374		{
375	0	style = (String) attr.get(org.apache.myfaces.shared.renderkit.JSFAttr.INFO_STYLE_ATTR);
376	0	styleClass = (String) attr.get(org.apache.myfaces.shared.renderkit.JSFAttr.INFO_CLASS_ATTR);
377		}
378	0	else if (severity == FacesMessage.SEVERITY_WARN)
379		{
380	0	style = (String) attr.get(org.apache.myfaces.shared.renderkit.JSFAttr.WARN_STYLE_ATTR);
381	0	styleClass = (String) attr.get(org.apache.myfaces.shared.renderkit.JSFAttr.WARN_CLASS_ATTR);
382		}
383	0	else if (severity == FacesMessage.SEVERITY_ERROR)
384		{
385	0	style = (String) attr.get(org.apache.myfaces.shared.renderkit.JSFAttr.ERROR_STYLE_ATTR);
386	0	styleClass = (String) attr.get(org.apache.myfaces.shared.renderkit.JSFAttr.ERROR_CLASS_ATTR);
387		}
388	0	else if (severity == FacesMessage.SEVERITY_FATAL)
389		{
390	0	style = (String) attr.get(org.apache.myfaces.shared.renderkit.JSFAttr.FATAL_STYLE_ATTR);
391	0	styleClass = (String) attr.get(org.apache.myfaces.shared.renderkit.JSFAttr.FATAL_CLASS_ATTR);
392		}
393
394	0	if (style == null)
395		{
396	0	style = (String) attr.get(org.apache.myfaces.shared.renderkit.JSFAttr.STYLE_ATTR);
397		}
398
399	0	if (styleClass == null)
400		{
401	0	styleClass = (String) attr.get(org.apache.myfaces.shared.renderkit.JSFAttr.STYLE_CLASS_ATTR);
402		}
403		}
404
405	0	return new String[]{style, styleClass};
406		}
407
408		protected String getFor(UIComponent component)
409		{
410	0	if (component instanceof UIMessage)
411		{
412	0	return ((UIMessage) component).getFor();
413		}
414
415	0	return (String) component.getAttributes().get(JSFAttr.FOR_ATTR);
416
417		}
418
419		protected String getTitle(UIComponent component)
420		{
421	0	if (component instanceof HtmlMessage)
422		{
423	0	return ((HtmlMessage) component).getTitle();
424		}
425
426	0	return (String) component.getAttributes().get(JSFAttr.TITLE_ATTR);
427
428		}
429
430		protected boolean isTooltip(UIComponent component)
431		{
432	0	if (component instanceof HtmlMessage)
433		{
434	0	return ((HtmlMessage) component).isTooltip();
435		}
436
437	0	return org.apache.myfaces.shared.renderkit.RendererUtils.getBooleanAttribute(component,
438		org.apache.myfaces.shared.renderkit.JSFAttr.TOOLTIP_ATTR, false);
439
440		}
441
442		protected boolean isShowSummary(UIComponent component)
443		{
444	0	if (component instanceof UIMessage)
445		{
446	0	return ((UIMessage) component).isShowSummary();
447		}
448
449	0	return org.apache.myfaces.shared.renderkit.RendererUtils.getBooleanAttribute(component,
450		org.apache.myfaces.shared.renderkit.JSFAttr.SHOW_SUMMARY_ATTR, false);
451
452		}
453
454		protected boolean isShowDetail(UIComponent component)
455		{
456	0	if (component instanceof UIMessage)
457		{
458	0	return ((UIMessage) component).isShowDetail();
459		}
460
461	0	return RendererUtils.getBooleanAttribute(component,
462		org.apache.myfaces.shared.renderkit.JSFAttr.SHOW_DETAIL_ATTR, false);
463
464		}
465
466		protected boolean isRedisplay(UIComponent component)
467		{
468	0	if (component instanceof UIMessage)
469		{
470	0	return ((UIMessage) component).isRedisplay();
471		}
472
473	0	return org.apache.myfaces.shared.renderkit.RendererUtils.getBooleanAttribute(component,
474		org.apache.myfaces.shared.renderkit.JSFAttr.REDISPLAY_ATTR, true);
475
476		}
477
478		}