Add LegacyCheckBox for old field factories, Grid editor etc.
Change-Id: Ic40790049421268c6de3d26730d1955d56aa86c4
--- /dev/null
+/*
+ * Copyright 2000-2014 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.client.legacy.ui.checkbox;
+
+import com.vaadin.client.ui.checkbox.CheckBoxConnector;
+import com.vaadin.legacy.ui.LegacyCheckBox;
+import com.vaadin.shared.ui.Connect;
+
+@Connect(LegacyCheckBox.class)
+public class LegacyCheckBoxConnector extends CheckBoxConnector {
+
+}
import com.vaadin.data.Item;
import com.vaadin.data.fieldgroup.FieldGroup.BindException;
-import com.vaadin.legacy.ui.LegacyField;
import com.vaadin.legacy.ui.LegacyAbstractField;
+import com.vaadin.legacy.ui.LegacyCheckBox;
+import com.vaadin.legacy.ui.LegacyField;
import com.vaadin.ui.AbstractSelect;
import com.vaadin.ui.AbstractTextField;
-import com.vaadin.ui.CheckBox;
import com.vaadin.ui.ComboBox;
import com.vaadin.ui.DateField;
import com.vaadin.ui.InlineDateField;
}
protected <T extends LegacyField> T createBooleanField(Class<T> fieldType) {
- if (fieldType.isAssignableFrom(CheckBox.class)) {
- CheckBox cb = new CheckBox(null);
+ if (fieldType.isAssignableFrom(LegacyCheckBox.class)) {
+ LegacyCheckBox cb = new LegacyCheckBox(null);
cb.setImmediate(true);
return (T) cb;
} else if (AbstractTextField.class.isAssignableFrom(fieldType)) {
--- /dev/null
+/*
+ * Copyright 2000-2014 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.legacy.ui;
+
+import java.util.Collection;
+
+import org.jsoup.nodes.Attributes;
+import org.jsoup.nodes.Element;
+
+import com.vaadin.data.Property;
+import com.vaadin.event.FieldEvents.BlurEvent;
+import com.vaadin.event.FieldEvents.BlurListener;
+import com.vaadin.event.FieldEvents.FocusAndBlurServerRpcImpl;
+import com.vaadin.event.FieldEvents.FocusEvent;
+import com.vaadin.event.FieldEvents.FocusListener;
+import com.vaadin.shared.MouseEventDetails;
+import com.vaadin.shared.ui.checkbox.CheckBoxServerRpc;
+import com.vaadin.shared.ui.checkbox.CheckBoxState;
+import com.vaadin.ui.declarative.DesignAttributeHandler;
+import com.vaadin.ui.declarative.DesignContext;
+
+public class LegacyCheckBox extends LegacyAbstractField<Boolean> {
+
+ private CheckBoxServerRpc rpc = new CheckBoxServerRpc() {
+
+ @Override
+ public void setChecked(boolean checked,
+ MouseEventDetails mouseEventDetails) {
+ if (isReadOnly()) {
+ return;
+ }
+
+ /*
+ * Client side updates the state before sending the event so we need
+ * to make sure the cached state is updated to match the client. If
+ * we do not do this, a reverting setValue() call in a listener will
+ * not cause the new state to be sent to the client.
+ *
+ * See #11028, #10030.
+ */
+ getUI().getConnectorTracker().getDiffState(LegacyCheckBox.this)
+ .put("checked", checked);
+
+ final Boolean oldValue = getValue();
+ final Boolean newValue = checked;
+
+ if (!newValue.equals(oldValue)) {
+ // The event is only sent if the switch state is changed
+ setValue(newValue);
+ }
+
+ }
+ };
+
+ FocusAndBlurServerRpcImpl focusBlurRpc = new FocusAndBlurServerRpcImpl(this) {
+ @Override
+ protected void fireEvent(Event event) {
+ LegacyCheckBox.this.fireEvent(event);
+ }
+ };
+
+ /**
+ * Creates a new checkbox.
+ */
+ public LegacyCheckBox() {
+ registerRpc(rpc);
+ registerRpc(focusBlurRpc);
+ setValue(Boolean.FALSE);
+ }
+
+ /**
+ * Creates a new checkbox with a set caption.
+ *
+ * @param caption
+ * the Checkbox caption.
+ */
+ public LegacyCheckBox(String caption) {
+ this();
+ setCaption(caption);
+ }
+
+ /**
+ * Creates a new checkbox with a caption and a set initial state.
+ *
+ * @param caption
+ * the caption of the checkbox
+ * @param initialState
+ * the initial state of the checkbox
+ */
+ public LegacyCheckBox(String caption, boolean initialState) {
+ this(caption);
+ setValue(initialState);
+ }
+
+ /**
+ * Creates a new checkbox that is connected to a boolean property.
+ *
+ * @param state
+ * the Initial state of the switch-button.
+ * @param dataSource
+ */
+ public LegacyCheckBox(String caption, Property<?> dataSource) {
+ this(caption);
+ setPropertyDataSource(dataSource);
+ }
+
+ @Override
+ public Class<Boolean> getType() {
+ return Boolean.class;
+ }
+
+ @Override
+ protected CheckBoxState getState() {
+ return (CheckBoxState) super.getState();
+ }
+
+ /*
+ * Overridden to keep the shared state in sync with the LegacyAbstractField
+ * internal value. Should be removed once LegacyAbstractField is refactored to use
+ * shared state.
+ *
+ * See tickets #10921 and #11064.
+ */
+ @Override
+ protected void setInternalValue(Boolean newValue) {
+ super.setInternalValue(newValue);
+ if (newValue == null) {
+ newValue = false;
+ }
+ getState().checked = newValue;
+ }
+
+ public void addBlurListener(BlurListener listener) {
+ addListener(BlurEvent.EVENT_ID, BlurEvent.class, listener,
+ BlurListener.blurMethod);
+ }
+
+ /**
+ * @deprecated As of 7.0, replaced by {@link #addBlurListener(BlurListener)}
+ **/
+ @Deprecated
+ public void addListener(BlurListener listener) {
+ addBlurListener(listener);
+ }
+
+ public void removeBlurListener(BlurListener listener) {
+ removeListener(BlurEvent.EVENT_ID, BlurEvent.class, listener);
+ }
+
+ /**
+ * @deprecated As of 7.0, replaced by
+ * {@link #removeBlurListener(BlurListener)}
+ **/
+ @Deprecated
+ public void removeListener(BlurListener listener) {
+ removeBlurListener(listener);
+ }
+
+ public void addFocusListener(FocusListener listener) {
+ addListener(FocusEvent.EVENT_ID, FocusEvent.class, listener,
+ FocusListener.focusMethod);
+ }
+
+ /**
+ * @deprecated As of 7.0, replaced by
+ * {@link #addFocusListener(FocusListener)}
+ **/
+ @Deprecated
+ public void addListener(FocusListener listener) {
+ addFocusListener(listener);
+ }
+
+ public void removeFocusListener(FocusListener listener) {
+ removeListener(FocusEvent.EVENT_ID, FocusEvent.class, listener);
+ }
+
+ /**
+ * @deprecated As of 7.0, replaced by
+ * {@link #removeFocusListener(FocusListener)}
+ **/
+ @Deprecated
+ public void removeListener(FocusListener listener) {
+ removeFocusListener(listener);
+ }
+
+ /**
+ * Get the boolean value of the button state.
+ *
+ * @return True iff the button is pressed down or checked.
+ *
+ * @deprecated As of 7.0, use {@link #getValue()} instead and, if needed,
+ * handle null values.
+ */
+ @Deprecated
+ public boolean booleanValue() {
+ Boolean value = getValue();
+ return (null == value) ? false : value.booleanValue();
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see com.vaadin.ui.AbstractField#readDesign(org.jsoup.nodes.Element,
+ * com.vaadin.ui.declarative.DesignContext)
+ */
+ @Override
+ public void readDesign(Element design, DesignContext designContext) {
+ super.readDesign(design, designContext);
+ if (design.hasAttr("checked")) {
+ this.setValue(
+ DesignAttributeHandler.readAttribute("checked",
+ design.attributes(), Boolean.class), false, true);
+ }
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see com.vaadin.ui.AbstractField#getCustomAttributes()
+ */
+ @Override
+ protected Collection<String> getCustomAttributes() {
+ Collection<String> attributes = super.getCustomAttributes();
+ attributes.add("checked");
+ return attributes;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see com.vaadin.ui.AbstractField#writeDesign(org.jsoup.nodes.Element,
+ * com.vaadin.ui.declarative.DesignContext)
+ */
+ @Override
+ public void writeDesign(Element design, DesignContext designContext) {
+ super.writeDesign(design, designContext);
+ LegacyCheckBox def = (LegacyCheckBox) designContext.getDefaultInstance(this);
+ Attributes attr = design.attributes();
+ DesignAttributeHandler.writeAttribute("checked", attr, getValue(),
+ def.getValue(), Boolean.class);
+ }
+
+ @Override
+ public void clear() {
+ setValue(Boolean.FALSE);
+ }
+
+ @Override
+ public boolean isEmpty() {
+ return getValue() == null || getValue().equals(Boolean.FALSE);
+
+ }
+
+}
/*
* Copyright 2000-2014 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
import org.jsoup.nodes.Attributes;
import org.jsoup.nodes.Element;
-import com.vaadin.data.Property;
import com.vaadin.event.FieldEvents.BlurEvent;
import com.vaadin.event.FieldEvents.BlurListener;
import com.vaadin.event.FieldEvents.FocusAndBlurServerRpcImpl;
import com.vaadin.event.FieldEvents.FocusEvent;
import com.vaadin.event.FieldEvents.FocusListener;
-import com.vaadin.legacy.ui.LegacyAbstractField;
import com.vaadin.shared.MouseEventDetails;
import com.vaadin.shared.ui.checkbox.CheckBoxServerRpc;
import com.vaadin.shared.ui.checkbox.CheckBoxState;
import com.vaadin.ui.declarative.DesignAttributeHandler;
import com.vaadin.ui.declarative.DesignContext;
-public class CheckBox extends LegacyAbstractField<Boolean> {
+public class CheckBox extends AbstractField<Boolean> {
private CheckBoxServerRpc rpc = new CheckBoxServerRpc() {
* to make sure the cached state is updated to match the client. If
* we do not do this, a reverting setValue() call in a listener will
* not cause the new state to be sent to the client.
- *
+ *
* See #11028, #10030.
*/
getUI().getConnectorTracker().getDiffState(CheckBox.this)
/**
* Creates a new checkbox with a set caption.
- *
+ *
* @param caption
* the Checkbox caption.
*/
/**
* Creates a new checkbox with a caption and a set initial state.
- *
+ *
* @param caption
* the caption of the checkbox
* @param initialState
setValue(initialState);
}
- /**
- * Creates a new checkbox that is connected to a boolean property.
- *
- * @param state
- * the Initial state of the switch-button.
- * @param dataSource
- */
- public CheckBox(String caption, Property<?> dataSource) {
- this(caption);
- setPropertyDataSource(dataSource);
+ @Override
+ public Boolean getValue() {
+ return getState(false).checked;
}
+ /**
+ * Sets the value of this ComboBox. If the new value is not equal to
+ * {@code getValue()}, fires a value change event. Throws
+ * {@code IllegalArgumentException} if the value is null.
+ *
+ * @param value
+ * the new value
+ * @throws IllegalArgumentException
+ * if the value is null
+ */
@Override
- public Class<Boolean> getType() {
- return Boolean.class;
+ public void setValue(Boolean value) {
+ if (value == null) {
+ throw new IllegalArgumentException("CheckBox value must not be null");
+ }
+ super.setValue(value);
}
@Override
return (CheckBoxState) super.getState();
}
- /*
- * Overridden to keep the shared state in sync with the LegacyAbstractField
- * internal value. Should be removed once LegacyAbstractField is refactored to use
- * shared state.
- *
- * See tickets #10921 and #11064.
- */
@Override
- protected void setInternalValue(Boolean newValue) {
- super.setInternalValue(newValue);
- if (newValue == null) {
- newValue = false;
- }
- getState().checked = newValue;
+ protected CheckBoxState getState(boolean markAsDirty) {
+ return (CheckBoxState) super.getState(markAsDirty);
+ }
+
+ @Override
+ protected void doSetValue(Boolean value) {
+ getState().checked = value;
}
public void addBlurListener(BlurListener listener) {
BlurListener.blurMethod);
}
- /**
- * @deprecated As of 7.0, replaced by {@link #addBlurListener(BlurListener)}
- **/
- @Deprecated
- public void addListener(BlurListener listener) {
- addBlurListener(listener);
- }
-
public void removeBlurListener(BlurListener listener) {
removeListener(BlurEvent.EVENT_ID, BlurEvent.class, listener);
}
- /**
- * @deprecated As of 7.0, replaced by
- * {@link #removeBlurListener(BlurListener)}
- **/
- @Deprecated
- public void removeListener(BlurListener listener) {
- removeBlurListener(listener);
- }
-
public void addFocusListener(FocusListener listener) {
addListener(FocusEvent.EVENT_ID, FocusEvent.class, listener,
FocusListener.focusMethod);
}
- /**
- * @deprecated As of 7.0, replaced by
- * {@link #addFocusListener(FocusListener)}
- **/
- @Deprecated
- public void addListener(FocusListener listener) {
- addFocusListener(listener);
- }
-
public void removeFocusListener(FocusListener listener) {
removeListener(FocusEvent.EVENT_ID, FocusEvent.class, listener);
}
- /**
- * @deprecated As of 7.0, replaced by
- * {@link #removeFocusListener(FocusListener)}
- **/
- @Deprecated
- public void removeListener(FocusListener listener) {
- removeFocusListener(listener);
- }
-
- /**
- * Get the boolean value of the button state.
- *
- * @return True iff the button is pressed down or checked.
- *
- * @deprecated As of 7.0, use {@link #getValue()} instead and, if needed,
- * handle null values.
- */
- @Deprecated
- public boolean booleanValue() {
- Boolean value = getValue();
- return (null == value) ? false : value.booleanValue();
- }
-
/*
* (non-Javadoc)
- *
+ *
* @see com.vaadin.ui.AbstractField#readDesign(org.jsoup.nodes.Element,
* com.vaadin.ui.declarative.DesignContext)
*/
if (design.hasAttr("checked")) {
this.setValue(
DesignAttributeHandler.readAttribute("checked",
- design.attributes(), Boolean.class), false, true);
+ design.attributes(), Boolean.class), false);
}
}
/*
* (non-Javadoc)
- *
+ *
* @see com.vaadin.ui.AbstractField#getCustomAttributes()
*/
@Override
/*
* (non-Javadoc)
- *
+ *
* @see com.vaadin.ui.AbstractField#writeDesign(org.jsoup.nodes.Element,
* com.vaadin.ui.declarative.DesignContext)
*/
def.getValue(), Boolean.class);
}
- @Override
- public void clear() {
- setValue(Boolean.FALSE);
- }
-
- @Override
- public boolean isEmpty() {
- return getValue() == null || getValue().equals(Boolean.FALSE);
-
- }
-
}
import com.vaadin.data.Container;
import com.vaadin.data.Item;
import com.vaadin.data.Property;
+import com.vaadin.legacy.ui.LegacyCheckBox;
import com.vaadin.legacy.ui.LegacyField;
import com.vaadin.shared.util.SharedUtil;
// Boolean field
if (Boolean.class.isAssignableFrom(type)) {
- return new CheckBox();
+ return new LegacyCheckBox();
}
return new TextField();
import com.vaadin.legacy.data.Validator.InvalidValueException;
import com.vaadin.legacy.data.util.converter.LegacyConverter;
import com.vaadin.legacy.data.util.converter.LegacyConverterUtil;
+import com.vaadin.legacy.ui.LegacyCheckBox;
import com.vaadin.legacy.ui.LegacyField;
import com.vaadin.server.AbstractClientConnector;
import com.vaadin.server.AbstractExtension;
Class<?> dataType,
Class<T> fieldType) throws BindException {
T field = super.build(caption, dataType, fieldType);
- if (field instanceof CheckBox) {
+ if (field instanceof LegacyCheckBox) {
field.setCaption(null);
}
return field;
for (Class<?> c : classes) {
boolean found = false;
for (Method m : c.getDeclaredMethods()) {
- if (m.getName().equals("addListener")) {
+ String methodName = m.getName();
+ if (methodName.startsWith("add")
+ && methodName.endsWith("Listener")
+ && !"addListener".equals(methodName)) {
if (m.getParameterTypes().length != 1) {
continue;
}
System.out.println("import "
+ AbstractListenerMethodsTestBase.class
- .getName() + ";");
+ .getName()
+ + ";");
System.out.println("import " + c.getName() + ";");
- System.out.println("public class "
- + c.getSimpleName()
- + "Listeners extends "
- + AbstractListenerMethodsTestBase.class
- .getSimpleName() + " {");
+ System.out
+ .println(
+ "public class " + c.getSimpleName()
+ + "Listeners extends "
+ + AbstractListenerMethodsTestBase.class
+ .getSimpleName()
+ + " {");
}
String listenerClassName = m.getParameterTypes()[0]
.getSimpleName();
- String eventClassName = listenerClassName.replaceFirst(
- "Listener$", "Event");
+ String eventClassName = listenerClassName
+ .replaceFirst("Listener$", "Event");
System.out.println("public void test" + listenerClassName
+ "() throws Exception {");
System.out.println(" testListener(" + c.getSimpleName()
private void addListener(Object c, Object listener1, Class<?> listenerClass)
throws IllegalArgumentException, IllegalAccessException,
- InvocationTargetException, SecurityException, NoSuchMethodException {
+ InvocationTargetException, SecurityException,
+ NoSuchMethodException {
Method method = getAddListenerMethod(c.getClass(), listenerClass);
method.invoke(c, listener1);
}
private Collection<?> getListeners(Object c, Class<?> eventType)
throws IllegalArgumentException, IllegalAccessException,
- InvocationTargetException, SecurityException, NoSuchMethodException {
+ InvocationTargetException, SecurityException,
+ NoSuchMethodException {
Method method = getGetListenersMethod(c.getClass());
return (Collection<?>) method.invoke(c, eventType);
}
private Method getAddListenerMethod(Class<?> cls, Class<?> listenerClass)
throws SecurityException, NoSuchMethodException {
- return cls.getMethod("addListener", listenerClass);
+ return cls.getMethod("add" + listenerClass.getSimpleName(),
+ listenerClass);
}
private Method getRemoveListenerMethod(Class<?> cls, Class<?> listenerClass)
throws SecurityException, NoSuchMethodException {
- return cls.getMethod("removeListener", listenerClass);
+ return cls.getMethod("remove" + listenerClass.getSimpleName(),
+ listenerClass);
}
package com.vaadin.tests.server.component.abstractfield;
import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import java.util.Locale;
import com.vaadin.data.util.MethodProperty;
import com.vaadin.data.util.ObjectProperty;
import com.vaadin.legacy.data.util.converter.LegacyConverter;
-import com.vaadin.legacy.data.util.converter.LegacyStringToIntegerConverter;
import com.vaadin.legacy.data.util.converter.LegacyConverter.ConversionException;
+import com.vaadin.legacy.data.util.converter.LegacyStringToIntegerConverter;
import com.vaadin.server.VaadinSession;
import com.vaadin.tests.data.bean.Address;
import com.vaadin.tests.data.bean.Country;
import com.vaadin.tests.data.bean.Person;
import com.vaadin.tests.data.bean.Sex;
import com.vaadin.tests.util.AlwaysLockedVaadinSession;
-import com.vaadin.ui.CheckBox;
import com.vaadin.ui.TextField;
public class AbsFieldValueConversionsTest {
tf.getValue());
}
- @Test
- public void testBooleanNullConversion() {
- CheckBox cb = new CheckBox();
- cb.setConverter(new LegacyConverter<Boolean, Boolean>() {
-
- @Override
- public Boolean convertToModel(Boolean value,
- Class<? extends Boolean> targetType, Locale locale) {
- // value from a CheckBox should never be null as long as it is
- // not set to null (handled by conversion below).
- assertNotNull(value);
- return value;
- }
-
- @Override
- public Boolean convertToPresentation(Boolean value,
- Class<? extends Boolean> targetType, Locale locale) {
- // Datamodel -> field
- if (value == null) {
- return false;
- }
-
- return value;
- }
-
- @Override
- public Class<Boolean> getModelType() {
- return Boolean.class;
- }
-
- @Override
- public Class<Boolean> getPresentationType() {
- return Boolean.class;
- }
-
- });
- MethodProperty<Boolean> property = new MethodProperty<Boolean>(
- paulaBean, "deceased");
- cb.setPropertyDataSource(property);
- assertEquals(Boolean.FALSE, property.getValue());
- assertEquals(Boolean.FALSE, cb.getValue());
- Boolean newDmValue = cb.getConverter().convertToPresentation(
- cb.getValue(), Boolean.class, new Locale("fi", "FI"));
- assertEquals(Boolean.FALSE, newDmValue);
-
- // FIXME: Should be able to set to false here to cause datamodel to be
- // set to false but the change will not be propagated to the Property
- // (field value is already false)
-
- cb.setValue(true);
- assertEquals(Boolean.TRUE, cb.getValue());
- assertEquals(Boolean.TRUE, property.getValue());
-
- cb.setValue(false);
- assertEquals(Boolean.FALSE, cb.getValue());
- assertEquals(Boolean.FALSE, property.getValue());
-
- }
-
// Now specific to Integer because StringToNumberConverter has been removed
public static class NumberBean {
private Integer number;
+++ /dev/null
-package com.vaadin.tests.server.component.abstractfield;
-
-import org.junit.Test;
-
-import com.vaadin.data.Property.ReadOnlyStatusChangeEvent;
-import com.vaadin.data.Property.ReadOnlyStatusChangeListener;
-import com.vaadin.data.Property.ValueChangeEvent;
-import com.vaadin.data.Property.ValueChangeListener;
-import com.vaadin.tests.server.component.AbstractListenerMethodsTestBase;
-import com.vaadin.ui.CheckBox;
-
-public class AbstractFieldListenersTest extends AbstractListenerMethodsTestBase {
-
- @Test
- public void testReadOnlyStatusChangeListenerAddGetRemove() throws Exception {
- testListenerAddGetRemove(CheckBox.class,
- ReadOnlyStatusChangeEvent.class,
- ReadOnlyStatusChangeListener.class);
- }
-
- @Test
- public void testValueChangeListenerAddGetRemove() throws Exception {
- testListenerAddGetRemove(CheckBox.class, ValueChangeEvent.class,
- ValueChangeListener.class);
- }
-}
--- /dev/null
+package com.vaadin.tests.server.component.abstractfield;
+
+import org.junit.Test;
+
+import com.vaadin.data.Property.ReadOnlyStatusChangeEvent;
+import com.vaadin.data.Property.ReadOnlyStatusChangeListener;
+import com.vaadin.data.Property.ValueChangeEvent;
+import com.vaadin.data.Property.ValueChangeListener;
+import com.vaadin.tests.server.component.AbstractListenerMethodsTestBase;
+import com.vaadin.ui.Table;
+
+public class LegacyAbstractFieldListenersTest extends AbstractListenerMethodsTestBase {
+
+ @Test
+ public void testReadOnlyStatusChangeListenerAddGetRemove() throws Exception {
+ testListenerAddGetRemove(Table.class,
+ ReadOnlyStatusChangeEvent.class,
+ ReadOnlyStatusChangeListener.class);
+ }
+
+ @Test
+ public void testValueChangeListenerAddGetRemove() throws Exception {
+ testListenerAddGetRemove(Table.class, ValueChangeEvent.class,
+ ValueChangeListener.class);
+ }
+}
/*
* Copyright 2000-2014 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
import org.junit.Assert;
import org.junit.Test;
-import com.vaadin.data.util.ObjectProperty;
-
public class CheckBoxTest {
@Test
- public void initiallyEmpty() {
- CheckBox tf = new CheckBox();
- Assert.assertTrue(tf.isEmpty());
- }
-
- @Test
- public void emptyAfterClearUsingPDS() {
- CheckBox tf = new CheckBox();
- tf.setPropertyDataSource(new ObjectProperty<Boolean>(Boolean.TRUE));
- Assert.assertFalse(tf.isEmpty());
- tf.clear();
- Assert.assertTrue(tf.isEmpty());
+ public void initiallyFalse() {
+ CheckBox cb = new CheckBox();
+ Assert.assertFalse(cb.getValue());
}
@Test
- public void emptyAfterClear() {
- CheckBox tf = new CheckBox();
- tf.setValue(true);
- Assert.assertFalse(tf.isEmpty());
- tf.clear();
- Assert.assertTrue(tf.isEmpty());
+ public void testSetValue() {
+ CheckBox cb = new CheckBox();
+ cb.setValue(true);
+ Assert.assertTrue(cb.getValue());
+ cb.setValue(false);
+ Assert.assertFalse(cb.getValue());
}
}
-/*
+/*
* Copyright 2000-2014 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
package com.vaadin.tests;
-import com.vaadin.data.Property;
import com.vaadin.data.Property.ValueChangeEvent;
import com.vaadin.data.Property.ValueChangeListener;
import com.vaadin.shared.ui.label.ContentMode;
import com.vaadin.ui.VerticalLayout;
/**
- *
+ *
* @author Vaadin Ltd.
*/
public class TestForRichTextEditor extends CustomComponent implements
CheckBox b = new CheckBox("enabled");
b.setImmediate(true);
- b.addListener(new Property.ValueChangeListener() {
-
- @Override
- public void valueChange(ValueChangeEvent event) {
- rte.setEnabled(!rte.isEnabled());
- }
- });
+ b.addValueChangeListener(event -> rte.setEnabled(!rte.isEnabled()));
main.addComponent(b);
}
/*
* Copyright 2000-2014 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
import com.vaadin.ui.VerticalLayout;
/**
- *
+ *
* @since
* @author Vaadin Ltd
*/
"Reconnect dialog modality");
reconnectDialogModal.setValue(getReconnectDialogConfiguration()
.isDialogModal());
- reconnectDialogModal.addValueChangeListener(new ValueChangeListener() {
- @Override
- public void valueChange(ValueChangeEvent event) {
- getReconnectDialogConfiguration().setDialogModal(
- reconnectDialogModal.getValue());
- }
- });
+ reconnectDialogModal.addValueChangeListener(
+ event -> getReconnectDialogConfiguration()
+ .setDialogModal(reconnectDialogModal.getValue()));
VerticalLayout vl = new VerticalLayout();
vl.setMargin(true);
import com.vaadin.data.Item;
import com.vaadin.data.Property;
import com.vaadin.data.Property.ValueChangeEvent;
-import com.vaadin.data.Property.ValueChangeListener;
import com.vaadin.legacy.ui.LegacyField;
import com.vaadin.ui.AbstractComponent;
import com.vaadin.ui.Alignment;
/**
* Override to provide custom actions for the test case.
- *
+ *
* @param actions
* Array with default actions. Add custom actions to this. Never
* null.
* Method that creates the "actions" shown in the upper part of the screen.
* Override this only if you do not want the default actions. Custom actions
* can be added through #createCustomActions();
- *
+ *
* @return A List with actions to which more actions can be added.
*/
protected List<Component> createActions() {
boolean initialState, final Command<T, Boolean> command) {
CheckBox checkBox = new CheckBox(caption);
- checkBox.addListener(new ValueChangeListener() {
-
- @Override
- public void valueChange(ValueChangeEvent event) {
- boolean enabled = (Boolean) event.getProperty().getValue();
- doCommand(command, enabled);
- }
- });
+ checkBox.addValueChangeListener(
+ event -> doCommand(command, event.getValue()));
checkBox.setValue(initialState);
checkBox.setImmediate(true);
package com.vaadin.tests.components.abstractcomponent;
-import com.vaadin.data.Property;
-import com.vaadin.data.Property.ValueChangeEvent;
import com.vaadin.tests.components.AbstractTestCase;
import com.vaadin.ui.Button;
import com.vaadin.ui.CheckBox;
panelLayout.addComponent(button);
CheckBox enable = new CheckBox("Toggle button enabled", true);
- enable.addListener(new Property.ValueChangeListener() {
-
- @Override
- public void valueChange(ValueChangeEvent event) {
- boolean enabled = (Boolean) event.getProperty().getValue();
- button.setEnabled(enabled);
- // button.requestRepaint();
- }
+ enable.addValueChangeListener(event -> {
+ boolean enabled = event.getValue();
+ button.setEnabled(enabled);
+ // button.requestRepaint();
});
enable.setImmediate(true);
CheckBox caption = new CheckBox("Toggle button caption", true);
- caption.addListener(new Property.ValueChangeListener() {
-
- @Override
- public void valueChange(ValueChangeEvent event) {
- button.setCaption(button.getCaption() + "+");
- }
- });
+ caption.addValueChangeListener(event -> button.setCaption(button.getCaption() + "+"));
caption.setImmediate(true);
CheckBox visible = new CheckBox("Toggle panel visibility", true);
- visible.addListener(new Property.ValueChangeListener() {
-
- @Override
- public void valueChange(ValueChangeEvent event) {
- boolean visible = (Boolean) event.getProperty().getValue();
-
- panel.setVisible(visible);
- }
- });
+ visible.addValueChangeListener(event -> panel.setVisible(event.getValue()));
visible.setImmediate(true);
CheckBox panelEnable = new CheckBox("Toggle panel enabled", true);
- panelEnable.addListener(new Property.ValueChangeListener() {
-
- @Override
- public void valueChange(ValueChangeEvent event) {
- boolean enabled = (Boolean) event.getProperty().getValue();
- panel.setEnabled(enabled);
- }
- });
+ panelEnable.addValueChangeListener(event -> panel.setEnabled(event.getValue()));
panelEnable.setImmediate(true);
mainWindow.addComponent(enable);
package com.vaadin.tests.components.abstractcomponent;
-import com.vaadin.data.Property;
-import com.vaadin.data.Property.ValueChangeEvent;
+import com.vaadin.data.HasValue;
import com.vaadin.tests.components.TestBase;
import com.vaadin.ui.CheckBox;
import com.vaadin.ui.HorizontalLayout;
HorizontalLayout topLayout = new HorizontalLayout();
addComponent(topLayout);
CheckBox panelCbox = new CheckBox("Panel");
- panelCbox.addListener(panelListener);
+ panelCbox.addValueChangeListener(panelListener);
topLayout.addComponent(panelCbox);
CheckBox layoutCbox = new CheckBox("Layout");
- layoutCbox.addListener(layoutListener);
+ layoutCbox.addValueChangeListener(layoutListener);
topLayout.addComponent(layoutCbox);
CheckBox labelCbox = new CheckBox("Label");
topLayout.addComponent(labelCbox);
- labelCbox.addListener(labelListener);
+ labelCbox.addValueChangeListener(labelListener);
panel = new Panel();
panel.setCaption("Panel caption");
layout.addComponent(label);
}
- private final Property.ValueChangeListener panelListener = new Property.ValueChangeListener() {
-
- @Override
- public void valueChange(ValueChangeEvent event) {
- boolean value = (Boolean) (event.getProperty().getValue());
- if (value) {
- panel.setDescription("I'm panel!");
- } else {
- panel.setDescription("");
- }
+ private final HasValue.ValueChangeListener<Boolean> panelListener = event -> {
+ if (event.getValue()) {
+ panel.setDescription("I'm panel!");
+ } else {
+ panel.setDescription("");
}
-
};
- private final Property.ValueChangeListener layoutListener = new Property.ValueChangeListener() {
-
- @Override
- public void valueChange(ValueChangeEvent event) {
- boolean value = (Boolean) (event.getProperty().getValue());
- if (value) {
- layout.setDescription("I'm layout!");
- } else {
- layout.setDescription("");
- }
+ private final HasValue.ValueChangeListener<Boolean> layoutListener = event -> {
+ if (event.getValue()) {
+ layout.setDescription("I'm layout!");
+ } else {
+ layout.setDescription("");
}
-
};
- private final Property.ValueChangeListener labelListener = new Property.ValueChangeListener() {
-
- @Override
- public void valueChange(ValueChangeEvent event) {
- boolean value = (Boolean) (event.getProperty().getValue());
- if (value) {
- label.setDescription("I'm label!");
- } else {
- label.setDescription("");
- }
+ private final HasValue.ValueChangeListener<Boolean> labelListener = event -> {
+ if (event.getValue()) {
+ label.setDescription("I'm label!");
+ } else {
+ label.setDescription("");
}
-
};
}
import java.util.HashSet;
import java.util.Set;
-import com.vaadin.data.Property.ValueChangeEvent;
-import com.vaadin.data.Property.ValueChangeListener;
import com.vaadin.legacy.ui.LegacyField;
import com.vaadin.server.VaadinRequest;
import com.vaadin.tests.components.AbstractTestUI;
CheckBox required = new CheckBox("Fields required", true);
required.setImmediate(true);
- required.addValueChangeListener(new ValueChangeListener() {
-
- @Override
- public void valueChange(ValueChangeEvent event) {
- boolean required = (Boolean) event.getProperty().getValue();
- for (LegacyField f : fields) {
- f.setRequired(required);
- }
+ required.addValueChangeListener(event -> {
+ boolean newRequired = event.getValue();
+ for (LegacyField f : fields) {
+ f.setRequired(newRequired);
}
});
addComponent(required);
/*
* (non-Javadoc)
- *
+ *
* @see com.vaadin.tests.components.AbstractTestUI#getTestDescription()
*/
@Override
/*
* (non-Javadoc)
- *
+ *
* @see com.vaadin.tests.components.AbstractTestUI#getTicketNumber()
*/
@Override
/*
* Copyright 2000-2014 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
*/
/**
- *
+ *
*/
package com.vaadin.tests.components.button;
-import com.vaadin.data.Property;
-import com.vaadin.data.Property.ValueChangeEvent;
import com.vaadin.server.ThemeResource;
import com.vaadin.server.VaadinRequest;
import com.vaadin.tests.components.AbstractTestUI;
import com.vaadin.ui.CheckBox;
/**
- *
+ *
* @since
* @author Vaadin Ltd
*/
/*
* (non-Javadoc)
- *
+ *
* @see com.vaadin.tests.components.AbstractTestUI#setup(com.vaadin.server.
* VaadinRequest)
*/
final CheckBox enable = new CheckBox("Enable alt text", true);
enable.setImmediate(true);
- enable.addValueChangeListener(new Property.ValueChangeListener() {
-
- @Override
- public void valueChange(ValueChangeEvent event) {
- if (enable.booleanValue()) {
- btn.setIconAlternateText("alt text");
- } else {
- btn.setIconAlternateText("");
- }
+ enable.addValueChangeListener(event -> {
+ if (event.getValue()) {
+ btn.setIconAlternateText("alt text");
+ } else {
+ btn.setIconAlternateText("");
}
});
addComponent(enable);
/*
* (non-Javadoc)
- *
+ *
* @see com.vaadin.tests.components.AbstractTestUI#getTestDescription()
*/
@Override
/*
* (non-Javadoc)
- *
+ *
* @see com.vaadin.tests.components.AbstractTestUI#getTicketNumber()
*/
@Override
/*
* Copyright 2000-2014 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
import com.vaadin.data.Property.ValueChangeEvent;
import com.vaadin.data.Property.ValueChangeListener;
-import com.vaadin.data.util.MethodProperty;
import com.vaadin.server.VaadinRequest;
import com.vaadin.tests.components.AbstractTestUIWithLog;
import com.vaadin.ui.Alignment;
}
});
ns.setValue("Month");
- final CheckBox allowHtml = new CheckBox("Allow HTML in event caption",
- new MethodProperty<Boolean>(calendar, "eventCaptionAsHtml"));
- allowHtml.addValueChangeListener(new ValueChangeListener() {
- @Override
- public void valueChange(ValueChangeEvent event) {
- log("HTML in event caption: " + allowHtml.getValue());
- }
- });
+ final CheckBox allowHtml = new CheckBox("Allow HTML in event caption");
+ allowHtml.setValue(calendar.isEventCaptionAsHtml());
+ allowHtml.addValueChangeListener(
+ event -> {
+ calendar.setEventCaptionAsHtml(event.getValue());
+ log("HTML in event caption: " + event.getValue());
+ });
HorizontalLayout hl = new HorizontalLayout();
hl.setDefaultComponentAlignment(Alignment.BOTTOM_LEFT);
hl.addComponents(ns, allowHtml);
import java.util.TimeZone;
import com.vaadin.annotations.Theme;
+import com.vaadin.data.Binder;
import com.vaadin.data.Item;
-import com.vaadin.data.Property;
import com.vaadin.data.Property.ValueChangeEvent;
import com.vaadin.data.Property.ValueChangeListener;
import com.vaadin.data.fieldgroup.FieldGroup;
private final FormLayout scheduleEventFieldLayout = new FormLayout();
private FieldGroup scheduleEventFieldGroup = new FieldGroup();
+ private Binder<CalendarEvent> scheduledEventBinder = new Binder<>();
private Button deleteEventButton;
private void initHideWeekEndButton() {
hideWeekendsButton = new CheckBox("Hide weekends");
hideWeekendsButton.setImmediate(true);
- hideWeekendsButton
- .addValueChangeListener(new Property.ValueChangeListener() {
-
- private static final long serialVersionUID = 1L;
-
- @Override
- public void valueChange(ValueChangeEvent event) {
- setWeekendsHidden(hideWeekendsButton.getValue());
- }
- });
+ hideWeekendsButton.addValueChangeListener(
+ event -> setWeekendsHidden(hideWeekendsButton.getValue()));
}
private void setWeekendsHidden(boolean weekendsHidden) {
private void initReadOnlyButton() {
readOnlyButton = new CheckBox("Read-only mode");
readOnlyButton.setImmediate(true);
- readOnlyButton
- .addValueChangeListener(new Property.ValueChangeListener() {
-
- private static final long serialVersionUID = 1L;
-
- @Override
- public void valueChange(ValueChangeEvent event) {
- calendarComponent.setReadOnly(readOnlyButton.getValue());
- }
- });
+ readOnlyButton.addValueChangeListener(event -> calendarComponent
+ .setReadOnly(readOnlyButton.getValue()));
}
private void initDisabledButton() {
disabledButton = new CheckBox("Disabled");
disabledButton.setImmediate(true);
- disabledButton
- .addValueChangeListener(new Property.ValueChangeListener() {
-
- private static final long serialVersionUID = 1L;
-
- @Override
- public void valueChange(ValueChangeEvent event) {
- calendarComponent.setEnabled(!disabledButton.getValue());
- }
- });
+ disabledButton.addValueChangeListener(event -> calendarComponent
+ .setEnabled(!disabledButton.getValue()));
}
public void initAddNewEventButton() {
endDateField = createDateField("End date");
final CheckBox allDayField = createCheckBox("All-day");
- allDayField.addValueChangeListener(new Property.ValueChangeListener() {
-
- private static final long serialVersionUID = -7104996493482558021L;
-
- @Override
- public void valueChange(ValueChangeEvent event) {
- Object value = event.getProperty().getValue();
- if (value instanceof Boolean && Boolean.TRUE.equals(value)) {
- setFormDateResolution(Resolution.DAY);
-
- } else {
- setFormDateResolution(Resolution.MINUTE);
- }
+ allDayField.addValueChangeListener(event -> {
+ if (event.getValue()) {
+ setFormDateResolution(Resolution.DAY);
+ } else {
+ setFormDateResolution(Resolution.MINUTE);
}
-
});
captionField = createTextField("Caption");
scheduleEventFieldGroup.bind(whereField, "where");
}
scheduleEventFieldGroup.bind(styleNameField, "styleName");
- scheduleEventFieldGroup.bind(allDayField, "allDay");
+ scheduledEventBinder.bind(allDayField, CalendarEvent::isAllDay, null);
}
private CheckBox createCheckBox(String caption) {
initFormFields(scheduleEventFieldLayout, event.getClass());
scheduleEventFieldGroup.setBuffered(true);
scheduleEventFieldGroup.setItemDataSource(item);
+ scheduledEventBinder.load(event);
}
private void setFormDateResolution(Resolution resolution) {
private void commitCalendarEvent() throws CommitException {
scheduleEventFieldGroup.commit();
BasicEvent event = getFormCalendarEvent();
+ scheduledEventBinder.save(event);
if (event.getEnd() == null) {
event.setEnd(event.getStart());
}
private void discardCalendarEvent() {
scheduleEventFieldGroup.discard();
+ scheduledEventBinder.load(getFormCalendarEvent());
removeWindow(scheduleEventPopup);
}
/*
* Copyright 2000-2014 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
*/
package com.vaadin.tests.components.checkbox;
-import com.vaadin.data.Property.ValueChangeEvent;
-import com.vaadin.data.Property.ValueChangeListener;
+import com.vaadin.data.HasValue;
import com.vaadin.server.VaadinRequest;
import com.vaadin.tests.components.AbstractTestUI;
import com.vaadin.ui.CheckBox;
addComponent(status);
CheckBox cb = new CheckBox("Non-immediate");
- ValueChangeListener listener = new ValueChangeListener() {
- @Override
- public void valueChange(ValueChangeEvent event) {
- count++;
- status.setValue("Events received: " + count);
- }
+ HasValue.ValueChangeListener<Boolean> listener = event -> {
+ count++;
+ status.setValue("Events received: " + count);
};
cb.addValueChangeListener(listener);
cb.setImmediate(false);
+++ /dev/null
-package com.vaadin.tests.components.checkbox;
-
-import com.vaadin.legacy.data.Validator.InvalidValueException;
-import com.vaadin.server.AbstractErrorMessage;
-import com.vaadin.tests.components.TestBase;
-import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickEvent;
-import com.vaadin.ui.CheckBox;
-import com.vaadin.ui.Label;
-
-public class CheckBoxNullValue extends TestBase {
-
- @Override
- protected void setup() {
- // workaround for #6919
- getLayout().setWidth("100%");
-
- final CheckBox checkbox = new CheckBox("A checkbox");
- checkbox.setValue(null);
- addComponent(checkbox);
-
- final CheckBox requiredCheckbox = new CheckBox("A required checkbox");
- requiredCheckbox.setRequired(true);
- requiredCheckbox.setValue(null);
- addComponent(requiredCheckbox);
-
- final Label valueLabel = new Label("");
-
- final Button button = new Button("Validate");
- addComponent(button);
- button.addListener(new Button.ClickListener() {
- @Override
- public void buttonClick(ClickEvent event) {
- checkbox.setComponentError(null);
- requiredCheckbox.setComponentError(null);
- try {
- checkbox.validate();
- } catch (InvalidValueException e) {
- checkbox.setComponentError(AbstractErrorMessage
- .getErrorMessageForException(e));
- }
- try {
- requiredCheckbox.validate();
- } catch (InvalidValueException e) {
- requiredCheckbox.setComponentError(AbstractErrorMessage
- .getErrorMessageForException(e));
- }
- valueLabel.setValue("Checkbox: " + checkbox.getValue()
- + "; Required checkbox: " + requiredCheckbox.getValue());
- }
- });
- addComponent(valueLabel);
- }
-
- @Override
- protected String getDescription() {
- return "CheckBox should support null values.";
- }
-
- @Override
- protected Integer getTicketNumber() {
- return 6918;
- }
-
-}
/*
* Copyright 2000-2014 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
package com.vaadin.tests.components.checkbox;
import com.vaadin.annotations.PreserveOnRefresh;
-import com.vaadin.data.Property;
import com.vaadin.server.VaadinRequest;
import com.vaadin.tests.components.AbstractTestUIWithLog;
import com.vaadin.ui.CheckBox;
@Override
protected void setup(VaadinRequest request) {
final CheckBox alwaysUnchecked = new CheckBox("You may not check me");
- alwaysUnchecked
- .addValueChangeListener(new Property.ValueChangeListener() {
- @Override
- public void valueChange(Property.ValueChangeEvent event) {
- if (alwaysUnchecked.getValue()) {
- log("I said no checking!");
- alwaysUnchecked.setValue(false);
- }
- }
- });
+ alwaysUnchecked.addValueChangeListener(event -> {
+ if (alwaysUnchecked.getValue()) {
+ log("I said no checking!");
+ alwaysUnchecked.setValue(false);
+ }
+ });
final CheckBox alwaysChecked = new CheckBox("You may not uncheck me");
alwaysChecked.setValue(true);
- alwaysChecked
- .addValueChangeListener(new Property.ValueChangeListener() {
- @Override
- public void valueChange(Property.ValueChangeEvent event) {
- if (!alwaysChecked.getValue()) {
- log("I said no unchecking!");
- alwaysChecked.setValue(true);
- }
- }
- });
+ alwaysChecked.addValueChangeListener(event -> {
+ if (!alwaysChecked.getValue()) {
+ log("I said no unchecking!");
+ alwaysChecked.setValue(true);
+ }
+ });
addComponent(alwaysUnchecked);
addComponent(alwaysChecked);
/*
* Copyright 2000-2014 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
*/
package com.vaadin.tests.components.checkbox;
-import com.vaadin.data.Property.ValueChangeEvent;
-import com.vaadin.data.Property.ValueChangeListener;
import com.vaadin.server.VaadinRequest;
import com.vaadin.shared.MouseEventDetails;
import com.vaadin.shared.ui.checkbox.CheckBoxServerRpc;
});
}
};
- cb.addValueChangeListener(new ValueChangeListener() {
-
- @Override
- public void valueChange(ValueChangeEvent event) {
- // Adding an empty ValueChangeListener just to ensure that
- // immediate mode is set to true
- }
- });
addComponent(cb);
}
package com.vaadin.tests.components.checkbox;
-import com.vaadin.tests.components.abstractfield.LegacyAbstractFieldTest;
+import com.vaadin.tests.components.abstractfield.AbstractFieldTest;
import com.vaadin.ui.Button.ClickEvent;
import com.vaadin.ui.Button.ClickListener;
import com.vaadin.ui.CheckBox;
-public class CheckBoxes2 extends LegacyAbstractFieldTest<CheckBox> implements
+public class CheckBoxes2 extends AbstractFieldTest<CheckBox, Boolean> implements
ClickListener {
@Override
/*
* Copyright 2000-2014 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
import javax.imageio.ImageIO;
-import com.vaadin.data.Property.ValueChangeEvent;
import com.vaadin.server.StreamResource;
import com.vaadin.server.VaadinRequest;
import com.vaadin.shared.ui.colorpicker.Color;
/**
* Instantiates a new my image source.
- *
+ *
* @param fg
* the foreground
* @param bg
optLayout.setSpacing(true);
rgbBox.setValue(rgbVisible);
- rgbBox.addValueChangeListener(new CheckBox.ValueChangeListener() {
- @Override
- public void valueChange(ValueChangeEvent event) {
- rgbVisible = (Boolean) event.getProperty().getValue();
- setPopupVisibilities();
- }
+ rgbBox.addValueChangeListener(event -> {
+ rgbVisible = event.getValue();
+ setPopupVisibilities();
});
rgbBox.setImmediate(true);
rgbBox.setId("rgbBox");
optLayout.addComponent(rgbBox);
hsvBox.setValue(hsvVisible);
- hsvBox.addValueChangeListener(new CheckBox.ValueChangeListener() {
- @Override
- public void valueChange(ValueChangeEvent event) {
- hsvVisible = (Boolean) event.getProperty().getValue();
- setPopupVisibilities();
- }
+ hsvBox.addValueChangeListener(event -> {
+ hsvVisible = event.getValue();
+ setPopupVisibilities();
});
hsvBox.setImmediate(true);
hsvBox.setId("hsvBox");
optLayout.addComponent(hsvBox);
swaBox.setValue(swaVisible);
- swaBox.addValueChangeListener(new CheckBox.ValueChangeListener() {
- @Override
- public void valueChange(ValueChangeEvent event) {
- swaVisible = (Boolean) event.getProperty().getValue();
- setPopupVisibilities();
- }
+ swaBox.addValueChangeListener(event -> {
+ swaVisible = event.getValue();
+ setPopupVisibilities();
});
swaBox.setImmediate(true);
swaBox.setId("swaBox");
optLayout.addComponent(swaBox);
hisBox.setValue(historyVisible);
- hisBox.addValueChangeListener(new CheckBox.ValueChangeListener() {
- @Override
- public void valueChange(ValueChangeEvent event) {
- historyVisible = (Boolean) event.getProperty().getValue();
- setPopupVisibilities();
- }
+ hisBox.addValueChangeListener(event -> {
+ historyVisible = event.getValue();
+ setPopupVisibilities();
});
hisBox.setImmediate(true);
hisBox.setId("hisBox");
optLayout.addComponent(hisBox);
txtBox.setValue(txtfieldVisible);
- txtBox.addValueChangeListener(new CheckBox.ValueChangeListener() {
- @Override
- public void valueChange(ValueChangeEvent event) {
- txtfieldVisible = (Boolean) event.getProperty().getValue();
- setPopupVisibilities();
- }
+ txtBox.addValueChangeListener(event -> {
+ txtfieldVisible = event.getValue();
+ setPopupVisibilities();
});
txtBox.setImmediate(true);
txtBox.setId("txtBox");
// This is called whenever a colorpicker popup is closed
/**
* Update display.
- *
+ *
* @param fg
* the fg
* @param bg
/*
* Copyright 2000-2014 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
*/
package com.vaadin.tests.components.combobox;
-import com.vaadin.data.Property.ValueChangeEvent;
-import com.vaadin.data.Property.ValueChangeListener;
import com.vaadin.server.VaadinRequest;
import com.vaadin.ui.CheckBox;
final CheckBox textInputCheckBox = new CheckBox("Text Input", true);
textInputCheckBox.setId("textInput");
- textInputCheckBox.addValueChangeListener(new ValueChangeListener() {
- @Override
- public void valueChange(ValueChangeEvent event) {
- comboBox.setTextInputAllowed(textInputCheckBox.getValue());
- }
- });
+ textInputCheckBox.addValueChangeListener(event -> comboBox
+ .setTextInputAllowed(textInputCheckBox.getValue()));
addComponent(textInputCheckBox);
}
package com.vaadin.tests.components.combobox;
-import com.vaadin.data.util.MethodProperty;
import com.vaadin.tests.components.TestBase;
import com.vaadin.ui.CheckBox;
import com.vaadin.ui.ComboBox;
}
private CheckBox createReadOnlyForComboBox(ComboBox combo) {
- CheckBox readonly = new CheckBox("Second combobox is read only",
- new MethodProperty(combo, "readOnly"));
+ CheckBox readonly = new CheckBox("Second combobox is read only");
+ readonly.setValue(combo.isReadOnly());
+ readonly.addValueChangeListener(
+ event -> combo.setReadOnly(event.getValue()));
readonly.setImmediate(true);
addComponent(readonly);
return readonly;
import java.util.Date;
import java.util.Locale;
-import com.vaadin.data.Property.ValueChangeEvent;
-import com.vaadin.data.Property.ValueChangeListener;
+import com.vaadin.data.HasValue;
import com.vaadin.data.util.BeanItem;
import com.vaadin.legacy.data.validator.LegacyRangeValidator;
import com.vaadin.shared.ui.datefield.Resolution;
import com.vaadin.tests.components.TestBase;
+import com.vaadin.tests.util.CheckBoxWithPropertyDataSource;
import com.vaadin.ui.CheckBox;
import com.vaadin.ui.PopupDateField;
}
private Range range = new Range();
- private ValueChangeListener refreshField = new ValueChangeListener() {
-
- @Override
- public void valueChange(ValueChangeEvent event) {
- actualDateField.markAsDirty();
- }
- };
private PopupDateField actualDateField;
+ private HasValue.ValueChangeListener<Boolean> refreshField = event -> actualDateField.markAsDirty();
@Override
protected void setup() {
PopupDateField fromField = createDateField();
fromField.setPropertyDataSource(bi.getItemProperty("from"));
- CheckBox fromInclusive = new CheckBox("From inclusive",
- bi.getItemProperty("fromInclusive"));
- CheckBox toInclusive = new CheckBox("To inclusive",
- bi.getItemProperty("toInclusive"));
+ CheckBox fromInclusive = new CheckBoxWithPropertyDataSource(
+ "From inclusive", bi.getItemProperty("fromInclusive"));
+ CheckBox toInclusive = new CheckBoxWithPropertyDataSource(
+ "To inclusive", bi.getItemProperty("toInclusive"));
fromInclusive.setImmediate(true);
- fromInclusive.addListener(refreshField);
+ fromInclusive.addValueChangeListener(refreshField);
toInclusive.setImmediate(true);
- toInclusive.addListener(refreshField);
+ toInclusive.addValueChangeListener(refreshField);
PopupDateField toField = createDateField();
toField.setPropertyDataSource(bi.getItemProperty("to"));
immediateCB.setValue(true);
immediateCB.setImmediate(true);
- immediateCB.addValueChangeListener(new ValueChangeListener() {
-
- @Override
- public void valueChange(ValueChangeEvent event) {
-
- inlineDynamicDateField.setImmediate(immediateCB.getValue());
- dynamicDateField.setImmediate(immediateCB.getValue());
-
- }
+ immediateCB.addValueChangeListener(event -> {
+ inlineDynamicDateField.setImmediate(immediateCB.getValue());
+ dynamicDateField.setImmediate(immediateCB.getValue());
});
recreate.addClickListener(new Button.ClickListener() {
import java.util.Date;
-import com.vaadin.data.Property.ValueChangeEvent;
-import com.vaadin.data.Property.ValueChangeListener;
import com.vaadin.server.VaadinRequest;
import com.vaadin.tests.components.AbstractTestUI;
import com.vaadin.ui.CheckBox;
main.addComponent(chk);
main.addComponent(sub);
- chk.addValueChangeListener(new ValueChangeListener() {
-
- @Override
- public void valueChange(ValueChangeEvent event) {
- df1.setValue(new Date());
- df2.setValue(new Date());
- pdf1.setValue(new Date());
- pdf2.setValue(new Date());
- pdf3.setValue(new Date());
- pdf4.setValue(new Date());
- sub.setEnabled(chk.getValue());
- }
+ chk.addValueChangeListener(event -> {
+ df1.setValue(new Date());
+ df2.setValue(new Date());
+ pdf1.setValue(new Date());
+ pdf2.setValue(new Date());
+ pdf3.setValue(new Date());
+ pdf4.setValue(new Date());
+ sub.setEnabled(chk.getValue());
});
}
CheckBox immediate = new CheckBox(
"Immediate (use sync button to change fields) ");
immediate.setValue(true);
- immediate.addListener(new CheckBox.ValueChangeListener() {
- @Override
- public void valueChange(ValueChangeEvent event) {
- boolean immediate = !dateField.isImmediate();
- dateField.setImmediate(immediate);
- dateField2.setImmediate(immediate);
- dateField3.setImmediate(immediate);
- }
+ immediate.addListener(event -> {
+ boolean newImmediate = !dateField.isImmediate();
+ dateField.setImmediate(newImmediate);
+ dateField2.setImmediate(newImmediate);
+ dateField3.setImmediate(newImmediate);
});
getLayout().addComponent(immediate);
package com.vaadin.tests.components.datefield;
-import com.vaadin.data.Property;
import com.vaadin.tests.components.TestBase;
import com.vaadin.ui.CheckBox;
import com.vaadin.ui.PopupDateField;
public void setup() {
final PopupDateField field = new PopupDateField();
final CheckBox box = new CheckBox(ENABLED, true);
- box.addListener(new Property.ValueChangeListener() {
-
- @Override
- public void valueChange(Property.ValueChangeEvent event) {
- field.setTextFieldEnabled((Boolean) event.getProperty()
- .getValue());
- if (field.isTextFieldEnabled()) {
- box.setCaption(ENABLED);
- } else {
- box.setCaption(DISABLED);
- }
+ box.addValueChangeListener(event -> {
+ field.setTextFieldEnabled(event.getValue());
+ if (field.isTextFieldEnabled()) {
+ box.setCaption(ENABLED);
+ } else {
+ box.setCaption(DISABLED);
}
});
addComponent(box);
package com.vaadin.tests.components.draganddropwrapper;
-import com.vaadin.data.Property.ValueChangeEvent;
-import com.vaadin.data.Property.ValueChangeListener;
import com.vaadin.event.dd.DragAndDropEvent;
import com.vaadin.event.dd.DropHandler;
import com.vaadin.event.dd.acceptcriteria.AcceptAll;
final CheckBox enabled = new CheckBox("Enabled", true);
addComponent(enabled);
enabled.setImmediate(true);
- enabled.addListener(new ValueChangeListener() {
-
- @Override
- public void valueChange(ValueChangeEvent event) {
- dnd.setEnabled(enabled.booleanValue());
- }
- });
+ enabled.addValueChangeListener(
+ event -> dnd.setEnabled(event.getValue()));
dnd.setDropHandler(new DropHandler() {
final CheckBox enabled = new CheckBox("Enabled", true);
addComponent(enabled);
enabled.setImmediate(true);
- enabled.addListener(new ValueChangeListener() {
-
- @Override
- public void valueChange(ValueChangeEvent event) {
- dnd.setEnabled(enabled.booleanValue());
- }
- });
+ enabled.addValueChangeListener(
+ event -> dnd.setEnabled(event.getValue()));
dnd.setDropHandler(new DropHandler() {
final CheckBox enabled = new CheckBox("Enabled", true);
addComponent(enabled);
enabled.setImmediate(true);
- enabled.addListener(new ValueChangeListener() {
-
- @Override
- public void valueChange(ValueChangeEvent event) {
- tbl.setEnabled(enabled.booleanValue());
- }
- });
+ enabled.addValueChangeListener(
+ event -> tbl.setEnabled(event.getValue()));
}
}
package com.vaadin.tests.components.formlayout;
-import com.vaadin.data.Property.ValueChangeEvent;
-import com.vaadin.data.Property.ValueChangeListener;
import com.vaadin.server.VaadinRequest;
import com.vaadin.tests.components.AbstractTestUI;
import com.vaadin.ui.CheckBox;
final CheckBox spacingCheckBox = new CheckBox("Spacings", false);
spacingCheckBox.setId("spacings");
spacingCheckBox.setImmediate(true);
- spacingCheckBox.addValueChangeListener(new ValueChangeListener() {
- @Override
- public void valueChange(ValueChangeEvent event) {
- setLayoutSpacing(spacingCheckBox.getValue());
- }
- });
+ spacingCheckBox.addValueChangeListener(
+ event -> setLayoutSpacing(spacingCheckBox.getValue()));
addComponent(spacingCheckBox);
final CheckBox marginCheckBox = new CheckBox("Margins", false);
marginCheckBox.setId("margins");
marginCheckBox.setImmediate(true);
- marginCheckBox.addValueChangeListener(new ValueChangeListener() {
- @Override
- public void valueChange(ValueChangeEvent event) {
- setLayoutMargin(marginCheckBox.getValue());
- }
- });
+ marginCheckBox.addValueChangeListener(
+ event -> setLayoutMargin(marginCheckBox.getValue()));
addComponent(marginCheckBox);
setLayoutSpacing(false);
/*
* Copyright 2000-2014 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
package com.vaadin.tests.components.grid;
import com.vaadin.annotations.Theme;
-import com.vaadin.data.Property.ValueChangeEvent;
-import com.vaadin.data.Property.ValueChangeListener;
import com.vaadin.server.VaadinRequest;
import com.vaadin.tests.util.Person;
import com.vaadin.tests.util.PersonContainer;
layout.addComponent(grid);
final CheckBox checkbox = new CheckBox("Details generator");
- checkbox.addValueChangeListener(new ValueChangeListener() {
- @Override
- @SuppressWarnings("boxing")
- public void valueChange(ValueChangeEvent event) {
- if (checkbox.getValue()) {
- grid.setDetailsGenerator(detailsGenerator);
- } else {
- grid.setDetailsGenerator(DetailsGenerator.NULL);
- }
+ checkbox.addValueChangeListener(event -> {
+ if (checkbox.getValue()) {
+ grid.setDetailsGenerator(detailsGenerator);
+ } else {
+ grid.setDetailsGenerator(DetailsGenerator.NULL);
}
});
layout.addComponent(checkbox);
import com.vaadin.annotations.Theme;
import com.vaadin.data.Item;
-import com.vaadin.data.Property.ValueChangeEvent;
-import com.vaadin.data.Property.ValueChangeListener;
import com.vaadin.data.util.IndexedContainer;
import com.vaadin.server.VaadinRequest;
import com.vaadin.tests.components.AbstractTestUIWithLog;
final CheckBox changeRenderer = new CheckBox(
"SetHtmlRenderer for Column 2", false);
- changeRenderer.addValueChangeListener(new ValueChangeListener() {
- @Override
- public void valueChange(ValueChangeEvent event) {
- Column column = grid.getColumn(getColumnProperty(1));
- if (changeRenderer.getValue()) {
- column.setRenderer(new HtmlRenderer());
- } else {
- column.setRenderer(new TextRenderer());
- }
- grid.markAsDirty();
+ changeRenderer.addValueChangeListener(event -> {
+ Column column = grid.getColumn(getColumnProperty(1));
+ if (changeRenderer.getValue()) {
+ column.setRenderer(new HtmlRenderer());
+ } else {
+ column.setRenderer(new TextRenderer());
}
+ grid.markAsDirty();
});
addComponent(changeRenderer);
}
/*
* Copyright 2000-2014 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
*/
package com.vaadin.tests.components.gridlayout;
-import com.vaadin.data.Property.ValueChangeEvent;
-import com.vaadin.data.Property.ValueChangeListener;
import com.vaadin.server.VaadinRequest;
import com.vaadin.tests.components.AbstractTestUI;
import com.vaadin.ui.CheckBox;
final GridLayout gl = new GridLayout(4, 4);
final CheckBox cb = new CheckBox("spacing");
- cb.addValueChangeListener(new ValueChangeListener() {
-
- @Override
- public void valueChange(ValueChangeEvent event) {
- gl.setSpacing(cb.getValue());
- }
- });
+ cb.addValueChangeListener(event -> gl.setSpacing(cb.getValue()));
cb.setValue(true);
addComponent(cb);
final CheckBox cb2 = new CheckBox("hide empty rows/columns");
- cb2.addValueChangeListener(new ValueChangeListener() {
-
- @Override
- public void valueChange(ValueChangeEvent event) {
- gl.setHideEmptyRowsAndColumns(cb2.getValue());
- }
- });
+ cb2.addValueChangeListener(
+ event -> gl.setHideEmptyRowsAndColumns(cb2.getValue()));
addComponent(cb2);
gl.setWidth("1000px");
gl.setHeight("500px");
/*
* (non-Javadoc)
- *
+ *
* @see com.vaadin.tests.components.AbstractTestUI#getTestDescription()
*/
@Override
/*
* (non-Javadoc)
- *
+ *
* @see com.vaadin.tests.components.AbstractTestUI#getTicketNumber()
*/
@Override
/*
* Copyright 2000-2014 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
*/
package com.vaadin.tests.components.gridlayout;
-import com.vaadin.data.Property.ValueChangeEvent;
-import com.vaadin.data.Property.ValueChangeListener;
import com.vaadin.server.VaadinRequest;
import com.vaadin.tests.components.AbstractTestUI;
import com.vaadin.ui.CheckBox;
toggleableLabel.setVisible(false); // Initially hidden
gridLayout.addComponent(toggleableLabel);
- visibilityToggleCheckBox
- .addValueChangeListener(new ValueChangeListener() {
- @Override
- public void valueChange(ValueChangeEvent event) {
- toggleableLabel.setVisible(visibilityToggleCheckBox
- .getValue());
- }
- });
+ visibilityToggleCheckBox.addValueChangeListener(event -> toggleableLabel
+ .setVisible(visibilityToggleCheckBox.getValue()));
}
/*
* Copyright 2000-2014 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
package com.vaadin.tests.components.javascriptcomponent;
import com.vaadin.annotations.JavaScript;
-import com.vaadin.data.Property;
import com.vaadin.server.VaadinRequest;
import com.vaadin.tests.components.AbstractTestUI;
import com.vaadin.ui.AbstractJavaScriptComponent;
addComponent(new CheckBox("Listener active") {
{
setImmediate(true);
- addValueChangeListener(new ValueChangeListener() {
- @Override
- public void valueChange(Property.ValueChangeEvent event) {
- resizeJsComponent.setListenerEnabled(event
- .getProperty().getValue() == Boolean.TRUE);
- }
- });
+ addValueChangeListener(event -> resizeJsComponent
+ .setListenerEnabled(event.getValue()));
}
});
/*
* Copyright 2000-2014 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
package com.vaadin.tests.components.media;
-import com.vaadin.data.util.MethodProperty;
import com.vaadin.server.ClassResource;
import com.vaadin.server.Resource;
import com.vaadin.tests.components.TestBase;
addComponent(audio);
- CheckBox checkBox = new CheckBox("Show controls",
- new MethodProperty<Boolean>(audio, "showControls"));
+ CheckBox checkBox = new CheckBox("Show controls");
+ checkBox.setValue(audio.isShowControls());
+ checkBox.addValueChangeListener(
+ event -> audio.setShowControls(event.getValue()));
checkBox.setImmediate(true);
addComponent(checkBox);
- checkBox = new CheckBox("HtmlContentAllowed",
- new MethodProperty<Boolean>(audio, "htmlContentAllowed"));
+ checkBox = new CheckBox("HtmlContentAllowed");
+ checkBox.setValue(audio.isHtmlContentAllowed());
+ checkBox.addValueChangeListener(
+ event -> audio.setHtmlContentAllowed(event.getValue()));
checkBox.setImmediate(true);
addComponent(checkBox);
- checkBox = new CheckBox("muted", new MethodProperty<Boolean>(audio,
- "muted"));
+ checkBox = new CheckBox("muted");
+ checkBox.setValue(audio.isMuted());
+ checkBox.addValueChangeListener(
+ event -> audio.setMuted(event.getValue()));
checkBox.setImmediate(true);
addComponent(checkBox);
- checkBox = new CheckBox("autoplay", new MethodProperty<Boolean>(audio,
- "autoplay"));
+ checkBox = new CheckBox("autoplay");
+ checkBox.setValue(audio.isAutoplay());
+ checkBox.addValueChangeListener(
+ event -> audio.setAutoplay(event.getValue()));
checkBox.setImmediate(true);
addComponent(checkBox);
/*
* Copyright 2000-2014 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
import java.util.Collections;
-import com.vaadin.data.Property;
import com.vaadin.server.VaadinRequest;
import com.vaadin.tests.components.AbstractTestUI;
import com.vaadin.ui.CheckBox;
/**
* Test UI for unset read-only flag of Option group with new items allowed.
- *
+ *
* @author Vaadin Ltd
*/
public class ReadOnlyOptionGroup extends AbstractTestUI {
final CheckBox readOnlyCheckbox = new CheckBox("read-only");
readOnlyCheckbox.setImmediate(true);
- readOnlyCheckbox
- .addValueChangeListener(new Property.ValueChangeListener() {
- @Override
- public void valueChange(Property.ValueChangeEvent event) {
- optionGroup.setReadOnly(readOnlyCheckbox.getValue());
- }
- });
+ readOnlyCheckbox.addValueChangeListener(
+ event -> optionGroup.setReadOnly(readOnlyCheckbox.getValue()));
readOnlyCheckbox.setValue(Boolean.TRUE);
addComponent(optionGroup);
final CheckBox vertical = new CheckBox("Vertical", !horizontal);
vertical.setImmediate(true);
- vertical.addListener(new ValueChangeListener() {
- @Override
- public void valueChange(ValueChangeEvent event) {
- view.removeAllComponents();
-
- view.addComponent(createControls(!vertical.getValue()
- .booleanValue()));
- view.addComponent(createTestLayout(!vertical.getValue()
- .booleanValue()));
+ vertical.addValueChangeListener(event -> {
+ view.removeAllComponents();
- view.setExpandRatio(view.getComponent(1), 1);
+ view.addComponent(createControls(!vertical.getValue()
+ .booleanValue()));
+ view.addComponent(createTestLayout(!vertical.getValue()
+ .booleanValue()));
- }
+ view.setExpandRatio(view.getComponent(1), 1);
});
header.addComponent(vertical);
layout.addComponent(height);
final CheckBox margin = new CheckBox("Margin", false);
- margin.addListener(new ValueChangeListener() {
- @Override
- public void valueChange(ValueChangeEvent event) {
- l.setMargin(margin.getValue().booleanValue());
- }
- });
+ margin.addValueChangeListener(event -> l.setMargin(event.getValue()));
margin.setImmediate(true);
layout.addComponent(margin);
layout.addComponent(margin);
final CheckBox spacing = new CheckBox("Spacing", false);
- spacing.addListener(new ValueChangeListener() {
- @Override
- public void valueChange(ValueChangeEvent event) {
- l.setSpacing(spacing.getValue().booleanValue());
- }
- });
+ spacing.addValueChangeListener(event -> l.setSpacing(event.getValue()));
spacing.setImmediate(true);
layout.addComponent(spacing);
expand = new CheckBox("Expand");
expand.setImmediate(true);
expand.setEnabled(false);
- expand.addListener(new ValueChangeListener() {
- @Override
- public void valueChange(ValueChangeEvent event) {
- if (target != null) {
- l.setExpandRatio(target, expand.getValue() ? 1 : 0);
- }
+ expand.addValueChangeListener(event -> {
+ if (target != null) {
+ l.setExpandRatio(target, expand.getValue() ? 1 : 0);
}
});
cell.addComponent(expand);
componentError = new CheckBox("Error");
componentError.setImmediate(true);
componentError.setEnabled(false);
- componentError.addListener(new ValueChangeListener() {
- @Override
- public void valueChange(ValueChangeEvent event) {
- if (target != null) {
- target.setComponentError(componentError.getValue() ? new UserError(
- "Error message") : null);
- }
+ componentError.addValueChangeListener(event -> {
+ if (target != null) {
+ target.setComponentError(componentError.getValue() ? new UserError(
+ "Error message") : null);
}
});
component.addComponent(componentError);
componentRequired = new CheckBox("Required");
componentRequired.setImmediate(true);
componentRequired.setEnabled(false);
- componentRequired.addListener(new ValueChangeListener() {
- @Override
- public void valueChange(ValueChangeEvent event) {
- if (target != null && target instanceof LegacyAbstractField) {
- ((LegacyAbstractField<?>) target).setRequired(componentRequired
- .getValue());
- }
+ componentRequired.addValueChangeListener(event -> {
+ if (target != null && target instanceof LegacyAbstractField) {
+ ((LegacyAbstractField<?>) target).setRequired(componentRequired
+ .getValue());
}
});
component.addComponent(componentRequired);
import java.util.Map;
-import com.vaadin.data.Property.ValueChangeEvent;
-import com.vaadin.data.Property.ValueChangeListener;
import com.vaadin.tests.components.TestBase;
import com.vaadin.ui.Button;
import com.vaadin.ui.CheckBox;
final CheckBox heightSelection = new CheckBox("Undefined height");
heightSelection.setImmediate(true);
- heightSelection.addListener(new ValueChangeListener() {
- @Override
- public void valueChange(ValueChangeEvent event) {
- if (heightSelection.getValue() == Boolean.TRUE) {
- panel.setHeight(null);
- } else {
- panel.setHeight("100%");
- }
+ heightSelection.addValueChangeListener(event -> {
+ if (heightSelection.getValue() == Boolean.TRUE) {
+ panel.setHeight(null);
+ } else {
+ panel.setHeight("100%");
}
});
actions.addComponent(heightSelection);
package com.vaadin.tests.components.richtextarea;
-import com.vaadin.data.Property.ValueChangeEvent;
-import com.vaadin.data.Property.ValueChangeListener;
import com.vaadin.shared.ui.label.ContentMode;
import com.vaadin.tests.components.TestBase;
import com.vaadin.ui.Button;
CheckBox cb = new CheckBox("close");
cb.setImmediate(true);
- cb.addValueChangeListener(new ValueChangeListener() {
-
- @Override
- public void valueChange(ValueChangeEvent event) {
- getMainWindow().removeWindow(subWindow);
- }
- });
+ cb.addValueChangeListener(
+ event -> getMainWindow().removeWindow(subWindow));
wLayout.addComponent(cb);
}
package com.vaadin.tests.components.select;
-import java.util.Iterator;
-
-import com.vaadin.data.Property.ValueChangeEvent;
-import com.vaadin.data.Property.ValueChangeListener;
import com.vaadin.tests.components.ComponentTestCase;
import com.vaadin.ui.AbstractSelect;
import com.vaadin.ui.CheckBox;
protected void initializeComponents() {
CheckBox cb = new CheckBox("Switch Selects ReadOnly", false);
- cb.addListener(new ValueChangeListener() {
-
- @Override
- public void valueChange(ValueChangeEvent event) {
- for (Iterator<Component> it = layout.getComponentIterator(); it
- .hasNext();) {
- Component c = it.next();
- if (c instanceof AbstractSelect) {
- c.setReadOnly(!c.isReadOnly());
- }
+ cb.addValueChangeListener(event -> {
+ for (Component c : layout) {
+ if (c instanceof AbstractSelect) {
+ c.setReadOnly(!c.isReadOnly());
}
}
});
CheckBox cb2 = new CheckBox("Switch Selects Enabled", true);
- cb2.addListener(new ValueChangeListener() {
-
- @Override
- public void valueChange(ValueChangeEvent event) {
- for (Iterator<Component> it = layout.getComponentIterator(); it
- .hasNext();) {
- Component c = it.next();
- if (c instanceof AbstractSelect) {
- boolean enabled = !c.isEnabled();
- c.setEnabled(enabled);
- c.setCaption(c.getCaption().replace(
- (enabled ? "disabled" : "enabled"),
- (enabled ? "enabled" : "disabled")));
- }
+ cb2.addValueChangeListener(event -> {
+ for (Component c : layout) {
+ if (c instanceof AbstractSelect) {
+ boolean enabled = !c.isEnabled();
+ c.setEnabled(enabled);
+ c.setCaption(c.getCaption().replace(
+ (enabled ? "disabled" : "enabled"),
+ (enabled ? "enabled" : "disabled")));
}
}
});
package com.vaadin.tests.components.splitpanel;
import com.vaadin.annotations.Theme;
-import com.vaadin.data.Property.ValueChangeEvent;
-import com.vaadin.data.Property.ValueChangeListener;
import com.vaadin.event.FieldEvents.TextChangeEvent;
import com.vaadin.event.FieldEvents.TextChangeListener;
import com.vaadin.server.VaadinRequest;
grid.addComponent(l, 0, 1);
CheckBox checkBox = new CheckBox();
grid.addComponent(checkBox, 1, 2);
- checkBox.addValueChangeListener(new ValueChangeListener() {
-
- @Override
- public void valueChange(ValueChangeEvent event) {
-
- }
- });
Window window = new Window();
window.setWidth(300.0f, Unit.PIXELS);
window.setContent(grid);
package com.vaadin.tests.components.table;
import com.vaadin.data.Item;
-import com.vaadin.data.Property.ValueChangeEvent;
-import com.vaadin.data.Property.ValueChangeListener;
import com.vaadin.tests.components.TestBase;
import com.vaadin.ui.Button;
import com.vaadin.ui.Button.ClickEvent;
CheckBox cb = new CheckBox("Set first column width");
cb.setValue(false);
cb.setImmediate(true);
- cb.addListener(new ValueChangeListener() {
-
- @Override
- public void valueChange(ValueChangeEvent event) {
- if ((Boolean) event.getProperty().getValue()) {
- rightTable.setColumnWidth("name", 150);
- } else {
- rightTable.setColumnWidth("name", -1);
- }
-
+ cb.addValueChangeListener(event -> {
+ if (event.getValue()) {
+ rightTable.setColumnWidth("name", 150);
+ } else {
+ rightTable.setColumnWidth("name", -1);
}
});
addComponent(cb);
cb = new CheckBox("Set second column width");
cb.setValue(true);
cb.setImmediate(true);
- cb.addListener(new ValueChangeListener() {
-
- @Override
- public void valueChange(ValueChangeEvent event) {
- if ((Boolean) event.getProperty().getValue()) {
- rightTable.setColumnWidth("info", 20);
- } else {
- rightTable.setColumnWidth("info", -1);
- }
-
+ cb.addValueChangeListener(event -> {
+ if (event.getValue()) {
+ rightTable.setColumnWidth("info", 20);
+ } else {
+ rightTable.setColumnWidth("info", -1);
}
});
addComponent(cb);
});
addComponent(theme);
CheckBox footers = new CheckBox("Show footers");
- footers.addListener(new ValueChangeListener() {
-
- @Override
- public void valueChange(ValueChangeEvent event) {
- boolean visible = (Boolean) event.getProperty().getValue();
- fooTable.setFooterVisible(visible);
- barTable.setFooterVisible(visible);
- bazTable.setFooterVisible(visible);
- }
+ footers.addValueChangeListener(event -> {
+ boolean visible = event.getValue();
+ fooTable.setFooterVisible(visible);
+ barTable.setFooterVisible(visible);
+ bazTable.setFooterVisible(visible);
});
footers.setImmediate(true);
addComponent(footers);
protected void setup() {
editMode = new CheckBox("Edit mode");
editMode.setImmediate(true);
- editMode.addListener(new ValueChangeListener() {
-
- @Override
- public void valueChange(ValueChangeEvent event) {
- table.setEditable(editMode.getValue());
-
- }
- });
+ editMode.addValueChangeListener(
+ event -> table.setEditable(editMode.getValue()));
useCustomConverters = new CheckBox("Use custom converters");
useCustomConverters.setImmediate(true);
- useCustomConverters.addListener(new ValueChangeListener() {
-
- @Override
- public void valueChange(ValueChangeEvent event) {
- recreateTable();
- }
- });
+ useCustomConverters.addValueChangeListener(event -> recreateTable());
localeSelect = createLocaleSelect();
personBeanItemContainer = createContainer(100);
import java.util.HashMap;
import com.vaadin.data.Container;
-import com.vaadin.data.Property.ValueChangeEvent;
-import com.vaadin.data.Property.ValueChangeListener;
import com.vaadin.legacy.ui.LegacyField;
import com.vaadin.shared.ui.label.ContentMode;
import com.vaadin.tests.components.TestBase;
protected void setup() {
addComponent(useFieldFactory);
useFieldFactory.setImmediate(true);
- useFieldFactory.addListener(new ValueChangeListener() {
-
- @Override
- public void valueChange(ValueChangeEvent event) {
- if (useFieldFactory.getValue()) {
- table.setTableFieldFactory(new CachingFieldFactory());
- } else {
- table.setTableFieldFactory(DefaultFieldFactory.get());
- }
+ useFieldFactory.addValueChangeListener(event -> {
+ if (useFieldFactory.getValue()) {
+ table.setTableFieldFactory(new CachingFieldFactory());
+ } else {
+ table.setTableFieldFactory(DefaultFieldFactory.get());
}
});
addComponent(table);
import com.vaadin.data.Container;
import com.vaadin.data.Item;
-import com.vaadin.data.Property;
-import com.vaadin.data.Property.ValueChangeEvent;
import com.vaadin.data.util.IndexedContainer;
import com.vaadin.server.VaadinRequest;
import com.vaadin.tests.components.AbstractTestUI;
final CheckBox visible = new CheckBox("Footers Visible", true);
visible.setImmediate(true);
- visible.addValueChangeListener(new Property.ValueChangeListener() {
- @Override
- public void valueChange(ValueChangeEvent event) {
- table.setFooterVisible(visible.getValue());
-
- }
- });
+ visible.addValueChangeListener(
+ event -> table.setFooterVisible(visible.getValue()));
options.addComponent(visible);
import com.vaadin.data.Container;
import com.vaadin.data.Item;
-import com.vaadin.data.Property;
-import com.vaadin.data.Property.ValueChangeEvent;
import com.vaadin.data.util.IndexedContainer;
import com.vaadin.server.VaadinRequest;
import com.vaadin.tests.components.AbstractTestUIWithLog;
CheckBox immediateCheckbox = new CheckBox("Immediate");
immediateCheckbox.setImmediate(true);
immediateCheckbox.setValue(table.isImmediate());
- immediateCheckbox
- .addValueChangeListener(new Property.ValueChangeListener() {
-
- @Override
- public void valueChange(ValueChangeEvent event) {
- table.setImmediate((Boolean) event.getProperty()
- .getValue());
- }
- });
+ immediateCheckbox.addValueChangeListener(
+ event -> table.setImmediate(event.getValue()));
CheckBox columnReorderingCheckbox = new CheckBox(
"Column reordering allowed");
columnReorderingCheckbox.setImmediate(true);
columnReorderingCheckbox.setValue(table.isColumnReorderingAllowed());
- columnReorderingCheckbox
- .addValueChangeListener(new Property.ValueChangeListener() {
-
- @Override
- public void valueChange(ValueChangeEvent event) {
- table.setColumnReorderingAllowed((Boolean) event
- .getProperty().getValue());
- }
- });
+ columnReorderingCheckbox.addValueChangeListener(
+ event -> table.setColumnReorderingAllowed(event.getValue()));
addComponent(immediateCheckbox);
addComponent(columnReorderingCheckbox);
import com.vaadin.data.Container;
import com.vaadin.data.Item;
-import com.vaadin.data.Property;
-import com.vaadin.data.Property.ValueChangeEvent;
import com.vaadin.data.util.IndexedContainer;
import com.vaadin.server.VaadinRequest;
import com.vaadin.tests.components.AbstractTestUI;
CheckBox immediateCheckbox = new CheckBox("Immediate");
immediateCheckbox.setImmediate(true);
immediateCheckbox.setValue(table.isImmediate());
- immediateCheckbox
- .addValueChangeListener(new Property.ValueChangeListener() {
-
- @Override
- public void valueChange(ValueChangeEvent event) {
- table.setImmediate((Boolean) event.getProperty()
- .getValue());
- }
- });
+ immediateCheckbox.addValueChangeListener(
+ event -> table.setImmediate(event.getValue()));
CheckBox sortEnabledCheckbox = new CheckBox("Sortable");
sortEnabledCheckbox.setImmediate(true);
sortEnabledCheckbox.setValue(table.isSortEnabled());
- sortEnabledCheckbox
- .addValueChangeListener(new Property.ValueChangeListener() {
-
- @Override
- public void valueChange(ValueChangeEvent event) {
- table.setSortEnabled((Boolean) event.getProperty()
- .getValue());
- }
- });
+ sortEnabledCheckbox.addValueChangeListener(
+ event -> table.setSortEnabled(event.getValue()));
CheckBox columnReorderingCheckbox = new CheckBox(
"Column reordering allowed");
columnReorderingCheckbox.setImmediate(true);
columnReorderingCheckbox.setValue(table.isColumnReorderingAllowed());
- columnReorderingCheckbox
- .addValueChangeListener(new Property.ValueChangeListener() {
-
- @Override
- public void valueChange(ValueChangeEvent event) {
- table.setColumnReorderingAllowed((Boolean) event
- .getProperty().getValue());
- }
- });
+ columnReorderingCheckbox.addValueChangeListener(
+ event -> table.setColumnReorderingAllowed(event.getValue()));
addComponent(immediateCheckbox);
addComponent(sortEnabledCheckbox);
package com.vaadin.tests.components.table;
import com.vaadin.data.Container;
+import com.vaadin.data.HasValue;
+import com.vaadin.data.HasValue.ValueChange;
import com.vaadin.data.Item;
-import com.vaadin.data.Property.ValueChangeEvent;
-import com.vaadin.data.Property.ValueChangeListener;
import com.vaadin.data.util.IndexedContainer;
import com.vaadin.server.VaadinRequest;
import com.vaadin.tests.components.AbstractTestUIWithLog;
CheckBox immediateCheckbox = new CheckBox("Immediate");
immediateCheckbox.setImmediate(true);
immediateCheckbox.setValue(table.isImmediate());
- immediateCheckbox.addValueChangeListener(new ValueChangeListener() {
-
- @Override
- public void valueChange(ValueChangeEvent event) {
- table.setImmediate((Boolean) event.getProperty().getValue());
- }
- });
+ immediateCheckbox.addValueChangeListener(
+ event -> table.setImmediate(event.getValue()));
CheckBox headerClickListenerCheckbox = new CheckBox(
"Header click listener");
headerClickListenerCheckbox.setImmediate(true);
headerClickListenerCheckbox
- .addValueChangeListener(new ValueChangeListener() {
+ .addValueChangeListener(new HasValue.ValueChangeListener<Boolean>() {
private HeaderClickListener headerClickListener = new HeaderClickListener() {
};
@Override
- public void valueChange(ValueChangeEvent event) {
+ public void accept(ValueChange<Boolean> event) {
if (table.getListeners(HeaderClickEvent.class)
.isEmpty()) {
table.addHeaderClickListener(headerClickListener);
"Footer click listener");
footerClickListenerCheckbox.setImmediate(true);
footerClickListenerCheckbox
- .addValueChangeListener(new ValueChangeListener() {
+ .addValueChangeListener(new HasValue.ValueChangeListener<Boolean>() {
private FooterClickListener footerClickListener = new FooterClickListener() {
};
@Override
- public void valueChange(ValueChangeEvent event) {
+ public void accept(ValueChange<Boolean> event) {
if (table.getListeners(FooterClickEvent.class)
.isEmpty()) {
table.addFooterClickListener(footerClickListener);
CheckBox sortEnabledCheckbox = new CheckBox("Sortable");
sortEnabledCheckbox.setImmediate(true);
sortEnabledCheckbox.setValue(table.isSortEnabled());
- sortEnabledCheckbox.addValueChangeListener(new ValueChangeListener() {
- @Override
- public void valueChange(ValueChangeEvent event) {
- table.setSortEnabled((Boolean) event.getProperty().getValue());
- }
- });
+ sortEnabledCheckbox.addValueChangeListener(
+ event -> table.setSortEnabled(event.getValue()));
CheckBox columnReorderingCheckbox = new CheckBox(
"Column reordering allowed");
columnReorderingCheckbox.setImmediate(true);
columnReorderingCheckbox.setValue(table.isColumnReorderingAllowed());
- columnReorderingCheckbox
- .addValueChangeListener(new ValueChangeListener() {
-
- @Override
- public void valueChange(ValueChangeEvent event) {
- table.setColumnReorderingAllowed((Boolean) event
- .getProperty().getValue());
- }
- });
+ columnReorderingCheckbox.addValueChangeListener(
+ event -> table.setColumnReorderingAllowed(event.getValue()));
addComponent(immediateCheckbox);
addComponent(headerClickListenerCheckbox);
package com.vaadin.tests.components.table;
import com.vaadin.data.Item;
-import com.vaadin.data.Property.ValueChangeEvent;
-import com.vaadin.data.Property.ValueChangeListener;
import com.vaadin.event.Action;
import com.vaadin.event.ItemClickEvent;
import com.vaadin.event.ItemClickEvent.ItemClickListener;
protected void setup(VaadinRequest request) {
CheckBox cb = new CheckBox("Item click listener");
cb.setImmediate(true);
- cb.addValueChangeListener(new ValueChangeListener() {
-
- @Override
- public void valueChange(ValueChangeEvent event) {
- if (((Boolean) event.getProperty().getValue())) {
- table.addItemClickListener(HeaderPositionWhenSorting.this);
- } else {
- table.removeItemClickListener(HeaderPositionWhenSorting.this);
- }
-
+ cb.addValueChangeListener(event -> {
+ if (event.getValue()) {
+ table.addItemClickListener(HeaderPositionWhenSorting.this);
+ } else {
+ table.removeItemClickListener(HeaderPositionWhenSorting.this);
}
});
addComponent(cb);
CheckBox cbActionHandler = new CheckBox("Action handler");
cbActionHandler.setImmediate(true);
- cbActionHandler.addValueChangeListener(new ValueChangeListener() {
-
- @Override
- public void valueChange(ValueChangeEvent event) {
- if (((Boolean) event.getProperty().getValue())) {
- table.addActionHandler(HeaderPositionWhenSorting.this);
- } else {
- table.removeActionHandler(HeaderPositionWhenSorting.this);
- }
-
+ cbActionHandler.addValueChangeListener(event -> {
+ if (event.getValue()) {
+ table.addActionHandler(HeaderPositionWhenSorting.this);
+ } else {
+ table.removeActionHandler(HeaderPositionWhenSorting.this);
}
});
addComponent(cbActionHandler);
CheckBox cbActionHasActions = new CheckBox("Action handler has actions");
cbActionHasActions.setImmediate(true);
- cbActionHasActions.addValueChangeListener(new ValueChangeListener() {
-
- @Override
- public void valueChange(ValueChangeEvent event) {
- actionHandlerHasActions = ((Boolean) event.getProperty()
- .getValue());
+ cbActionHasActions.addValueChangeListener(event -> {
+ actionHandlerHasActions = event.getValue();
- // Workaround to ensure actions are repainted
- removeComponent(table);
- addComponent(table);
-
- }
+ // Workaround to ensure actions are repainted
+ removeComponent(table);
+ addComponent(table);
});
addComponent(cbActionHasActions);
package com.vaadin.tests.components.table;
-import com.vaadin.data.Property.ValueChangeEvent;
-import com.vaadin.data.Property.ValueChangeListener;
import com.vaadin.server.VaadinRequest;
import com.vaadin.tests.components.AbstractTestUI;
import com.vaadin.ui.CheckBox;
table.setImmediate(true);
final CheckBox showHeaders = new CheckBox("Show headers");
- showHeaders.addValueChangeListener(new ValueChangeListener() {
-
- @Override
- public void valueChange(ValueChangeEvent event) {
- if (showHeaders.getValue()) {
- table.setColumnHeaderMode(ColumnHeaderMode.EXPLICIT_DEFAULTS_ID);
- } else {
- table.setColumnHeaderMode(ColumnHeaderMode.HIDDEN);
- }
+ showHeaders.addValueChangeListener(event -> {
+ if (showHeaders.getValue()) {
+ table.setColumnHeaderMode(ColumnHeaderMode.EXPLICIT_DEFAULTS_ID);
+ } else {
+ table.setColumnHeaderMode(ColumnHeaderMode.HIDDEN);
}
});
package com.vaadin.tests.components.table;
import com.vaadin.data.Item;
-import com.vaadin.data.util.MethodProperty;
import com.vaadin.event.ItemClickEvent;
import com.vaadin.event.ItemClickEvent.ItemClickListener;
import com.vaadin.server.ExternalResource;
import com.vaadin.server.VaadinRequest;
import com.vaadin.tests.components.AbstractTestUI;
import com.vaadin.tests.util.Log;
+import com.vaadin.ui.AbstractSelect;
import com.vaadin.ui.Button;
import com.vaadin.ui.Button.ClickEvent;
import com.vaadin.ui.CheckBox;
-import com.vaadin.ui.Component;
import com.vaadin.ui.HorizontalLayout;
import com.vaadin.ui.Table;
import com.vaadin.ui.Tree;
}
- private static HorizontalLayout createHorizontalLayout(Component c) {
+ private static HorizontalLayout createHorizontalLayout(AbstractSelect c) {
HorizontalLayout layout = new HorizontalLayout();
- CheckBox b = new CheckBox("immediate", new MethodProperty<Boolean>(c,
- "immediate"));
+ CheckBox b = new CheckBox("immediate");
+ b.setValue(c.isImmediate());
+ b.addValueChangeListener(event -> c.setImmediate(event.getValue()));
b.setImmediate(true);
layout.addComponent(b);
- b = new CheckBox("selectable", new MethodProperty<Boolean>(c,
- "selectable"));
+ b = new CheckBox("selectable");
+ if (c instanceof Table) {
+ b.setValue(((Table) c).isSelectable());
+ b.addValueChangeListener(event -> ((Table) c).setSelectable(event.getValue()));
+ } else if (c instanceof Tree) {
+ b.setValue(((Tree) c).isSelectable());
+ b.addValueChangeListener(event -> ((Tree) c).setSelectable(event.getValue()));
+ }
b.setImmediate(true);
layout.addComponent(b);
- b = new CheckBox("nullsel", new MethodProperty<Boolean>(c,
- "nullSelectionAllowed"));
+ b = new CheckBox("nullsel");
+ b.setValue(c.isNullSelectionAllowed());
+ b.addValueChangeListener(event -> c.setNullSelectionAllowed(event.getValue()));
b.setImmediate(true);
layout.addComponent(b);
- b = new CheckBox("multi", new MethodProperty<Boolean>(c, "multiSelect"));
+ b = new CheckBox("multi");
+ b.setValue(c.isMultiSelect());
+ b.addValueChangeListener(event -> c.setMultiSelect(event.getValue()));
b.setImmediate(true);
layout.addComponent(b);
return layout;
/*
* Copyright 2000-2014 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
*/
package com.vaadin.tests.components.table;
-import com.vaadin.data.Property.ValueChangeListener;
import com.vaadin.server.VaadinRequest;
import com.vaadin.tests.components.AbstractTestUIWithLog;
import com.vaadin.ui.CheckBox;
import com.vaadin.ui.Table;
/**
- *
+ *
* @since
* @author Vaadin Ltd
*/
/*
* (non-Javadoc)
- *
+ *
* @see com.vaadin.tests.components.AbstractTestUI#setup(com.vaadin.server.
* VaadinRequest)
*/
table.setSelectable(true);
CheckBox selectAllCheckbox = new CheckBox("Select All");
- selectAllCheckbox.addValueChangeListener(new ValueChangeListener() {
- @Override
- public void valueChange(
- com.vaadin.data.Property.ValueChangeEvent event) {
- Object checked = event.getProperty().getValue();
- if (checked instanceof Boolean) {
- if (((Boolean) checked).booleanValue()) {
- table.setValue(table.getItemIds());
- } else {
- table.setValue(null);
- }
- }
+ selectAllCheckbox.addValueChangeListener(event -> {
+ if (event.getValue()) {
+ table.setValue(table.getItemIds());
+ } else {
+ table.setValue(null);
}
});
/*
* (non-Javadoc)
- *
+ *
* @see com.vaadin.tests.components.AbstractTestUI#getTestDescription()
*/
@Override
/*
* (non-Javadoc)
- *
+ *
* @see com.vaadin.tests.components.AbstractTestUI#getTicketNumber()
*/
@Override
package com.vaadin.tests.components.table;
import com.vaadin.data.Item;
-import com.vaadin.data.Property.ValueChangeEvent;
-import com.vaadin.data.Property.ValueChangeListener;
import com.vaadin.event.Action;
import com.vaadin.event.ItemClickEvent;
import com.vaadin.event.ItemClickEvent.ItemClickListener;
public void setup() {
CheckBox cb = new CheckBox("Item click listener");
cb.setImmediate(true);
- cb.addListener(new ValueChangeListener() {
-
- @Override
- public void valueChange(ValueChangeEvent event) {
- if (((Boolean) event.getProperty().getValue())) {
- table.addListener(TableAndBrowserContextMenu.this);
- } else {
- table.removeListener(TableAndBrowserContextMenu.this);
- }
-
+ cb.addValueChangeListener(event -> {
+ if (event.getValue()) {
+ table.addListener(TableAndBrowserContextMenu.this);
+ } else {
+ table.removeListener(TableAndBrowserContextMenu.this);
}
});
addComponent(cb);
CheckBox cbActionHandler = new CheckBox("Action handler");
cbActionHandler.setImmediate(true);
- cbActionHandler.addListener(new ValueChangeListener() {
-
- @Override
- public void valueChange(ValueChangeEvent event) {
- if (((Boolean) event.getProperty().getValue())) {
- table.addActionHandler(TableAndBrowserContextMenu.this);
- } else {
- table.removeActionHandler(TableAndBrowserContextMenu.this);
- }
-
+ cbActionHandler.addValueChangeListener(event -> {
+ if (event.getValue()) {
+ table.addActionHandler(TableAndBrowserContextMenu.this);
+ } else {
+ table.removeActionHandler(TableAndBrowserContextMenu.this);
}
});
addComponent(cbActionHandler);
CheckBox cbActionHasActions = new CheckBox("Action handler has actions");
cbActionHasActions.setImmediate(true);
- cbActionHasActions.addListener(new ValueChangeListener() {
-
- @Override
- public void valueChange(ValueChangeEvent event) {
- actionHandlerHasActions = ((Boolean) event.getProperty()
- .getValue());
+ cbActionHasActions.addValueChangeListener(event -> {
+ actionHandlerHasActions = event.getValue();
- // Workaround to ensure actions are repainted
- removeComponent(table);
- addComponent(table);
-
- }
+ // Workaround to ensure actions are repainted
+ removeComponent(table);
+ addComponent(table);
});
addComponent(cbActionHasActions);
package com.vaadin.tests.components.table;
-import com.vaadin.data.Property.ValueChangeEvent;
-import com.vaadin.data.Property.ValueChangeListener;
import com.vaadin.event.Action;
import com.vaadin.server.VaadinRequest;
import com.vaadin.tests.components.AbstractTestUI;
import com.vaadin.ui.VerticalLayout;
/*
- * Differs from TableContextMenu by number of items, their numbering and
+ * Differs from TableContextMenu by number of items, their numbering and
* immediate/selectable/multiselect toggling
*/
public class TableContextMenuTouch extends AbstractTestUI {
final CheckBox immediateCheckBox = new CheckBox("Immediate");
vlay.addComponent(immediateCheckBox);
- immediateCheckBox.addValueChangeListener(new ValueChangeListener() {
- @Override
- public void valueChange(ValueChangeEvent event) {
- table.setImmediate(immediateCheckBox.getValue());
- }
- });
+ immediateCheckBox.addValueChangeListener(
+ event -> table.setImmediate(immediateCheckBox.getValue()));
immediateCheckBox.setValue(true);
table.setImmediate(immediateCheckBox.getValue());
final CheckBox selectableCheckBox = new CheckBox("Selectable");
final CheckBox multiselectCheckBox = new CheckBox("Multiselect");
vlay.addComponent(selectableCheckBox);
- selectableCheckBox.addValueChangeListener(new ValueChangeListener() {
- @Override
- public void valueChange(ValueChangeEvent event) {
- table.setSelectable(selectableCheckBox.getValue());
- multiselectCheckBox.setEnabled(selectableCheckBox.getValue());
- }
+ selectableCheckBox.addValueChangeListener(event -> {
+ table.setSelectable(selectableCheckBox.getValue());
+ multiselectCheckBox.setEnabled(selectableCheckBox.getValue());
});
selectableCheckBox.setValue(true);
multiselectCheckBox.setEnabled(selectableCheckBox.getValue());
table.setSelectable(selectableCheckBox.getValue());
vlay.addComponent(multiselectCheckBox);
- multiselectCheckBox.addValueChangeListener(new ValueChangeListener() {
- @Override
- public void valueChange(ValueChangeEvent event) {
- table.setMultiSelect(multiselectCheckBox.getValue());
- }
- });
+ multiselectCheckBox.addValueChangeListener(
+ event -> table.setMultiSelect(multiselectCheckBox.getValue()));
multiselectCheckBox.setValue(true);
table.setMultiSelect(multiselectCheckBox.getValue());
package com.vaadin.tests.components.table;
-import com.vaadin.data.Property.ValueChangeEvent;
-import com.vaadin.data.Property.ValueChangeListener;
import com.vaadin.tests.components.AbstractTestCase;
import com.vaadin.ui.CheckBox;
import com.vaadin.ui.LegacyWindow;
* Setting table height and setting column header mode as hidden leaves the body
* height of the table as it would be with the headers visible and leaves an
* empty area below the body.
- *
+ *
*/
@SuppressWarnings("serial")
public class TableHeightWhenHidingHeaders extends AbstractTestCase {
table.addItem("2").getItemProperty("Name").setValue("Item 2");
CheckBox showHeaders = new CheckBox("Show headers");
- showHeaders.addListener(new ValueChangeListener() {
+ showHeaders.addValueChangeListener(event -> {
+ if (event.getValue()) {
+ // table body height is now 77px, which together
+ // with header makes 100px
+ table.setColumnHeaderMode(Table.COLUMN_HEADER_MODE_EXPLICIT_DEFAULTS_ID);
+ } else {
+ table.setColumnHeaderMode(Table.COLUMN_HEADER_MODE_HIDDEN);
+ // header disappears, but table body height stays at
+ // 77px
+ // and below the body is an empty area (same height
+ // as header would
+ // have)
- @Override
- public void valueChange(ValueChangeEvent event) {
- if ((Boolean) event.getProperty().getValue()) {
- // table body height is now 77px, which together
- // with header makes 100px
- table.setColumnHeaderMode(Table.COLUMN_HEADER_MODE_EXPLICIT_DEFAULTS_ID);
- } else {
- table.setColumnHeaderMode(Table.COLUMN_HEADER_MODE_HIDDEN);
- // header disappears, but table body height stays at
- // 77px
- // and below the body is an empty area (same height
- // as header would
- // have)
-
- }
}
});
showHeaders.setValue(true);
import com.vaadin.data.Container;
import com.vaadin.data.Item;
-import com.vaadin.data.Property.ValueChangeEvent;
-import com.vaadin.data.Property.ValueChangeListener;
import com.vaadin.data.util.IndexedContainer;
import com.vaadin.server.VaadinRequest;
import com.vaadin.tests.components.AbstractTestUI;
final Table table = createTable();
table.setId("table");
componentDescription = new CheckBox("Tooltip on components");
- componentDescription.addValueChangeListener(new ValueChangeListener() {
-
- @Override
- public void valueChange(ValueChangeEvent event) {
- table.setContainerDataSource(createContainer(componentDescription
- .getValue()));
- }
- });
+ componentDescription
+ .addValueChangeListener(event -> table.setContainerDataSource(
+ createContainer(componentDescription.getValue())));
componentDescription.setImmediate(true);
componentDescription.setValue(true);
tableCellItemDescription = new CheckBox("Tooltip on table cells");
tableCellItemDescription
- .addValueChangeListener(new ValueChangeListener() {
-
- @Override
- public void valueChange(ValueChangeEvent event) {
- table.refreshRowCache();
- }
- });
+ .addValueChangeListener(event -> table.refreshRowCache());
tableCellItemDescription.setImmediate(true);
tableCellItemDescription.setValue(true);
tableRowItemDescription = new CheckBox("Tooltip on table Rows");
tableRowItemDescription
- .addValueChangeListener(new ValueChangeListener() {
-
- @Override
- public void valueChange(ValueChangeEvent event) {
- table.refreshRowCache();
- }
- });
+ .addValueChangeListener(event -> table.refreshRowCache());
tableRowItemDescription.setImmediate(true);
tableRowItemDescription.setValue(true);
package com.vaadin.tests.components.table;
-import com.vaadin.data.Property.ValueChangeEvent;
-import com.vaadin.data.Property.ValueChangeListener;
import com.vaadin.tests.components.TestBase;
import com.vaadin.ui.CheckBox;
import com.vaadin.ui.Table;
final CheckBox chkSelectable = new CheckBox("selectable");
chkSelectable.setImmediate(true);
- chkSelectable.addListener(new ValueChangeListener() {
- @Override
- public void valueChange(ValueChangeEvent event) {
- table.setSelectable(chkSelectable.getValue());
- }
- });
+ chkSelectable.addValueChangeListener(
+ event -> table.setSelectable(chkSelectable.getValue()));
table.addContainerProperty("row #", String.class, "-");
table.setColumnWidth("row #", 150);
import com.vaadin.data.Property;
import com.vaadin.data.Property.ValueChangeEvent;
-import com.vaadin.data.Property.ValueChangeListener;
import com.vaadin.data.util.sqlcontainer.SQLContainer;
import com.vaadin.data.util.sqlcontainer.connection.JDBCConnectionPool;
import com.vaadin.data.util.sqlcontainer.connection.SimpleJDBCConnectionPool;
});
final CheckBox editMode = new CheckBox("Edit mode");
- editMode.addValueChangeListener(new ValueChangeListener() {
- @Override
- public void valueChange(ValueChangeEvent event) {
- table.setEditable(editMode.getValue());
- }
- });
+ editMode.addValueChangeListener(
+ event -> table.setEditable(editMode.getValue()));
addComponent(editMode);
}
/**
* (Re)creates the test table
- *
+ *
* @param connectionPool
*/
private void createTestTable(JDBCConnectionPool connectionPool) {
/**
* Adds test data to the test table
- *
+ *
* @param connectionPool
* @throws SQLException
*/
import com.vaadin.data.Container;
import com.vaadin.data.Property;
import com.vaadin.data.Property.ValueChangeEvent;
-import com.vaadin.data.Property.ValueChangeListener;
import com.vaadin.data.util.IndexedContainer;
import com.vaadin.tests.components.TestBase;
import com.vaadin.tests.util.Log;
CheckBox cb = new CheckBox("Column 1");
cb.setValue(true);
- cb.addListener(new ValueChangeListener() {
-
- @Override
- public void valueChange(ValueChangeEvent event) {
- Boolean value = (Boolean) event.getProperty().getValue();
- tbl.setColumnCollapsed("Column 1", !value);
- if (value) {
- log.log("Column 1 visible");
- } else {
- log.log("Column 1 hidden");
- }
+ cb.addValueChangeListener(event -> {
+ Boolean value = event.getValue();
+ tbl.setColumnCollapsed("Column 1", !value);
+ if (value) {
+ log.log("Column 1 visible");
+ } else {
+ log.log("Column 1 hidden");
}
});
cb.setImmediate(true);
cb = new CheckBox("Column 2");
cb.setValue(true);
- cb.addListener(new ValueChangeListener() {
-
- @Override
- public void valueChange(ValueChangeEvent event) {
- Boolean value = (Boolean) event.getProperty().getValue();
- tbl.setColumnCollapsed("Column 2", !value);
-
- if (value) {
- log.log("Column 2 visible");
- } else {
- log.log("Column 2 hidden");
- }
+ cb.addValueChangeListener(event -> {
+ Boolean value = event.getValue();
+ tbl.setColumnCollapsed("Column 2", !value);
+
+ if (value) {
+ log.log("Column 2 visible");
+ } else {
+ log.log("Column 2 hidden");
}
});
cb.setImmediate(true);
cb = new CheckBox("Column 3");
cb.setValue(true);
- cb.addListener(new ValueChangeListener() {
-
- @Override
- public void valueChange(ValueChangeEvent event) {
- Boolean value = (Boolean) event.getProperty().getValue();
+ cb.addValueChangeListener(event -> {
+ Boolean value = event.getValue();
- tbl.setColumnCollapsed("Column 3", !value);
+ tbl.setColumnCollapsed("Column 3", !value);
- if (value) {
- log.log("Column 3 visible");
- } else {
- log.log("Column 3 hidden");
- }
+ if (value) {
+ log.log("Column 3 visible");
+ } else {
+ log.log("Column 3 hidden");
}
});
cb.setImmediate(true);
/*
* Copyright 2000-2014 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
import com.vaadin.data.Item;
import com.vaadin.data.Property;
-import com.vaadin.data.Property.ValueChangeEvent;
-import com.vaadin.data.Property.ValueChangeListener;
import com.vaadin.data.util.IndexedContainer;
import com.vaadin.event.ListenerMethod.MethodException;
import com.vaadin.server.ErrorEvent;
/**
* Container which throws an exception on every fifth call to
* {@link #getContainerProperty(Object, Object)}.
- *
+ *
* @author Vaadin Ltd
* @version @VERSION@
* @since 7.0
- *
+ *
*/
public class BrokenContainer extends IndexedContainer {
private int counter = 0;
brokenContainer.setImmediate(true);
brokenGenerator.setImmediate(true);
clearTableOnError.setImmediate(true);
- clearTableOnError.addValueChangeListener(new ValueChangeListener() {
-
- @Override
- public void valueChange(ValueChangeEvent event) {
- Boolean value = clearTableOnError.getValue();
- setErrorHandler(value != null ? value : false);
- }
+ clearTableOnError.addValueChangeListener(event -> {
+ Boolean value = clearTableOnError.getValue();
+ setErrorHandler(value != null ? value : false);
});
final Table table = new Table("Semi-broken table");
table.setContainerDataSource(createBrokenContainer(10, 4));
final CheckBox multiselect = new CheckBox("Multiselect");
multiselect.setImmediate(true);
multiselect.setId("multiselect");
- multiselect.addValueChangeListener(new ValueChangeListener() {
-
- @Override
- public void valueChange(ValueChangeEvent event) {
- Boolean value = multiselect.getValue();
- table.setMultiSelect(value == null ? false : value);
- }
+ multiselect.addValueChangeListener(event -> {
+ Boolean value = multiselect.getValue();
+ table.setMultiSelect(value == null ? false : value);
});
addComponent(multiselect);
Button addItemsButton = new Button("Add table items",
package com.vaadin.tests.components.textarea;
-import com.vaadin.data.Property;
-import com.vaadin.data.Property.ValueChangeEvent;
import com.vaadin.tests.components.TestBase;
import com.vaadin.tests.util.LoremIpsum;
import com.vaadin.ui.CheckBox;
CheckBox onoff = new CheckBox("Wrap state for the right field");
onoff.setValue(false);
- onoff.addListener(new Property.ValueChangeListener() {
- @Override
- public void valueChange(ValueChangeEvent event) {
- boolean wrap = (Boolean) event.getProperty().getValue();
- area2.setWordwrap(wrap);
- if (wrap) {
- area2.setCaption("Wrapping");
- } else {
- area2.setCaption("Nonwrapping");
- }
-
+ onoff.addValueChangeListener(event -> {
+ boolean wrap = event.getValue();
+ area2.setWordwrap(wrap);
+ if (wrap) {
+ area2.setCaption("Wrapping");
+ } else {
+ area2.setCaption("Nonwrapping");
}
});
onoff.setImmediate(true);
package com.vaadin.tests.components.textfield;
-import com.vaadin.data.Property;
-import com.vaadin.data.Property.ValueChangeEvent;
import com.vaadin.tests.components.TestBase;
import com.vaadin.ui.AbstractTextField;
import com.vaadin.ui.Button;
panel.setCaption("Hackers panel");
CheckBox ml = new CheckBox("Multiline");
ml.setImmediate(true);
- ml.addListener(new Property.ValueChangeListener() {
- @Override
- public void valueChange(ValueChangeEvent event) {
- if (textField.getUI() == null
- || textField.getUI().getSession() == null) {
- replaceComponent(textArea, textField);
- activeComponent = textField;
- } else {
- replaceComponent(textField, textArea);
- activeComponent = textArea;
- }
+ ml.addValueChangeListener(event -> {
+ if (textField.getUI() == null
+ || textField.getUI().getSession() == null) {
+ replaceComponent(textArea, textField);
+ activeComponent = textField;
+ } else {
+ replaceComponent(textField, textArea);
+ activeComponent = textArea;
}
});
fl.addComponent(ml);
package com.vaadin.tests.components.textfield;
-import com.vaadin.data.Property;
-import com.vaadin.data.Property.ValueChangeEvent;
import com.vaadin.tests.components.TestBase;
import com.vaadin.ui.CheckBox;
import com.vaadin.ui.TextField;
final CheckBox readonly = new CheckBox("Readonly");
readonly.setImmediate(true);
- readonly.addListener(new Property.ValueChangeListener() {
- @Override
- public void valueChange(ValueChangeEvent event) {
- boolean readonly = Boolean.valueOf(event.getProperty()
- .getValue().toString());
- field1.setReadOnly(readonly);
- field2.setReadOnly(readonly);
- field3.setReadOnly(readonly);
- field0.setReadOnly(readonly);
- }
+ readonly.addValueChangeListener(event -> {
+ boolean newReadonly = event.getValue();
+ field1.setReadOnly(newReadonly);
+ field2.setReadOnly(newReadonly);
+ field3.setReadOnly(newReadonly);
+ field0.setReadOnly(newReadonly);
});
addComponent(readonly);
package com.vaadin.tests.components.textfield;
-import com.vaadin.data.Property.ValueChangeEvent;
-import com.vaadin.data.Property.ValueChangeListener;
import com.vaadin.event.ShortcutAction.KeyCode;
import com.vaadin.tests.components.TestBase;
import com.vaadin.tests.util.Log;
final CheckBox inputPromptSelection = new CheckBox("Input prompt");
inputPromptSelection.setImmediate(true);
- inputPromptSelection.addListener(new ValueChangeListener() {
- @Override
- public void valueChange(ValueChangeEvent event) {
- if (event.getProperty().getValue() == Boolean.TRUE) {
- textField.setInputPrompt("Input prompt");
- } else {
- textField.setInputPrompt(null);
- }
- log.log("Set input prompt: " + textField.getInputPrompt());
+ inputPromptSelection.addValueChangeListener(event -> {
+ if (event.getValue()) {
+ textField.setInputPrompt("Input prompt");
+ } else {
+ textField.setInputPrompt(null);
}
+ log.log("Set input prompt: " + textField.getInputPrompt());
});
inputPromptSelection.setImmediate(true);
package com.vaadin.tests.components.tree;
import com.vaadin.data.Item;
-import com.vaadin.data.Property.ValueChangeEvent;
-import com.vaadin.data.Property.ValueChangeListener;
import com.vaadin.data.util.HierarchicalContainer;
import com.vaadin.event.dd.DragAndDropEvent;
import com.vaadin.event.dd.DropHandler;
CheckBox cb = new CheckBox("Connectors");
cb.setValue(false);
cb.setImmediate(true);
- cb.addListener(new ValueChangeListener() {
-
- @Override
- public void valueChange(ValueChangeEvent event) {
- if ((Boolean) event.getProperty().getValue()) {
- tree.addStyleName(BaseTheme.TREE_CONNECTORS);
- } else {
- tree.removeStyleName(BaseTheme.TREE_CONNECTORS);
- }
+ cb.addValueChangeListener(event -> {
+ if (event.getValue()) {
+ tree.addStyleName(BaseTheme.TREE_CONNECTORS);
+ } else {
+ tree.removeStyleName(BaseTheme.TREE_CONNECTORS);
}
});
addComponent(cb);
package com.vaadin.tests.components.tree;
import com.vaadin.data.Item;
-import com.vaadin.data.Property.ValueChangeEvent;
-import com.vaadin.data.Property.ValueChangeListener;
import com.vaadin.data.util.HierarchicalContainer;
import com.vaadin.tests.components.TestBase;
import com.vaadin.ui.Button;
final CheckBox filterType = new CheckBox(
"Include parent when filtering", true);
filterType.setImmediate(true);
- filterType.addListener(new ValueChangeListener() {
-
- @Override
- public void valueChange(ValueChangeEvent event) {
- cont.setIncludeParentsWhenFiltering(((CheckBox) event
- .getProperty()).getValue());
- ccTree.markAsDirty();
- }
+ filterType.addValueChangeListener(event -> {
+ cont.setIncludeParentsWhenFiltering(event.getValue());
+ ccTree.markAsDirty();
});
addComponent(filterType);
/*
* Copyright 2000-2014 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
*/
package com.vaadin.tests.components.tree;
-import com.vaadin.data.Property.ValueChangeEvent;
-import com.vaadin.data.Property.ValueChangeListener;
import com.vaadin.server.VaadinRequest;
import com.vaadin.tests.components.AbstractTestUI;
import com.vaadin.ui.CheckBox;
final CheckBox toggle = new CheckBox("HTML content allowed",
tree.isHtmlContentAllowed());
- toggle.addValueChangeListener(new ValueChangeListener() {
- @Override
- public void valueChange(ValueChangeEvent event) {
- tree.setHtmlContentAllowed(toggle.getValue().booleanValue());
- }
- });
+ toggle.addValueChangeListener(event -> tree
+ .setHtmlContentAllowed(toggle.getValue().booleanValue()));
addComponents(tree, toggle);
}
package com.vaadin.tests.components.window;
-import com.vaadin.data.Property.ValueChangeEvent;
-import com.vaadin.data.Property.ValueChangeListener;
import com.vaadin.server.Page.BrowserWindowResizeEvent;
import com.vaadin.server.Page.BrowserWindowResizeListener;
import com.vaadin.shared.ui.label.ContentMode;
lazyMode = new CheckBox("Lazy resize");
lazyMode.setImmediate(true);
- lazyMode.addListener(new ValueChangeListener() {
-
- @Override
- public void valueChange(ValueChangeEvent event) {
- setLazy(lazyMode.getValue());
- }
- });
+ lazyMode.addValueChangeListener(event -> setLazy(lazyMode.getValue()));
resizeListenerCheckBox = new CheckBox("Resize listener");
resizeListenerCheckBox.setImmediate(true);
- resizeListenerCheckBox.addListener(new ValueChangeListener() {
-
- @Override
- public void valueChange(ValueChangeEvent event) {
- if (resizeListenerCheckBox.getValue()) {
- subWindow.addListener(resizeListener);
- mainWindow.addListener(browserWindowResizeListener);
- } else {
- subWindow.removeListener(resizeListener);
- mainWindow.removeListener(browserWindowResizeListener);
- }
-
+ resizeListenerCheckBox.addValueChangeListener(event -> {
+ if (resizeListenerCheckBox.getValue()) {
+ subWindow.addListener(resizeListener);
+ mainWindow.addListener(browserWindowResizeListener);
+ } else {
+ subWindow.removeListener(resizeListener);
+ mainWindow.removeListener(browserWindowResizeListener);
}
-
});
immediateCheckBox = new CheckBox("Windows immediate");
immediateCheckBox.setImmediate(true);
- immediateCheckBox.addListener(new ValueChangeListener() {
-
- @Override
- public void valueChange(ValueChangeEvent event) {
- mainWindow.setImmediate(immediateCheckBox.getValue());
- subWindow.setImmediate(immediateCheckBox.getValue());
- }
-
+ immediateCheckBox.addValueChangeListener(event -> {
+ mainWindow.setImmediate(immediateCheckBox.getValue());
+ subWindow.setImmediate(immediateCheckBox.getValue());
});
mainWindow.addComponent(lazyMode);
mainWindow.addComponent(resizeListenerCheckBox);
});
final CheckBox resizeable = new CheckBox("Resizeable");
resizeable.setValue(w.isResizable());
- resizeable.addValueChangeListener(new ValueChangeListener() {
-
- @Override
- public void valueChange(ValueChangeEvent event) {
- w.setResizable(resizeable.getValue());
- }
- });
+ resizeable.addValueChangeListener(
+ event -> w.setResizable(resizeable.getValue()));
((ComponentContainer) w.getContent()).addComponent(resizeable);
final CheckBox closeable = new CheckBox("Closeable");
closeable.setValue(w.isClosable());
- closeable.addValueChangeListener(new ValueChangeListener() {
-
- @Override
- public void valueChange(ValueChangeEvent event) {
- w.setClosable(closeable.getValue());
- }
- });
+ closeable.addValueChangeListener(
+ event -> w.setClosable(closeable.getValue()));
((ComponentContainer) w.getContent()).addComponent(closeable);
NativeButton contentFull = new NativeButton("Set Content Size Full",
new Button.ClickListener() {
package com.vaadin.tests.components.window;
-import com.vaadin.data.Property;
-import com.vaadin.data.Property.ValueChangeEvent;
import com.vaadin.server.Page;
import com.vaadin.server.Page.BrowserWindowResizeEvent;
import com.vaadin.tests.components.TestBase;
CheckBox subwindow = new CheckBox("show subwindow");
subwindow.setImmediate(true);
- subwindow.addListener(new Property.ValueChangeListener() {
-
- @Override
- public void valueChange(ValueChangeEvent event) {
- if ((Boolean) event.getProperty().getValue()) {
- getMainWindow().addWindow(subwin);
- } else {
- getMainWindow().removeWindow(subwin);
- }
+ subwindow.addValueChangeListener(event -> {
+ if (event.getValue()) {
+ getMainWindow().addWindow(subwin);
+ } else {
+ getMainWindow().removeWindow(subwin);
}
});
getLayout().addComponent(subwindow);
CheckBox immediate = new CheckBox("immediate");
- immediate.addListener(new Property.ValueChangeListener() {
-
- @Override
- public void valueChange(ValueChangeEvent event) {
- boolean booleanValue = (Boolean) event.getProperty().getValue();
- getMainWindow().setImmediate(booleanValue);
- subwin.setImmediate(booleanValue);
- }
+ immediate.addValueChangeListener(event -> {
+ boolean booleanValue = event.getValue();
+ getMainWindow().setImmediate(booleanValue);
+ subwin.setImmediate(booleanValue);
});
immediate.setImmediate(true);
immediate.setValue(true);
package com.vaadin.tests.containers;
import com.vaadin.data.Item;
-import com.vaadin.data.Property.ValueChangeEvent;
-import com.vaadin.data.Property.ValueChangeListener;
import com.vaadin.data.util.BeanItemContainer;
import com.vaadin.server.Sizeable;
import com.vaadin.tests.components.TestBase;
vl.addComponent(filterString);
final CheckBox cb = new CheckBox("Filter on value");
- cb.addListener(new ValueChangeListener() {
-
- @Override
- public void valueChange(ValueChangeEvent event) {
- container.removeAllContainerFilters();
- if (((CheckBox) event.getProperty()).getValue()) {
- container.addContainerFilter("value", filterString
- .getValue().toString(), false, false);
- }
+ cb.addValueChangeListener(event -> {
+ container.removeAllContainerFilters();
+ if (event.getValue()) {
+ container.addContainerFilter("value",
+ filterString.getValue().toString(), false, false);
}
});
cb.setImmediate(true);
package com.vaadin.tests.containers;
import com.vaadin.data.Item;
-import com.vaadin.data.Property.ValueChangeEvent;
-import com.vaadin.data.Property.ValueChangeListener;
import com.vaadin.data.util.IndexedContainer;
import com.vaadin.server.Sizeable;
import com.vaadin.tests.components.TestBase;
vl.addComponent(filterString);
final CheckBox cb = new CheckBox("Filter");
- cb.addListener(new ValueChangeListener() {
-
- @Override
- public void valueChange(ValueChangeEvent event) {
- container.removeAllContainerFilters();
- if (((CheckBox) event.getProperty()).getValue()) {
- container.addContainerFilter("column1", filterString
- .getValue().toString(), false, false);
- }
+ cb.addValueChangeListener(event -> {
+ container.removeAllContainerFilters();
+ if (event.getValue()) {
+ container.addContainerFilter("column1", filterString
+ .getValue().toString(), false, false);
}
});
cb.setImmediate(true);
import java.util.Iterator;
import com.vaadin.data.Container;
-import com.vaadin.data.Property.ValueChangeEvent;
-import com.vaadin.data.Property.ValueChangeListener;
import com.vaadin.data.util.BeanItem;
import com.vaadin.data.util.BeanItemContainer;
import com.vaadin.data.util.HierarchicalContainer;
CheckBox checkBox = new CheckBox("Enabled");
checkBox.setImmediate(true);
checkBox.setValue(true);
- checkBox.addListener(new ValueChangeListener() {
- @Override
- public void valueChange(ValueChangeEvent event) {
- tree.setEnabled(!tree.isEnabled());
- }
- });
+ checkBox.addValueChangeListener(event -> tree.setEnabled(!tree.isEnabled()));
addComponent(checkBox);
checkBox = new CheckBox("Drag start");
checkBox.setImmediate(true);
checkBox.setValue(true);
- checkBox.addListener(new ValueChangeListener() {
- @Override
- public void valueChange(ValueChangeEvent event) {
- if (((CheckBox) event.getProperty()).getValue()) {
- tree.setDragMode(TreeDragMode.NODE);
- } else {
- tree.setDragMode(TreeDragMode.NONE);
- }
+ checkBox.addValueChangeListener(event -> {
+ if (event.getValue()) {
+ tree.setDragMode(TreeDragMode.NODE);
+ } else {
+ tree.setDragMode(TreeDragMode.NONE);
}
});
addComponent(checkBox);
import com.vaadin.tests.data.bean.Sex;
import com.vaadin.ui.Button;
import com.vaadin.ui.Button.ClickEvent;
+import com.vaadin.ui.CheckBox;
import com.vaadin.ui.ComponentContainer;
import com.vaadin.ui.Notification;
import com.vaadin.ui.Panel;
private Configuration configuration = new Configuration();
private class ConfigurationPanel extends Panel {
+ private CheckBox preCommitCheckBox = new CheckBox("Pre Commit Fails", configuration.isPreCommitFails());
+ private CheckBox postCommitCheckBox = new CheckBox("Post Commit Fails", configuration.isPostCommitFails());
public ConfigurationPanel() {
super("Configuration", new VerticalLayout());
((VerticalLayout) getContent()).setMargin(true);
- BeanItem<Configuration> bi = new BeanItem<BasicPersonForm.Configuration>(
- configuration);
- FieldGroup confFieldGroup = new FieldGroup(bi);
- confFieldGroup.setItemDataSource(bi);
- confFieldGroup.setBuffered(false);
-
- for (Object propertyId : bi.getItemPropertyIds()) {
- ((ComponentContainer) getContent())
- .addComponent(confFieldGroup.buildAndBind(propertyId));
- }
+ preCommitCheckBox.addValueChangeListener(event -> configuration.setPreCommitFails(event.getValue()));
+ postCommitCheckBox.addValueChangeListener(event -> configuration.setPostCommitFails(event.getValue()));
+ ((ComponentContainer) getContent()).addComponents(preCommitCheckBox, postCommitCheckBox);
}
}
package com.vaadin.tests.integration;
-import com.vaadin.data.Property.ValueChangeEvent;
-import com.vaadin.data.Property.ValueChangeListener;
import com.vaadin.server.Page;
import com.vaadin.server.Page.BrowserWindowResizeEvent;
import com.vaadin.tests.components.TestBase;
mainWindow.setImmediate(true);
CheckBox lazyCheckBox = new CheckBox("Lazy resize");
- lazyCheckBox.addListener(new ValueChangeListener() {
- @Override
- public void valueChange(ValueChangeEvent event) {
- CheckBox cb = (CheckBox) event.getProperty();
- Boolean resizeLazy = cb.getValue();
- getMainWindow().setResizeLazy(resizeLazy);
- log.log("Resize lazy: " + resizeLazy);
- }
+ lazyCheckBox.addValueChangeListener(event -> {
+ boolean resizeLazy = event.getValue();
+ getMainWindow().setResizeLazy(resizeLazy);
+ log.log("Resize lazy: " + resizeLazy);
});
lazyCheckBox.setValue(Boolean.FALSE);
lazyCheckBox.setImmediate(true);
CheckBox requiredToggle = new CheckBox();
requiredToggle.setImmediate(true);
requiredToggle.setCaption("Required");
- requiredToggle.addListener(new ValueChangeListener() {
-
- @Override
- public void valueChange(ValueChangeEvent event) {
- setRequired((Boolean) event.getProperty().getValue());
- }
- });
+ requiredToggle
+ .addValueChangeListener(event -> setRequired(event.getValue()));
return requiredToggle;
}
CheckBox iconToggle = new CheckBox();
iconToggle.setImmediate(true);
iconToggle.setCaption("Icons");
- iconToggle.addListener(new ValueChangeListener() {
-
- @Override
- public void valueChange(ValueChangeEvent event) {
- setIcon((Boolean) event.getProperty().getValue());
- }
- });
+ iconToggle.addValueChangeListener(event -> setIcon(event.getValue()));
return iconToggle;
}
CheckBox errorToggle = new CheckBox();
errorToggle.setImmediate(true);
errorToggle.setCaption("Error");
- errorToggle.addListener(new ValueChangeListener() {
-
- @Override
- public void valueChange(ValueChangeEvent event) {
- setError((Boolean) event.getProperty().getValue());
- }
- });
+ errorToggle.addValueChangeListener(event -> setError(event.getValue()));
return errorToggle;
}
import java.util.ArrayList;
import java.util.List;
+import com.vaadin.data.HasRequired;
import com.vaadin.data.Item;
import com.vaadin.data.Property.ValueChangeEvent;
import com.vaadin.data.Property.ValueChangeListener;
-import com.vaadin.legacy.ui.LegacyAbstractField;
import com.vaadin.server.ThemeResource;
import com.vaadin.server.UserError;
import com.vaadin.tests.components.TestBase;
+import com.vaadin.ui.AbstractComponent;
import com.vaadin.ui.Button;
import com.vaadin.ui.Button.ClickEvent;
import com.vaadin.ui.Button.ClickListener;
private HorizontalLayout horizontalLayout;
private GridLayout gridLayout;
private FormLayout formLayout;
- private List<LegacyAbstractField<?>> components = new ArrayList<LegacyAbstractField<?>>();
+ private List<AbstractComponent> components = new ArrayList<>();
private CssLayout cssLayout;
private HorizontalLayout layoutParent = new HorizontalLayout();
}
protected void prependCaptions(String prepend) {
- for (LegacyAbstractField<?> c : components) {
+ for (Component c : components) {
c.setCaption(prepend + c.getCaption());
}
CheckBox requiredToggle = new CheckBox();
requiredToggle.setImmediate(true);
requiredToggle.setCaption("Required");
- requiredToggle.addListener(new ValueChangeListener() {
-
- @Override
- public void valueChange(ValueChangeEvent event) {
- setRequired((Boolean) event.getProperty().getValue());
- }
- });
+ requiredToggle
+ .addValueChangeListener(event -> setRequired(event.getValue()));
return requiredToggle;
}
CheckBox iconToggle = new CheckBox();
iconToggle.setImmediate(true);
iconToggle.setCaption("Icons");
- iconToggle.addListener(new ValueChangeListener() {
-
- @Override
- public void valueChange(ValueChangeEvent event) {
- setIcon((Boolean) event.getProperty().getValue());
- }
- });
+ iconToggle.addValueChangeListener(event -> setIcon(event.getValue()));
return iconToggle;
}
CheckBox readOnlyToggle = new CheckBox();
readOnlyToggle.setImmediate(true);
readOnlyToggle.setCaption("Read only");
- readOnlyToggle.addValueChangeListener(new ValueChangeListener() {
- @Override
- public void valueChange(ValueChangeEvent event) {
- setReadOnly((Boolean) event.getProperty().getValue());
- }
- });
+ readOnlyToggle
+ .addValueChangeListener(event -> setReadOnly(event.getValue()));
return readOnlyToggle;
}
enabledToggle.setImmediate(true);
enabledToggle.setValue(true);
enabledToggle.setCaption("Enabled");
- enabledToggle.addValueChangeListener(new ValueChangeListener() {
- @Override
- public void valueChange(ValueChangeEvent event) {
- setEnabled((Boolean) event.getProperty().getValue());
- }
- });
+ enabledToggle
+ .addValueChangeListener(event -> setEnabled(event.getValue()));
return enabledToggle;
}
private Component toggleInvalid() {
CheckBox invalid = new CheckBox("Invalid");
invalid.setImmediate(true);
- invalid.addValueChangeListener(new ValueChangeListener() {
- @Override
- public void valueChange(ValueChangeEvent event) {
- setInvalid((Boolean) event.getProperty().getValue());
- }
- });
+ invalid.addValueChangeListener(event -> setInvalid(event.getValue()));
return invalid;
}
"Der eingegebene Wert ist nicht zulässig!");
}
- for (LegacyAbstractField<?> c : components) {
+ for (AbstractComponent c : components) {
c.setComponentError(userError);
}
}
protected void setRequired(boolean value) {
- for (LegacyAbstractField<?> c : components) {
- c.setRequired(value);
+ for (AbstractComponent c : components) {
+ if (c instanceof HasRequired) {
+ ((HasRequired) c).setRequired(value);
+ }
}
}
protected void setIcon(boolean value) {
- for (LegacyAbstractField<?> c : components) {
+ for (Component c : components) {
if (!value) {
c.setIcon(null);
} else {
}
protected void setReadOnly(boolean value) {
- for (LegacyAbstractField<?> c : components) {
+ for (Component c : components) {
c.setReadOnly(value);
}
}
protected void setEnabled(boolean value) {
- for (LegacyAbstractField<?> c : components) {
+ for (Component c : components) {
c.setEnabled(value);
}
}
CheckBox errorToggle = new CheckBox();
errorToggle.setImmediate(true);
errorToggle.setCaption("Error");
- errorToggle.addListener(new ValueChangeListener() {
-
- @Override
- public void valueChange(ValueChangeEvent event) {
- setError((Boolean) event.getProperty().getValue());
- }
- });
+ errorToggle.addValueChangeListener(event -> setError(event.getValue()));
return errorToggle;
}
protected void setError(boolean value) {
- for (LegacyAbstractField<?> c : components) {
+ for (AbstractComponent c : components) {
if (value) {
c.setComponentError(new UserError("error"));
} else {
import java.util.HashMap;
import java.util.Map;
-import com.vaadin.data.Property.ValueChangeEvent;
-import com.vaadin.data.Property.ValueChangeListener;
import com.vaadin.tests.components.TestBase;
import com.vaadin.ui.Button;
import com.vaadin.ui.Button.ClickEvent;
private Component createMarginsToggle() {
final CheckBox cb = new CheckBox("Margins");
cb.setImmediate(true);
- cb.addListener(new ValueChangeListener() {
-
- @Override
- public void valueChange(ValueChangeEvent event) {
- ((MarginHandler) layout).setMargin(cb.getValue());
- }
- });
+ cb.addValueChangeListener(
+ event -> ((MarginHandler) layout).setMargin(cb.getValue()));
return cb;
}
package com.vaadin.tests.layouts;
-import com.vaadin.data.Property.ValueChangeEvent;
-import com.vaadin.data.Property.ValueChangeListener;
import com.vaadin.tests.components.TestBase;
import com.vaadin.ui.CheckBox;
import com.vaadin.ui.FormLayout;
protected void setup() {
FormLayout formLayout = new FormLayout();
CheckBox control = new CheckBox("Messages On/Off");
- control.addListener(new ValueChangeListener() {
-
- @Override
- public void valueChange(ValueChangeEvent event) {
- messages.setVisible((Boolean) event.getProperty().getValue());
- messages.setRequired(true);
- messages.setCaption("Messages visible");
- }
-
+ control.addValueChangeListener(event -> {
+ messages.setVisible(event.getValue());
+ messages.setRequired(true);
+ messages.setCaption("Messages visible");
});
control.setImmediate(true);
formLayout.addComponent(control);
return;
}
- boolean wrapped = wrapInPanel.booleanValue();
+ boolean wrapped = wrapInPanel.getValue();
ComponentContainer container = containerType.buildLayout(
((Number) levels.getValue()).intValue(),
((Number) childAmount.getValue()).intValue(), leafType,
import org.apache.commons.lang.SerializationUtils;
import com.vaadin.annotations.Push;
-import com.vaadin.data.Property.ValueChangeEvent;
-import com.vaadin.data.Property.ValueChangeListener;
import com.vaadin.server.VaadinRequest;
import com.vaadin.tests.components.AbstractTestUIWithLog;
import com.vaadin.ui.AbstractOrderedLayout;
@Override
protected void setup(VaadinRequest request) {
final CheckBox pollingEnabled = new CheckBox("Polling enabled");
- pollingEnabled.addValueChangeListener(new ValueChangeListener() {
- @Override
- public void valueChange(ValueChangeEvent event) {
- setPollInterval(pollingEnabled.getValue() ? 1000 : -1);
- }
- });
+ pollingEnabled.addValueChangeListener(event -> setPollInterval(
+ pollingEnabled.getValue() ? 1000 : -1));
Button start = new Button("start");
start.setId(START);
@Override
public void run() {
access(new Runnable() {
+ @Override
public void run() {
populate();
log("Serialized session size: "
/*
* Copyright 2000-2014 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
import java.util.Timer;
import java.util.TimerTask;
-import com.vaadin.data.Property.ValueChangeEvent;
-import com.vaadin.data.Property.ValueChangeListener;
import com.vaadin.server.VaadinRequest;
import com.vaadin.shared.communication.PushMode;
import com.vaadin.tests.components.AbstractTestUI;
pushSetting.setValue(Boolean.valueOf(getPushConfiguration()
.getPushMode().isEnabled()));
pushSetting.setImmediate(true);
- pushSetting.addValueChangeListener(new ValueChangeListener() {
- @Override
- public void valueChange(ValueChangeEvent event) {
- if (event.getProperty().getValue() == Boolean.TRUE) {
- getPushConfiguration().setPushMode(PushMode.AUTOMATIC);
- } else {
- getPushConfiguration().setPushMode(PushMode.DISABLED);
- }
+ pushSetting.addValueChangeListener(event -> {
+ if (event.getValue()) {
+ getPushConfiguration().setPushMode(PushMode.AUTOMATIC);
+ } else {
+ getPushConfiguration().setPushMode(PushMode.DISABLED);
}
});
addComponent(pushSetting);
/*
* Copyright 2000-2014 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
package com.vaadin.tests.serialization;
import com.vaadin.annotations.Widgetset;
-import com.vaadin.data.Property.ValueChangeEvent;
-import com.vaadin.data.Property.ValueChangeListener;
import com.vaadin.server.VaadinRequest;
import com.vaadin.tests.components.AbstractTestUI;
import com.vaadin.tests.widgetset.TestingWidgetSet;
addComponent(layoutDetector);
CheckBox uiPolling = new CheckBox("UI polling enabled");
- uiPolling.addValueChangeListener(new ValueChangeListener() {
- @Override
- public void valueChange(ValueChangeEvent event) {
- if (event.getProperty().getValue() == Boolean.TRUE) {
- setPollInterval(100);
- } else {
- setPollInterval(-1);
- }
+ uiPolling.addValueChangeListener(event -> {
+ if (event.getValue()) {
+ setPollInterval(100);
+ } else {
+ setPollInterval(-1);
}
});
addComponent(uiPolling);
package com.vaadin.tests.themes;
-import com.vaadin.data.Property.ValueChangeEvent;
-import com.vaadin.data.Property.ValueChangeListener;
import com.vaadin.server.ThemeResource;
import com.vaadin.server.UserError;
import com.vaadin.ui.Button;
setTheme("reindeer");
themeToggle = new CheckBox("Runo theme");
- themeToggle.addListener(new ValueChangeListener() {
-
- @Override
- public void valueChange(ValueChangeEvent event) {
- if (getTheme() == "reindeer") {
- setTheme("runo");
- } else {
- setTheme("reindeer");
- }
+ themeToggle.addValueChangeListener(event -> {
+ if (getTheme() == "reindeer") {
+ setTheme("runo");
+ } else {
+ setTheme("reindeer");
}
});
themeToggle.setStyleName("small");
themeToggle.setImmediate(true);
styleToggle = new CheckBox("Black style");
- styleToggle.addListener(new ValueChangeListener() {
-
- @Override
- public void valueChange(ValueChangeEvent event) {
- if (!main.getContent().getStyleName().contains("black")) {
- main.getContent().setStyleName("black");
- } else {
- main.getContent().setStyleName("");
- }
+ styleToggle.addValueChangeListener(event -> {
+ if (!main.getContent().getStyleName().contains("black")) {
+ main.getContent().setStyleName("black");
+ } else {
+ main.getContent().setStyleName("");
}
});
styleToggle.setImmediate(true);
styleToggle.setStyleName("small");
iconToggle = new CheckBox("64x icons");
- iconToggle.addListener(new ValueChangeListener() {
-
- @Override
- public void valueChange(ValueChangeEvent event) {
- largeIcons = !largeIcons;
- recreateAll();
- }
+ iconToggle.addValueChangeListener(event -> {
+ largeIcons = !largeIcons;
+ recreateAll();
});
iconToggle.setImmediate(true);
iconToggle.setStyleName("small");
nativeToggle = new CheckBox("Native buttons");
- nativeToggle.addListener(new ValueChangeListener() {
-
- @Override
- public void valueChange(ValueChangeEvent event) {
- nativeButtons = !nativeButtons;
- recreateAll();
- }
+ nativeToggle.addValueChangeListener(event -> {
+ nativeButtons = !nativeButtons;
+ recreateAll();
});
nativeToggle.setImmediate(true);
nativeToggle.setStyleName("small");
import java.util.TimeZone;
import com.vaadin.annotations.Theme;
+import com.vaadin.data.Binder;
import com.vaadin.data.Item;
-import com.vaadin.data.Property;
import com.vaadin.data.Property.ValueChangeEvent;
import com.vaadin.data.Property.ValueChangeListener;
import com.vaadin.data.fieldgroup.FieldGroup;
private final FormLayout scheduleEventFieldLayout = new FormLayout();
private FieldGroup scheduleEventFieldGroup = new FieldGroup();
+ private Binder<CalendarEvent> scheduledEventBinder = new Binder<>();
private Button deleteEventButton;
private void initHideWeekEndButton() {
hideWeekendsButton = new CheckBox("Hide weekends");
hideWeekendsButton.setImmediate(true);
- hideWeekendsButton
- .addValueChangeListener(new Property.ValueChangeListener() {
-
- private static final long serialVersionUID = 1L;
-
- @Override
- public void valueChange(ValueChangeEvent event) {
- setWeekendsHidden(hideWeekendsButton.getValue());
- }
- });
+ hideWeekendsButton.addValueChangeListener(
+ event -> setWeekendsHidden(hideWeekendsButton.getValue()));
}
private void setWeekendsHidden(boolean weekendsHidden) {
private void initReadOnlyButton() {
readOnlyButton = new CheckBox("Read-only mode");
readOnlyButton.setImmediate(true);
- readOnlyButton
- .addValueChangeListener(new Property.ValueChangeListener() {
-
- private static final long serialVersionUID = 1L;
-
- @Override
- public void valueChange(ValueChangeEvent event) {
- calendarComponent.setReadOnly(readOnlyButton.getValue());
- }
- });
+ readOnlyButton.addValueChangeListener(event -> calendarComponent
+ .setReadOnly(readOnlyButton.getValue()));
}
private void initDisabledButton() {
disabledButton = new CheckBox("Disabled");
disabledButton.setImmediate(true);
- disabledButton
- .addValueChangeListener(new Property.ValueChangeListener() {
-
- private static final long serialVersionUID = 1L;
-
- @Override
- public void valueChange(ValueChangeEvent event) {
- calendarComponent.setEnabled(!disabledButton.getValue());
- }
- });
+ disabledButton.addValueChangeListener(event -> calendarComponent
+ .setEnabled(!disabledButton.getValue()));
}
public void initAddNewEventButton() {
endDateField = createDateField("End date");
final CheckBox allDayField = createCheckBox("All-day");
- allDayField.addValueChangeListener(new Property.ValueChangeListener() {
-
- private static final long serialVersionUID = -7104996493482558021L;
-
- @Override
- public void valueChange(ValueChangeEvent event) {
- Object value = event.getProperty().getValue();
- if (value instanceof Boolean && Boolean.TRUE.equals(value)) {
- setFormDateResolution(Resolution.DAY);
-
- } else {
- setFormDateResolution(Resolution.MINUTE);
- }
+ allDayField.addValueChangeListener(event -> {
+ if (event.getValue()) {
+ setFormDateResolution(Resolution.DAY);
+ } else {
+ setFormDateResolution(Resolution.MINUTE);
}
-
});
captionField = createTextField("Caption");
scheduleEventFieldGroup.bind(whereField, "where");
}
scheduleEventFieldGroup.bind(styleNameField, "styleName");
- scheduleEventFieldGroup.bind(allDayField, "allDay");
+ scheduledEventBinder.bind(allDayField, CalendarEvent::isAllDay, null);
}
private CheckBox createCheckBox(String caption) {
initFormFields(scheduleEventFieldLayout, event.getClass());
scheduleEventFieldGroup.setBuffered(true);
scheduleEventFieldGroup.setItemDataSource(item);
+ scheduledEventBinder.load(event);
}
private void setFormDateResolution(Resolution resolution) {
private void commitCalendarEvent() throws CommitException {
scheduleEventFieldGroup.commit();
BasicEvent event = getFormCalendarEvent();
+ scheduledEventBinder.save(event);
if (event.getEnd() == null) {
event.setEnd(event.getStart());
}
private void discardCalendarEvent() {
scheduleEventFieldGroup.discard();
+ scheduledEventBinder.load(getFormCalendarEvent());
getUI().removeWindow(scheduleEventPopup);
}
/*
* Copyright 2000-2014 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
addComponent(show);
final CheckBox hidden = new CheckBox("Hidden");
- hidden.addValueChangeListener(new ValueChangeListener() {
- @Override
- public void valueChange(ValueChangeEvent event) {
- win.setVisible(!hidden.getValue());
- }
- });
+ hidden.addValueChangeListener(
+ event -> win.setVisible(!hidden.getValue()));
addComponent(hidden);
win.addCloseListener(new CloseListener() {
package com.vaadin.tests.themes.valo;
import com.vaadin.data.Container;
-import com.vaadin.data.Property.ValueChangeEvent;
-import com.vaadin.data.Property.ValueChangeListener;
+import com.vaadin.data.HasValue;
import com.vaadin.event.dd.DragAndDropEvent;
import com.vaadin.event.dd.DropHandler;
import com.vaadin.event.dd.acceptcriteria.AcceptAll;
verticalLines, horizontalLines, borderless, headers, compact,
small, rowIndex, rowCaption, rowIcon, componentsInCells);
- ValueChangeListener update = new ValueChangeListener() {
- @Override
- public void valueChange(ValueChangeEvent event) {
- if (table == null) {
- table = new Table();
- table.setContainerDataSource(normalContainer);
- addComponent(table);
- }
- if (hierarchical.getValue() && table instanceof Table) {
- removeComponent(table);
- table = new TreeTable();
- table.setContainerDataSource(hierarchicalContainer);
- addComponent(table);
- } else if (!hierarchical.getValue()
- && table instanceof TreeTable) {
- removeComponent(table);
- table = new Table();
- table.setContainerDataSource(normalContainer);
- addComponent(table);
- }
-
- configure(table, footer.getValue(), sized.getValue(),
- expandRatios.getValue(), stripes.getValue(),
- verticalLines.getValue(), horizontalLines.getValue(),
- borderless.getValue(), headers.getValue(),
- compact.getValue(), small.getValue(),
- rowIndex.getValue(), rowCaption.getValue(),
- rowIcon.getValue(), componentsInCells.getValue());
+ HasValue.ValueChangeListener<Boolean> update = event -> {
+ if (table == null) {
+ table = new Table();
+ table.setContainerDataSource(normalContainer);
+ addComponent(table);
+ }
+ if (hierarchical.getValue() && table instanceof Table) {
+ removeComponent(table);
+ table = new TreeTable();
+ table.setContainerDataSource(hierarchicalContainer);
+ addComponent(table);
+ } else if (!hierarchical.getValue()
+ && table instanceof TreeTable) {
+ removeComponent(table);
+ table = new Table();
+ table.setContainerDataSource(normalContainer);
+ addComponent(table);
}
+
+ configure(table, footer.getValue(), sized.getValue(),
+ expandRatios.getValue(), stripes.getValue(),
+ verticalLines.getValue(), horizontalLines.getValue(),
+ borderless.getValue(), headers.getValue(),
+ compact.getValue(), small.getValue(),
+ rowIndex.getValue(), rowCaption.getValue(),
+ rowIcon.getValue(), componentsInCells.getValue());
};
hierarchical.addValueChangeListener(update);
/*
* Copyright 2000-2014 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
*/
package com.vaadin.tests.themes.valo;
-import com.vaadin.data.Property.ValueChangeEvent;
-import com.vaadin.data.Property.ValueChangeListener;
+import com.vaadin.data.HasValue;
import com.vaadin.navigator.View;
import com.vaadin.navigator.ViewChangeListener.ViewChangeEvent;
import com.vaadin.shared.ui.MarginInfo;
selectedOnly.setImmediate(true);
wrap.addComponent(selectedOnly);
- ValueChangeListener update = new ValueChangeListener() {
- @Override
- public void valueChange(ValueChangeEvent event) {
- String style = framed.getValue() ? "framed " : "";
- style += centered.getValue() ? " centered-tabs" : "";
- style += rightAlign.getValue() ? " right-aligned-tabs" : "";
- style += equal.getValue() ? " equal-width-tabs" : "";
- style += padded.getValue() ? " padded-tabbar" : "";
- style += compact.getValue() ? " compact-tabbar" : "";
- style += iconsOnTop.getValue() ? " icons-on-top" : "";
- style += selectedOnly.getValue() ? " only-selected-closable"
- : "";
-
- if (tabs != null) {
- removeComponent(tabs);
- }
- tabs = getTabSheet(caption.getValue(), style.trim(),
- closable.getValue(), overflow.getValue(),
- icon.getValue(), disable.getValue());
- addComponent(tabs);
+ HasValue.ValueChangeListener<Boolean> update = event -> {
+ String style = framed.getValue() ? "framed " : "";
+ style += centered.getValue() ? " centered-tabs" : "";
+ style += rightAlign.getValue() ? " right-aligned-tabs" : "";
+ style += equal.getValue() ? " equal-width-tabs" : "";
+ style += padded.getValue() ? " padded-tabbar" : "";
+ style += compact.getValue() ? " compact-tabbar" : "";
+ style += iconsOnTop.getValue() ? " icons-on-top" : "";
+ style += selectedOnly.getValue() ? " only-selected-closable"
+ : "";
+
+ if (tabs != null) {
+ removeComponent(tabs);
}
+ tabs = getTabSheet(caption.getValue(), style.trim(),
+ closable.getValue(), overflow.getValue(),
+ icon.getValue(), disable.getValue());
+ addComponent(tabs);
};
closable.addValueChangeListener(update);
overflow.addValueChangeListener(update);
import java.util.Iterator;
+import com.vaadin.data.HasValue;
import com.vaadin.data.Property;
import com.vaadin.data.Property.ValueChangeEvent;
import com.vaadin.data.util.MethodProperty;
final VerticalLayout orderedLayout = new VerticalLayout();
LayoutTestingPanel oltp = new LayoutTestingPanel("OrderedLayout",
orderedLayout);
- CheckBox cb = new CheckBox("OrderedLayout",
- new MethodProperty<Boolean>(oltp, "visible"));
+ CheckBox cb = new CheckBox("OrderedLayout");
+ cb.setValue(oltp.isVisible());
+ cb.addValueChangeListener(event -> oltp.setVisible(event.getValue()));
cb.setImmediate(true);
hidingControls.addComponent(cb);
lo.addComponent(oltp);
// GridLayout
GridLayout grid = new GridLayout(1, 1);
Panel g1tp = new LayoutTestingPanel("Gridlayout with 1 column", grid);
- cb = new CheckBox("GridLayout (1col)", new MethodProperty<Boolean>(
- g1tp, "visible"));
+ cb = new CheckBox("GridLayout (1col)");
cb.setImmediate(true);
hidingControls.addComponent(cb);
g1tp.setVisible(false);
+ cb.setValue(g1tp.isVisible());
+ cb.addValueChangeListener(event -> g1tp.setVisible(event.getValue()));
lo.addComponent(g1tp);
grid.setSpacing(true);
addFields(grid);
GridLayout grid2 = new GridLayout(2, 1);
Panel g2tp = new LayoutTestingPanel("Gridlayout with 2 columns", grid2);
- cb = new CheckBox("GridLayout (2cols)", new MethodProperty<Boolean>(
- g2tp, "visible"));
+ cb = new CheckBox("GridLayout (2cols)");
cb.setImmediate(true);
hidingControls.addComponent(cb);
g2tp.setVisible(false);
+ cb.setValue(g2tp.isVisible());
+ cb.addValueChangeListener(event -> g2tp.setVisible(event.getValue()));
lo.addComponent(g2tp);
grid2.setSpacing(true);
addFields(grid2);
VerticalLayout el = new VerticalLayout();
Panel elp = new LayoutTestingPanel(
"ExpandLayout width first component expanded", el);
- cb = new CheckBox("ExpandLayout (vertical)",
- new MethodProperty<Boolean>(elp, "visible"));
+ cb = new CheckBox("ExpandLayout (vertical)");
cb.setImmediate(true);
hidingControls.addComponent(cb);
elp.setVisible(false);
+ cb.setValue(elp.isVisible());
+ cb.addValueChangeListener(event -> elp.setVisible(event.getValue()));
el.setHeight("700px");
addFields(el);
Component firstComponent = el.getComponentIterator().next();
HorizontalLayout elh = new HorizontalLayout();
Panel elhp = new LayoutTestingPanel(
"ExpandLayout width first component expanded; horizontal", elh);
- cb = new CheckBox("ExpandLayout (horizontal)",
- new MethodProperty<Boolean>(elhp, "visible"));
+ cb = new CheckBox("ExpandLayout (horizontal)");
cb.setImmediate(true);
hidingControls.addComponent(cb);
elhp.setVisible(false);
+ cb.setValue(elhp.isVisible());
+ cb.addValueChangeListener(event -> elhp.setVisible(event.getValue()));
elh.setWidth("2000px");
elh.setHeight("100px");
addFields(elh);
// CustomLayout
VerticalLayout cl = new VerticalLayout();
Panel clp = new LayoutTestingPanel("CustomLayout", cl);
- cb = new CheckBox("CustomLayout", new MethodProperty<Boolean>(clp,
- "visible"));
+ cb = new CheckBox("CustomLayout");
cb.setImmediate(true);
hidingControls.addComponent(cb);
clp.setVisible(false);
+ cb.setValue(clp.isVisible());
+ cb.addValueChangeListener(event -> clp.setVisible(event.getValue()));
lo.addComponent(clp);
cl.addComponent(new Label("<<< Add customlayout testcase here >>>"));
VerticalLayout formPanelLayout = new VerticalLayout();
formPanelLayout.setMargin(true);
Panel formPanel = new Panel("Form", formPanelLayout);
- cb = new CheckBox("Form", new MethodProperty<Boolean>(formPanel,
- "visible"));
+ cb = new CheckBox("Form");
cb.setImmediate(true);
hidingControls.addComponent(cb);
formPanel.setVisible(false);
+ cb.setValue(formPanel.isVisible());
+ cb.addValueChangeListener(event -> formPanel.setVisible(event.getValue()));
formPanelLayout.addComponent(getFormPanelExample());
lo.addComponent(formPanel);
f.setCaption("Test form");
CheckBox fb2 = new CheckBox("Test button", true);
fb2.setComponentError(new SystemError("Test error"));
- f.addField("fb2", fb2);
+ f.getLayout().addComponent(fb2);
TextField ft1 = new TextField("With caption");
ft1.setComponentError(new SystemError("Error"));
f.addField("ft1", ft1);
controls.addComponent(new Label("width"));
controls.addComponent(new TextField(new MethodProperty<Float>(
testedLayout, "width")));
- CheckBox widthPercentsCheckBox = new CheckBox("%",
- new MethodProperty<Boolean>(this, "widthPercents"));
+ CheckBox widthPercentsCheckBox = new CheckBox("%");
widthPercentsCheckBox.setImmediate(true);
controls.addComponent(widthPercentsCheckBox);
controls.addComponent(new Label("height"));
controls.addComponent(new TextField(new MethodProperty<Float>(
testedLayout, "height")));
- CheckBox heightPercentsCheckBox = new CheckBox("%",
- new MethodProperty<Boolean>(this, "heightPercents"));
+ CheckBox heightPercentsCheckBox = new CheckBox("%");
heightPercentsCheckBox.setImmediate(true);
controls.addComponent(heightPercentsCheckBox);
controls.addComponent(marginLeft);
controls.addComponent(spacing);
}
- Property.ValueChangeListener marginSpacingListener = new Property.ValueChangeListener() {
- @Override
- public void valueChange(ValueChangeEvent event) {
- updateMarginsAndSpacing();
- }
- };
+ HasValue.ValueChangeListener<Boolean> marginSpacingListener = event -> updateMarginsAndSpacing();
- marginBottom.addListener(marginSpacingListener);
- marginTop.addListener(marginSpacingListener);
- marginLeft.addListener(marginSpacingListener);
- marginRight.addListener(marginSpacingListener);
- spacing.addListener(marginSpacingListener);
+ marginBottom.addValueChangeListener(marginSpacingListener);
+ marginTop.addValueChangeListener(marginSpacingListener);
+ marginLeft.addValueChangeListener(marginSpacingListener);
+ marginRight.addValueChangeListener(marginSpacingListener);
+ spacing.addValueChangeListener(marginSpacingListener);
updateMarginsAndSpacing();
addAlignmentControls();
package com.vaadin.tests.tickets;
-import com.vaadin.data.Property;
-import com.vaadin.data.Property.ValueChangeEvent;
import com.vaadin.event.Action;
import com.vaadin.event.Action.Handler;
import com.vaadin.server.LegacyApplication;
false);
footer.addComponent(actionHandlerEnabler);
actionHandlerEnabler.setImmediate(true);
- actionHandlerEnabler.addListener(new Property.ValueChangeListener() {
- @Override
- public void valueChange(ValueChangeEvent event) {
- if (actionHandlerEnabler.getValue().booleanValue()) {
- t.addActionHandler(Ticket1857.this);
- } else {
- t.removeActionHandler(Ticket1857.this);
- }
+ actionHandlerEnabler.addValueChangeListener(event -> {
+ if (actionHandlerEnabler.getValue().booleanValue()) {
+ t.addActionHandler(Ticket1857.this);
+ } else {
+ t.removeActionHandler(Ticket1857.this);
}
});
final CheckBox cellStylesEnabler = new CheckBox("Cell styles", false);
footer.addComponent(cellStylesEnabler);
cellStylesEnabler.setImmediate(true);
- cellStylesEnabler.addListener(new Property.ValueChangeListener() {
- @Override
- public void valueChange(ValueChangeEvent event) {
- if (cellStylesEnabler.getValue().booleanValue()) {
- t.setCellStyleGenerator(new Table.CellStyleGenerator() {
- @Override
- public String getStyle(Table source, Object itemId,
- Object propertyId) {
- Object cell = t.getContainerProperty(itemId,
- propertyId).getValue();
- if (!(cell instanceof Integer)) {
- return null;
- }
- int age = ((Integer) cell).intValue();
- return age > 65 ? "old" : (age < 18 ? "young"
- : null);
+ cellStylesEnabler.addValueChangeListener(event -> {
+ if (cellStylesEnabler.getValue().booleanValue()) {
+ t.setCellStyleGenerator(new Table.CellStyleGenerator() {
+ @Override
+ public String getStyle(Table source, Object itemId,
+ Object propertyId) {
+ Object cell = t.getContainerProperty(itemId,
+ propertyId).getValue();
+ if (!(cell instanceof Integer)) {
+ return null;
}
- });
- } else {
- t.setCellStyleGenerator(null);
- }
+ int age = ((Integer) cell).intValue();
+ return age > 65 ? "old" : (age < 18 ? "young"
+ : null);
+ }
+ });
+ } else {
+ t.setCellStyleGenerator(null);
}
});
cellStylesEnabler.setValue(Boolean.TRUE);
package com.vaadin.tests.tickets;
-import com.vaadin.data.Property.ValueChangeEvent;
-import com.vaadin.data.Property.ValueChangeListener;
import com.vaadin.data.util.IndexedContainer;
import com.vaadin.server.LegacyApplication;
import com.vaadin.server.Sizeable;
leftSide.setFirstComponent(ol);
CheckBox checkBox = new CheckBox("Two col");
- checkBox.addListener(new ValueChangeListener() {
-
- @Override
- public void valueChange(ValueChangeEvent event) {
- if ((Boolean) event.getProperty().getValue()) {
- table.setVisibleColumns(new Object[] { propId, propId2 });
- } else {
- table.setVisibleColumns(new Object[] { propId });
- }
-
+ checkBox.addValueChangeListener(event -> {
+ if (event.getValue()) {
+ table.setVisibleColumns(new Object[] { propId, propId2 });
+ } else {
+ table.setVisibleColumns(new Object[] { propId });
}
-
});
ol.addComponent(checkBox);
import com.vaadin.legacy.data.validator.LegacyCompositeValidator.CombinationMode;
import com.vaadin.legacy.data.validator.LegacyIntegerValidator;
import com.vaadin.server.LegacyApplication;
+import com.vaadin.tests.util.CheckBoxWithPropertyDataSource;
import com.vaadin.ui.Button;
import com.vaadin.ui.CheckBox;
import com.vaadin.ui.LegacyWindow;
"readOnly", "readThrough", "invalidCommitted",
"validationVisible" };
for (int i = 0; i < visibleProps.length; i++) {
- CheckBox b = new CheckBox(visibleProps[i],
+ CheckBox b = new CheckBoxWithPropertyDataSource(visibleProps[i],
new MethodProperty<Boolean>(tx, visibleProps[i]));
b.setImmediate(true);
mainWin.addComponent(b);
package com.vaadin.tests.tickets;
-import com.vaadin.data.Property;
-import com.vaadin.data.Property.ValueChangeEvent;
import com.vaadin.server.LegacyApplication;
import com.vaadin.ui.CheckBox;
import com.vaadin.ui.Label;
w.addComponent(l);
final CheckBox b = new CheckBox("fixed width: 30px", false);
- b.addListener(new Property.ValueChangeListener() {
- @Override
- public void valueChange(ValueChangeEvent event) {
- if (b.getValue()) {
- l.setWidth("30px");
- } else {
- l.setWidth(null);
- }
+ b.addValueChangeListener(event -> {
+ if (b.getValue()) {
+ l.setWidth("30px");
+ } else {
+ l.setWidth(null);
}
});
b.setImmediate(true);
false);
w.addComponent(b);
b.setImmediate(true);
- b.addListener(new Property.ValueChangeListener() {
- @Override
- public void valueChange(ValueChangeEvent event) {
- tf.setRequiredError(b.getValue() ? "Field must not be empty"
- : null);
- }
- });
+ b.addValueChangeListener(event -> tf.setRequiredError(
+ b.getValue() ? "Field must not be empty" : null));
}
}
package com.vaadin.tests.tickets;
-import com.vaadin.data.Property.ValueChangeEvent;
-import com.vaadin.data.Property.ValueChangeListener;
-import com.vaadin.data.util.MethodProperty;
import com.vaadin.event.ItemClickEvent;
import com.vaadin.event.ItemClickEvent.ItemClickListener;
import com.vaadin.server.ExternalResource;
HorizontalLayout ol = new HorizontalLayout();
main.addComponent(ol);
- CheckBox cb = new CheckBox("immediate", new MethodProperty<Boolean>(
- tree, "immediate"));
+ CheckBox cb = new CheckBox("immediate");
+ cb.setValue(tree.isImmediate());
+ cb.addValueChangeListener(event -> tree.setImmediate(event.getValue()));
cb.setImmediate(true);
ol.addComponent(cb);
- cb = new CheckBox("selectable", new MethodProperty<Boolean>(tree,
- "selectable"));
+ cb = new CheckBox("selectable");
+ cb.setValue(tree.isSelectable());
+ cb.addValueChangeListener(
+ event -> tree.setSelectable(event.getValue()));
cb.setImmediate(true);
ol.addComponent(cb);
- cb = new CheckBox("nullsel", new MethodProperty<Boolean>(tree,
- "nullSelectionAllowed"));
+ cb = new CheckBox("nullsel");
+ cb.setValue(tree.isNullSelectionAllowed());
+ cb.addValueChangeListener(
+ event -> tree.setNullSelectionAllowed(event.getValue()));
cb.setImmediate(true);
ol.addComponent(cb);
- cb = new CheckBox("multi", new MethodProperty<Boolean>(tree,
- "multiSelect"));
+ cb = new CheckBox("multi");
+ cb.setValue(tree.isMultiSelect());
+ cb.addValueChangeListener(
+ event -> tree.setMultiSelect(event.getValue()));
cb.setImmediate(true);
ol.addComponent(cb);
cb = new CheckBox("icon");
- cb.addListener(new ValueChangeListener() {
-
- @Override
- public void valueChange(ValueChangeEvent event) {
- if (tree.getItemIconPropertyId() == null) {
- tree.setItemIconPropertyId("icon");
- } else {
- tree.setItemIconPropertyId(null);
- }
-
+ cb.addValueChangeListener(event -> {
+ if (tree.getItemIconPropertyId() == null) {
+ tree.setItemIconPropertyId("icon");
+ } else {
+ tree.setItemIconPropertyId(null);
}
});
cb.setImmediate(true);
ol = new HorizontalLayout();
main.addComponent(ol);
- cb = new CheckBox("immediate", new MethodProperty<Boolean>(table,
- "immediate"));
+ cb = new CheckBox("immediate");
+ cb.setValue(table.isImmediate());
+ cb.addValueChangeListener(event -> table.setImmediate(event.getValue()));
cb.setImmediate(true);
ol.addComponent(cb);
- cb = new CheckBox("selectable", new MethodProperty<Boolean>(table,
- "selectable"));
+ cb = new CheckBox("selectable");
+ cb.setValue(table.isSelectable());
+ cb.addValueChangeListener(
+ event -> table.setSelectable(event.getValue()));
cb.setImmediate(true);
ol.addComponent(cb);
- cb = new CheckBox("nullsel", new MethodProperty<Boolean>(table,
- "nullSelectionAllowed"));
+ cb = new CheckBox("nullsel");
+ cb.setValue(table.isNullSelectionAllowed());
+ cb.addValueChangeListener(
+ event -> table.setNullSelectionAllowed(event.getValue()));
cb.setImmediate(true);
ol.addComponent(cb);
- cb = new CheckBox("multi", new MethodProperty<Boolean>(table,
- "multiSelect"));
+ cb = new CheckBox("multi");
+ cb.setValue(table.isMultiSelect());
+ cb.addValueChangeListener(
+ event -> table.setMultiSelect(event.getValue()));
cb.setImmediate(true);
ol.addComponent(cb);
main.addComponent(table);
false);
w.addComponent(b);
b.setImmediate(true);
- b.addListener(new Property.ValueChangeListener() {
- @Override
- public void valueChange(ValueChangeEvent event) {
- tf.setRequiredError(b.getValue() ? "Field must not be empty"
- : null);
- }
- });
+ b.addValueChangeListener(event -> tf.setRequiredError(
+ b.getValue() ? "Field must not be empty" : null));
}
}
package com.vaadin.tests.tickets;
-import com.vaadin.data.util.MethodProperty;
import com.vaadin.server.LegacyApplication;
import com.vaadin.ui.CheckBox;
import com.vaadin.ui.Component;
}
});
- CheckBox b = new CheckBox("editmode", new MethodProperty<Boolean>(
- table, "editable"));
+ CheckBox b = new CheckBox("editmode");
+ b.setValue(table.isEditable());
+ b.addValueChangeListener(event -> table.setEditable(event.getValue()));
b.setImmediate(true);
addComponent(b);
}
package com.vaadin.tests.tickets;
-import com.vaadin.data.util.ObjectProperty;
-import com.vaadin.legacy.ui.LegacyAbstractField;
import com.vaadin.server.LegacyApplication;
import com.vaadin.ui.AbstractComponent;
import com.vaadin.ui.AbstractOrderedLayout;
checkButton(Button.class);
checkCheckBox(CheckBox.class);
- checkDataBinding(CheckBox.class);
}
}
- private void checkDataBinding(Class<? extends LegacyAbstractField> class1) {
- boolean ok = false;
- LegacyAbstractField b;
- try {
- b = class1.newInstance();
- b.setCaption("Button of type " + class1.getSimpleName());
- try {
- b.setBuffered(false);
- ObjectProperty<String> prop = new ObjectProperty<String>(
- "ABC 123");
- /*
- * This should throw an exception or somehow tell that the
- * property was invalid (wrong type). See #2223.
- */
- b.setPropertyDataSource(prop);
- } catch (Exception e) {
- e.printStackTrace();
- }
- } catch (Exception e1) {
- e1.printStackTrace();
- return;
- }
-
- if (ok) {
- status.setValue(status.getValue() + " "
- + class1.getClass().getSimpleName() + "/DB: OK");
- } else {
- status.setValue(status.getValue() + " "
- + class1.getClass().getSimpleName() + "/DB: FAILED");
- }
-
- }
}
import com.vaadin.legacy.data.validator.LegacyIntegerValidator;
import com.vaadin.server.LegacyApplication;
import com.vaadin.server.ThemeResource;
+import com.vaadin.tests.util.CheckBoxWithPropertyDataSource;
import com.vaadin.ui.AbstractComponent;
import com.vaadin.ui.Alignment;
import com.vaadin.ui.Button;
"readOnly", "readThrough", "writeThrough", "invalidCommitted",
"validationVisible", "immediate" };
for (int i = 0; i < visibleProps.length; i++) {
- CheckBox b = new CheckBox(visibleProps[i],
+ CheckBox b = new CheckBoxWithPropertyDataSource(visibleProps[i],
new MethodProperty<Boolean>(f, visibleProps[i]));
b.setImmediate(true);
formPropertiesLayout.addComponent(b);
import com.vaadin.data.util.MethodProperty;
import com.vaadin.legacy.data.validator.LegacyIntegerValidator;
import com.vaadin.server.LegacyApplication;
+import com.vaadin.tests.util.CheckBoxWithPropertyDataSource;
import com.vaadin.ui.Button;
import com.vaadin.ui.CheckBox;
import com.vaadin.ui.LegacyWindow;
"readOnly", "readThrough", "invalidCommitted",
"validationVisible" };
for (int i = 0; i < visibleProps.length; i++) {
- CheckBox b = new CheckBox(visibleProps[i],
+ CheckBox b = new CheckBoxWithPropertyDataSource(visibleProps[i],
new MethodProperty<Boolean>(tx, visibleProps[i]));
b.setImmediate(true);
mainWin.addComponent(b);
--- /dev/null
+package com.vaadin.tests.util;
+
+import com.vaadin.data.Property;
+import com.vaadin.data.Property.ValueChangeNotifier;
+import com.vaadin.legacy.data.Validator.InvalidValueException;
+import com.vaadin.ui.CheckBox;
+
+public class CheckBoxWithPropertyDataSource extends CheckBox {
+
+ public CheckBoxWithPropertyDataSource(String caption) {
+ super(caption);
+ }
+
+ public CheckBoxWithPropertyDataSource(String caption,
+ Property<Boolean> property) {
+ super(caption);
+
+ setValue(property.getValue());
+ addValueChangeListener(event -> property.setValue(event.getValue()));
+
+ if (property instanceof ValueChangeNotifier) {
+ ((ValueChangeNotifier) property)
+ .addValueChangeListener(event -> setValue(
+ (Boolean) event.getProperty().getValue()));
+ }
+ }
+
+ public void validate() {
+ if (isRequired() && !getValue()) {
+ throw new InvalidValueException("Required CheckBox should be checked");
+ }
+ }
+
+}
protected void setup(VaadinRequest request) {
requiredInput = new CheckBox("Field required");
requiredInput.setImmediate(true);
- requiredInput.addValueChangeListener(new ValueChangeListener() {
- @Override
- public void valueChange(ValueChangeEvent event) {
- tf.setRequired(requiredInput.getValue());
- }
- });
+ requiredInput.addValueChangeListener(
+ event -> tf.setRequired(requiredInput.getValue()));
requiredErrorInput = new TextField("Required error message");
requiredErrorInput.setImmediate(true);
integerValidatorInput = new CheckBox("Integer validator");
integerValidatorInput.setImmediate(true);
- integerValidatorInput.addValueChangeListener(new ValueChangeListener() {
-
- @Override
- public void valueChange(ValueChangeEvent event) {
- if (integerValidatorInput.getValue()) {
- tf.addValidator(integerValidator);
- } else {
- tf.removeValidator(integerValidator);
- }
+ integerValidatorInput.addValueChangeListener(event -> {
+ if (integerValidatorInput.getValue()) {
+ tf.addValidator(integerValidator);
+ } else {
+ tf.removeValidator(integerValidator);
}
});
stringLengthValidatorInput = new CheckBox("String length validator");
stringLengthValidatorInput.setImmediate(true);
- stringLengthValidatorInput
- .addValueChangeListener(new ValueChangeListener() {
-
- @Override
- public void valueChange(ValueChangeEvent event) {
- if (stringLengthValidatorInput.getValue()) {
- tf.addValidator(stringLengthValidator);
- } else {
- tf.removeValidator(stringLengthValidator);
- }
- }
- });
+ stringLengthValidatorInput.addValueChangeListener(event -> {
+ if (stringLengthValidatorInput.getValue()) {
+ tf.addValidator(stringLengthValidator);
+ } else {
+ tf.removeValidator(stringLengthValidator);
+ }
+ });
tf = new TextField();
tf.setImmediate(true);
+++ /dev/null
-package com.vaadin.tests.components.checkbox;
-
-import java.util.List;
-
-import org.junit.Assert;
-import org.junit.Test;
-import org.openqa.selenium.WebElement;
-
-import com.vaadin.testbench.By;
-import com.vaadin.testbench.elements.ButtonElement;
-import com.vaadin.testbench.elements.CheckBoxElement;
-import com.vaadin.tests.tb3.MultiBrowserTest;
-
-public class CheckBoxNullValueTest extends MultiBrowserTest {
- @Test
- public void testValidation() throws Exception {
- openTestURL();
- CheckBoxElement checkbox = $(CheckBoxElement.class).first();
- CheckBoxElement requiredCheckbox = $(CheckBoxElement.class).caption(
- "A required checkbox").first();
-
- assertValid(checkbox, true);
- assertValid(requiredCheckbox, true);
- ButtonElement validate = $(ButtonElement.class).caption("Validate")
- .first();
- validate.click();
-
- assertValid(checkbox, true);
- assertValid(requiredCheckbox, false);
-
- click(checkbox);
- click(requiredCheckbox);
- validate.click();
-
- assertValid(checkbox, true);
- assertValid(requiredCheckbox, true);
-
- click(checkbox);
- click(requiredCheckbox);
- validate.click();
- assertValid(checkbox, true);
- assertValid(requiredCheckbox, false);
-
- }
-
- private void assertValid(CheckBoxElement checkbox, boolean valid) {
- boolean hasIndicator = false;
- List<WebElement> e = checkbox.findElements(By
- .className("v-errorindicator"));
- if (e.size() != 0) {
- hasIndicator = e.get(0).isDisplayed();
- }
-
- Assert.assertEquals("Checkbox state should be "
- + (valid ? "valid" : "invalid"), valid, !hasIndicator);
-
- }
-
-}
/*
* Copyright 2000-2014 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
import com.vaadin.testbench.elements.CheckBoxElement;
import com.vaadin.testbench.elements.GridElement;
import com.vaadin.testbench.parallel.TestCategory;
+import com.vaadin.tests.legacyelements.LegacyCheckBoxElement;
import com.vaadin.tests.tb3.SingleBrowserTest;
@TestCategory("grid")
// First edit false item and see that the CheckBox is unchecked
grid.getCell(1, 0).doubleClick();
- CheckBoxElement checkbox = $(CheckBoxElement.class).first();
+ CheckBoxElement checkbox = $(LegacyCheckBoxElement.class).first();
Assert.assertEquals("CheckBox was checked", "unchecked",
checkbox.getValue());
// Edit true item and see that the CheckBox is checked
grid.getCell(0, 0).doubleClick();
- checkbox = $(CheckBoxElement.class).first();
+ checkbox = $(LegacyCheckBoxElement.class).first();
Assert.assertEquals("CheckBox was not checked.", "checked",
checkbox.getValue());
// Edit false item and confirm that the CheckBox is unchecked again
grid.getCell(1, 0).doubleClick();
- checkbox = $(CheckBoxElement.class).first();
+ checkbox = $(LegacyCheckBoxElement.class).first();
Assert.assertEquals("CheckBox was checked", "unchecked",
checkbox.getValue());
}
--- /dev/null
+package com.vaadin.tests.legacyelements;
+
+import com.vaadin.testbench.elements.CheckBoxElement;
+import com.vaadin.testbench.elementsbase.ServerClass;
+
+@ServerClass("com.vaadin.legacy.ui.LegacyCheckBox")
+public class LegacyCheckBoxElement extends CheckBoxElement {
+
+}
projects / vaadin-framework.git / commitdiff