Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * JBoss, Home of Professional Open Source
   * Copyright ${year}, Red Hat, Inc. and individual contributors
   * by the @authors tag. See the copyright.txt in the distribution for a
   * full listing of individual contributors.
   *
   * This is free software; you can redistribute it and/or modify it
   * under the terms of the GNU Lesser General Public License as
   * published by the Free Software Foundation; either version 2.1 of
  * the License, or (at your option) any later version.
  *
  * This software is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this software; if not, write to the Free
  * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
  * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
  */
 package org.richfaces.renderkit;
 
 import java.util.Map;
 
 import  javax.faces.application.ResourceDependencies;
 import  javax.faces.application.ResourceDependency;
 import  javax.faces.component.UIColumn;
 import  javax.faces.component.UIComponent;
 import  javax.faces.context.FacesContext;
 import  javax.faces.context.ResponseWriter;
 import  javax.faces.event.AbortProcessingException;
 
 import  org.ajax4jsf.javascript.JSFunction;
 import  org.richfaces.component.Row;
 import  org.richfaces.event.CollapsibleSubTableToggleEvent;

Author(s):
Anton Belevich
 
 @JsfRenderer(type = "org.richfaces.CollapsibleSubTableRenderer", family = .)
 @ResourceDependencies({ @ResourceDependency(library = "org.richfaces", name = "base-component.reslib"),
         @ResourceDependency(library = "org.richfaces", name = "collapsible-subtable.js"),
         @ResourceDependency(library = "org.richfaces", name = "collapsible-subtable.ecss") })
     public static final String TB_ROW = ":c";
     private static final String STATE = ":state";
     private static final String OPTIONS = ":options";
     private static final String DISPLAY_NONE = "display: none;";
 
     private class CollapsibleSubTableHiddenEncodeStrategy implements EncodeStrategy {
         public void begin(ResponseWriter writer, FacesContext context, UIComponent componentObject[] params)
             throws IOException {
             AbstractCollapsibleSubTable subTable = (AbstractCollapsibleSubTablecomponent;
             writer.startElement(HtmlConstants.TR_ELEMENT, subTable);
             writer.writeAttribute(HtmlConstants.ID_ATTRIBUTE, subTable.getContainerClientId(context) + ,
                 null);
             writer.writeAttribute(HtmlConstants.STYLE_ATTRIBUTE, null);
             writer.startElement(HtmlConstants.TD_ELEM, subTable);
         }
 
         public void end(ResponseWriter writer, FacesContext context, UIComponent componentObject[] paramsthrows IOException {
             writer.endElement(HtmlConstants.TD_ELEM);
             writer.endElement(HtmlConstants.TR_ELEMENT);
 
             if (params != null && params.length == 1) {
                 boolean endTbody = (Booleanparams[0];
                 if (endTbody) {
                     encodeTableBodyEnd(writer);
                 }
             }
         }
     }
 
     ;
 
     protected void doDecode(FacesContext facesContext, UIComponent component) {
         AbstractCollapsibleSubTable subTable = (AbstractCollapsibleSubTablecomponent;
 
         String clientId = subTable.getClientId(facesContext);
         Map<StringStringrequestMap = facesContext.getExternalContext().getRequestParameterMap();
 
         String optionsId = clientId + ;
         String togglerId = requestMap.get(optionsId);
 
         String stateId = clientId + ;
         String state = (StringrequestMap.get(stateId);
 
         boolean isExpanded = true;
         if (state != null) {
            int newValue = Integer.parseInt(state);
            if (newValue < 1) {
                isExpanded = false;
            }
            if (subTable.isExpanded() != isExpanded) {
                new CollapsibleSubTableToggleEvent(subTableisExpandedtogglerId).queue();
            }
        }
    }
    @Override
    public void encodeFirstRowStart(ResponseWriter writer, FacesContext contextString parentIdint currentRow,
        UIComponent componentthrows IOException {
        writer.startElement(HtmlConstants.TR_ELEMENT, component);
        writer.writeAttribute(HtmlConstants.ID_ATTRIBUTE, parentId + ":" + currentRow + ":b"null);
        String styleClass = concatClasses(getRowClass(contextparentId), getFirstRowClass(contextparentId), component
            .getAttributes().get());
        encodeStyleClass(writercontextcomponent, HtmlConstants.STYLE_CLASS_ATTR, styleClass);
    }
    @Override
    public void encodeRowStart(ResponseWriter writer, FacesContext contextString parentIdint currentRow,
        UIComponent componentthrows IOException {
        writer.startElement(HtmlConstants.TR_ELEMENT, component);
        writer.writeAttribute(HtmlConstants.ID_ATTRIBUTE, parentId + ":" + currentRow + ":b"null);
        String styleClass = concatClasses(getRowClass(contextparentId), component.getAttributes().get());
        encodeStyleClass(writercontextcomponent, HtmlConstants.STYLE_CLASS_ATTR, styleClass);
    }
    public void encodeTableFacets(ResponseWriter writer, FacesContext contextUIDataTableBase dataTablethrows IOException {
        AbstractCollapsibleSubTable subTable = (AbstractCollapsibleSubTabledataTable;
        encodeStyle(writercontextsubTablenull);
        encodeHeaderFacet(writercontextsubTablefalse);
        String rowClass = getRowSkinClass();
        String cellClass = getCellSkinClass();
        String firstClass = getFirstRowSkinClass();
        rowClass = mergeStyleClasses("rowClass"rowClasssubTable);
        cellClass = mergeStyleClasses("cellClass"cellClasssubTable);
        firstClass = mergeStyleClasses("firstRowClass"firstClasssubTable);
        saveRowStyles(contextsubTable.getContainerClientId(context), firstClassrowClasscellClass);
    }
    @Override
    public void encodeTableBodyStart(ResponseWriter writer, FacesContext facesContextUIDataTableBase dataTableBase)
        throws IOException {
        AbstractCollapsibleSubTable subTable = (AbstractCollapsibleSubTabledataTableBase;
        UIDataTableBase component = findParent(subTable);
        if (component instanceof AbstractDataTable) {
            writer.startElement(HtmlConstants.TBODY_ELEMENT, null);
            writer.writeAttribute(HtmlConstants.ID_ATTRIBUTE,
                component.getRelativeClientId(facesContext) + ":" + subTable.getId() + null);
            writer.writeAttribute(HtmlConstants.CLASS_ATTRIBUTE, getTableSkinClass(), null);
            String predefinedStyles = !subTable.isExpanded() ?  : null;
            encodeStyle(writerfacesContextsubTablepredefinedStyles);
        }
    }
    @Override
    public void encodeBeforeRows(ResponseWriter writer, FacesContext facesContextUIDataTableBase dataTableBase,
        boolean encodeParentTBodyboolean partialUpdatethrows IOException {
        AbstractCollapsibleSubTable subTable = (AbstractCollapsibleSubTabledataTableBase;
        encodeTableBodyStart(writerfacesContextsubTable);
        encodeSubTableDomElement(writerfacesContextsubTable);
        encodeHeaderFacet(writerfacesContextsubTablefalse);
    }
    private void encodeSubTableDomElement(ResponseWriter writer, FacesContext facesContextAbstractCollapsibleSubTable subTable)
        throws IOException {
        writer.startElement(HtmlConstants.TR_ELEMENT, subTable);
        writer.writeAttribute(HtmlConstants.STYLE_ATTRIBUTE, null);
        writer.writeAttribute(HtmlConstants.ID_ATTRIBUTE, subTable.getContainerClientId(facesContext), null);
        writer.startElement(HtmlConstants.TD_ELEM, subTable);
        writer.endElement(HtmlConstants.TD_ELEM);
        writer.endElement(HtmlConstants.TR_ELEMENT);
    }
    public void encodeRow(ResponseWriter writer, FacesContext facesContextRowHolderBase holderthrows IOException {
        RowHolder rowHolder = (RowHolderholder;
        Row row = rowHolder.getRow();
        putRowStylesIntoContext(facesContextrowHolder);
        rowHolder.setRowStart(true);
        Iterator<UIComponent> components = row.columns();
        if (rowHolder.isUpdatePartial()) {
            partialStart(facesContext, ((AbstractCollapsibleSubTablerow).getRelativeClientId(facesContext) + ":b");
        }
        int columnNumber = 0;
        while (components.hasNext()) {
            UIComponent component = components.next();
            if (component.isRendered()) {
                if (component instanceof UIColumn) {
                    component.getAttributes().put(getColumnClass(rowHoldercolumnNumber));
                    encodeColumn(facesContextwriter, (UIColumn) componentrowHolder);
                    columnNumber++;
                } else if (component instanceof AbstractCollapsibleSubTable) {
                    if (component.isRendered()) {
                        encodeRowEnd(writer);
                    }
                    component.encodeAll(facesContext);
                    rowHolder.setRowStart(true);
                }
            }
        }
        encodeRowEnd(writer);
        if (rowHolder.isUpdatePartial()) {
            partialEnd(facesContext);
        }
    }
    @Override
    public void encodeAfterRows(ResponseWriter writer, FacesContext facesContextUIDataTableBase dataTableBase,
        boolean encodeParentTBodyboolean partialUpdatethrows IOException {
        AbstractCollapsibleSubTable subTable = (AbstractCollapsibleSubTabledataTableBase;
        encodeFooterFacet(writerfacesContextsubTablefalse);
    }
    @Override
    public boolean encodeParentTBody(UIDataTableBase dataTableBase) {
        UIDataTableBase parent = findParent((AbstractCollapsibleSubTabledataTableBase);
        return (parent instanceof AbstractDataTable);
    }
    public void encodeHiddenInput(ResponseWriter writer, FacesContext facesContextUIDataTableBase dataTableBase)
        throws IOException {
        AbstractCollapsibleSubTable subTable = (AbstractCollapsibleSubTabledataTableBase;
        String stateId = subTable.getClientId(facesContext) + ;
        writer.startElement(HtmlConstants.INPUT_ELEM, subTable);
        writer.writeAttribute(HtmlConstants.ID_ATTRIBUTE, stateIdnull);
        writer.writeAttribute(HtmlConstants.NAME_ATTRIBUTE, stateIdnull);
        writer.writeAttribute(HtmlConstants.TYPE_ATTR, HtmlConstants.INPUT_TYPE_HIDDEN, null);
        int state = subTable.isExpanded() ? .
        writer.writeAttribute(HtmlConstants.VALUE_ATTRIBUTE, statenull);
        writer.endElement(HtmlConstants.INPUT_ELEM);
        String optionsId = subTable.getClientId(facesContext) + ;
        writer.startElement(HtmlConstants.INPUT_ELEM, subTable);
        writer.writeAttribute(HtmlConstants.ID_ATTRIBUTE, optionsIdnull);
        writer.writeAttribute(HtmlConstants.NAME_ATTRIBUTE, optionsIdnull);
        writer.writeAttribute(HtmlConstants.TYPE_ATTR, HtmlConstants.INPUT_TYPE_HIDDEN, null);
        writer.endElement(HtmlConstants.INPUT_ELEM);
    }
    public boolean containsThead() {
        return false;
    }
    public EncodeStrategy getHeaderEncodeStrategy(UIComponent columnString tableFacetName) {
        // TODO: anton -> use RichHeaderEncodeStrategy for our columns ???
        return new SimpleHeaderEncodeStrategy();
    }
    public void encodeClientScript(ResponseWriter writer, FacesContext facesContextUIDataTableBase component)
        throws IOException {
        AbstractCollapsibleSubTable subTable = (AbstractCollapsibleSubTablecomponent;
        String id = subTable.getClientId(facesContext);
        UIComponent nestingForm = getUtils().getNestingForm(facesContextsubTable);
        String formId = nestingForm != null ? nestingForm.getClientId(facesContext) : "";
        Map<StringObjectoptions = new HashMap<StringObject>();
        options.put("stateInput"subTable.getClientId(facesContext) + );
        options.put("optionsInput"subTable.getClientId(facesContext) + );
        options.put("expandMode"subTable.getExpandMode());
        options.put("eventOptions", AjaxRendererUtils.buildEventOptions(facesContextsubTable));
        JSFunction jsFunction = new JSFunction("new RichFaces.ui.CollapsibleSubTable");
        jsFunction.addParameter(id);
        jsFunction.addParameter(formId);
        jsFunction.addParameter(options);
        writer.startElement(HtmlConstants.SCRIPT_ELEM, subTable);
        writer.writeAttribute(HtmlConstants.TYPE_ATTR, HtmlConstants.JAVASCRIPT_TYPE, null);
        writer.writeText(jsFunction.toScript(), null);
        writer.endElement(HtmlConstants.SCRIPT_ELEM);
    }
    public String getTableSkinClass() {
        return "rf-cst";
    }
    public String getRowSkinClass() {
        return "rf-cst-r";
    }
    public String getFirstRowSkinClass() {
        return "rf-cst-fst-r";
    }
    public String getHeaderRowSkinClass() {
        return "rf-cst-hdr-r";
    }
        return "rf-cst-hdr-fst-r";
    }
    public String getCellSkinClass() {
        return "rf-cst-c";
    }
    public String getHeaderCellSkinClass() {
        return "rf-cst-hdr-c";
    }
        return "rf-cst-shdr-c";
    }
    public String getColumnHeaderSkinClass() {
        return "rf-cst-shdr";
    }
    public String getFooterSkinClass() {
        return "rf-cst-ftr";
    }
    public String getFooterCellSkinClass() {
        return "rf-cst-ftr-c";
    }
        return "rf-cst-ftr-fst";
    }
        return "rf-cst-sftr-c";
    }
    public String getColumnFooterSkinClass() {
        return "rf-cst-sftr";
    }
        return "rf-cst-sftr-fst";
    }
        return "rf-cst-shdr-fst";
    }
    public String getFooterFirstSkinClass() {
        return "rf-cst-ftr-fst";
    }
    public String getHeaderFirstSkinClass() {
        return "rf-cst-hdr-fst";
    }
    public String getHeaderSkinClass() {
        return "rf-cst-hdr";
    }
    public String getNoDataClass() {
        return "rf-cst-nd";
    }
    @Override
    public String getNoDataCellClass() {
        return "rf-cst-nd-c";
    }
    @Override
    public String getTableBodySkinClass() {
        // AbstractSubTable doesn't have tbody
        return null;
    }
    @Override
    public void encodeMetaComponent(FacesContext facesContext, UIComponent componentString metaComponentId)
        throws IOException {
        AbstractCollapsibleSubTable subTable = (AbstractCollapsibleSubTablecomponent;
        if (..equals(metaComponentId)) {
            ResponseWriter writer = facesContext.getResponseWriter();
            UIDataTableBase dataTableBase = findParent(subTable);
            String updateId = dataTableBase.getRelativeClientId(facesContext) + ":" + subTable.getId() + ;
            partialStart(facesContextupdateId);
            encodeTableRows(writerfacesContextsubTablefalse);
            partialEnd(facesContext);
        }
    }
    @Override
        return new CollapsibleSubTableHiddenEncodeStrategy();
    }
        UIComponent parent = subTable.getParent();
        while (parent != null && !(parent instanceof UIDataTableBase)) {
            parent = parent.getParent();
        }
        if (parent == null) {
            // TODO: anton -> do we need this?
            throw new AbortProcessingException("UISubTable should be a child of UIDataTable or UISubTable");
        }
        return (UIDataTableBaseparent;
    }
New to GrepCode? Check out our FAQ X