/**
 * Copyright 2005-2016 The Kuali Foundation
 *
 * Licensed under the Educational Community 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.opensource.org/licenses/ecl2.php
 *
 * 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.kuali.rice.krad.uif.layout;

import org.apache.commons.lang.StringUtils;
import org.kuali.rice.krad.uif.UifConstants;
import org.kuali.rice.krad.uif.component.DataBinding;
import org.kuali.rice.krad.uif.container.CollectionGroup;
import org.kuali.rice.krad.uif.container.Container;
import org.kuali.rice.krad.uif.container.Group;
import org.kuali.rice.krad.uif.field.DataField;
import org.kuali.rice.krad.uif.field.FieldGroup;
import org.kuali.rice.krad.uif.field.InputField;
import org.kuali.rice.krad.uif.view.View;
import org.kuali.rice.krad.uif.component.Component;
import org.kuali.rice.krad.uif.field.ActionField;
import org.kuali.rice.krad.uif.field.Field;
import org.kuali.rice.krad.uif.field.LabelField;
import org.kuali.rice.krad.uif.field.MessageField;
import org.kuali.rice.krad.uif.util.ComponentFactory;
import org.kuali.rice.krad.uif.util.ComponentUtils;
import org.kuali.rice.krad.uif.widget.RichTable;
import org.kuali.rice.krad.web.form.UifFormBase;

import java.util.ArrayList;
import java.util.List;
import java.util.Set;

/**
 * Layout manager that works with <code>CollectionGroup</code> components and
 * renders the collection as a Table
 * 
 * <p>
 * Based on the fields defined, the <code>TableLayoutManager</code> will
 * dynamically create instances of the fields for each collection row. In
 * addition, the manager can create standard fields like the action and sequence
 * fields for each row. The manager supports options inherited from the
 * <code>GridLayoutManager</code> such as rowSpan, colSpan, and cell width
 * settings.
 * </p>
 * 
 * @author Kuali Rice Team (rice.collab@kuali.org)
 */
public class TableLayoutManager extends GridLayoutManager implements CollectionLayoutManager {
        private static final long serialVersionUID = 3622267585541524208L;

        private boolean useShortLabels;
        private boolean repeatHeader;
        private LabelField headerFieldPrototype;

        private boolean renderSequenceField;
        private boolean generateAutoSequence;
        private Field sequenceFieldPrototype;

        private FieldGroup actionFieldPrototype;
        private FieldGroup subCollectionFieldGroupPrototype;
    private Field selectFieldPrototype;

    private boolean separateAddLine;
    private Group addLineGroup;

        // internal counter for the data columns (not including sequence, action)
        private int numberOfDataColumns;

        private List<LabelField> headerFields;
        private List<Field> dataFields;

        private RichTable richTable;
        private boolean headerAdded = false;

    private Set<String> hiddenColumns;
    private Set<String> sortableColumns;

        public TableLayoutManager() {
                useShortLabels = true;
                repeatHeader = false;
                renderSequenceField = true;
                generateAutoSequence = false;
        separateAddLine = false;

                headerFields = new ArrayList<LabelField>();
                dataFields = new ArrayList<Field>();
        }
        
        /**
         * The following actions are performed:
         * 
         * <ul>
         * <li>Sets sequence field prototype if auto sequence is true</li>
         * <li>Initializes the prototypes</li>
         * </ul>
         * 
         * @see org.kuali.rice.krad.uif.layout.BoxLayoutManager#performInitialization(org.kuali.rice.krad.uif.view.View,
         *      java.lang.Object, org.kuali.rice.krad.uif.container.Container)
         */
        @Override
        public void performInitialization(View view, Object model, Container container) {
                super.performInitialization(view, model, container);
                
        if (generateAutoSequence && !(sequenceFieldPrototype instanceof MessageField)) {
            sequenceFieldPrototype = ComponentFactory.getMessageField();
            view.assignComponentIds(sequenceFieldPrototype);
        }

                view.getViewHelperService().performComponentInitialization(view, model, headerFieldPrototype);
                view.getViewHelperService().performComponentInitialization(view, model, sequenceFieldPrototype);
                view.getViewHelperService().performComponentInitialization(view, model, actionFieldPrototype);
                view.getViewHelperService().performComponentInitialization(view, model, subCollectionFieldGroupPrototype);
        view.getViewHelperService().performComponentInitialization(view, model, selectFieldPrototype);
        }

        /**
         * Sets up the final column count for rendering based on whether the
         * sequence and action fields have been generated
         * 
         * @see org.kuali.rice.krad.uif.layout.LayoutManagerBase#performFinalize(org.kuali.rice.krad.uif.view.View,
         *      java.lang.Object, org.kuali.rice.krad.uif.container.Container)
         */
        @Override
        public void performFinalize(View view, Object model, Container container) {
                super.performFinalize(view, model, container);

        UifFormBase formBase = (UifFormBase) model;

                CollectionGroup collectionGroup = (CollectionGroup) container;

                int totalColumns = getNumberOfDataColumns();
                if (renderSequenceField) {
                        totalColumns++;
                }

        if (collectionGroup.isRenderSelectField()) {
            totalColumns++;
        }

                if (collectionGroup.isRenderLineActions() && !collectionGroup.isReadOnly()) {
                        totalColumns++;
                }

        if (collectionGroup.isRenderAddLine()){
            if(StringUtils.isBlank(this.getFirstLineStyle()) && !isSeparateAddLine()){
                this.setFirstLineStyle("kr-addLine");
            }
        }

        // if add line event, add highlighting for added row
        if (UifConstants.ActionEvents.ADD_LINE.equals(formBase.getActionEvent())) {
            String highlightScript =
                    "jq(\"#" + container.getId() + "_div > tr:first\").effect(\"highlight\",{}, 6000);";
            String onReadyScript = collectionGroup.getOnDocumentReadyScript();
            if (StringUtils.isNotBlank(onReadyScript)) {
                highlightScript = onReadyScript + highlightScript;
            }
            collectionGroup.setOnDocumentReadyScript(highlightScript);
        }
                setNumberOfColumns(totalColumns);
        }

        /**
         * Assembles the field instances for the collection line. The given sequence
         * field prototype is copied for the line sequence field. Likewise a copy of
         * the actionFieldPrototype is made and the given actions are set as the
         * items for the action field. Finally the generated items are assembled
         * together into the dataFields list with the given lineFields.
         * 
         * @see org.kuali.rice.krad.uif.layout.CollectionLayoutManager#buildLine(org.kuali.rice.krad.uif.view.View,
         *      java.lang.Object, org.kuali.rice.krad.uif.container.CollectionGroup,
         *      java.util.List, java.util.List, java.lang.String, java.util.List,
         *      java.lang.String, java.lang.Object, int)
         */
        public void buildLine(View view, Object model, CollectionGroup collectionGroup, List<Field> lineFields,
                        List<FieldGroup> subCollectionFields, String bindingPath, List<ActionField> actions, String idSuffix,
                        Object currentLine, int lineIndex) {
                boolean isAddLine = lineIndex == -1;

        // if separate add line prepare the add line group
        if (isAddLine && separateAddLine) {
            if (StringUtils.isBlank(addLineGroup.getTitle()) && StringUtils.isBlank(
                    addLineGroup.getHeader().getHeaderText())) {
               addLineGroup.getHeader().setHeaderText(collectionGroup.getAddLineLabel());
            }

            addLineGroup.setItems(lineFields);

            List<Component> footerItems = new ArrayList<Component>(actions);
            footerItems.addAll(addLineGroup.getFooter().getItems());
            addLineGroup.getFooter().setItems(footerItems);

            return;
        }

        // if first line for table set number of data columns
        if (dataFields.isEmpty()) {
            if (isSuppressLineWrapping()) {
                setNumberOfDataColumns(lineFields.size());
            } else {
                setNumberOfDataColumns(getNumberOfColumns());
            }
        }

                // TODO: implement repeat header
                if (!headerAdded) {
                        headerFields = new ArrayList<LabelField>();
                        dataFields = new ArrayList<Field>();

                        buildTableHeaderRows(collectionGroup, lineFields);
                        ComponentUtils.pushObjectToContext(headerFields, UifConstants.ContextVariableNames.LINE, currentLine);
                        ComponentUtils.pushObjectToContext(headerFields, UifConstants.ContextVariableNames.INDEX, new Integer(
                                        lineIndex));
                        headerAdded = true;
                }

                // set label field rendered to true on line fields
                for (Field field : lineFields) {
                        field.setLabelFieldRendered(true);

                        // don't display summary message
                        // TODO: remove once we have modifier
                        ComponentUtils.setComponentPropertyDeep(field, "summaryMessageField.render", new Boolean(false));
                }

                int rowCount = calculateNumberOfRows(lineFields);
                int rowSpan = rowCount + subCollectionFields.size();

                // sequence field is always first and should span all rows for the line
                if (renderSequenceField) {
                        Field sequenceField = null;
            if (!isAddLine) {
                sequenceField = ComponentUtils.copy(sequenceFieldPrototype, idSuffix);

                if (generateAutoSequence && (sequenceField instanceof MessageField)) {
                    ((MessageField) sequenceField).setMessageText(Integer.toString(lineIndex + 1));
                }
            }
                        else {
                                sequenceField = ComponentUtils.copy(collectionGroup.getAddLineLabelField(), idSuffix);
                        }
                        sequenceField.setRowSpan(rowSpan);

                        if (sequenceField instanceof DataBinding) {
                                ((DataBinding) sequenceField).getBindingInfo().setBindByNamePrefix(bindingPath);
                        }

                        ComponentUtils.updateContextForLine(sequenceField, currentLine, lineIndex);
                        dataFields.add(sequenceField);
                }

        // select field will come after sequence field (if enabled) or be first column
        if (collectionGroup.isRenderSelectField()) {
            Field selectField = ComponentUtils.copy(selectFieldPrototype, idSuffix);
            CollectionLayoutUtils.prepareSelectFieldForLine(selectField, collectionGroup, bindingPath, currentLine);

            ComponentUtils.updateContextForLine(selectField, currentLine, lineIndex);
            dataFields.add(selectField);
        }

                // now add the fields in the correct position
                int cellPosition = 0;
                for (Field lineField : lineFields) {
                        dataFields.add(lineField);

                        cellPosition += lineField.getColSpan();

                        // action field should be in last column
                        if ((cellPosition == getNumberOfDataColumns()) && collectionGroup.isRenderLineActions()
                                        && !collectionGroup.isReadOnly()) {
                                FieldGroup lineActionsField = ComponentUtils.copy(actionFieldPrototype, idSuffix);

                                ComponentUtils.updateContextForLine(lineActionsField, currentLine, lineIndex);
                                lineActionsField.setRowSpan(rowSpan);
                                lineActionsField.setItems(actions);

                                dataFields.add(lineActionsField);
                        }
                }

                // update colspan on sub-collection fields
                for (FieldGroup subCollectionField : subCollectionFields) {
                        subCollectionField.setColSpan(numberOfDataColumns);
                }

                // add sub-collection fields to end of data fields
                dataFields.addAll(subCollectionFields);
        }

        /**
         * Create the <code>LabelField</code> instances that will be used to render
         * the table header
         * 
         * <p>
         * For each column, a copy of headerFieldPrototype is made that determines
         * the label configuration. The actual label text comes from the field for
         * which the header applies to. The first column is always the sequence (if
         * enabled) and the last column contains the actions. Both the sequence and
         * action header fields will span all rows for the header.
         * </p>
         * 
         * <p>
         * The headerFields list will contain the final list of header fields built
         * </p>
         * 
         * @param collectionGroup
         *            - CollectionGroup container the table applies to
         * @param lineFields - fields for the data columns from which the headers are pulled
         */
        protected void buildTableHeaderRows(CollectionGroup collectionGroup, List<Field> lineFields) {
                // row count needed to determine the row span for the sequence and
                // action fields, since they should span all rows for the line
                int rowCount = calculateNumberOfRows(lineFields);

                // first column is sequence label
                if (renderSequenceField) {
                        sequenceFieldPrototype.setLabelFieldRendered(true);
                        sequenceFieldPrototype.setRowSpan(rowCount);
                        addHeaderField(sequenceFieldPrototype, 1);
                }

        // next is select field
        if (collectionGroup.isRenderSelectField()) {
            selectFieldPrototype.setLabelFieldRendered(true);
            selectFieldPrototype.setRowSpan(rowCount);
            addHeaderField(selectFieldPrototype, 1);
        }

                // pull out label fields from the container's items
                int cellPosition = 0;
                for (Field field : lineFields) {
                    if (!field.isRender() && StringUtils.isEmpty(field.getProgressiveRender())) {
                        continue;
                    }
                    
                        cellPosition += field.getColSpan();
                        addHeaderField(field, cellPosition);

                        // add action header as last column in row
                        if ((cellPosition == getNumberOfDataColumns()) && collectionGroup.isRenderLineActions()
                                        && !collectionGroup.isReadOnly()) {
                                actionFieldPrototype.setLabelFieldRendered(true);
                                actionFieldPrototype.setRowSpan(rowCount);
                                addHeaderField(actionFieldPrototype, cellPosition);
                        }
                }
        }

        /**
         * Creates a new instance of the header field prototype and then sets the
         * label to the short (if useShortLabels is set to true) or long label of
         * the given component. After created the header field is added to the list
         * making up the table header
         * 
         * @param field
         *            - field instance the header field is being created for
         * @param column
         *            - column number for the header, used for setting the id
         */
        protected void addHeaderField(Field field, int column) {
                LabelField headerField = ComponentUtils.copy(headerFieldPrototype, "_c" + column);
                if (useShortLabels) {
                        headerField.setLabelText(field.getLabel());
                }
                else {
                        headerField.setLabelText(field.getLabel());
                }

                headerField.setRowSpan(field.getRowSpan());
                headerField.setColSpan(field.getColSpan());

                if ((field.getRequired() != null) && field.getRequired().booleanValue()) {
                        headerField.getRequiredMessageField().setRender(true);
                }
                else {
                        headerField.getRequiredMessageField().setRender(false);
                }

                headerFields.add(headerField);
        }

        /**
         * Calculates how many rows will be needed per collection line to display
         * the list of fields. Assumption is made that the total number of cells the
         * fields take up is evenly divisible by the configured number of columns
         * 
         * @param items
         *            - list of items that make up one collection line
         * @return int number of rows
         */
        protected int calculateNumberOfRows(List<? extends Field> items) {
                int rowCount = 0;
                
                // check flag that indicates only one row should be created
                if (isSuppressLineWrapping()) {
                    return 1;
                }

                int cellCount = 0;
                for (Field field : items) {
                        cellCount += field.getColSpan() + field.getRowSpan() - 1;
                }

                if (cellCount != 0) {
                        rowCount = cellCount / getNumberOfDataColumns();
                }

                return rowCount;
        }

        /**
         * @see org.kuali.rice.krad.uif.layout.ContainerAware#getSupportedContainer()
         */
        @Override
        public Class<? extends Container> getSupportedContainer() {
                return CollectionGroup.class;
        }

        /**
         * @see org.kuali.rice.krad.uif.layout.LayoutManagerBase#getComponentsForLifecycle()
         */
        @Override
        public List<Component> getComponentsForLifecycle() {
                List<Component> components = super.getComponentsForLifecycle();

                components.add(richTable);
        components.add(addLineGroup);
                components.addAll(headerFields);
                components.addAll(dataFields);

                return components;
        }

    /**
     * @see org.kuali.rice.krad.uif.layout.LayoutManager#getComponentPrototypes()
     */
    @Override
    public List<Component> getComponentPrototypes() {
        List<Component> components = super.getComponentPrototypes();

        components.add(headerFieldPrototype);
        components.add(sequenceFieldPrototype);
        components.add(actionFieldPrototype);
        components.add(subCollectionFieldGroupPrototype);
        components.add(selectFieldPrototype);

        return components;
    }

        /**
         * Indicates whether the short label for the collection field should be used
         * as the table header or the regular label
         * 
         * @return boolean true if short label should be used, false if long label
         *         should be used
         */
        public boolean isUseShortLabels() {
                return this.useShortLabels;
        }

        /**
         * Setter for the use short label indicator
         * 
         * @param useShortLabels
         */
        public void setUseShortLabels(boolean useShortLabels) {
                this.useShortLabels = useShortLabels;
        }

        /**
         * Indicates whether the header should be repeated before each collection
         * row. If false the header is only rendered at the beginning of the table
         * 
         * @return boolean true if header should be repeated, false if it should
         *         only be rendered once
         */
        public boolean isRepeatHeader() {
                return this.repeatHeader;
        }

        /**
         * Setter for the repeat header indicator
         * 
         * @param repeatHeader
         */
        public void setRepeatHeader(boolean repeatHeader) {
                this.repeatHeader = repeatHeader;
        }

        /**
         * <code>LabelField</code> instance to use as a prototype for creating the
         * tables header fields. For each header field the prototype will be copied
         * and adjusted as necessary
         * 
         * @return LabelField instance to serve as prototype
         */
        public LabelField getHeaderFieldPrototype() {
                return this.headerFieldPrototype;
        }

        /**
         * Setter for the header field prototype
         * 
         * @param headerFieldPrototype
         */
        public void setHeaderFieldPrototype(LabelField headerFieldPrototype) {
                this.headerFieldPrototype = headerFieldPrototype;
        }

        /**
         * List of <code>LabelField</code> instances that should be rendered to make
         * up the tables header
         * 
         * @return List of label field instances
         */
        public List<LabelField> getHeaderFields() {
                return this.headerFields;
        }

        /**
         * Indicates whether the sequence field should be rendered for the
         * collection
         * 
         * @return boolean true if sequence field should be rendered, false if not
         */
        public boolean isRenderSequenceField() {
                return this.renderSequenceField;
        }

        /**
         * Setter for the render sequence field indicator
         * 
         * @param renderSequenceField
         */
        public void setRenderSequenceField(boolean renderSequenceField) {
                this.renderSequenceField = renderSequenceField;
        }

        /**
         * Attribute name to use as sequence value. For each collection line the
         * value of this field on the line will be retrieved and used as the
         * sequence value
         * 
         * @return String sequence property name
         */
    public String getSequencePropertyName() {
        if ((sequenceFieldPrototype != null) && (sequenceFieldPrototype instanceof DataField)) {
            return ((DataField) sequenceFieldPrototype).getPropertyName();
        }

        return null;
    }

    /**
     * Setter for the sequence property name
     * 
     * @param sequencePropertyName
     */
    public void setSequencePropertyName(String sequencePropertyName) {
        if ((sequenceFieldPrototype != null) && (sequenceFieldPrototype instanceof DataField)) {
            ((DataField) sequenceFieldPrototype).setPropertyName(sequencePropertyName);
        }
    }
        
    /**
     * Indicates whether the sequence field should be generated with the current
     * line number
     * 
     * <p>
     * If set to true the sequence field prototype will be changed to a message
     * field (if not already a message field) and the text will be set to the
     * current line number
     * </p>
     * 
     * @return boolean true if the sequence field should be generated from the
     *         line number, false if not
     */
    public boolean isGenerateAutoSequence() {
        return this.generateAutoSequence;
    }

    /**
     * Setter for the generate auto sequence field
     * 
     * @param generateAutoSequence
     */
    public void setGenerateAutoSequence(boolean generateAutoSequence) {
        this.generateAutoSequence = generateAutoSequence;
    }

    /**
         * <code>Field</code> instance to serve as a prototype for the
         * sequence field. For each collection line this instance is copied and
         * adjusted as necessary
         * 
         * @return Attribute field instance
         */
        public Field getSequenceFieldPrototype() {
                return this.sequenceFieldPrototype;
        }

        /**
         * Setter for the sequence field prototype
         * 
         * @param sequenceFieldPrototype
         */
        public void setSequenceFieldPrototype(Field sequenceFieldPrototype) {
                this.sequenceFieldPrototype = sequenceFieldPrototype;
        }

        /**
         * <code>FieldGroup</code> instance to serve as a prototype for the actions
         * column. For each collection line this instance is copied and adjusted as
         * necessary. Note the actual actions for the group come from the collection
         * groups actions List
         * (org.kuali.rice.krad.uif.container.CollectionGroup.getActionFields()). The
         * FieldGroup prototype is useful for setting styling of the actions column
         * and for the layout of the action fields. Note also the label associated
         * with the prototype is used for the action column header
         * 
         * @return GroupField instance
         */
        public FieldGroup getActionFieldPrototype() {
                return this.actionFieldPrototype;
        }

        /**
         * Setter for the action field prototype
         * 
         * @param actionFieldPrototype
         */
        public void setActionFieldPrototype(FieldGroup actionFieldPrototype) {
                this.actionFieldPrototype = actionFieldPrototype;
        }

        /**
         * @see org.kuali.rice.krad.uif.layout.CollectionLayoutManager#getSubCollectionFieldGroupPrototype()
         */
        public FieldGroup getSubCollectionFieldGroupPrototype() {
                return this.subCollectionFieldGroupPrototype;
        }

        /**
         * Setter for the sub-collection field group prototype
         * 
         * @param subCollectionFieldGroupPrototype
         */
        public void setSubCollectionFieldGroupPrototype(FieldGroup subCollectionFieldGroupPrototype) {
                this.subCollectionFieldGroupPrototype = subCollectionFieldGroupPrototype;
        }

    /**
     * Field instance that serves as a prototype for creating the select field on each line when
     * {@link org.kuali.rice.krad.uif.container.CollectionGroup#isRenderSelectField()} is true
     *
     * <p>
     * This prototype can be used to set the control used for the select field (generally will be a checkbox control)
     * in addition to styling and other setting. The binding path will be formed with using the
     * {@link org.kuali.rice.krad.uif.container.CollectionGroup#getSelectPropertyName()} or if not set the framework
     * will use {@link org.kuali.rice.krad.web.form.UifFormBase#getSelectedCollectionLines()}
     * </p>
     *
     * @return Field select field prototype instance
     */
    public Field getSelectFieldPrototype() {
        return selectFieldPrototype;
    }

    /**
     * Setter for the prototype instance for select fields
     *
     * @param selectFieldPrototype
     */
    public void setSelectFieldPrototype(Field selectFieldPrototype) {
        this.selectFieldPrototype = selectFieldPrototype;
    }

    /**
     * Indicates whether the add line should be rendered in a separate group, or as part of the table (first line)
     *
     * <p>
     * When separate add line is enabled, the fields for the add line will be placed in the {@link #getAddLineGroup()}.
     * This group can be used to configure the add line presentation. In addition to the fields, the header on the
     * group (unless already set) will be set to
     * {@link org.kuali.rice.krad.uif.container.CollectionGroup#getAddLineLabel()} and the add line actions will
     * be placed into the group's footer.
     * </p>
     *
     * @return boolean true if add line should be separated, false if it should be placed into the table
     */
    public boolean isSeparateAddLine() {
        return separateAddLine;
    }

    /**
     * Setter for the separate add line indicator
     *
     * @param separateAddLine
     */
    public void setSeparateAddLine(boolean separateAddLine) {
        this.separateAddLine = separateAddLine;
    }

    /**
     * When {@link #isSeparateAddLine()} is true, this group will be used to render the add line
     *
     * <p>
     * This group can be used to configure how the add line will be rendered. For example the layout manager configured
     * on the group will be used to rendered the add line fields. If the header (title) is not set on the group, it
     * will be set from
     * {@link org.kuali.rice.krad.uif.container.CollectionGroup#getAddLineLabel()}. In addition,
     * {@link org.kuali.rice.krad.uif.container.CollectionGroup#getAddLineActionFields()} will be added to the group
     * footer items.
     * </p>
     *
     * @return Group instance for the collection add line
     */
    public Group getAddLineGroup() {
        return addLineGroup;
    }

    /**
     * Setter for the add line Group
     *
     * @param addLineGroup
     */
    public void setAddLineGroup(Group addLineGroup) {
        this.addLineGroup = addLineGroup;
    }

    /**
         * List of <code>Field</code> instances that make up the tables body. Pulled
         * by the layout manager template to send through the Grid layout
         * 
         * @return List<Field> table body fields
         */
        public List<Field> getDataFields() {
                return this.dataFields;
        }

        /**
         * Widget associated with the table to add functionality such as sorting,
         * paging, and export
         * 
         * @return TableTools instance
         */
        public RichTable getRichTable() {
                return this.richTable;
        }

        /**
         * Setter for the table tools widget
         * 
         * @param richTable
         */
        public void setRichTable(RichTable richTable) {
                this.richTable = richTable;
        }

        /**
     * @return the numberOfDataColumns
     */
    public int getNumberOfDataColumns() {
        return this.numberOfDataColumns;
    }

        /**
     * @param numberOfDataColumns the numberOfDataColumns to set
     */
    public void setNumberOfDataColumns(int numberOfDataColumns) {
        this.numberOfDataColumns = numberOfDataColumns;
    }

    /** since columns are visible by default, this set holds propertyNames for the ones meant to be hidden*/
    public Set<String> getHiddenColumns() {
        return hiddenColumns;
    }

    public void setHiddenColumns(Set<String> hiddenColumns) {
        this.hiddenColumns = hiddenColumns;
    }

    /**holds the propertyNames for columns that are to be sorted*/
    public Set<String> getSortableColumns() {
        return sortableColumns;
    }

    public void setSortableColumns(Set<String> sortableColumns) {
        this.sortableColumns = sortableColumns;
    }
}