Java > Open Source Codes > com > icesoft > faces > component > paneltabset > PanelTabSetRenderer


1 /*
2  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
3  *
4  * "The contents of this file are subject to the Mozilla Public License
5  * Version 1.1 (the "License"); you may not use this file except in
6  * compliance with the License. You may obtain a copy of the License at
7  * http://www.mozilla.org/MPL/
8  *
9  * Software distributed under the License is distributed on an "AS IS"
10  * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the
11  * License for the specific language governing rights and limitations under
12  * the License.
13  *
14  * The Original Code is ICEfaces 1.5 open source software code, released
15  * November 5, 2006. The Initial Developer of the Original Code is ICEsoft
16  * Technologies Canada, Corp. Portions created by ICEsoft are Copyright (C)
17  * 2004-2006 ICEsoft Technologies Canada, Corp. All Rights Reserved.
18  *
19  * Contributor(s): _____________________.
20  *
21  * Alternatively, the contents of this file may be used under the terms of
22  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"
23  * License), in which case the provisions of the LGPL License are
24  * applicable instead of those above. If you wish to allow use of your
25  * version of this file only under the terms of the LGPL License and not to
26  * allow others to use your version of this file under the MPL, indicate
27  * your decision by deleting the provisions above and replace them with
28  * the notice and other provisions required by the LGPL License. If you do
29  * not delete the provisions above, a recipient may use your version of
30  * this file under either the MPL or the LGPL License."
31  *
32  */
33
34 package com.icesoft.faces.component.paneltabset;
35
36 import com.icesoft.faces.component.CSS_DEFAULT;
37 import com.icesoft.faces.component.ext.taglib.Util;
38 import com.icesoft.faces.component.panelseries.UISeries;
39 import com.icesoft.faces.component.util.CustomComponentUtils;
40 import com.icesoft.faces.context.DOMContext;
41 import com.icesoft.faces.renderkit.dom_html_basic.DomBasicRenderer;
42 import com.icesoft.faces.renderkit.dom_html_basic.FormRenderer;
43 import com.icesoft.faces.renderkit.dom_html_basic.HTML;
44 import com.icesoft.faces.util.CoreUtils;
45 import com.icesoft.faces.util.DOMUtils;
46 import org.apache.commons.logging.Log;
47 import org.apache.commons.logging.LogFactory;
48 import org.w3c.dom.Element ;
49 import org.w3c.dom.Text ;
50
51 import javax.faces.FacesException;
52 import javax.faces.component.NamingContainer;
53 import javax.faces.component.UIComponent;
54 import javax.faces.component.UIForm;
55 import javax.faces.component.UINamingContainer;
56 import javax.faces.component.UIParameter;
57 import javax.faces.component.UIViewRoot;
58 import javax.faces.context.FacesContext;
59 import java.beans.Beans ;
60 import java.io.IOException ;
61 import java.util.HashMap ;
62 import java.util.Iterator ;
63 import java.util.List ;
64 import java.util.Map ;
65
66 /**
67  * <p>PanelTabSetRenderer extends DomBasicRenderer and is responsible for
68  * rendering PanelTabSet and PanelTab components.</p>
69  */
70 public class PanelTabSetRenderer
71         extends DomBasicRenderer
72
73 {
74     // hidden field for the tab links
75 private static final String HIDDEN_FIELD_NAME = "cl";
76
77     private static final Log log = LogFactory.getLog(PanelTabSetRenderer.class);
78     private static final String SPACER_IMG =
79             "/xmlhttp/css/xp/css-images/spacer.gif";
80
81     /* (non-Javadoc)
82      * @see javax.faces.render.Renderer#encodeBegin(javax.faces.context.FacesContext, javax.faces.component.UIComponent)
83      */
84     public void encodeBegin(FacesContext facesContext, UIComponent uiComponent)
85             throws IOException {
86     }
87
88     /* (non-Javadoc)
89      * @see javax.faces.render.Renderer#getRendersChildren()
90      */
91     public boolean getRendersChildren() {
92         return true;
93     }
94
95     /* (non-Javadoc)
96      * @see javax.faces.render.Renderer#encodeChildren(javax.faces.context.FacesContext, javax.faces.component.UIComponent)
97      */
98     public void encodeChildren(FacesContext facescontext,
99                                UIComponent uicomponent) throws IOException {
100     }
101
102     /* (non-Javadoc)
103      * @see javax.faces.render.Renderer#encodeEnd(javax.faces.context.FacesContext, javax.faces.component.UIComponent)
104      */
105     public void encodeEnd(FacesContext facesContext, UIComponent uiComponent)
106             throws IOException {
107         validateParameters(facesContext, uiComponent, PanelTabSet.class);
108         // get DOMContext using DOMContext static method getDOMContext
109 DOMContext domContext =
110                 DOMContext.attachDOMContext(facesContext, uiComponent);
111         // if the domContext has not been initialized
112 // initialize it, create the Root Element
113 if (!domContext.isInitialized()) {
114             Element table = domContext.createRootElement(HTML.TABLE_ELEM);
115             table.setAttribute(HTML.CELLPADDING_ATTR, "0");
116             table.setAttribute(HTML.CELLSPACING_ATTR, "0");
117             setRootElementId(facesContext, table, uiComponent);
118         }
119
120         FormRenderer.addHiddenField(facesContext,
121                                     deriveCommonHiddenFieldName(
122                                             facesContext, uiComponent));
123
124         PanelTabSet tabSet = (PanelTabSet) uiComponent;
125         String baseClass = tabSet.getStyleClass();
126
127         int selectedIndex = tabSet.getSelectedIndex();
128
129         // get the parentForm
130 UIComponent parentForm = findForm(tabSet);
131         // if there is no parent form - ERROR
132 if (parentForm == null) {
133             if (log.isErrorEnabled()) {
134                 log.error(" TabbedPane::must be in a FORM");
135             }
136             return;
137         }
138
139         if (tabSet.getValue() != null) {
140             if (tabSet.getChildCount() < 1) {
141                 if (log.isErrorEnabled()) {
142                     log.error(" TabbedPane:a panelTab element is required");
143                 }
144                 return;
145             }
146
147             if (tabSet.getChildCount() > 1 ||
148                 !(tabSet.getChildren().get(0) instanceof PanelTab)) {
149                 if (log.isErrorEnabled()) {
150                     log.error(
151                             " TabbedPane::only one panelTab element allowed when using value atttibute");
152                 }
153                 return;
154             }
155         }
156
157         // get table
158 Element table = (Element ) domContext.getRootNode();
159         // render table pass thru attributes
160 for (int i = 0; i < HTML.TABLE_PASSTHROUGH_ATTRIBUTES.length; i++) {
161             if (HTML.TABLE_PASSTHROUGH_ATTRIBUTES[i]
162                     .equalsIgnoreCase("styleClass")) {
163                 renderAttribute(tabSet, table,
164                                 HTML.TABLE_PASSTHROUGH_ATTRIBUTES[i],
165                                 HTML.CLASS_ATTR);
166             } else {
167                 renderAttribute(tabSet, table,
168                                 HTML.TABLE_PASSTHROUGH_ATTRIBUTES[i],
169                                 HTML.TABLE_PASSTHROUGH_ATTRIBUTES[i]);
170             }
171         }
172
173 // table.removeAttribute(HTML.BGCOLOR_ATTR);
174
175         // clean out children
176 DOMContext.removeChildrenByTagName(table, HTML.TR_ELEM);
177         // create a new table row for the Tab Header Cell
178 Element headerRow = domContext.createElement(HTML.TR_ELEM);
179
180         // Create Tab headers
181 int tabIdx = 0;
182         int visibleTabCount = 0;
183         List children = tabSet.getChildren();
184
185         // check tabPlacement
186 // default is Top
187 // if tabPlacement is Bottom
188 // render Tab Cell first then Tab Header
189
190         List tabList = null;
191         if (tabSet.getValue() != null) {
192             tabList = (List ) tabSet.getValue();
193         }
194         if (tabSet.getTabPlacement()
195                 .equalsIgnoreCase(PanelTabSet.TABPLACEMENT_BOTTOM)) {
196
197             if (tabList != null) {
198                 visibleTabCount = tabList.size();
199             } else {
200                 // determine visibleTabCount
201 for (int i = 0, len = children.size(); i < len; i++) {
202                     UIComponent child =
203                             getUIComponent((UIComponent) children.get(i));
204                     if (child instanceof PanelTab) {
205                         if (child.isRendered()) {
206                             visibleTabCount++;
207                         }
208                     }
209                 }
210             }
211             // Create Tab Cells
212 // create a new table row Element for the Tab Content Cells
213 Element contentRow = domContext.createElement(HTML.TR_ELEM);
214             // append the tab content table row Element to the table
215 table.appendChild(contentRow);
216             table.appendChild(headerRow);
217             Element headerTd = domContext.createElement(HTML.TD_ELEM);
218             headerRow.appendChild(headerTd);
219             Element tabsTable = domContext.createElement(HTML.TABLE_ELEM);
220             tabsTable.setAttribute(HTML.CELLPADDING_ATTR, "0");
221             tabsTable.setAttribute(HTML.CELLSPACING_ATTR, "0");
222             headerTd.appendChild(tabsTable);
223             Element tabsTableRow = domContext.createElement(HTML.TR_ELEM);
224             tabsTable.appendChild(tabsTableRow);
225             
226             contentRow.setAttribute(HTML.HEIGHT_ATTR, "100%");
227             // call the writeTabCell method
228 // pass in the new table row Element tr3
229 writeTabCell(domContext,
230                          facesContext,
231                          tabSet,
232                          visibleTabCount,
233                          selectedIndex,
234                          contentRow,
235                          tabSet);
236             if (tabSet.getValue() != null) {
237                 int rowIndex = tabSet.getFirst();
238                 int rowsToBeDisplayed = tabSet.getRows();
239                 int rowsDisplayed = 0;
240                 tabSet.setRowIndex(rowIndex);
241
242                 while (tabSet.isRowAvailable()) {
243                     if (rowsToBeDisplayed > 0 &&
244                         rowsDisplayed >= rowsToBeDisplayed) {
245                         break;
246                     }
247
248                     UIComponent child = getUIComponent(
249                             (UIComponent) tabSet.getChildren().get(0));
250                     if (child instanceof PanelTab) {
251                         if (child.isRendered()) {
252                             // append the header table row Element to the table
253
254                             // call the writeHeaderCell method
255 // pass in the new header table row Element
256 writeHeaderCell(domContext,
257                                             facesContext,
258                                             tabSet,
259                                             (PanelTab) child,
260                                             tabIdx,
261                                             tabIdx == selectedIndex,
262                                             ((PanelTab) child).isDisabled(),
263                                             tabsTableRow);
264                             visibleTabCount++;
265                         }
266                         tabIdx++;
267                     }
268                     rowsDisplayed++;
269                     rowIndex++;
270                     tabSet.setRowIndex(rowIndex);
271                 }
272                 tabSet.setRowIndex(-1);
273             } else {
274
275                 for (int i = 0, len = children.size(); i < len; i++) {
276                     UIComponent child =
277                             getUIComponent((UIComponent) children.get(i));
278                     if (child instanceof PanelTab) {
279                         if (child.isRendered()) {
280                             // append the header table row Element to the table
281 // call the writeHeaderCell method
282 // pass in the new header table row Element
283 writeHeaderCell(domContext,
284                                             facesContext,
285                                             tabSet,
286                                             (PanelTab) child,
287                                             tabIdx,
288                                             tabIdx == selectedIndex,
289                                             ((PanelTab) child).isDisabled(),
290                                             tabsTableRow);
291                             visibleTabCount++;
292                         }
293                         tabIdx++;
294                     }
295                 }
296             }
297             // Empty tab cell on the right for better look
298 // create a new table data for the empty TextNode
299 Element td = domContext.createElement(HTML.TD_ELEM);
300             String className = tabSet.getSpacerClass();
301             td.setAttribute(HTML.CLASS_ATTR, className);
302             Text text = null;
303             if (domContext.isStreamWriting()) {
304                 text = domContext.createTextNode(" ");
305             } else {
306                 text = domContext.createTextNode("&#160;");
307             }
308             td.appendChild(text);
309             // append the empty TextNode table data to our table row Element tr1
310 tabsTableRow.appendChild(td);
311
312             domContext.streamWrite(facesContext, tabSet);
313             // steps to the position where the next sibling should be rendered
314 domContext.stepOver();
315
316         } else { // for now it's either Top or Bottom
317 table.appendChild(headerRow);
318             Element headerTd = domContext.createElement(HTML.TD_ELEM);
319             headerRow.appendChild(headerTd);
320             Element tabsTable = domContext.createElement(HTML.TABLE_ELEM);
321             tabsTable.setAttribute(HTML.CELLPADDING_ATTR, "0");
322             tabsTable.setAttribute(HTML.CELLSPACING_ATTR, "0");
323             headerTd.appendChild(tabsTable);
324             Element tabsTableRow = domContext.createElement(HTML.TR_ELEM);
325             tabsTable.appendChild(tabsTableRow);
326             if (tabSet.getValue() != null) {
327                 int rowIndex = tabSet.getFirst();
328                 int rowsToBeDisplayed = tabSet.getRows();
329                 int rowsDisplayed = 0;
330                 tabSet.setRowIndex(rowIndex);
331
332                 while (tabSet.isRowAvailable()) {
333                     if (rowsToBeDisplayed > 0 &&
334                         rowsDisplayed >= rowsToBeDisplayed) {
335                         break;
336                     }
337
338                     UIComponent child = getUIComponent(
339                             (UIComponent) tabSet.getChildren().get(0));
340                     if (child instanceof PanelTab) {
341                         if (child.isRendered()) {
342                             // append the header table row Element to the table
343 // call the writeHeaderCell method
344 // pass in the new header table row Element
345 writeHeaderCell(domContext,
346                                             facesContext,
347                                             tabSet,
348                                             (PanelTab) child,
349                                             tabIdx,
350                                             tabIdx == selectedIndex,
351                                             ((PanelTab) child).isDisabled(),
352                                             tabsTableRow);
353                             visibleTabCount++;
354                         }
355                         tabIdx++;
356                     }
357                     rowsDisplayed++;
358                     rowIndex++;
359                     tabSet.setRowIndex(rowIndex);
360                 }
361                 tabSet.setRowIndex(-1);
362             } else {
363                 for (int i = 0, len = children.size(); i < len; i++) {
364                     UIComponent child =
365                             getUIComponent((UIComponent) children.get(i));
366                     if (child instanceof PanelTab) {
367                         if (child.isRendered()) {
368                             // append the header table row Element to the table
369 // call the writeHeaderCell method
370 // pass in the new header table row Element
371 writeHeaderCell(domContext,
372                                             facesContext,
373                                             tabSet,
374                                             (PanelTab) child,
375                                             tabIdx,
376                                             tabIdx == selectedIndex,
377                                             ((PanelTab) child).isDisabled(),
378                                             tabsTableRow);
379                             visibleTabCount++;
380                         }
381                         tabIdx++;
382                     }
383                 }
384             }
385             // Empty tab cell on the right for better look
386 // create a new table data for the empty TextNode
387 Element td = domContext.createElement(HTML.TD_ELEM);
388
389             String className = tabSet.getSpacerClass();
390             td.setAttribute(HTML.CLASS_ATTR, className);
391             Text text;
392             if (domContext.isStreamWriting()) {
393                 text = domContext.createTextNode(" ");
394             } else {
395                 text = domContext.createTextNode("&#160;");
396             }
397
398             td.appendChild(text);
399             // append the empty TextNode table data to our table row Element tr1
400 tabsTableRow.appendChild(td);
401
402             // Create Tab Cells
403 // create a new table row Element for the Tab Cells
404 Element contentRow = domContext.createElement(HTML.TR_ELEM);
405             contentRow.setAttribute(HTML.HEIGHT_ATTR, "100%");
406             // append the table row Element to the table
407 table.appendChild(contentRow);
408             // call the writeTabCell method
409 // pass in the new table row Element tr3
410 writeTabCell(domContext,
411                          facesContext,
412                          tabSet,
413                          visibleTabCount,
414                          selectedIndex,
415                          contentRow,
416                          tabSet);
417
418             // steps to the position where the next sibling should be rendered
419 domContext.stepOver();
420             domContext.streamWrite(facesContext, tabSet);
421
422         }
423     }
424
425
426     /* (non-Javadoc)
427      * @see javax.faces.render.Renderer#decode(javax.faces.context.FacesContext, javax.faces.component.UIComponent)
428      */
429     public void decode(FacesContext facesContext, UIComponent uiComponent) {
430         validateParameters(facesContext, uiComponent, PanelTabSet.class);
431
432         PanelTabSet tabSet = (PanelTabSet) uiComponent;
433         Map paramMap =
434                 facesContext.getExternalContext().getRequestParameterMap();
435         int tabIdx = 0;
436         String paramName;
437         String paramValue;
438         if (tabSet.getValue() != null) {
439             int rowIndex = tabSet.getFirst();
440             tabSet.setRowIndex(rowIndex);
441             int rowsToBeDisplayed = tabSet.getRows();
442             int rowsDisplayed = 0;
443             UIComponent child =
444                     getUIComponent((UIComponent) tabSet.getChildren().get(0));
445             while (tabSet.isRowAvailable()) {
446                 if (rowsToBeDisplayed > 0 &&
447                     rowsDisplayed >= rowsToBeDisplayed) {
448                     break;
449                 }
450                 if (child instanceof PanelTab) {
451                     paramName = tabSet.getClientId(facesContext) + "." + tabIdx;
452                     paramValue = (String ) paramMap.get(paramName);
453                     if (paramValue != null && paramValue.length() > 0) {
454                         tabSet.queueEvent(new TabChangeEvent(tabSet,
455                                                              tabSet.getSelectedIndex(),
456                                                              tabIdx));
457                         return;
458                     }
459                     tabIdx++;
460                 }
461                 rowsDisplayed++;
462                 rowIndex++;
463                 tabSet.setRowIndex(rowIndex);
464             }
465             tabSet.setRowIndex(-1);
466         } else {
467             List children = tabSet.getChildren();
468             for (int i = 0, len = children.size(); i < len; i++) {
469                 UIComponent child =
470                         getUIComponent((UIComponent) children.get(i));
471                 if (child instanceof PanelTab) {
472                     paramName = tabSet.getClientId(facesContext) + "." + tabIdx;
473                     paramValue = (String ) paramMap.get(paramName);
474                     if (paramValue != null && paramValue.length() > 0) {
475                         tabSet.queueEvent(new TabChangeEvent(tabSet,
476                                                              tabSet.getSelectedIndex(),
477                                                              tabIdx));
478                         return;
479                     }
480                     tabIdx++;
481                 }
482             }
483         }
484     }
485
486     /**
487      * writeHeaderCell is a DOM-enabled version of the MyFaces writeHeaderCell
488      * implementation. Calls to the ResponseWriter have been substituted with
489      * DOMContext and w3c DOM API calls.
490      *
491      * @param domContext
492      * @param facesContext
493      * @param tabSet
494      * @param tab
495      * @param tabIndex
496      * @param active
497      * @param disabled
498      * @param tr
499      * @throws IOException
500      */
501     protected void writeHeaderCell(DOMContext domContext,
502                                    FacesContext facesContext,
503                                    PanelTabSet tabSet,
504                                    PanelTab tab,
505                                    int tabIndex,
506                                    boolean active,
507                                    boolean disabled,
508                                    Element tr)
509             throws IOException {
510         String baseClass = tabSet.getStyleClass();
511         // create a new table data Element using the DOMContext API
512 Element td = domContext.createElement(HTML.TD_ELEM);
513         td.setAttribute(HTML.ID_ATTR,
514                         tabSet.getClientId(facesContext) + "ht" + tabIndex);
515         // append the td to the tr
516 tr.appendChild(td);
517
518         String styleClass = tab.getStyleClass();
519
520         String label = tab.getLabel();
521
522         if (label == null || label.length() == 0) {
523             label = "Tab " + tabIndex;
524         }
525
526         label = DOMUtils.escapeAnsi(label);
527
528         String tabPlacement = "";
529         if (tabSet.getTabPlacement()
530                 .equalsIgnoreCase(PanelTabSet.TABPLACEMENT_BOTTOM)) {
531             tabPlacement = CSS_DEFAULT.PANEL_TAB_SET_DEFAULT_BOTTOM;
532         }
533
534         // create a table for the tab
535 Element table = domContext.createElement(HTML.TABLE_ELEM);
536         // append the table to the td
537 td.appendChild(table);
538
539         table.setAttribute(HTML.CELLPADDING_ATTR, "0");
540         table.setAttribute(HTML.CELLSPACING_ATTR, "0");
541
542         // table will have 3 rows
543 Element tr_top = domContext.createElement(HTML.TR_ELEM);
544         Element tr_mid = domContext.createElement(HTML.TR_ELEM);
545         Element tr_bot = domContext.createElement(HTML.TR_ELEM);
546
547         // each row will have 3 columns
548 Element td_top_left = domContext.createElement(HTML.TD_ELEM);
549         Element td_top_mid = domContext.createElement(HTML.TD_ELEM);
550         Element td_top_right = domContext.createElement(HTML.TD_ELEM);
551         this.renderSpacerImage(domContext, td_top_left);
552         this.renderSpacerImage(domContext, td_top_mid);
553         this.renderSpacerImage(domContext, td_top_right);
554
555         Element td_mid_left = domContext.createElement(HTML.TD_ELEM);
556         // the command link will go in this td
557 Element td_mid_mid = domContext.createElement(HTML.TD_ELEM);
558         Element td_mid_right = domContext.createElement(HTML.TD_ELEM);
559         this.renderSpacerImage(domContext, td_mid_left);
560         this.renderSpacerImage(domContext, td_mid_right);
561
562         Element td_bot_left = domContext.createElement(HTML.TD_ELEM);
563         Element td_bot_mid = domContext.createElement(HTML.TD_ELEM);
564         Element td_bot_right = domContext.createElement(HTML.TD_ELEM);
565         this.renderSpacerImage(domContext, td_bot_left);
566         this.renderSpacerImage(domContext, td_bot_mid);
567         this.renderSpacerImage(domContext, td_bot_right);
568
569         String disableStyleClassSuffix;
570
571         if (disabled) {
572             disableStyleClassSuffix = "-dis";
573             Text text = domContext.createTextNode(label);
574             td_mid_mid.appendChild(text);
575         } else {
576             disableStyleClassSuffix = "";
577             // Build a command link
578 Element link = domContext.createElement(HTML.ANCHOR_ELEM);
579             link.setAttribute(HTML.NAME_ATTR, tabSet.getClientId(facesContext) +
580                                               "." + tabIndex);
581             link.setAttribute(HTML.ID_ATTR, tabSet.getClientId(facesContext) +
582                                             "." + tabIndex);
583             link.setAttribute(HTML.HREF_ATTR, "#");
584             // set focus handler
585 link.setAttribute(HTML.ONFOCUS_ATTR, "setFocus(this.id);");
586             link.setAttribute(HTML.ONBLUR_ATTR, "setFocus('');");
587             td_mid_mid.appendChild(link);
588             renderLinkText(label, domContext, link, tab, tabSet);
589
590             Map parameterMap = getParameterMap(facesContext, tab);
591             renderOnClick(facesContext, tabSet, tab, link, parameterMap);
592
593             Iterator parameterKeys = parameterMap.keySet().iterator();
594             String nextKey;
595             while (parameterKeys.hasNext()) {
596                 nextKey = (String ) parameterKeys.next();
597                 FormRenderer.addHiddenField(facesContext, nextKey);
598             }
599
600         }
601         String tabStyleClass;
602         // set style class attributes
603 if (active) {
604             tabStyleClass = tab.getTabOnClass(tabPlacement);
605             table.setAttribute(HTML.CLASS_ATTR, tabStyleClass);
606         } else // inactive style with mouse over and out
607 {
608             tabStyleClass = tab.getTabOffClass(tabPlacement);
609             table.setAttribute(HTML.CLASS_ATTR, tabStyleClass);
610             if (!disabled) {
611                 table.setAttribute(HTML.ONMOUSEOVER_ATTR,
612                                    "this.className='" + tab.getTabOverClass(tabPlacement) + "';");
613                 table.setAttribute(HTML.ONMOUSEOUT_ATTR,
614                                    "this.className='" + tab.getTabOffClass(tabPlacement) + "';");
615             } else {
616                 table.removeAttribute(HTML.ONMOUSEOVER_ATTR);
617                 table.removeAttribute(HTML.ONMOUSEOUT_ATTR);
618             }
619         }
620
621         td_top_left.setAttribute(HTML.CLASS_ATTR, CSS_DEFAULT
622                 .PANEL_TAB_SET_DEFAULT_LEFT + CSS_DEFAULT
623                 .PANEL_TAB_SET_DEFAULT_TOP + disableStyleClassSuffix);
624         td_top_mid.setAttribute(HTML.CLASS_ATTR, CSS_DEFAULT
625                 .PANEL_TAB_SET_DEFAULT_MIDDLE + CSS_DEFAULT
626                 .PANEL_TAB_SET_DEFAULT_TOP + disableStyleClassSuffix);
627         td_top_right.setAttribute(HTML.CLASS_ATTR, CSS_DEFAULT
628                 .PANEL_TAB_SET_DEFAULT_RIGHT + CSS_DEFAULT
629                 .PANEL_TAB_SET_DEFAULT_TOP + disableStyleClassSuffix);
630
631         td_mid_left.setAttribute(HTML.CLASS_ATTR, CSS_DEFAULT
632                 .PANEL_TAB_SET_DEFAULT_LEFT + CSS_DEFAULT
633                 .PANEL_TAB_SET_DEFAULT_MIDDLE + disableStyleClassSuffix);
634         td_mid_mid.setAttribute(HTML.CLASS_ATTR, CSS_DEFAULT
635                 .PANEL_TAB_SET_DEFAULT_MIDDLE + CSS_DEFAULT
636                 .PANEL_TAB_SET_DEFAULT_MIDDLE + disableStyleClassSuffix);
637         td_mid_right.setAttribute(HTML.CLASS_ATTR, CSS_DEFAULT
638                 .PANEL_TAB_SET_DEFAULT_RIGHT + CSS_DEFAULT
639                 .PANEL_TAB_SET_DEFAULT_MIDDLE + disableStyleClassSuffix);
640
641         td_bot_left.setAttribute(HTML.CLASS_ATTR, CSS_DEFAULT
642                 .PANEL_TAB_SET_DEFAULT_LEFT + CSS_DEFAULT
643                 .PANEL_TAB_SET_DEFAULT_BOTTOM + disableStyleClassSuffix);
644         td_bot_mid.setAttribute(HTML.CLASS_ATTR, CSS_DEFAULT
645                 .PANEL_TAB_SET_DEFAULT_MIDDLE + CSS_DEFAULT
646                 .PANEL_TAB_SET_DEFAULT_BOTTOM + disableStyleClassSuffix);
647         td_bot_right.setAttribute(HTML.CLASS_ATTR, CSS_DEFAULT
648                 .PANEL_TAB_SET_DEFAULT_RIGHT + CSS_DEFAULT
649                 .PANEL_TAB_SET_DEFAULT_BOTTOM + disableStyleClassSuffix);
650
651         tr_top.appendChild(td_top_left);
652         tr_top.appendChild(td_top_mid);
653         tr_top.appendChild(td_top_right);
654         table.appendChild(tr_top);
655
656         tr_mid.appendChild(td_mid_left);
657         tr_mid.appendChild(td_mid_mid);
658         tr_mid.appendChild(td_mid_right);
659         table.appendChild(tr_mid);
660
661         tr_bot.appendChild(td_bot_left);
662         tr_bot.appendChild(td_bot_mid);
663         tr_bot.appendChild(td_bot_right);
664         table.appendChild(tr_bot);
665
666         // TODO: test passthru attributes
667 //PassThruAttributeRenderer.renderAttributes(facesContext, tab, new String[] { "onclick" });
668
669         // append Elements using the w3c DOM API appendChild
670 if (styleClass != null) {
671             td.setAttribute(HTML.CLASS_ATTR, styleClass);
672         }
673
674         if (tab.getTitle() != null) {
675             td.setAttribute(HTML.TITLE_ATTR, tab.getTitle());
676         }
677     }
678
679
680     protected static String deriveCommonHiddenFieldName(
681             FacesContext facesContext,
682             UIComponent uiComponent) {
683         if (Beans.isDesignTime()) {
684             return "";
685         }
686         try {
687             UIComponent parentNamingContainer =
688                     findNamingContainer(uiComponent);
689             String parentClientId =
690                     parentNamingContainer.getClientId(facesContext);
691             return parentClientId
692                    + NamingContainer.SEPARATOR_CHAR
693                    + UIViewRoot.UNIQUE_ID_PREFIX
694                    + HIDDEN_FIELD_NAME;
695         } catch (NullPointerException e) {
696             throw new RuntimeException ("Panel Tab Set must be in a <ice:form>",
697                                        e);
698         }
699     }
700
701     /**
702      * @param linkText
703      * @param domContext
704      * @param link
705      * @param tab
706      * @param tabSet
707      */
708     private void renderLinkText(String linkText, DOMContext
709             domContext, Element link, PanelTab tab, PanelTabSet tabSet) {
710
711         // create a new or update the old text node for the label
712 if (linkText != null && linkText.length() != 0) {
713             Text labelNode = (Text ) link.getFirstChild();
714             if (labelNode == null) {
715                 labelNode = domContext.getDocument().createTextNode(linkText);
716                 tab.addHeaderText(domContext, link, labelNode, tabSet);
717             } else {
718                 labelNode.setData(linkText);
719             }
720         }
721     }
722
723     /**
724      * This method is defined in the DomBasicRenderer with a default package
725      * visiblity. TODO: modify visiblity to public in DomBasicRenderer and
726      * remove from PanelTabSetRenderer Due to the behaviour of the UIParameter
727      * class, the names in the name-value pairs of the Map returned by this
728      * method are guaranteed to be Strings
729      *
730      * @param facesContext
731      * @param uiComponent
732      * @return map
733      */
734     static Map getParameterMap(FacesContext facesContext,
735                                UIComponent uiComponent) {
736         Map parameterMap = new HashMap ();
737         Iterator children = uiComponent.getChildren().iterator();
738         UIComponent nextChild;
739         UIParameter uiParam;
740         while (children.hasNext()) {
741             nextChild = (UIComponent) children.next();
742             if (nextChild instanceof UIParameter) {
743                 uiParam = (UIParameter) nextChild;
744                 parameterMap.put(uiParam.getName(), uiParam.getValue());
745             }
746         }
747         return parameterMap;
748     }
749
750     /**
751      * @param facesContext
752      * @param root
753      * @param parameters
754      */
755     private void renderOnClick(FacesContext facesContext,
756                                UIComponent tabSet,
757                                PanelTab tab,
758                                Element root, Map parameters) {
759         UIComponent uiForm = findForm(tabSet);
760         if (uiForm == null) {
761             throw new FacesException("CommandLink must be contained in a form");
762         }
763         String uiFormClientId = uiForm.getClientId(facesContext);
764         String onclick = "";
765         if (tab.getOnclick()!= null){
766             onclick = tab.getOnclick();
767         }
768         root.setAttribute("onclick", onclick + getJavaScriptOnClickString(facesContext,
769                                                                 tabSet,
770                                                                 uiFormClientId,
771                                                                 parameters)); // replaced command w/component
772 }
773
774     private String getJavaScriptOnClickString(FacesContext facesContext,
775                                               UIComponent uiComponent,
776                                               String formClientId,
777                                               Map parameters) {
778         return getJavascriptHiddenFieldSetters(facesContext,
779                                                uiComponent, formClientId,
780                                                parameters)
781                + "iceSubmitPartial("
782                + " document.forms['" + formClientId + "'],"
783                + " this,event); "
784                + "return false;";
785     }
786
787     /**
788      * @param facesContext
789      * @param uiComponent
790      * @param formClientId
791      * @param parameters
792      * @return string representing hidden field setters for this tabset
793      */
794     private String getJavascriptHiddenFieldSetters(FacesContext facesContext,
795                                                    UIComponent uiComponent,
796                                                    String formClientId,
797                                                    Map parameters) {
798         StringBuffer buffer;
799         buffer = new StringBuffer ("document.forms['" + formClientId + "']['");
800         buffer.append(deriveCommonHiddenFieldName(facesContext, uiComponent));
801         buffer.append("'].value='");
802         buffer.append(uiComponent.getClientId(facesContext));
803         buffer.append("';");
804         Iterator parameterKeys = parameters.keySet().iterator();
805         String nextParamName;
806         Object nextParamValue;
807         while (parameterKeys.hasNext()) {
808             nextParamName = (String ) parameterKeys.next();
809             nextParamValue = parameters.get(nextParamName);
810             buffer.append("document.forms['");
811             buffer.append(formClientId);
812             buffer.append("']['");
813             buffer.append(nextParamName);
814             buffer.append("'].value='");
815             buffer.append((String ) nextParamValue);
816             buffer.append("';");
817         }
818         return buffer.toString();
819     }
820
821     /**
822      * @param domContext
823      * @param td
824      */
825     private void renderSpacerImage(DOMContext domContext, Element td) {
826
827         // create a dummy image to load into given td
828 Element img = domContext.createElement(HTML.IMG_ELEM);
829         img.setAttribute(HTML.SRC_ATTR, CoreUtils.resolveResourceURL(
830                 FacesContext.getCurrentInstance(), SPACER_IMG));
831         img.setAttribute(HTML.HEIGHT_ATTR, "1");
832         img.setAttribute(HTML.WIDTH_ATTR, "4");
833         img.setAttribute(HTML.ALT_ATTR, "");
834
835         td.appendChild(img);
836     }
837
838     /**
839      * writeTabCell is a DOM-enabled version of the MyFaces writeTabCell
840      * implementation. Calls to the ResponseWriter have been substituted with
841      * DOMContext and w3c DOM API calls.
842      *
843      * @param domContext
844      * @param facesContext
845      * @param tabSet
846      * @param tabCount
847      * @param selectedIndex
848      * @param tr
849      * @param uiList
850      * @throws IOException
851      */
852     protected void writeTabCell(DOMContext domContext,
853                                 FacesContext facesContext,
854                                 PanelTabSet tabSet,
855                                 int tabCount,
856                                 int selectedIndex,
857                                 Element tr,
858                                 UISeries uiList)
859             throws IOException {
860         // create a new table data Element
861 Element td = domContext.createElement(HTML.TD_ELEM);
862         td.setAttribute(HTML.ID_ATTR,
863                         tabSet.getClientId(facesContext) + "td" + tabCount);
864         // append the new table data Element to the table row
865 tr.appendChild(td);
866
867         // set the table data attributes
868 //extra column for Safari table bug
869 // td.setAttribute(HTML.COLSPAN_ATTR, Integer.toString(tabCount + 2 ));
870 td.setAttribute(HTML.CLASS_ATTR, tabSet.getContentClass());
871
872         // set the cursor parent to the new table data Element
873 // this will cause the renderChild method to append the child nodes
874 // to the new table data Element
875 domContext.setCursorParent(td);
876         domContext.streamWrite(facesContext, tabSet, domContext.getRootNode(),
877                                td);
878         int tabIdx = 0;
879         if (uiList.getValue() != null) {
880             int rowIndex = uiList.getFirst();
881             uiList.setRowIndex(rowIndex);
882             int rowsToBeDisplayed = uiList.getRows();
883             int rowsDisplayed = 0;
884             UIComponent child =
885                     getUIComponent((UIComponent) tabSet.getChildren().get(0));
886             while (uiList.isRowAvailable()) {
887                 if (rowsToBeDisplayed > 0 &&
888                     rowsDisplayed >= rowsToBeDisplayed) {
889                     break;
890                 }
891                 if (child instanceof PanelTab) {
892                     if (tabIdx == selectedIndex) {
893                         CustomComponentUtils.renderChild(facesContext, child);
894                     }
895                     tabIdx++;
896                 }
897                 rowsDisplayed++;
898                 rowIndex++;
899                 uiList.setRowIndex(rowIndex);
900             }
901             uiList.setRowIndex(-1);
902         } else {
903             List children = tabSet.getChildren();
904             UIComponent child;
905             for (int i = 0, len = children.size(); i < len; i++) {
906                 child = getUIComponent((UIComponent) children.get(i));
907                 if (child instanceof PanelTab) {
908                     if (tabIdx == selectedIndex) {
909                         CustomComponentUtils.renderChild(facesContext, child);
910                     }
911                     tabIdx++;
912                 } else {
913                     CustomComponentUtils.renderChild(facesContext, child);
914                 }
915             }
916         }
917     }
918
919     private UIComponent getUIComponent(UIComponent uiComponent) {
920         if (uiComponent instanceof UIForm ||
921             uiComponent instanceof UINamingContainer) {
922             List children = uiComponent.getChildren();
923             for (int i = 0, len = children.size(); i < len; i++) {
924                 uiComponent = getUIComponent((UIComponent) children.get(i));
925             }
926         }
927         return uiComponent;
928     }
929 }
930

A to Z: JavaDoc & Examples

---

Daily Java News & Articles

---

Open Source Projects

---

Open Source Codes

---

Free Computer Books

---

Remove Frame

---

Popular Tags