Home | History | Annotate | Download | only in tko 
      1 package autotest.tko;
      2 
      3 import autotest.common.SimpleCallback;
      4 import autotest.common.ui.NotifyManager;
      5 import autotest.common.ui.SimplifiedList;
      6 
      7 import com.google.gwt.event.dom.client.ClickEvent;
      8 import com.google.gwt.event.dom.client.ClickHandler;
      9 import com.google.gwt.event.dom.client.HasClickHandlers;
     10 import com.google.gwt.user.client.ui.HasText;
     11 
     12 import java.util.ArrayList;
     13 import java.util.HashMap;
     14 import java.util.HashSet;
     15 import java.util.List;
     16 import java.util.Map;
     17 import java.util.Set;
     18 
     19 public class ParameterizedFieldListPresenter implements ClickHandler {
     20     public interface Display {
     21         public interface FieldWidget {
     22             public HasClickHandlers getDeleteLink();
     23         }
     24 
     25         public SimplifiedList getTypeSelect();
     26         public HasText getValueInput();
     27         public HasClickHandlers getAddLink();
     28         public FieldWidget addFieldWidget(String name, String filteringName);
     29         public void removeFieldWidget(FieldWidget widget);
     30     }
     31 
     32     private Display display;
     33     private HeaderFieldCollection headerFields;
     34     private Map<ParameterizedField, Display.FieldWidget> fieldInputMap =
     35         new HashMap<ParameterizedField, Display.FieldWidget>();
     36     private Set<Object> fieldIds = new HashSet<Object>();
     37     private SimpleCallback changeListener;
     38 
     39     /**
     40      * @param headerFields Generated ParameterizedFields will be added to this (and removed when
     41      * they're deleted)
     42      */
     43     public ParameterizedFieldListPresenter(HeaderFieldCollection headerFields) {
     44         this.headerFields = headerFields;
     45     }
     46 
     47     public void bindDisplay(Display display) {
     48         this.display = display;
     49         display.getAddLink().addClickHandler(this);
     50         populateTypeSelect();
     51     }
     52 
     53     public void setListener(SimpleCallback changeListener) {
     54         this.changeListener = changeListener;
     55     }
     56 
     57     private void populateTypeSelect() {
     58         for (String name : ParameterizedField.getFieldTypeNames()) {
     59             display.getTypeSelect().addItem(name, name);
     60         }
     61     }
     62 
     63     @Override
     64     public void onClick(ClickEvent event) {
     65         assert event.getSource() == display.getAddLink();
     66 
     67         String type = display.getTypeSelect().getSelectedName();
     68         String value = display.getValueInput().getText();
     69         if (value.isEmpty()) {
     70             NotifyManager.getInstance().showError("You must provide a value");
     71             return;
     72         }
     73 
     74         ParameterizedField field = createField(type, value);
     75         if (fieldIds.contains(field.getIdentifier())) {
     76             NotifyManager.getInstance().showError("This field already exists: " + field.getName());
     77             return;
     78         }
     79 
     80         addField(field);
     81         changeListener.doCallback(this);
     82         display.getValueInput().setText("");
     83     }
     84 
     85     private ParameterizedField createField(String type, String value) {
     86         return ParameterizedField.newInstance(type, value);
     87     }
     88 
     89     private void addField(final ParameterizedField field) {
     90         headerFields.add(field);
     91 
     92         Display.FieldWidget fieldWidget = display.addFieldWidget(field.getName(),
     93                                                                  field.getFilteringName());
     94         fieldInputMap.put(field, fieldWidget);
     95         fieldWidget.getDeleteLink().addClickHandler(new ClickHandler() {
     96             @Override
     97             public void onClick(ClickEvent event) {
     98                 deleteField(field);
     99                 changeListener.doCallback(this);
    100             }
    101         });
    102 
    103         fieldIds.add(field.getIdentifier());
    104     }
    105 
    106     public void addFieldIfNotPresent(String type, String name) {
    107         ParameterizedField field = createField(type, name);
    108         if (!fieldIds.contains(field.getIdentifier())) {
    109             addField(field);
    110         }
    111     }
    112 
    113     private void deleteField(ParameterizedField field) {
    114         headerFields.remove(field);
    115         Display.FieldWidget widget = fieldInputMap.remove(field);
    116         display.removeFieldWidget(widget);
    117         fieldIds.remove(field.getIdentifier());
    118     }
    119 
    120     private String getListKey(int index) {
    121         return "parameterized_field_" + Integer.toString(index);
    122     }
    123 
    124     public void addHistoryArguments(Map<String, String> arguments) {
    125         int index = 0;
    126         for (ParameterizedField field : fieldInputMap.keySet()) {
    127             String baseKey = getListKey(index);
    128             arguments.put(baseKey + "_type", field.getTypeName());
    129             arguments.put(baseKey + "_value", field.getValue());
    130             index++;
    131         }
    132     }
    133 
    134     public void handleHistoryArguments(Map<String, String> arguments) {
    135         reset();
    136         for (int index = 0; ; index++) {
    137             String baseKey = getListKey(index);
    138             String typeKey = baseKey + "_type";
    139             String valueKey = baseKey + "_value";
    140             if (!arguments.containsKey(typeKey) || !arguments.containsKey(valueKey)) {
    141                 break;
    142             }
    143 
    144             String typeName = arguments.get(typeKey), value = arguments.get(valueKey);
    145             addField(createField(typeName, value));
    146         }
    147         changeListener.doCallback(this);
    148     }
    149 
    150     private void reset() {
    151         // avoid ConcurrentModificationException
    152         List<ParameterizedField> fieldListCopy =
    153             new ArrayList<ParameterizedField>(fieldInputMap.keySet());
    154         for (ParameterizedField field : fieldListCopy) {
    155             deleteField(field);
    156         }
    157     }
    158 }
    159