edu.harvard.iq.dvn.core.web.subsetting.AnalysisPage.java Source code

Introduction

Here is the source code for edu.harvard.iq.dvn.core.web.subsetting.AnalysisPage.java

Source

/*
   Copyright (C) 2005-2012, by the President and Fellows of Harvard College.
    
   Licensed 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.
    
   Dataverse Network - A web application to share, preserve and analyze research data.
   Developed at the Institute for Quantitative Social Science, Harvard University.
   Version 3.0.
*/
/*
 * AnalysisPage.java
 *
 * Created on October 12, 2006, 12:13 AM
 *
 */
package edu.harvard.iq.dvn.core.web.subsetting;

/**
 * 
 * @author asone
 */

import static java.lang.System.*;

import java.util.*;
import java.util.Map.*;
import java.util.regex.*;
import java.util.Collection.*;
import java.util.logging.*;

import java.io.*;

import javax.servlet.http.*;

import java.lang.Integer;
import java.lang.Long;

// jsf-api classes
import javax.faces.component.*;
import javax.faces.component.UIComponent.*;
import javax.faces.component.html.*;
import javax.faces.event.*;
import javax.faces.context.*;
import javax.faces.FacesException;
import javax.faces.model.SelectItem;
import javax.faces.render.ResponseStateManager;

// new VDCRequestBean VDCRequestBean
import javax.ejb.EJB;

import edu.harvard.iq.dvn.core.study.VariableServiceLocal;
import edu.harvard.iq.dvn.core.study.DataVariable;
import edu.harvard.iq.dvn.core.study.Study;
import edu.harvard.iq.dvn.core.study.StudyVersion;
import edu.harvard.iq.dvn.core.study.SummaryStatistic;
import edu.harvard.iq.dvn.core.study.VariableCategory;
import edu.harvard.iq.dvn.core.study.StudyFile;
import edu.harvard.iq.dvn.core.study.StudyServiceLocal;

import edu.harvard.iq.dvn.core.web.common.VDCBaseBean;

import edu.harvard.iq.dvn.core.admin.VDCUser;

import edu.harvard.iq.dvn.core.vdc.VDC;
import edu.harvard.iq.dvn.core.vdc.VDCServiceLocal;
import edu.harvard.iq.dvn.core.vdc.GuestBookResponseServiceBean;

import edu.harvard.iq.dvn.ingest.dsb.*;
import edu.harvard.iq.dvn.ingest.dsb.impl.*;

import edu.harvard.iq.dvn.core.web.dataaccess.*;
import edu.harvard.iq.dvn.core.util.FileUtil;

import java.io.File;
import java.io.FileNotFoundException;
import java.net.MalformedURLException;
import java.net.URL;

import java.util.zip.*;

import org.apache.commons.lang.RandomStringUtils;
import org.apache.commons.lang.StringUtils;

import com.icesoft.faces.component.paneltabset.*;
import com.icesoft.faces.context.ByteArrayResource;
import com.icesoft.faces.context.Resource;
import com.icesoft.faces.component.outputresource.*;
import com.icesoft.faces.component.datapaginator.*;
import edu.harvard.iq.dvn.core.study.*;
import edu.harvard.iq.dvn.core.vdc.GuestBookResponse;
import edu.harvard.iq.dvn.core.web.study.StudyUI;
import edu.harvard.iq.dvn.core.web.VersionPage;
import edu.harvard.iq.dvn.unf.*;
import javax.faces.bean.ViewScoped;
import javax.inject.Named;
import javax.inject.Inject;

import edu.harvard.iq.dvn.core.visualization.DataVariableMapping;

@ViewScoped
@Named("AnalysisPage")
public class AnalysisPage extends VDCBaseBean implements java.io.Serializable {

    /**
     * Injects VariableServiceLocal to this class
     */
    @EJB
    private VariableServiceLocal variableService;
    @EJB
    private DvnDSBTimerServiceLocal dvnDSBTimerService;
    @EJB
    StudyServiceLocal studyService;
    @EJB
    private VDCServiceLocal vdcService;

    @EJB
    GuestBookResponseServiceBean guestBookResponseServiceBean;

    @Inject
    VersionPage versionPageClass;

    /**
     * getter for the injected VariableServiceLocal
     * 
     * @return VariableService
     */
    public VariableServiceLocal getVariableService() {
        return variableService;
    }

    // -----------------------------------------------------------------------
    // Initializes JSF components
    // -----------------------------------------------------------------------
    // <editor-fold desc="Initialization of JSF components">

    /*
     * sets various initial values of html components
     *
     */
    private void _init() throws Exception {

        // Advanced Statistics: radio button group for the setx option
        //        radioButtonGroup1DefaultOptions.setOptions(
        //            new Option[] {
        //                new Option("0", "Use average values (setx default)"),
        //                new Option("1", "Select values")
        //            });
        //  new Option("1","Set a value for 1 or 2 variables") 
        //  new Option("2","First differences between baseline and alterantive")

        simOptionMap.put("Use average values (setx default)", "0");
        simOptionMap.put("Select values", "1");
        radioSimTypeChoiceSelected = "0";
        //radioSimTypeChoice.setValue("0");

        // Sets the default value of the above setx option
        //        radioButtonGroup1DefaultOptions.setSelectedValue("0");

        // Advanced Statistics: checkbox group for the output option pane
        //        checkboxGroup2DefaultOptions.setOptions(
        //            new Option[] {
        //                new Option("Summary", "Include Summary Statistics"),
        //                new Option("Plots", "Include Plot"),
        //                new Option("BinOutput", "Include Replication Data")
        //            });

        // Sets the default state of each checkbox of the above group
        //        checkboxGroup2DefaultOptions.setSelectedValue(new Object[] { "Summary",
        //            "Plots", "BinOutput" });

        chkbxAdvStatOutputOptMap.put("Include Summary Statistics", "Summary");
        chkbxAdvStatOutputOptMap.put("Include Plot", "Plots");
        chkbxAdvStatOutputOptMap.put("Include Replication Data", "BinOutput");

        chkbxAdvStatOutputOpt.setValue(new String[] { "Summary", "Plots", "BinOutput" });

        // Cross-tabs have their own checkbox menu:

        chkbxAdvStatOutputXtbOptMap.put("Include Totals", "xtb_Totals");
        chkbxAdvStatOutputXtbOptMap.put("Include Statistics", "xtb_Statistics");
        chkbxAdvStatOutputXtbOptMap.put("Include Percentages", "xtb_Percentages");
        chkbxAdvStatOutputXtbOptMap.put("Include Extra Tables", "xtb_ExtraTables");

        chkbxAdvStatOutputXtbOpt.setValue(new String[] { "xtb_Totals", "xtb_Statistics", "xtb_Percentages", });

        // Advanced Statistics: checkbox group for the output option pane(xtab)
        //        checkboxGroupXtbOptions.setOptions(
        //            new Option[] {
        //                new Option("xtb_Totals",      "Include Totals"),
        //                new Option("xtb_Statistics",  "Include Statistics"),
        //                new Option("xtb_Percentages", "Include Percentages"),
        //                new Option("xtb_ExtraTables", "Include Extra Tables")
        //            });

        // Sets the default state of each checkbox of the above group
        //        checkboxGroupXtbOptions.setSelectedValue(
        //            new Object[] {
        //                "xtb_Totals", 
        //                "xtb_Statistics", 
        //                "xtb_Percentages",
        //                "false"
        //            });

        // Dropdown menu of how many rows to be displayed in the variable table
        howManyRowsOptions.add(new SelectItem("10", "10 Variables"));
        howManyRowsOptions.add(new SelectItem("20", "20 Variables"));
        howManyRowsOptions.add(new SelectItem("50", "50 Variables"));
        howManyRowsOptions.add(new SelectItem("0", "All"));

        // Sets the default state of the above Dropdown menu to 20 (variables)
        /*
        // howManyRowsOptions.setSelectedValue("20");
        */
        //selectedNoRows= "10";
        /*
         * Setter for property StudyUIclassName.  The instance of StudyUI class
         * contains citation-related information
         */
        setStudyUIclassName("edu.harvard.iq.dvn.core.web.study.StudyUI");

        /*
         * Fills dropdown menu for selecting a model (advanced Statistics tab)
         * with options obtained through AnalysisApplicationBean
         */
        setModelMenuOptions(getAnalysisApplicationBean().getModelMenuOptions());

        /*
         * Initializes the dataType-to-integer table used for
         * the switch statement in the checkVarType method
         */
        dataType2Int.put("binary", Integer.valueOf("1"));
        dataType2Int.put("nominal", Integer.valueOf("2"));
        dataType2Int.put("nominal|ordinal", Integer.valueOf("23"));
        dataType2Int.put("ordinal|nominal", Integer.valueOf("32"));
        dataType2Int.put("ordinal", Integer.valueOf("3"));
        dataType2Int.put("discrete", Integer.valueOf("4"));
        dataType2Int.put("continuous", Integer.valueOf("5"));
        dataType2Int.put("any", Integer.valueOf("0"));

        // Initializes the variable-type-to-String conversion table 
        vtInt2String.put("2", "continuous");
        vtInt2String.put("1", "discrete");
        vtInt2String.put("0", "character");

        //        getTabSet1().setSelected("tabDwnld");
        //        getVDCRequestBean().setSelectedTab("tabDwnld");

        REP_README_FILE = new File(this.getClass().getResource("README").getFile());
        REP_README_FILE_PREFIX = "README_";
        DVN_R2HTML_CSS_FILE = new File(this.getClass().getResource("R2HTML.css").getFile());
        DVN_R_HELPER_FILE = new File(this.getClass().getResource("dvn_helper.R").getFile());

        R_COMMAND_FILE_PREFIX = "RcommandFile_";

    } // end of _init()

    // </editor-fold>

    // -----------------------------------------------------------------------
    // Static Variables
    // -----------------------------------------------------------------------
    // <editor-fold desc="Static Variables">

    /** 
     * The number of variables to be shown in the variable table.
     * The default value is set 20. 0 is used to show all variables
     */
    private static final int INITIAL_ROW_NO = 10;

    /** Sets the id number of the download GUI pane */
    private static final int PANE_DWNLD = 3;

    /** Sets the id number of the recode GUI pane */
    private static final int PANE_RECODE = 2;

    /** Sets the id number of the EDA GUI pane */
    private static final int PANE_EDA = 4;

    /** Sets the id number of the advanced statistics GUI pane */
    private static final int PANE_ADVSTAT = 5;

    private boolean resultPageTest = false;

    /** Sets the logger (use the package name) */
    private static Logger dbgLog = Logger.getLogger(AnalysisPage.class.getPackage().getName());

    private static String SUBSET_FILENAME_PREFIX = "dvnSubsetFile.";
    private static String SUBSET_DATAFILE = "dvnDataFile.";

    private static File REP_README_FILE;
    private static String REP_README_FILE_PREFIX;
    private static String R_COMMAND_FILE_PREFIX;
    private static File DVN_R2HTML_CSS_FILE;

    private static File DVN_R_HELPER_FILE;

    private static Long TEMP_FILE_LIFETIME = 10L;

    private static String TEMP_DIR = System.getProperty("java.io.tmpdir");

    // </editor-fold>

    // -----------------------------------------------------------------------
    // Non-JSF-component Instance variables
    // -----------------------------------------------------------------------
    // <editor-fold desc="Instance Variables">

    private String dvnVersionNumber;

    public String getDvnVersionNumber() {
        return dvnVersionNumber;
    }

    public void setDvnVersionNumber(String dvnVersionNumber) {
        this.dvnVersionNumber = dvnVersionNumber;
    }

    private Long versionNumber;

    public Long getVersionNumber() {
        return versionNumber;
    }

    public void setVersionNumber(Long versionNumber) {
        this.versionNumber = versionNumber;
    }

    private List<File> deleteTempFileList = new ArrayList<File>();

    /**
     * Instance of the DataTable that contains major metadata of all variables
     * in the data file requested by an end-user
     */
    private edu.harvard.iq.dvn.core.study.DataTable dataTable;

    /**
     * The List object that holds the metadata of all variables in the
     * requested data file
     */
    private List<DataVariable> dataVariables = new ArrayList<DataVariable>();

    /**
     * The ID of the requested DataTable instance. Specified as a managed-property in
     * managed-beans.xml <property-class>java.lang.Long</property-class>
     * <value>#{param.dtId}</value>
     */
    private Long dtId;

    /**
     * Getter for property dtId
     * 
     * @return    value of property dtId
     */
    public Long getDtId() {
        return this.dtId;
    }

    /**
     * Setter for property dtId.
     * 
     * @param dtId    new value of property dtId
     *           
     */
    public void setDtId(Long dtId) {
        this.dtId = dtId;
    }

    /**
     * The Id of the data table that stores the requested data file
     */
    private String dataTableId;

    /**
     * The hash table (variable Id to variable name)
     * that stores the current selected variables
     */
    private Map<String, String> varCart = new LinkedHashMap<String, String>();

    // Map for switch statement in checkVarType()
    /**
     *  The dataType-to-integer table used for
     *  the switch statement in the checkVarType method
     */
    private Map<String, Integer> dataType2Int = new HashMap<String, Integer>();

    /**
     * The variable-type-to-String conversion table 
     */
    private Map<String, String> vtInt2String = new HashMap<String, String>();

    // study-related data
    /**
     * The name of StudyUI class that contains the citation-related 
     * information about the requested Study
     */
    private String studyUIclassName;

    /**
     * Setter for property studyUI class name
     * @param suiClass    studyUI classbname
     */
    public void setStudyUIclassName(String suiClass) {
        studyUIclassName = suiClass;
    }

    /**
     * getter for property studyUI class-name
     *
     * @return    the studyUI class name
     */
    public String getStudyUIclassName() {
        return studyUIclassName;
    }

    /**
     * getter for property citation
     * 
     * @return    the citation information of the requested data file
     */
    private String getCitation() {
        return studyUI.getMetadata().getCitation(false);
    }

    /**
     * 
     *
     * @return    the title of the requested study
     */
    private String getStudyTitle() {
        return studyUI.getMetadata().getTitle();
    }

    /**
     *
     *
     * @return the ID of the requested study
     */
    public Long getStudyId() {
        return studyUI.getStudy().getId();
    }

    /** 
     * The name of the requested data file
     * Exposed to SubsettingPage.xhtml
     */
    private String fileName;

    /**
     * Getter for property fileName
     *
     * @return    the name of the requested data file
     */
    public String getFileName() {
        return fileName;
    }

    /**
     * Setter for property fileName
     *
     * @param fNm    the name of the requested data file
     */
    public void setFileName(String fNm) {
        fileName = fNm;
    }

    /** The URL of the requested study */
    private String studyURL;

    /**
     * Getter for property studyURL
     *
     * @return    the URL of the requested study
     */
    public String getAtudyURL() {
        return studyURL;
    }

    /**
     * Setter for property studyURL
     *
     * @param url    the URL of the requested study
     */
    public void setStudyURL(String url) {
        studyURL = url;
    }

    private StudyUI studyUI;

    public StudyUI getStudyUI() {
        return studyUI;
    }

    public void setStudyUI(StudyUI studyUI) {
        this.studyUI = studyUI;
    }

    /** The type of an end-user's browser */
    private String browserType;

    /**
     * Getter for property browserType
     *
     * @return    the type of an end-user's browser
     */
    public String getBrowserType() {
        return browserType;
    }

    /**
     * Setter for property borwserType
     *
     * @param bt    the type of an end-user's browser
     */
    public void setBrowserType(String bt) {
        this.browserType = bt;
    }

    /** The subsettability of the Subsetting Page */
    private Boolean subsettingPageAccess;

    /** Sets the state number of the initially selected tab.
     *  The default is 3 
     */
    //private int clickedTab = 3;
    private int currentTabIndex;

    private Map<String, String> resultInfo = new HashMap<String, String>();

    public Map<String, String> getResultInfo() {
        return resultInfo;
    }

    public void setResultInfo(Map<String, String> resultInfo) {
        this.resultInfo = resultInfo;
    }

    private String DVNversionNo;
    // </editor-fold>

    // -----------------------------------------------------------------------
    // Page-level JSF components
    // -----------------------------------------------------------------------

    // <editor-fold desc="Page-level-components">

    /**
     * ice:panelTabSet component backing the binding attribute of the tabset in
     * the subsetting page and whose id is tabSet1
     */
    private PanelTabSet tabSet1 = new PanelTabSet();

    /**
     * Getter for component tabSet1
     *
     * @return    the main tab-set component
     */
    public PanelTabSet getTabSet1() {
        return tabSet1;
    }

    /**
     * Setter for component tabSet1
     *
     * @param ts    the main tab-set component
     */
    public void setTabSet1(PanelTabSet tabSet1) {
        this.tabSet1 = tabSet1;
    }

    /**
     * ice:panelTab component backing the binding attribute of the tab of 
     * the downloading option and whose id is tabDwnld
     * 
     */
    private PanelTab tabDwnld = new PanelTab();

    /**
     * Getter for component tabDwnld
     *
     * @return    ice:panelTab of the downloading option
     */
    public PanelTab getTabDwnld() {
        return tabDwnld;
    }

    /**
     * Setter for component tabDwnld
     *
     * @param tab3    ice:panelTab of the downloading option
     */
    public void setTabDwnld(PanelTab tabDwnld) {
        this.tabDwnld = tabDwnld;
    }

    /**
     * ice:panelTab component backing the binding attribute of the tab of 
     * the recoding option and whose id is tabRecode
     */
    private PanelTab tabRecode = new PanelTab();

    /**
     * Getter for component tabRecode
     *
     * @return    ice:panelTab of the recoding option
     */
    public PanelTab getTabRecode() {
        return tabRecode;
    }

    /**
     * Setter for component tabRecode
     *
     * @param tab2    ice:panelTab of the recoding option
     */
    public void setTabRecode(PanelTab tabRecode) {
        this.tabRecode = tabRecode;
    }

    /**
     * ice:panelTab component backing the binding attribute of the tab of 
     * the EDA option and whose id is tabEda
     */
    private PanelTab tabEda = new PanelTab();

    /**
     * Getter for component tabEda
     *
     * @return    ice:panelTab of the EDA option
     */
    public PanelTab getTabEda() {
        return tabEda;
    }

    /**
     * Setter for component tabEda
     *
     * @param tab4    ice:panelTab of the EDA option
     */
    public void setTabEda(PanelTab tabEda) {
        this.tabEda = tabEda;
    }

    /**
     * ice:panelTab component backing the binding attribute of the tab of 
     * the advanced statistics optionn and whose id is tabAdvStat
     */
    private PanelTab tabAdvStat = new PanelTab();

    /**
     * Getter for component tabAdvStat
     *
     * @return    ice:panelTab of the advanced statistics option
     */
    public PanelTab getTabAdvStat() {
        return tabAdvStat;
    }

    /**
     * Setter for component tabAdvStat
     *
     * @param tab5    ice:panelTab of the advanced statistics option
     */
    public void setTabAdvStat(PanelTab tabAdvStat) {
        this.tabAdvStat = tabAdvStat;
    }

    /** The Id of the currently selected tab */
    private String currentTabId;

    /**
     * Getter for property currentTabId
     *
     * @return    the Id of the currently selected tab
     */
    public String getCurrentTabId() {
        return currentTabId;
    }

    /**
     * Setter for property currentTabId
     *
     * @param tb    the Id of the currently selected tab
     */
    public void setCurrentTabId(String tb) {
        currentTabId = tb;
    }

    /**
     * Moves all variables back to the box of an end-user selected variables
     * and resets the backing storage object varCart.  
     * Backing the actionListener attribute of each ice:panelTab component.
     *
     * @param  acev    tab-clicking-action event
     */
    public void resetVariableInLBox(ActionEvent acev) {
        dbgLog.fine("Within resetVariableInLBox: tab Id =" + acev.getComponent().getId());
        getVDCRequestBean().setSelectedTab(acev.getComponent().getId());
        // remove vars from RHS boxes
        advStatVarRBox1.clear();
        advStatVarRBox2.clear();
        advStatVarRBox3.clear();

        // add existing vars to LHS box
        // add user-defined vars to LHS box if available
        resetVarSetAdvStat(varCart);

        // recode message area
        resetMsgMoveRecodeVarBttn();
        resetMsgSaveRecodeBttn();
        resetMsg4MoveVar();

        // download message area
        msgDwnldButton.setValue(" ");
        msgDwnldButton.setVisible(false);

        // eda message area
        msgEdaButton.setValue(" ");
        msgEdaButton.setVisible(false);

        // advance stat area
        msgAdvStatButton.setValue(" ");
        msgAdvStatButton.setVisible(false);

        // uncheck-variable-error message 
        resetMsgVariableSelection();
    }

    public void processTabChange(TabChangeEvent tce) {

        dbgLog.fine("***** within processTabChange: start *****");
        dbgLog.fine("selectedIndex=" + tabSet1.getSelectedIndex());
        dbgLog.fine("tabPlacement=" + tabSet1.getTabPlacement());
        dbgLog.fine("old tab Index=" + tce.getOldTabIndex());
        dbgLog.fine("new tab Index=" + tce.getNewTabIndex());

        if (tce.getNewTabIndex() != tce.getOldTabIndex()) {
            dbgLog.fine("reset messages and boxes");
            // reset boxes
            // remove vars from RHS boxes
            advStatVarRBox1.clear();
            advStatVarRBox2.clear();
            advStatVarRBox3.clear();

            // add existing vars to LHS box
            // add user-defined vars to LHS box if available
            resetVarSetAdvStat(varCart);

            // download message area
            msgDwnldButton.setValue("");
            msgDwnldButton.setVisible(false);

            // recode message area
            resetMsgMoveRecodeVarBttn();
            resetMsgSaveRecodeBttn();
            resetMsg4MoveVar();

            // eda message area
            msgEdaButton.setValue("");
            msgEdaButton.setVisible(false);

            // advance stat area
            msgAdvStatButton.setValue("");
            msgAdvStatButton.setVisible(false);

            // uncheck-variable-error message 
            resetMsgVariableSelection();

            // hide the download button and
            // show the create button
            dwnldButton.setRendered(true);
            dwnloadSubsetButton.setRendered(false);
        }

        dbgLog.fine("***** within processTabChange: end *****");
    }
    // </editor-fold>

    // -----------------------------------------------------------------------
    // download section   
    // -----------------------------------------------------------------------
    // <editor-fold desc="download">

    // download radio button selection
    private HtmlSelectOneRadio dwnldFileTypeSet = new com.icesoft.faces.component.ext.HtmlSelectOneRadio();

    public HtmlSelectOneRadio getDwnldFileTypeSet() {
        return dwnldFileTypeSet;
    }

    public void setDwnldFileTypeSet(HtmlSelectOneRadio hsor) {
        this.dwnldFileTypeSet = hsor;
    }

    // download: radio button items

    private List dwnldFileTypeItems = null;

    public List getDwnldFileTypeItems() {
        if (dwnldFileTypeItems == null) {
            dwnldFileTypeItems = new ArrayList();
            dwnldFileTypeItems.add("D01");// Text
            dwnldFileTypeItems.add("D04");// RData
            dwnldFileTypeItems.add("D02");// Splus
            dwnldFileTypeItems.add("D03");// Stata
        }
        return dwnldFileTypeItems;
    }

    public void setDwnldFileTypeItems(List dfti) {
        dwnldFileTypeItems = dfti;
    }

    // File format for the saved subset defaults to plain text:
    private String dwnldFileTypeSelected = (String) (getDwnldFileTypeItems().get(0));

    public String getDwnldFileTypeSelected() {
        dbgLog.fine("Subsetting: returning dnwldFileTypeSelected=" + dwnldFileTypeSelected);
        return dwnldFileTypeSelected;
    }

    public void setDwnldFileTypeSelected(String s) {
        dbgLog.fine("Subsetting: setting dnwldFileTypeSelected to " + s);
        this.dwnldFileTypeSelected = s;
    }

    // dwnldBttn commandButton@binding
    private HtmlCommandButton dwnldButton = new com.icesoft.faces.component.ext.HtmlCommandButton();

    //new javax.faces.component.html.HtmlCommandButton();
    public HtmlCommandButton getDwnldButton() {
        return dwnldButton;
    }

    public void setDwnldButton(HtmlCommandButton hcb) {
        this.dwnldButton = hcb;
    }

    // dwnldBttn:h:commandButton@action
    public boolean checkDwnldParameters() {
        boolean result = false;
        dbgLog.fine("***** within checkDwnldParameters() *****");
        // param-checking conditions
        if (dwnldFileTypeSelected != null) {
            dbgLog.fine("download radio button set: selected value=" + (String) dwnldFileTypeSet.getValue());
            result = true;
        } else if (dwnldFileTypeSet.getValue() != null) {
            dbgLog.fine("download radio button set: selected value=" + (String) dwnldFileTypeSet.getValue());
            result = true;
        } else {
            dbgLog.warning("download radio button set: no selected value");
        }
        return result;
    }

    private HtmlPanelGrid pgDwnldErrMsg = new com.icesoft.faces.component.ext.HtmlPanelGrid();

    public HtmlPanelGrid getPgDwnldErrMsg() {
        return pgDwnldErrMsg;
    }

    public void setPgDwnldErrMsg(HtmlPanelGrid pgDwnldErrMsg) {
        this.pgDwnldErrMsg = pgDwnldErrMsg;
    }

    // msgDwnldButton:ice:outputText@binding
    private com.icesoft.faces.component.ext.HtmlOutputText msgDwnldButton = new com.icesoft.faces.component.ext.HtmlOutputText();

    public com.icesoft.faces.component.ext.HtmlOutputText getMsgDwnldButton() {
        return msgDwnldButton;
    }

    public void setMsgDwnldButton(com.icesoft.faces.component.ext.HtmlOutputText txt) {
        this.msgDwnldButton = txt;
    }

    /**
     * The object backing the value attribute of
     * htmlOutputText for msgDwnldButton that shows 
     * error messages for the action of the download
     * button
     */
    private String msgDwnldButtonTxt;

    /**
     * Getter for property msgDwnldButtonTxt
     *
     * @return the error message text
     */
    public String getMsgDwnldButtonTxt() {
        return msgDwnldButtonTxt;
    }

    /**
     * Setter for property msgDwnldButtonTxt
     *
     * @param txt   the new error message text
     */
    public void setMsgDwnldButtonTxt(String txt) {
        this.msgDwnldButtonTxt = txt;
    }

    /**
     * Clears the contents of the error message text (msgDwnldButtonTxt)
     * for the download button (dwnldButton)
     */
    public void resetMsgDwnldButton() {
        dbgLog.fine("***** within resetMsgDwnldButton *****");
        // Replaces the error message text with spaces
        // so that the previous error message is not shown
        // even if the following setVisible(false) line fails
        msgDwnldButton.setValue("     ");

        // Stores the new state of msgDwnldButtonTxt in the session map
        FacesContext.getCurrentInstance().getExternalContext().getSessionMap().put("msgDwnldButtonTxt",
                msgDwnldButtonTxt);

        // Hides the error message text next to the download button
        msgDwnldButton.setVisible(false);
        pgDwnldErrMsg.setRendered(false);
        dbgLog.fine("***** resetMsgDwnldButton: end *****");
    }

    private Resource zipResourceDynFileName; //= new ByteArrayResource(null);

    public Resource getZipResourceDynFileName() {
        return zipResourceDynFileName;
    }

    public void setZipResourceDynFileName(Resource zipResourceDynFileName) {
        this.zipResourceDynFileName = zipResourceDynFileName;
    }

    private String zipFileName;

    public String getZipFileName() {
        return zipFileName;
    }

    public void setZipFileName(String zipFileName) {
        this.zipFileName = zipFileName;
    }

    private OutputResource dwnloadSubsetButton = new OutputResource();

    public OutputResource getDwnloadSubsetButton() {
        return dwnloadSubsetButton;
    }

    public void setDwnloadSubsetButton(OutputResource dsb) {
        this.dwnloadSubsetButton = dsb;
    }

    public void processDwnldFileType(ValueChangeEvent vce) {
        dbgLog.fine("***** within processDwnldFileType: start *****");
        dbgLog.fine("old value=" + vce.getOldValue());
        dbgLog.fine("new value=" + vce.getNewValue());
        if (vce.getOldValue() == null) {
            dbgLog.fine("old value is null and this must be the initial case");
        } else {
            dwnldFileTypeSelected = (String) vce.getNewValue();
            if (vce.getNewValue().equals(vce.getOldValue())) {
                dbgLog.fine("new value is the same as before");
            } else {
                dbgLog.fine("new value differs from the old one");
                dwnloadSubsetButton.setRendered(false);
                dwnldButton.setRendered(true);
            }
        }
        dbgLog.fine("***** within processDwnldFileType: end *****");
    }

    //TODO: hiddenSelectedFileType -- debug
    private HtmlInputHidden hiddenSelectedFileType = new HtmlInputHidden();

    /**
     * Get the value of hiddenSelectedFileType
     *
     * @return the value of hiddenSelectedFileType
     */
    public HtmlInputHidden getHiddenSelectedFileType() {
        if (hiddenSelectedFileType != null) {
            dbgLog.fine("returning hiddenSelectedFileType" + hiddenSelectedFileType.getValue());
        } else {
            dbgLog.fine("hiddenSelectedFileType is null");
        }
        return hiddenSelectedFileType;
    }

    /**
     * Set the value of hiddenSelectedFileType
     *
     * @param hiddenSelectedFileType new value of hiddenSelectedFileType
     */
    public void setHiddenSelectedFileType(HtmlInputHidden hiddenSelectedFileType) {
        this.hiddenSelectedFileType = hiddenSelectedFileType;
    }

    // END TODO

    // end of download section -----------------------------------------------
    // </editor-fold>

    public static byte[] toByteArray(InputStream input) throws IOException {
        ByteArrayOutputStream output = new ByteArrayOutputStream();
        byte[] buf = new byte[4096];
        int len = 0;
        while ((len = input.read(buf)) > -1)
            output.write(buf, 0, len);
        return output.toByteArray();
    }

    // dwnldButton commandButton@action
    public String dwnldAction() {
        dbgLog.fine("***** within dwnldAction() *****");

        resetMsgDwnldButton();

        if (checkDwnldParameters()) {

            FacesContext cntxt = FacesContext.getCurrentInstance();

            HttpServletResponse res = (HttpServletResponse) cntxt.getExternalContext().getResponse();

            HttpServletRequest req = (HttpServletRequest) cntxt.getExternalContext().getRequest();

            StudyFile sf = dataTable.getStudyFile();

            Long noRecords = dataTable.getRecordsPerCase();

            String dsbUrl = getDsbUrl();
            dbgLog.fine("dsbUrl=" + dsbUrl);

            String serverPrefix = req.getScheme() + "://" + req.getServerName() + ":" + req.getServerPort()
                    + req.getContextPath();

            dbgLog.fine("serverPrefix" + serverPrefix);

            Map<String, List<String>> mpl = new HashMap<String, List<String>>();

            // File inFile = new File(sf.getFileSystemLocation());
            // File origFile = new File(inFile.getParent(), "_" + sf.getFileSystemName());

            String formatType = (String) dwnldFileTypeSet.getValue();
            dbgLog.fine("file type from the binding=" + formatType);
            if (formatType == null) {
                formatType = dwnldFileTypeSelected;
                dbgLog.fine("file type from the value=" + dwnldFileTypeSelected);
            }
            mpl.put("dtdwnld", Arrays.asList(formatType));

            dbgLog.fine("citation info to be sent:\n" + getCitation());

            mpl.put("studytitle", Arrays.asList(getStudyTitle()));
            dbgLog.fine("studyId=" + getStudyId().toString());
            mpl.put("studyno", Arrays.asList(getStudyId().toString()));
            mpl.put("studyURL", Arrays.asList(studyURL));

            mpl.put("", Arrays.asList(""));
            mpl.put("browserType", Arrays.asList(browserType));

            mpl.put("recodedVarIdSet", getRecodedVarIdSet());
            mpl.put("recodedVarNameSet", getRecodedVarNameSet());
            mpl.put("recodedVarLabelSet", getRecodedVarLabelSet());
            mpl.put("recodedVarTypeSet", getRecodedVariableType());
            mpl.put("recodedVarBaseTypeSet", getBaseVariableTypeForRecodedVariable());

            mpl.put("baseVarIdSet", getBaseVarIdSetFromRecodedVarIdSet());
            mpl.put("baseVarNameSet", getBaseVarNameSetFromRecodedVarIdSet());

            mpl.put("requestType", Arrays.asList("Download"));

            // Added by Matt Owen to find a way to sneak in Metadata that is lost between Rdata -> Tab 
            mpl.put("originalFile", Arrays.asList(getOriginalFileSystemLocation().getAbsolutePath()));

            // -----------------------------------------------------
            // Processing route, step by step:
            // 
            // Step 0. Locate the data file and its attributes

            String fileId = sf.getId().toString();

            String fileloc = sf.getFileSystemLocation();
            String tabflnm = sf.getFileName();
            boolean sbstOK = sf.isSubsettable();
            String flct = sf.getFileType();

            // Output debug statements
            dbgLog.info("location=" + fileloc);
            dbgLog.info("filename=" + tabflnm);
            dbgLog.info("subsettable=" + sbstOK);
            dbgLog.info("filetype=" + flct);
            dbgLog.info("studyUrl = " + studyURL);
            dbgLog.info("original file asbolute path = " + getOriginalFileSystemLocation().getAbsolutePath());

            // D
            DvnRJobRequest sro = null;

            List<File> zipFileList = new ArrayList();

            File tmpsbfl = null;

            if (sbstOK) {

                try {

                    // this temp file will store the requested column(s):
                    tmpsbfl = File.createTempFile("tempsubsetfile.", ".tab");
                    deleteTempFileList.add(tmpsbfl);

                    // to produce this file, we'll either open the stream
                    // and run our local subsetting code on it, or request
                    // the subsetting to be performed natively by the access
                    // driver, if it supports the functionality:

                    // check whether a source file is tab-delimited or not

                    boolean fieldcut = true;
                    if ((noRecords != null) && (noRecords >= 1)) {
                        fieldcut = false;
                    }

                    DataAccessRequest daReq = new DataAccessRequest();
                    daReq.setParameter("noVarHeader", "1");

                    DataAccessObject accessObject = DataAccess.createDataAccessObject(sf, daReq);

                    if (accessObject.isSubsetSupported()) {
                        dbgLog.fine("Using NATIVE subset functionality of the repository.");
                        daReq.setParameter("vars", getVariableNamesForSubset());

                        accessObject.open();

                        InputStream inSubset = accessObject.getInputStream();
                        OutputStream outSubset = new BufferedOutputStream(
                                new FileOutputStream(tmpsbfl.getAbsolutePath()));

                        int bufsize = 8192;
                        byte[] subsetDataBuffer = new byte[bufsize];
                        while ((bufsize = inSubset.read(subsetDataBuffer)) != -1) {
                            outSubset.write(subsetDataBuffer, 0, bufsize);
                        }

                        inSubset.close();
                        outSubset.close();

                        // TODO: catch exceptions; reset the state of the page
                        // if anything went wrong. See the fixed-field section
                        // below for an example.

                    } else {
                        accessObject.open();

                        if (fieldcut) {
                            // Cutting requested fields of data from a TAB-delimited stream:

                            Set<Integer> fields = getFieldNumbersForSubsetting();
                            dbgLog.fine("subsetting fields=" + fields);

                            // Create an instance of DvnJavaFieldCutter
                            FieldCutter fc = new DvnJavaFieldCutter();

                            // Executes the subsetting request
                            fc.subsetFile(accessObject.getInputStream(), tmpsbfl.getAbsolutePath(), fields,
                                    dataTable.getCaseQuantity(), "\t");

                            // TODO: catch exceptions; reset the state of the page
                            // if anything went wrong. See the fixed-field section
                            // below for an example.

                        } else {
                            // Cutting requested columns of data from a fixed-field stream:

                            Map<Long, List<List<Integer>>> varMetaSet = getSubsettingMetaData(noRecords);
                            DvnNewJavaFieldCutter fc = new DvnNewJavaFieldCutter(varMetaSet);

                            try {
                                //fc.cutColumns(new File(cutOp1), noRecords.intValue(), 0, "\t", tmpsbfl.getAbsolutePath());
                                fc.cutColumns(accessObject.getInputStream(), noRecords.intValue(), 0, "\t",
                                        tmpsbfl.getAbsolutePath());
                            } catch (FileNotFoundException e) {
                                e.printStackTrace();

                                msgDwnldButton.setValue("* could not generate subset due to an IO problem");
                                msgDwnldButton.setVisible(true);
                                dbgLog.warning("exiting dwnldAction() due to an IO problem ");
                                getVDCRequestBean().setSelectedTab("tabDwnld");
                                dvnDSBTimerService.createTimer(deleteTempFileList, TEMP_FILE_LIFETIME);
                                return "";

                            } catch (RuntimeException re) {
                                re.printStackTrace();

                                msgDwnldButton.setValue("* could not generate subset due to an runtime error");
                                msgDwnldButton.setVisible(true);
                                dbgLog.warning("exiting dwnldAction() due to an runtime error");
                                getVDCRequestBean().setSelectedTab("tabDwnld");
                                dvnDSBTimerService.createTimer(deleteTempFileList, TEMP_FILE_LIFETIME);
                                return "";

                            }

                        }
                    }

                    // Checks the resulting subset file:

                    if (tmpsbfl.exists()) {
                        Long subsetFileSize = tmpsbfl.length();
                        dbgLog.fine("subset file:Length=" + subsetFileSize);
                        dbgLog.fine("subset file:name=" + tmpsbfl.getAbsolutePath());

                        if (subsetFileSize > 0) {
                            mpl.put("subsetFileName", Arrays.asList(tmpsbfl.getAbsolutePath()));
                            mpl.put("subsetDataFileName", Arrays.asList(tmpsbfl.getName()));
                        } else {
                            // subset file exists but it is empty

                            msgDwnldButton.setValue("* an subset file is empty");
                            msgDwnldButton.setVisible(true);
                            dbgLog.warning(
                                    "exiting dwnldAction() due to a subsetting error:" + "a subset file is empty");
                            getVDCRequestBean().setSelectedTab("tabDwnld");
                            dvnDSBTimerService.createTimer(deleteTempFileList, TEMP_FILE_LIFETIME);
                            return "";

                        }
                    } else {
                        // subset file was not created
                        msgDwnldButton.setValue("* a subset file was not created");
                        msgDwnldButton.setVisible(true);
                        dbgLog.warning("exiting dwnldAction() due to a subsetting error:"
                                + "a subset file was not created");
                        getVDCRequestBean().setSelectedTab("tabDwnld");
                        dvnDSBTimerService.createTimer(deleteTempFileList, TEMP_FILE_LIFETIME);
                        return "";

                    }

                    // If we've made it this far, we can increment the number of
                    // downloads for the study file:

                    VDC vdc = vdcService.getVDCFromRequest(req);
                    GuestBookResponse guestbookResponse = (GuestBookResponse) getVDCSessionBean()
                            .getGuestbookResponseMap().get("guestBookResponse_" + sf.getStudy().getId());

                    if (guestbookResponse == null) {
                        //need to set up dummy network response
                        guestbookResponse = guestBookResponseServiceBean.initNetworkGuestBookResponse(sf.getStudy(),
                                sf, getVDCSessionBean().getLoginBean());
                    }
                    guestbookResponse.setStudyVersion(sf.getStudy().getStudyVersionByNumber(versionNumber));
                    String jsessionId = null;
                    Cookie cookies[] = req.getCookies();

                    for (int i = 0; i < cookies.length; i++) {
                        if ("JSESSIONID".equals(cookies[i].getName())) {
                            jsessionId = cookies[i].getValue();
                        }
                    }

                    if (jsessionId == null || "".equals(jsessionId)) {
                        String[] stringArray = getVDCSessionBean().toString().split("@");
                        jsessionId = stringArray[1];
                    }

                    guestbookResponse.setSessionId(jsessionId);

                    String friendlyFormatName = "";
                    String formatRequestedMimeType = "";

                    if (formatType != null && !"".equals(formatType)) {
                        if (formatType.equals("D00")) {
                            formatRequestedMimeType = "text/tab-separated-values"; // tabular
                        } else if (formatType.equals("D01")) {
                            formatRequestedMimeType = "text/tab-separated-values"; // fixed-field
                        } else {
                            for (DataFileFormatType type : studyService.getDataFileFormatTypes()) {
                                if (formatType.equals(type.getValue())) {
                                    formatRequestedMimeType = type.getMimeType();
                                }
                            }
                        }
                    }

                    if (formatRequestedMimeType == null || "".equals(formatRequestedMimeType)) {
                        formatRequestedMimeType = "application/x-unknown";
                    }

                    friendlyFormatName = FileUtil.getUserFriendlyTypeForMime(formatRequestedMimeType);
                    guestbookResponse.setDownloadtype("Subsetting - " + friendlyFormatName);

                    if (vdc != null) {
                        studyService.incrementNumberOfDownloads(sf.getId(), vdc.getId(),
                                (GuestBookResponse) guestbookResponse);
                    } else {
                        studyService.incrementNumberOfDownloads(sf.getId(), (Long) null,
                                (GuestBookResponse) guestbookResponse);
                    }

                    // Step 3. Organizes parameters/metadata to be sent to the implemented
                    // data-analysis-service class

                    // skip the Rserve call completely (for plain tab file format, with no recoding)! -- L.A.
                    if (!formatType.equals("D01") || (recodeSchema.size() > 0)) {

                        Map<String, Map<String, String>> vls = getValueTablesForAllRequestedVariables();

                        // New (as of 3.6): support for ordered categorical variables 
                        // (ingested from R ordered factors). 
                        // Note that this is only being added here, i.e., to the 
                        // download-and-save part; if/when we make the analysis 
                        // and statistics utilize/handle these ordered categories 
                        // in some special way, we'll need to add the actual 
                        // ordered values to the SRO objects there as well. -- L.A. 

                        Map<String, List<String>> categoryOrders = getCategoryValueOrdersForAllRequestedVariables();

                        if (categoryOrders != null) {
                            sro = new DvnRJobRequest(getDataVariableForRequest(), mpl, vls, recodeSchema,
                                    categoryOrders, null);
                        } else {
                            sro = new DvnRJobRequest(getDataVariableForRequest(), mpl, vls, recodeSchema);
                        }

                        /*
                         * Add the recoded -> base variable name map; (new as of v3.6;)
                         * TODO: (?) do the same for the other action requests. 
                         *          -- L.A.
                         */
                        sro.setRecodedToBaseVar(getRecodedVarToBaseVarName());

                        // dbgLog.fine("sro dump:\n"+ToStringBuilder.reflectionToString(sro, ToStringStyle.MULTI_LINE_STYLE));

                        // Step 4. Creates an instance of the the implemented
                        // data-analysis-service class

                        DvnRDataAnalysisServiceImpl das = new DvnRDataAnalysisServiceImpl();

                        // Executes a download or data analysis request and
                        // stores the results in a Map <String, String>

                        resultInfo = das.execute(sro);

                        // Step 5. Check the exit status of the R process:

                        if (resultInfo.get("RexecError").equals("true")) {

                            msgDwnldButton.setValue("* The Request failed due to an R-runtime error");
                            msgDwnldButton.setVisible(true);
                            dbgLog.fine("exiting dwnldAction() due to an R-runtime error");
                            getVDCRequestBean().setSelectedTab("tabDwnld");
                            dvnDSBTimerService.createTimer(deleteTempFileList, TEMP_FILE_LIFETIME);
                            return "";
                        }
                    }

                    if (recodeSchema.size() > 0) {
                        resultInfo.put("subsettingCriteria", sro.getSubsetConditionsForCitation());
                    } else {
                        resultInfo.put("subsettingCriteria", "variables: " + getVariableNamesForSubset());
                    }

                } catch (MalformedURLException e) {
                    e.printStackTrace();

                    msgDwnldButton.setValue("* file URL is malformed");
                    msgDwnldButton.setVisible(true);
                    dbgLog.warning("exiting dwnldAction() due to a URL problem ");
                    getVDCRequestBean().setSelectedTab("tabDwnld");

                    return "";

                } catch (IOException e) {
                    // this may occur if the dataverse is not released,
                    // or if the file exists, but it is not accessible, etc.
                    e.printStackTrace();

                    msgDwnldButton.setValue("* an IO problem occurred");
                    msgDwnldButton.setVisible(true);
                    dbgLog.warning("exiting dwnldAction() due to an IO problem ");
                    getVDCRequestBean().setSelectedTab("tabDwnld");

                    return "";
                }

                // end of subset-OK case
            } else {
                // not subsettable data file
                msgDwnldButton.setValue("* this data file is not subsettable file");
                msgDwnldButton.setVisible(true);
                dbgLog.warning("exiting dwnldAction(): the data file is not subsettable ");
                getVDCRequestBean().setSelectedTab("tabDwnld");
                dvnDSBTimerService.createTimer(deleteTempFileList, TEMP_FILE_LIFETIME);
                return "";

            } // end:subsetNotOKcase

            // final processing steps for all successful cases
            // add study-metadata to the resultInfo map

            if (formatType.equals("D01") && !(recodeSchema.size() > 0)) {
                resultInfo.put("wbDataFileName", tmpsbfl.getAbsolutePath());
                // Fields that would normally be populated by R:

                resultInfo.put("PID", "N/A");
                resultInfo.put("R_min_verion_no", "N/A");
                resultInfo.put("dsbHost", "N/A");
                Date now = new Date();
                resultInfo.put("RexecDate", now.toString());
            } else {
                resultInfo.put("R_min_verion_no", resultInfo.get("Rversion").substring(2));
            }

            resultInfo.put("offlineCitation", getCitation());
            resultInfo.put("studyTitle", getStudyTitle());
            resultInfo.put("studyNo", getStudyId().toString());
            resultInfo.put("dtId", dtId.toString());
            if (versionNumber != null) {
                resultInfo.put("versionNumber", versionNumber.toString());
            }
            resultInfo.put("studyURL", studyURL);
            resultInfo.put("dataverse_version_no", dvnVersionNumber);

            resultInfo.put("option", "subset");
            resultInfo.put("variableList", getVariableNamesForSubset());

            // calculate UNF (locally, on the application side):

            List<DataVariable> subsetVariableList = getDataVariableForRequest();

            String subsetUNFvalue = "[NOT CALCULATED]";

            String[] unfValues = new String[subsetVariableList.size()];

            for (int i = 0; i < subsetVariableList.size(); i++) {
                unfValues[i] = subsetVariableList.get(i).getUnf();
            }

            dbgLog.fine("unf set:\n" + Arrays.deepToString(unfValues));

            try {
                subsetUNFvalue = UNF5Util.calculateUNF(unfValues);

            } catch (NumberFormatException ex) {
                // if anything went wrong during the UNF calculation, it's not
                // a fatal condition; we'll just be displaying "not calculated"
                // instead of the UNF in the final README file.

                dbgLog.fine("error while trying to calculate subset UNF: Number Format Exception.");
                ex.printStackTrace();
            } catch (IOException ex) {
                dbgLog.fine("error while trying to calculate subset UNF: IO Exception.");
                ex.printStackTrace();
            }

            resultInfo.put("fileUNF", subsetUNFvalue);

            // writing necessary files:

            try {

                if (formatType.equals("D01") && !(recodeSchema.size() > 0)) {
                    // (2) tab-delimited-format-only step:
                    //
                    // In the final zip file we package the subset file
                    // and a replication README file (also contains citation). 
                    // We also *used to* include the SAS, SPSS and R control
                    // files created by R. We are not doing this anymore, but 
                    // I left the code commented-out below. 
                    //                  -- L.A. Jan. 2012
                    //
                    // We are also adding the variable header to the file here.

                    /* SKIP CODE FILES -- L.A.
                    String codeFileSas = "codeFile_sas_" + resultInfo.get("PID") + ".sas";
                    File tmpCCsasfl = new File(TEMP_DIR, codeFileSas);
                        
                    deleteTempFileList.add(tmpCCsasfl);
                    zipFileList.add(tmpCCsasfl);
                        
                    String codeFileSpss = "codeFile_spss_" + resultInfo.get("PID") + ".sps";
                    File tmpCCspsfl = new File(TEMP_DIR, codeFileSpss);
                        
                    deleteTempFileList.add(tmpCCspsfl);
                    zipFileList.add(tmpCCspsfl);
                        
                    String codeFileStata = "codeFile_stata_" + resultInfo.get("PID") + ".do";
                    File tmpCCdofl  = new File(TEMP_DIR, codeFileStata);
                        
                    deleteTempFileList.add(tmpCCdofl);
                    zipFileList.add(tmpCCdofl);
                        
                    StatisticalCodeFileWriter scfw = new StatisticalCodeFileWriter(sro);
                    scfw.write(tmpCCsasfl, tmpCCspsfl, tmpCCdofl);
                     */

                    // add the subset file:

                    File tmpsbflnew = File.createTempFile("tempsubsetfile_new.", ".tab");
                    deleteTempFileList.add(tmpsbflnew);

                    InputStream inb = new BufferedInputStream(new FileInputStream(tmpsbfl));
                    OutputStream outb = new BufferedOutputStream(new FileOutputStream(tmpsbflnew));

                    String varHeaderLine = getVariableHeaderForSubset();
                    // Add the variable header to the subset file:
                    byte[] varHeaderBuffer = null;
                    varHeaderBuffer = varHeaderLine.getBytes();
                    outb.write(varHeaderBuffer);
                    outb.flush();

                    int bufsize;
                    byte[] bffr = new byte[8192];
                    while ((bufsize = inb.read(bffr)) != -1) {
                        outb.write(bffr, 0, bufsize);
                    }
                    inb.close();
                    outb.close();

                    dbgLog.fine("adding tab file: " + tmpsbflnew.getName());
                    zipFileList.add(tmpsbflnew);

                } else {

                    // (2)The format-converted subset data file
                    String wbDataFileName = resultInfo.get("wbDataFileName");
                    dbgLog.fine("wbDataFileName=" + wbDataFileName);

                    File wbSubsetDataFile = new File(wbDataFileName);
                    if (wbSubsetDataFile.exists()) {
                        dbgLog.fine("wbSubsetDataFile:length=" + wbSubsetDataFile.length());
                        deleteTempFileList.add(wbSubsetDataFile);
                        zipFileList.add(wbSubsetDataFile);
                    } else {
                        // the data file was not created
                        dbgLog.fine("wbSubsetDataFile does not exist");

                        msgDwnldButton.setValue("* The requested data file is not available");
                        msgDwnldButton.setVisible(true);
                        dbgLog.warning("exiting dwnldAction(): data file was not transferred");
                        getVDCRequestBean().setSelectedTab("tabDwnld");
                        dvnDSBTimerService.createTimer(deleteTempFileList, TEMP_FILE_LIFETIME);
                        return "";
                    }
                }

                // Create README file:

                String readMeFileName = null;

                if (resultInfo.get("PID") != null && !resultInfo.get("PID").equals("N/A")) {
                    readMeFileName = REP_README_FILE_PREFIX + resultInfo.get("PID") + ".txt";
                } else {
                    readMeFileName = REP_README_FILE_PREFIX + fileId + ".txt";
                }

                File readMeFile = new File(TEMP_DIR, readMeFileName);

                DvnReplicationREADMEFileWriter rw = new DvnReplicationREADMEFileWriter(resultInfo);
                rw.writeREADMEfile(readMeFile, true);

                zipFileList.add(readMeFile);
                deleteTempFileList.add(readMeFile);

                for (File f : zipFileList) {
                    dbgLog.fine("file to zip: path=" + f.getAbsolutePath() + "\tname=" + f.getName());
                }

                // We can now zip all the required files"
                try {
                    String zipFilePrefix = null;

                    if (resultInfo.get("PID") != null && !resultInfo.get("PID").equals("N/A")) {
                        zipFilePrefix = "zipFile_" + resultInfo.get("PID") + ".zip";
                    } else {
                        zipFilePrefix = "zipFile_" + fileId + ".zip";

                    }
                    File zipFile = new File(TEMP_DIR, zipFilePrefix);

                    //deleteTempFileList.add(zipFile);
                    String zfname = zipFile.getName();
                    zipFileName = zfname;
                    zipFiles(new FileOutputStream(zipFile), zipFileList);

                    /*
                    try {
                    Thread.sleep(1000);
                    } catch (Exception e) {
                        
                    }
                     */

                    zipResourceDynFileName = new ByteArrayResource(
                            toByteArray(new FileInputStream(zipFile.getAbsolutePath())));
                    dbgLog.info("Subsetting: zipFileName=" + zipFileName);
                    dbgLog.info("Subsetting: zipFile, absolute path: " + zipFile.getAbsolutePath());
                    dvnDSBTimerService.createTimer(deleteTempFileList, TEMP_FILE_LIFETIME);

                    // Hide 'Create' button, show 'Download' button:
                    dwnldButton.setRendered(false);
                    dwnloadSubsetButton.setRendered(true);
                    dbgLog.info("***** within dwnldAction(): ends here *****");

                    /*
                     * Navigation: 
                     *  - is it necessary to use "faces-redirect" navigation here? 
                     *    Or should we simply return "" as long as we want to stay 
                     *    on the subsetting page?
                    if (versionNumber != null) {
                        return "/study/SubsettingPage?faces-redirect=true&dtId=" + dtId + "&versionNumber=" + versionNumber;
                    }
                    return "/study/SubsettingPage?faces-redirect=true&dtId=" + dtId;
                     */
                    return "";

                } catch (IOException e) {
                    // file-access problem, etc.
                    e.printStackTrace();
                    dbgLog.fine("download zipping IO exception");
                    msgDwnldButton.setValue("* an IO problem occurred");
                    msgDwnldButton.setVisible(true);
                    dbgLog.warning("exiting dwnldAction() due to an IO problem ");
                    getVDCRequestBean().setSelectedTab("tabDwnld");
                    dvnDSBTimerService.createTimer(deleteTempFileList, TEMP_FILE_LIFETIME);
                    return "";
                }
                // end of zipping step

            } catch (IOException e) {
                e.printStackTrace();

                msgDwnldButton.setValue("* an IO problem occurred");
                msgDwnldButton.setVisible(true);
                dbgLog.warning("exiting dwnldAction() due to an IO problem ");
                getVDCRequestBean().setSelectedTab("tabDwnld");
                dvnDSBTimerService.createTimer(deleteTempFileList, TEMP_FILE_LIFETIME);
                return "";
            }

            // end: params are OK-case
        } else {
            // the selection is incomplete
            // show error message;
            pgDwnldErrMsg.setRendered(true);
            msgDwnldButton.setValue("* Error: Select a file format");
            msgDwnldButton.setVisible(true);
            dbgLog.warning("exiting dwnldAction() due to incomplete data ");
            getVDCRequestBean().setSelectedTab("tabDwnld");

            return "";
        } // end: checking params

    }

    // -----------------------------------------------------------------------
    // recode section
    // -----------------------------------------------------------------------
    // <editor-fold desc="recode">

    // moveRecodeVarBttn:h:commandButton@binding
    private HtmlCommandButton moveRecodeVarBttn = new com.icesoft.faces.component.ext.HtmlCommandButton();

    public HtmlCommandButton getMoveRecodeVarBttn() {
        return moveRecodeVarBttn;
    }

    public void setMoveRecodeVarBttn(HtmlCommandButton hcb) {
        this.moveRecodeVarBttn = hcb;
    }

    // errormessage for non-selected var case
    private HtmlOutputText msgMoveRecodeVarBttn = new com.icesoft.faces.component.ext.HtmlOutputText();

    public HtmlOutputText getMsgMoveRecodeVarBttn() {
        return msgMoveRecodeVarBttn;
    }

    public void setMsgMoveRecodeVarBttn(HtmlOutputText txt) {
        this.msgMoveRecodeVarBttn = txt;
    }

    public void resetMsgMoveRecodeVarBttn() {
        dbgLog.fine("***** within resetMsgMoveRecodeVarBttn *****");
        msgMoveRecodeVarBttn.setValue(" ");
        msgMoveRecodeVarBttn.setRendered(false);

    }

    private HtmlPanelGrid groupPanelRecodeNewVarInfo = new com.icesoft.faces.component.ext.HtmlPanelGrid();

    public HtmlPanelGrid getGroupPanelRecodeNewVarInfo() {
        return groupPanelRecodeNewVarInfo;
    }

    public void setGroupPanelRecodeNewVarInfo(HtmlPanelGrid gp) {
        this.groupPanelRecodeNewVarInfo = gp;
    }

    private HtmlPanelGrid groupPanelRecodeInstruction1 = new com.icesoft.faces.component.ext.HtmlPanelGrid();

    public HtmlPanelGrid getGroupPanelRecodeInstruction1() {
        return groupPanelRecodeInstruction1;
    }

    public void setGroupPanelRecodeInstruction1(HtmlPanelGrid gpri) {
        this.groupPanelRecodeInstruction1 = gpri;
    }

    private HtmlPanelGrid groupPanelRecodeInstruction2 = new com.icesoft.faces.component.ext.HtmlPanelGrid();

    public HtmlPanelGrid getGroupPanelRecodeInstruction2() {
        return groupPanelRecodeInstruction2;
    }

    public void setGroupPanelRecodeInstruction2(HtmlPanelGrid gpri2) {
        this.groupPanelRecodeInstruction2 = gpri2;
    }

    private HtmlPanelGrid groupPanelRecodeTableArea = new com.icesoft.faces.component.ext.HtmlPanelGrid();;

    public HtmlPanelGrid getGroupPanelRecodeTableArea() {
        return groupPanelRecodeTableArea;
    }

    public void setGroupPanelRecodeTableArea(HtmlPanelGrid gprta) {
        this.groupPanelRecodeTableArea = gprta;
    }

    // ice:selectOneListbox binding => varSetAdvStat
    private HtmlSelectOneListbox listboxRecode = new com.icesoft.faces.component.ext.HtmlSelectOneListbox();

    public HtmlSelectOneListbox getListboxRecode() {
        return listboxRecode;
    }

    public void setListboxRecode(HtmlSelectOneListbox lstbx) {
        this.listboxRecode = lstbx;
    }

    // listboxRecode:ice:selectOneListbox value
    private String selectedRecodeVariable;

    public void setSelectedRecodeVariable(String s) {
        selectedRecodeVariable = s;
    }

    public String getSelectedRecodeVariable() {
        return selectedRecodeVariable;
    }

    public void recodeVariableChanged(ValueChangeEvent event) {
        dbgLog.fine("***** recodeVariableChanged(): begins here *****");
        dbgLog.fine("old selectedRecodeVariable=" + selectedRecodeVariable);
        String oldVarValue = (String) event.getOldValue();
        dbgLog.fine("old value=" + event.getOldValue());
        String newVarValue = (String) event.getNewValue();
        dbgLog.fine("new value=" + event.getNewValue());
        selectedRecodeVariable = (String) event.getNewValue();
        dbgLog.fine("new selectedRecodeVariable=" + selectedRecodeVariable);
        dbgLog.fine("***** recodeVariableChanged(): ends here *****");
    }

    // moveRecodeVarBttn:h:commandButton@actionListener
    public void moveRecodeVariable(ActionEvent acev) {

        dbgLog.fine("***** moveRecodeVariable(): begins here *****");
        resetMsgMoveRecodeVarBttn();
        if (listboxRecode.getValue() != null) {
            dbgLog.fine("listboxRecode.getValue=" + listboxRecode.getValue());
        } else {
            dbgLog.fine("listboxRecode.getValue is null");
        }
        if (selectedRecodeVariable != null) {
            dbgLog.fine("selectedRecodeVariable=" + selectedRecodeVariable);
        } else {
            dbgLog.fine("selectedRecodeVariable is null");
        }

        String varId = null;// getSelectedRecodeVariable();
        if (selectedRecodeVariable == null) {
            dbgLog.fine("recode varId selected from the binding=" + listboxRecode.getValue());
            varId = (String) listboxRecode.getValue();
        } else {
            dbgLog.fine("recode varId selected from the value=" + selectedRecodeVariable);
            varId = selectedRecodeVariable;
        }

        if (varId != null) {
            dbgLog.fine("Is this a recoded var?[" + isRecodedVar(varId) + "]");
        } else {
            dbgLog.fine("recode-variable id is still null");

            msgMoveRecodeVarBttn.setRendered(true);
            msgMoveRecodeVarBttn.setValue("Select one variable as a source variable;<br />"
                    + "and click the start button to set up the recode table");
            return;
        }
        if (!groupPanelRecodeTableArea.isRendered()) {
            groupPanelRecodeTableArea.setRendered(true);
            groupPanelRecodeInstruction2.setRendered(true);
            groupPanelRecodeInstruction1.setRendered(false);
        }
        resetMsgSaveRecodeBttn();
        if (isRecodedVar(varId)) {
            // newly recoded var case
            dbgLog.fine("This a recoded var[" + varId + "]");

            List<Object> rvs = getRecodedVarSetRow(varId);
            if (rvs != null) {

                dbgLog.fine("requested newly recoded var was found");
                dbgLog.fine("new varName=" + rvs.get(0));
                dbgLog.fine("new varLabel=" + rvs.get(1));

                recallRecodedVariable(varId);

            } else {
                dbgLog.fine("requested newly recoded var was not found=" + varId);

            }

        } else {
            if (varId != null) {
                // set the name
                String varName = getVariableNamefromId(varId);
                dbgLog.fine("recode variable Name=" + varName);
                // setRecodeVariableName(varName);

                currentRecodeVariableName = varName;
                currentRecodeVariableId = varId;
                dbgLog.fine("currentRecodeVariableName=" + currentRecodeVariableName);
                dbgLog.fine("currentRecodeVariableId=" + currentRecodeVariableId);

                dbgLog.fine("recodeTargetVarName(b)=" + recodeTargetVarName.getValue());
                // set the label
                // setRecodeVariableLabel(getVariableLabelfromId(varId));
                String newNamePrefix = "new_" + RandomStringUtils.randomAlphanumeric(2) + "_";
                recodeTargetVarName.setValue(newNamePrefix + varName);
                recodeTargetVarLabel.setValue(newNamePrefix + getVariableLabelfromId(varId));
                dbgLog.fine("recodeTargetVarName(a)=" + recodeTargetVarName.getValue());
                // get value/label data and set them to the table
                DataVariable dv = getVariableById(varId);

                Collection<VariableCategory> catStat = dv.getCategories();
                recodeDataList.clear();
                recodeValueBox.setSubmittedValue(null);
                recodeTable.setRendered(false);
                dbgLog.fine("catStat.size=" + catStat.size());
                if (catStat.size() > 0) {
                    // catStat exists
                    dbgLog.fine("catStat exists");

                    for (Iterator elc = catStat.iterator(); elc.hasNext();) {
                        VariableCategory dvcat = (VariableCategory) elc.next();
                        if ((dvcat.getValue().equals(".")) && (dvcat.getFrequency() == 0)) {
                            continue;
                        }
                        List<Object> rw = new ArrayList<Object>();

                        // 0th: Drop
                        rw.add(new Boolean(false));
                        // 1st: New value
                        rw.add(dvcat.getValue());
                        // 2nd: New value label
                        rw.add(dvcat.getLabel());
                        // conditions
                        rw.add(dvcat.getValue());
                        //
                        recodeDataList.add(rw);
                    }

                } else {
                    // no catStat, either sumStat or too-many-categories
                    dbgLog.fine("catStat does not exists");
                    dbgLog.fine("create a default two-row table");
                    for (int i = 0; i < 2; i++) {
                        List<Object> rw = new ArrayList<Object>();
                        // 0th: Drop
                        rw.add(new Boolean(false));
                        // 1st: New value
                        rw.add("enter value here");
                        // 2nd: New value label
                        rw.add("enter label here");
                        // conditions
                        rw.add("enter a condition here");
                        //
                        recodeDataList.add(rw);
                    }

                }
                dbgLog.fine("recodeDataList=" + recodeDataList);
                //recodeTable.setValue(recodeDataList);
                dbgLog.fine("recodeTable: value=" + recodeTable.getValue());
                // show the recodeTable
                dbgLog.fine("Number of rows in this Recode Table=" + recodeDataList.size());
                groupPanelRecodeTableHelp.setRendered(true);
                recodeValueBox.setRendered(true);
                //                recodeTable.setValue(recodeDataList);
                //                recodeTable.setRendered(true);

                addValueRangeBttn.setRendered(true);
                // keep this variable's Id
                FacesContext.getCurrentInstance().getExternalContext().getSessionMap()
                        .put("currentRecodeVariableId", currentRecodeVariableId);
                FacesContext.getCurrentInstance().getExternalContext().getSessionMap()
                        .put("currentRecodeVariableName", currentRecodeVariableName);
                FacesContext.getCurrentInstance().getExternalContext().getSessionMap().put("recodeDataList",
                        recodeDataList);
                //FacesContext.getCurrentInstance().renderResponse();
                recodeTable.setRendered(true);
                recodeTable.setValue(recodeDataList);
                recodeValueBox.setRendered(true);
            } else {
                dbgLog.fine("Variable to be recoded is null");
            }
        }
        dbgLog.fine("***** moveRecodeVariable(): ends here *****");

    }

    private HtmlInputText recodeValueBox = new com.icesoft.faces.component.ext.HtmlInputText();

    public HtmlInputText getRecodeValueBox() {
        return recodeValueBox;
    }

    public void setRecodeValueBox(HtmlInputText recodeValueBox) {
        this.recodeValueBox = recodeValueBox;
    }

    public void clearRecodeTargetVarInfo() {
        dbgLog.fine("pass the clear step");
        recodeTargetVarName.resetValue();
        recodeTargetVarLabel.resetValue();
    }

    // panel above the recodeTable : recodeTableHelpPanel
    // @binding  ui to ice
    private HtmlPanelGrid groupPanelRecodeTableHelp = new com.icesoft.faces.component.ext.HtmlPanelGrid();

    public HtmlPanelGrid getGroupPanelRecodeTableHelp() {
        return groupPanelRecodeTableHelp;
    }

    public void setGroupPanelRecodeTableHelp(HtmlPanelGrid pg) {
        this.groupPanelRecodeTableHelp = pg;
    }

    // checkbox column(drop this value)
    // recodeDropValueCheckbox@binding
    //    private Checkbox recodeDropValueCheckbox = new Checkbox();
    //
    //    public Checkbox getRecodeDropValueCheckbox() {
    //        return recodeDropValueCheckbox;
    //    }
    //
    //    public void setRecodeDropValueCheckbox(Checkbox c) {
    //        this.recodeDropValueCheckbox = c;
    //    }

    private HtmlSelectBooleanCheckbox recodeDropValueCheckboxx = new com.icesoft.faces.component.ext.HtmlSelectBooleanCheckbox();

    public HtmlSelectBooleanCheckbox getRecodeDropValueCheckboxx() {
        return recodeDropValueCheckboxx;
    }

    public void setRecodeDropValueCheckboxx(HtmlSelectBooleanCheckbox cb) {
        this.recodeDropValueCheckboxx = cb;
    }

    // recode-Variable-name for the recode-table header cell
    // h:outputText(recodeHdrVariable)
    // @value

    private String currentRecodeVariableName;

    public void setCurrentRecodeVariableName(String crv) {
        this.currentRecodeVariableName = crv;
    }

    public String getCurrentRecodeVariableName() {
        return currentRecodeVariableName;
    }

    private String currentRecodeVariableId;

    public void setCurrentRecodeVariableId(String crv) {
        this.currentRecodeVariableId = crv;
    }

    public String getCurrentRecodeVariableId() {
        return currentRecodeVariableId;
    }

    // inputText: recodeTargetVarName:
    // @binding
    private HtmlInputText recodeTargetVarName = new com.icesoft.faces.component.ext.HtmlInputText();

    public HtmlInputText getRecodeTargetVarName() {
        return recodeTargetVarName;
    }

    public void setRecodeTargetVarName(HtmlInputText vn) {
        this.recodeTargetVarName = vn;
    }

    // @value
    private String recodeVariableName;

    public void setRecodeVariableName(String vn) {
        recodeVariableName = vn;
    }

    public String getRecodeVariableName() {
        return recodeVariableName;
    }

    // inputText: recodeTargetVarLabel
    // @binding
    private HtmlInputText recodeTargetVarLabel = new com.icesoft.faces.component.ext.HtmlInputText();

    public HtmlInputText getRecodeTargetVarLabel() {
        return recodeTargetVarLabel;
    }

    public void setRecodeTargetVarLabel(HtmlInputText vl) {
        this.recodeTargetVarLabel = vl;
    }

    // dataTable:recodeTable
    // @binding
    private HtmlDataTable recodeTable = new com.icesoft.faces.component.ext.HtmlDataTable();
    //new javax.faces.component.html.HtmlDataTable();

    public HtmlDataTable getRecodeTable() {
        return recodeTable;
    }

    public void setRecodeTable(HtmlDataTable daTa) {
        this.recodeTable = daTa;
    }

    // @value
    private List<Object> recodeDataList = new ArrayList<Object>();

    public List<Object> getRecodeDataList() {
        return recodeDataList;
    }

    public void setRecodeDataList(List<Object> dl) {
        this.recodeDataList = dl;
    }

    // commandButton (Add Value/Range Button)
    // addValueRangeBttn@binding

    private HtmlCommandButton addValueRangeBttn = new com.icesoft.faces.component.ext.HtmlCommandButton();

    public HtmlCommandButton getAddValueRangeBttn() {
        return addValueRangeBttn;
    }

    public void setAddValueRangeBttn(HtmlCommandButton hcb) {
        this.addValueRangeBttn = hcb;
    }

    // commandButton:addValueRangeBttn
    // @actionListener
    public void addValueRange(ActionEvent acev) {
        dbgLog.fine("before add: recodeDataList=" + recodeDataList);
        List<Object> rw = new ArrayList<Object>();
        // 0th: Drop
        rw.add(new Boolean(false));
        // 1st: New value
        rw.add("enter value here");
        // 2nd: New value label
        rw.add("enter label here");
        // conditions
        rw.add("enter a condition here");
        // 
        recodeDataList.add(rw);
        dbgLog.fine("after add: recodeDataList=" + recodeDataList);
        FacesContext.getCurrentInstance().getExternalContext().getSessionMap().put("recodeDataList",
                recodeDataList);
    }

    // A hash map that stores recoding schema
    private Map<String, List<Object>> recodeSchema = new HashMap<String, List<Object>>();

    // private Map<String, UIData> recodeSchema = new HashMap<String, UIData>();

    // public void setRecodeSchema(String varId, UIData rs){
    public void setRecodeSchema(String varId, List<Object> rs) {
        recodeSchema.put(varId, rs);
    }

    // public UIData getRecodeSchema (String varId){
    public List<Object> getRecodeSchema(String varId) {
        List<Object> rt = recodeSchema.get(varId);
        return rt;
    }

    // h:commandButton(Apply Recode Button)
    // recodeBttn@binding
    private HtmlCommandButton recodeButton = new com.icesoft.faces.component.ext.HtmlCommandButton();

    public HtmlCommandButton getRecodeButton() {
        return recodeButton;
    }

    public void setRecodeButton(HtmlCommandButton hcb) {
        this.recodeButton = hcb;
    }

    /**
     * Saves the current recoding schema in the Map object recodeSchema
     * after an end-user clicked the apply-recode button.
     * Attached to the actionListener attribute of h:commandButton component
     * whose id is recodeBttn
     */
    public void saveRecodedVariable(ActionEvent acev) {
        dbgLog.fine("***** saveRecodedVariable(): begins here *****");

        // get the current var Id (base variable's ID)
        String oldVarId = getCurrentRecodeVariableId();
        dbgLog.fine("base var_id=" + oldVarId);
        if (oldVarId == null) {
            dbgLog.fine("source variable is not selected");
            msgSaveRecodeBttn.setRendered(true);
            msgSaveRecodeBttn.setValue("Select one of the existing variables as a source variable;<br />"
                    + "and click the arrow button to set up the recode table");
            return;
        }

        // get the varName in the input field
        String newVarName = (String) recodeTargetVarName.getValue();
        dbgLog.fine("new var name=" + newVarName);
        if (StringUtils.isEmpty(newVarName)) {
            dbgLog.fine("Recode variable is not entered");
            msgSaveRecodeBttn.setRendered(true);
            msgSaveRecodeBttn.setValue(
                    "New variable name is not entered;<br />" + "enter a unique name in the variable-name box;");
            return;
        } else if (isRecodedVar(oldVarId)) {
            // replace (re-save) case
            dbgLog.fine(
                    "This variable id is found in the new variable set" + " and recoding scheme would be updated");
            dbgLog.fine("currentVarId=" + oldVarId);
            replaceRecodedVariable(oldVarId);
            return;
        } else {
            // newly create case
            if (isDuplicatedVariableName(newVarName)) {
                // duplicated name
                dbgLog.fine("The new variable name is already in use");
                msgSaveRecodeBttn.setRendered(true);
                msgSaveRecodeBttn.setValue("The variable Name you entered is found "
                        + "among the existing variables;<br />" + " enter a new variable name");
                return;
            } else {
                // sanity check against the name
                String whiteSpace = "\\s+";
                String prohibitedChars = "\\W+";
                String firstChar = "^[^a-zA-Z]";
                if (isVariableNameValid(newVarName, whiteSpace)) {
                    // whitespace found
                    msgSaveRecodeBttn.setRendered(true);
                    msgSaveRecodeBttn.setValue("A whitespace character was found in " + "the variable name;<br />"
                            + "Whitesapce characters are not allowed " + "in a variable name.");
                    return;
                } else if (isVariableNameValid(newVarName, prohibitedChars)) {
                    // non-permissible character was found
                    msgSaveRecodeBttn.setRendered(true);
                    msgSaveRecodeBttn.setValue("At least one non-permissible character was found "
                            + "in the variable name;<br />" + "Use a-z, A-Z, _, 0-9 characters.");
                    return;
                } else if (isVariableNameValid(newVarName, firstChar)) {
                    // non-permissible character found
                    msgSaveRecodeBttn.setRendered(true);
                    msgSaveRecodeBttn
                            .setValue("The first character of a variable name must be " + "an alphabet character.");
                    return;
                } else {
                    // unique and safe name
                    dbgLog.fine("The new variable name is unique");
                    msgSaveRecodeBttn.setRendered(false);
                }
            }
        }

        // get the varLabel in the input field
        String newVarLabel = (String) getRecodeTargetVarLabel().getValue();
        dbgLog.fine("new var Label=" + newVarLabel);

        // create a new var Id
        // new-case only

        StringBuilder sb = new StringBuilder(oldVarId + "_");
        sb.append(varIdGenerator(oldVarId));
        String newVarId = sb.toString();
        dbgLog.fine("newVarId=" + newVarId);
        FacesContext.getCurrentInstance().getExternalContext().getSessionMap().put("currentRecodeVariableId",
                newVarId);

        // new-case only
        varCart.put(newVarId, newVarName);
        // new only
        getVarSetAdvStat().add(new SelectItem(newVarId, newVarName));

        // add this new var to the old2new mapping table
        // new-case only
        if (baseVarToDerivedVar.containsKey(oldVarId)) {
            // already used for recoding
            Set<String> tmps = baseVarToDerivedVar.get(oldVarId);
            if (tmps.contains(newVarId)) {
                dbgLog.fine("This new var Id [" + newVarId + "] is found in the set");
            } else {
                tmps.add(newVarId);
            }
        } else {
            // not-yet used for recoding
            Set<String> tmps = new HashSet<String>();
            dbgLog.fine("This new var Id [" + newVarId + "] is NOT found in the set");
            tmps.add(newVarId);
            baseVarToDerivedVar.put(oldVarId, tmps);
        }
        dbgLog.fine("old-2-new-var map=" + baseVarToDerivedVar);

        // remove a row whose condition cell is blank
        // both
        dbgLog.fine("start normalization");
        for (int i = (recodeDataList.size() - 1); i >= 0; i--) {
            List<Object> row = (List<Object>) recodeDataList.get(i);
            String raw = removeWhiteSpacesfromBothEnds((String) row.get(3));
            dbgLog.fine("after removing white spaces[=" + raw + "]");

            if (raw.equals("")) {
                recodeDataList.remove(i);
                dbgLog.fine("element[" + i + "] was removed");
            }
        }
        dbgLog.fine("end of normalization");

        dbgLog.fine("recodeDataList=" + recodeDataList);
        // saving the data for the recode-table
        // new and replace: both cases
        // replace-case: remove the key first?
        recodeSchema.put(newVarId, new ArrayList(recodeDataList));

        // update the value-label-mapping-data storage
        // new and replace: both cases
        FacesContext.getCurrentInstance().getExternalContext().getSessionMap().put("recodeSchema", recodeSchema);
        dbgLog.fine("recodeSchema=" + recodeSchema);

        if (!recodeVarNameSet.contains(newVarName)) {
            // 1st-time save

            // add this var to the mapping table
            // add this new var to the new2old mappting table
            derivedVarToBaseVar.put(newVarId, oldVarId);
            dbgLog.fine("new-2-old-var map=" + derivedVarToBaseVar);

            // add this var's name, label, id to the backing object
            // (recodedVarSet)
            List<Object> rw = new ArrayList<Object>();
            // [0]
            rw.add(new String(newVarName));
            // [1]
            rw.add(new String(newVarLabel));
            // [2]
            rw.add(newVarId);

            recodedVarSet.add(rw);
            // update recodeVarSet for the recodedVarTable
            FacesContext.getCurrentInstance().getExternalContext().getSessionMap().put("recodedVarSet",
                    recodedVarSet);
            // add this newly created var to the set
            recodeVarNameSet.add(newVarName);

            // show the recode-var table
            pgRecodedVarTable.setRendered(true);
            dbgLog.fine("updated recodeVarNameSet:" + recodeVarNameSet);
        } else {
            // 2nd-time save
            // not required to add this var to mapping tables
            dbgLog.fine("newVarName=" + newVarName);
            dbgLog.fine("existing recodeVarNameSet:" + recodeVarNameSet);
        }
        // show the recoded-var table
        // recodedVarTable.setRendered(true);
        dbgLog.fine("recodeVarSet=" + recodedVarSet);
        // save recode-source variable name for the header
        FacesContext.getCurrentInstance().getExternalContext().getSessionMap().put("currentRecodeVariableName",
                currentRecodeVariableName);

        dbgLog.fine("***** saveRecodedVariable(): ends here *****");
    }

    public String removeWhiteSpacesfromBothEnds(String src) {
        String s = src.replaceAll("\\s+$", "");
        return s.replaceAll("^\\s+", "");
    }

    public boolean isDuplicatedVariableName(String newVarName) {
        boolean rtvl = false;
        // against the set of the existing variable names
        if (recodeVarNameSet.contains(newVarName)) {
            rtvl = true;

        } else {
            for (Iterator el = dataVariables.iterator(); el.hasNext();) {
                DataVariable dv = (DataVariable) el.next();
                if (dv.getName().equals(newVarName)) {
                    rtvl = true;
                    break;
                }
            }
        }

        return rtvl;
    }

    public boolean isVariableNameValid(String newVarName, String regex) {
        boolean rtvl = false;
        // 
        Pattern p = null;
        try {
            p = Pattern.compile(regex);
        } catch (PatternSyntaxException pex) {
            pex.printStackTrace();

        }
        Matcher matcher = p.matcher(newVarName);
        rtvl = matcher.find();
        return rtvl;
    }

    // Map from base-variable=>derived variable by varId
    // old(one) => new(many)
    private Map<String, Set<String>> baseVarToDerivedVar = new HashMap<String, Set<String>>();

    // new(one) => old(one)
    private Map<String, String> derivedVarToBaseVar = new HashMap<String, String>();

    // for duplication check
    private Set<String> recodeVarNameSet = new HashSet<String>();

    // newly derived variable's ID generator
    public String varIdGenerator(String varId) {
        int lstlen = 0;
        if (baseVarToDerivedVar.containsKey(varId)) {
            lstlen = baseVarToDerivedVar.get(varId).size();
        }
        return Integer.toString(lstlen);
    }

    // errormessage for recode-save button
    // ice:outputText
    private HtmlOutputText msgSaveRecodeBttn = new com.icesoft.faces.component.ext.HtmlOutputText();

    public HtmlOutputText getMsgSaveRecodeBttn() {
        return msgSaveRecodeBttn;
    }

    public void setMsgSaveRecodeBttn(HtmlOutputText txt) {
        this.msgSaveRecodeBttn = txt;
    }

    public void resetMsgSaveRecodeBttn() {
        dbgLog.fine("***** within resetMsgSaveRecodeBttn *****");
        msgSaveRecodeBttn.setValue(" ");
        msgSaveRecodeBttn.setRendered(false);

    }

    /**
     * remove a recoded Variable from the cart
     * 
     * h:commandLink attr: actionListener see recode block above
     */
    public void removeRecodedVariable(ActionEvent e) {
        dbgLog.fine("***** removeRecodedVariable(): begins here *****");

        // get data stored in the event row
        List<Object> tmpRecodeVarLine = (List<Object>) getRecodedVarTable().getRowData();
        // get varId as a key of recodeSchema
        String newVarId = (String) tmpRecodeVarLine.get(2);
        String newVarName = (String) tmpRecodeVarLine.get(0);
        dbgLog.fine("recoded-var id=" + newVarId);
        // clear the error message if it still exists
        resetMsgVariableSelection();

        // remove this recoded var from the value-label storage Map
        // (recodeSchema)
        if (recodeSchema.containsKey(newVarId)) {
            recodeSchema.remove(newVarId);
        } else {
            dbgLog.fine("value-label table of this var [" + newVarId + "] is not found");
        }
        // remove this recoded var from the recoded-var table (recodedVarSet)

        for (int i = 0; i < recodedVarSet.size(); i++) {
            List<Object> rvs = (List<Object>) recodedVarSet.get(i);
            String iter = (String) rvs.get(2);
            if (newVarId.equals(iter)) {
                dbgLog.fine("iter=" + i + " th element removed");
                recodedVarSet.remove(i);
                break;
            }
        }
        // remove this key from the old-2-new mapping table
        String oldVarId = derivedVarToBaseVar.get(newVarId);
        if (baseVarToDerivedVar.containsKey(oldVarId)) {

            Set<String> tmps = baseVarToDerivedVar.get(oldVarId);
            if (tmps.contains(newVarId)) {
                dbgLog.fine("This new var Id [" + newVarId + "] is found in the set and to be removed");
                tmps.remove(newVarId);
                if (tmps.size() < 1) {
                    dbgLog.fine("There is no recoded var for this base-var(id=" + oldVarId + " name="
                            + getVariableNamefromId(oldVarId) + ")");
                    baseVarToDerivedVar.remove(oldVarId);
                } else {
                    dbgLog.fine("The set is " + tmps.size() + " for this base-var(id=" + oldVarId + " name="
                            + getVariableNamefromId(oldVarId) + ")");
                }
            } else {
                dbgLog.fine("This new var Id [" + newVarId + "] is NOT found in the set");
            }

            derivedVarToBaseVar.remove(newVarId);
        } else {
            dbgLog.fine("recoded variable [" + newVarId + "] is not found in the new2old mapping table");
        }

        // remove this key from the new-2-old map
        if (derivedVarToBaseVar.containsKey(newVarId)) {
            derivedVarToBaseVar.remove(newVarId);
        } else {
            dbgLog.fine("recoded variable [" + newVarId + "] is not found in the new2old mapping table");
        }

        // if this variable is in the recode-table,
        String currentVarNameInBox = (String) recodeTargetVarName.getValue();
        dbgLog.fine("currentVarName in inputBox=" + currentVarNameInBox);
        if (newVarName.equals(currentVarNameInBox)) {
            dbgLog.fine("The variable in the recode table is" + " the variable to be removed");
            // clear the table
            recodeDataList.clear();
            // reset the current variable Id
            setCurrentRecodeVariableName(null);
            setCurrentRecodeVariableId(null);

            FacesContext.getCurrentInstance().getExternalContext().getSessionMap().put("currentRecodeVariableId",
                    currentRecodeVariableId);

            FacesContext.getCurrentInstance().getExternalContext().getSessionMap().put("currentRecodeVariableName",
                    currentRecodeVariableName);

            // reset variable name and label
            recodeTargetVarName.resetValue();
            recodeTargetVarLabel.resetValue();
            // hide the recode table and add-row button
            groupPanelRecodeTableHelp.setRendered(false);
            recodeTable.setRendered(false);
            addValueRangeBttn.setRendered(false);

            varCart.remove(newVarId);
            // remove the existing option first
            removeOption(newVarId, getVarSetAdvStat());
        } else {
            dbgLog.fine("The variable in the recode table differs " + "from the variable to be removed");
        }

        // if no more recoded var, hide the recoded var table
        if (baseVarToDerivedVar.isEmpty()) {
            pgRecodedVarTable.setRendered(false);
        }
        // reset the recode-woring area
        groupPanelRecodeTableArea.setRendered(false);
        groupPanelRecodeInstruction2.setRendered(false);
        groupPanelRecodeInstruction1.setRendered(true);

        dbgLog.fine("***** removeRecodedVariable(): ends here *****");
    }

    public boolean isRecodedVar(String varId) {
        Pattern p = Pattern.compile("_");
        Matcher m = p.matcher(varId);
        return m.find();
    }

    public String getNewVarName(String newVarId) {
        for (int i = 0; i < recodedVarSet.size(); i++) {
            List<Object> rvs = (List<Object>) recodedVarSet.get(i);
            String iter = (String) rvs.get(2);
            if (newVarId.equals(iter)) {
                dbgLog.fine("recode data(name) found at " + i + " th row");
                return (String) rvs.get(0);
            }
        }
        return null;
    }

    public String getNewVarLabel(String newVarId) {
        for (int i = 0; i < recodedVarSet.size(); i++) {
            List<Object> rvs = (List<Object>) recodedVarSet.get(i);
            String iter = (String) rvs.get(2);
            if (newVarId.equals(iter)) {
                dbgLog.fine("recode data(label) found at " + i + " th row");
                return (String) rvs.get(1);
            }
        }
        return null;
    }

    public List<Object> getRecodedVarSetRow(String newVarId) {
        for (int i = 0; i < recodedVarSet.size(); i++) {
            List<Object> rvs = (List<Object>) recodedVarSet.get(i);
            String iter = (String) rvs.get(2);
            if (newVarId.equals(iter)) {
                dbgLog.fine("recode data(row) found at " + i + " th row");
                return rvs;
            }
        }
        return null;
    }

    // editRecodedVariable
    // h:commandLink @actionListener
    // se recode block above

    public void editRecodedVariable(ActionEvent e) {

        // get data stored in the event row
        List<Object> tmpRecodeVarLine = (List<Object>) getRecodedVarTable().getRowData();
        dbgLog.fine("current recodedVar row:size=" + tmpRecodeVarLine.size());
        dbgLog.fine("current recodedVar row=" + tmpRecodeVarLine);
        // get varId
        String newVarId = (String) tmpRecodeVarLine.get(2);
        dbgLog.fine("recoded-var id=" + newVarId);

        dbgLog.fine("Is this a recoded var?[" + isRecodedVar(newVarId) + "]");
        // set this varId's list to the recodeTable

        if (recodeSchema.containsKey(newVarId)) {
            setRecodeDataList((List<Object>) recodeSchema.get(newVarId));

            recodeTable.setValue((List<Object>) recodeSchema.get(newVarId));
            // FacesContext.getCurrentInstance().getExternalContext()
            //      .getSessionMap().put("recodeDataList", recodeDataList);

            dbgLog.fine("contents of new value-label set=" + (List<Object>) recodeSchema.get(newVarId));
            dbgLog.fine("contents of new value-label set=" + recodeDataList);
            clearRecodeTargetVarInfo();
            // update the current recode-Variable's ID
            String[] tmp = null;
            tmp = newVarId.split("_");
            dbgLog.fine("base-var Id from new var id=" + tmp[0]);
            dbgLog.fine("base-var Id from the map=" + derivedVarToBaseVar.get(newVarId));
            // setCurrentRecodeVariableId(tmp[0]);

            currentRecodeVariableId = tmp[0];
            FacesContext.getCurrentInstance().getExternalContext().getSessionMap().put("currentRecodeVariableId",
                    currentRecodeVariableId);

            // update the varName
            // setRecodeVariableName( (String) tmpRecodeVarLine.get(0));

            // update the varLabel
            // setRecodeVariableLabel((String) tmpRecodeVarLine.get(1));

            recodeTargetVarName.setValue((String) tmpRecodeVarLine.get(0));
            recodeTargetVarLabel.setValue((String) tmpRecodeVarLine.get(1));

            // FacesContext.getCurrentInstance().getExternalContext()
            // .getSessionMap().put("recodeVariableName",recodeVariableName);
            // 
            // FacesContext.getCurrentInstance().getExternalContext()
            // .getSessionMap().put("recodeVariableLabel",recodeVariableLabel);
            //

            //FacesContext.getCurrentInstance().renderResponse();

        } else {
            dbgLog.fine("value-label table of this var [" + newVarId + "] is not found");
        }

    }

    public void recallRecodedVariable(String newVarId) {
        dbgLog.fine("***** recallRecodedVariable(): begins here *****");

        // get data stored in a row of the recodedVarTable by Id
        List<Object> rvs = getRecodedVarSetRow(newVarId);
        if (rvs != null) {
            dbgLog.fine("requested newly recoded var was found");
            dbgLog.fine("new varName=" + rvs.get(0));
            dbgLog.fine("new varLabel=" + rvs.get(1));

            // set this varId's list to the recodeTable

            if (recodeSchema.containsKey(newVarId)) {
                setRecodeDataList((List<Object>) recodeSchema.get(newVarId));

                recodeTable.setValue((List<Object>) recodeSchema.get(newVarId));
                dbgLog.fine("contents of new value-label set=" + (List<Object>) recodeSchema.get(newVarId));
                dbgLog.fine("contents of new value-label set=" + recodeDataList);
                FacesContext.getCurrentInstance().getExternalContext().getSessionMap().put("recodeDataList",
                        recodeDataList);

                clearRecodeTargetVarInfo();

                // update the current recode-Variable's ID
                String[] tmp = null;
                tmp = newVarId.split("_");
                dbgLog.fine("base-var Id from new var id=" + tmp[0]);
                dbgLog.fine("base-var Id from the map=" + derivedVarToBaseVar.get(newVarId));

                // currentRecodeVariableId=tmp[0];
                currentRecodeVariableId = newVarId;
                FacesContext.getCurrentInstance().getExternalContext().getSessionMap()
                        .put("currentRecodeVariableId", currentRecodeVariableId);

                recodeTargetVarName.setValue((String) rvs.get(0));
                recodeTargetVarLabel.setValue((String) rvs.get(1));

                //FacesContext.getCurrentInstance().renderResponse();

            } else {
                dbgLog.fine("value-label table of this var [" + newVarId + "] is not found");
            }
        } else {
            dbgLog.warning("requested newly recoded var was not found=" + newVarId);
        }
        dbgLog.fine("***** recallRecodedVariable(): ends here *****");

    }

    // updating the current recoding scheme
    public void replaceRecodedVariable(String newVarId) {

        dbgLog.fine("***** replaceRecodedVariable(): begins here *****");
        dbgLog.fine("current var id (from: args)=" + newVarId);
        dbgLog.fine("current var id (from: method)=" + getCurrentRecodeVariableId());

        // get the latest varName in the input field
        String newVarName = (String) recodeTargetVarName.getValue();
        dbgLog.fine("new var Name =" + newVarName);

        // sanity check against the name
        String whiteSpace = "\\s+";
        String prohibitedChars = "\\W+";
        String firstChar = "^[^a-zA-Z]";
        if (isVariableNameValid(newVarName, whiteSpace)) {
            // whitespace found
            msgSaveRecodeBttn.setRendered(true);
            msgSaveRecodeBttn.setValue(
                    "A whitespace character was found in the variable name;<br />Whitesapce characters are not allowed in a variable name.");
            return;
        } else if (isVariableNameValid(newVarName, prohibitedChars)) {
            // non-permissible character found
            msgSaveRecodeBttn.setRendered(true);
            msgSaveRecodeBttn.setValue(
                    "At least one non-permissible character was found in the variable name;<br />Use a-z, A-Z, _, 0-9 characters.");
            return;
        } else if (isVariableNameValid(newVarName, firstChar)) {
            // non-permissible character found
            msgSaveRecodeBttn.setRendered(true);
            msgSaveRecodeBttn.setValue("The first character of a variable name must be an alphabet character.");
            return;
        } else {
            // unique and safe name
            dbgLog.fine("The new variable name is unique");
            msgSaveRecodeBttn.setRendered(false);
            // msgSaveRecodeBttn.setValue("The variable name is unique");
        }

        // get the latest varLabel in the input field
        String newVarLabel = (String) getRecodeTargetVarLabel().getValue();
        dbgLog.fine("new var Label=" + newVarLabel);

        // create a new var Id
        // new-case only
        dbgLog.fine("newVarId=" + newVarId);

        // replace-case only
        // remove the current varId-varName pair: variable name might have been
        // updated
        varCart.remove(newVarId);

        // new and replace: both cases
        varCart.put(newVarId, newVarName);

        // replace only: remove the existing option first
        removeOption(newVarId, getVarSetAdvStat());
        // new and replace: both cases
        getVarSetAdvStat().add(new SelectItem(newVarId, newVarName));

        // add this new var to the old2new mapping table
        // new-case only
        dbgLog.fine("old-2-new-var map=" + baseVarToDerivedVar);

        // remove a row whose condition cell is blank
        // both
        dbgLog.fine("start normalization");
        for (int i = (recodeDataList.size() - 1); i >= 0; i--) {
            List<Object> row = (List<Object>) recodeDataList.get(i);
            String raw = removeWhiteSpacesfromBothEnds((String) row.get(3));
            dbgLog.fine("after removing white spaces[=" + raw + "]");

            if (raw.equals("")) {
                recodeDataList.remove(i);
                dbgLog.fine("element[" + i + "] was removed");
            }
        }
        dbgLog.fine("end of normalization");

        dbgLog.fine("recodeDataList=" + recodeDataList);
        // saving the data for the recode-table
        // replace-case: remove the existing entry first
        recodeSchema.remove(newVarId);

        // new and replace: both cases
        recodeSchema.put(newVarId, new ArrayList(recodeDataList));

        // update the value-label-mapping-data storage
        // new and replace: both cases
        FacesContext.getCurrentInstance().getExternalContext().getSessionMap().put("recodeSchema", recodeSchema);
        dbgLog.fine("recodeSchema=" + recodeSchema);

        // replace case
        // 2nd-time save
        // update the existing variable name and label because they might have
        // been modified
        dbgLog.fine("new-2-old-var map=" + derivedVarToBaseVar);

        // get the current row of this recoded var
        int location = -1;
        for (int i = 0; i < recodedVarSet.size(); i++) {
            List<Object> row = (List<Object>) recodedVarSet.get(i);
            String varId = (String) row.get(2);
            dbgLog.fine(i + "-th current varId=" + varId);
            if (varId.equals(newVarId)) {
                dbgLog.fine("The ID was found in the " + i + "-th row");
                location = i;
            }
        }
        if (location >= 0) {
            List<Object> oldrw = (List<Object>) recodedVarSet.get(location);

            boolean isVariableNameUpdated = false;
            String oldVarName = (String) oldrw.get(0);
            if (oldVarName.equals(newVarName)) {
                dbgLog.fine("The variable name was not updated");
            } else {
                dbgLog.fine("The old variable name(" + oldVarName + ") is replaced by " + newVarName);

                // The variable name has been updated;
                // remove the current name from recodeVarNameSet first
                if (recodeVarNameSet.remove(oldVarName)) {
                    dbgLog.fine("The old variable name was successfully removed");
                } else {
                    dbgLog.fine("The old variable name(" + oldVarName + ") was not removed");
                }
                isVariableNameUpdated = true;
            }
            // remove the current row first
            recodedVarSet.remove(location);

            // add the new row
            // add this var's name, label, id to the backing object
            // (recodedVarSet)
            List<Object> rw = new ArrayList<Object>();
            // [0]
            rw.add(new String(newVarName));
            // [1]
            rw.add(new String(newVarLabel));
            // [2]
            rw.add(newVarId);
            recodedVarSet.add(rw);
            // update recodeVarSet for the recodedVarTable
            FacesContext.getCurrentInstance().getExternalContext().getSessionMap().put("recodedVarSet",
                    recodedVarSet);

            // if the variable name has been updated,
            // remove the current name from recodeVarNameSet and
            // add the new one to it

            if (isVariableNameUpdated) {
                recodeVarNameSet.add(newVarName);
            }
        } else {
            dbgLog.warning("This variable was not saved(id=" + newVarId + ")");
        }
        // show the recoded-var table
        // recodedVarTable.setRendered(true);
        dbgLog.fine("recodeVarSet(after update)=" + recodedVarSet);
        dbgLog.fine("***** replaceRecodedVariable(): ends here *****");
    }

    public Map<String, List<String>> getRecodedVarParameters() {
        Map<String, List<String>> mpl = new HashMap<String, List<String>>();
        // new var name list
        List<String> vns = new ArrayList<String>();
        // Set<String> vids = recodeSchema.keySet();
        for (Object rw : recodedVarSet) {
            // add variable label
            List<Object> rwi = (List<Object>) rw;
            // [0] varName
            // [1] varLabel
            // [2] varId
            String newVarName = (String) rwi.get(0);
            String newVarLabel = (String) rwi.get(1);
            String newVarId = (String) rwi.get(2);
            // add newVarId to newVarName
            mpl.put("v" + newVarId, Arrays.asList(newVarName));
            dbgLog.fine("Id-Name: " + newVarId + "=>" + newVarName);
            // add new varName
            vns.add(newVarName);
            mpl.put("ud_" + newVarName + "_q_lebaLrav", Arrays.asList(newVarLabel));
            // add variable type:  0 for character var
            mpl.put("ud_" + newVarName + "_q_epyTrav", Arrays.asList("1"));
            // add value-label-condition
            List<Object> rdtbl = (List<Object>) recodeSchema.get(newVarId);
            dbgLog.fine("rdtbl=" + rdtbl);
            List<String> delList = new ArrayList<String>();
            for (Object rdtblrw : rdtbl) {
                List<Object> rdtbli = (List<Object>) rdtblrw;
                String baseVarName = getVariableNamefromId(derivedVarToBaseVar.get(newVarId));
                dbgLog.fine("rdtbli=" + rdtbli);

                if ((Boolean) rdtbli.get(0)) {
                    // delete flag: boolean true
                    // delete value
                    // "ud_"+ {newVarName} + "_q_eteleD"
                    // "eteleD|"+{VarName}+"|"+{condition}
                    dbgLog.fine("delete this value=" + rdtbli.get(3));
                    delList.add("eteleD|" + baseVarName + "|" + rdtbli.get(3));

                } else {
                    // delete flag: boolean false, i.e.,
                    // value - label - condition
                    // "ud_"+ {newVarName} + "_q_" +{value}
                    // {label}+"|"+{VarName}+"|"+{condition}
                    dbgLog.fine("keep this value=" + rdtbli.get(3));
                    String pmky = "ud_" + newVarName + "_q_" + rdtbli.get(1);
                    dbgLog.fine("pmky=" + pmky);
                    if (mpl.containsKey(pmky)) {
                        // key exits
                        List<String> tmpvl = (List<String>) mpl.get(pmky);
                        dbgLog.fine("tmpvl:b=" + tmpvl);
                        String pmvl = rdtbli.get(2) + "|" + baseVarName + "|" + rdtbli.get(3);
                        dbgLog.fine("pmvl=" + pmvl);
                        tmpvl.add(pmvl);
                        dbgLog.fine("tmpvl:a=" + tmpvl);
                        // mpl.put(pmky, new ArrayList(tmpvl) );
                        mpl.put(pmky, tmpvl);

                    } else {
                        List<String> pvlst = new ArrayList();
                        pvlst.add(rdtbli.get(2) + "|" + baseVarName + "|" + rdtbli.get(3));
                        mpl.put(pmky, pvlst);
                    }
                    // mpl.put("ud_"+newVarName+"_q_"+rdtbli.get(1),
                    // Arrays.asList(rdtbli.get(2)+"|"+baseVarName+"|"+rdtbli.get(3))
                    // );
                }

            } // for:inner

            if (delList.size() > 0) {
                mpl.put("ud_" + newVarName + "_q_eteleD", delList);
            }

        } // for:outer
          // add newVarNameSet
        mpl.put("newVarNameSet", vns);

        return mpl;
    }

    // -----------------------------------------------------------------------
    // recoded-variable Table section
    // -----------------------------------------------------------------------
    // / title and message line

    // HtmlOutputText: recodedVarTableTitle@binding
    private HtmlOutputText recodedVarTableTitle = new com.icesoft.faces.component.ext.HtmlOutputText();

    public HtmlOutputText getRecodedVarTableTitle() {
        return recodedVarTableTitle;
    }

    public void setRecodedVarTableTitle(HtmlOutputText hot) {
        this.recodedVarTableTitle = hot;
    }

    // h:panelGroup PGrecodedVarTable
    // @binding
    private HtmlPanelGrid pgRecodedVarTable = new com.icesoft.faces.component.ext.HtmlPanelGrid();

    public HtmlPanelGrid getPgRecodedVarTable() {
        return pgRecodedVarTable;
    }

    public void setPgRecodedVarTable(HtmlPanelGrid pg) {
        this.pgRecodedVarTable = pg;
    }

    // h:dataTable: recodedVarTable
    // @binding
    private UIData recodedVarTable = null;

    public UIData getRecodedVarTable() {
        return recodedVarTable;
    }

    public void setRecodedVarTable(UIData data) {
        this.recodedVarTable = data;
    }

    // @value
    private List<Object> recodedVarSet = new ArrayList<Object>();

    public void setRecodedVarSet(List<Object> dt) {
        this.recodedVarSet = dt;
    }

    public List<Object> getRecodedVarSet() {
        return recodedVarSet;
    }

    public void hideRecodeTableArea() {
        groupPanelRecodeTableHelp.setRendered(false);
        recodeTable.setRendered(false);
        addValueRangeBttn.setRendered(false);
    }

    public void clearRecodeTableBlock() {
        // borrowed from the removeRecodedVariable()
        dbgLog.fine("***** clearRecodeTableBlock(): starts *****");

        // clear the table
        recodeDataList.clear();
        // reset the current variable Id
        setCurrentRecodeVariableName(null);
        setCurrentRecodeVariableId(null);

        // reset variable name and label
        recodeTargetVarName.resetValue();
        recodeTargetVarLabel.resetValue();

        // hide the recode table and add-row button
        groupPanelRecodeTableHelp.setRendered(false);
        recodeTable.setRendered(false);
        addValueRangeBttn.setRendered(false);

        // if no more recoded var, hide the recoded var table
        if (baseVarToDerivedVar.isEmpty()) {
            pgRecodedVarTable.setRendered(false);
        }

        // reset the recode-woring area
        groupPanelRecodeTableArea.setRendered(false);
        groupPanelRecodeInstruction2.setRendered(false);
        groupPanelRecodeInstruction1.setRendered(true);

        dbgLog.fine("***** clearRecodeTableBlock(): ends *****");
    }

    // recode section ends here
    // </editor-fold>

    // -----------------------------------------------------------------------
    // eda section
    // -----------------------------------------------------------------------
    // <editor-fold desc="EDA">

    // LHS: list box related fields

    // RHS: checkbox area related fields
    // analysis :selectManyCheckbox@binding
    private HtmlSelectManyCheckbox edaOptionSet = new com.icesoft.faces.component.ext.HtmlSelectManyCheckbox();
    //new HtmlSelectManyCheckbox();

    public HtmlSelectManyCheckbox getEdaOptionSet() {
        return edaOptionSet;
    }

    public void setEdaOptionSet(HtmlSelectManyCheckbox edaOptionSet) {
        this.edaOptionSet = edaOptionSet;
    }

    // selectManyCheckbox@value

    private Object[] edaOptionSelected = null;

    public Object[] getEdaOptionSelected() {
        if (edaOptionSelected == null) {
            edaOptionSelected = new Object[1];
            edaOptionSelected[0] = (Object) (getEdaOptionItems().get(0));
        }
        return edaOptionSelected;
    }

    public void setEdaOptionSelected(Object[] edaOptionSelected) {
        this.edaOptionSelected = edaOptionSelected;
    }

    // edaOptionNumeric:f:selectItem@itemValue
    // edaOptionGraphic:f:selectItem@itemValue
    private List edaOptionItems = null;

    public List getEdaOptionItems() {
        if (edaOptionItems == null) {
            edaOptionItems = new ArrayList();
            edaOptionItems.add("A01");
            edaOptionItems.add("A02");
        }
        return edaOptionItems;
    }

    // submit button
    // edaBttn:h:commandButton@binding
    private HtmlCommandButton edaButton = new com.icesoft.faces.component.ext.HtmlCommandButton();
    // new HtmlCommandButton();

    public HtmlCommandButton getEdaButton() {
        return edaButton;
    }

    public void setEdaButton(HtmlCommandButton hcb) {
        this.edaButton = hcb;
    }

    // checking parameters before submission-
    public boolean checkEdaParameters() {
        boolean result = false;
        dbgLog.info("EDA: number of selected options (value)=" + edaOptionSelected);
        Object[] vs = edaOptionSet.getSelectedValues();
        dbgLog.info("EDA: number of selected options (binding)=" + vs);
        // param-checking conditions
        if (edaOptionSelected.length > 0) {
            dbgLog.info("EDA(checkEdaParameters): number of selected options=" + vs.length);
            result = true;
        } else if (vs.length > 0) {
            dbgLog.info("EDA(checkEdaParameters): number of selected options=" + vs.length);
            result = true;
        } else {
            dbgLog.info("EDA(checkEdaParameters()): no option is checked");
        }
        return result;
    }

    // msgEdaButton:ice:outputText@binding
    private com.icesoft.faces.component.ext.HtmlOutputText msgEdaButton = new com.icesoft.faces.component.ext.HtmlOutputText();

    public com.icesoft.faces.component.ext.HtmlOutputText getMsgEdaButton() {
        return msgEdaButton;
    }

    public void setMsgEdaButton(com.icesoft.faces.component.ext.HtmlOutputText txt) {
        this.msgEdaButton = txt;
    }

    private String msgEdaButtonTxt;

    public String getMsgEdaButtonTxt() {
        return msgEdaButtonTxt;
    }

    public void setMsgEdaButtonTxt(String txt) {
        this.msgEdaButtonTxt = txt;
    }

    public void resetMsgEdaButton() {
        dbgLog.info("***** within resetMsgEdaButton *****");
        msgEdaButton.setValue(" ");
        FacesContext.getCurrentInstance().getExternalContext().getSessionMap().put("msgEdaButtonTxt",
                msgEdaButtonTxt);
        msgEdaButton.setVisible(false);

        dbgLog.info("***** resetMsgEdaButton: end  *****");
    }

    // end of eda section ----------------------------------------------------
    // </editor-fold>

    // edaBttn:h:commandButton@action
    public String edaAction() {

        //        dbgLog.fine("selected tab(eda)="+getTabSet1().getSelected());
        // clear the error message around the EDA button if they exisit
        resetMsgEdaButton();

        if (checkEdaParameters()) {

            FacesContext cntxt = FacesContext.getCurrentInstance();

            HttpServletResponse res = (HttpServletResponse) cntxt.getExternalContext().getResponse();
            HttpServletRequest req = (HttpServletRequest) cntxt.getExternalContext().getRequest();

            dbgLog.info("***** within edaAction() *****");

            StudyFile sf = dataTable.getStudyFile();
            Long noRecords = dataTable.getRecordsPerCase();

            String dsbUrl = getDsbUrl();
            dbgLog.info("dsbUrl=" + dsbUrl);

            String serverPrefix = req.getScheme() + "://" + req.getServerName() + ":" + req.getServerPort()
                    + req.getContextPath();
            /*
            String serverPrefix = "http://dvn-alpha.hmdc.harvard.edu"
                + req.getContextPath();
            */
            dbgLog.info("serverPrefix" + serverPrefix);

            /*
             * "optnlst_a" => "A01|A02|A03",
             * "analysis" => "A01 A02",
             * "varbl" => "v1.3 v1.10 v1.13 v1.22 v1.40", 
             * "charVarNoSet" =>
             * "v1.10|v1.719",
             */

            Map<String, List<String>> mpl = new HashMap<String, List<String>>();

            Object[] vs = edaOptionSet.getSelectedValues();
            // analysis=[A01, A02]
            List<String> alst = new ArrayList<String>();

            for (int i = 0; i < vs.length; i++) {
                dbgLog.info("eda option[" + i + "]=" + vs[i]);
                alst.add((String) vs[i]);
            }

            mpl.put("analysis", alst);

            mpl.put("optnlst_a", Arrays.asList("A01|A02|A03"));

            // if there is a user-defined (recoded) variables
            /*
            if (recodedVarSet.size() > 0) {
                mpl.putAll(getRecodedVarParameters());
            }
            */
            //                dbgLog.fine("citation info to be sent:\n" + citation);
            //                mpl.put("OfflineCitation", Arrays.asList(citation));
            //                mpl.put("appSERVER", Arrays.asList(req.getServerName() + ":"
            //                    + req.getServerPort() + req.getContextPath()));

            mpl.put("studytitle", Arrays.asList(getStudyTitle()));
            dbgLog.info("studyId from get method=" + getStudyId().toString());
            mpl.put("studyno", Arrays.asList(getStudyId().toString()));
            mpl.put("studyURL", Arrays.asList(studyURL));
            mpl.put("browserType", Arrays.asList(browserType));

            mpl.put("recodedVarIdSet", getRecodedVarIdSet());
            mpl.put("recodedVarNameSet", getRecodedVarNameSet());
            mpl.put("recodedVarLabelSet", getRecodedVarLabelSet());
            mpl.put("recodedVarTypeSet", getRecodedVariableType());
            mpl.put("recodedVarBaseTypeSet", getBaseVariableTypeForRecodedVariable());

            mpl.put("baseVarIdSet", getBaseVarIdSetFromRecodedVarIdSet());
            mpl.put("baseVarNameSet", getBaseVarNameSetFromRecodedVarIdSet());

            mpl.put("requestType", Arrays.asList("EDA"));

            // -----------------------------------------------------
            // New processing route
            // 
            // Step 0. Locate the data file and its attributes

            String fileId = sf.getId().toString();
            //VDC vdc = vdcService.getVDCFromRequest(req);

            String fileloc = sf.getFileSystemLocation();
            String tabflnm = sf.getFileName();
            boolean sbstOK = sf.isSubsettable();
            String flct = sf.getFileType();

            dbgLog.info("location=" + fileloc);
            dbgLog.info("filename=" + tabflnm);
            dbgLog.info("subsettable=" + sbstOK);
            dbgLog.info("filetype=" + flct);

            DvnRJobRequest sro = null;

            List<File> zipFileList = new ArrayList();

            // the data file for downloading/statistical analyses must be subset-ready
            // local (relative to the application) file case 
            // note: a typical remote case is: US Census Bureau
            File tmpsbfl = null;
            if (sbstOK) {

                try {
                    // this temp file will store the requested columns:
                    tmpsbfl = File.createTempFile("tempsubsetfile.", ".tab");
                    deleteTempFileList.add(tmpsbfl);

                    // to produce this file, we'll either open the stream
                    // and run our local subsetting code on it, or request
                    // the subsetting to be performed natively by the access
                    // driver, if it supports the functionality:

                    // check whether a source file is tab-delimited or not

                    boolean fieldcut = true;
                    if ((noRecords != null) && (noRecords >= 1)) {
                        fieldcut = false;
                    }

                    DataAccessRequest daReq = new DataAccessRequest();
                    daReq.setParameter("noVarHeader", "1");

                    DataAccessObject accessObject = DataAccess.createDataAccessObject(sf, daReq);

                    if (accessObject.isSubsetSupported()) {
                        dbgLog.info("Using NATIVE subset functionality of the repository.");
                        daReq.setParameter("vars", getVariableNamesForSubset());

                        accessObject.open();

                        InputStream inSubset = accessObject.getInputStream();
                        OutputStream outSubset = new BufferedOutputStream(
                                new FileOutputStream(tmpsbfl.getAbsolutePath()));

                        int bufsize = 8192;
                        byte[] subsetDataBuffer = new byte[bufsize];
                        while ((bufsize = inSubset.read(subsetDataBuffer)) != -1) {
                            outSubset.write(subsetDataBuffer, 0, bufsize);
                        }

                        inSubset.close();
                        outSubset.close();

                        // TODO: catch exceptions; reset the state of the page
                        // if anything went wrong. See the fixed-field section
                        // below for an example.

                    } else {
                        accessObject.open();

                        if (fieldcut) {
                            // Cutting requested fields of data from a TAB-delimited stream:

                            Set<Integer> fields = getFieldNumbersForSubsetting();
                            dbgLog.info("subsetting fields=" + fields);

                            // Create an instance of DvnJavaFieldCutter
                            FieldCutter fc = new DvnJavaFieldCutter();

                            // Executes the subsetting request
                            fc.subsetFile(accessObject.getInputStream(), tmpsbfl.getAbsolutePath(), fields,
                                    dataTable.getCaseQuantity(), "\t");

                            // TODO: catch exceptions; reset the state of the page
                            // if anything went wrong. See the fixed-field section
                            // below for an example.

                        } else {
                            // Cutting requested columns of data from a fixed-field stream:

                            Map<Long, List<List<Integer>>> varMetaSet = getSubsettingMetaData(noRecords);
                            DvnNewJavaFieldCutter fc = new DvnNewJavaFieldCutter(varMetaSet);

                            try {
                                //fc.cutColumns(new File(cutOp1), noRecords.intValue(), 0, "\t", tmpsbfl.getAbsolutePath());
                                fc.cutColumns(accessObject.getInputStream(), noRecords.intValue(), 0, "\t",
                                        tmpsbfl.getAbsolutePath());
                            } catch (FileNotFoundException e) {
                                e.printStackTrace();

                                msgDwnldButton.setValue("* could not generate subset due to an IO problem");
                                msgDwnldButton.setVisible(true);
                                dbgLog.warning("exiting dwnldAction() due to an IO problem ");
                                getVDCRequestBean().setSelectedTab("tabDwnld");
                                dvnDSBTimerService.createTimer(deleteTempFileList, TEMP_FILE_LIFETIME);
                                return "";

                            } catch (RuntimeException re) {
                                re.printStackTrace();

                                msgDwnldButton.setValue("* could not generate subset due to an runtime error");
                                msgDwnldButton.setVisible(true);
                                dbgLog.warning("exiting dwnldAction() due to an runtime error");
                                getVDCRequestBean().setSelectedTab("tabDwnld");
                                dvnDSBTimerService.createTimer(deleteTempFileList, TEMP_FILE_LIFETIME);
                                return "";

                            }

                        }
                    }

                    // Checks the resulting subset file 
                    if (tmpsbfl.exists()) {
                        Long subsetFileSize = tmpsbfl.length();
                        dbgLog.info("subsettFile:Length=" + subsetFileSize);
                        dbgLog.info("tmpsb file name=" + tmpsbfl.getAbsolutePath());

                        if (subsetFileSize > 0) {
                            mpl.put("subsetFileName", Arrays.asList(tmpsbfl.getAbsolutePath()));
                            mpl.put("subsetDataFileName", Arrays.asList(tmpsbfl.getName()));
                        } else {
                            // subset file exists but it is empty

                            msgEdaButton.setValue("* an subset file is empty");
                            msgEdaButton.setVisible(true);
                            dbgLog.warning(
                                    "exiting edaAction() due to a subsetting error:" + "a subset file is empty");
                            getVDCRequestBean().setSelectedTab("tabEda");

                            return "";

                        }
                    } else {
                        // subset file was not created
                        msgEdaButton.setValue("* a subset file was not created");
                        msgEdaButton.setVisible(true);
                        dbgLog.warning(
                                "exiting edaAction() due to a subsetting error:" + "a subset file was not created");
                        getVDCRequestBean().setSelectedTab("tabEda");

                        return "";

                    }

                    // Step 3. Organizes parameters/metadata to be sent to the implemented
                    // data-analysis-service class

                    //Map<String, Map<String, String>> vls = getValueTableForRequestedVariables(getDataVariableForRequest());
                    Map<String, Map<String, String>> vls = getValueTablesForAllRequestedVariables();

                    sro = new DvnRJobRequest(getDataVariableForRequest(), mpl, vls, recodeSchema);

                    //                    dbgLog.fine("sro dump:\n"+ToStringBuilder.reflectionToString(sro, ToStringStyle.MULTI_LINE_STYLE));

                    // Step 4. Creates an instance of the the implemented 
                    // data-analysis-service class 

                    DvnRDataAnalysisServiceImpl das = new DvnRDataAnalysisServiceImpl();

                    // Executes a request of downloading or data analysis and 
                    // capture result info as a Map <String, String>

                    resultInfo = das.execute(sro);

                    // Step 5. Checks the DSB-exit-status code
                    if (resultInfo.get("RexecError").equals("true")) {
                        msgEdaButton.setValue("* The Request failed due to an R-runtime error");
                        msgEdaButton.setVisible(true);
                        dbgLog.info("exiting edaAction() due to an R-runtime error");
                        getVDCRequestBean().setSelectedTab("tabEda");

                        return "";
                    } else {
                        if (recodeSchema.size() > 0) {
                            resultInfo.put("subsettingCriteria", sro.getSubsetConditionsForCitation());
                        } else {
                            resultInfo.put("subsettingCriteria", "");
                        }
                    }

                } catch (MalformedURLException e) {
                    e.printStackTrace();

                    msgEdaButton.setValue("* file URL is malformed");
                    msgEdaButton.setVisible(true);
                    dbgLog.warning("exiting edaAction() due to a URL problem ");
                    getVDCRequestBean().setSelectedTab("tabEda");

                    return "";

                } catch (IOException e) {
                    // this may occur if the dataverse is not released
                    // the file exists, but it is not accessible 
                    e.printStackTrace();

                    msgEdaButton.setValue("* an IO problem occurred");
                    msgEdaButton.setVisible(true);
                    dbgLog.warning("exiting edaAction() due to an IO problem ");
                    getVDCRequestBean().setSelectedTab("tabEda");

                    return "";
                }

                // end of the subset-OK case
            } else {
                // not subsettable data file
                msgEdaButton.setValue("* this data file is not subsettable file");
                msgEdaButton.setVisible(true);
                dbgLog.warning("exiting edaAction(): the data file is not subsettable ");
                getVDCRequestBean().setSelectedTab("tabEda");

                return "";

            } // end:subsetNotOKcaseF

            // final processing steps for all successful cases

            resultInfo.put("offlineCitation", getCitation());
            resultInfo.put("studyTitle", getStudyTitle());
            resultInfo.put("studyNo", getStudyId().toString());
            resultInfo.put("fileName", fileName);
            resultInfo.put("dtId", dtId.toString());
            if (versionNumber != null) {
                resultInfo.put("versionNumber", versionNumber.toString());
            }
            resultInfo.put("studyURL", studyURL);
            resultInfo.put("R_min_verion_no", resultInfo.get("Rversion").substring(2));
            resultInfo.put("dataverse_version_no", dvnVersionNumber);

            dbgLog.info("RwrkspFileName=" + resultInfo.get("wrkspFileName"));

            // writing necessary files
            try {

                // rename the subsetting file
                File tmpsbflnew = File.createTempFile(SUBSET_FILENAME_PREFIX + resultInfo.get("PID") + ".", ".tab");
                deleteTempFileList.add(tmpsbflnew);
                InputStream inb = new BufferedInputStream(new FileInputStream(tmpsbfl));
                OutputStream outb = new BufferedOutputStream(new FileOutputStream(tmpsbflnew));

                int bufsize;
                byte[] bffr = new byte[8192];
                while ((bufsize = inb.read(bffr)) != -1) {
                    outb.write(bffr, 0, bufsize);
                }
                inb.close();
                outb.close();

                String rhistNew = StringUtils.replace(resultInfo.get("RCommandHistory"), tmpsbfl.getName(),
                        tmpsbflnew.getName());

                //zipFileList.add(tmpsbflnew);

                // (1) write a citation file 
                //                String citationFilePrefix = "citationFile_"+ resultInfo.get("PID") + "_";
                //                File tmpcfl = File.createTempFile(citationFilePrefix, ".txt");
                //
                //                zipFileList.add(tmpcfl);
                //                deleteTempFileList.add(tmpcfl);
                //
                //                DvnCitationFileWriter dcfw = new DvnCitationFileWriter(resultInfo);
                //
                //                String fmpcflFullname = tmpcfl.getAbsolutePath();
                //                String fmpcflname = tmpcfl.getName();
                //                dcfw.write(tmpcfl);

                // (2) R command file
                String rhistoryFilePrefix = R_COMMAND_FILE_PREFIX + resultInfo.get("PID") + ".R";
                File tmpRhfl = new File(TEMP_DIR, rhistoryFilePrefix);

                zipFileList.add(tmpRhfl);
                deleteTempFileList.add(tmpRhfl);
                resultInfo.put("dvn_R_helper_file", "dvn_helper.R");
                DvnReplicationCodeFileWriter rcfw = new DvnReplicationCodeFileWriter(resultInfo);
                rcfw.writeEdaCode(tmpRhfl);

                // (3)RData Replication file
                String wrkspFileName = resultInfo.get("wrkspFileName");
                dbgLog.info("wrkspFileName=" + wrkspFileName);

                File RwrkspFileName = new File(wrkspFileName);
                if (RwrkspFileName.exists()) {
                    dbgLog.info("RwrkspFileName:length=" + RwrkspFileName.length());

                    zipFileList.add(RwrkspFileName);

                } else {
                    dbgLog.info("RwrkspFileName does not exist");
                    //msgEdaButton.setValue("* The workspace file is not available");
                    //msgEdaButton.setVisible(true);
                    dbgLog.warning("edaAction(): R workspace file was not transferred");
                    //getVDCRequestBean().setSelectedTab("tabEda");

                    //return "failure";
                }
                deleteTempFileList.add(RwrkspFileName);

                //                // vdc_startup.R file
                //                String vdc_startupFileName = resultInfo.get("vdc_startupFileName");
                //                dbgLog.fine("vdc_startupFileName="+vdc_startupFileName);
                //                File vdcstrtFileName = new File(vdc_startupFileName);
                //                if (vdcstrtFileName.exists()){
                //                    dbgLog.fine("vdcstrtFileName:length="+vdcstrtFileName.length());
                //                    zipFileList.add(vdcstrtFileName);
                //                } else {
                //                    dbgLog.fine("vdcstrtFileName does not exist");
                //                    //msgEdaButton.setValue("* vdc_startup.R is not available");
                //                    //msgEdaButton.setVisible(true);
                //                    dbgLog.warning("edaAction(): vdc_startup.R was not transferred");
                //                    //getVDCRequestBean().setSelectedTab("tabEda");
                //
                //                    //return "failure";
                //                }
                //                deleteTempFileList.add(vdcstrtFileName);
                // add replication readme file
                // (4) readme file
                // zipFileList.add(REP_README_FILE);
                String readMeFileName = REP_README_FILE_PREFIX + resultInfo.get("PID") + ".txt";
                File readMeFile = new File(TEMP_DIR, readMeFileName);

                DvnReplicationREADMEFileWriter rw = new DvnReplicationREADMEFileWriter(resultInfo);
                rw.writeREADMEfile(readMeFile);
                //zipFileList.add(REP_README_FILE);
                zipFileList.add(readMeFile);
                deleteTempFileList.add(readMeFile);

                // (5) css file
                zipFileList.add(DVN_R2HTML_CSS_FILE);
                // (6) dvn_R_helper
                zipFileList.add(DVN_R_HELPER_FILE);
                // zip the following files as a replication-pack
                //
                // local     local        local      remote
                // citation, tab-file,   R history,  wrksp

                for (File f : zipFileList) {
                    dbgLog.fine("path=" + f.getAbsolutePath() + "\tname=" + f.getName());
                }

                // zipping all required files
                try {
                    String zipFilePrefix = "zipFile_" + resultInfo.get("PID") + ".zip";
                    File zipFile = new File(TEMP_DIR, zipFilePrefix);

                    //res.setContentType("application/zip");
                    String zfname = zipFile.getAbsolutePath();
                    //res.setHeader("content-disposition", "attachment; filename=" + zfname);

                    OutputStream zfout = new FileOutputStream(zipFile);
                    //zipFiles(res.getOutputStream(), zipFileList);
                    zipFiles(zfout, zipFileList);
                    deleteTempFileList.add(zipFile);
                    if (zipFile.exists()) {
                        Long zipFileSize = zipFile.length();
                        dbgLog.info("zip file:length=" + zipFileSize);
                        dbgLog.info("zip file:name=" + zipFile.getAbsolutePath());
                        if (zipFileSize > 0) {
                            resultInfo.put("replicationZipFile", zfname);
                            resultInfo.put("replicationZipFileName", zipFile.getName());
                        } else {
                            dbgLog.info("zip file is empty");
                        }
                    } else {
                        dbgLog.info("zip file was not saved");
                    }

                    resultInfo.remove("RCommandHistory");

                    // put resultInfo into the session object

                    FacesContext.getCurrentInstance().getExternalContext().getSessionMap().put("resultInfo",
                            resultInfo);

                    dvnDSBTimerService.createTimer(deleteTempFileList, TEMP_FILE_LIFETIME);

                    dbgLog.info("***** within edaAction(): succcessfully ends here *****");

                    return "/subsetting/AnalysisResultsPage?faces-redirect=true" + getContextSuffix();
                    //return "success";

                } catch (IOException e) {
                    // file-access problem, etc.
                    e.printStackTrace();
                    dbgLog.info("zipping IO exception");
                    msgEdaButton.setValue("* an IO problem occurred during zipping replication files");
                    msgEdaButton.setVisible(true);
                    dbgLog.warning("exiting edaAction() due to an zipping IO problem ");
                    //getVDCRequestBean().setSelectedTab("tabEda");
                    dvnDSBTimerService.createTimer(deleteTempFileList, TEMP_FILE_LIFETIME);
                    return "/subsetting/AnalysisResultsPage?faces-redirect=true" + getContextSuffix();
                    //return "success";
                }
                // end of zipping step

            } catch (IOException e) {
                // io errors caught during writing files
                e.printStackTrace();

                msgEdaButton.setValue("* an IO problem occurred");
                msgEdaButton.setVisible(true);
                dbgLog.warning("exiting edaAction() due to an IO problem ");
                getVDCRequestBean().setSelectedTab("tabEda");

                return "";
            }

            // end of CheckParameters: OK case
        } else {
            // parameters are not complete: show error message;
            msgEdaButton.setValue("* Select at least one option");
            msgEdaButton.setVisible(true);
            dbgLog.warning("exiting edaAction(): selection is incomplete");
            getVDCRequestBean().setSelectedTab("tabEda");

            return "";
        }

    }

    // -----------------------------------------------------------------------
    // AdvStat section
    // -----------------------------------------------------------------------
    // <editor-fold desc="Advanced Statistics">
    // <editor-fold desc="Adv Stat box and panels">

    // ice:selectOneMenu @binding

    private HtmlSelectOneMenu dropDown1 = new com.icesoft.faces.component.ext.HtmlSelectOneMenu();

    public HtmlSelectOneMenu getDropDown1() {
        return dropDown1;
    }

    public void setDropDown1(HtmlSelectOneMenu dropDown1) {
        this.dropDown1 = dropDown1;
    }

    // ice:selectOneMenu @value: options for selectOneMenu
    private List<SelectItem> modelMenuOptions = new ArrayList<SelectItem>();

    public List<SelectItem> getModelMenuOptions() {
        return modelMenuOptions;
    }

    public void setModelMenuOptions(List<SelectItem> modelMenuOptions) {
        this.modelMenuOptions = modelMenuOptions;
    }

    private String currentModelName;

    public String getCurrentModelName() {
        return currentModelName;
    }

    public void setCurrentModelName(String cmn) {
        this.currentModelName = cmn;
    }

    private String modelHelpLinkURL;

    public String getModelHelpLinkURL() {
        return modelHelpLinkURL;
    }

    public void setModelHelpLinkURL(String url) {
        this.modelHelpLinkURL = url;
    }

    /**
     * panelGrid component that contains the model help
     * information box in the advanced statistics pane.
     * The rendered attribute of this component must be state-kept.
     * Initially hidden.
     */
    private HtmlPanelGrid gridPanelModelInfoBox = new com.icesoft.faces.component.ext.HtmlPanelGrid();

    /**
     * Getter for component gridPanelModelInfoBox
     *
     * @return    h:panelGrid of the model help info box
     */
    public HtmlPanelGrid getGridPanelModelInfoBox() {
        return gridPanelModelInfoBox;
    }

    /**
     * Setter for component gridPanelModelInfoBox
     *
     * @param hpg    h:panelGrid of the model help info box
     */
    public void setGridPanelModelInfoBox(HtmlPanelGrid hpg) {
        this.gridPanelModelInfoBox = hpg;
    }

    /**
     * The Boolean object backing the rendered attribute of 
     * gridPanelModelInfoBox (h:panelGrid) component.
     * Exposed to the SubsettingPage.xhtml.
     * Must be state-kept.
     */
    private Boolean gridPanelModelInfoBoxRendered;

    /**
     * Getter for attribute gridPanelModelInfoBoxRendered
     *
     * @return    the rendered attribute of h:panelGrid
     */
    public Boolean getGridPanelModelInfoBoxRendered() {
        return groupPanel8belowRendered;
    }

    /**
     * Setter for attribute gridPanelModelInfoBoxRendered
     *
     * @param rndrd    the rendered attribute of h:panelGrid
     */
    public void setGridPanelModelInfoBoxRendered(Boolean rndrd) {
        gridPanelModelInfoBoxRendered = rndrd;
    }

    private String modelSelectionInstruction = "Choose a Statistical Model";

    // storage for dropdown1 value
    private String advModelDropdownValue = modelSelectionInstruction;

    public String getAdvModelDropdownValue() {
        return advModelDropdownValue;
    }

    public void setAdvModelDropdownValue(String advModelDropdownValue) {
        this.advModelDropdownValue = advModelDropdownValue;

    }

    // dropDown1: @valueChangeListener
    public void dropDown1_processValueChange(ValueChangeEvent vce) {
        dbgLog.fine("\n\n***** dropDown1_processValueChange:start *****");
        String lastModelName = getCurrentModelName();
        dbgLog.fine("stored model name(get)=" + lastModelName);
        dbgLog.fine("stored model name=" + currentModelName);
        FacesContext cntxt = FacesContext.getCurrentInstance();

        // clear message
        resetMsg4MoveVar();
        resetMsgAdvStatButton();

        dbgLog.fine("pass the valueChangeListener dropDown1_processValueChange");
        String newModelName = (String) vce.getNewValue();
        dbgLog.fine("Newly selected model=" + newModelName);
        // IE users may select separator "---"
        if (newModelName.startsWith(modelSelectionInstruction)) {
            if (lastModelName == null) {
                // no model has been chosen but the separator was chosen (1st)
                return;
            } else if (lastModelName.startsWith(modelSelectionInstruction)) {
                // 2nd or later time
                return;
            } else {
                // last option was some meaningful model name
                newModelName = lastModelName;
                dbgLog.fine("revert to the previous choice");
                dbgLog.fine("selected model(---)=" + getCurrentModelName());
                dbgLog.fine("selected model(---)=" + lastModelName);
                setCurrentModelName(lastModelName);
                dropDown1.setValue(lastModelName);
                dbgLog.fine("selected model(---)=" + dropDown1.getValue());
                dbgLog.fine("selected model(---)=" + currentModelName);

                cntxt.getExternalContext().getSessionMap().put("currentModelName", currentModelName);
            }
        } else {
            // model option was chosen
            // this model's name
            // String selectedModelName= (String)dropDown1.getSelected();
            setCurrentModelName((String) dropDown1.getValue());
            dbgLog.fine("selected model=" + getCurrentModelName());
            cntxt.getExternalContext().getSessionMap().put("currentModelName", currentModelName);
        }
        // this model's spec
        AdvancedStatGUIdata.Model selectedModelSpec = getAnalysisApplicationBean().getSpecMap()
                .get(getCurrentModelName());
        dbgLog.fine("model info:\n" + selectedModelSpec);
        // cntxt.getExternalContext().getSessionMap().put("selectedModelSpec",selectedModelSpec);

        // for the first time only
        //if (!groupPanel8below.isRendered()) {
        if (!groupPanel8belowRendered) {
            dbgLog.fine("this is the first time to render the model-option panel");
            // groupPanel8below.setRendered(true);
            groupPanel8belowRendered = Boolean.TRUE;
        } else {
            dbgLog.fine("this is NOT the first time to render the model-option panel");
            if (!newModelName.equals(lastModelName)) {
                dbgLog.fine("A New Model is selected: Clear all variables in the R boxes");
                advStatVarRBox1.clear();
                advStatVarRBox2.clear();
                advStatVarRBox3.clear();
                resetVarSetAdvStat(varCart);
            }

        }
        String modelHelp = selectedModelSpec.getHelplink();
        if (!StringUtils.isEmpty(modelHelp)) {
            setModelHelpLinkURL(modelHelp);
            FacesContext.getCurrentInstance().getExternalContext().getSessionMap().put("modelHelpLinkURL",
                    modelHelp);
            gridPanelModelInfoBox.setRendered(true);
        } else {
            gridPanelModelInfoBox.setRendered(false);
        }
        dbgLog.fine("help Link=" + modelHelp);

        // this model's required variable boxes
        int noRboxes = selectedModelSpec.getNoRboxes();
        dbgLog.fine("model info:RBoxes=" + noRboxes);

        if (noRboxes == 1) {
            // hide 2nd/3rd panels
            groupPanel13.setRendered(false);
            groupPanel14.setRendered(false);

            dbgLog.fine("varBoxR1 label=" + selectedModelSpec.getVarBox().get(0).getLabel());

            // set var box label
            varListbox1Lbl.setValue(selectedModelSpec.getVarBox().get(0).getLabel());

        } else if (noRboxes == 2) {
            // open 2nd panel and hide 3rd one
            groupPanel13.setRendered(true);
            groupPanel14.setRendered(false);

            dbgLog.fine("varBoxR1 label=" + selectedModelSpec.getVarBox().get(0).getLabel());
            dbgLog.fine("varBoxR2 label=" + selectedModelSpec.getVarBox().get(1).getLabel());

            // set var box label
            varListbox1Lbl.setValue(selectedModelSpec.getVarBox().get(0).getLabel());
            varListbox2Lbl.setValue(selectedModelSpec.getVarBox().get(1).getLabel());

        } else if (noRboxes == 3) {
            // open 2nd/3rd panels
            groupPanel13.setRendered(true);
            groupPanel14.setRendered(true);

            dbgLog.fine("varBoxR1 label=" + selectedModelSpec.getVarBox().get(0).getLabel());
            dbgLog.fine("varBoxR2 label=" + selectedModelSpec.getVarBox().get(1).getLabel());
            dbgLog.fine("varBoxR3 label=" + selectedModelSpec.getVarBox().get(2).getLabel());

            // set var box label
            varListbox1Lbl.setValue(selectedModelSpec.getVarBox().get(0).getLabel());
            varListbox2Lbl.setValue(selectedModelSpec.getVarBox().get(1).getLabel());
            varListbox3Lbl.setValue(selectedModelSpec.getVarBox().get(2).getLabel());

        }

        // set up option panels
        if (getCurrentModelName().equals("xtb")) {
            // cross-tabulation (non-zelig)

            chkbxAdvStatOutputOpt.setRendered(false);

            chkbxAdvStatOutputXtbOpt.setRendered(true);

            // Important!
            // the "setValue" call on a "selectMany" checkbox,
            // to specify the boxes checked by default, needs
            // to be made *after* setRendered(true) call has 
            // been made. 
            // This is the reason the default settings were lost 
            // when this page was rewritten in icefaces. 

            chkbxAdvStatOutputXtbOpt.setValue(new String[] { "xtb_Totals", "xtb_Statistics", "xtb_Percentages", });

            analysisOptionPanel.setRendered(false);

        } else {
            // zelig
            if (selectedModelSpec.getMaxSetx() == 0) {
                // hide analysis option panel such as factor models
                setxOptionPanel.setRendered(false);
                analysisOptionPanel.setRendered(false);
            } else {

                chkbxAdvStatOutputOpt.setRendered(true);
                chkbxAdvStatOutputOpt.setValue(new String[] { "Summary", "Plots", "BinOutput" });

                chkbxAdvStatOutputXtbOpt.setRendered(false);

                analysisOptionPanel.setRendered(true);
                // show/hide setx-option panel
                setxOptionPanel.setRendered(true);

            }
        }
        FacesContext.getCurrentInstance().getExternalContext().getSessionMap().put("groupPanel8belowRendered",
                groupPanel8belowRendered);
        dbgLog.fine("groupPanel8belowRendered=" + groupPanel8belowRendered);
        //cntxt.renderResponse();
        dbgLog.fine("***** dropDown1_processValueChange:end *****\n");
    }

    private String dropDown1ClientId;

    public String getDropDown1ClientId() {
        FacesContext cntxt = FacesContext.getCurrentInstance();
        return dropDown1.getClientId(cntxt);
    }

    // panel below the dropDown Menu

    /**
     * The PanelGroup object backing the binding attribute of 
     * panelGroup component that covers the pane below the dropDown 
     * model-selection menu in the advanced statistics pane.
     * The rendered attribute of this component must be state-kept.
     * Initially hidden.
     */
    private HtmlPanelGroup groupPanel8below = new com.icesoft.faces.component.ext.HtmlPanelGroup();

    /**
     * Getter for component groupPanel8below
     *
     * @return    panelGroup of the pane below the model-selection menu
     */
    public HtmlPanelGroup getGroupPanel8below() {
        return groupPanel8below;
    }

    /**
     * Setter for component groupPanel8below
     *
     * @param pg    panelGroup of the pane below the model-selection menu
     */
    public void setGroupPanel8below(HtmlPanelGroup pg) {
        this.groupPanel8below = pg;
    }

    /**
     * The Boolean object backing the rendered attribute of 
     * groupPanel8below (panelGroup) component.
     * Exposed to the SubsettingPage.xhtml.
     * Must be state-kept. 
     * Added after serialization problems of the component-binding
     */
    private Boolean groupPanel8belowRendered;

    /**
     * Getter for attribute groupPanel8belowRendered
     *
     * @return    the rendered attribute of panelGroup
     */
    public Boolean getGroupPanel8belowRendered() {
        return groupPanel8belowRendered;
    }

    /**
     * Setter for attribute groupPanel8belowRendered
     *
     * @param rndrd    the rendered attribute of panelGroup
     */
    public void setGroupPanel8belowRendered(Boolean rndrd) {
        groupPanel8belowRendered = rndrd;
    }

    // ice:outputLabel@binding for variable Left box1
    private HtmlOutputLabel varListbox1Lbl = new com.icesoft.faces.component.ext.HtmlOutputLabel();

    public HtmlOutputLabel getVarListbox1Lbl() {
        return varListbox1Lbl;
    }

    public void setVarListbox1Lbl(HtmlOutputLabel l) {
        this.varListbox1Lbl = l;
    }

    // ice:outputLabel@binding for variable box2
    private HtmlOutputLabel varListbox2Lbl = new com.icesoft.faces.component.ext.HtmlOutputLabel();

    public HtmlOutputLabel getVarListbox2Lbl() {
        return varListbox2Lbl;
    }

    public void setVarListbox2Lbl(HtmlOutputLabel l) {
        this.varListbox2Lbl = l;
    }

    // ice:outputLabel@binding for variable box3
    private HtmlOutputLabel varListbox3Lbl = new com.icesoft.faces.component.ext.HtmlOutputLabel();

    public HtmlOutputLabel getVarListbox3Lbl() {
        return varListbox3Lbl;
    }

    public void setVarListbox3Lbl(HtmlOutputLabel l) {
        this.varListbox3Lbl = l;
    }

    // panel for the 1st var box
    // PanelGroup@binding
    private HtmlPanelGroup groupPanel12 = new com.icesoft.faces.component.ext.HtmlPanelGroup();

    public HtmlPanelGroup getGroupPanel12() {
        return groupPanel12;
    }

    public void setGroupPanel12(HtmlPanelGroup pg) {
        this.groupPanel12 = pg;
    }

    // panel for the 2nd var box
    // PanelGroup@binding
    private HtmlPanelGroup groupPanel13 = new com.icesoft.faces.component.ext.HtmlPanelGroup();

    public HtmlPanelGroup getGroupPanel13() {
        return groupPanel13;
    }

    public void setGroupPanel13(HtmlPanelGroup pg) {
        this.groupPanel13 = pg;
    }

    // plane for the 3rd var box
    // PanelGroup@binding
    private HtmlPanelGroup groupPanel14 = new com.icesoft.faces.component.ext.HtmlPanelGroup();

    public HtmlPanelGroup getGroupPanel14() {
        return groupPanel14;
    }

    public void setGroupPanel14(HtmlPanelGroup pg) {
        this.groupPanel14 = pg;
    }

    // boxL1:listbox@binding
    //private Listbox listboxAdvStat = new Listbox();
    private HtmlSelectManyListbox listboxAdvStat = new com.icesoft.faces.component.ext.HtmlSelectManyListbox();

    public HtmlSelectManyListbox getListboxAdvStat() {
        return listboxAdvStat;
    }

    public void setListboxAdvStat(HtmlSelectManyListbox lstbx) {
        this.listboxAdvStat = lstbx;
    }

    // boxL1: listbox@items (data for the listbox)

    private List<SelectItem> varSetAdvStat = new ArrayList<SelectItem>();

    public List<SelectItem> getVarSetAdvStat() {
        return varSetAdvStat;
    }

    public void setVarSetAdvStat(List<SelectItem> co) {
        this.varSetAdvStat = co;
    }

    // re-populating the list of Options
    public void resetVarSetAdvStat(Map vs) {
        if (!varSetAdvStat.isEmpty()) {
            varSetAdvStat.clear();
        }

        /*
         * dbgLog.fine("resetVarSetAdvStat: current tab
         * id="+tabSet1.getSelected()); if
         * (tabSet1.getSelected().equals("tabRecode")){ dbgLog.fine("current tab
         * is: Recode[no recoded variables added]"); } else{
         * dbgLog.fine("current tab is not Recode [add recoded variables]"); }
         */

        Iterator all = vs.entrySet().iterator();
        while (all.hasNext()) {
            Entry entry = (Entry) all.next();
            varSetAdvStat.add(new SelectItem(entry.getKey().toString(), (String) entry.getValue()));
        }
    }

    // boxL1: listbox@selected : storage object for selected value
    private String[] advStatSelectedVarLBox;

    public String[] getAdvStatSelectedVarLBox() {
        return advStatSelectedVarLBox;
    }

    public void setAdvStatSelectedVarLBox(String[] dol) {
        this.advStatSelectedVarLBox = dol;
    }

    // boxR1: listbox@binding
    // 
    //private Listbox advStatVarListboxR1 = new Listbox();
    private HtmlSelectManyListbox advStatVarListboxR1 = new com.icesoft.faces.component.ext.HtmlSelectManyListbox();

    public HtmlSelectManyListbox getAdvStatVarListboxR1() {
        return advStatVarListboxR1;
    }

    public void setAdvStatVarListboxR1(HtmlSelectManyListbox l1) {
        this.advStatVarListboxR1 = l1;
    }

    // boxR1 : listbox@items [provide data for the listbox]
    // value
    private List<SelectItem> advStatVarRBox1 = new ArrayList<SelectItem>();

    public List<SelectItem> getAdvStatVarRBox1() {
        return advStatVarRBox1;
    }

    public void setAdvStatVarRBox1(List<SelectItem> dol) {
        this.advStatVarRBox1 = dol;
    }

    // boxR1: listbox@selected
    private String[] advStatSelectedVarRBox1;

    public String[] getAdvStatSelectedVarRBox1() {
        return advStatSelectedVarRBox1;
    }

    public void setAdvStatSelectedVarRBox1(String[] dol) {
        this.advStatSelectedVarRBox1 = dol;
    }

    // boxR2: listbox@binding
    // private Listbox advStatVarListboxR2 = new Listbox();
    private HtmlSelectManyListbox advStatVarListboxR2 = new com.icesoft.faces.component.ext.HtmlSelectManyListbox();

    public HtmlSelectManyListbox getAdvStatVarListboxR2() {
        return advStatVarListboxR2;
    }

    public void setAdvStatVarListboxR2(HtmlSelectManyListbox l2) {
        this.advStatVarListboxR2 = l2;
    }

    // boxR2: listbox@items [provide data for the listbox]
    private List<SelectItem> advStatVarRBox2 = new ArrayList<SelectItem>();

    public List<SelectItem> getAdvStatVarRBox2() {
        return advStatVarRBox2;
    }

    public void setAdvStatVarRBox2(List<SelectItem> dol) {
        this.advStatVarRBox2 = dol;
    }

    // boxR2: listbox@selected
    private String[] advStatSelectedVarRBox2;

    public String[] getAdvStatSelectedVarRBox2() {
        return advStatSelectedVarRBox2;
    }

    public void setAdvStatSelectedVarRBox2(String[] dol) {
        this.advStatSelectedVarRBox2 = dol;
    }

    // boxR3: listbox@binding
    //private Listbox advStatVarListboxR3 = new Listbox();
    private HtmlSelectManyListbox advStatVarListboxR3 = new com.icesoft.faces.component.ext.HtmlSelectManyListbox();

    public HtmlSelectManyListbox getAdvStatVarListboxR3() {
        return advStatVarListboxR3;
    }

    public void setAdvStatVarListboxR3(HtmlSelectManyListbox l3) {
        this.advStatVarListboxR3 = l3;
    }

    // boxR3: listbox@items [provide data for the listbox]
    private List<SelectItem> advStatVarRBox3 = new ArrayList<SelectItem>();

    public List<SelectItem> getAdvStatVarRBox3() {
        return advStatVarRBox3;
    }

    public void setAdvStatVarRBox3(List<SelectItem> dol) {
        this.advStatVarRBox3 = dol;
    }

    // boxR3: listbox@selected
    private String[] advStatSelectedVarRBox3;

    public String[] getAdvStatSelectedVarRBox3() {
        return advStatSelectedVarRBox3;
    }

    public void setAdvStatSelectedVarRBox3(String[] dol) {
        this.advStatSelectedVarRBox3 = dol;
    }

    // moveVar1Bttn
    // > button (add)
    // @binding
    private HtmlCommandButton button4 = new com.icesoft.faces.component.ext.HtmlCommandButton();

    public HtmlCommandButton getButton4() {
        return button4;
    }

    public void setButton4(HtmlCommandButton hcb) {
        this.button4 = hcb;
    }

    // < button (remove)
    // @binding
    private HtmlCommandButton button4b = new com.icesoft.faces.component.ext.HtmlCommandButton();

    public HtmlCommandButton getButton4b() {
        return button4b;
    }

    public void setButton4b(HtmlCommandButton hcb) {
        this.button4 = hcb;
    }

    // moveVar2Bttn
    // > button (add)
    // @binding
    private HtmlCommandButton button5 = new com.icesoft.faces.component.ext.HtmlCommandButton();

    public HtmlCommandButton getButton5() {
        return button5;
    }

    public void setButton5(HtmlCommandButton hcb) {
        this.button5 = hcb;
    }

    // < button (remove)
    // @binding
    private HtmlCommandButton button5b = new com.icesoft.faces.component.ext.HtmlCommandButton();

    public HtmlCommandButton getButton5b() {
        return button5b;
    }

    public void setButton5b(HtmlCommandButton hcb) {
        this.button5b = hcb;
    }

    // moveVar3Bttn
    // > button (add)
    // @binding
    private HtmlCommandButton button6 = new com.icesoft.faces.component.ext.HtmlCommandButton();

    public HtmlCommandButton getButton6() {
        return button6;
    }

    public void setButton6(HtmlCommandButton hcb) {
        this.button6 = hcb;
    }

    // < button (remove)
    // @binding
    private HtmlCommandButton button6b = new com.icesoft.faces.component.ext.HtmlCommandButton();

    public HtmlCommandButton getButton6b() {
        return button6b;
    }

    public void setButton6b(HtmlCommandButton hcb) {
        this.button6b = hcb;
    }
    // </editor-fold>
    // <editor-fold desc="Adv Stat  movement">    

    // get variable type (int) from a given row of the dataTable
    public int getVariableType(DataVariable dv) {
        Integer varType;

        if (dv.getVariableFormatType().getName().equals("numeric")) {
            if (dv.getVariableIntervalType().getName().equals("continuous")) {
                varType = Integer.valueOf("2");
            } else {
                varType = Integer.valueOf("1");
            }
        } else {
            varType = Integer.valueOf("0");
        }
        dbgLog.fine("within: getVariableType: varType= " + varType);
        return varType.intValue();
    }

    // character var or not
    public boolean isCharacterVariable(String newVarId) {
        boolean chr = false;
        Pattern p = Pattern.compile("[a-zA-Z_]+");
        int counter = 0;
        // get the recode table by varId
        List<Object> rvtbl = (List<Object>) recodeSchema.get(newVarId);
        for (int i = 0; i < rvtbl.size(); i++) {
            List<Object> rvs = (List<Object>) rvtbl.get(i);
            // check character or not
            String value = (String) rvs.get(1);
            Matcher m = p.matcher(value);
            if (m.find()) {
                counter++;
            }
        }
        if (counter > 0) {
            chr = true;
        }
        return chr;
    }

    /**
     * Returns the number of valid and unique categories (String type) 
     * in a recode table (List) that is stored in recodeSchema (Map) 
     * to check whether this variable is binary, etc.
     * 
     * @param newVarId    the id of a requested variable
     * @return    the number of valid and unique categories
     */
    public int getValidCategories(String newVarId) {
        int noCat = 0;
        // use a Set object to find a unique set of values (String)
        Set<String> newValidValueSet = new HashSet<String>();
        // get the recode table by varId
        List<Object> rvtbl = (List<Object>) recodeSchema.get(newVarId);
        for (int i = 0; i < rvtbl.size(); i++) {
            List<Object> rvs = (List<Object>) rvtbl.get(i);
            if (!((Boolean) rvs.get(0))) {
                // 1st element tells whether this value is to be excuded
                // false means "not to exclude this value"

                // add this value to the set
                newValidValueSet.add((String) rvs.get(1));
                noCat++;
            }
        }
        dbgLog.fine("non-exclude values=" + noCat);
        dbgLog.fine("unique non-exclude values=" + newValidValueSet.size());
        //return noCat;
        return newValidValueSet.size();
    }

    /**
     * Returns the number of summary statistics of the requested variable
     * 
     * @param varId    the id of a requested variable
     * @return    the number of summary statistics (8 for continuous variables
     *            and at least 3 for non-continuous ones)
     */
    public int getSumStatSize(String varId) {
        int sumStatSize = getVariableById(varId).getSummaryStatistics().size();
        dbgLog.fine("sumStat size=" + sumStatSize);
        return sumStatSize;
    }

    /**
     * Returns the number of valid (non-missing-value) values of
     * the requested variable
     * 
     * @param varId    the id of a requested variable
     * @return    the number of valid (non-missing-value) responses
     */
    public int getCatStatSize(String varId) {
        Collection<VariableCategory> catStatSet = getVariableById(varId).getCategories();
        // count non-missing category only
        int catStatSize = 0;
        for (Iterator elc = catStatSet.iterator(); elc.hasNext();) {
            VariableCategory dvcat = (VariableCategory) elc.next();
            if (!dvcat.isMissing()) {
                catStatSize++;
            }
        }
        dbgLog.fine("valid categories=" + catStatSize);

        return catStatSize;
    }

    // check whether the requested move is permissible
    private Boolean checkVarType(String varId, String boxVarType, Boolean strict) {
        dbgLog.fine("variable id=" + varId);
        int varType = 1;
        if (isRecodedVar(varId)) {
            // recoded var case
            if (isCharacterVariable(varId)) {
                // 
                varType = 0;
            }
        } else {
            // existing var case
            // DataVariable dv = getVariableById(varId);
            varType = getVariableType(getVariableById(varId));
        }

        dbgLog.fine("Type of the variable to be moved=" + varType);
        Integer boxType = dataType2Int.get(boxVarType);

        Boolean result = false;
        switch (boxType != null ? boxType : -1) {
        case 5:
            // continuous
            if (strict) {
                // stricter test
                if (varType == 2) {
                    result = true;
                } else {
                    result = false;
                }
            } else {
                if (varType != 0) {
                    result = true;
                } else {
                    result = false;
                }
            }

            break;
        case 4:
            // discrete
            // this categorization is zelig-context
            if (strict) {
                // stricter test
                if ((varType != 0) && (varType != 2)) {
                    result = true;
                } else {
                    result = false;
                }
            } else {
                if (varType != 0) {
                    result = true;
                } else {
                    result = false;
                }
            }

            break;
        case 3:
            // ordinal
            if (strict) {
                // stricter test
                if ((varType != 0) && (varType != 2)) {
                    result = true;
                } else {
                    result = false;
                }
            } else {
                if (varType != 0) {
                    result = true;
                } else {
                    result = false;
                }
            }
            break;

        case 2:
            // nominal
            // no stricter case
            if (varType == 0) {
                result = true;
            } else {
                result = false;
            }
            break;

        case 23:
        case 32:
            // nominal|ordinal
            // no stricter case
            if (varType != 2) {
                result = true;
            } else {
                result = false;
            }
            break;

        case 1:
            // binary
            int sumStatSize = 0;
            int catStatSize = 0;
            if (isRecodedVar(varId)) {
                catStatSize = getValidCategories(varId);
            } else {
                sumStatSize = getSumStatSize(varId);
                catStatSize = getCatStatSize(varId);
            }
            if (varType == 2) {
                // continuous var => not binary
                result = false;
            } else {
                // net test
                if (catStatSize == 2) {
                    result = true;
                } else {
                    result = false;
                }
            }

            break;
        case 0:
            // any
            // do nothing
            result = true;

            break;
        default:
            result = true;
            break;
        }

        if (result) {
            dbgLog.fine("The move passed the test");
        } else {
            dbgLog.fine("The move failed the test");
            dbgLog.fine("expected type=" + boxVarType);
            dbgLog.fine("variable's type=" + vtInt2String.get(Integer.toString(varType)));
        }
        return result;
    }

    // remove the selected SelectItem from a given selectManyListbox
    private SelectItem removeOption(String varId, List<SelectItem> co) {
        SelectItem matchedOptn = null;
        Iterator iter = co.iterator();
        while (iter.hasNext()) {
            SelectItem optn = (SelectItem) iter.next();
            if (varId.equals(optn.getValue())) {
                matchedOptn = optn;
                co.remove(optn);
                break;
            }
        }
        return matchedOptn;
    }

    // reset all error message text-fields related to moveVar buttons
    public void resetMsg4MoveVar() {
        msgMoveVar1Bttn.setRendered(false);
        msgMoveVar1Bttn.setValue(" ");
        msgMoveVar2Bttn.setRendered(false);
        msgMoveVar2Bttn.setValue(" ");
        msgMoveVar3Bttn.setRendered(false);
        msgMoveVar3Bttn.setValue(" ");
    }

    private HtmlOutputText msgMoveVar1Bttn = new com.icesoft.faces.component.ext.HtmlOutputText();

    public HtmlOutputText getMsgMoveVar1Bttn() {
        return msgMoveVar1Bttn;
    }

    public void setMsgMoveVar1Bttn(HtmlOutputText txt) {
        this.msgMoveVar1Bttn = txt;
    }

    // move from L to R1
    public void addVarBoxR1(ActionEvent acev) {
        dbgLog.fine("\n***** within addVarBoxR1(): model name=" + getCurrentModelName() + " *****");

        resetMsg4MoveVar();
        resetMsgAdvStatButton();

        dbgLog.fine("advStatSelectedVarLBox=" + advStatSelectedVarLBox);
        dbgLog.fine("advStatSelectedVar from binding=" + listboxAdvStat.getValue());
        String[] OptnSet = null;
        if (getAdvStatSelectedVarLBox() == null) {
            OptnSet = (String[]) listboxAdvStat.getValue();
        } else {
            OptnSet = getAdvStatSelectedVarLBox();
        }

        dbgLog.fine("OptnSet Length=" + OptnSet.length);
        dbgLog.fine("OptnSet=" + OptnSet);

        int BoxR1max = getAnalysisApplicationBean().getSpecMap().get(getCurrentModelName()).getVarBox().get(0)
                .getMaxvar();

        dbgLog.fine("BoxR1max=" + BoxR1max);

        // dbgLog.fine("BoxR1min="+getAnalysisApplicationBean().getSpecMap().get(getCurrentModelName()).getVarBox().get(0).getMinvar()
        // );

        dbgLog.fine("current listboxR1 size=" + advStatVarRBox1.size());

        String varType = getAnalysisApplicationBean().getSpecMap().get(getCurrentModelName()).getVarBox().get(0)
                .getVarType();

        dbgLog.fine("permissible variable type for advStatVarRBox1=" + varType);

        // for each selected item
        if (advStatVarRBox1.size() < BoxR1max) {
            dbgLog.fine("< BoxR1max case");
            for (int i = 0; i < OptnSet.length; i++) {
                // reset error message field
                resetMsg4MoveVar();
                // type check
                dbgLog.fine("OptnSet[" + i + "]=" + OptnSet[i]);
                if (checkVarType(OptnSet[i], varType, true)) {
                    getAdvStatVarRBox1().add(removeOption(OptnSet[i], getVarSetAdvStat()));

                    dbgLog.fine("current listboxR1 size(within loop)=" + advStatVarRBox1.size());
                    if (advStatVarRBox1.size() == BoxR1max) {
                        return;
                    }
                } else {
                    // show error message
                    msgMoveVar1Bttn.setValue("* Incompatible type:<br />required=" + varType + "<br />found="
                            + vtInt2String.get(Integer.toString(getVariableType(getVariableById(OptnSet[i])))));
                    msgMoveVar1Bttn.setRendered(true);
                }
            }
        } else {
            dbgLog.fine("1st RHS box is already maxed out");
            // show error message;
            msgMoveVar1Bttn.setValue("* The max number of variables<br/>for this box is: " + BoxR1max);
            msgMoveVar1Bttn.setRendered(true);
        }
    }

    private HtmlOutputText msgMoveVar2Bttn = new com.icesoft.faces.component.ext.HtmlOutputText();

    public HtmlOutputText getMsgMoveVar2Bttn() {
        return msgMoveVar2Bttn;
    }

    public void setMsgMoveVar2Bttn(HtmlOutputText txt) {
        this.msgMoveVar2Bttn = txt;
    }

    // move from L to R2
    public void addVarBoxR2(ActionEvent acev) {
        // set left-selected items to a temp list
        //String[] OptnSet = (String[])getAdvStatSelectedVarLBox();

        dbgLog.fine("***** within addVarBoxR2(): model name=" + getCurrentModelName() + " *****");

        resetMsg4MoveVar();
        resetMsgAdvStatButton();

        dbgLog.fine("advStatSelectedVarLBox=" + advStatSelectedVarLBox);
        dbgLog.fine("advStatSelectedVar from binding=" + listboxAdvStat.getValue());
        String[] OptnSet = null;
        if (getAdvStatSelectedVarLBox() == null) {
            OptnSet = (String[]) listboxAdvStat.getValue();
        } else {
            OptnSet = getAdvStatSelectedVarLBox();
        }

        dbgLog.fine("OptnSet Length=" + OptnSet.length);
        dbgLog.fine("OptnSet=" + OptnSet);

        int BoxR2max = getAnalysisApplicationBean().getSpecMap().get(getCurrentModelName()).getVarBox().get(1)
                .getMaxvar();

        dbgLog.fine("BoxR2max=" + BoxR2max);

        // dbgLog.fine("BoxR2min="+getAnalysisApplicationBean().getSpecMap().get(getCurrentModelName()).getVarBox().get(1).getMinvar()
        // );

        dbgLog.fine("current listbox size=" + advStatVarRBox2.size());

        String varType = getAnalysisApplicationBean().getSpecMap().get(getCurrentModelName()).getVarBox().get(1)
                .getVarType();

        dbgLog.fine("permissible variable type for advStatVarRBox2=" + varType);

        // for each selected item
        if (advStatVarRBox2.size() < BoxR2max) {

            for (int i = 0; i < OptnSet.length; i++) {
                // reset error message field
                resetMsg4MoveVar();
                // type check
                dbgLog.fine("OptnSet[" + i + "]=" + OptnSet[i]);
                if (checkVarType(OptnSet[i], varType, true)) {
                    getAdvStatVarRBox2().add(removeOption(OptnSet[i], getVarSetAdvStat()));
                    dbgLog.fine("current listboxR2 size(within loop)=" + advStatVarRBox2.size());
                    if (advStatVarRBox2.size() == BoxR2max) {
                        return;
                    }
                } else {
                    // show error message
                    msgMoveVar2Bttn.setValue("* Incompatible type:<br />required=" + varType + "<br />found="
                            + vtInt2String.get(Integer.toString(getVariableType(getVariableById(OptnSet[i])))));
                    msgMoveVar2Bttn.setRendered(true);
                }
            }
        } else {
            dbgLog.warning("2nd RHS box is already maxed out");
            // show error message;
            msgMoveVar2Bttn.setValue("* The max number of variables<br/>for this box is: " + BoxR2max);
            msgMoveVar2Bttn.setRendered(true);
        }
    }

    private HtmlOutputText msgMoveVar3Bttn = new com.icesoft.faces.component.ext.HtmlOutputText();

    public HtmlOutputText getMsgMoveVar3Bttn() {
        return msgMoveVar3Bttn;
    }

    public void setMsgMoveVar3Bttn(HtmlOutputText txt) {
        this.msgMoveVar3Bttn = txt;
    }

    // move from L to R3
    public void addVarBoxR3(ActionEvent acev) {
        // set left-selected items to a temp list
        //String[] OptnSet = (String[])getAdvStatSelectedVarLBox();

        dbgLog.fine("***** within addVarBoxR3(): model name=" + getCurrentModelName() + " *****");

        resetMsg4MoveVar();
        resetMsgAdvStatButton();

        dbgLog.fine("advStatSelectedVarLBox=" + advStatSelectedVarLBox);
        dbgLog.fine("advStatSelectedVar from binding=" + listboxAdvStat.getValue());
        String[] OptnSet = null;
        if (getAdvStatSelectedVarLBox() == null) {
            OptnSet = (String[]) listboxAdvStat.getValue();
        } else {
            OptnSet = getAdvStatSelectedVarLBox();
        }

        dbgLog.fine("OptnSet Length=" + OptnSet.length);
        dbgLog.fine("OptnSet=" + OptnSet);

        int BoxR3max = getAnalysisApplicationBean().getSpecMap().get(getCurrentModelName()).getVarBox().get(2)
                .getMaxvar();

        dbgLog.fine("BoxR3max=" + BoxR3max);

        // dbgLog.fine("BoxR2min="+getAnalysisApplicationBean().getSpecMap().get(getCurrentModelName()).getVarBox().get(2).getMinvar()
        // );

        dbgLog.fine("current listboxR3 size=" + advStatVarRBox3.size());

        String varType = getAnalysisApplicationBean().getSpecMap().get(getCurrentModelName()).getVarBox().get(2)
                .getVarType();

        dbgLog.fine("permissible variable type for advStatVarRBox3=" + varType);

        // for each selected item
        if (advStatVarRBox3.size() < BoxR3max) {
            for (int i = 0; i < OptnSet.length; i++) {
                // reset error message field
                resetMsg4MoveVar();
                // type check
                dbgLog.fine("OptnSet[" + i + "]=" + OptnSet[i]);
                if (checkVarType(OptnSet[i], varType, true)) {

                    getAdvStatVarRBox3().add(removeOption(OptnSet[i], getVarSetAdvStat()));

                    dbgLog.fine("current listboxR3 size(within loop)=" + advStatVarRBox3.size());
                    if (advStatVarRBox3.size() == BoxR3max) {
                        return;
                    }
                } else {
                    // show error message
                    msgMoveVar3Bttn.setValue("* Incompatible type:<br />required=" + varType + "<br />found="
                            + vtInt2String.get(Integer.toString(getVariableType(getVariableById(OptnSet[i])))));
                    msgMoveVar3Bttn.setRendered(true);
                }
            }
        }
    }

    // move from R1 to L
    public void removeVarBoxR1(ActionEvent acev) {

        dbgLog.fine("************  within removeVarBoxR1() ************");
        // set left-selected items to a temp list
        //String[] OptnSet = getAdvStatSelectedVarRBox1();

        resetMsg4MoveVar();
        resetMsgAdvStatButton();

        dbgLog.fine("advStatSelectedVarRBox1=" + advStatSelectedVarRBox1);
        dbgLog.fine("advStatSelectedVar from binding=" + advStatVarListboxR1.getValue());
        String[] OptnSet = null;
        if (getAdvStatSelectedVarRBox1() == null) {
            OptnSet = (String[]) advStatVarListboxR1.getValue();
        } else {
            OptnSet = getAdvStatSelectedVarRBox1();
        }

        dbgLog.fine("OptnSet Length=" + OptnSet.length);
        dbgLog.fine("OptnSet=" + OptnSet);
        // for each selected item
        for (int i = 0; i < OptnSet.length; i++) {
            getVarSetAdvStat().add(removeOption(OptnSet[i], getAdvStatVarRBox1()));
        }
    }

    // move from R2 to L
    public void removeVarBoxR2(ActionEvent acev) {
        dbgLog.fine("************  within removeVarBoxR2() ************");
        // set left-selected items to a temp array, Option []
        //String[] OptnSet = getAdvStatSelectedVarRBox2();

        resetMsg4MoveVar();
        resetMsgAdvStatButton();

        dbgLog.fine("advStatSelectedVarRBox2=" + advStatSelectedVarRBox2);
        dbgLog.fine("advStatSelectedVar from binding=" + advStatVarListboxR2.getValue());
        String[] OptnSet = null;
        if (getAdvStatSelectedVarRBox2() == null) {
            OptnSet = (String[]) advStatVarListboxR2.getValue();
        } else {
            OptnSet = getAdvStatSelectedVarRBox2();
        }

        dbgLog.fine("OptnSet Length=" + OptnSet.length);
        dbgLog.fine("OptnSet=" + OptnSet);

        // for each selected item
        for (int i = 0; i < OptnSet.length; i++) {
            getVarSetAdvStat().add(removeOption(OptnSet[i], getAdvStatVarRBox2()));
        }
    }

    // move from R3 to L
    public void removeVarBoxR3(ActionEvent acev) {
        dbgLog.fine("************  within removeVarBoxR3() ************");
        // set left-selected items to a temp array, Option []
        //String[] OptnSet = getAdvStatSelectedVarRBox3();

        resetMsg4MoveVar();
        resetMsgAdvStatButton();

        dbgLog.fine("advStatSelectedVarRBox3=" + advStatSelectedVarRBox3);
        dbgLog.fine("advStatSelectedVar from binding=" + advStatVarListboxR3.getValue());
        String[] OptnSet = null;
        if (getAdvStatSelectedVarRBox3() == null) {
            OptnSet = (String[]) advStatVarListboxR3.getValue();
        } else {
            OptnSet = getAdvStatSelectedVarRBox3();
        }

        dbgLog.fine("OptnSet Length=" + OptnSet.length);
        dbgLog.fine("OptnSet=" + OptnSet);

        // for each selected item
        for (int i = 0; i < OptnSet.length; i++) {
            getVarSetAdvStat().add(removeOption(OptnSet[i], getAdvStatVarRBox3()));
        }
    }
    // </editor-fold>
    // ////////////////////
    // Output option
    // ////////////////////
    // <editor-fold desc="Adv Stat Output option">
    // output option panel

    /*
     * private PanelGroup groupPanel25 = new PanelGroup();
     * 
     * public PanelGroup getGroupPanel25() { return groupPanel25; }
     * 
     * public void setGroupPanel25(PanelGroup pg) { this.groupPanel25 = pg; }
     */

    // output option checkbox group: zelig
    //    private CheckboxGroup checkboxGroup2 = new CheckboxGroup();
    //
    //    public CheckboxGroup getCheckboxGroup2() {
    //        return checkboxGroup2;
    //    }
    //
    //    public void setCheckboxGroup2(CheckboxGroup cg) {
    //        this.checkboxGroup2 = cg;
    //    }
    //
    //    private MultipleSelectOptionsList checkboxGroup2DefaultOptions = new MultipleSelectOptionsList();
    //
    //    public MultipleSelectOptionsList getCheckboxGroup2DefaultOptions() {
    //        return checkboxGroup2DefaultOptions;
    //    }
    //
    //    public void setCheckboxGroup2DefaultOptions(MultipleSelectOptionsList msol) {
    //        this.checkboxGroup2DefaultOptions = msol;
    //    }

    private HtmlSelectManyCheckbox chkbxAdvStatOutputOpt = new com.icesoft.faces.component.ext.HtmlSelectManyCheckbox();

    public HtmlSelectManyCheckbox getChkbxAdvStatOutputOpt() {
        return chkbxAdvStatOutputOpt;
    }

    public void setChkbxAdvStatOutputOpt(HtmlSelectManyCheckbox chkbxOut) {
        this.chkbxAdvStatOutputOpt = chkbxOut;
    }

    private Map<String, String> chkbxAdvStatOutputOptMap = new LinkedHashMap<String, String>();

    public Map<String, String> getChkbxAdvStatOutputOptMap() {
        return chkbxAdvStatOutputOptMap;
    }

    public void setChkbxAdvStatOutputOptMap(Map<String, String> chkbxOutMp) {
        this.chkbxAdvStatOutputOptMap = chkbxOutMp;
    }

    private HtmlSelectManyCheckbox chkbxAdvStatOutputXtbOpt = new com.icesoft.faces.component.ext.HtmlSelectManyCheckbox();

    public HtmlSelectManyCheckbox getChkbxAdvStatOutputXtbOpt() {
        return chkbxAdvStatOutputXtbOpt;
    }

    public void setChkbxAdvStatOutputXtbOpt(HtmlSelectManyCheckbox chkbxXtb) {
        this.chkbxAdvStatOutputXtbOpt = chkbxXtb;
    }

    private Map<String, String> chkbxAdvStatOutputXtbOptMap = new LinkedHashMap<String, String>();

    public Map<String, String> getChkbxAdvStatOutputXtbOptMap() {
        return chkbxAdvStatOutputXtbOptMap;
    }

    public void setChkbxAdvStatOutputXtbOptMap(Map<String, String> chkbxAdvStatOutputXtbOptMap) {
        this.chkbxAdvStatOutputXtbOptMap = chkbxAdvStatOutputXtbOptMap;
    }

    // output option checkbox group: xtab
    //    private CheckboxGroup checkboxGroupXtb = new CheckboxGroup();
    //
    //    public CheckboxGroup getCheckboxGroupXtb() {
    //        return checkboxGroupXtb;
    //    }
    //
    //    public void setCheckboxGroupXtb(CheckboxGroup cg) {
    //        this.checkboxGroupXtb = cg;
    //    }
    //
    //    private MultipleSelectOptionsList checkboxGroupXtbOptions = new MultipleSelectOptionsList();
    //
    //    public MultipleSelectOptionsList getCheckboxGroupXtbOptions() {
    //        return checkboxGroupXtbOptions;
    //    }
    //
    //    public void setCheckboxGroupXtbOptions(MultipleSelectOptionsList msol) {
    //        this.checkboxGroupXtbOptions = msol;
    //    }

    //    public void checkboxGroupXtbProcessValueChange(ValueChangeEvent vce) {
    //        dbgLog.fine("checkboxGroupXtbProcessValueChange");
    //        dbgLog.fine("checkbox: new value=" + vce.getNewValue());
    //        Option[] outOption = (Option[]) checkboxGroupXtbOptions.getOptions();
    //        for (int i = 0; i < outOption.length; i++) {
    //            dbgLog.fine("output option[" + i + "]=" + outOption[i].getValue());
    //        }
    //    }
    // </editor-fold>
    // ////////////////////
    // Analysis option
    // ////////////////////
    // <editor-fold desc="Adv Stat Analysis Option">
    // Analysis option block: casing panel

    //    private HtmlPanelGroup analysisOptionPanel = 
    //        new com.icesoft.faces.component.ext.HtmlPanelGroup();
    //
    //    public HtmlPanelGroup getAnalysisOptionPanel() {
    //        return analysisOptionPanel;
    //    }
    //
    //    public void setAnalysisOptionPanel(HtmlPanelGroup pg) {
    //        this.analysisOptionPanel = pg;
    //    }
    private HtmlPanelGrid analysisOptionPanel = new com.icesoft.faces.component.ext.HtmlPanelGrid();

    public HtmlPanelGrid getAnalysisOptionPanel() {
        return analysisOptionPanel;
    }

    public void setAnalysisOptionPanel(HtmlPanelGrid analysisOptionPanel) {
        this.analysisOptionPanel = analysisOptionPanel;
    }

    // setx-option panel
    //    private HtmlPanelGroup setxOptionPanel = 
    //        new com.icesoft.faces.component.ext.HtmlPanelGroup();
    //
    //    public HtmlPanelGroup getSetxOptionPanel() {
    //        return setxOptionPanel;
    //    }
    //
    //    public void setSetxOptionPanel(HtmlPanelGroup pg) {
    //        this.setxOptionPanel = pg;
    //    }
    private HtmlPanelGrid setxOptionPanel = new com.icesoft.faces.component.ext.HtmlPanelGrid();

    public HtmlPanelGrid getSetxOptionPanel() {
        return setxOptionPanel;
    }

    public void setSetxOptionPanel(HtmlPanelGrid setxOptionPanel) {
        this.setxOptionPanel = setxOptionPanel;
    }

    // simulation: casing panel
    //    private PanelGroup groupPanel20 = new PanelGroup();
    //
    //    public PanelGroup getGroupPanel20() {
    //        return groupPanel20;
    //    }
    //
    //    public void setGroupPanel20(PanelGroup pg) {
    //        this.groupPanel20 = pg;
    //    }

    private HtmlPanelGrid groupPanelSimTypeChoice = new com.icesoft.faces.component.ext.HtmlPanelGrid();;

    public HtmlPanelGrid getGroupPanelSimTypeChoice() {
        return groupPanelSimTypeChoice;
    }

    public void setGroupPanelSimTypeChoice(HtmlPanelGrid gpstc) {
        this.groupPanelSimTypeChoice = gpstc;
    }

    // simulation option: checkbox

    private HtmlSelectBooleanCheckbox simulationPanel = new com.icesoft.faces.component.ext.HtmlSelectBooleanCheckbox();

    public HtmlSelectBooleanCheckbox getSimulationPanel() {
        return simulationPanel;
    }

    public void setSimulationPanel(HtmlSelectBooleanCheckbox c) {
        this.simulationPanel = c;
    }

    public void showHideSimulationsOptPanel(ValueChangeEvent vce) {
        dbgLog.fine("***** showHideSimulationsOptPanel: starts here *****");
        Boolean currentState = (Boolean) vce.getNewValue();
        dbgLog.fine("currentState=" + currentState);
        if ((currentState.toString()).equals("true")) {
            //groupPanel20.setRendered(true);
            groupPanelSimTypeChoice.setRendered(true);
            dbgLog.fine("groupPanelSimTypeChoice(rendered?)=" + groupPanelSimTypeChoice.isRendered());
        } else if ((currentState.toString()).equals("false")) {
            //groupPanel20.setRendered(false);
            groupPanelSimTypeChoice.setRendered(false);
            dbgLog.fine("groupPanelSimTypeChoice(rendered?)=" + groupPanelSimTypeChoice.isRendered());
        }

        //FacesContext.getCurrentInstance().renderResponse();
        dbgLog.fine("***** showHideSimulationsOptPanel: ends here *****");
    }

    // simulation option: radio button
    // @selected
    //    private String lastSimCndtnSelected;
    //
    //    public String getLastSimCndtnSelected() {
    //        return lastSimCndtnSelected;
    //    }
    //
    //    public void setLastSimCndtnSelected(String lastSimCndtnSelected) {
    //        this.lastSimCndtnSelected = lastSimCndtnSelected;
    //    }

    private HtmlSelectOneRadio radioSimTypeChoice = new com.icesoft.faces.component.ext.HtmlSelectOneRadio();

    public HtmlSelectOneRadio getRadioSimTypeChoice() {
        return radioSimTypeChoice;
    }

    public void setRadioSimTypeChoice(HtmlSelectOneRadio radioSimTypeChoice) {
        this.radioSimTypeChoice = radioSimTypeChoice;
    }

    private Map<String, String> simOptionMap = new LinkedHashMap<String, String>();

    public Map<String, String> getSimOptionMap() {
        return simOptionMap;
    }

    public void setSimOptionMap(Map<String, String> simOptionMap) {
        this.simOptionMap = simOptionMap;
    }

    private String radioSimTypeChoiceSelected;

    public String getRadioSimTypeChoiceSelected() {
        return radioSimTypeChoiceSelected;
    }

    public void setRadioSimTypeChoiceSelected(String s) {
        this.radioSimTypeChoiceSelected = s;
    }

    // @valueChangeListener
    public void showHideSimCndtnOptPanel(ValueChangeEvent vce) {
        FacesContext cntxt = FacesContext.getCurrentInstance();
        dbgLog.fine("***** within showHideSimCndtnOptPanel(): starts here *****");
        String currentState = (String) vce.getNewValue();
        dbgLog.fine("currentState=" + currentState);
        dbgLog.fine("current model name in setx=" + getCurrentModelName());

        dbgLog.fine("radioSimTypeChoice(value)=" + radioSimTypeChoice.getValue());
        dbgLog.fine("radioSimTypeChoiceSelected=" + radioSimTypeChoiceSelected);
        if (getCurrentModelName() != null) {

            AdvancedStatGUIdata.Model selectedModelSpec = getAnalysisApplicationBean().getSpecMap()
                    .get(getCurrentModelName());
            dbgLog.finer("spec within setx:\n" + selectedModelSpec);
            if ((currentState.toString()).equals("1")) {
                //groupPanel22.setRendered(true);
                groupPanelSimNonDefault.setRendered(true);
                gridPanel11.setRendered(true);

                dbgLog.fine("groupPanelSimNonDefault: rendered=" + groupPanelSimNonDefault.isRendered());
                // set up the @items for dropDown2/dropDown3

                if (selectedModelSpec.getNoRboxes() == 2) {
                    setSetxDiffVarBox1(getAdvStatVarRBox2());
                    setSetxDiffVarBox2(getAdvStatVarRBox2());

                } else if (selectedModelSpec.getNoRboxes() == 3) {
                    setSetxDiffVarBox1(getAdvStatVarRBox3());
                    setSetxDiffVarBox2(getAdvStatVarRBox3());

                }

                cntxt.getExternalContext().getSessionMap().put("setxDiffVarBox1", setxDiffVarBox1);
                cntxt.getExternalContext().getSessionMap().put("setxDiffVarBox2", setxDiffVarBox2);
                //                cntxt.getExternalContext().getSessionMap().put(
                //                "lastSimCndtnSelected", currentState.toString());
            } else if ((currentState.toString()).equals("0")) {
                //groupPanel22.setRendered(false);
                groupPanelSimNonDefault.setRendered(false);
                //                cntxt.getExternalContext().getSessionMap().put(
                //                "lastSimCndtnSelected", currentState.toString());
            }
        } else {
            //groupPanel22.setRendered(false);
            groupPanelSimNonDefault.setRendered(false);
        }

        //cntxt.renderResponse();
        dbgLog.fine("***** within showHideSimCndtnOptPanel(): ends here *****");
    }

    // simulation: option panel for the radio-button-option of select values
    // @binding
    //    private PanelGroup groupPanel22 = new PanelGroup();
    //
    //    public PanelGroup getGroupPanel22() {
    //        return groupPanel22;
    //    }
    //
    //    public void setGroupPanel22(PanelGroup pg) {
    //        this.groupPanel22 = pg;
    //    }

    //    private HtmlPanelGroup groupPanelSimNonDefault = 
    //        new com.icesoft.faces.component.ext.HtmlPanelGroup(); //new javax.faces.component.html.HtmlPanelGroup();
    //
    //    public HtmlPanelGroup getGroupPanelSimNonDefault() {
    //        return groupPanelSimNonDefault;
    //    }
    //
    //    public void setGroupPanelSimNonDefault(HtmlPanelGroup groupPanelSimNonDefault) {
    //        this.groupPanelSimNonDefault = groupPanelSimNonDefault;
    //    }
    private HtmlPanelGrid groupPanelSimNonDefault = new com.icesoft.faces.component.ext.HtmlPanelGrid();

    public HtmlPanelGrid getGroupPanelSimNonDefault() {
        return groupPanelSimNonDefault;
    }

    public void setGroupPanelSimNonDefault(HtmlPanelGrid groupPanelSimNonDefault) {
        this.groupPanelSimNonDefault = groupPanelSimNonDefault;
    }

    // simulation : value for 1st diff: casing pane

    private HtmlPanelGrid gridPanel10 = new com.icesoft.faces.component.ext.HtmlPanelGrid();

    public HtmlPanelGrid getGridPanel10() {
        return gridPanel10;
    }

    public void setGridPanel10(HtmlPanelGrid hpg) {
        this.gridPanel10 = hpg;
    }

    // simulation : value for 1st diff: label for the casing panel
    //
    //    private Label label2 = new Label();
    //
    //    public Label getLabel2() {
    //        return label2;
    //    }
    //
    //    public void setLabel2(Label l) {
    //        this.label2 = l;
    //    }

    // simulation : value for 1st diff: pull-down var selection
    // dropdown2: ice:selectOneMenu@binding
    // private DropDown dropDown2 = new DropDown();
    private HtmlSelectOneMenu dropDown2 = new com.icesoft.faces.component.ext.HtmlSelectOneMenu();

    public HtmlSelectOneMenu getDropDown2() {
        return dropDown2;
    }

    public void setDropDown2(HtmlSelectOneMenu dd) {
        this.dropDown2 = dd;
    }

    // dropdown2: ice:selectOneMenu@value
    private List<SelectItem> setxDiffVarBox1 = new ArrayList<SelectItem>();

    public List<SelectItem> getSetxDiffVarBox1() {
        return setxDiffVarBox1;
    }

    public void setSetxDiffVarBox1(List<SelectItem> dol) {
        this.setxDiffVarBox1 = dol;
    }

    // simulation : value for 1st diff: text box
    private HtmlInputText textField8 = new com.icesoft.faces.component.ext.HtmlInputText();

    public HtmlInputText getTextField8() {
        return textField8;
    }

    public void setTextField8(HtmlInputText tf) {
        this.textField8 = tf;
    }

    // simulation : explanatory variable value: casing panel

    private HtmlPanelGrid gridPanel11 = new com.icesoft.faces.component.ext.HtmlPanelGrid();

    public HtmlPanelGrid getGridPanel11() {
        return gridPanel11;
    }

    public void setGridPanel11(HtmlPanelGrid hpg) {
        this.gridPanel11 = hpg;
    }

    // simulation : explanatory variable value: label for casing panel
    //    private Label label1 = new Label();
    //
    //    public Label getLabel1() {
    //        return label1;
    //    }
    //
    //    public void setLabel1(Label l) {
    //        this.label1 = l;
    //    }

    // simulation : explanatory variable value: pull-down var selection
    // dropdown3: ice:selectOneMenu@binding
    //private DropDown dropDown3 = new DropDown();
    private HtmlSelectOneMenu dropDown3 = new com.icesoft.faces.component.ext.HtmlSelectOneMenu();

    public HtmlSelectOneMenu getDropDown3() {
        return dropDown3;
    }

    public void setDropDown3(HtmlSelectOneMenu dd) {
        this.dropDown3 = dd;
    }

    // dropdown3: ice:selectOneMenu@value
    private List<SelectItem> setxDiffVarBox2 = new ArrayList<SelectItem>();

    public List<SelectItem> getSetxDiffVarBox2() {
        return setxDiffVarBox2;
    }

    public void setSetxDiffVarBox2(List<SelectItem> dol) {
        this.setxDiffVarBox2 = dol;
    }

    // simulation : explanatory variable value: text box
    private HtmlInputText textField10 = new com.icesoft.faces.component.ext.HtmlInputText();

    public HtmlInputText getTextField10() {
        return textField10;
    }

    public void setTextField10(HtmlInputText tf) {
        this.textField10 = tf;
    }

    // submit button (modeling request)
    // advStatBttn: commandButton@binding
    private HtmlCommandButton advStatButton = new com.icesoft.faces.component.ext.HtmlCommandButton();

    public HtmlCommandButton getAdvStatButton() {
        return advStatButton;
    }

    public void setAdvStatButton(HtmlCommandButton hcb) {
        this.advStatButton = hcb;
    }

    private List<Integer> getCurrentVarBoxSize(String mdlName) {
        List<Integer> bs = new ArrayList();
        int noBoxR = getAnalysisApplicationBean().getSpecMap().get(mdlName).getNoRboxes();
        if (noBoxR == 1) {
            bs.add(advStatVarRBox1.size());
        } else if (noBoxR == 2) {
            bs.add(advStatVarRBox1.size());
            bs.add(advStatVarRBox2.size());
        } else if (noBoxR == 3) {
            bs.add(advStatVarRBox1.size());
            bs.add(advStatVarRBox2.size());
            bs.add(advStatVarRBox3.size());
        }
        return bs;
    }

    // checking advStat-related parameters before submission
    public boolean checkAdvStatParameters(String mdlName) {
        // boolean result=false;

        Integer noBoxR = getAnalysisApplicationBean().getSpecMap().get(mdlName).getNoRboxes();
        List<Integer> RBoxSizes = getCurrentVarBoxSize(mdlName);
        dbgLog.fine("RBoxSizes=" + RBoxSizes);
        int noe = 0;
        resetMsg4MoveVar();
        for (int i = 0; i < noBoxR; i++) {

            Integer ithBoxMin = getAnalysisApplicationBean().getSpecMap().get(mdlName).getVarBox().get(i)
                    .getMinvar();

            dbgLog.fine("i-th BoxMin(" + i + ")=" + ithBoxMin);

            if (RBoxSizes.get(i) < ithBoxMin) {
                String ermsg = "No of Vars in Box" + i + " (" + RBoxSizes.get(i) + ") is less than the minimum("
                        + ithBoxMin + ")";

                dbgLog.fine("* " + ermsg);

                noe++;
                if (i == 0) {
                    msgMoveVar1Bttn.setValue("*" + ermsg);
                    msgMoveVar1Bttn.setRendered(true);
                } else if (i == 1) {
                    msgMoveVar2Bttn.setValue("*" + ermsg);
                    msgMoveVar2Bttn.setRendered(true);
                } else if (i == 2) {
                    msgMoveVar3Bttn.setValue("*" + ermsg);
                    msgMoveVar3Bttn.setRendered(true);
                }
            }

        }
        dbgLog.fine("noe=" + noe);
        return (noe == 0 ? true : false);
    }

    // msgAdvStatButton:ice:outputText@binding
    private com.icesoft.faces.component.ext.HtmlOutputText msgAdvStatButton = new com.icesoft.faces.component.ext.HtmlOutputText();

    public com.icesoft.faces.component.ext.HtmlOutputText getMsgAdvStatButton() {
        return msgAdvStatButton;
    }

    public void setMsgAdvStatButton(com.icesoft.faces.component.ext.HtmlOutputText txt) {
        this.msgAdvStatButton = txt;
    }

    private String msgAdvStatButtonTxt;

    public String getMsgAdvStatButtonTxt() {
        return msgAdvStatButtonTxt;
    }

    public void setMsgAdvStatButtonTxt(String txt) {
        this.msgAdvStatButtonTxt = txt;
    }

    public void resetMsgAdvStatButton() {
        dbgLog.fine("***** within resetMsgAdvStatButton *****");
        msgAdvStatButton.setValue(" ");
        FacesContext.getCurrentInstance().getExternalContext().getSessionMap().put("msgAdvStatButtonTxt",
                msgAdvStatButtonTxt);
        msgAdvStatButton.setVisible(false);

        dbgLog.fine("***** resetMsgAdvStatButton: end  *****");
    }

    public List<String> getDataVariableForRBox1() {
        List<String> dvs = new ArrayList<String>();
        for (Iterator el = advStatVarRBox1.iterator(); el.hasNext();) {
            SelectItem dv = (SelectItem) el.next();
            String id = (String) dv.getValue();
            dvs.add("v" + id);
        }
        return dvs;
    }

    public List<String> getDataVariableForRBox2() {
        List<String> dvs = new ArrayList<String>();
        for (Iterator el = advStatVarRBox2.iterator(); el.hasNext();) {
            SelectItem dv = (SelectItem) el.next();
            String id = (String) dv.getValue();
            dvs.add("v" + id);
        }
        return dvs;
    }

    public List<String> getDataVariableForRBox3() {
        List<String> dvs = new ArrayList<String>();
        for (Iterator el = advStatVarRBox3.iterator(); el.hasNext();) {
            SelectItem dv = (SelectItem) el.next();
            String id = (String) dv.getValue();
            dvs.add("v" + id);
        }
        return dvs;
    }

    public List<String> getZlg(String mdlId, String mdlName) {
        List<String> ls = new ArrayList<String>();
        ls.add(mdlId + "-" + mdlName);
        return ls;
    }

    public List<String> getMdlType(String mdlName, String sf) {
        List<String> ls = new ArrayList<String>();
        dbgLog.fine("model name=" + mdlName + "  special function=" + sf);
        int typeValue = 0;

        if (mdlName.equals("blogit") || mdlName.equals("bprobit")) {
            typeValue = 1;
        } else {
            if (sf != null) {
                if (sf.equals("Surv")) {
                    typeValue = 2;
                } else {
                    String[] tmp = null;
                    tmp = mdlName.split("\\.");
                    dbgLog.fine("tmp[0]=" + tmp[0]);
                    if (tmp[0].equals("factor")) {
                        typeValue = 3;
                    }
                }

            }
        }

        dbgLog.fine("model type=" + typeValue);
        ls.add(Integer.toString(typeValue));
        return ls;
    }
    // </editor-fold>
    // end of advStat
    // <----------------------------------------------------------------------
    // </editor-fold>

    // advStatBttn:h:commandButton@action
    public String advStatAction() {
        //        dbgLog.fine("selected tab(advStat)="+getTabSet1().getSelected());
        // check the current model

        String mdlName = (String) dropDown1.getValue();
        dbgLog.fine("model name=" + mdlName);

        AdvancedStatGUIdata.Model modelSpec = getAnalysisApplicationBean().getSpecMap().get(mdlName);

        if (checkAdvStatParameters(mdlName)) {

            FacesContext cntxt = FacesContext.getCurrentInstance();

            HttpServletResponse res = (HttpServletResponse) cntxt.getExternalContext().getResponse();
            HttpServletRequest req = (HttpServletRequest) cntxt.getExternalContext().getRequest();

            dbgLog.fine("***** within advStatAction() *****");
            // common parts
            // data file
            StudyFile sf = dataTable.getStudyFile();
            Long noRecords = dataTable.getRecordsPerCase();

            String dsbUrl = getDsbUrl();
            dbgLog.fine("dsbUrl=" + dsbUrl);

            String serverPrefix = req.getScheme() + "://" + req.getServerName() + ":" + req.getServerPort()
                    + req.getContextPath();

            dbgLog.fine("serverPrefix=" + serverPrefix);
            //                /
            //                  "optnlst_a" => "A01|A02|A03", "analysis" => "A01 A02",
            //                  "varbl" => "v1.3 v1.10 v1.13 v1.22 v1.40", "charVarNoSet" =>
            //                  "v1.10|v1.719",
            //                 /

            // common parameters
            Map<String, List<String>> mpl = new HashMap<String, List<String>>();

            List<String> alst = new ArrayList<String>();
            List<String> aoplst = new ArrayList<String>();

            aoplst.add("A01|A02|A03");
            mpl.put("optnlst_a", aoplst);

            Map<String, List<String>> xtbro = new HashMap<String, List<String>>();

            // xtbro: modelName
            xtbro.put("modelName", Arrays.asList(mdlName));

            // outoput options

            List<String> outOptionList = new ArrayList<String>();

            mpl.put("modelName", Arrays.asList(mdlName));
            if (mdlName.equals("xtb")) {
                mpl.put("requestType", Arrays.asList("Xtab"));
            } else {
                mpl.put("requestType", Arrays.asList("Zelig"));
            }

            if (mdlName.equals("xtb")) {
                alst.add("A03");

                // output options
                // Object[] outOptn = (Object[]) checkboxGroupXtbOptions.getSelectedValue();
                Object[] outOptn = chkbxAdvStatOutputXtbOpt.getSelectedValues();
                List<String> tv = new ArrayList<String>();
                //tv.add("T");

                for (int j = 0; j < outOptn.length; j++) {
                    dbgLog.fine("output option[" + j + "]=" + outOptn[j]);
                    mpl.put((String) outOptn[j], Arrays.asList("T"));
                    tv.add((String) outOptn[j]);
                }
                mpl.put("xtb_outputOptions", tv);

                // variables: 1st RBox
                if (advStatVarRBox1.size() >= 1) {
                    dbgLog.fine("RB1:" + getDataVariableForRBox1());
                    mpl.put("xtb_nmBxR1", getDataVariableForRBox1());
                }

                // variables: 2nd RBox
                if (advStatVarRBox2.size() >= 1) {
                    dbgLog.fine("RB2:" + getDataVariableForRBox2());
                    mpl.put("xtb_nmBxR2", getDataVariableForRBox2());
                }

                mpl.put("analysis", alst);

            } else {
                // Zelig cases

                dbgLog.fine("***** zelig param block *****");
                // non-xtb, i.e., zelig cases
                // check zlg value

                dbgLog.fine("model spec dump=" + modelSpec);
                dbgLog.fine("model spec mdlId=" + modelSpec.getMdlId());

                String zligPrefix = modelSpec.getMdlId();
                dbgLog.fine("model no=" + zligPrefix);

                // get the varId-list of each box
                // 1-RBox case
                if (advStatVarRBox1.size() >= 1) {
                    dbgLog.fine("RB1:" + getDataVariableForRBox1());
                    //mpl.put(zligPrefix + "_nmBxR1", getDataVariableForRBox1());
                    mpl.put("nmBxR1", getDataVariableForRBox1());
                }

                // 2-RBox case
                if (advStatVarRBox2.size() >= 1) {
                    dbgLog.fine("RB2:" + getDataVariableForRBox2());
                    //mpl.put(zligPrefix + "_nmBxR2", getDataVariableForRBox2());
                    mpl.put("nmBxR2", getDataVariableForRBox2());
                }

                // 3-RBox case
                if (advStatVarRBox3.size() >= 1) {
                    dbgLog.fine("RB3:" + getDataVariableForRBox3());
                    //mpl.put(zligPrefix + "_nmBxR3", getDataVariableForRBox3());
                    mpl.put("nmBxR3", getDataVariableForRBox3());
                }

                // model name
                //mpl.put("zlg", getZlg(zligPrefix, mdlName));

                // model type
                //String sfn = modelSpec.getSpecialFn();
                //mpl.put("mdlType_" + mdlName, getMdlType(mdlName, sfn));

                // model title
                //String ttl = modelSpec.getTitle();
                //dbgLog.fine("model title=" + ttl);
                //mpl.put("mdlTitle_" + mdlName, Arrays.asList(ttl));
                //mpl.put("mdlTitle", Arrays.asList(ttl));

                // nrBoxes
                int noRboxes = modelSpec.getNoRboxes();
                dbgLog.fine("noRboxes=" + noRboxes);

                //mpl.put("noBoxes_" + mdlName, Arrays.asList(Integer.toString(noRboxes)));
                mpl.put("noBoxes", Arrays.asList(Integer.toString(noRboxes)));

                // binary
                String mdlCategory = modelSpec.getCategory();
                String outcomeType = modelSpec.getVarBox().get(0).getVarType();

                dbgLog.fine("model category=" + mdlCategory);

                if (mdlCategory.equals("Models for Dichotomous Dependent Variables")) {
                    mpl.put("mdlDepVarType", Arrays.asList("binary"));
                }
                if (outcomeType.equals("binary")) {
                    mpl.put("isOutcomeBinary", Arrays.asList("T"));
                } else {
                    mpl.put("isOutcomeBinary", Arrays.asList("F"));
                }
                // output options
                //                    //
                //                     // zlg_017_Summary zlg_017_Plots zlg_017_BinOutput
                //                     //
                //Object[] outOptn = (Object[]) checkboxGroup2DefaultOptions.getSelectedValue();
                Object[] outOptn = chkbxAdvStatOutputOpt.getSelectedValues();
                List<String> tv = new ArrayList<String>();

                for (int j = 0; j < outOptn.length; j++) {
                    //String outputOptnkey = zligPrefix + "_"+ (String) outOptn[j];
                    String outputOptnkey = (String) outOptn[j];
                    dbgLog.fine("zelig: output option[" + j + "]=" + outputOptnkey);
                    mpl.put(outputOptnkey, Arrays.asList("T"));
                    tv.add((String) outOptn[j]);
                }
                mpl.put("zelig_outputOptions", tv);

                // analysis options
                //                    
                //                      zlg_017_Sim zlg_017_setx zlg_017_setx_var
                //                      zlg_017_setx_val_1 zlg_017_setx_val_2
                //                      
                //                      zlg_017_naMethod
                //                     
                //
                dbgLog.fine("simulationPanel is selected=" + simulationPanel.isSelected());
                if (simulationPanel.isSelected()) {
                    dbgLog.fine("radioSimTypeChoiceSelected=" + radioSimTypeChoiceSelected);
                    //mpl.put(zligPrefix + "_Sim", Arrays.asList("T"));
                    mpl.put("Sim", Arrays.asList("T"));

                    //Object simOptn = radioButtonGroup1DefaultOptions.getSelectedValue();
                    dbgLog.fine("radioSimTypeChoice(value)=" + radioSimTypeChoice.getValue());
                    dbgLog.fine("radioSimTypeChoiceSelected=" + radioSimTypeChoiceSelected);
                    // simOptn = 0 or 1
                    //mpl.put(zligPrefix + "_setx", Arrays.asList((String) simOptn));
                    //                        mpl.put("setx", Arrays.asList((String) simOptn));
                    //                        mpl.put("setxType", Arrays.asList((String) simOptn));
                    mpl.put("setx", Arrays.asList(radioSimTypeChoiceSelected));
                    mpl.put("setxType", Arrays.asList(radioSimTypeChoiceSelected));
                    if (radioSimTypeChoiceSelected.equals("1")) {
                        Object v1 = dropDown2.getValue();
                        Object v2 = dropDown3.getValue();
                        Object vl1 = textField10.getValue();
                        Object vl2 = textField8.getValue();
                        dbgLog.fine("v1=" + v1);
                        dbgLog.fine("v2=" + v2);
                        dbgLog.fine("vl1=" + vl1);
                        dbgLog.fine("vl2=" + vl2);

                        List<String> setxVars = new ArrayList<String>();

                        if (v1 != null) {
                            setxVars.add((String) v1);

                        }
                        if (v2 != null) {
                            setxVars.add((String) v2);
                        }
                        //mpl.put(zligPrefix + "_setx_var", setxVars);
                        mpl.put("setx_var", setxVars);

                        if (vl1 != null) {
                            //mpl.put(zligPrefix + "_setx_val_1", Arrays.asList((String) vl1));
                            mpl.put("setx_val_1", Arrays.asList((String) vl1));
                        }
                        if (vl2 != null) {
                            //mpl.put(zligPrefix + "_setx_val_2", Arrays.asList((String) vl2));
                            mpl.put("setx_val_2", Arrays.asList((String) vl2));
                        }

                        List<String> setxVar1 = new ArrayList<String>();

                        if (v1 != null) {
                            setxVar1.add("v" + v1);
                            if (vl1 != null) {
                                setxVar1.add((String) vl1);
                            } else {
                                setxVar1.add("");
                            }
                            mpl.put("setx_var1", setxVar1);
                        }

                        if (v2 != null) {
                            List<String> setxVar2 = new ArrayList<String>();

                            setxVar2.add("v" + v2);
                            if (vl2 != null) {
                                setxVar2.add((String) vl2);
                            } else {
                                setxVar2.add("");
                            }
                            mpl.put("setx_var2", setxVar2);
                        }

                    }
                } else {
                    mpl.put("Sim", Arrays.asList("F"));
                }

            }

            dbgLog.fine("contents(mpl so far):" + mpl);

            // if there is a user-defined (recoded) variables
            /*
            if (recodedVarSet.size() > 0) {
                mpl.putAll(getRecodedVarParameters());
            }
            */
            //                dbgLog.fine("citation info to be sent:\n" + citation);
            //                mpl.put("OfflineCitation", Arrays.asList(citation));
            //                mpl.put("appSERVER", Arrays.asList(req.getServerName() +
            //                    ":"+ req.getServerPort() + req.getContextPath()));

            mpl.put("studytitle", Arrays.asList(getStudyTitle()));
            dbgLog.fine("alt studyId=" + getStudyId().toString());
            mpl.put("studyno", Arrays.asList(getStudyId().toString()));
            mpl.put("studyURL", Arrays.asList(studyURL));
            mpl.put("browserType", Arrays.asList(browserType));

            mpl.put("recodedVarIdSet", getRecodedVarIdSet());
            mpl.put("recodedVarNameSet", getRecodedVarNameSet());
            mpl.put("recodedVarLabelSet", getRecodedVarLabelSet());
            mpl.put("recodedVarTypeSet", getRecodedVariableType());
            mpl.put("recodedVarBaseTypeSet", getBaseVariableTypeForRecodedVariable());

            mpl.put("baseVarIdSet", getBaseVarIdSetFromRecodedVarIdSet());
            mpl.put("baseVarNameSet", getBaseVarNameSetFromRecodedVarIdSet());

            // -----------------------------------------------------
            // New processing route
            // 
            // Step 0. Locate the data file and its attributes

            String fileId = sf.getId().toString();
            //VDC vdc = vdcService.getVDCFromRequest(req);

            String fileloc = sf.getFileSystemLocation();
            String tabflnm = sf.getFileName();
            boolean sbstOK = sf.isSubsettable();
            String flct = sf.getFileType();

            dbgLog.fine("location=" + fileloc);
            dbgLog.fine("filename=" + tabflnm);
            dbgLog.fine("subsettable=" + sbstOK);
            dbgLog.fine("filetype=" + flct);

            DvnRJobRequest sro = null;

            List<File> zipFileList = new ArrayList();

            // the data file for downloading/statistical analyses must be subset-ready
            // local (relative to the application) file case 
            // note: a typical remote case is: US Census Bureau
            File tmpsbfl = null;
            if (sbstOK) {

                try {
                    // this temp file will store the requested columns:
                    tmpsbfl = File.createTempFile("tempsubsetfile.", ".tab");
                    deleteTempFileList.add(tmpsbfl);

                    // to produce this file, we'll either open the stream
                    // and run our local subsetting code on it, or request
                    // the subsetting to be performed natively by the access
                    // driver, if it supports the functionality:

                    // check whether a source file is tab-delimited or not

                    boolean fieldcut = true;
                    if ((noRecords != null) && (noRecords >= 1)) {
                        fieldcut = false;
                    }

                    DataAccessRequest daReq = new DataAccessRequest();
                    daReq.setParameter("noVarHeader", "1");

                    DataAccessObject accessObject = DataAccess.createDataAccessObject(sf, daReq);

                    if (accessObject.isSubsetSupported()) {
                        dbgLog.fine("Using NATIVE subset functionality of the repository.");
                        daReq.setParameter("vars", getVariableNamesForSubset());

                        accessObject.open();

                        InputStream inSubset = accessObject.getInputStream();
                        OutputStream outSubset = new BufferedOutputStream(
                                new FileOutputStream(tmpsbfl.getAbsolutePath()));

                        int bufsize = 8192;
                        byte[] subsetDataBuffer = new byte[bufsize];
                        while ((bufsize = inSubset.read(subsetDataBuffer)) != -1) {
                            outSubset.write(subsetDataBuffer, 0, bufsize);
                        }

                        inSubset.close();
                        outSubset.close();

                        // TODO: catch exceptions; reset the state of the page
                        // if anything went wrong. See the fixed-field section
                        // below for an example.

                    } else {
                        accessObject.open();

                        if (fieldcut) {
                            // Cutting requested fields of data from a TAB-delimited stream:

                            Set<Integer> fields = getFieldNumbersForSubsetting();
                            dbgLog.fine("subsetting fields=" + fields);

                            // Create an instance of DvnJavaFieldCutter
                            FieldCutter fc = new DvnJavaFieldCutter();

                            // Executes the subsetting request
                            fc.subsetFile(accessObject.getInputStream(), tmpsbfl.getAbsolutePath(), fields,
                                    dataTable.getCaseQuantity(), "\t");

                            // TODO: catch exceptions; reset the state of the page
                            // if anything went wrong. See the fixed-field section
                            // below for an example.

                        } else {
                            // Cutting requested columns of data from a fixed-field stream:

                            Map<Long, List<List<Integer>>> varMetaSet = getSubsettingMetaData(noRecords);
                            DvnNewJavaFieldCutter fc = new DvnNewJavaFieldCutter(varMetaSet);

                            try {
                                //fc.cutColumns(new File(cutOp1), noRecords.intValue(), 0, "\t", tmpsbfl.getAbsolutePath());
                                fc.cutColumns(accessObject.getInputStream(), noRecords.intValue(), 0, "\t",
                                        tmpsbfl.getAbsolutePath());
                            } catch (FileNotFoundException e) {
                                e.printStackTrace();

                                msgDwnldButton.setValue("* could not generate subset due to an IO problem");
                                msgDwnldButton.setVisible(true);
                                dbgLog.warning("exiting dwnldAction() due to an IO problem ");
                                getVDCRequestBean().setSelectedTab("tabDwnld");
                                dvnDSBTimerService.createTimer(deleteTempFileList, TEMP_FILE_LIFETIME);
                                return "";

                            } catch (RuntimeException re) {
                                re.printStackTrace();

                                msgDwnldButton.setValue("* could not generate subset due to an runtime error");
                                msgDwnldButton.setVisible(true);
                                dbgLog.warning("exiting dwnldAction() due to an runtime error");
                                getVDCRequestBean().setSelectedTab("tabDwnld");
                                dvnDSBTimerService.createTimer(deleteTempFileList, TEMP_FILE_LIFETIME);
                                return ""; //"failure";

                            }

                        }
                    }

                    // Checks the resulting subset file 
                    if (tmpsbfl.exists()) {
                        Long subsetFileSize = tmpsbfl.length();
                        dbgLog.fine("subsettFile:Length=" + subsetFileSize);
                        dbgLog.fine("tmpsb file name=" + tmpsbfl.getAbsolutePath());

                        if (subsetFileSize > 0) {
                            mpl.put("subsetFileName", Arrays.asList(tmpsbfl.getAbsolutePath()));
                            mpl.put("subsetDataFileName", Arrays.asList(tmpsbfl.getName()));
                        } else {
                            // subset file exists but it is empty

                            msgAdvStatButton.setValue("* an subset file is empty");
                            msgAdvStatButton.setVisible(true);
                            dbgLog.warning("exiting advStatAction() due to a subsetting error:"
                                    + "a subset file is empty");
                            getVDCRequestBean().setSelectedTab("tabAdvStat");

                            return ""; //"failure";

                        }
                    } else {
                        // subset file was not created
                        msgAdvStatButton.setValue("* a subset file was not created");
                        msgAdvStatButton.setVisible(true);
                        dbgLog.warning("exiting advStatAction() due to a subsetting error:"
                                + "a subset file was not created");
                        getVDCRequestBean().setSelectedTab("tabAdvStat");

                        return ""; //"failure";

                    }

                    // Step 3. Organizes parameters/metadata to be sent to the implemented
                    // data-analysis-service class

                    //Map<String, Map<String, String>> vls = getValueTableForRequestedVariables(getDataVariableForRequest());
                    Map<String, Map<String, String>> vls = getValueTablesForAllRequestedVariables();

                    sro = new DvnRJobRequest(getDataVariableForRequest(), mpl, vls, recodeSchema, modelSpec);

                    //dbgLog.fine("Prepared sro dump:\n"+ToStringBuilder.reflectionToString(sro, ToStringStyle.MULTI_LINE_STYLE));

                    // Step 4. Creates an instance of the the implemented
                    // data-analysis-service class 

                    DvnRDataAnalysisServiceImpl das = new DvnRDataAnalysisServiceImpl();

                    // Executes a request of downloading or data analysis and 
                    // capture result info as a Map <String, String>

                    resultInfo = das.execute(sro);

                    // Step 5. Checks the DSB-exit-status code
                    if (resultInfo.get("RexecError").equals("true")) {
                        //msgAdvStatButton.setValue("* The Request failed due to an R-runtime error");
                        msgAdvStatButton.setValue("* The Request failed due to an R-runtime error");
                        msgAdvStatButton.setVisible(true);
                        dbgLog.fine("exiting advStatAction() due to an R-runtime error");
                        getVDCRequestBean().setSelectedTab("tabAdvStat");

                        return ""; //"failure";
                    } else {
                        if (recodeSchema.size() > 0) {
                            resultInfo.put("subsettingCriteria", sro.getSubsetConditionsForCitation());
                        } else {
                            resultInfo.put("subsettingCriteria", "");
                        }
                    }

                } catch (MalformedURLException e) {
                    e.printStackTrace();
                    // pass the error message to the resultPage
                    // resultInfo.put();
                    msgAdvStatButton.setValue("* file URL is malformed");
                    msgAdvStatButton.setVisible(true);
                    dbgLog.warning("exiting advStatAction() due to a URL problem ");
                    getVDCRequestBean().setSelectedTab("tabAdvStat");

                    return ""; //"failure";

                } catch (IOException e) {
                    // this may occur if the dataverse is not released
                    // the file exists, but it is not accessible 
                    e.printStackTrace();

                    msgAdvStatButton.setValue("* an IO problem occurred");
                    msgAdvStatButton.setVisible(true);
                    dbgLog.warning("exiting advStatAction() due to an IO problem ");
                    getVDCRequestBean().setSelectedTab("tabAdvStat");

                    return ""; //"failure";

                }
                // end of the subset-OK case
            } else {
                // not subsettable data file
                msgAdvStatButton.setValue("* this data file is not subsettable file");
                msgAdvStatButton.setVisible(true);
                dbgLog.warning("exiting advStatAction(): the data file is not subsettable ");
                getVDCRequestBean().setSelectedTab("tabAdvStat");

                return ""; //"failure";

            } // end:subsetNotOKcase

            // final processing steps for all successful cases

            resultInfo.put("offlineCitation", getCitation());
            resultInfo.put("studyTitle", getStudyTitle());
            resultInfo.put("studyNo", getStudyId().toString());
            resultInfo.put("dtId", dtId.toString());
            if (versionNumber != null) {
                resultInfo.put("versionNumber", versionNumber.toString());
            }
            resultInfo.put("studyURL", studyURL);
            resultInfo.put("R_min_verion_no", resultInfo.get("Rversion").substring(2));
            resultInfo.put("dataverse_version_no", dvnVersionNumber);

            dbgLog.fine("RwrkspFileName=" + resultInfo.get("wrkspFileName"));

            // writing necessary files
            try {

                // rename the subsetting file
                File tmpsbflnew = File.createTempFile(SUBSET_FILENAME_PREFIX + resultInfo.get("PID") + ".", ".tab");
                deleteTempFileList.add(tmpsbflnew);
                InputStream inb = new BufferedInputStream(new FileInputStream(tmpsbfl));
                OutputStream outb = new BufferedOutputStream(new FileOutputStream(tmpsbflnew));

                int bufsize;
                byte[] bffr = new byte[8192];
                while ((bufsize = inb.read(bffr)) != -1) {
                    outb.write(bffr, 0, bufsize);
                }
                inb.close();
                outb.close();

                String rhistNew = StringUtils.replace(resultInfo.get("RCommandHistory"), tmpsbfl.getName(),
                        tmpsbflnew.getName());

                //zipFileList.add(tmpsbflnew);

                // (1) write a citation file 
                //                String citationFilePrefix = "citationFile_"+ resultInfo.get("PID") + "_";
                //                File tmpcfl = File.createTempFile(citationFilePrefix, ".txt");
                //
                //                zipFileList.add(tmpcfl);
                //                deleteTempFileList.add(tmpcfl);
                //
                //                DvnCitationFileWriter dcfw = new DvnCitationFileWriter(resultInfo);
                //
                //                String fmpcflFullname = tmpcfl.getAbsolutePath();
                //                String fmpcflname = tmpcfl.getName();
                //                dcfw.write(tmpcfl);

                // (2) R command file
                String rhistoryFilePrefix = R_COMMAND_FILE_PREFIX + resultInfo.get("PID") + ".R";
                File tmpRhfl = new File(TEMP_DIR, rhistoryFilePrefix);

                zipFileList.add(tmpRhfl);
                deleteTempFileList.add(tmpRhfl);
                resultInfo.put("dvn_R_helper_file", "dvn_helper.R");
                DvnReplicationCodeFileWriter rcfw = new DvnReplicationCodeFileWriter(resultInfo);
                if (mdlName.equals("xtb")) {
                    rcfw.writeXtabCode(tmpRhfl);
                } else {
                    rcfw.writeZeligCode(tmpRhfl);
                }

                // (3) RData Replication file
                String wrkspFileName = resultInfo.get("wrkspFileName");
                dbgLog.fine("wrkspFileName=" + wrkspFileName);

                File RwrkspFileName = new File(wrkspFileName);
                if (RwrkspFileName.exists()) {
                    dbgLog.fine("RwrkspFileName:length=" + RwrkspFileName.length());

                    zipFileList.add(RwrkspFileName);

                } else {
                    dbgLog.fine("RwrkspFileName does not exist");
                    //msgAdvStatButton.setValue("* The workspace file is not available");
                    //msgAdvStatButton.setVisible(true);
                    dbgLog.warning("advStatAction(): R workspace file was not transferred");
                    //getVDCRequestBean().setSelectedTab("tabAdvStat");

                    //return "failure";
                }
                deleteTempFileList.add(RwrkspFileName);

                // vdc_startup.R file
                //                String vdc_startupFileName = resultInfo.get("vdc_startupFileName");
                //                dbgLog.fine("vdc_startupFileName="+vdc_startupFileName);
                //                File vdcstrtFileName = new File(vdc_startupFileName);
                //                if (vdcstrtFileName.exists()){
                //                    dbgLog.fine("vdcstrtFileName:length="+vdcstrtFileName.length());
                //                    zipFileList.add(vdcstrtFileName);
                //                } else {
                //                    dbgLog.fine("vdcstrtFileName does not exist");
                //                    //msgAdvStatButton.setValue("* vdc_startup.R is not available");
                //                    //msgAdvStatButton.setVisible(true);
                //                    dbgLog.warning("advStatAction(): vdc_startup.R was not transferred");
                //                    //getVDCRequestBean().setSelectedTab("tabAdvStat");
                //
                //                    //return "failure";
                //                }
                //                deleteTempFileList.add(vdcstrtFileName);
                // (4) add replication readme file
                String readMeFileName = REP_README_FILE_PREFIX + resultInfo.get("PID") + ".txt";
                File readMeFile = new File(TEMP_DIR, readMeFileName);

                DvnReplicationREADMEFileWriter rw = new DvnReplicationREADMEFileWriter(resultInfo);
                rw.writeREADMEfile(readMeFile);
                //zipFileList.add(REP_README_FILE);
                zipFileList.add(readMeFile);
                deleteTempFileList.add(readMeFile);
                // (5) helper
                zipFileList.add(DVN_R_HELPER_FILE);
                if (mdlName.equals("xtb")) {
                    // (6) css file
                    zipFileList.add(DVN_R2HTML_CSS_FILE);

                }
                // zip the following files as a replication-pack
                //
                // local     local        local      remote
                // citation, tab-file,   R history,  wrksp

                for (File f : zipFileList) {
                    dbgLog.fine("path=" + f.getAbsolutePath() + "\tname=" + f.getName());
                }

                // zipping all required files
                try {
                    String zipFilePrefix = "zipFile_" + resultInfo.get("PID") + ".zip";
                    File zipFile = new File(TEMP_DIR, zipFilePrefix);

                    deleteTempFileList.add(zipFile);
                    //res.setContentType("application/zip");
                    String zfname = zipFile.getAbsolutePath();
                    //res.setHeader("content-disposition", "attachment; filename=" + zfname);

                    OutputStream zfout = new FileOutputStream(zipFile);
                    //zipFiles(res.getOutputStream(), zipFileList);
                    zipFiles(zfout, zipFileList);

                    if (zipFile.exists()) {
                        Long zipFileSize = zipFile.length();
                        dbgLog.fine("zip file:length=" + zipFileSize);
                        dbgLog.fine("zip file:name=" + zipFile.getAbsolutePath());
                        if (zipFileSize > 0) {
                            resultInfo.put("replicationZipFile", zfname);
                            resultInfo.put("replicationZipFileName", zipFile.getName());

                        } else {
                            dbgLog.fine("zip file is empty");
                        }
                    } else {
                        dbgLog.fine("zip file was not saved");
                    }

                    // put resultInfo into the session object
                    resultInfo.remove("RCommandHistory");
                    FacesContext.getCurrentInstance().getExternalContext().getSessionMap().put("resultInfo",
                            resultInfo);

                    dvnDSBTimerService.createTimer(deleteTempFileList, TEMP_FILE_LIFETIME);

                    dbgLog.fine("***** within advStatAction(): succcessfully ends here *****");

                    return "/subsetting/AnalysisResultsPage?faces-redirect=true" + getContextSuffix(); //"success";

                } catch (IOException e) {
                    // file-access problem, etc.
                    e.printStackTrace();
                    dbgLog.fine("zipping IO exception");
                    msgAdvStatButton.setValue("* an IO problem occurred during zipping replication files");
                    msgAdvStatButton.setVisible(true);
                    dbgLog.warning("exiting edaAction() due to an zipping IO problem ");
                    //getVDCRequestBean().setSelectedTab("tabAdvStat");
                    dvnDSBTimerService.createTimer(deleteTempFileList, TEMP_FILE_LIFETIME);
                    return "/subsetting/AnalysisResultsPage?faces-redirect=true" + getContextSuffix(); //"success";
                }
                // end of zipping step

            } catch (IOException e) {
                // io errors caught during writing files
                e.printStackTrace();

                msgAdvStatButton.setValue("* an IO problem occurred");
                msgAdvStatButton.setVisible(true);
                dbgLog.warning("exiting edaAction() due to an IO problem ");
                getVDCRequestBean().setSelectedTab("tabAdvStat");

                return ""; //"failure";
            }

            // end of CheckParameters: OK case
        } else {
            // parameters are not complete: show error message;

            msgAdvStatButton.setValue("* Selection is incomplete");
            msgAdvStatButton.setVisible(true);
            dbgLog.fine("exiting advStatAction(): selection is incomplete");
            getVDCRequestBean().setSelectedTab("tabAdvStat");

            return ""; //"failure";
        }

    }

    // -----------------------------------------------------------------------
    // subsetting-instruction section
    // -----------------------------------------------------------------------
    // <editor-fold desc="subsetting instruction">

    // message block: subsetting allowed
    private HtmlOutputText txtSubsettingInstruction = new com.icesoft.faces.component.ext.HtmlOutputText();

    public HtmlOutputText getTxtSubsettingInstruction() {
        return txtSubsettingInstruction;
    }

    public void setTxtSubsettingInstruction(HtmlOutputText hot) {
        this.txtSubsettingInstruction = hot;
    }

    // message block: subsetting not allowed
    private HtmlOutputText txtNonSubsettingInstruction = new com.icesoft.faces.component.ext.HtmlOutputText();

    public HtmlOutputText getTxtNonSubsettingInstruction() {
        return txtNonSubsettingInstruction;
    }

    public void setTxtNonSubsettingInstruction(HtmlOutputText hot) {
        this.txtNonSubsettingInstruction = hot;
    }

    private HtmlPanelGrid wrapSubsettingInstruction = new com.icesoft.faces.component.ext.HtmlPanelGrid();

    /**
     * Getter for component wrapSubsettingInstruction
     *
     * @return    ice:panelGrid of the pane 
     */
    public HtmlPanelGrid getWrapSubsettingInstruction() {
        return wrapSubsettingInstruction;
    }

    /**
     * Setter for panelGroup wrapSubsettingInstruction
     *
     * @param pg    ice:panelGrid of the pane
     */
    public void setWrapSubsettingInstruction(HtmlPanelGrid pg) {
        wrapSubsettingInstruction = pg;
    }

    private Boolean wrapSubsettingInstructionRendered;

    /**
     * Getter for attribute wrapSubsettingInstructionRendered
     *
     * @return    the rendered attribute of ice:panelGroup
     */
    public Boolean getWrapSubsettingInstructionRendered() {
        return wrapSubsettingInstructionRendered;
    }

    /**
     * Setter for attribute wrapSubsettingInstructionRendered
     *
     * @param rndrd    the rendered attribute of ice:panelGroup
     */
    public void setWrapSusettingInstructionRendered(Boolean rndrd) {
        wrapSubsettingInstructionRendered = rndrd;
    }

    private HtmlPanelGroup wrapNonSubsettingInstruction = new com.icesoft.faces.component.ext.HtmlPanelGroup();

    /**
     * Getter for component wrapNonSubsettingInstruction
     *
     * @return    ice:panelGroup of the pane 
     */
    public HtmlPanelGroup getWrapNonSubsettingInstruction() {
        return wrapNonSubsettingInstruction;
    }

    /**
     * Setter for panelGroup wrapNonSubsettingInstruction
     *
     * @param pg    ice:panelGroup of the pane
     */
    public void setWrapNonSubsettingInstruction(HtmlPanelGroup pg) {
        wrapNonSubsettingInstruction = pg;
    }

    private Boolean wrapNonSubsettingInstructionRendered;

    /**
     * Getter for attribute wrapNonSubsettingInstructionRendered
     *
     * @return    the rendered attribute of ice:panelGroup
     */
    public Boolean getWrapNonSubsettingInstructionRendered() {
        return wrapNonSubsettingInstructionRendered;
    }

    /**
     * Setter for attribute wrapNonSubsettingInstructionRendered
     *
     * @param rndrd    the rendered attribute of panelGroup
     */
    public void setWrapNonSubsettingInstructionRendered(Boolean rndrd) {
        wrapNonSubsettingInstructionRendered = rndrd;
    }

    // end of subsetting-instruction
    // <----------------------------------------------------------------------
    // </editor-fold>

    // -----------------------------------------------------------------------
    // How-many-variable-DropDown menu
    // -----------------------------------------------------------------------
    // <editor-fold desc="How Many Variable Menu">

    private HtmlInputText textField4 = new com.icesoft.faces.component.ext.HtmlInputText();

    public HtmlInputText getTextField4() {
        return textField4;
    }

    public void setTextField4(HtmlInputText hit) {
        this.textField4 = hit;
    }

    // ice:selectOneMenu: howManyRows
    // howManyRows@binding

    private HtmlSelectOneMenu howManyRows = new com.icesoft.faces.component.ext.HtmlSelectOneMenu();

    public HtmlSelectOneMenu getHowManyRows() {
        return howManyRows;
    }

    public void setHowManyRows(HtmlSelectOneMenu dd) {
        this.howManyRows = dd;
    }

    // howManyRows@value

    private List<SelectItem> howManyRowsOptions = new ArrayList<SelectItem>();

    public List<SelectItem> getHowManyRowsOptions() {
        return howManyRowsOptions;
    }

    public void setHowManyRowsOptions(List<SelectItem> ssol) {
        this.howManyRowsOptions = ssol;
    }
    // howManyRows@valueChangeListener

    public void howManyRows_processValueChange(ValueChangeEvent vce) {
        dbgLog.fine("***** howManyRows_processValueChange: start *****");
        // the value of show-all-rows option == 0
        dbgLog.fine("old number of Rows=" + vce.getOldValue());
        if (vce.getOldValue() == null) {
            return;
        }
        dbgLog.fine("new number of Rows=" + vce.getNewValue());
        dbgLog.fine("current Row Index(1)=" + data.getRowIndex());
        selectedNoRows = (String) howManyRows.getValue();
        dbgLog.fine("selected number of Rows=" + selectedNoRows);

        int newNoRows = Integer.parseInt(selectedNoRows);
        if (newNoRows == 0) {
            newNoRows = data.getRowCount();
        }
        dbgLog.fine("acutually selected number of Rows=" + newNoRows);
        data.setFirst(0);
        data.setRows(newNoRows);
        dbgLog.fine("first row to be shown=" + data.getFirst());
        dbgLog.fine("current Row Index(2)=" + data.getRowIndex());
        //FacesContext.getCurrentInstance().renderResponse();
        howManyVarsChecked();
        FacesContext.getCurrentInstance().getExternalContext().getSessionMap().put("selectedNoRows",
                selectedNoRows);

        dbgLog.fine("***** howManyRows_processValueChange: end *****");
    }

    private String howManyRowsClientId;

    public String getHowManyRowsClientId() {
        FacesContext cntxt = FacesContext.getCurrentInstance();
        return howManyRows.getClientId(cntxt);
    }

    private String selectedNoRows;

    public String getSelectedNoRows() {
        return selectedNoRows;
    }

    public void setSelectedNoRows(String selectedNoRows) {
        this.selectedNoRows = selectedNoRows;
    }

    // </editor-fold>

    // -----------------------------------------------------------------------
    // variable Table section
    // -----------------------------------------------------------------------
    // <editor-fold desc="variable table">

    // Variable Table: @binding

    /**
     * UIData that backs the binding attribute of 
     * the variable table (h:dataTable) whose id is dataTable1
     *
     */
    private UIData data = null;

    /**
     * Getter for property data
     *
     * @return     property data
     */
    public UIData getData() {
        return data;
    }

    /**
     * Setter for property data
     *
     * @param data new UIData
     */
    public void setData(UIData data) {
        this.data = data;
    }

    // -----------------------------------------------------------------------
    // scroller-related methods
    // -----------------------------------------------------------------------
    /**
     * Shifts the displayed rows of the variable table back to the top
     *
     * @return    null String
     */
    public String first() {
        scroll(0);
        return (null);
    }

    /**
     * Shifts the displayed rows of the variable table forward to the buttom
     *
     * @return    null String
     */
    public String last() {
        scroll(data.getRowCount() - 1);
        return (null);
    }

    /**
     * Shifts the displayed rows of the variable table one page forward
     *
     * @return    null String
     */
    public String next() {
        int first = data.getFirst();
        scroll(first + data.getRows());
        return (null);
    }

    /**
     * Shifts the displayed rows of the variable table one page back
     *
     * @return    null String
     */
    public String previous() {
        int first = data.getFirst();
        scroll(first - data.getRows());
        return (null);
    }

    /**
     * Shifts the displayed rows of the variable table to
     * the indexed position on which an end-user clicked
     *
     * @param row    the new current row Id number (integer)
     */

    public void scroll(int row) {
        int rows = data.getRows();
        dbgLog.fine("within scroll:rows=" + rows);
        if (rows < 1) {
            return;
        }
        if (rows < 0) {
            data.setFirst(0);
        } else if (rows >= data.getRowCount()) {
            data.setFirst(data.getRowCount() - 1);
        } else {
            data.setFirst(row - (row % rows));
        }
    }

    /**
     * Shifts the displayed rows of the variable table upon an end-user's
     * clicking action on the scroller element
     *
     * @param event ActionEvent event
     */
    public void processScrollEvent(ActionEvent event) {
        int currentRow = 1;
        UIComponent component = event.getComponent();
        Integer curRow = (Integer) component.getAttributes().get("currentRow");
        dbgLog.fine("within processScrollEvent: curRow=" + curRow);
        int firstRow = data.getFirst();
        dbgLog.fine("b: 1st row-index value=" + firstRow);
        int lastRow = data.getFirst() + data.getRows();
        dbgLog.fine("b: tentative last row-index value=" + lastRow);
        if (curRow != null) {
            currentRow = curRow.intValue();
        }
        dbgLog.fine("currentRow=" + currentRow);
        scroll(currentRow);
        firstRow = data.getFirst();
        dbgLog.fine("a: 1st row-index value=" + firstRow);
        lastRow = data.getFirst() + data.getRows();
        dbgLog.fine("a: tentative last row-index value=" + lastRow);
        howManyVarsChecked();
    }

    private DataPaginator dataScroller1 = new DataPaginator();

    public DataPaginator getDataScroller1() {
        return dataScroller1;
    }

    public void setDataScroller1(DataPaginator dataScroller1) {
        this.dataScroller1 = dataScroller1;
    }

    public void processDataScroller1(ActionEvent ae) {
        dbgLog.fine("***** processDataScroller1: start *****");
        dbgLog.fine("current page index=" + dataScroller1.getPageIndex());
        checkboxSelectUnselectAll.setSelected(false);
        dbgLog.fine("***** processDataScroller1: end *****");
    }

    // -----------------------------------------------------------------------
    // select-all checkbox
    // -----------------------------------------------------------------------

    /**
     * The Checkbox object backing the binding attribute of 
     * HtmlSelectBooleanCheckbox 
     * component that renders the select/unselect-all variable checkbox
     *  in the first column of the header of the variable table
     */
    //private Checkbox checkboxSelectUnselectAll = new Checkbox();
    private HtmlSelectBooleanCheckbox checkboxSelectUnselectAll = new com.icesoft.faces.component.ext.HtmlSelectBooleanCheckbox();

    /**
     * Getter for component checkboxSelectUnselectAll
     *
     * @return  the Checkbox object backing the
     *          select/unselect-all variable checkbox
     */
    public HtmlSelectBooleanCheckbox getCheckboxSelectUnselectAll() {
        return checkboxSelectUnselectAll;
    }

    /**
     * Setter for component checkboxSelectUnselectAll
     *
     * @param c    the Checkbox object that backs the
     *             select/unselect-all variable checkbox
     */
    public void setCheckboxSelectUnselectAll(HtmlSelectBooleanCheckbox c) {
        checkboxSelectUnselectAll = c;
    }

    /**
     * To avoid serialization-related errors, the component-binding of
     * checkboxSelectUnselectAll should not be used for state-keeping
     * The two attributes of this checkbox object, 
     * selected and rendered, must be separately handled by two new 
     * Boolean properties.
     * attribute       Boolean property
     * --.value     checkboxSelectUnselectAllSelected
     * --.rendered     checkboxSelectUnselectAllRendered
     */

    /**
     * The Boolean object backing the selected attribute of
     * checkboxSelectUnselectAll 
     */
    private Boolean checkboxSelectUnselectAllSelected;

    /**
     * Getter for property checkboxSelectUnselectAllSelected
     *
     * @return    the selected attribute of checkboxSelectUnselectAll
     */
    public Boolean getCheckboxSelectUnselectAllSelected() {
        return checkboxSelectUnselectAllSelected;
    }

    /**
     * Setter for property checkboxSelectUnselectAllSelected
     *
     * @param     The Boolean object that backs the selected 
     *            attribute of checkboxSelectUnselectAll
     */
    public void setCheckboxSelectUnselectAllSelected(Boolean c) {
        checkboxSelectUnselectAllSelected = c;
    }

    /**
     * The Boolean object backing the rendered attribute of
     * checkboxSelectUnselectAll 
     */
    private Boolean checkboxSelectUnselectAllRendered;

    /**
     * Getter for property checkboxSelectUnselectAllRendered
     *
     * @return    the rendered attribute of checkboxSelectUnselectAll
     */
    public Boolean getCheckboxSelectUnselectAllRendered() {
        return checkboxSelectUnselectAllRendered;
    }

    /**
     * Setter for property checkboxSelectUnselectAllRendered
     *
     * @param     The Boolean object that backs the rendered 
     *            attribute of checkboxSelectUnselectAll
     */
    public void setCheckboxSelectUnselectAllRendered(Boolean c) {
        checkboxSelectUnselectAllRendered = c;
    }

    /**
     * Updates the Boolean state of the select/unselect-all checkbox 
     * via its backing attribute checkboxSelectUnselectAllSelected and
     * saves this Boolean state in the sessionMap object
     */
    public void howManyVarsChecked() {
        dbgLog.fine("***** howManyVarsChecked: start *****");
        // get the 1st and last ones of the displayed rows
        int firstRow = data.getFirst();
        dbgLog.fine("1st row-index value=" + firstRow);
        int lastRow = data.getFirst() + data.getRows();
        dbgLog.fine("tentative last row-index value=" + lastRow);
        int remain = data.getRowCount() - firstRow;
        if (remain < data.getRows()) {
            lastRow = data.getFirst() + remain;
            dbgLog.fine("adjusted last row-index value=" + lastRow);
        }
        dbgLog.fine("how many rows are displayed=" + data.getRows());

        int counter = 0;
        for (int i = firstRow; i < lastRow; i++) {
            List<Object> rw = new ArrayList<Object>();
            rw = (ArrayList) dt4Display.get(i);
            if ((Boolean) rw.get(0)) {
                counter++;
            }
        }
        int diff = lastRow - firstRow;
        dbgLog.fine("how many rows to be displayed=" + diff);
        dbgLog.fine("how many rows are checked=" + counter);
        if (counter == diff) {
            // check the checkbox
            checkboxSelectUnselectAll.setSelected(Boolean.TRUE);
            dbgLog.fine("set the select/unselect-all checkbox checked");
        } else {
            // uncheck the checkbox
            checkboxSelectUnselectAll.setSelected(Boolean.FALSE);
            dbgLog.fine("set the select/unselect-all checkbox UN-checked");
        }

        // Stores the objects that represents the properties of the component
        // instead of the component itsefl in the session map
        /* deprecated
        FacesContext.getCurrentInstance().getExternalContext()
            .getSessionMap().put("checkboxSelectUnselectAll",
            checkboxSelectUnselectAll);
        */
        checkboxSelectUnselectAllSelected = (Boolean) checkboxSelectUnselectAll.getValue();
        FacesContext.getCurrentInstance().getExternalContext().getSessionMap()
                .put("checkboxSelectUnselectAllSelected", checkboxSelectUnselectAllSelected);
        dbgLog.fine("***** howManyVarsChecked: end *****");
    }

    /**
     * Updates backing objects and components after an end-user 
     * checked/unchecked the checkbox checkboxSelectUnselectAll.
     * Attached to the valueChangeListener  attribute of checkbox
     * component whose id is checkboxSelectUnselectAll
     *
     * @param vce ValueChangeEvent event 
     */
    public void selectUnselectAllCheckbox(ValueChangeEvent vce) {
        dbgLog.fine("***** selectUnselectAllCheckbox: start *****");

        // toggle false to true or vice versa
        FacesContext cntxt = FacesContext.getCurrentInstance();
        Boolean oldState = (Boolean) vce.getOldValue();
        dbgLog.fine("oldState=" + oldState);
        Boolean currentState = (Boolean) vce.getNewValue();
        dbgLog.fine("newState=" + currentState);

        // clear the error message if it still exists
        resetMsgVariableSelection();

        // hide the download button and
        // show the create button
        dwnldButton.setRendered(true);
        dwnloadSubsetButton.setRendered(false);

        // check the displayed rows
        int firstRow = data.getFirst();
        dbgLog.fine("1st-row index value=" + firstRow);
        int lastRow = data.getFirst() + data.getRows();
        dbgLog.fine("tentative last row-index value=" + lastRow);
        int remain = data.getRowCount() - firstRow;
        if (remain < data.getRows()) {
            lastRow = data.getFirst() + remain;
            dbgLog.fine("adjusted last row-index value=" + lastRow);
        }
        dbgLog.fine("how many rows are to be displayed=" + data.getRows());

        Set<String> bvIdSet = new HashSet<String>();
        Set<String> rmIdSet = new HashSet<String>();
        int bvcnt = 0;
        for (int i = firstRow; i < lastRow; i++) {
            List<Object> rw = new ArrayList<Object>();
            rw = (ArrayList) dt4Display.get(i);
            String varId = (String) rw.get(2);

            // check this var is a base-var for recoded vars
            if (!baseVarToDerivedVar.containsKey(varId)) {
                // recoded var's Id may also pass this block
                rw.set(0, currentState);
                if (!isRecodedVar(varId)) {
                    // if this id is not recoded var's id
                    dbgLog.fine(varId + " is not a recoded varId");
                    rmIdSet.add(varId);
                } else {
                    dbgLog.fine(varId + " is a recoded varId");
                    bvcnt++;
                    bvIdSet.add(varId);
                }
            } else {
                // keep this var's checkbox checked
                rw.set(0, Boolean.TRUE);
                bvcnt++;
                bvIdSet.add(varId);
            }
            dt4Display.set(i, rw);
        }
        dbgLog.fine("conents:bvIdSet=" + bvIdSet);
        dbgLog.fine("number of recoded vars=" + bvcnt);

        if (currentState) {
            // select-all case
            dbgLog.fine("select all case: add all variable to varCart, etc.");

            for (int i = firstRow; i < lastRow; i++) {
                String keyS = (String) ((ArrayList) dt4Display.get(i)).get(2);
                String valueS = (String) ((ArrayList) dt4Display.get(i)).get(3);
                // Long newKey= Long.valueOf(keyS);
                // if (!varCart.containsKey(newKey)){
                if (!varCart.containsKey(keyS)) {
                    // varCart.put( newKey, valueS );
                    varCart.put(keyS, valueS);
                    getVarSetAdvStat().add(new SelectItem(keyS, valueS));
                }
            }
            // activate buttons
            activateButtons();
            checkboxSelectUnselectAll.setSelected(Boolean.TRUE);
        } else {
            // unselect-all case
            dbgLog.fine("unselect all case");
            if (bvcnt == 0) {
                // no recoded var case
                dbgLog.fine("un-select-all case: no recoding vars");
                // backing Map object
                varCart.clear();
                // LHS listbox
                varSetAdvStat.clear();
                // RHS listboxes
                advStatVarRBox1.clear();
                advStatVarRBox2.clear();
                advStatVarRBox3.clear();

                // RHS simulation option: unchecked
                simulationPanel.setSelected(false);

                // simulation-type radio button group
                radioSimTypeChoice.setValue("0");
                //groupPanel20.setRendered(false);
                groupPanelSimTypeChoice.setRendered(false);
                //groupPanel22.setRendered(false);
                groupPanelSimNonDefault.setRendered(false);
                // deactivate buttons
                deactivateButtons();
                // clear the recodeTable area
                clearRecodeTargetVarInfo();
                // hide recode Area
                hideRecodeTableArea();
            } else {
                // at least one recoded variable exists
                dbgLog.fine("un-select-all case: " + "some variables are used for recoding and they are kept");

                // clear varCart(Map) except for base vars for recoding
                for (String v : rmIdSet) {
                    dbgLog.fine("to be removed=" + v);
                    varCart.remove(v);
                }

                dbgLog.fine("pass the block for varCart");
                // clear varSetAdvStat except for base vars for recoding
                // LHS listbox object (Collection ArrayList<Option>)
                List<SelectItem> tmpvs = new ArrayList<SelectItem>();
                for (Iterator i = varSetAdvStat.iterator(); i.hasNext();) {
                    SelectItem el = (SelectItem) i.next();
                    if (bvIdSet.contains((String) el.getValue())) {
                        tmpvs.add(new SelectItem(el.getValue(), el.getLabel()));
                    } else if (isRecodedVar((String) el.getValue())) {
                        dbgLog.fine("recoded varId to be re-attached=" + el.getValue());
                        tmpvs.add(new SelectItem(el.getValue(), el.getLabel()));
                    }
                }
                dbgLog.fine("To-be-re-attached selectItem set:tmpvs(size)=" + tmpvs.size());
                for (SelectItem tmpvsi : tmpvs) {
                    dbgLog.fine("value=" + tmpvsi.getValue() + " label=" + tmpvsi.getLabel());
                }
                varSetAdvStat.clear();
                varSetAdvStat.addAll(tmpvs);

                dbgLog.fine("pass the block for varSetAdvState");

                // RHS listbox1
                List<SelectItem> tmpRBox1 = new ArrayList<SelectItem>();
                for (Iterator i = advStatVarRBox1.iterator(); i.hasNext();) {
                    SelectItem el = (SelectItem) i.next();
                    if (!bvIdSet.contains((String) el.getValue())) {
                        tmpRBox1.add(new SelectItem(el.getValue(), el.getLabel()));

                    }
                }
                advStatVarRBox1.clear();
                advStatVarRBox1.addAll(tmpRBox1);
                dbgLog.fine("pass the block for advStatVarRBox1");

                // RHS listbox2
                List<SelectItem> tmpRBox2 = new ArrayList<SelectItem>();
                for (Iterator i = advStatVarRBox2.iterator(); i.hasNext();) {
                    SelectItem el = (SelectItem) i.next();
                    if (bvIdSet.contains((String) el.getValue())) {
                        tmpRBox2.add(new SelectItem(el.getValue(), el.getLabel()));
                    }
                }
                advStatVarRBox2.clear();
                advStatVarRBox2.addAll(tmpRBox2);

                // RHS listbox3
                List<SelectItem> tmpRBox3 = new ArrayList<SelectItem>();
                for (Iterator i = advStatVarRBox3.iterator(); i.hasNext();) {
                    SelectItem el = (SelectItem) i.next();
                    if (bvIdSet.contains((String) el.getValue())) {
                        tmpRBox3.add(new SelectItem(el.getValue(), el.getLabel()));
                    }
                }
                advStatVarRBox3.clear();
                advStatVarRBox3.addAll(tmpRBox3);

                msgVariableSelection.setVisible(true);
                msgVariableSelection.setValue("At least one variable is used for recoding;<br />"
                        + "Remove its recoded variable(s) first.");
            }
        }
        cntxt.renderResponse();
        dbgLog.fine("***** selectUnselectAllCheckbox: end *****");
    }

    // -----------------------------------------------------------------------
    // variable-table: Checkboxes in the first column
    // -----------------------------------------------------------------------
    /**
     * h:HtmlSelectBooleanCheckbox component backing the binding attribute of 
     * a HtmlSelectBooleanCheckbox in the first column of the variable table in 
     * the subsetting page and whose id is varCheckbox
     */
    private HtmlSelectBooleanCheckbox varCheckbox = new com.icesoft.faces.component.ext.HtmlSelectBooleanCheckbox();

    /**
     * Getter for component varCheckbox
     *
     * @return    HtmlSelectBooleanCheckbox object
     */
    public HtmlSelectBooleanCheckbox getVarCheckbox() {
        return varCheckbox;
    }

    /**
     * Setter for component varCheckbox 
     *
     * @param c    HtmlSelectBooleanCheckbox object
     */

    public void setVarCheckbox(HtmlSelectBooleanCheckbox c) {
        this.varCheckbox = c;
    }

    /**
     * Updates backing objects and components after
     * an end-user checked/unchecked a checkbox in each of the variable table.
     * Attached to the valueChangeListener attribute of HtmlSelectBooleanCheckbox
     * component whose id is varCheckbox
     *
     * @param vce    ValueChangeEvent event
     */
    public void updateCheckBoxState(ValueChangeEvent vce) {
        dbgLog.fine("***** updateCheckBoxState:starts here *****");
        int cr = 0;

        List<Object> tmpDataLine = (List<Object>) data.getRowData();
        dbgLog.fine("current varName=" + tmpDataLine.get(3));
        dbgLog.fine("current varId=" + tmpDataLine.get(2));
        String varId = (String) tmpDataLine.get(2);

        resetMsgVariableSelection();

        // remove vars from RHS boxes
        resetMsgDwnldButton();
        resetMsgMoveRecodeVarBttn();
        resetMsgSaveRecodeBttn();
        resetMsgEdaButton();
        resetMsg4MoveVar();
        resetMsgAdvStatButton();
        resetMsgVariableSelection();

        if ((Boolean) tmpDataLine.get(0)) {
            dbgLog.fine("row Id=" + tmpDataLine.get(2) + ":current checkbox value is [true]");
        } else {
            dbgLog.fine("row Id=" + tmpDataLine.get(2) + ":current checkbox value is [false]");
        }

        Boolean currentState = (Boolean) vce.getNewValue();
        dbgLog.fine("currentState=" + currentState);
        dbgLog.fine("selected=" + varCheckbox.isSelected());
        // update the state of the selected value of this row

        if (currentState) {
            tmpDataLine.set(0, currentState);
            // put
            // varCart.put(dt4Display.get(cr).getVarId(),
            // dt4Display.get(cr).getVarName());
            // ID and Variable Name
            // varCart.put(Long.valueOf((String) tmpDataLine.get(2)), (String)
            // tmpDataLine.get(3));
            varCart.put((String) tmpDataLine.get(2), (String) tmpDataLine.get(3));

            getVarSetAdvStat().add(new SelectItem((String) tmpDataLine.get(2), (String) tmpDataLine.get(3)));
            dbgLog.fine("selected(case 1)=" + varCheckbox.isSelected());

        } else {
            // remove

            // varCart.remove(Long.valueOf((String) tmpDataLine.get(2)));
            // check this var is used for recoded var

            if (baseVarToDerivedVar.containsKey(varId)) {
                // Case: Used for recoding
                dbgLog.fine("this var is already used for recoding and cannot be unchekced");
                // flips back the checkbox [checked]
                tmpDataLine.set(0, Boolean.TRUE);
                dbgLog.fine("flip the boolean value");
                // shows the error message
                msgVariableSelection.setVisible(true);

                dbgLog.fine("selected(case 2)=" + varCheckbox.isSelected());
                varCheckbox.setValue(Boolean.TRUE);
                dbgLog.fine("selected(case 2)=" + varCheckbox.isSelected());

                msgVariableSelection.setValue("The variable (" + tmpDataLine.get(3)
                        + ") is used for recoding;<br />" + "Check " + tmpDataLine.get(3) + " again <br />"
                        + "and remove its recoded variable(s) first.");

                //FacesContext.getCurrentInstance().renderResponse();

            } else {
                tmpDataLine.set(0, currentState);

                // Case: Not used for recoding
                // Removes this variable
                varCart.remove(varId);

                // Removes this variable from a variable box
                if (removeOption((String) tmpDataLine.get(2), getVarSetAdvStat()) == null) {
                    // Rbox1
                    if (removeOption((String) tmpDataLine.get(2), getAdvStatVarRBox1()) == null) {
                        // Rbox2
                        if (removeOption((String) tmpDataLine.get(2), getAdvStatVarRBox2()) == null) {
                            // Rbox3
                            if (removeOption((String) tmpDataLine.get(2), getAdvStatVarRBox3()) == null) {
                                dbgLog.fine("Unchecked var is not found in these boxes");
                            }
                        }
                    }
                }
                // clear uncommitted recoding data
                clearRecodeTableBlock();

                dbgLog.fine("recoded var is=" + getCurrentRecodeVariableId());
                dbgLog.fine("checkboxSelectUnselectAll(b)=" + checkboxSelectUnselectAll.isSelected());
                if (checkboxSelectUnselectAll.isSelected()) {
                    checkboxSelectUnselectAll.setSelected(false);
                    checkboxSelectUnselectAllSelected = false;
                    //FacesContext.getCurrentInstance().renderResponse();
                    dbgLog.fine("checkboxSelectUnselectAll(a)=" + checkboxSelectUnselectAll.isSelected());
                }

            }

        }
        // hide the download button and
        // show the create button
        dwnldButton.setRendered(true);
        dwnloadSubsetButton.setRendered(false);

        // Checkes the number of the currently selected variables and 
        // if positive, enable command buttons; disable them otherwise
        if (!varCart.isEmpty()) {
            // enable buttons
            activateButtons();
        } else {
            // disable buttons
            deactivateButtons();
            // reset recode field
        }
        dbgLog.fine("***** updateCheckBoxState:ends here *****");
    }

    /**
     * ice:outputText component that is under the subsetting instruction
     * to show an error message when a base-variable for a recoded variable
     * is unchecked.  Exposed to the subsetting page and 
     * the component id is the same as this property
     */
    private com.icesoft.faces.component.ext.HtmlOutputText msgVariableSelection = new com.icesoft.faces.component.ext.HtmlOutputText();

    /**
     * Getter for property msgVariableSelection
     *
     * @return    an unchecked-error message 
     */
    public com.icesoft.faces.component.ext.HtmlOutputText getMsgVariableSelection() {
        return msgVariableSelection;
    }

    /**
     * Setter for property msgVariableSelection
     *
     * @param txt    an uncheck-error message to be displayed
     */
    public void setMsgVariableSelection(com.icesoft.faces.component.ext.HtmlOutputText txt) {
        this.msgVariableSelection = txt;
    }

    /**
     * Rests message components that display a wrong-variable-selection 
     * error messages
     */
    public void resetMsgVariableSelection() {
        dbgLog.fine("***** resetMsgVariableSelection: start *****");
        msgVariableSelection.setVisible(false);
        msgVariableSelection.setValue(" ");
        dbgLog.fine("***** resetMsgVariableSelection: end *****");
    }

    /**
     * Enables command buttons in the subsetting page after 
     * at least one variable selected by an end-user
     */
    public void activateButtons() {
        dwnldButton.setDisabled(false);
        recodeButton.setDisabled(false);
        moveRecodeVarBttn.setDisabled(false);
        edaButton.setDisabled(false);
        advStatButton.setDisabled(false);
    }

    /**
     * Disables command buttons in the subsetting page until 
     * at least one variable is selected by an end-user
     */
    public void deactivateButtons() {
        dwnldButton.setDisabled(true);
        recodeButton.setDisabled(true);
        moveRecodeVarBttn.setDisabled(true);
        edaButton.setDisabled(true);
        advStatButton.setDisabled(true);
    }

    // -----------------------------------------------------------------------
    // Summary Statistics
    // -----------------------------------------------------------------------

    /**
     * A Collection of summary statistics of each variable in the
     * requested data file.  Used in the recoding-GUI rendering process
     */
    private Collection<SummaryStatistic> summaryStatistics;

    /**
     * Getter for property summaryStatistics
     * 
     * @return    a Collection of summaryStatistic objects
     */
    public Collection<SummaryStatistic> getSummaryStatistics() {
        return this.summaryStatistics;
    }

    /**
     * Setter for property summaryStatistics
     * 
     * @param summaryStatistics    a Collection of summaryStatistic objects
     */
    public void setSummaryStatistics(Collection<SummaryStatistic> summaryStatistics) {
        this.summaryStatistics = summaryStatistics;
    }

    /**
     * A Collection of category data of each variable in the 
     * requested data file.   Used in the recoding-GUI rendering proces
     */
    private Collection<VariableCategory> categories;

    /**
     * Getter for property categories
     * 
     * @return    a Collection of VariableCategory objects
     */
    public Collection<VariableCategory> getCategories() {
        return this.categories;
    }

    /**
     * Setter for property categories
     * 
     * @param categories    A Collection of VariableCategory objects
     */
    public void setCategories(Collection<VariableCategory> categories) {
        this.categories = categories;
    }

    // -----------------------------------------------------------------------
    // data for the Variable Table
    // -----------------------------------------------------------------------

    /**
     * ArrayList object that stores major metadata of all variables in 
     * the requested data file and backs the value attribute of 
     * h:dataTable (id = dataTable1) in the variable table of the jsp page.
     */
    private List<Object> dt4Display = new ArrayList<Object>();

    /**
     * Getter for property dt4Display
     *
     * @return    a List object of major metadata of all varibles
     */
    public List<Object> getDt4Display() {
        return (dt4Display);
    }

    /**
     * Setter for property dt4Display
     *
     * @param dt    a List object of major metadata of all variables
     */
    public void setDt4Display(List<Object> dt) {
        dt4Display = dt;
    }

    /**
     * Adds major metadata of all variables in the requested data file into
     * dt4Display.  The six cells of each row are as follows:
     * 
     * boolean: checkbox state,
     * String: variable type,
     * Long:   variable Id,
     * String: variable name,
     * String: variable label,
     * String: blank cell for summary statistics
     * 
     * @see       #dt4Display
     */
    private void initDt4Display() {
        int counter = 0;
        int dbglns = 25;
        for (Iterator el = dataVariables.iterator(); el.hasNext();) {
            DataVariable dv = (DataVariable) el.next();
            counter++;
            if (counter <= dbglns) {
                dbgLog.fine("dtId=" + dtId + " : within initDt4Display: row no=" + counter);
            }

            List<Object> rw = new ArrayList<Object>();
            // 0-th: boolean (checked/unchecked)
            rw.add(new Boolean(false));

            // 1st: variable type
            if (dv.getVariableFormatType().getName().equals("numeric")) {
                if (dv.getVariableIntervalType() == null) {
                    rw.add("Continuous");
                } else {
                    if (dv.getVariableIntervalType().getId().intValue() == 2) {
                        rw.add("Continuous");
                    } else {
                        rw.add("Discrete");
                    }
                }
            } else {
                // Special labels for character variables that represent dates 
                // and times:
                String formatCategory = dv.getFormatCategory();

                if (formatCategory != null) {
                    if (dv.getFormatCategory().toLowerCase().equals("date")) {
                        rw.add("Character (Date Value)");
                    } else if (dv.getFormatCategory().toLowerCase().equals("time")) {
                        rw.add("Character (Time Value)");
                    } else {
                        rw.add("Character");
                    }
                } else {
                    rw.add("Character");
                }
            }

            // 2nd: ID
            rw.add(dv.getId().toString());

            // 3rd: Variable Name
            rw.add(dv.getName());

            // 4th: Variable Label
            if (dv.getLabel() != null) {
                rw.add(dv.getLabel());
            } else {
                rw.add("[label missing]");
            }

            // 5th: summary statistics(blank)
            // the content is generated by an AJAX call upon request
            rw.add("");
            /*
            // 6th: fileorder number
            rw.add(dv.getFileOrder());
             */
            // add a row
            dt4Display.add(rw);
        }
    }

    // <----------------------------------------------------------------------
    // </editor-fold>

    // -----------------------------------------------------------------------
    // Constructor and Init method
    // -----------------------------------------------------------------------
    // <editor-fold desc="Constructor and Init method">
    // defaultstate="collapsed"

    /**
     * The default constructor
     *
     */
    public AnalysisPage() {

    }

    /**
     * Returns a reference to the application-scoped bean
     * 
     * @return a bean that stores zelig-model-related information
     */
    public AnalysisApplicationBean getAnalysisApplicationBean() {
        return (AnalysisApplicationBean) getBean("AnalysisApplicationBean");
    }

    /**
     * Prepares the state-keeping html components 
     * and their backing java objects for rendering SubsettingPage.xhtml
     * 
     */
    public void init() {
        dbgLog.fine("\n***** init():start " + "(edu.harvard.iq.dvn.core.web.subsetting.AnalysisPage) *****");
        super.init();
        try {
            // sets default values to html components
            _init();

            dbgLog.fine("pass _init() in init()");
            // gets the FacesContext instance
            FacesContext cntxt = FacesContext.getCurrentInstance();

            // gets the ExternalContext
            ExternalContext exCntxt = FacesContext.getCurrentInstance().getExternalContext();

            // gets session data from the ExternalContext
            Map<String, Object> sessionMap = exCntxt.getSessionMap();

            dbgLog.finer("\ncontents of RequestParameterMap:\n" + exCntxt.getRequestParameterMap());
            dbgLog.finer("\ncontents of SessionMap:\n" + sessionMap);

            // gets the request header data
            Map<String, String> rqustHdrMp = exCntxt.getRequestHeaderMap();

            dbgLog.fine("\nRequest Header Values Map:\n" + rqustHdrMp);
            dbgLog.fine("\nRequest Header Values Map(user-agent):" + rqustHdrMp.get("user-agent"));

            // gets an end-user's browser type
            if (isBrowserFirefox(rqustHdrMp.get("user-agent"))) {
                dbgLog.fine("user's browser is firefox");
                browserType = "Firefox";
            } else {
                browserType = "notFirefox";
            }

            // gets the current view state value (for post-back-checking)
            String currentViewStateValue = exCntxt.getRequestParameterMap()
                    .get(ResponseStateManager.VIEW_STATE_PARAM);

            dbgLog.fine("ViewState value=" + currentViewStateValue);
            dbgLog.fine("VDCRequestBean: current VDC URL =" + getVDCRequestBean().getCurrentVDCURL());

            // Stores the URL of the requested study 
            setStudyURL(getVDCRequestBean().getCurrentVDCURL());

            dbgLog.fine("VDCRequestBean: studyId =" + getVDCRequestBean().getStudyId());
            dbgLog.fine("VDCRequestBean =" + getVDCRequestBean());

            //             dbgLog.fine("selected tab(init())="+getTabSet1().getSelected());

            // set tab if it was it was sent as pamameter or part of request bean
            //            if (getTab() != null) {
            //                getTabSet1().setSelected(getTab());
            //                dbgLog.fine("getTab()= "+getTab());
            //            } else if (getVDCRequestBean().getSelectedTab() != null) {
            //                dbgLog.fine("tab from the requestBean="+getVDCRequestBean().getSelectedTab());
            //            
            //                getTabSet1().setSelected(getVDCRequestBean().getSelectedTab());
            //            }

            /*
            // Deletes session-scoped objects if this page is rendered 
            // for the first time, i.e. not post-back
            */
            if (currentViewStateValue == null || getVDCRequestBean().getDtId() != null) {
                // The first time visit to the SubsettingPage.xhtml

                List<String> sessionObjects = new ArrayList<String>();

                Collections.addAll(sessionObjects, "dt4Display", "varCart", "varSetAdvStat",
                        "groupPanel8belowRendered", "advStatVarRBox1", "advStatVarRBox2", "advStatVarRBox3",
                        "setxDiffVarBox1", "setxDiffVarBox2", "checkboxSelectUnselectAllSelected",
                        "checkboxSelectUnselectAllRendered", "currentModelName", "currentRecodeVariableId",
                        "currentRecodeVariableName", "recodedVarSet", "recodeSchema", "baseVarToDerivedVar",
                        "derivedVarToBaseVar", "recodeVarNameSet", "selectedNoRows", "msgEdaButtonTxt",
                        "msgDwnldButtonTxt", "msgAdvStatButtonTxt", "gridPanelModelInfoBox", "resultInfo",
                        "wrapSubsettingInstructionRendered", "wrapNonSubsettingInstructionRendered",
                        "modelHelpLinkURL");

                for (String obj : sessionObjects) {
                    if (sessionMap.containsKey(obj)) {
                        cntxt.getExternalContext().getSessionMap().remove(obj);
                    }
                }

                dbgLog.fine("left-over objects of the previous session" + " have been removed");
            }

            // Gets the datatable Id if we're coming from editVariabePage
            if (dtId == null) {
                dtId = getVDCRequestBean().getDtId();
                dbgLog.fine("dtId(null case: came from editVariablePage)=" + dtId);
            }

            // we need to create the VariableServiceBean
            if (dtId == null) {
                // dtId is not available case
                dbgLog.severe("ERROR: AnalysisPage.java: without dtId supplied");
                throw new FacesException("AnalysisPage called without DataTable id");
            }

            dbgLog.fine("Init() enters non-null-dtId case: dtId=" + dtId);
            // Gets the requested data table by its Id
            dataTable = variableService.getDataTable(dtId);

            if (versionNumber == null) {
                versionNumber = getVDCRequestBean().getStudyVersionNumber();
            }

            // Exposes the data file name to SubsettingPage.xhtml
            setFileName(dataTable.getStudyFile().getFileName(versionNumber));
            // (if versionNumber is still null at this point, getFileName()
            // will default to the latest version of the file metadata -- L.A.

            dbgLog.fine("file Name=" + fileName);

            // Retrieves each var's data from the data table
            // and saves them in Collection<DataVariable> dataVariables
            dataVariables.addAll(dataTable.getDataVariables());

            dbgLog.fine("pass the addAll line");

            // Gets VDCUser-related data
            VDCUser user = null;
            if (getVDCSessionBean().getLoginBean() != null) {
                user = getVDCSessionBean().getLoginBean().getUser();
            }

            VDC vdc = getVDCRequestBean().getCurrentVDC();
            dbgLog.fine("VDCUser instnce=" + user);
            dbgLog.fine("VDC instnce=" + vdc);

            //  Gets the StudyFile object via the dataTable object.
            //  This StudyFile determines whether
            //  Subsetting functionalities are rendered or not
            //  in SubsettingPage.xhtml
            dbgLog.fine("checking this end-user's permission status");
            StudyFile sf = dataTable.getStudyFile();
            HttpServletRequest request = (HttpServletRequest) this.getExternalContext().getRequest();

            if (sf.isSubsetRestrictedForUser(user, getVDCSessionBean().getIpUserGroup())) {
                dbgLog.fine("restricted=yes: this user " + "does not have the subsetting permission");
                subsettingPageAccess = Boolean.FALSE;
                txtNonSubsettingInstruction.setRendered(true);
                wrapNonSubsettingInstructionRendered = Boolean.TRUE;
                wrapSubsettingInstructionRendered = Boolean.FALSE;
                hideSubsettingFunctions();
            } else {
                // Sets the state of the Subsetting Page to subsettable
                subsettingPageAccess = Boolean.TRUE;
                // sets the default rendering state of the checkbox 
                // checkboxSelectUnselectAll shown (TRUE)
                checkboxSelectUnselectAllRendered = Boolean.TRUE;
                checkboxSelectUnselectAllSelected = Boolean.FALSE;

                wrapNonSubsettingInstructionRendered = Boolean.FALSE;
                wrapSubsettingInstructionRendered = Boolean.TRUE;
                dbgLog.fine("restricted=no: " + "this user has the subsetting permission");
            }

            dbgLog.fine("Number of vars in this data table(" + dtId + ")=" + dataTable.getVarQuantity());

            // Sets data for the variable table in the subsetting page.
            // Variable data are stored in List<Object> dt4Display
            if (!sessionMap.containsKey("dt4Display")) {
                // dt4Display does not exist => 
                // the page was rendered for the first time
                // not a post-back case
                dbgLog.fine("This is the 1st-time visit to this page:"
                        + "(dt4Display does not exist in the session map)");
                // Fills List<Object> dt4Display with data
                // and newly creaded data 
                initDt4Display();

                dbgLog.fine("how many variables in dt4Display=" + getDt4Display().size());

                // Adds state-keeping objects to the session Map
                // 
                // List<Object>: The data for the variable table
                sessionMap.put("dt4Display", dt4Display);

                // Map<String, String>: The currently selected variables
                sessionMap.put("varCart", varCart);

                // List<SelectItem> varSetAdvStat: user-selected
                // variables behind the LHS variable list box
                sessionMap.put("varSetAdvStat", varSetAdvStat);
                dbgLog.fine("varSetAdvStat:\n" + varSetAdvStat);
                // PanelGroup component that shows/hides the pane for
                // the advanced statistics. 
                // The rendered attribute of this PanelGroup object
                // must be state-kept
                // deprecated: serialization-unsafe approach
                // sessionMap.put("groupPanel8below", groupPanel8below);
                // Hides the pane
                groupPanel8belowRendered = Boolean.FALSE;
                sessionMap.put("groupPanel8belowRendered", groupPanel8belowRendered);

                // h:panelGrid component that contains the model help
                // information box in the advanced statistics pane.
                // The rendered attribute of this HtmlPanelGrid object
                // must be state-kept
                // deprecated: 
                // sessionMap.put("gridPanelModelInfoBox",
                //    gridPanelModelInfoBox);

                /**/
                // Hides the pane
                gridPanelModelInfoBoxRendered = Boolean.FALSE;
                sessionMap.put("gridPanelModelInfoBoxRendered", gridPanelModelInfoBoxRendered);

                // to do
                // accessors: get/set
                // JSP rendered="#{AnalysisPage.gridPanelModelInfoBoxRendered}"

                // List<SelectItem> advStatVarRBox1
                sessionMap.put("advStatVarRBox1", advStatVarRBox1);
                sessionMap.put("advStatVarRBox2", advStatVarRBox2);
                sessionMap.put("advStatVarRBox3", advStatVarRBox3);

                //                    sessionMap.put("lastSimCndtnSelected", "0");

                // ice:selectBooleanCheckbox
                // 
                // Saves the selected attribute

                sessionMap.put("checkboxSelectUnselectAllSelected", checkboxSelectUnselectAllSelected);

                // Saves the rendered attribute

                sessionMap.put("checkboxSelectUnselectAllRendered", checkboxSelectUnselectAllRendered);

                sessionMap.put("wrapSubsettingInstructionRendered", wrapSubsettingInstructionRendered);
                sessionMap.put("wrapNonSubsettingInstructionRendered", wrapNonSubsettingInstructionRendered);

                // String selectedNoRows
                selectedNoRows = Integer.toString(INITIAL_ROW_NO);
                //howManyRowsOptions.setSelectedValue(selectedNoRows);
                howManyRows.setValue(selectedNoRows);
                sessionMap.put("selectedNoRows", selectedNoRows);

                dbgLog.fine("selectedNoRows=" + selectedNoRows);
                dbgLog.fine("1st time visit: " + "selected value for howManyRows=" + howManyRows.getValue());
                currentTabIndex = 0;
            } else {
                // Postback cases (not 1st-time visit to this page)
                // Applies the stored data to the key page-scoped objects

                dbgLog.fine("Postback(non-1st-time) case: " + "dt4Display was found in the session map=>");

                // Gets the stored object backing the value attribute 
                // of h:dataTable for the variable table 
                setDt4Display((List<Object>) cntxt.getExternalContext().getSessionMap().get("dt4Display"));

                // Gets the stored object that records 
                // the currently selected variables 
                varCart = (Map<String, String>) sessionMap.get("varCart");
                dbgLog.fine("varCart:\n" + varCart);

                // Gets the stored object backing the items attribute of 
                // ice:selectManyListbox for the LHS list-box component, which is
                // located in each tab
                varSetAdvStat = (List<SelectItem>) sessionMap.get("varSetAdvStat");
                dbgLog.fine("varSetAdvStat:\n" + varSetAdvStat);

                // Gets the stored object backing the items attribute of
                // ice:selectManyListbox for the 1st RHS variable box
                // located in the advanced statistics tab
                advStatVarRBox1 = (List<SelectItem>) sessionMap.get("advStatVarRBox1");

                // ditto (2nd)
                advStatVarRBox2 = (List<SelectItem>) sessionMap.get("advStatVarRBox2");

                // ditto (3rd)
                advStatVarRBox3 = (List<SelectItem>) sessionMap.get("advStatVarRBox3");
                dbgLog.fine("advStatVarRBox1:\n" + advStatVarRBox1);
                dbgLog.fine("advStatVarRBox2:\n" + advStatVarRBox2);
                dbgLog.fine("advStatVarRBox3:\n" + advStatVarRBox3);

                //                    radioButtonGroup1DefaultOptions.setSelectedValue( (String)sessionMap.get("lastSimCndtnSelected"));
                //                        dbgLog.fine("lastSimCndtnSelected= "+ sessionMap.get("lastSimCndtnSelected"));

                // Gets the stored object backing the items attribute
                // of ice:selectOneMenu for the 1st setx variable selector
                setxDiffVarBox1 = (List<SelectItem>) sessionMap.get("setxDiffVarBox1");

                // ditto (2nd)
                setxDiffVarBox2 = (List<SelectItem>) sessionMap.get("setxDiffVarBox2");

                // String object backing the currently selected model name
                currentModelName = (String) sessionMap.get("currentModelName");

                dbgLog.fine("\nSelected model name(after post-back)=" + currentModelName + "\n");

                // new approach
                // Updates the following two attributes at least
                // class method  tag attr
                // setSelected   selectedValue
                // setRendered   rendered

                // Gets the selected attribute
                checkboxSelectUnselectAllSelected = (Boolean) sessionMap.get("checkboxSelectUnselectAllSelected");
                checkboxSelectUnselectAll.setSelected(checkboxSelectUnselectAllSelected);

                // Gets the rendered attribute

                checkboxSelectUnselectAllRendered = (Boolean) sessionMap.get("checkboxSelectUnselectAllRendered");
                checkboxSelectUnselectAll.setRendered(checkboxSelectUnselectAllRendered);

                wrapSubsettingInstructionRendered = (Boolean) sessionMap.get("wrapSubsettingInstructionRendered");
                wrapNonSubsettingInstructionRendered = (Boolean) sessionMap
                        .get("wrapNonSubsettingInstructionRendered");

                // Gets the stored object backing the selected attribute
                // of ice:selectOneMenu for the menu of choosing
                // an option of how many row per table
                selectedNoRows = (String) sessionMap.get("selectedNoRows");
                dbgLog.fine("post-back case: " + "returned the selected value for howManyRows=" + selectedNoRows);

                howManyRows.setValue(selectedNoRows);

                dbgLog.fine("post-back case:" + " selected value for howManyRows=" + howManyRows.getValue());

                if (currentRecodeVariableId == null) {
                    dbgLog.fine("currentRecodeVariableId is null");
                } else {
                    dbgLog.fine("currentRecodeVariableId=" + currentRecodeVariableId);
                }
                dbgLog.fine("currentRecodeVariableId: " + "received value from sessionMap="
                        + (String) sessionMap.get("currentRecodeVariableId"));

                currentRecodeVariableId = (String) sessionMap.get("currentRecodeVariableId");

                dbgLog.fine("new currentRecodeVariableId=" + currentRecodeVariableId);

                // Gets the stored object backing the rendered attribute
                // of PaneGroup for groupPanel8below
                groupPanel8belowRendered = (Boolean) sessionMap.get("groupPanel8belowRendered");
                dbgLog.fine("groupPanel8belowRendered(map)=" + sessionMap.get("groupPanel8belowRendered"));
                dbgLog.fine("groupPanel8belowRendered(result)=" + groupPanel8belowRendered);
                // deprecated approach
                // Gets the stored object backing the binding attribute of
                // PanelGroup for groupPanel8below
                // cntxt.getExternalContext().getSessionMap()
                // .get("groupPanel8below"));

                // Gets the stored object backing the value attribute of
                // h:outputText (id=recodeHdrVariable) for the currently 
                // selected recode variable name that is used in the 
                // column header of the recode variable editing table
                if (!sessionMap.containsKey("currentRecodeVariableName")) {
                    sessionMap.put("currentRecodeVariableName", currentRecodeVariableName);
                } else {
                    currentRecodeVariableName = (String) sessionMap.get("currentRecodeVariableName");
                }

                dbgLog.fine("new currentRecodeVariableName=" + currentRecodeVariableName);
                // deprecated (component-binding is used now)
                // Gets the stored object backing the value attribute
                // of h:inputText for the label of the recode variable
                // (id= recodeTargetVarLabel)
                /*
                if (!sessionMap.containsKey("recodeVariableLabel")) {
                    sessionMap.put("recodeVariableLabel",
                        recodeVariableLabel);
                } else {
                    recodeVariableLabel = (String) sessionMap
                        .get("recodeVariableLabel");
                }
                */

                // Gets the stored object backing the value attribute of
                // h:dataTable for the recoding table 
                // whose id is "recodeTable"

                if (!sessionMap.containsKey("recodeDataList")) {
                    sessionMap.put("recodeDataList", recodeDataList);
                } else {
                    recodeDataList = (List<Object>) sessionMap.get("recodeDataList");
                }

                // Gets the stored object for recodeSchema that 
                // stores each recode variable's recodeDataList
                // as a hash table. Not exposed to SubsettingPage.xhtml
                if (!sessionMap.containsKey("recodeSchema")) {
                    sessionMap.put("recodeSchema", recodeSchema);
                } else {
                    recodeSchema = (Map<String, List<Object>>) sessionMap.get("recodeSchema");
                }

                // Gets the stored object for the value attribute
                // of h:dataTable for the table of recode variables
                // whose id is "recodedVarTable"
                if (!sessionMap.containsKey("recodedVarSet")) {
                    sessionMap.put("recodedVarSet", recodedVarSet);
                } else {
                    recodedVarSet = (List<Object>) sessionMap.get("recodedVarSet");
                }

                // Gets the stored object for derivedVarToBaseVar
                // that maps a new variable to its base one.
                // No exposed to SubsettingPage.xhtml
                if (!sessionMap.containsKey("derivedVarToBaseVar")) {
                    sessionMap.put("derivedVarToBaseVar", derivedVarToBaseVar);
                } else {
                    derivedVarToBaseVar = (Map<String, String>) sessionMap.get("derivedVarToBaseVar");
                }

                // Gets the stored object for baseVarToDerivedVar
                // that maps a base variable to its derived variables.
                // Not exposed to SubsettingPage.xhtml
                if (!sessionMap.containsKey("baseVarToDerivedVar")) {
                    sessionMap.put("baseVarToDerivedVar", baseVarToDerivedVar);
                } else {
                    baseVarToDerivedVar = (Map<String, Set<String>>) sessionMap.get("baseVarToDerivedVar");
                }

                // Gets the stored object for recodeVarNameSet that
                // checks the uniqueness of a name 
                // for a new recode-variable.
                // Not exposed to SubsettingPage.xhtml
                if (!sessionMap.containsKey("recodeVarNameSet")) {
                    sessionMap.put("recodeVarNameSet", recodeVarNameSet);
                } else {
                    recodeVarNameSet = (Set<String>) sessionMap.get("recodeVarNameSet");
                }

                resetMsgMoveRecodeVarBttn();
                // Resets the properties (rendered and text) of
                // msgSaveRecodeBttn (ice:outputText) that shows
                // error messages for the action of SaveRecodeBttn
                resetMsgSaveRecodeBttn();

                // Rests the properties (rendered and text) of
                // msgVariableSelection (ice:outputText) that shows
                // error message when the base varaible for
                // a recoded variable is un-selected in the variable table
                resetMsgVariableSelection();

                // Gets the stored object backing msgDwnldButtonTxt that
                // shows error messages for the action of dwnldButton
                if (!sessionMap.containsKey("msgDwnldButtonTxt")) {
                    sessionMap.put("msgDwnldButtonTxt", msgDwnldButtonTxt);
                } else {
                    msgDwnldButtonTxt = (String) sessionMap.get("msgDwnldButtonTxt");
                }
                // Hides the error message text for dwnldButton
                msgDwnldButton.setVisible(false);

                // Gets the stored object backing msgEdaButtonTxt that
                // shows error messages for the action of edaButton
                if (!sessionMap.containsKey("msgEdaButtonTxt")) {
                    sessionMap.put("msgEdaButtonTxt", msgEdaButtonTxt);
                } else {
                    msgEdaButtonTxt = (String) sessionMap.get("msgEdaButtonTxt");
                }
                // Hides the error message text for edaButton
                msgEdaButton.setVisible(false);

                // Gets the stored object backing msgAdvStatButtonTxt that
                // shows error messages for the action of edaButton
                if (!sessionMap.containsKey("msgAdvStatButtonTxt")) {
                    sessionMap.put("msgAdvStatButtonTxt", msgAdvStatButtonTxt);
                } else {
                    msgAdvStatButtonTxt = (String) sessionMap.get("msgAdvStatButtonTxt");
                }
                // Hides the error message text for edaButton
                msgAdvStatButton.setVisible(false);

                //                    if (sessionMap.containsKey("modelHelpLinkURL")) {
                //                        dbgLog.fine("modelHelpLinkURL="+sessionMap.get("modelHelpLinkURL"));
                //                        modelHelpLinkURL= (String) sessionMap.get("modelHelpLinkURL");
                //                    }

                // end of post-back cases
            }

            //}

            /*
            if (versionNumber == null) {
                thisStudyVersion = thisStudy.getReleasedVersion();
            } else {
                thisStudyVersion = thisStudy.getStudyVersionByNumber(versionNumber);
            }
                
            if (thisStudyVersion == null) {
                dbgLog.severe("ERROR: Could not find a valid Version of this study");
                throw new FacesException("Could not find a valid Version of this study");
            }
                
               */
            Study thisStudy = dataTable.getStudyFile().getStudy();
            if (versionNumber == null) {
                studyUI = new StudyUI(thisStudy);
            } else {
                StudyVersion thisStudyVersion = thisStudy.getStudyVersionByNumber(versionNumber);

                if (thisStudyVersion == null) {
                    dbgLog.severe("ERROR: Could not find a valid Version of this study");
                    throw new FacesException("Could not find a valid Version of this study, studyId = "
                            + thisStudy.getId() + " versionNumber= " + versionNumber);
                }
                studyUI = new StudyUI(thisStudyVersion, user);
            }

            dbgLog.finer("\nSpec Map:\n" + getAnalysisApplicationBean().getSpecMap());
            dbgLog.finer("\nMenu Option List:\n" + getAnalysisApplicationBean().getModelMenuOptions());
            dbgLog.finer("\ncontents of the cart:\n" + varCart);

        } catch (Exception e) {
            dbgLog.severe("AnalysisPage Initialization Failure");
            e.printStackTrace();
            throw e instanceof FacesException ? (FacesException) e : new FacesException(e);
        } // end of try-catch block

        //            dbgLog.fine("init(): current tab id=" + tabSet1.getSelected());

        this.setDvnVersionNumber(versionPageClass.getVersionNumber());

        dbgLog.fine("***** init():end *****\n\n");
    }

    // end of doInit() -------------------------------------------------------

    public void preprocess() {
    }

    public void prerender() {
    }

    public void destroy() {
    }

    // </editor-fold>

    // -----------------------------------------------------------------------
    // Access control methods
    // -----------------------------------------------------------------------

    public String gotoEditVariableAction() {
        String dvFilter = "";
        for (SelectItem item : getVarSetAdvStat()) {
            dvFilter += (String) item.getValue() + ",";
        }

        getVDCRequestBean().setDtId(dtId);
        getVDCRequestBean().setDvFilter(dvFilter);

        return "/study/ditVariablePage?faces-redirect=true"; //"editVariable";
    }

    public boolean isEditVariableActionRendered() {
        boolean render = false;

        if (getVDCSessionBean().getLoginBean() != null) {
            Study study = dataTable.getStudyFile().getStudy();
            boolean authorized = study.isUserAuthorizedToEdit(getVDCSessionBean().getLoginBean().getUser());
            boolean locked = study.getStudyLock() != null;

            render = authorized && !locked;
        }

        return render;
    }

    // hide subsetting functions according to the user's status
    /**
     * Hides the subsetting related components when an end-user does not 
     * have permission to subset a data file
     *
     */
    public void hideSubsettingFunctions() {
        // Sets the rendered attribute of the following components as follows:

        // 1. Hides tabSet above the variable table
        tabSet1.setRendered(false);

        // 2. Hides the subsetting intruction text
        //txtSubsettingInstruction.setRendered(false);

        // 3. Shows the non-Subsetting intruction text
        //txtNonSubsettingInstruction.setRendered(true);

        // 4. Hides the select-all checkbox in the header(1st column) of 
        //    the variable table
        checkboxSelectUnselectAll.setRendered(false);
        // Stores this hide state in a Boolean object
        checkboxSelectUnselectAllRendered = Boolean.FALSE;

        // 5. Hides the variable-checkboxes in the 1st column of 
        //    the variable table
        varCheckbox.setRendered(false);

        // 6. Hides the title of the recoded-var table
        recodedVarTableTitle.setRendered(false);

        // 7. Hides the panel grid that contains the recoded-variable table
        //pgRecodedVarTable.setRendered(false);
        groupPanelRecodeTableArea.setRendered(false);
    }

    // <----------------------------------------------------------------------
    //  service-request-related methods
    // <----------------------------------------------------------------------
    // <editor-fold desc="service-request-related methods">

    /**
     * Returns a List object that stores major metadata for all variables 
     * selected by an end-user
     *
     * @return    List of DataVariable objects that stores metadata
     */
    public List<DataVariable> getDataVariableForRequest() {

        List<DataVariable> dvs = new ArrayList<DataVariable>();
        for (Iterator el = dataVariables.iterator(); el.hasNext();) {
            DataVariable dv = (DataVariable) el.next();

            // dv.;
            dv.getCategories();

            // dv.getD

            // dv.get

            for (DataVariableMapping dvm : dv.getDataVariableMappings()) {

            }

            for (VariableCategory v : dv.getCategories()) {

            }

            String keyS = dv.getId().toString();

            if (varCart.containsKey(keyS)) {
                dvs.add(dv);
            }
        }
        return dvs;
    }

    /**
     * Returns the name of a given variable whose id is known.
     * Because dt4Display is not a HashMap but a List, 
     * loop-through is necessary
     *
     * @param varId    the id of a given variable
     * @return    the name of a given variable
     */
    public String getVariableNamefromId(String varId) {

        for (int i = 0; i < dt4Display.size(); i++) {
            if (((String) ((ArrayList) dt4Display.get(i)).get(2)).equals(varId)) {
                return (String) ((ArrayList) dt4Display.get(i)).get(3);

            }
        }
        return null;
    }

    /**
     * Returns the label of a given variable whose id is known.
     * Because dt4Display is not a HashMap but a List, 
     * loop-through is necessary
     *
     * @param varId    the id of a given variable
     * @return    the label of a given variable
     */
    public String getVariableLabelfromId(String varId) {

        for (int i = 0; i < dt4Display.size(); i++) {
            if (((String) ((ArrayList) dt4Display.get(i)).get(2)).equals(varId)) {
                return (String) ((ArrayList) dt4Display.get(i)).get(4);
            }
        }
        return null;
    }

    /**
     * Returns the file-order of a given variable whose id is known.
     * Because dt4Display is not a HashMap but a List, 
     * loop-through is necessary
     *
     * @param varId    the id of a given variable
     * @return    the file-order number of a given variable
     */
    /*
    public String getVariableFileOderfromId(String varId) {
        
    for (int i = 0; i < dt4Display.size(); i++) {
        if (((String) ((ArrayList) dt4Display.get(i)).get(2)).equals(varId)) {
            return (String) ((ArrayList) dt4Display.get(i)).get(6);
        
        }
    }
    return null;
    }
    */
    /**
     * Gets the row of metadata of a variable whose Id is given by a String
     * object
     *
     * @param varId    a given variable's ID as a String object
     * @return    a DataVariable instance that contains major metadata of the
     *            requested variable
     */
    public DataVariable getVariableById(String varId) {

        DataVariable dv = null;
        for (Iterator el = dataVariables.iterator(); el.hasNext();) {
            dv = (DataVariable) el.next();
            // Id is Long
            if (dv.getId().toString().equals(varId)) {
                return dv;
            }
        }
        return dv;
    }

    /**
     * 
     *
     * @param dvs   
     * @return      
     */
    public List<String> generateVariableIdList(List<String> dvs) {
        List<String> variableIdList = new ArrayList<String>();
        if (dvs != null) {
            for (String el : dvs) {
                variableIdList.add("v" + el);
            }
        }
        return variableIdList;
    }

    /**
     * 
     *
     * @param     
     * @return    
     */

    public List<String> getVariableListForRequest() {
        List<String> variableList = new ArrayList();
        if (getDataVariableForRequest() != null) {
            Iterator iter = getDataVariableForRequest().iterator();
            while (iter.hasNext()) {
                DataVariable dv = (DataVariable) iter.next();
                variableList.add(dv.getId().toString());
            }
        }
        return variableList;
    }

    public List<String> getVariableIdListForRequest() {
        List<String> ids = generateVariableIdList(getVariableListForRequest());
        return ids;
    }

    public String getVariableIdsForRequest() {
        String variableIdString = "";
        List<String> vi = new ArrayList<String>();

        if (getDataVariableForRequest() != null) {
            Iterator iter = getDataVariableForRequest().iterator();
            while (iter.hasNext()) {
                DataVariable dv = (DataVariable) iter.next();
                vi.add(dv.getId().toString());
            }
            variableIdString = StringUtils.join(vi, ",");
        }

        return variableIdString;

    }

    /**
     * 
     *
     * @param     
     * @return    
     */

    public List<String> getVariableOrderForRequest() {
        List<String> variableOrder = new ArrayList();
        if (getDataVariableForRequest() != null) {
            Iterator iter = getDataVariableForRequest().iterator();
            while (iter.hasNext()) {
                DataVariable dv = (DataVariable) iter.next();
                // the susbsetting parameter starts from 1 not 0,
                // add 1 to the number
                variableOrder.add(Integer.toString(dv.getFileOrder() + 1));
            }
        }
        return variableOrder;
    }

    /**
     * 
     *
     * @return    A List of file-order numbers
     */
    public List<Integer> getFileOrderForRequest() {
        List<DataVariable> dvs = new ArrayList<DataVariable>();
        List<Integer> fileOrderForRequest = new ArrayList<Integer>();
        for (Iterator el = dataVariables.iterator(); el.hasNext();) {
            DataVariable dv = (DataVariable) el.next();
            String keyS = dv.getId().toString();
            if (varCart.containsKey(keyS)) {
                fileOrderForRequest.add(dv.getFileOrder());
            }
        }
        Collections.sort(fileOrderForRequest);
        return fileOrderForRequest;
    }

    /**
     * 
     *
     * @return    
     */
    public Map<Long, List<List<Integer>>> getSubsettingMetaData(Long noRecords) {

        Map<Long, List<List<Integer>>> varMetaSet = new LinkedHashMap<Long, List<List<Integer>>>();

        List<DataVariable> dvs = getDataVariableForRequest();

        //populate the initial, empty varMetaSet: 

        for (Long count = new Long((long) 0); count < noRecords; count++) {
            List<List<Integer>> cardVarMetaSet = new LinkedList<List<Integer>>();
            varMetaSet.put((count + 1), cardVarMetaSet);
        }

        if (dvs != null) {
            for (int i = 0; i < dvs.size(); i++) {

                DataVariable dv = dvs.get(i);

                List<Integer> varMeta = new ArrayList<Integer>();

                varMeta.add(Integer.valueOf(dv.getFileStartPosition().toString()));
                varMeta.add(Integer.valueOf(dv.getFileEndPosition().toString()));
                // raw data: 1: numeric 2: character=> 0: numeric; 1 character
                varMeta.add(Integer.valueOf((int) (dv.getVariableFormatType().getId() - 1)));

                if (dv.getNumberOfDecimalPoints() == null) {
                    varMeta.add(0);
                } else if (dv.getNumberOfDecimalPoints().toString().equals("")) {
                    varMeta.add(0);
                } else {
                    varMeta.add(Integer.valueOf(dv.getNumberOfDecimalPoints().toString()));
                }

                Long recordSegmentNumber = dv.getRecordSegmentNumber();

                //if ( varMetaSet.get(recordSegmentNumber) == null ) {
                //    List<List<Integer>> cardVarMetaSet = new LinkedList<List<Integer>>();
                //    varMetaSet.put(recordSegmentNumber, cardVarMetaSet); 
                //}

                varMetaSet.get(recordSegmentNumber).add(varMeta);

            }
        }

        return varMetaSet;
    }

    public Map<String, String> getValueTableForRequestedVariable(DataVariable dv) {
        List<VariableCategory> varCat = new ArrayList<VariableCategory>();
        varCat.addAll(dv.getCategories());
        Map<String, String> vl = new HashMap<String, String>();
        for (VariableCategory vc : varCat) {
            vl.put(vc.getValue(), vc.getLabel());
        }
        return vl;
    }

    public Map<String, List<String>> getCategoryValueOrdersForAllRequestedVariables() {
        List<DataVariable> dvs = getDataVariableForRequest();
        Map<String, List<String>> catOrderMap = null;

        for (DataVariable dv : dvs) {

            List<VariableCategory> varCat = new ArrayList<VariableCategory>();
            varCat.addAll(dv.getCategories());

            List<String> orderedValuesList = new ArrayList<String>(varCat.size());
            // Fill the orderedValuesList with NULLs to capacity: 
            // (this way we can use .set on arbitrary index locations, before 
            // the list gets fully populated). 

            for (int i = 0; i < varCat.size(); i++) {
                orderedValuesList.add(null);
            }
            for (VariableCategory vc : varCat) {
                if (!vc.isMissing()) {
                    dbgLog.info("adding category value \"" + vc.getValue() + "\" with the defined order "
                            + vc.getOrder());
                    try {
                        orderedValuesList.set(vc.getOrder(), vc.getValue());
                    } catch (IndexOutOfBoundsException ex) {
                        dbgLog.warning(
                                "Could not populate the ordered category values map; \"out of bounds\" exception");
                        return null;
                    }

                }
            }

            if (orderedValuesList.size() > 0) {
                // initialize the map, if this hasn't been done yet:
                if (dv.isOrderedCategorical()) {
                    if (catOrderMap == null) {
                        catOrderMap = new LinkedHashMap<String, List<String>>();
                    }
                    catOrderMap.put("v" + dv.getId(), orderedValuesList);
                }
            }
        }

        return catOrderMap;
    }

    public Map<String, Map<String, String>> getValueTableForRequestedVariables(List<DataVariable> dvs) {
        Map<String, Map<String, String>> vls = new LinkedHashMap<String, Map<String, String>>();
        for (DataVariable dv : dvs) {
            List<VariableCategory> varCat = new ArrayList<VariableCategory>();
            varCat.addAll(dv.getCategories());
            Map<String, String> vl = new HashMap<String, String>();
            for (VariableCategory vc : varCat) {
                if (vc.getLabel() != null) {
                    dbgLog.fine("adding label \"" + vc.getLabel() + "\" for variable v" + dv.getId());
                    vl.put(vc.getValue(), vc.getLabel());
                } else {
                    dbgLog.fine("no label for variable v" + dv.getId());
                }
            }
            if (vl.size() > 0) {
                vls.put("v" + dv.getId(), vl);
            }
        }
        return vls;
    }

    public Map<String, Map<String, String>> getValueTablesOfRecodedVariables() {
        Map<String, Map<String, String>> vls = new LinkedHashMap<String, Map<String, String>>();
        List<String> varId = getRawRecodedVarIdSet();
        for (int i = 0; i < varId.size(); i++) {
            Map<String, String> vl = new HashMap<String, String>();
            // get the outer-list by Id
            List<Object> rdtbl = (List<Object>) recodeSchema.get(varId.get(i));
            // loop through inner lists
            for (int j = 0; j < rdtbl.size(); j++) {
                List<Object> rw = (List<Object>) rdtbl.get(j);
                if (rw.get(2) != null /* Experiment! -- L.A., v3.6 */ && !"".equals((String) rw.get(2))) {
                    vl.put((String) rw.get(1), (String) rw.get(2));
                }
            }
            if (vl.size() > 0) {
                vls.put("v" + varId.get(i), vl);
            }
        }
        return vls;
    }

    public Map<String, Map<String, String>> getValueTablesForAllRequestedVariables() {
        Map<String, Map<String, String>> vls = getValueTableForRequestedVariables(getDataVariableForRequest());
        Map<String, Map<String, String>> vln = getValueTablesOfRecodedVariables();
        vls.putAll(vln);
        return vls;
    }

    public List<String> getRecodedVarIdSet() {
        List<String> vi = new ArrayList<String>();
        for (int i = 0; i < recodedVarSet.size(); i++) {
            List<Object> rvs = (List<Object>) recodedVarSet.get(i);
            vi.add("v" + (String) rvs.get(2));
        }
        return vi;
    }

    public List<String> getRawRecodedVarIdSet() {
        List<String> vi = new ArrayList<String>();
        for (int i = 0; i < recodedVarSet.size(); i++) {
            List<Object> rvs = (List<Object>) recodedVarSet.get(i);
            vi.add((String) rvs.get(2));
        }
        return vi;
    }

    public List<String> getRecodedVarNameSet() {
        List<String> vn = new ArrayList<String>();
        for (int i = 0; i < recodedVarSet.size(); i++) {
            List<Object> rvs = (List<Object>) recodedVarSet.get(i);
            vn.add((String) rvs.get(0));
        }
        return vn;
    }

    public List<String> getBaseVarIdSetFromRecodedVarIdSet() {
        List<String> vi = new ArrayList<String>();
        for (int i = 0; i < recodedVarSet.size(); i++) {
            List<Object> rvs = (List<Object>) recodedVarSet.get(i);
            vi.add("v" + derivedVarToBaseVar.get((String) rvs.get(2)));
        }
        return vi;
    }

    public List<String> getBaseVarNameSetFromRecodedVarIdSet() {
        List<String> vn = new ArrayList<String>();
        for (int i = 0; i < recodedVarSet.size(); i++) {
            List<Object> rvs = (List<Object>) recodedVarSet.get(i);
            vn.add(getVariableNamefromId(derivedVarToBaseVar.get((String) rvs.get(2))));
        }
        return vn;
    }

    private Map<String, String> getRecodedVarToBaseVarName() {
        Map<String, String> recodedVarToBaseVarName = new HashMap<String, String>();

        for (int i = 0; i < recodedVarSet.size(); i++) {
            List<Object> rvs = (List<Object>) recodedVarSet.get(i);
            String recodedVarName = (String) rvs.get(0);
            String recodedVarId = (String) rvs.get(2);
            String baseVarId = derivedVarToBaseVar.get(recodedVarId);
            String baseVarName = getVariableNamefromId(baseVarId);

            recodedVarToBaseVarName.put(recodedVarName, baseVarName);
        }

        return recodedVarToBaseVarName;
    }

    public List<String> getRecodedVarLabelSet() {
        List<String> vl = new ArrayList<String>();
        for (int i = 0; i < recodedVarSet.size(); i++) {
            List<Object> rvs = (List<Object>) recodedVarSet.get(i);
            vl.add((String) rvs.get(1));
        }
        return vl;
    }

    // get variable type (int) from a given row of the dataTable
    public List<String> getRecodedVariableType() {
        List<String> vt = new ArrayList<String>();
        for (int i = 0; i < recodedVarSet.size(); i++) {
            List<Object> rvs = (List<Object>) recodedVarSet.get(i);
            dbgLog.fine("rvs=" + rvs);
            String newVarId = (String) rvs.get(2);
            int rawType = getVariableType(getVariableById(derivedVarToBaseVar.get(newVarId)));
            if (rawType == 2) {
                rawType = 1;
            }
            vt.add(Integer.toString(rawType));
        }
        return vt;
    }

    // get variable type (int) from a given row of the dataTable
    public List<String> getBaseVariableTypeForRecodedVariable() {
        List<String> vt = new ArrayList<String>();
        for (int i = 0; i < recodedVarSet.size(); i++) {
            List<Object> rvs = (List<Object>) recodedVarSet.get(i);
            vt.add(Integer
                    .toString(getVariableType(getVariableById(derivedVarToBaseVar.get((String) rvs.get(2))))));
        }
        return vt;
    }

    public String getVariableHeaderForSubset() {
        String varHeader = null;
        List<DataVariable> dvs = getDataVariableForRequest();
        List<String> vn = new ArrayList<String>();
        if (dvs != null) {
            for (Iterator el = dvs.iterator(); el.hasNext();) {
                DataVariable dv = (DataVariable) el.next();
                vn.add(dv.getName());
            }
            varHeader = StringUtils.join(vn, "\t");
            varHeader = varHeader + "\n";
        }
        return varHeader;
    }

    public Set<Integer> getFieldNumbersForSubsetting() {
        // create var ids for subsetting
        // data(int) are taken from DB's studyfile table -- FileOrder column
        Set<Integer> fields = new LinkedHashSet<Integer>();
        List<DataVariable> dvs = getDataVariableForRequest();

        if (dvs != null) {
            for (Iterator el = dvs.iterator(); el.hasNext();) {
                DataVariable dv = (DataVariable) el.next();
                fields.add(dv.getFileOrder());
            }
        }
        return fields;
    }

    public String getVariableNamesForSubset() {
        String varHeader = "";
        List<DataVariable> dvs = getDataVariableForRequest();
        List<String> vn = new ArrayList<String>();
        if (dvs != null) {
            for (Iterator el = dvs.iterator(); el.hasNext();) {
                DataVariable dv = (DataVariable) el.next();
                vn.add(dv.getName());
            }
            varHeader = StringUtils.join(vn, ",");
        }
        return varHeader;
    }

    // </editor-fold>

    // -----------------------------------------------------------------------
    // misc. methods 
    // -----------------------------------------------------------------------
    // <editor-fold desc="misc. methods">

    /**
     * Returns true if an end-user's brower is Firefox
     *
     * @param userAgent    hash value of the user-agent key in the request
     *                     header's map
     * @return    true if an end-user's brower is Firefox; false otherwise
     */
    public boolean isBrowserFirefox(String userAgent) {
        boolean rtvl = false;
        String regex = "Firefox";
        Pattern p = null;
        try {
            p = Pattern.compile(regex, Pattern.CASE_INSENSITIVE);
        } catch (PatternSyntaxException pex) {
            pex.printStackTrace();
        }
        Matcher matcher = p.matcher(userAgent);
        rtvl = matcher.find();
        return rtvl;
    }

    /**
     *
     * @return    The url of the DSB
     */
    public String getDsbUrl() {

        String dsbUrl = System.getProperty("vdc.dsb.host");
        String dsbPort = System.getProperty("vdc.dsb.port");

        if (dsbPort != null) {
            dsbUrl += ":" + dsbPort;
        }

        if (dsbUrl == null) {
            dsbUrl = System.getProperty("vdc.dsb.url");
        }
        return dsbUrl;
    }

    // <----------------------------------------------------------------------
    public void writeRhistory(File frh, String rh) {
        OutputStream outs = null;
        try {
            outs = new BufferedOutputStream(new FileOutputStream(frh));
            PrintWriter pw = new PrintWriter(new OutputStreamWriter(outs, "utf8"), true);
            pw.println(rh);
            outs.close();
        } catch (IOException ex) {
            ex.printStackTrace();
        }
    }

    public void zipFiles(OutputStream out, List<File> fllst) {
        ZipOutputStream zout = null;
        //BufferedInputStream infile = null;
        FileInputStream infile = null;

        zout = new ZipOutputStream(out);

        for (int i = 0; i < fllst.size(); i++) {
            try {
                infile = new FileInputStream(fllst.get(i));//new BufferedInputStream()

            } catch (FileNotFoundException e) {
                err.println("input file is not found");
                e.printStackTrace();
                try {
                    zout.close();
                } catch (ZipException ze) {
                    err.println("zip file invalid");
                    ze.printStackTrace();
                } catch (IOException ex) {
                    err.println("closing output file");
                    ex.printStackTrace();
                }
            }

            ZipEntry ze = new ZipEntry(fllst.get(i).getName());
            try {
                zout.putNextEntry(ze);
                /*
                    int len;
                    while ((len = infile.read())> 0) {
                zout.write(len);
                    }
                */

                byte[] dataBuffer = new byte[8192];

                int k = 0;
                while ((k = infile.read(dataBuffer)) > 0) {
                    zout.write(dataBuffer, 0, k);
                    //fileSize += i; 
                    out.flush();
                }

            } catch (ZipException zpe) {
                zpe.printStackTrace();
                err.println("zip file is invalid");
            } catch (IOException ie) {
                ie.printStackTrace();
                err.println("output file io-error");
            }

            try {
                infile.close();
            } catch (IOException ie) {
                err.println("error: closing input file");
            }
        }

        try {
            zout.close();
        } catch (ZipException zpe) {
            err.println("zip file invalid");
            zpe.printStackTrace();
        } catch (IOException ioe) {
            err.println("error closing zip file");
            ioe.printStackTrace();
        }

    }

    // </editor-fold>

    // end of this class

    private File getOriginalFileSystemLocation() {

        // Get the Study File from the dataTable private variable
        // This points
        StudyFile sf = dataTable.getStudyFile();

        // 
        File inFile = new File(dataTable.getStudyFile().getFileSystemLocation());

        return new File(inFile.getParent(), "_" + sf.getFileSystemName());
    }
}