Changeset 3942


Ignore:
Timestamp:
Nov 2, 2010, 2:58:33 PM (13 years ago)
Author:
Gregory Vincic
Message:

Refs #698. Removing method getSetFilterForm and related methods/classes.

Location:
trunk/client/servlet/src/org/proteios
Files:
4 deleted
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/client/servlet/src/org/proteios/gui/form/FormFactory.java

    r3941 r3942  
    7171    private Localizer locale = null;
    7272    private String forwardActionId = null;
    73     private String sortColumnKey = null;
    74     private Integer filterListSize = null;
    75     private List<String> filterKeyColumnList = null;
    76     private HashMap<String, String> filterClassColumnHashMap = null;
    77     private HashMap<String, String> filterConditionColumnHashMap = null;
    78     private HashMap<String, String> filterValueColumnHashMap = null;
    7973    // Valid parameters
    8074    public static final VInteger VID = new DBID();
    … …  
    167161    .getLogger("org.proteios.gui.form");
    168162                       
    169     /**
    170         Default constructor. Initializes list excludedDeclMethods.
    171     */
    172     public FormFactory()
    173     {
    174         /*
    175             Initialize list excludedDeclMethods.
    176         */
    177                
    178     }
    179                        
    180163    public void setActionFactory(ActionFactory af)
    181164    {
    … …  
    191174    {
    192175        this.forwardActionId = forwardActionId;
    193     }
    194                        
    195     public String getSortColumnKey()
    196     {
    197         return this.sortColumnKey;
    198     }
    199                        
    200     public void setSortColumnKey(String sortColumnKey)
    201     {
    202         this.sortColumnKey = sortColumnKey;
    203     }
    204                        
    205     public Integer getFilterListSize()
    206     {
    207         return this.filterListSize;
    208     }
    209                        
    210     public void setFilterListSize(Integer filterListSize)
    211     {
    212         this.filterListSize = filterListSize;
    213     }
    214                        
    215     public List<String> getFilterKeyColumnList()
    216     {
    217         return this.filterKeyColumnList;
    218     }
    219                        
    220     public void setFilterKeyColumnList(List<String> filterKeyColumnList)
    221     {
    222         this.filterKeyColumnList = filterKeyColumnList;
    223     }
    224                        
    225     public HashMap<String, String> getFilterClassColumnHashMap()
    226     {
    227         return this.filterClassColumnHashMap;
    228     }
    229                        
    230     public void setFilterClassColumnHashMap(
    231     HashMap<String, String> filterClassColumnHashMap)
    232     {
    233         this.filterClassColumnHashMap = filterClassColumnHashMap;
    234     }
    235                        
    236     public HashMap<String, String> getFilterConditionColumnHashMap()
    237     {
    238         return this.filterConditionColumnHashMap;
    239     }
    240                        
    241     public void setFilterConditionColumnHashMap(
    242     HashMap<String, String> filterConditionColumnHashMap)
    243     {
    244         this.filterConditionColumnHashMap = filterConditionColumnHashMap;
    245     }
    246                        
    247     public HashMap<String, String> getFilterValueColumnHashMap()
    248     {
    249         return this.filterValueColumnHashMap;
    250     }
    251                        
    252     public void setFilterValueColumnHashMap(
    253     HashMap<String, String> filterValueColumnHashMap)
    254     {
    255         this.filterValueColumnHashMap = filterValueColumnHashMap;
    256176    }
    257177                       
    … …  
    19021822        return form;
    19031823    }
    1904                        
    1905     public Form getSetFilterForm(String filterName, String filterClass,
    1906     String filterCondition, String filterValue)
    1907     {
    1908         log
    1909         .debug("FormFactory::getSetFilterForm(): Start - filterName = \"" + filterName + "\" filterClass = \"" + filterClass + "\" filterCondition = \"" + filterCondition + "\" filterValue = \"" + filterValue + "\"");
    1910         Form form = new Form("setFilterForm");
    1911         // Properties field set
    1912         Fieldset properties = new Fieldset();
    1913         properties.setTitle("ColumnFilterSettings");
    1914         form.addFieldset(properties);
    1915         // Filter name field (hidden - for transfer of value to other classes)
    1916         TextField<String> filterNameF = newHiddenStringField(VFILTERNAME);
    1917         filterNameF.setLabel(filterName);
    1918         filterNameF.setValue(filterName);
    1919         properties.add(filterNameF);
    1920         // Filter name display field (disabled - for display of value as label)
    1921         TextField<String> filterNameDisplayF = new DummyField();
    1922         filterNameDisplayF.setLabel(filterName);
    1923         filterNameDisplayF.setValue("");
    1924         filterNameDisplayF.setDisabled(true);
    1925         properties.add(filterNameDisplayF);
    1926         // Filter class field (disabled)
    1927         TextField<String> filterClassF = new TextField<String>(VFILTERCLASS);
    1928         filterClassF.setLabel("Type");
    1929         filterClassF.setValue(filterClass);
    1930         filterClassF.setDisabled(true);
    1931         properties.add(filterClassF);
    1932         // Filter condition select field
    1933         Select<VString> filterConditionS = new Select<VString>(VFILTERCONDITION);
    1934         filterConditionS.setLabel("Condition");
    1935         // Filter value field
    1936         TextField<String> filterValueF = new TextField<String>(VFILTERVALUE);
    1937         filterValueF.setLabel("FilterValue");
    1938         filterValueF.setValue(filterValue);
    1939         List<Option> optionList = new ArrayList<Option>(0);
    1940         // Set option content
    1941         if (filterClass != null && (filterClass.equals("boolean") || filterClass
    1942         .equals("Boolean")))
    1943         {
    1944             optionList.add(new Option("="));
    1945             optionList.add(new Option("!="));
    1946         }
    1947         else
    1948         {
    1949             optionList.add(new Option("="));
    1950             if (filterClass != null && (filterClass.equals("string") || filterClass
    1951             .equals("String")))
    1952             {
    1953                 filterValueF.setLabel("FilterValueWildCard");
    1954             }
    1955             optionList.add(new Option("!="));
    1956             optionList.add(new Option("<="));
    1957             optionList.add(new Option("<"));
    1958             optionList.add(new Option(">"));
    1959             optionList.add(new Option(">="));
    1960         }
    1961         // Set default option
    1962         for (int i = 0; i < optionList.size(); i++)
    1963         {
    1964             if (filterCondition.equals(optionList.get(i).getContent()))
    1965             {
    1966                 optionList.get(i).setSelected(true);
    1967             }
    1968         }
    1969         // Add options to select box
    1970         for (int i = 0; i < optionList.size(); i++)
    1971         {
    1972             filterConditionS.addOption(optionList.get(i));
    1973         }
    1974         properties.add(filterConditionS);
    1975         properties.add(filterValueF);
    1976         /*
    1977             The following section stores information on previous settings in
    1978             hidden fields, to be retrieved when the form is verified.
    1979         */
    1980         // Add forward action id
    1981         String forwardActId = getForwardActionId();
    1982         log
    1983         .debug("FormFactory::getSetFilterForm(): forwardActionId = \"" + forwardActId + "\"");
    1984         TextField<String> fwdF = newHiddenStringField(ForwardField.VPARAM);
    1985         fwdF.setValue(forwardActId);
    1986         properties.add(fwdF);
    1987         // Add sort column key
    1988         String sortClmKey = getSortColumnKey();
    1989         log
    1990         .debug("FormFactory::getSetFilterForm(): sortColumnKey = \"" + sortClmKey + "\"");
    1991         TextField<String> sortClmF = newHiddenStringField(VSORTCOLUMNKEY);
    1992         sortClmF.setValue(sortClmKey);
    1993         properties.add(sortClmF);
    1994         // Add filter setting hashmap data
    1995         addFilterSettingsToFieldset(properties);
    1996         return form;
    1997     }
    1998                        
    1999     private void addFilterSettingsToFieldset(Fieldset fs)
    2000     {
    2001         // Add filter setting hashmap data
    2002         Integer filterLstSize = getFilterListSize();
    2003         log
    2004         .debug("FormFactory::addFilterSettingsToFieldset(): filterListSize = " + filterLstSize);
    2005         if (filterLstSize != null)
    2006         {
    2007             for (int keyNum = 0; keyNum < filterLstSize; keyNum++)
    2008             {
    2009                 String filterKey = null;
    2010                 String filterCls = null;
    2011                 String filterCnd = null;
    2012                 String filterVal = null;
    2013                 /*
    2014                     Note that the list and hash maps may be null here, even
    2015                     though filter list size > 0. This happens after the form has
    2016                     been displayed, and a following action verifies the form to
    2017                     have the form fields filled in with data stored in the
    2018                     request.
    2019                 */
    2020                 if (getFilterKeyColumnList() != null)
    2021                 {
    2022                     filterKey = getFilterKeyColumnList().get(keyNum);
    2023                 }
    2024                 if (filterKey != null && getFilterClassColumnHashMap() != null)
    2025                 {
    2026                     filterCls = getFilterClassColumnHashMap().get(filterKey);
    2027                 }
    2028                 if (filterKey != null && getFilterConditionColumnHashMap() != null)
    2029                 {
    2030                     filterCnd = getFilterConditionColumnHashMap()
    2031                     .get(filterKey);
    2032                 }
    2033                 if (filterKey != null && getFilterValueColumnHashMap() != null)
    2034                 {
    2035                     filterVal = getFilterValueColumnHashMap().get(filterKey);
    2036                 }
    2037                 log
    2038                 .debug(this.getClass().getSimpleName() + "::addFilterSettingsToFieldset(): keyNum = " + keyNum + " filterKey = \"" + filterKey + "\" filterClass = \"" + filterCls + "\" filterCnd = \"" + filterCnd + "\" filterVal = \"" + filterVal + "\"");
    2039                 TextField<String> filterKeyF = newValueField(
    2040                 "filterKey-" + keyNum, String.class);
    2041                 TextField<String> filterClsF = newValueField(
    2042                 "filterCls-" + keyNum, String.class);
    2043                 TextField<String> filterCndF = newValueField(
    2044                 "filterCnd-" + keyNum, String.class);
    2045                 TextField<String> filterValF = newValueField(
    2046                 "filterVal-" + keyNum, String.class);
    2047                 filterKeyF.setValue(filterKey);
    2048                 filterClsF.setValue(filterCls);
    2049                 filterCndF.setValue(filterCnd);
    2050                 filterValF.setValue(filterVal);
    2051                 filterKeyF.setHidden(true);
    2052                 filterClsF.setHidden(true);
    2053                 filterCndF.setHidden(true);
    2054                 filterValF.setHidden(true);
    2055                 fs.add(filterKeyF);
    2056                 fs.add(filterClsF);
    2057                 fs.add(filterCndF);
    2058                 fs.add(filterValF);
    2059             }
    2060         }
    2061     }
    2062                        
     1824
    20631825    public TextField<Float> newOriginalQuantityField()
    20641826    {

  • trunk/client/servlet/src/org/proteios/gui/table/TableFactory.java

    r3842 r3942  
    4545import org.proteios.action.ActionFactory;
    4646import org.proteios.action.ProteiosAction;
    47 import org.proteios.action.SetColumnSelection;
    48 import org.proteios.action.SetFilter1;
    49 import org.proteios.action.SetSortColumn;
    50 import org.proteios.action.SetTableConfiguration;
    5147import org.proteios.action.execute.ShareToProject;
    5248import org.proteios.action.read.ScrollTo;
    … …  
    966962
    967963
    968   // public GUIElement createConfigForm()
    969   public Form createConfigForm(boolean writeMode)
    970   {
    971     log.debug("Start - writeMode = " + writeMode);
    972     // Set number of non-check box columns, if known
    973     if (writeMode)
    974     {
    975       int tmpListSize = columnsSorted.size();
    976       if (tmpListSize > 0)
    977       {
    978         Column<?> c = columnsSorted.get(0);
    979         if (c != null && c.isAsCheckBox())
    980         {
    981           // Ignore initial check box column
    982           tmpListSize--;
    983         }
    984       }
    985       setColumnListSize(tmpListSize);
    986       // Set initial user column order list
    987       log.debug("tmpListSize = " + tmpListSize);
    988       if (getColumnOrderUserList() == null)
    989       {
    990         // Set all columns to be visible
    991         List<Integer> tmpColumnOrderUserList = new ArrayList<Integer>(
    992           tmpListSize);
    993         for (int i = 0; i < tmpListSize; i++)
    994         {
    995           tmpColumnOrderUserList.add(i, Integer.valueOf(i));
    996         }
    997         setColumnOrderUserList(tmpColumnOrderUserList);
    998       }
    999       log.debug("getColumnOrderUserList() = " + getColumnOrderUserList());
    1000     }
    1001     Form form = new Form("tableConfig");
    1002     form.setTitle("ConfigureTable");
    1003     Fieldset fields = new Fieldset();
    1004     // fields.setTitle("SelectVisibleColumns");
    1005     fields.setTitle("ConfigureTable");
    1006     form.addFieldset(fields);
    1007     // VString showColumnParameter = new VString("showColumn", 1, 32, true);
    1008     // Select<VString> selectBoxColumns = new
    1009     // Select<VString>(showColumnParameter);
    1010     // selectBoxColumns.setLabel("Columns");
    1011     // selectBoxColumns.setLabel("SelectVisibleColumns");
    1012     // Add real column options here, this is just an example
    1013     // for (Column<?> c: columnsSorted)
    1014     // {
    1015     // Option clmOpt = new Option(locale.get(c.getValue()));
    1016     // selectBoxColumns.addOption(clmOpt);
    1017     // }
    1018     // Option nameColumn = new Option("name");
    1019     // selectBoxColumns.addOption(nameColumn);
    1020     // fields.add(selectBoxColumns);
    1021     // TODO olle add fields to configure the table here....
    1022     /*
    1023      * Column selection table
    1024      */
    1025     // One check box for each column
    1026     // Table for column selection
    1027     String clmTableId = "ColumnTable";
    1028     Table columnTable = new Table(clmTableId);
    1029     columnTable.setTitle("SelectVisibleColumns");
    1030     // Initial check box column
    1031     IdColumn chkboxColumn = new IdColumn();
    1032     columnTable.add(chkboxColumn);
    1033     // Column for column names
    1034     Column<String> clmNameColumn = new Column<String>("Column");
    1035     clmNameColumn.setValue("Columns");
    1036     columnTable.add(clmNameColumn);
    1037     // Add rows for columns except initial check box column
    1038     int nColumns = 0;
    1039     if (getColumnListSize() != null)
    1040     {
    1041       nColumns = getColumnListSize();
    1042     }
    1043     log.debug("nColumns = " + nColumns);
    1044     // int rowId = 0;
    1045     // for (Column<?> c: columnsSorted)
    1046     int clmId = -1;
    1047     for (int rowId = 0; rowId < nColumns; rowId++)
    1048     {
    1049       Column<?> c = null;
    1050       if (writeMode)
    1051       {
    1052         // Get next non-checkbox column
    1053         clmId++;
    1054         c = columnsSorted.get(clmId);
    1055         while (c != null && c.isAsCheckBox())
    1056         {
    1057           clmId++;
    1058           c = columnsSorted.get(clmId);
    1059         }
    1060       }
    1061       Row row = new Row(rowId);
    1062       // Add cell with check box for selection
    1063       Checkbox<VInteger> cb = new Checkbox<VInteger>(
    1064         FormFactory.VCOLUMNROWID);
    1065       cb.setValue("" + rowId);
    1066       if (getColumnOrderUserList() != null)
    1067       {
    1068         if (getColumnOrderUserList().contains(Integer.valueOf(rowId)))
    1069         {
    1070           cb.isChecked(true);
    1071         }
    1072         log.debug("rowId = " + rowId + " cb.getValue() = \"" + cb
    1073           .getValue() + "\" cb.isChecked() = " + cb.isChecked());
    1074       }
    1075       Cell<Checkbox<VInteger>> cell = new Cell<Checkbox<VInteger>>(cb);
    1076       row.addCell(cell);
    1077       // Add cell with column name
    1078       if (c != null)
    1079       {
    1080         if (locale == null)
    1081         {
    1082           try
    1083           {
    1084             locale = new Localizer("en");
    1085           }
    1086           catch (IOException e)
    1087           {
    1088             log
    1089               .debug("IOException when trying to create Localizer: " + e);
    1090           }
    1091         }
    1092         row.addCell(new Cell<String>(locale.get(c.getValue())));
    1093       }
    1094       // Add row to column selection table
    1095       columnTable.addRow(row);
    1096     }
    1097     fields.add(columnTable);
    1098     // Toolbar
    1099     Toolbar toolbar = new Toolbar();
    1100     // TODO change to an appropriate action
    1101     // ProteiosAction action = (ProteiosAction) event.getLastAction();
    1102     // ActionLink configure = actionFactory.getActionLink(action.getClass(),
    1103     // "Save");
    1104     ActionLink configure = actionFactory.getActionLink(
    1105       SetColumnSelection.class, "Save");
    1106     // ActionLink configure =
    1107     // actionFactory.getActionLink(SetTableConfiguration.class,
    1108     // "Save");
    1109     // Add parameter for column list size
    1110     configure
    1111       .addParameter(FormFactory.VCOLUMNLISTSIZE, getColumnListSize());
    1112     HashMap<String, String> parameters = new HashMap<String, String>(0);
    1113     // Add parameters for current filter settings.
    1114     parameters = addFilterParameters(parameters);
    1115     // Add parameter for current sort column key
    1116     // parameters = addSortColumnKeyParameter(parameters);
    1117     // Add defined parameters to cell action link
    1118     if (parameters != null)
    1119     {
    1120       for (String key : parameters.keySet())
    1121       {
    1122         configure.addParameter(key, parameters.get(key));
    1123       }
    1124     }
    1125     toolbar.add(configure);
    1126     columnTable.setToolbar(toolbar);
    1127     // Add forward action id
    1128     log.debug("getCurrentAction().getId() = " + getCurrentAction().getId());
    1129     TextField<String> forwardActionField = new TextField<String>(
    1130       ForwardField.VPARAM);
    1131     forwardActionField.setHidden(true);
    1132     forwardActionField.setValue(getCurrentAction().getId());
    1133     fields.add(forwardActionField);
    1134     // TODO when this works fine make sure to return the form
    1135     // return null;
    1136     log.debug("End");
    1137     return form;
    1138   }
    1139 
    1140 
    1141964  @SuppressWarnings("unchecked")
    1142965  public <E extends BasicItem> Table build()
    … …  
    1166989    // Add optional column header sort action
    1167990    initializeSortOption();
    1168     columnsSorted = addHeaderAction(columnsSorted);
    1169991    // Optional user selection/sorting of columns
    1170992    columnsUserSorted = columnsUserSort(columnsSorted);
    … …  
    11791001    // Optional filtering of columns
    11801002    initializeColumnFilters(columnsUserSorted);
    1181     Row filterRow = obtainFilterRow(columnsUserSorted);
    1182     if (filterRow != null)
    1183     {
    1184       table.addRow(filterRow);
    1185     }
    11861003    // Set optional filtering as query restrictions
    11871004    addFiltersToQuery(query);
    … …  
    12031020      scroller.setTotalCount(count);
    12041021      scroller.setScrollActionId(actionFactory.getId(ScrollTo.class));
    1205       scroller.setTableConfActionId(actionFactory
    1206         .getId(SetTableConfiguration.class));
    12071022      scroller.setDisplayActionId(getCurrentAction().getId());
    12081023      scroller.put(FormFactory.VCLASSNAME, itemClass.getName());
    … …  
    12191034    if (usingLocalDbControl)
    12201035      dc.close();
    1221     // Table configuration GUI
    1222     PopupLink link = new PopupLink();
    1223     link.setContent(createConfigForm(true));
    1224     table.setConfigFormLink(link);
    12251036    // Add table state information as valid parameters
    12261037    table = addStateInformation(table);
    … …  
    14511262
    14521263
    1453   @SuppressWarnings("unchecked")
    1454   private List<Column<?>> addHeaderAction(List<Column<?>> inColumnList)
    1455   {
    1456     if (sortOptionAvailable)
    1457     {
    1458       // Add optional column header sort action
    1459       for (Column<?> c : inColumnList)
    1460       {
    1461         String key = c.getValue();
    1462         // Check if column name in hash map of sortable columns
    1463         if (sortableColumns.containsKey(key))
    1464         {
    1465           // Add header sort action to column
    1466           ActionLink headerAction = actionFactory.getActionLink(
    1467             SetTableConfiguration.class, "Sort");
    1468           String setSortColumnActionId = actionFactory
    1469             .getId(SetSortColumn.class);
    1470           headerAction.addParameter(FormFactory.VTABLECONFACTION,
    1471             setSortColumnActionId);
    1472           headerAction.addParameter(FormFactory.VSORTCOLUMNKEY,
    1473             sortableColumns.get(c.getValue()));
    1474           // Add header action to column
    1475           c.setHeaderAction(headerAction);
    1476           c.setOrder(SortOrder.ASC);
    1477         }
    1478       }
    1479     }
    1480     return inColumnList;
    1481   }
    1482 
    1483 
    1484   @SuppressWarnings("unchecked")
    1485   private Row obtainFilterRow(List<Column<?>> inColumnList)
    1486   {
    1487     Row filterRow = null;
    1488     if (inColumnList != null && filterOptionAvailable)
    1489     {
    1490       for (int i = 0; i < inColumnList.size(); i++)
    1491       {
    1492         Column<?> c = inColumnList.get(i);
    1493         if (filterRow == null)
    1494         {
    1495           /*
    1496            * Set row id to -1, so the filter row can be easily
    1497            * identified.
    1498            */
    1499           filterRow = new Row(-1);
    1500         }
    1501         String columnName = c.getValue();
    1502         // Get filter class
    1503         String filterClass = obtainColumnClass(c);
    1504         if (filterClass == null)
    1505         {
    1506           filterClass = "";
    1507         }
    1508         // log.debug(this.getClass().getSimpleName() +
    1509         // "::obtainFilterRow(): columnName = \"" + columnName + "\"
    1510         // filterClass = \"" + filterClass + "\"");
    1511         // Get filter condition
    1512         String filterCondition = filterConditionColumnHashMap
    1513           .get(columnName);
    1514         if (filterCondition == null)
    1515         {
    1516           if (filterClass.equals("boolean") || filterClass
    1517             .equals("Boolean"))
    1518           {
    1519             filterCondition = "=";
    1520           }
    1521           else
    1522           {
    1523             filterCondition = "<";
    1524           }
    1525         }
    1526         // Get filter value
    1527         String filterValue = filterValueColumnHashMap.get(columnName);
    1528         if (filterValue == null)
    1529         {
    1530           filterValue = "";
    1531         }
    1532         // Add cell for column filter
    1533         Cell<Object> cell = null;
    1534         if (columnName != null && !columnName.equals("") && sortableColumns
    1535           .containsKey(columnName))
    1536         {
    1537           /*
    1538            * Set filter cell name to report current filter setting.
    1539            */
    1540           if (!filterValue.equals(""))
    1541           {
    1542             String filterValueDisplayed = filterValue;
    1543             if (filterClass != null && filterClass.equals("String"))
    1544             {
    1545               // Convert hex code to string.
    1546               filterValueDisplayed = fromHexString(filterValue);
    1547             }
    1548             log
    1549               .debug("columnName = \"" + columnName + "\" filterValue = \"" + filterValue + "\" filterValueDisplayed = \"" + filterValueDisplayed + "\"");
    1550             cell = new Cell<Object>(
    1551               filterCondition + " " + filterValueDisplayed);
    1552           }
    1553           else
    1554           {
    1555             cell = new Cell<Object>("Filter");
    1556           }
    1557           /*
    1558            * Construct action for filter cell for setting filter
    1559            * value.
    1560            */
    1561           // ActionLink cellAction = actionFactory.getActionLink(
    1562           // SetFilter1.class, "Set Filter");
    1563           ActionLink cellAction = actionFactory.getActionLink(
    1564             SetTableConfiguration.class, "Set Filter");
    1565           String setFilterActionId = actionFactory
    1566             .getId(SetFilter1.class);
    1567           cellAction.addParameter(FormFactory.VTABLECONFACTION,
    1568             setFilterActionId);
    1569           HashMap<String, String> parameters = new HashMap<String, String>(
    1570             0);
    1571           // Add parameters for selected filter
    1572           parameters.put(FormFactory.VFILTERNAME.getName(),
    1573             columnName);
    1574           parameters.put(FormFactory.VFILTERCLASS.getName(),
    1575             filterClass);
    1576           parameters.put(FormFactory.VFILTERCONDITION.getName(),
    1577             filterCondition);
    1578           parameters.put(FormFactory.VFILTERVALUE.getName(),
    1579             filterValue);
    1580           // Add parameters for current filter settings.
    1581           // parameters = addFilterParameters(parameters);
    1582           // Add parameter for current sort column key
    1583           // parameters = addSortColumnKeyParameter(parameters);
    1584           // Add parameter for forward action id
    1585           parameters = addForwardActionParameter(parameters);
    1586           // Add defined parameters to cell action link
    1587           if (parameters != null)
    1588           {
    1589             for (String key : parameters.keySet())
    1590             {
    1591               cellAction.addParameter(key, parameters.get(key));
    1592             }
    1593           }
    1594           /*
    1595            * Add action to filter cell for setting filter value.
    1596            */
    1597           cell.setActionLink(cellAction);
    1598         }
    1599         else
    1600         {
    1601           /*
    1602            * Column has no name or column key.
    1603            */
    1604           if (i == 0)
    1605           {
    1606             cell = new Cell<Object>("");
    1607           }
    1608           else
    1609           {
    1610             cell = new Cell<Object>("");
    1611           }
    1612         }
    1613         filterRow.addCell(cell);
    1614       }
    1615     }
    1616     return filterRow;
    1617   }
     1264
    16181265
    16191266
Note: See TracChangeset for help on using the changeset viewer.