Jak dynamicznie aktualizować opcje w SelectionCell za pomocą GWT?

Question

Próbuję mieć tabela, która wyświetla dane, które użytkownik wprowadza, a także edytować dane. Zorientowałem się, jak to zrobić z tekstem (tzn. Mogą edytować nazwę czegoś w tabeli), ale nie mogę go uruchomić z komórkami wyboru.

Działa poprawnie, jeśli elementy w komórce zaznaczenia są predefiniowane, ale nie mogę dynamicznie aktualizować elementów w komórce, aby uwzględnić nowe rzeczy po utworzeniu komórki.

Mam wyjaśnienie, mam kolumnę "typ". Użytkownik wprowadza elementy do tabeli przy danym typie, ale może również później dodawać nowe typy. Kiedy klikną na element w kolumnie typu, chcę, aby pole rozwijane zawierało wszystkie nowe typy, które wprowadzili, ale nie wiem, jak to osiągnąć.

Oto kod, który mam do tej pory (który nie aktualizuje się tak jak chcę). record.getTypeList() będzie zawierać dodatkowe wpisy po wprowadzeniu przez użytkownika nowych typów.

SelectionCell editTypeComboBox = new SelectionCell(record.getTypeList()); 

    Column<Assignment, String> typeColumn = new Column<Assignment, String>(editTypeComboBox) { 
     @Override 
     public String getValue(Assignment object) { 
      return object.getType(); 
     } 
    }; 
    typeColumn.setFieldUpdater(new FieldUpdater<Assignment, String>() { 

     @Override 
     public void update(int index, Assignment object, String value) { 
      int row = index; 
      String newType = value; 
      record.editAssignType(row, newType); 
      updateClassGradeLabel(); 
      log.info("Set type to " 
        + value); 
      cellTable.redraw(); 
     } 
    }); 

    cellTable.addColumn(typeColumn, "Type"); 

Edit: Dzięki Peter Knego wroga pomaga mi zrozumieć to. Oto zmodyfikowana klasa DynamicSelectionCell jeśli ktoś jeżeli zainteresowany:

/* 
* Copyright 2010 Google Inc. 
* 
* 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. 
*/ 
package com.google.gwt.cell.client; 

import com.google.gwt.core.client.GWT; 
import com.google.gwt.dom.client.Element; 
import com.google.gwt.dom.client.NativeEvent; 
import com.google.gwt.dom.client.SelectElement; 
import com.google.gwt.safehtml.client.SafeHtmlTemplates; 
import com.google.gwt.safehtml.shared.SafeHtml; 
import com.google.gwt.safehtml.shared.SafeHtmlBuilder; 

import java.util.ArrayList; 
import java.util.HashMap; 
import java.util.List; 

/** 
* A {@link Cell} used to render a drop-down list. 
*/ 
public class DynamicSelectionCell extends AbstractInputCell<String, String> { 

    interface Template extends SafeHtmlTemplates { 
    @Template("<option value=\"{0}\">{0}</option>") 
    SafeHtml deselected(String option); 

    @Template("<option value=\"{0}\" selected=\"selected\">{0}</option>") 
    SafeHtml selected(String option); 
    } 

    private static Template template; 

    private HashMap<String, Integer> indexForOption = new HashMap<String, Integer>(); 

    private final List<String> options; 

    /** 
    * Construct a new {@link SelectionCell} with the specified options. 
    * 
    * @param options the options in the cell 
    */ 
    public DynamicSelectionCell(List<String> options) { 
    super("change"); 
    if (template == null) { 
     template = GWT.create(Template.class); 
    } 
    this.options = new ArrayList<String>(options); 
    int index = 0; 
    for (String option : options) { 
     indexForOption.put(option, index++); 
    } 
    } 

    public void addOption(String newOp){ 
     String option = new String(newOp); 
     options.add(option); 
     refreshIndexes(); 
    } 

    public void removeOption(String op){ 
     String option = new String(op); 
     options.remove(indexForOption.get(option)); 
     refreshIndexes(); 
    } 

    private void refreshIndexes(){ 
     int index = 0; 
     for (String option : options) { 
      indexForOption.put(option, index++); 
     } 
    } 

    @Override 
    public void onBrowserEvent(Context context, Element parent, String value, 
     NativeEvent event, ValueUpdater<String> valueUpdater) { 
    super.onBrowserEvent(context, parent, value, event, valueUpdater); 
    String type = event.getType(); 
    if ("change".equals(type)) { 
     Object key = context.getKey(); 
     SelectElement select = parent.getFirstChild().cast(); 
     String newValue = options.get(select.getSelectedIndex()); 
     setViewData(key, newValue); 
     finishEditing(parent, newValue, key, valueUpdater); 
     if (valueUpdater != null) { 
     valueUpdater.update(newValue); 
     } 
    } 
    } 

    @Override 
    public void render(Context context, String value, SafeHtmlBuilder sb) { 
    // Get the view data. 
    Object key = context.getKey(); 
    String viewData = getViewData(key); 
    if (viewData != null && viewData.equals(value)) { 
     clearViewData(key); 
     viewData = null; 
    } 

    int selectedIndex = getSelectedIndex(viewData == null ? value : viewData); 
    sb.appendHtmlConstant("<select tabindex=\"-1\">"); 
    int index = 0; 
    for (String option : options) { 
     if (index++ == selectedIndex) { 
     sb.append(template.selected(option)); 
     } else { 
     sb.append(template.deselected(option)); 
     } 
    } 
    sb.appendHtmlConstant("</select>"); 
    } 

    private int getSelectedIndex(String value) { 
    Integer index = indexForOption.get(value); 
    if (index == null) { 
     return -1; 
    } 
    return index.intValue(); 
    } 
} 

Answer 1

Niestety SelectionCell przechowuje opcje w prywatnym liście, a nie istnieją żadne metody manipulowania to po ustawieniu ich w konstruktorze. Na szczęście jest dość prostą klasą. Po prostu utwórz własną kopię (zmienioną nazwę) i dodaj metody do manipulowania , aby manipulować List<String> options.