Coverage Report

 /**
  * Copyright 2010 The Kuali Foundation Licensed under the
  * Educational Community License, Version 2.0 (the "License"); you may
  * not use this file except in compliance with the License. You may
  * obtain a copy of the License at
  *
  * http://www.osedu.org/licenses/ECL-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 org.kuali.student.common.ui.client.widgets.list;
 
 import java.util.ArrayList;
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
 
 import org.kuali.student.common.assembly.data.Data;
 import org.kuali.student.common.assembly.data.Data.DataValue;
 import org.kuali.student.common.assembly.data.Data.Property;
 import org.kuali.student.common.assembly.data.Data.StringKey;
 import org.kuali.student.common.assembly.data.Data.Value;
 import org.kuali.student.common.ui.client.configurable.mvc.WidgetConfigInfo;
 import org.kuali.student.common.ui.client.mvc.Callback;
 import org.kuali.student.common.ui.client.mvc.HasCrossConstraints;
 import org.kuali.student.common.ui.client.mvc.HasDataValue;
 import org.kuali.student.common.ui.client.mvc.HasFocusLostCallbacks;
 import org.kuali.student.common.ui.client.mvc.HasWidgetReadyCallback;
 import org.kuali.student.common.ui.client.mvc.TranslatableValueWidget;
 import org.kuali.student.common.ui.client.util.UtilConstants;
 import org.kuali.student.common.ui.client.widgets.DataHelper;
 import org.kuali.student.common.ui.client.widgets.HasInputWidget;
 import org.kuali.student.common.ui.client.widgets.KSButton;
 import org.kuali.student.common.ui.client.widgets.KSButtonAbstract.ButtonStyle;
 import org.kuali.student.common.ui.client.widgets.KSDropDown;
 import org.kuali.student.common.ui.client.widgets.KSItemLabel;
 import org.kuali.student.common.ui.client.widgets.field.layout.element.ValidationProcessable;
 import org.kuali.student.common.ui.client.widgets.layout.VerticalFlowPanel;
 import org.kuali.student.common.ui.client.widgets.menus.KSListPanel;
 import org.kuali.student.common.ui.client.widgets.menus.KSListPanel.ListType;
 import org.kuali.student.common.ui.client.widgets.search.KSPicker;
 import org.kuali.student.common.ui.client.widgets.search.SelectedResults;
 import org.kuali.student.common.ui.client.widgets.suggestbox.KSSuggestBox;
 import org.kuali.student.common.validation.dto.ValidationResultInfo;
 import org.kuali.student.common.validation.dto.ValidationResultInfo.ErrorLevel;
 
 import com.google.gwt.event.dom.client.ClickEvent;
 import com.google.gwt.event.dom.client.ClickHandler;
 import com.google.gwt.event.logical.shared.CloseEvent;
 import com.google.gwt.event.logical.shared.CloseHandler;
 import com.google.gwt.event.shared.HandlerRegistration;
 import com.google.gwt.user.client.Timer;
 import com.google.gwt.user.client.ui.Composite;
 import com.google.gwt.user.client.ui.HasName;
 import com.google.gwt.user.client.ui.HorizontalPanel;
 import com.google.gwt.user.client.ui.Widget;
 
 public class KSSelectedList extends Composite implements HasDataValue, HasName, HasSelectionChangeHandlers, HasWidgetReadyCallback, TranslatableValueWidget, HasInputWidget, HasFocusLostCallbacks, HasCrossConstraints, ValidationProcessable {
     private static final String VALUE = "value";
     private static final String DISPLAY = "display";
 
     private String name;
     private boolean initialized;
     private VerticalFlowPanel mainPanel;
     private HorizontalPanel pickerPanel;
     private KSPicker picker;
     private KSButton addItemButton;
     private KSListPanel valuesPanel;
 //    private List<SelectedValue> selectedValues = new ArrayList<SelectedValue>();
 //    private List<SelectedValue> removedValues = new ArrayList<SelectedValue>();
 
     private List<KSItemLabel> selectedItems = new ArrayList<KSItemLabel>();
     private List<KSItemLabel> removedItems = new ArrayList<KSItemLabel>();
     public static ItemDataHelper itemDataHelper = new ItemDataHelper();
 
     private final List<SelectionChangeHandler> selectionChangeHandlers = new ArrayList<SelectionChangeHandler>();
     private final List<Callback<Widget>> widgetReadyCallbacks = new ArrayList<Callback<Widget>>();
     private boolean hasDetails = false;
 
     private WidgetConfigInfo config;
 
     public KSSelectedList(WidgetConfigInfo config, boolean hasDetails) {
         init(config, hasDetails);
     }
 
     public KSSelectedList(WidgetConfigInfo config) {
         init(config, false);
     }
 
     public WidgetConfigInfo getConfig() {
         return config;
     }
 
     private void init(WidgetConfigInfo config, final boolean hasDetails) {
         this.config = config;
         this.hasDetails = hasDetails;
         mainPanel = new VerticalFlowPanel();
         initWidget(mainPanel);
         if (config.canEdit) {
             pickerPanel = new HorizontalPanel();
             pickerPanel.addStyleName("ks-selected-list-picker");
             addItemButton = new KSButton("Add to list", ButtonStyle.SECONDARY_SMALL);
             addItemButton.setEnabled(false);
             picker = new KSPicker(config);
             picker.setAdvancedSearchCallback(createAdvancedSearchCallback());
             addSelectionChangeHandler();
 
             addItemButton.addClickHandler(new ClickHandler() {
                 @Override
                 public void onClick(ClickEvent event) {
                         Value v = picker.getValue();
                         if(v instanceof DataValue){
                             Data d = ((DataValue) picker.getValue()).get();
                             
                             Iterator<Property> iter = d.realPropertyIterator();
                             while (iter.hasNext()) {
                                 Property p = iter.next();
                                 String s = p.getValue();
                                 KSItemLabel selectedItem = createItem(s, picker.getDisplayValue(),
                                         hasDetails);
                                 addItem(selectedItem);
                             }
                         }else{
                                 String s = v.get();
                         KSItemLabel selectedItem = createItem(s, picker.getDisplayValue(),
                                         hasDetails);
                             addItem(selectedItem);
                         }
                         picker.clear();
                     addItemButton.setEnabled(false);
                 }
             });
 
             pickerPanel.add(picker);
             pickerPanel.add(addItemButton);
 
 
             mainPanel.add(pickerPanel);
         }
 
 
         valuesPanel = new KSListPanel(ListType.UNORDERED);
         if (config.canEdit) {
             valuesPanel.setStyleName("ks-selected-list");
         } else {
             valuesPanel.setStyleName("ks-selected-list-readOnly");
         }
         mainPanel.add(valuesPanel);
         initialized = true;
         widgetReady();
     }
 
     public KSListPanel separateValuesPanel() {
         mainPanel.remove(valuesPanel);
         return valuesPanel;
     }
 
     private void widgetReady() {
         for (Callback<Widget> callback : widgetReadyCallbacks) {
             callback.exec(this);
         }
     }
 
     private Callback<List<SelectedResults>> createAdvancedSearchCallback() {
         Callback<List<SelectedResults>> result = new Callback<List<SelectedResults>>() {
             public void exec(List<SelectedResults> results) {
                 if (results.size() > 0) {
                     for (SelectedResults res : results) {
                         KSItemLabel item = createItem(res.getReturnKey(), res.getDisplayKey(), hasDetails);
                         addItem(item, false);
                     }
                     picker.clear();
                     addItemButton.setEnabled(false);
                     selectionChanged();
                 }
             }
 
         };
         return result;
     }
 
     /**
      * Adds handler when suggest box selection change event is fired and enables/disables the the
      * Add item button accordingly.
      */
     private void addSelectionChangeHandler() {
         if (picker.getInputWidget() instanceof KSSuggestBox) {
             KSSuggestBox suggestBox = (KSSuggestBox) picker.getInputWidget();
             suggestBox.addSelectionChangeHandler(new SelectionChangeHandler() {
                 @Override
                 public void onSelectionChange(SelectionChangeEvent event) {
                     //Compare the user entered value in picker's input textbox with the current display value
                     //from the picker suggest list, if they are the same (ie. user has selected item from list)
                     //then enable the add to list button. NOTE: This comparison should not be required if the picker
                     //ONLY fired selection change event when an actual selection change took place, but doesn't seem
                     //to be doing that.
                     String userValue = ((KSSuggestBox) picker.getInputWidget()).getText();
                     String displayValue = picker.getDisplayValue();
                     boolean enabled = displayValue != null && !displayValue.isEmpty() && displayValue.equals(userValue);
                     addItemButton.setEnabled(enabled);
                 }
             });
         } else if(picker.getInputWidget() instanceof KSDropDown){
                 KSDropDown dropDown = (KSDropDown) picker.getInputWidget();
                 dropDown.addSelectionChangeHandler(new SelectionChangeHandler() {
                 @Override
                 public void onSelectionChange(SelectionChangeEvent event) {
                         //Enable if not null
                     String displayValue = picker.getDisplayValue();
                     boolean enabled = displayValue != null && !displayValue.isEmpty();
                     addItemButton.setEnabled(enabled);
                 }
             });
         }
     }
 
     public void addItem(String value, String display) {
         addItem(createItem(value, display, hasDetails));
     }
     
     public void addItem(final KSItemLabel item) {
         addItem(item, true);
     }
 
     public void addItem(final KSItemLabel item, boolean fireChangeListeners) {
         if (removedItems.contains(item)) {
             removedItems.remove(item);
         }
         if (!selectedItems.contains(item)) {
             selectedItems.add(item);
         
                 valuesPanel.add(item);
                 if (fireChangeListeners) {
                     selectionChanged();
                 }
                 if (config.canEdit && fireChangeListeners) {
                     item.setHighlighted(true);
                     new Timer() {
                         @Override
                         public void run() {
                             item.setHighlighted(false);
                         }
                     }.schedule(5000);
                 } else {
                     item.removeHighlight();
                 }
         }
     }
 
     private void selectionChanged() {
         for (SelectionChangeHandler handler : selectionChangeHandlers) {
             handler.onSelectionChange(new SelectionChangeEvent(this));
         }
     }
 
     public void clear() {
         selectedItems = new ArrayList<KSItemLabel>();
         removedItems = new ArrayList<KSItemLabel>();
         valuesPanel.clear();
     }
 
     @Override
     public String getName() {
 
         return name;
     }
 
     @Override
     public void setName(String name) {
         this.name = name;
     }
 
 
     @Override
     public HandlerRegistration addSelectionChangeHandler(final SelectionChangeHandler handler) {
         selectionChangeHandlers.add(handler);
         HandlerRegistration result = new HandlerRegistration() {
             @Override
             public void removeHandler() {
                 selectionChangeHandlers.remove(handler);
             }
         };
         return result;
     }
 
     @Override
     public void addWidgetReadyCallback(Callback<Widget> callback) {
         widgetReadyCallbacks.add(callback);
     }
 
     @Override
     public boolean isInitialized() {
         return initialized;
     }
 
     @Override
     public void setInitialized(boolean initialized) {
         this.initialized = initialized;
     }
 
 
     @Override
     public void addValueChangeCallback(Callback<Value> callback) {
         // TODO ryan - THIS METHOD NEEDS JAVADOCS
 
     }
 
     @Override
     public Value getValue() {
         Data data = new Data();
         for (KSItemLabel item : selectedItems) {
             data.add(item.getKey());
         }
         if (picker.getDisplayValue().equals(UtilConstants.IMPOSSIBLE_CHARACTERS)) {
             data.add(UtilConstants.IMPOSSIBLE_CHARACTERS);
         }
         DataValue result = new DataValue(data);
         return result;
     }
 
     public List<KSItemLabel> getSelectedItems() {
         return selectedItems;
     }
 
     /**
      * Returns all selected values along with their translations in the _runtime data.
      *
      * @return
      */
     public Value getValueWithTranslations() {
         Data data = new Data();
         Data _runtimeData = new Data();
 
         for (KSItemLabel item : selectedItems) {
             data.add(item.getKey());
             Data displayData = new Data();
             displayData.set("id-translation", item.getDisplayText());
             _runtimeData.add(displayData);
         }
         if (picker.getDisplayValue().equals(UtilConstants.IMPOSSIBLE_CHARACTERS)) {
             data.add(UtilConstants.IMPOSSIBLE_CHARACTERS);
             Data displayData = new Data();
             displayData.set("id-translation", UtilConstants.IMPOSSIBLE_CHARACTERS);
             _runtimeData.add(displayData);
         }
         data.set(new StringKey("_runtimeData"), _runtimeData);
         DataValue result = new DataValue(data);
         return result;
     }
 
     private KSItemLabel createItem(String value, String display, boolean hasDetails) {
         Data itemData = toItemData(value, display);
         DataValue itemDataValue = new DataValue(itemData);
         KSItemLabel item = new KSItemLabel(KSSelectedList.this.config.canEdit, hasDetails,
                 itemDataHelper);
         item.setValue(itemDataValue);
         item.addCloseHandler(new CloseHandler<KSItemLabel>() {
             @Override
             public void onClose(CloseEvent<KSItemLabel> event) {
                 KSItemLabel itemToBeDeleted = event.getTarget();
                 selectedItems.remove(itemToBeDeleted);
                 removedItems.add(itemToBeDeleted);
                 valuesPanel.remove(itemToBeDeleted);
                 selectionChanged();
             }
         });
         return item;
     }
 
     private Data toItemData(String value, String display) {
         Data data = new Data();
         data.set(VALUE, value);
         data.set(DISPLAY, display);
         return data;
     }
 
     @Override
     public void setValue(Value value) {
         clear();
         if (value != null) {
                 try{
                         if(value instanceof DataValue){
                             Data data = ((DataValue) value).get();
                             Iterator<Property> iter = data.realPropertyIterator();
                             while (iter.hasNext()) {
                                 Property p = iter.next();
                                 setSingleValue(p.getValue());
                             }
                         }else{
                                 setSingleValue(value.get());
                         }
                 }catch(ClassCastException cce){
                         String errorMsg =         "ClassCastException in KSSelectedList.java::setValue \n " +
                                                                 "Trying to cast Value from: " + value.getClass().getName() + "\n " +
                                                                 "TO DataValue.java. \n Value was of type " + value.getType().getName() + "\n ";
                         try{                        
                                 errorMsg += "Value=["+ value.get().toString() +"]";
                         }catch(Exception ex){
                                 errorMsg += "Error printing error value: " + ex.getMessage();
                         }
                         
                         throw new ClassCastException(errorMsg);
                 }
         }
     }
 
     private void setSingleValue(Object pVal) {
         String v = null;
         if(pVal != null){
                 v = pVal.toString();
         }
         //FIXME: do we need to do a search? is this method ever going to be called?
         KSItemLabel item = createItem(v, "Display: " + v, hasDetails);
         addItem(item);
         }
 
         @Override
     public void addFocusLostCallback(Callback<Boolean> callback) {
         if (picker != null)
             picker.addFocusLostCallback(callback);
     }
 
     public static class ItemDataHelper implements DataHelper {
 
         @Override
         public String parse(Data data) {
             String result;
             if (data == null) {
                 return null;
             }
             result = (String) data.get(DISPLAY);
             return result;
         }
 
         @Override
         public String getKey(Data data) {
             String result;
             if (data == null) {
                 return null;
             }
             result = (String) data.get(VALUE);
             return result;
         }
 
     }
 
     @Override
     public void setValue(String id, String translation) {
         clear();
         if (id != null && translation != null) {
             addItem(createItem(id, translation, hasDetails), false);
         }
     }
 
     @Override
     public void setValue(Map<String, String> translations) {
         clear();
         if (translations != null) {
             for (Entry<String, String> e : translations.entrySet()) {
                 addItem(createItem(e.getKey(), e.getValue(), hasDetails), false);
             }
         }
     }
 
     @Override
     public Widget getInputWidget() {
         if (picker == null) {
             return valuesPanel;
         }
         return picker.getInputWidget();
     }
 
         @Override
         public HashSet<String> getCrossConstraints() {
                 if(picker!=null){
                         return picker.getCrossConstraints();
                 }
                 return new HashSet<String>();
         }
 
         @Override
         public void reprocessWithUpdatedConstraints() {
                 if(picker!=null){
                         picker.reprocessWithUpdatedConstraints();
                 }
         }
 
         public KSButton getAddItemButton() {
                 return addItemButton;
         }
 
         public VerticalFlowPanel getMainPanel() {
                 return mainPanel;
         }
 
         public KSPicker getPicker() {
                 return picker;
         }
 
         @Override
         public ErrorLevel processValidationResult(ValidationResultInfo vr) {
                 //Validation results passed to selected list should be in the form foo/bar/1
                 String indexNumber=vr.getElement().substring(vr.getElement().lastIndexOf('/')+1);
                 int index = Integer.parseInt(indexNumber);
                 if(index<getSelectedItems().size()){
                         KSItemLabel itemLabel = getSelectedItems().get(index);
                         return itemLabel.processValidationResult(vr, vr.getElement().substring(0, vr.getElement().lastIndexOf('/')));
                 }else{
                         return ErrorLevel.OK;
                 }
         }
 
         @Override
         public boolean shouldProcessValidationResult(ValidationResultInfo vr) {
                 //Check if the element ends in a number and is thus a list of primitives (foo/bar/2)
                 if(vr.getElement()!=null&&vr.getElement().matches("^\\S+/[0-9]+$")){
                         return true;
                 }
                 return false;
         }
 
 }

1		/**
2		* Copyright 2010 The Kuali Foundation Licensed under the
3		* Educational Community License, Version 2.0 (the "License"); you may
4		* not use this file except in compliance with the License. You may
5		* obtain a copy of the License at
6		*
7		* http://www.osedu.org/licenses/ECL-2.0
8		*
9		* Unless required by applicable law or agreed to in writing,
10		* software distributed under the License is distributed on an "AS IS"
11		* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
12		* or implied. See the License for the specific language governing
13		* permissions and limitations under the License.
14		*/
15
16		package org.kuali.student.common.ui.client.widgets.list;
17
18		import java.util.ArrayList;
19		import java.util.HashSet;
20		import java.util.Iterator;
21		import java.util.List;
22		import java.util.Map;
23		import java.util.Map.Entry;
24
25		import org.kuali.student.common.assembly.data.Data;
26		import org.kuali.student.common.assembly.data.Data.DataValue;
27		import org.kuali.student.common.assembly.data.Data.Property;
28		import org.kuali.student.common.assembly.data.Data.StringKey;
29		import org.kuali.student.common.assembly.data.Data.Value;
30		import org.kuali.student.common.ui.client.configurable.mvc.WidgetConfigInfo;
31		import org.kuali.student.common.ui.client.mvc.Callback;
32		import org.kuali.student.common.ui.client.mvc.HasCrossConstraints;
33		import org.kuali.student.common.ui.client.mvc.HasDataValue;
34		import org.kuali.student.common.ui.client.mvc.HasFocusLostCallbacks;
35		import org.kuali.student.common.ui.client.mvc.HasWidgetReadyCallback;
36		import org.kuali.student.common.ui.client.mvc.TranslatableValueWidget;
37		import org.kuali.student.common.ui.client.util.UtilConstants;
38		import org.kuali.student.common.ui.client.widgets.DataHelper;
39		import org.kuali.student.common.ui.client.widgets.HasInputWidget;
40		import org.kuali.student.common.ui.client.widgets.KSButton;
41		import org.kuali.student.common.ui.client.widgets.KSButtonAbstract.ButtonStyle;
42		import org.kuali.student.common.ui.client.widgets.KSDropDown;
43		import org.kuali.student.common.ui.client.widgets.KSItemLabel;
44		import org.kuali.student.common.ui.client.widgets.field.layout.element.ValidationProcessable;
45		import org.kuali.student.common.ui.client.widgets.layout.VerticalFlowPanel;
46		import org.kuali.student.common.ui.client.widgets.menus.KSListPanel;
47		import org.kuali.student.common.ui.client.widgets.menus.KSListPanel.ListType;
48		import org.kuali.student.common.ui.client.widgets.search.KSPicker;
49		import org.kuali.student.common.ui.client.widgets.search.SelectedResults;
50		import org.kuali.student.common.ui.client.widgets.suggestbox.KSSuggestBox;
51		import org.kuali.student.common.validation.dto.ValidationResultInfo;
52		import org.kuali.student.common.validation.dto.ValidationResultInfo.ErrorLevel;
53
54		import com.google.gwt.event.dom.client.ClickEvent;
55		import com.google.gwt.event.dom.client.ClickHandler;
56		import com.google.gwt.event.logical.shared.CloseEvent;
57		import com.google.gwt.event.logical.shared.CloseHandler;
58		import com.google.gwt.event.shared.HandlerRegistration;
59		import com.google.gwt.user.client.Timer;
60		import com.google.gwt.user.client.ui.Composite;
61		import com.google.gwt.user.client.ui.HasName;
62		import com.google.gwt.user.client.ui.HorizontalPanel;
63		import com.google.gwt.user.client.ui.Widget;
64
65	0	public class KSSelectedList extends Composite implements HasDataValue, HasName, HasSelectionChangeHandlers, HasWidgetReadyCallback, TranslatableValueWidget, HasInputWidget, HasFocusLostCallbacks, HasCrossConstraints, ValidationProcessable {
66		private static final String VALUE = "value";
67		private static final String DISPLAY = "display";
68
69		private String name;
70		private boolean initialized;
71		private VerticalFlowPanel mainPanel;
72		private HorizontalPanel pickerPanel;
73		private KSPicker picker;
74		private KSButton addItemButton;
75		private KSListPanel valuesPanel;
76		// private List<SelectedValue> selectedValues = new ArrayList<SelectedValue>();
77		// private List<SelectedValue> removedValues = new ArrayList<SelectedValue>();
78
79	0	private List<KSItemLabel> selectedItems = new ArrayList<KSItemLabel>();
80	0	private List<KSItemLabel> removedItems = new ArrayList<KSItemLabel>();
81	0	public static ItemDataHelper itemDataHelper = new ItemDataHelper();
82
83	0	private final List<SelectionChangeHandler> selectionChangeHandlers = new ArrayList<SelectionChangeHandler>();
84	0	private final List<Callback<Widget>> widgetReadyCallbacks = new ArrayList<Callback<Widget>>();
85	0	private boolean hasDetails = false;
86
87		private WidgetConfigInfo config;
88
89	0	public KSSelectedList(WidgetConfigInfo config, boolean hasDetails) {
90	0	init(config, hasDetails);
91	0	}
92
93	0	public KSSelectedList(WidgetConfigInfo config) {
94	0	init(config, false);
95	0	}
96
97		public WidgetConfigInfo getConfig() {
98	0	return config;
99		}
100
101		private void init(WidgetConfigInfo config, final boolean hasDetails) {
102	0	this.config = config;
103	0	this.hasDetails = hasDetails;
104	0	mainPanel = new VerticalFlowPanel();
105	0	initWidget(mainPanel);
106	0	if (config.canEdit) {
107	0	pickerPanel = new HorizontalPanel();
108	0	pickerPanel.addStyleName("ks-selected-list-picker");
109	0	addItemButton = new KSButton("Add to list", ButtonStyle.SECONDARY_SMALL);
110	0	addItemButton.setEnabled(false);
111	0	picker = new KSPicker(config);
112	0	picker.setAdvancedSearchCallback(createAdvancedSearchCallback());
113	0	addSelectionChangeHandler();
114
115	0	addItemButton.addClickHandler(new ClickHandler() {
116		@Override
117		public void onClick(ClickEvent event) {
118	0	Value v = picker.getValue();
119	0	if(v instanceof DataValue){
120	0	Data d = ((DataValue) picker.getValue()).get();
121
122	0	Iterator<Property> iter = d.realPropertyIterator();
123	0	while (iter.hasNext()) {
124	0	Property p = iter.next();
125	0	String s = p.getValue();
126	0	KSItemLabel selectedItem = createItem(s, picker.getDisplayValue(),
127		hasDetails);
128	0	addItem(selectedItem);
129	0	}
130	0	}else{
131	0	String s = v.get();
132	0	KSItemLabel selectedItem = createItem(s, picker.getDisplayValue(),
133		hasDetails);
134	0	addItem(selectedItem);
135		}
136	0	picker.clear();
137	0	addItemButton.setEnabled(false);
138	0	}
139		});
140
141	0	pickerPanel.add(picker);
142	0	pickerPanel.add(addItemButton);
143
144
145	0	mainPanel.add(pickerPanel);
146		}
147
148
149	0	valuesPanel = new KSListPanel(ListType.UNORDERED);
150	0	if (config.canEdit) {
151	0	valuesPanel.setStyleName("ks-selected-list");
152		} else {
153	0	valuesPanel.setStyleName("ks-selected-list-readOnly");
154		}
155	0	mainPanel.add(valuesPanel);
156	0	initialized = true;
157	0	widgetReady();
158	0	}
159
160		public KSListPanel separateValuesPanel() {
161	0	mainPanel.remove(valuesPanel);
162	0	return valuesPanel;
163		}
164
165		private void widgetReady() {
166	0	for (Callback<Widget> callback : widgetReadyCallbacks) {
167	0	callback.exec(this);
168		}
169	0	}
170
171		private Callback<List<SelectedResults>> createAdvancedSearchCallback() {
172	0	Callback<List<SelectedResults>> result = new Callback<List<SelectedResults>>() {
173		public void exec(List<SelectedResults> results) {
174	0	if (results.size() > 0) {
175	0	for (SelectedResults res : results) {
176	0	KSItemLabel item = createItem(res.getReturnKey(), res.getDisplayKey(), hasDetails);
177	0	addItem(item, false);
178	0	}
179	0	picker.clear();
180	0	addItemButton.setEnabled(false);
181	0	selectionChanged();
182		}
183	0	}
184
185		};
186	0	return result;
187		}
188
189		/**
190		* Adds handler when suggest box selection change event is fired and enables/disables the the
191		* Add item button accordingly.
192		*/
193		private void addSelectionChangeHandler() {
194	0	if (picker.getInputWidget() instanceof KSSuggestBox) {
195	0	KSSuggestBox suggestBox = (KSSuggestBox) picker.getInputWidget();
196	0	suggestBox.addSelectionChangeHandler(new SelectionChangeHandler() {
197		@Override
198		public void onSelectionChange(SelectionChangeEvent event) {
199		//Compare the user entered value in picker's input textbox with the current display value
200		//from the picker suggest list, if they are the same (ie. user has selected item from list)
201		//then enable the add to list button. NOTE: This comparison should not be required if the picker
202		//ONLY fired selection change event when an actual selection change took place, but doesn't seem
203		//to be doing that.
204	0	String userValue = ((KSSuggestBox) picker.getInputWidget()).getText();
205	0	String displayValue = picker.getDisplayValue();
206	0	boolean enabled = displayValue != null && !displayValue.isEmpty() && displayValue.equals(userValue);
207	0	addItemButton.setEnabled(enabled);
208	0	}
209		});
210	0	} else if(picker.getInputWidget() instanceof KSDropDown){
211	0	KSDropDown dropDown = (KSDropDown) picker.getInputWidget();
212	0	dropDown.addSelectionChangeHandler(new SelectionChangeHandler() {
213		@Override
214		public void onSelectionChange(SelectionChangeEvent event) {
215		//Enable if not null
216	0	String displayValue = picker.getDisplayValue();
217	0	boolean enabled = displayValue != null && !displayValue.isEmpty();
218	0	addItemButton.setEnabled(enabled);
219	0	}
220		});
221		}
222	0	}
223
224		public void addItem(String value, String display) {
225	0	addItem(createItem(value, display, hasDetails));
226	0	}
227
228		public void addItem(final KSItemLabel item) {
229	0	addItem(item, true);
230	0	}
231
232		public void addItem(final KSItemLabel item, boolean fireChangeListeners) {
233	0	if (removedItems.contains(item)) {
234	0	removedItems.remove(item);
235		}
236	0	if (!selectedItems.contains(item)) {
237	0	selectedItems.add(item);
238
239	0	valuesPanel.add(item);
240	0	if (fireChangeListeners) {
241	0	selectionChanged();
242		}
243	0	if (config.canEdit && fireChangeListeners) {
244	0	item.setHighlighted(true);
245	0	new Timer() {
246		@Override
247		public void run() {
248	0	item.setHighlighted(false);
249	0	}
250		}.schedule(5000);
251		} else {
252	0	item.removeHighlight();
253		}
254		}
255	0	}
256
257		private void selectionChanged() {
258	0	for (SelectionChangeHandler handler : selectionChangeHandlers) {
259	0	handler.onSelectionChange(new SelectionChangeEvent(this));
260		}
261	0	}
262
263		public void clear() {
264	0	selectedItems = new ArrayList<KSItemLabel>();
265	0	removedItems = new ArrayList<KSItemLabel>();
266	0	valuesPanel.clear();
267	0	}
268
269		@Override
270		public String getName() {
271
272	0	return name;
273		}
274
275		@Override
276		public void setName(String name) {
277	0	this.name = name;
278	0	}
279
280
281		@Override
282		public HandlerRegistration addSelectionChangeHandler(final SelectionChangeHandler handler) {
283	0	selectionChangeHandlers.add(handler);
284	0	HandlerRegistration result = new HandlerRegistration() {
285		@Override
286		public void removeHandler() {
287	0	selectionChangeHandlers.remove(handler);
288	0	}
289		};
290	0	return result;
291		}
292
293		@Override
294		public void addWidgetReadyCallback(Callback<Widget> callback) {
295	0	widgetReadyCallbacks.add(callback);
296	0	}
297
298		@Override
299		public boolean isInitialized() {
300	0	return initialized;
301		}
302
303		@Override
304		public void setInitialized(boolean initialized) {
305	0	this.initialized = initialized;
306	0	}
307
308
309		@Override
310		public void addValueChangeCallback(Callback<Value> callback) {
311		// TODO ryan - THIS METHOD NEEDS JAVADOCS
312
313	0	}
314
315		@Override
316		public Value getValue() {
317	0	Data data = new Data();
318	0	for (KSItemLabel item : selectedItems) {
319	0	data.add(item.getKey());
320		}
321	0	if (picker.getDisplayValue().equals(UtilConstants.IMPOSSIBLE_CHARACTERS)) {
322	0	data.add(UtilConstants.IMPOSSIBLE_CHARACTERS);
323		}
324	0	DataValue result = new DataValue(data);
325	0	return result;
326		}
327
328		public List<KSItemLabel> getSelectedItems() {
329	0	return selectedItems;
330		}
331
332		/**
333		* Returns all selected values along with their translations in the _runtime data.
334		*
335		* @return
336		*/
337		public Value getValueWithTranslations() {
338	0	Data data = new Data();
339	0	Data _runtimeData = new Data();
340
341	0	for (KSItemLabel item : selectedItems) {
342	0	data.add(item.getKey());
343	0	Data displayData = new Data();
344	0	displayData.set("id-translation", item.getDisplayText());
345	0	_runtimeData.add(displayData);
346	0	}
347	0	if (picker.getDisplayValue().equals(UtilConstants.IMPOSSIBLE_CHARACTERS)) {
348	0	data.add(UtilConstants.IMPOSSIBLE_CHARACTERS);
349	0	Data displayData = new Data();
350	0	displayData.set("id-translation", UtilConstants.IMPOSSIBLE_CHARACTERS);
351	0	_runtimeData.add(displayData);
352		}
353	0	data.set(new StringKey("_runtimeData"), _runtimeData);
354	0	DataValue result = new DataValue(data);
355	0	return result;
356		}
357
358		private KSItemLabel createItem(String value, String display, boolean hasDetails) {
359	0	Data itemData = toItemData(value, display);
360	0	DataValue itemDataValue = new DataValue(itemData);
361	0	KSItemLabel item = new KSItemLabel(KSSelectedList.this.config.canEdit, hasDetails,
362		itemDataHelper);
363	0	item.setValue(itemDataValue);
364	0	item.addCloseHandler(new CloseHandler<KSItemLabel>() {
365		@Override
366		public void onClose(CloseEvent<KSItemLabel> event) {
367	0	KSItemLabel itemToBeDeleted = event.getTarget();
368	0	selectedItems.remove(itemToBeDeleted);
369	0	removedItems.add(itemToBeDeleted);
370	0	valuesPanel.remove(itemToBeDeleted);
371	0	selectionChanged();
372	0	}
373		});
374	0	return item;
375		}
376
377		private Data toItemData(String value, String display) {
378	0	Data data = new Data();
379	0	data.set(VALUE, value);
380	0	data.set(DISPLAY, display);
381	0	return data;
382		}
383
384		@Override
385		public void setValue(Value value) {
386	0	clear();
387	0	if (value != null) {
388		try{
389	0	if(value instanceof DataValue){
390	0	Data data = ((DataValue) value).get();
391	0	Iterator<Property> iter = data.realPropertyIterator();
392	0	while (iter.hasNext()) {
393	0	Property p = iter.next();
394	0	setSingleValue(p.getValue());
395	0	}
396	0	}else{
397	0	setSingleValue(value.get());
398		}
399	0	}catch(ClassCastException cce){
400	0	String errorMsg = "ClassCastException in KSSelectedList.java::setValue \n " +
401		"Trying to cast Value from: " + value.getClass().getName() + "\n " +
402		"TO DataValue.java. \n Value was of type " + value.getType().getName() + "\n ";
403		try{
404	0	errorMsg += "Value=["+ value.get().toString() +"]";
405	0	}catch(Exception ex){
406	0	errorMsg += "Error printing error value: " + ex.getMessage();
407	0	}
408
409	0	throw new ClassCastException(errorMsg);
410	0	}
411		}
412	0	}
413
414		private void setSingleValue(Object pVal) {
415	0	String v = null;
416	0	if(pVal != null){
417	0	v = pVal.toString();
418		}
419		//FIXME: do we need to do a search? is this method ever going to be called?
420	0	KSItemLabel item = createItem(v, "Display: " + v, hasDetails);
421	0	addItem(item);
422	0	}
423
424		@Override
425		public void addFocusLostCallback(Callback<Boolean> callback) {
426	0	if (picker != null)
427	0	picker.addFocusLostCallback(callback);
428	0	}
429
430	0	public static class ItemDataHelper implements DataHelper {
431
432		@Override
433		public String parse(Data data) {
434		String result;
435	0	if (data == null) {
436	0	return null;
437		}
438	0	result = (String) data.get(DISPLAY);
439	0	return result;
440		}
441
442		@Override
443		public String getKey(Data data) {
444		String result;
445	0	if (data == null) {
446	0	return null;
447		}
448	0	result = (String) data.get(VALUE);
449	0	return result;
450		}
451
452		}
453
454		@Override
455		public void setValue(String id, String translation) {
456	0	clear();
457	0	if (id != null && translation != null) {
458	0	addItem(createItem(id, translation, hasDetails), false);
459		}
460	0	}
461
462		@Override
463		public void setValue(Map<String, String> translations) {
464	0	clear();
465	0	if (translations != null) {
466	0	for (Entry<String, String> e : translations.entrySet()) {
467	0	addItem(createItem(e.getKey(), e.getValue(), hasDetails), false);
468		}
469		}
470	0	}
471
472		@Override
473		public Widget getInputWidget() {
474	0	if (picker == null) {
475	0	return valuesPanel;
476		}
477	0	return picker.getInputWidget();
478		}
479
480		@Override
481		public HashSet<String> getCrossConstraints() {
482	0	if(picker!=null){
483	0	return picker.getCrossConstraints();
484		}
485	0	return new HashSet<String>();
486		}
487
488		@Override
489		public void reprocessWithUpdatedConstraints() {
490	0	if(picker!=null){
491	0	picker.reprocessWithUpdatedConstraints();
492		}
493	0	}
494
495		public KSButton getAddItemButton() {
496	0	return addItemButton;
497		}
498
499		public VerticalFlowPanel getMainPanel() {
500	0	return mainPanel;
501		}
502
503		public KSPicker getPicker() {
504	0	return picker;
505		}
506
507		@Override
508		public ErrorLevel processValidationResult(ValidationResultInfo vr) {
509		//Validation results passed to selected list should be in the form foo/bar/1
510	0	String indexNumber=vr.getElement().substring(vr.getElement().lastIndexOf('/')+1);
511	0	int index = Integer.parseInt(indexNumber);
512	0	if(index<getSelectedItems().size()){
513	0	KSItemLabel itemLabel = getSelectedItems().get(index);
514	0	return itemLabel.processValidationResult(vr, vr.getElement().substring(0, vr.getElement().lastIndexOf('/')));
515		}else{
516	0	return ErrorLevel.OK;
517		}
518		}
519
520		@Override
521		public boolean shouldProcessValidationResult(ValidationResultInfo vr) {
522		//Check if the element ends in a number and is thus a list of primitives (foo/bar/2)
523	0	if(vr.getElement()!=null&&vr.getElement().matches("^\\S+/[0-9]+$")){
524	0	return true;
525		}
526	0	return false;
527		}
528
529		}