import com.vaadin.server.ErrorMessage;
import com.vaadin.server.UserError;
import com.vaadin.shared.Registration;
+import com.vaadin.shared.data.selection.SelectionModel.Multi;
import com.vaadin.ui.AbstractComponent;
+import com.vaadin.ui.AbstractMultiSelect;
import com.vaadin.ui.AbstractSingleSelect;
import com.vaadin.ui.Component;
import com.vaadin.ui.Label;
});
}
+ /**
+ * Creates a new binding for the given multi select component. The returned
+ * binding may be further configured before invoking
+ * {@link Binding#bind(Function, BiConsumer) Binding.bind} which completes
+ * the binding. Until {@code Binding.bind} is called, the binding has no
+ * effect.
+ *
+ * @param <SELECTVALUE>
+ * the item type of the select
+ * @param select
+ * the select to be bound, not null
+ * @return the new binding
+ */
+ public <SELECTVALUE> Binding<BEAN, Set<SELECTVALUE>, Set<SELECTVALUE>> forSelect(
+ AbstractMultiSelect<SELECTVALUE> select) {
+ return forField(new HasValue<Set<SELECTVALUE>>() {
+
+ @Override
+ public void setValue(Set<SELECTVALUE> value) {
+ Multi<SELECTVALUE> selectionModel = select.getSelectionModel();
+ selectionModel.deselectAll();
+ value.forEach(selectionModel::select);
+ }
+
+ @Override
+ public Set<SELECTVALUE> getValue() {
+ return select.getSelectionModel().getSelectedItems();
+ }
+
+ @Override
+ public Registration addValueChangeListener(
+ ValueChangeListener<? super Set<SELECTVALUE>> listener) {
+ return select.addSelectionListener(
+ e -> listener.accept(new ValueChange<>(select,
+ getValue(), e.isUserOriginated())));
+ }
+ });
+ }
+
/**
* Binds a field to a bean property represented by the given getter and
* setter pair. The functions are used to update the field value from the
forSelect(select).bind(getter, setter);
}
+ /**
+ * Binds a multi select to a bean property represented by the given getter
+ * and setter pair. The functions are used to update the set of selected
+ * items from the property and to store the selection to the property,
+ * respectively.
+ * <p>
+ * Use the {@link #forSelect(AbstractMultiSelect)} method instead if you
+ * want to further configure the new binding.
+ * <p>
+ * When a bean is bound with {@link Binder#bind(BEAN)}, the set of selected
+ * items are set to the return value of the given getter. The property value
+ * is then updated via the given setter whenever the selected items changes.
+ * The setter may be null; in that case the property value is never updated
+ * and the binding is said to be <i>read-only</i>.
+ * <p>
+ * If the Binder is already bound to some item, the newly bound select is
+ * associated with the corresponding bean property as described above.
+ * <p>
+ * The getter and setter can be arbitrary functions, for instance
+ * implementing user-defined conversion or validation. However, in the most
+ * basic use case you can simply pass a pair of method references to this
+ * method as follows:
+ *
+ * <pre>
+ * class Feature {
+ * public enum Browser { CHROME, EDGE, FIREFOX, IE, OPERA, SAFARI }
+
+ * public Set<Browser> getSupportedBrowsers() { ... }
+ * public void setSupportedBrowsers(Set<Browser> title) { ... }
+ * }
+ *
+ * CheckBoxGroup<Title> browserSelect = new CheckBoxGroup<>();
+ * browserSelect.setItems(Browser.values());
+ * binder.bind(browserSelect, Feature::getSupportedBrowsers, Feature::setSupportedBrowsers);
+ * </pre>
+ *
+ * @param <SELECTVALUE>
+ * the item type of the select
+ * @param select
+ * the select to bind, not null
+ * @param getter
+ * the function to get the set of selected items, not null
+ * @param setter
+ * the function to save the set of selected items or null if
+ * read-only
+ */
+ public <SELECTVALUE> void bind(AbstractMultiSelect<SELECTVALUE> select,
+ Function<BEAN, Set<SELECTVALUE>> getter,
+ BiConsumer<BEAN, Set<SELECTVALUE>> setter) {
+ forSelect(select).bind(getter, setter);
+ }
+
/**
* Binds the given bean to all the fields added to this Binder. To remove
* the binding, call {@link #unbind()}.
import java.util.Collections;
import java.util.Set;
-import com.vaadin.event.ConnectorEvent;
+import com.vaadin.data.HasValue.ValueChange;
import com.vaadin.shared.data.selection.SelectionModel;
import com.vaadin.ui.AbstractListing;
* @param <T>
* the data type of the selection model
*/
-public class MultiSelectionEvent<T> extends ConnectorEvent {
+public class MultiSelectionEvent<T> extends ValueChange<Set<T>> {
- private Set<T> oldSelection;
- private Set<T> newSelection;
+ private final Set<T> oldSelection;
/**
* Creates a new event.
* the old set of selected items
* @param newSelection
* the new set of selected items
+ * @param userOriginated
+ * {@code true} if this event originates from the client,
+ * {@code false} otherwise.
*/
public MultiSelectionEvent(
AbstractListing<T, SelectionModel.Multi<T>> source,
- Set<T> oldSelection, Set<T> newSelection) {
- super(source);
+ Set<T> oldSelection, Set<T> newSelection, boolean userOriginated) {
+ super(source, Collections.unmodifiableSet(newSelection),
+ userOriginated);
this.oldSelection = oldSelection;
- this.newSelection = newSelection;
}
/**
* @return a set of items selected after the selection was changed
*/
public Set<T> getNewSelection() {
- return Collections.unmodifiableSet(newSelection);
+ return getValue();
}
/**
public Set<T> getOldSelection() {
return Collections.unmodifiableSet(oldSelection);
}
-
}
--- /dev/null
+/*
+ * Copyright 2000-2016 Vaadin Ltd.
+ *
+ * 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.vaadin.ui;
+
+import java.lang.reflect.Method;
+import java.util.Objects;
+
+import com.vaadin.event.selection.MultiSelectionEvent;
+import com.vaadin.event.selection.MultiSelectionListener;
+import com.vaadin.shared.Registration;
+import com.vaadin.shared.data.selection.SelectionModel.Multi;
+import com.vaadin.util.ReflectTools;
+
+/**
+ * Base class for listing components that allow selecting multiple items.
+ *
+ * @param <T>
+ * item type
+ * @author Vaadin Ltd
+ * @since 8.0
+ */
+public abstract class AbstractMultiSelect<T>
+ extends AbstractListing<T, Multi<T>> {
+
+ @Deprecated
+ private static final Method SELECTION_CHANGE_METHOD = ReflectTools
+ .findMethod(MultiSelectionListener.class, "accept",
+ MultiSelectionEvent.class);
+
+ /**
+ * Creates a new multi select with an empty data source.
+ */
+ protected AbstractMultiSelect() {
+ super();
+ }
+
+ /**
+ * Adds a selection listener that will be called when the selection is
+ * changed either by the user or programmatically.
+ *
+ * @param listener
+ * the value change listener, not <code>null</code>
+ * @return a registration for the listener
+ */
+ public Registration addSelectionListener(
+ MultiSelectionListener<T> listener) {
+ Objects.requireNonNull(listener, "listener cannot be null");
+ addListener(MultiSelectionEvent.class, listener,
+ SELECTION_CHANGE_METHOD);
+ return () -> removeListener(MultiSelectionEvent.class, listener);
+ }
+
+}
\ No newline at end of file
package com.vaadin.ui;
-import java.lang.reflect.Method;
import java.util.Collection;
import java.util.Collections;
import java.util.LinkedHashSet;
import com.vaadin.data.Listing;
import com.vaadin.event.selection.MultiSelectionEvent;
-import com.vaadin.event.selection.MultiSelectionListener;
import com.vaadin.server.Resource;
import com.vaadin.server.ResourceReference;
import com.vaadin.server.data.DataGenerator;
import com.vaadin.server.data.DataSource;
-import com.vaadin.shared.Registration;
import com.vaadin.shared.data.selection.SelectionModel;
import com.vaadin.shared.data.selection.SelectionServerRpc;
import com.vaadin.shared.ui.optiongroup.CheckBoxGroupConstants;
import com.vaadin.shared.ui.optiongroup.CheckBoxGroupState;
-import com.vaadin.util.ReflectTools;
import elemental.json.JsonObject;
* @author Vaadin Ltd
* @since 8.0
*/
-public class CheckBoxGroup<T>
- extends AbstractListing<T, SelectionModel.Multi<T>> {
+public class CheckBoxGroup<T> extends AbstractMultiSelect<T> {
private final class SimpleMultiSelectModel
implements SelectionModel.Multi<T> {
@Override
public void select(T item) {
+ // Not user originated
+ select(item, false);
+ }
+
+ private void select(T item, boolean userOriginated) {
if (selection.contains(item)) {
return;
}
- updateSelection(set -> set.add(item));
+ updateSelection(set -> set.add(item), userOriginated);
}
@Override
@Override
public void deselect(T item) {
+ // Not user originated
+ deselect(item, false);
+ }
+
+ private void deselect(T item, boolean userOriginated) {
if (!selection.contains(item)) {
return;
}
- updateSelection(set -> set.remove(item));
+ updateSelection(set -> set.remove(item), userOriginated);
}
@Override
return;
}
- updateSelection(Set::clear);
+ updateSelection(Set::clear, false);
}
- private void updateSelection(Consumer<Set<T>> handler) {
+ private void updateSelection(Consumer<Set<T>> handler,
+ boolean userOriginated) {
LinkedHashSet<T> oldSelection = new LinkedHashSet<>(selection);
handler.accept(selection);
LinkedHashSet<T> newSelection = new LinkedHashSet<>(selection);
fireEvent(new MultiSelectionEvent<>(CheckBoxGroup.this,
- oldSelection, newSelection));
+ oldSelection, newSelection, userOriginated));
getDataCommunicator().reset();
}
}
}
- @Deprecated
- private static final Method SELECTION_CHANGE_METHOD = ReflectTools
- .findMethod(MultiSelectionListener.class, "accept",
- MultiSelectionEvent.class);
-
private Function<T, Resource> itemIconProvider = item -> null;
private Function<T, String> itemCaptionProvider = String::valueOf;
@Override
public void select(String key) {
- getItemForSelectionChange(key)
- .ifPresent(getSelectionModel()::select);
+ getItemForSelectionChange(key).ifPresent(
+ item -> getSelectionModel().select(item, true));
}
@Override
public void deselect(String key) {
- getItemForSelectionChange(key)
- .ifPresent(getSelectionModel()::deselect);
+ getItemForSelectionChange(key).ifPresent(
+ item -> getSelectionModel().deselect(item, true));
}
private Optional<T> getItemForSelectionChange(String key) {
return Optional.of(item);
}
+
+ private SimpleMultiSelectModel getSelectionModel() {
+ return (SimpleMultiSelectModel) CheckBoxGroup.this
+ .getSelectionModel();
+ }
});
addDataGenerator(new DataGenerator<T>() {
Objects.nonNull(itemEnabledProvider);
this.itemEnabledProvider = itemEnabledProvider;
}
-
- /**
- * Adds a selection listener that will be called when the selection is
- * changed either by the user or programmatically.
- *
- * @param listener
- * the value change listener, not <code>null</code>
- * @return a registration for the listener
- */
- public Registration addSelectionListener(
- MultiSelectionListener<T> listener) {
- Objects.requireNonNull(listener, "listener cannot be null");
- addListener(MultiSelectionEvent.class, listener,
- SELECTION_CHANGE_METHOD);
- return () -> removeListener(MultiSelectionEvent.class, listener);
- }
}
--- /dev/null
+/*
+ * Copyright 2000-2016 Vaadin Ltd.
+ *
+ * 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.vaadin.data;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import java.util.Collections;
+import java.util.Locale;
+import java.util.Set;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import com.vaadin.data.util.converter.Converter;
+import com.vaadin.tests.data.bean.BeanWithEnums;
+import com.vaadin.tests.data.bean.TestEnum;
+import com.vaadin.ui.CheckBoxGroup;
+
+public class BinderMultiSelectTest
+ extends BinderTestBase<Binder<BeanWithEnums>, BeanWithEnums> {
+ public class TestEnumSetToStringConverter
+ implements Converter<Set<TestEnum>, String> {
+ @Override
+ public Result<String> convertToModel(Set<TestEnum> value,
+ Locale locale) {
+ return Result.ok(value.stream().map(TestEnum::name)
+ .collect(Collectors.joining(",")));
+ }
+
+ @Override
+ public Set<TestEnum> convertToPresentation(String value,
+ Locale locale) {
+ return Stream.of(value.split(","))
+ .filter(string -> !string.isEmpty()).map(TestEnum::valueOf)
+ .collect(Collectors.toSet());
+ }
+ }
+
+ private Binder<AtomicReference<String>> converterBinder = new Binder<>();
+
+ private CheckBoxGroup<TestEnum> select;
+
+ @Before
+ public void setUp() {
+ binder = new Binder<>();
+ item = new BeanWithEnums();
+ select = new CheckBoxGroup<>();
+ select.setItems(TestEnum.values());
+
+ converterBinder.forSelect(select)
+ .withConverter(new TestEnumSetToStringConverter())
+ .bind(AtomicReference<String>::get,
+ AtomicReference<String>::set);
+ }
+
+ @Test
+ public void beanBound_bindSelectByShortcut_selectionUpdated() {
+ item.setEnums(Collections.singleton(TestEnum.ONE));
+ binder.bind(item);
+ binder.bind(select, BeanWithEnums::getEnums, BeanWithEnums::setEnums);
+
+ assertEquals(Collections.singleton(TestEnum.ONE),
+ select.getSelectedItems());
+ }
+
+ @Test
+ public void beanBound_bindSelect_selectionUpdated() {
+ item.setEnums(Collections.singleton(TestEnum.TWO));
+ binder.bind(item);
+ binder.forSelect(select).bind(BeanWithEnums::getEnums,
+ BeanWithEnums::setEnums);
+
+ assertEquals(Collections.singleton(TestEnum.TWO),
+ select.getSelectedItems());
+ }
+
+ @Test
+ public void selectBound_bindBeanWithoutEnums_selectedItemNotPresent() {
+ bindEnum();
+
+ assertTrue(select.getSelectedItems().isEmpty());
+ }
+
+ @Test
+ public void selectBound_bindBean_selectionUpdated() {
+ item.setEnums(Collections.singleton(TestEnum.ONE));
+ bindEnum();
+
+ assertEquals(Collections.singleton(TestEnum.ONE),
+ select.getSelectedItems());
+ }
+
+ @Test
+ public void bound_setSelection_beanValueUpdated() {
+ bindEnum();
+
+ select.select(TestEnum.TWO);
+
+ assertEquals(Collections.singleton(TestEnum.TWO), item.getEnums());
+ }
+
+ @Test
+ public void bound_deselect_beanValueUpdatedToNull() {
+ item.setEnums(Collections.singleton(TestEnum.ONE));
+ bindEnum();
+
+ select.deselect(TestEnum.ONE);
+
+ assertTrue(item.getEnums().isEmpty());
+ }
+
+ @Test
+ public void unbound_changeSelection_beanValueNotUpdated() {
+ item.setEnums(Collections.singleton(TestEnum.ONE));
+ bindEnum();
+ binder.unbind();
+
+ select.select(TestEnum.TWO);
+
+ assertEquals(Collections.singleton(TestEnum.ONE), item.getEnums());
+ }
+
+ @Test
+ public void withConverter_load_selectUpdated() {
+ converterBinder.load(new AtomicReference<>("TWO"));
+
+ assertEquals(Collections.singleton(TestEnum.TWO),
+ select.getSelectionModel().getSelectedItems());
+ }
+
+ @Test
+ public void withConverter_save_referenceUpdated() {
+ select.select(TestEnum.ONE);
+ select.select(TestEnum.TWO);
+
+ AtomicReference<String> reference = new AtomicReference<>("");
+ converterBinder.saveIfValid(reference);
+
+ assertEquals("ONE,TWO", reference.get());
+ }
+
+ @Test
+ public void withValidator_validate_validatorUsed() {
+ binder.forSelect(select)
+ .withValidator(selection -> selection.size() % 2 == 1,
+ "Must select odd number of items")
+ .bind(BeanWithEnums::getEnums, BeanWithEnums::setEnums);
+ binder.bind(item);
+
+ assertFalse(binder.validate().isOk());
+
+ select.select(TestEnum.TWO);
+
+ assertTrue(binder.validate().isOk());
+ }
+
+ protected void bindEnum() {
+ binder.forSelect(select).bind(BeanWithEnums::getEnums,
+ BeanWithEnums::setEnums);
+ binder.bind(item);
+ }
+}
--- /dev/null
+/*
+ * Copyright 2000-2016 Vaadin Ltd.
+ *
+ * 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.vaadin.tests.data.bean;
+
+import java.util.HashSet;
+import java.util.Set;
+
+public class BeanWithEnums {
+ private Set<TestEnum> enums = new HashSet<>();
+
+ public Set<TestEnum> getEnums() {
+ return enums;
+ }
+
+ public void setEnums(Set<TestEnum> enums) {
+ this.enums = enums;
+ }
+}
import java.util.ArrayList;
import java.util.Arrays;
+import java.util.concurrent.atomic.AtomicInteger;
import org.junit.Assert;
+import org.junit.Before;
import org.junit.Test;
import com.vaadin.server.data.DataSource;
import com.vaadin.shared.data.selection.SelectionModel.Multi;
+import com.vaadin.shared.data.selection.SelectionServerRpc;
public class CheckBoxGroupTest {
- @Test
- public void stableSelectionOrder() {
- CheckBoxGroup<String> checkBoxGroup = new CheckBoxGroup<>();
+ private CheckBoxGroup<String> checkBoxGroup;
+ private Multi<String> selectionModel;
+
+ @Before
+ public void setUp() {
+ checkBoxGroup = new CheckBoxGroup<>();
// Intentional deviation from upcoming selection order
checkBoxGroup
.setDataSource(DataSource.create("Third", "Second", "First"));
- Multi<String> selectionModel = checkBoxGroup.getSelectionModel();
+ selectionModel = checkBoxGroup.getSelectionModel();
+ }
+ @Test
+ public void stableSelectionOrder() {
selectionModel.select("First");
selectionModel.select("Second");
selectionModel.select("Third");
assertSelectionOrder(selectionModel, "Second", "Third", "First");
}
+ @Test
+ public void apiSelectionChange_notUserOriginated() {
+ AtomicInteger listenerCount = new AtomicInteger(0);
+
+ checkBoxGroup.addSelectionListener(event -> {
+ listenerCount.incrementAndGet();
+ Assert.assertFalse(event.isUserOriginated());
+ });
+
+ checkBoxGroup.select("First");
+ checkBoxGroup.select("Second");
+
+ checkBoxGroup.deselect("Second");
+ checkBoxGroup.getSelectionModel().deselectAll();
+
+ Assert.assertEquals(4, listenerCount.get());
+ }
+
+ @Test
+ public void rpcSelectionChange_userOriginated() {
+ AtomicInteger listenerCount = new AtomicInteger(0);
+
+ checkBoxGroup.addSelectionListener(event -> {
+ listenerCount.incrementAndGet();
+ Assert.assertTrue(event.isUserOriginated());
+ });
+
+ SelectionServerRpc rpc = ComponentTest.getRpcProxy(checkBoxGroup,
+ SelectionServerRpc.class);
+
+ rpc.select(getItemKey("First"));
+ rpc.select(getItemKey("Second"));
+ rpc.deselect(getItemKey("Second"));
+
+ Assert.assertEquals(3, listenerCount.get());
+ }
+
+ private String getItemKey(String dataObject) {
+ return checkBoxGroup.getDataCommunicator().getKeyMapper()
+ .key(dataObject);
+ }
+
private static void assertSelectionOrder(Multi<String> selectionModel,
String... selectionOrder) {
Assert.assertEquals(Arrays.asList(selectionOrder),
*/
package com.vaadin.ui;
-import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
-import java.lang.reflect.Proxy;
import com.vaadin.server.ClientConnector;
-import com.vaadin.server.ServerRpcMethodInvocation;
+import com.vaadin.server.ServerRpcManager;
import com.vaadin.shared.communication.ServerRpc;
/**
}
/**
- * Gets a proxy object which invokes ServerRpc methods.
+ * Gets the server rpc handler registered for a component.
*
* @param component
* the component which listens to the RPC
* @param serverRpcClass
* the server RPC class
- * @return a proxy which can be used to invoke RPC methods
+ * @return the server RPC handler
*/
- @SuppressWarnings("unchecked")
public static <T extends ServerRpc> T getRpcProxy(Component component,
Class<T> serverRpcClass) {
- return (T) Proxy.newProxyInstance(component.getClass().getClassLoader(),
- new Class[] { serverRpcClass }, new InvocationHandler() {
-
- @Override
- public Object invoke(Object proxy, Method method,
- Object[] args) throws Throwable {
- ServerRpcMethodInvocation invocation = new ServerRpcMethodInvocation(
- component.getConnectorId(), serverRpcClass,
- method.getName(), args.length);
- invocation.setParameters(args);
- component.getRpcManager(serverRpcClass.getName())
- .applyInvocation(invocation);
- return null;
- }
- });
+ try {
+ ServerRpcManager<?> rpcManager = component
+ .getRpcManager(serverRpcClass.getName());
+ Method method = ServerRpcManager.class
+ .getDeclaredMethod("getImplementation");
+ method.setAccessible(true);
+ return serverRpcClass.cast(method.invoke(rpcManager));
+ } catch (ReflectiveOperationException e) {
+ throw new RuntimeException(e);
+ }
}
}
projects / vaadin-framework.git / commitdiff