// The show must go on
onLoad(event);
}
-
};
/**
import com.vaadin.client.communication.ServerRpcQueue;
import com.vaadin.client.communication.StateChangeEvent;
import com.vaadin.client.communication.StateChangeEvent.StateChangeHandler;
-import com.vaadin.client.ui.layout.ElementResizeEvent;
import com.vaadin.client.ui.layout.ElementResizeListener;
import com.vaadin.shared.JavaScriptConnectorState;
import com.vaadin.shared.communication.MethodInvocation;
if (listener == null) {
LayoutManager layoutManager = LayoutManager
.get(connector.getConnection());
- listener = new ElementResizeListener() {
- @Override
- public void onElementResize(ElementResizeEvent e) {
- invokeElementResizeCallback(e.getElement(),
- callbackFunction);
- }
- };
+ listener = event -> invokeElementResizeCallback(event.getElement(),
+ callbackFunction);
layoutManager.addElementResizeListener(element, listener);
elementListeners.put(callbackFunction, listener);
}
import com.google.gwt.user.client.Window.Location;
import com.google.gwt.user.client.rpc.AsyncCallback;
import com.vaadin.client.ui.VNotification;
-import com.vaadin.client.ui.VNotification.EventListener;
-import com.vaadin.client.ui.VNotification.HideEvent;
/**
* Class that enables SuperDevMode using a ?superdevmode parameter in the url.
private void failed() {
VNotification n = new VNotification();
- n.addEventListener(new EventListener() {
-
- @Override
- public void notificationHidden(HideEvent event) {
- recompileWidgetsetAndStartInDevMode(serverUrl);
- }
- });
+ n.addEventListener(
+ event -> recompileWidgetsetAndStartInDevMode(
+ serverUrl));
n.show("Recompilation failed.<br/>"
+ "Make sure CodeServer is running, "
+ "check its output and click to retry",
import com.vaadin.client.WidgetUtil;
import com.vaadin.client.data.DataChangeHandler;
import com.vaadin.client.extensions.AbstractExtensionConnector;
-import com.vaadin.client.ui.layout.ElementResizeEvent;
import com.vaadin.client.ui.layout.ElementResizeListener;
import com.vaadin.client.widget.grid.HeightAwareDetailsGenerator;
import com.vaadin.client.widgets.Grid;
private Registration dataChangeRegistration;
private final Map<Element, ScheduledCommand> elementToResizeCommand = new HashMap<Element, Scheduler.ScheduledCommand>();
- private final ElementResizeListener detailsRowResizeListener = new ElementResizeListener() {
-
- @Override
- public void onElementResize(ElementResizeEvent e) {
- if (elementToResizeCommand.containsKey(e.getElement())) {
- Scheduler.get().scheduleFinally(
- elementToResizeCommand.get(e.getElement()));
- }
+ private final ElementResizeListener detailsRowResizeListener = event -> {
+ if (elementToResizeCommand.containsKey(event.getElement())) {
+ Scheduler.get().scheduleFinally(
+ elementToResizeCommand.get(event.getElement()));
}
};
}
});
- hierarchyPanel.addListener(new SelectConnectorListener() {
- @Override
- public void select(ServerConnector connector, Element element) {
- printState(connector, true);
- }
- });
+ hierarchyPanel.addListener(
+ (connector, element) -> printState(connector, true));
- analyzeLayoutsPanel.addListener(new SelectConnectorListener() {
- @Override
- public void select(ServerConnector connector, Element element) {
- printState(connector, true);
- }
- });
+ analyzeLayoutsPanel.addListener(
+ (connector, element) -> printState(connector, true));
content.setStylePrimaryName(VDebugWindow.STYLENAME + "-hierarchy");
package com.vaadin.client.ui;
-import com.google.gwt.event.dom.client.DomEvent;
-import com.vaadin.client.ui.VAbstractCalendarPanel.FocusOutListener;
import com.vaadin.client.ui.VAbstractCalendarPanel.SubmitListener;
/**
}
});
- calendarPanel.setFocusOutListener(new FocusOutListener() {
- @Override
- public boolean onFocusOut(DomEvent<?> event) {
- updateValueFromPanel();
- return false;
- }
+ calendarPanel.setFocusOutListener(event -> {
+ updateValueFromPanel();
+ return false;
});
}
import com.google.gwt.dom.client.Element;
import com.google.gwt.event.dom.client.ClickEvent;
import com.google.gwt.event.dom.client.ClickHandler;
-import com.google.gwt.event.dom.client.DomEvent;
import com.google.gwt.event.dom.client.KeyCodes;
import com.google.gwt.event.dom.client.MouseOutEvent;
import com.google.gwt.event.dom.client.MouseOutHandler;
import com.vaadin.client.BrowserInfo;
import com.vaadin.client.ComputedStyle;
import com.vaadin.client.VConsole;
-import com.vaadin.client.ui.VAbstractCalendarPanel.FocusOutListener;
import com.vaadin.client.ui.VAbstractCalendarPanel.SubmitListener;
import com.vaadin.client.ui.aria.AriaHelper;
import com.vaadin.shared.ui.datefield.TextualDateFieldState;
calendar = calendarPanel;
calendar.setParentField(this);
- calendar.setFocusOutListener(new FocusOutListener() {
- @Override
- public boolean onFocusOut(DomEvent<?> event) {
- event.preventDefault();
- closeCalendarPanel();
- return true;
- }
+ calendar.setFocusOutListener(event -> {
+ event.preventDefault();
+ closeCalendarPanel();
+ return true;
});
// FIXME: Problem is, that the element with the provided id does not
public void sendBufferedValues() {
rpc.update(bufferedDateString,
bufferedResolutions.entrySet().stream().collect(Collectors
- .toMap(e -> e.getKey().name(), e -> e.getValue())));
+ .toMap(e -> e.getKey().name(),
+ e -> e.getValue())));
bufferedDateString = null;
bufferedResolutions.clear();
}
import com.google.gwt.aria.client.Roles;
import com.google.gwt.core.client.GWT;
import com.google.gwt.dom.client.Element;
-import com.google.gwt.dom.client.NativeEvent;
import com.google.gwt.event.dom.client.KeyCodes;
import com.google.gwt.user.client.DOM;
import com.google.gwt.user.client.Event;
import com.google.gwt.user.client.ui.Label;
import com.google.gwt.user.client.ui.Widget;
import com.vaadin.client.AnimationUtil;
-import com.vaadin.client.AnimationUtil.AnimationEndListener;
import com.vaadin.client.ApplicationConnection;
import com.vaadin.client.BrowserInfo;
import com.vaadin.client.WidgetUtil;
if (getStyleName()
.contains(VOverlay.ADDITIONAL_CLASSNAME_ANIMATE_IN)) {
AnimationUtil.addAnimationEndListener(getElement(),
- new AnimationEndListener() {
- @Override
- public void onAnimationEnd(NativeEvent event) {
- if (AnimationUtil.getAnimationName(event)
- .contains(
- VOverlay.ADDITIONAL_CLASSNAME_ANIMATE_IN)) {
- VNotification.this.hide();
- }
+ event -> {
+ if (AnimationUtil.getAnimationName(event).contains(
+ VOverlay.ADDITIONAL_CLASSNAME_ANIMATE_IN)) {
+ VNotification.this.hide();
}
});
} else {
import com.vaadin.client.UIDL;
import com.vaadin.client.communication.StateChangeEvent;
import com.vaadin.client.ui.VAbstractCalendarPanel;
-import com.vaadin.client.ui.VAbstractCalendarPanel.FocusChangeListener;
import com.vaadin.client.ui.VAbstractDateFieldCalendar;
import com.vaadin.shared.ui.datefield.InlineDateFieldState;
protected void updateListeners() {
if (isResolutionMonthOrHigher()) {
getWidget().calendarPanel
- .setFocusChangeListener(new FocusChangeListener() {
- @Override
- public void focusChanged(Date date) {
- Date date2 = new Date();
- if (getWidget().calendarPanel.getDate() != null) {
- date2.setTime(getWidget().calendarPanel
- .getDate().getTime());
- }
- /*
- * Update the value of calendarPanel
- */
- date2.setYear(date.getYear());
- date2.setMonth(date.getMonth());
- getWidget().calendarPanel.setDate(date2);
- /*
- * Then update the value from panel to server
- */
- getWidget().updateValueFromPanel();
+ .setFocusChangeListener(date -> {
+ Date date2 = new Date();
+ if (getWidget().calendarPanel.getDate() != null) {
+ date2.setTime(getWidget().calendarPanel.getDate()
+ .getTime());
}
+ /*
+ * Update the value of calendarPanel
+ */
+ date2.setYear(date.getYear());
+ date2.setMonth(date.getMonth());
+ getWidget().calendarPanel.setDate(date2);
+ /*
+ * Then update the value from panel to server
+ */
+ getWidget().updateValueFromPanel();
});
} else {
getWidget().calendarPanel.setFocusChangeListener(null);
import com.vaadin.client.DateTimeService;
import com.vaadin.client.ui.VDateTimeCalendarPanel;
-import com.vaadin.client.ui.VDateTimeCalendarPanel.TimeChangeListener;
import com.vaadin.client.ui.VPopupTimeCalendar;
import com.vaadin.shared.ui.Connect;
import com.vaadin.shared.ui.datefield.DateTimeResolution;
if (getWidget().getCurrentResolution()
.compareTo(DateTimeResolution.DAY) < 0) {
getWidget().calendar
- .setTimeChangeListener(new TimeChangeListener() {
- @Override
- public void changed(int hour, int min, int sec,
- int msec) {
- Date d = getWidget().getDate();
- if (d == null) {
- // date currently null, use the value from
- // calendarPanel
- // (~ client time at the init of the widget)
- d = (Date) getWidget().calendar.getDate()
- .clone();
- }
- d.setHours(hour);
- d.setMinutes(min);
- d.setSeconds(sec);
- DateTimeService.setMilliseconds(d, msec);
+ .setTimeChangeListener((hour, min, sec, msec) -> {
+ Date d = getWidget().getDate();
+ if (d == null) {
+ // date currently null, use the value from
+ // calendarPanel
+ // (~ client time at the init of the widget)
+ d = (Date) getWidget().calendar.getDate().clone();
+ }
+ d.setHours(hour);
+ d.setMinutes(min);
+ d.setSeconds(sec);
+ DateTimeService.setMilliseconds(d, msec);
- // Always update time changes to the server
- getWidget().updateValue(d);
+ // Always update time changes to the server
+ getWidget().updateValue(d);
- // Update text field
- getWidget().buildDate();
- }
+ // Update text field
+ getWidget().buildDate();
});
}
}
import com.vaadin.client.DateTimeService;
import com.vaadin.client.ui.VDateTimeCalendarPanel;
-import com.vaadin.client.ui.VDateTimeCalendarPanel.TimeChangeListener;
import com.vaadin.client.ui.VDateTimeFieldCalendar;
import com.vaadin.shared.ui.Connect;
import com.vaadin.shared.ui.datefield.DateTimeResolution;
if (getWidget().getCurrentResolution()
.compareTo(DateTimeResolution.DAY) < 0) {
getWidget().calendarPanel
- .setTimeChangeListener(new TimeChangeListener() {
- @Override
- public void changed(int hour, int min, int sec,
- int msec) {
- Date d = getWidget().getDate();
- if (d == null) {
- // date currently null, use the value from
- // calendarPanel
- // (~ client time at the init of the widget)
- d = (Date) getWidget().calendarPanel.getDate()
- .clone();
- }
- d.setHours(hour);
- d.setMinutes(min);
- d.setSeconds(sec);
- DateTimeService.setMilliseconds(d, msec);
-
- // Always update time changes to the server
- getWidget().calendarPanel.setDate(d);
- getWidget().updateValueFromPanel();
+ .setTimeChangeListener((hour, min, sec, msec) -> {
+ Date d = getWidget().getDate();
+ if (d == null) {
+ // date currently null, use the value from
+ // calendarPanel
+ // (~ client time at the init of the widget)
+ d = (Date) getWidget().calendarPanel.getDate()
+ .clone();
}
+ d.setHours(hour);
+ d.setMinutes(min);
+ d.setSeconds(sec);
+ DateTimeService.setMilliseconds(d, msec);
+
+ // Always update time changes to the server
+ getWidget().calendarPanel.setDate(d);
+ getWidget().updateValueFromPanel();
});
}
}
protected void updateListeners() {
FocusChangeListener listener;
if (isResolutionMonthOrHigher()) {
- listener = new FocusChangeListener() {
- @Override
- public void focusChanged(Date date) {
- if (isResolutionMonthOrHigher()) {
- getWidget().updateValue(date);
- getWidget().buildDate();
- Date date2 = getWidget().calendar.getDate();
- date2.setYear(date.getYear());
- date2.setMonth(date.getMonth());
- }
+ listener = date -> {
+ if (isResolutionMonthOrHigher()) {
+ getWidget().updateValue(date);
+ getWidget().buildDate();
+ Date date2 = getWidget().calendar.getDate();
+ date2.setYear(date.getYear());
+ date2.setMonth(date.getMonth());
}
};
} else {
import com.google.gwt.dom.client.Element;
import com.google.gwt.user.client.DOM;
import com.google.gwt.user.client.Event;
-import com.google.gwt.user.client.EventListener;
import com.vaadin.client.WidgetUtil;
import com.vaadin.client.ui.dd.DragAndDropHandler.DragAndDropCallback;
dndHandler = new DragAndDropHandler();
DOM.sinkEvents(element, Event.ONMOUSEDOWN | Event.ONTOUCHSTART);
- DOM.setEventListener(element, new EventListener() {
- @Override
- public void onBrowserEvent(Event event) {
- dndHandler.onDragStartOnDraggableElement(event, dndCallback);
- event.stopPropagation();
- }
+ DOM.setEventListener(element, event -> {
+ dndHandler.onDragStartOnDraggableElement(event, dndCallback);
+ event.stopPropagation();
});
}
import com.vaadin.client.communication.StateChangeEvent;
import com.vaadin.client.ui.AbstractComponentConnector;
import com.vaadin.client.ui.VFlash;
-import com.vaadin.client.ui.layout.ElementResizeEvent;
import com.vaadin.client.ui.layout.ElementResizeListener;
import com.vaadin.shared.ui.AbstractEmbeddedState;
import com.vaadin.shared.ui.Connect;
getWidget().rebuildIfNeeded();
}
- private final ElementResizeListener listener = new ElementResizeListener() {
- public void onElementResize(ElementResizeEvent e) {
- Element slot = e.getElement().getParentElement();
- getWidget().setSlotHeightAndWidth(slot.getOffsetHeight(),
- slot.getOffsetWidth());
- }
+ private final ElementResizeListener listener = event -> {
+ Element slot = event.getElement().getParentElement();
+ getWidget().setSlotHeightAndWidth(slot.getOffsetHeight(),
+ slot.getOffsetWidth());
};
@Override
import com.vaadin.client.ui.VFormLayout.Caption;
import com.vaadin.client.ui.VFormLayout.ErrorFlag;
import com.vaadin.client.ui.VFormLayout.VFormLayoutTable;
-import com.vaadin.client.ui.layout.ElementResizeEvent;
import com.vaadin.client.ui.layout.ElementResizeListener;
import com.vaadin.shared.ui.Connect;
import com.vaadin.shared.ui.LayoutClickRpc;
private Map<ComponentConnector, String> oldMaxWidths = null;
- private static final ElementResizeListener DUMMY_FIRST_CELL_RESIZE_LISTENER = new ElementResizeListener() {
- @Override
- public void onElementResize(ElementResizeEvent e) {
- // Ignore event, listener added just to make measurements available
- }
+ private static final ElementResizeListener DUMMY_FIRST_CELL_RESIZE_LISTENER = event -> {
+ // Ignore event, listener added just to make measurements available
};
// Detects situations when there's something inside the FormLayout that
// prevents it from shrinking
- private ElementResizeListener resizeListener = new ElementResizeListener() {
- @Override
- public void onElementResize(ElementResizeEvent e) {
- LayoutManager layoutManager = getLayoutManager();
- double tableWidth = layoutManager
- .getOuterWidthDouble(getWidget().table.getElement());
- double ownWidth = layoutManager
- .getInnerWidthDouble(getWidget().getElement());
- if (ownWidth < tableWidth) {
- // Something inside the table prevents it from shrinking,
- // temporarily force column widths
- double excessWidth = tableWidth - ownWidth;
-
- // All td elements in the component column have the same width,
- // so we only need to check the width of the first one to know
- // how wide the column is.
- Element firstComponentTd = findFirstComponentTd();
- if (firstComponentTd == null) {
- // Can't do anything if there are no rows
- return;
- }
+ private ElementResizeListener resizeListener = event -> {
+ LayoutManager layoutManager = getLayoutManager();
+ double tableWidth = layoutManager
+ .getOuterWidthDouble(getWidget().table.getElement());
+ double ownWidth = layoutManager
+ .getInnerWidthDouble(getWidget().getElement());
+ if (ownWidth < tableWidth) {
+ // Something inside the table prevents it from shrinking,
+ // temporarily force column widths
+ double excessWidth = tableWidth - ownWidth;
+
+ // All td elements in the component column have the same width,
+ // so we only need to check the width of the first one to know
+ // how wide the column is.
+ Element firstComponentTd = findFirstComponentTd();
+ if (firstComponentTd == null) {
+ // Can't do anything if there are no rows
+ return;
+ }
- double componentColWidth = layoutManager
- .getOuterWidthDouble(firstComponentTd);
+ double componentColWidth = layoutManager
+ .getOuterWidthDouble(firstComponentTd);
- if (componentColWidth == -1) {
- // Didn't get a proper width reading, best to not touch
- // anything
- return;
- }
+ if (componentColWidth == -1) {
+ // Didn't get a proper width reading, best to not touch
+ // anything
+ return;
+ }
- // Restrict content td width
- // Round down to prevent interactions with fractional sizes of
- // other columns
- int targetWidth = (int) Math
- .floor(componentColWidth - excessWidth);
+ // Restrict content td width
+ // Round down to prevent interactions with fractional sizes of
+ // other columns
+ int targetWidth = (int) Math.floor(componentColWidth - excessWidth);
- // Target might be negative if captions are wider than the total
- // available width
- targetWidth = Math.max(0, targetWidth);
+ // Target might be negative if captions are wider than the total
+ // available width
+ targetWidth = Math.max(0, targetWidth);
- if (oldMaxWidths == null) {
- oldMaxWidths = new HashMap<>();
- }
+ if (oldMaxWidths == null) {
+ oldMaxWidths = new HashMap<>();
+ }
- for (ComponentConnector child : getChildComponents()) {
- Element childElement = child.getWidget().getElement();
- if (!oldMaxWidths.containsKey(child)) {
- oldMaxWidths.put(child,
- childElement.getPropertyString("maxWidth"));
- }
- childElement.getStyle().setPropertyPx("maxWidth",
- targetWidth);
- layoutManager.reportOuterWidth(child, targetWidth);
+ for (ComponentConnector child : getChildComponents()) {
+ Element childElement = child.getWidget().getElement();
+ if (!oldMaxWidths.containsKey(child)) {
+ oldMaxWidths.put(child,
+ childElement.getPropertyString("maxWidth"));
}
+ childElement.getStyle().setPropertyPx("maxWidth", targetWidth);
+ layoutManager.reportOuterWidth(child, targetWidth);
}
}
};
protected void init() {
super.init();
selectionChangeRegistration = getWidget().getListBox()
- .addChangeHandler(e -> selectionRpc
+ .addChangeHandler(event -> selectionRpc
.select(getWidget().getListBox().getSelectedValue()));
}
super.init();
selectionChangeRegistration = getWidget().addSelectionChangeHandler(
- e -> selectionRpc.select(getRowKey(e)));
+ event -> selectionRpc.select(getRowKey(event)));
}
@Override
import com.vaadin.client.ui.Icon;
import com.vaadin.client.ui.LayoutClickEventHandler;
import com.vaadin.client.ui.aria.AriaHelper;
-import com.vaadin.client.ui.layout.ElementResizeEvent;
import com.vaadin.client.ui.layout.ElementResizeListener;
import com.vaadin.shared.ComponentConstants;
import com.vaadin.shared.communication.URLReference;
}
};
- private ElementResizeListener slotCaptionResizeListener = new ElementResizeListener() {
- @Override
- public void onElementResize(ElementResizeEvent e) {
+ private ElementResizeListener slotCaptionResizeListener = event -> {
- // Get all needed element references
- Element captionElement = e.getElement();
+ // Get all needed element references
+ Element captionElement = event.getElement();
- // Caption position determines if the widget element is the first or
- // last child inside the caption wrap
- CaptionPosition pos = getWidget().getCaptionPositionFromElement(
- captionElement.getParentElement());
+ // Caption position determines if the widget element is the first or
+ // last child inside the caption wrap
+ CaptionPosition pos = getWidget().getCaptionPositionFromElement(
+ captionElement.getParentElement());
- // The default is the last child
- Element widgetElement = captionElement.getParentElement()
- .getLastChild().cast();
+ // The default is the last child
+ Element widgetElement = captionElement.getParentElement().getLastChild()
+ .cast();
- // ...but if caption position is bottom or right, the widget is the
- // first child
- if (pos == CaptionPosition.BOTTOM || pos == CaptionPosition.RIGHT) {
- widgetElement = captionElement.getParentElement()
- .getFirstChildElement().cast();
- }
+ // ...but if caption position is bottom or right, the widget is the
+ // first child
+ if (pos == CaptionPosition.BOTTOM || pos == CaptionPosition.RIGHT) {
+ widgetElement = captionElement.getParentElement()
+ .getFirstChildElement().cast();
+ }
- if (captionElement == widgetElement) {
- // Caption element already detached
- Slot slot = getWidget().getSlot(widgetElement);
- if (slot != null) {
- slot.setCaptionResizeListener(null);
- }
- return;
+ if (captionElement == widgetElement) {
+ // Caption element already detached
+ Slot slot = getWidget().getSlot(widgetElement);
+ if (slot != null) {
+ slot.setCaptionResizeListener(null);
}
+ return;
+ }
- String widgetWidth = widgetElement.getStyle().getWidth();
- String widgetHeight = widgetElement.getStyle().getHeight();
+ String widgetWidth = widgetElement.getStyle().getWidth();
+ String widgetHeight = widgetElement.getStyle().getHeight();
- if (widgetHeight.endsWith("%") && (pos == CaptionPosition.TOP
- || pos == CaptionPosition.BOTTOM)) {
- getWidget().updateCaptionOffset(captionElement);
- } else if (widgetWidth.endsWith("%") && (pos == CaptionPosition.LEFT
- || pos == CaptionPosition.RIGHT)) {
- getWidget().updateCaptionOffset(captionElement);
- }
+ if (widgetHeight.endsWith("%") && (pos == CaptionPosition.TOP
+ || pos == CaptionPosition.BOTTOM)) {
+ getWidget().updateCaptionOffset(captionElement);
+ } else if (widgetWidth.endsWith("%") && (pos == CaptionPosition.LEFT
+ || pos == CaptionPosition.RIGHT)) {
+ getWidget().updateCaptionOffset(captionElement);
+ }
- updateLayoutHeight();
+ updateLayoutHeight();
- if (needsExpand()) {
- getWidget().updateExpandCompensation();
- }
+ if (needsExpand()) {
+ getWidget().updateExpandCompensation();
}
};
- private ElementResizeListener childComponentResizeListener = new ElementResizeListener() {
- @Override
- public void onElementResize(ElementResizeEvent e) {
- updateLayoutHeight();
- if (needsExpand()) {
- getWidget().updateExpandCompensation();
- }
+ private ElementResizeListener childComponentResizeListener = event -> {
+ updateLayoutHeight();
+ if (needsExpand()) {
+ getWidget().updateExpandCompensation();
}
};
- private ElementResizeListener spacingResizeListener = new ElementResizeListener() {
- @Override
- public void onElementResize(ElementResizeEvent e) {
- if (needsExpand()) {
- getWidget().updateExpandCompensation();
- }
+ private ElementResizeListener spacingResizeListener = event -> {
+ if (needsExpand()) {
+ getWidget().updateExpandCompensation();
}
};
import com.vaadin.client.communication.StateChangeEvent;
import com.vaadin.client.ui.AbstractFieldConnector;
import com.vaadin.client.ui.VSlider;
-import com.vaadin.client.ui.layout.ElementResizeEvent;
import com.vaadin.client.ui.layout.ElementResizeListener;
import com.vaadin.shared.ui.Connect;
import com.vaadin.shared.ui.slider.SliderServerRpc;
protected SliderServerRpc rpc = RpcProxy.create(SliderServerRpc.class,
this);
- private final ElementResizeListener resizeListener = new ElementResizeListener() {
-
- @Override
- public void onElementResize(ElementResizeEvent e) {
- getWidget().iLayout();
- }
- };
+ private final ElementResizeListener resizeListener = event -> getWidget()
+ .iLayout();
@Override
public void init() {
import com.google.gwt.event.shared.HandlerRegistration;
import com.google.gwt.user.client.DOM;
import com.google.gwt.user.client.Event;
-import com.google.gwt.user.client.EventListener;
import com.google.gwt.user.client.Timer;
import com.vaadin.client.BrowserInfo;
import com.vaadin.client.DeferredWorker;
if (isInvisibleScrollbar) {
Event.sinkEvents(root, Event.ONSCROLL);
- Event.setEventListener(root, new EventListener() {
- @Override
- public void onBrowserEvent(Event event) {
- invisibleScrollbarTemporaryResizer.show();
- }
- });
+ Event.setEventListener(root,
+ event -> invisibleScrollbarTemporaryResizer.show());
+
root.getStyle().setVisibility(Visibility.HIDDEN);
} else {
Event.sinkEvents(root, 0);
public UI createInstance(UICreateEvent event) {
if (prototype) {
UI ui = serviceObjects.getService();
- ui.addDetachListener(e -> serviceObjects.ungetService(ui));
+ ui.addDetachListener(event2 -> serviceObjects.ungetService(ui));
return ui;
}
logService.ifPresent(log -> log.log(LogService.LOG_WARNING,
}
if (navigator != null) {
popStateListenerRegistration = ui.getPage().addPopStateListener(
- e -> navigator.navigateTo(getState()));
+ event -> navigator.navigateTo(getState()));
}
}
public PushRequestHandler(VaadinServletService service)
throws ServiceException {
- service.addServiceDestroyListener(e -> destroy());
+ service.addServiceDestroyListener(event -> destroy());
final ServletConfig vaadinServletConfig = service.getServlet()
.getServletConfig();
treeGrid.setHeightUndefined();
treeGrid.setHeightMode(HeightMode.UNDEFINED);
- treeGrid.addExpandListener(e -> {
- fireExpandEvent(e.getExpandedItem(), e.isUserOriginated());
+ treeGrid.addExpandListener(event -> {
+ fireExpandEvent(event.getExpandedItem(), event.isUserOriginated());
if (autoRecalculateWidth) {
treeGrid.recalculateColumnWidths();
}
});
- treeGrid.addCollapseListener(e -> {
- fireCollapseEvent(e.getCollapsedItem(), e.isUserOriginated());
+ treeGrid.addCollapseListener(event -> {
+ fireCollapseEvent(event.getCollapsedItem(),
+ event.isUserOriginated());
if (autoRecalculateWidth) {
treeGrid.recalculateColumnWidths();
}
});
- treeGrid.addItemClickListener(e -> fireEvent(
- new ItemClick<>(this, e.getItem(), e.getMouseEventDetails())));
+ treeGrid.addItemClickListener(event -> fireEvent(new ItemClick<>(this,
+ event.getItem(), event.getMouseEventDetails())));
}
/**
blueSlider = createRGBSlider("Blue", "blue");
setRgbSliderValues(color);
- redSlider.addValueChangeListener(e -> {
- double red = e.getValue();
+ redSlider.addValueChangeListener(event -> {
+ double red = event.getValue();
if (!updatingColors) {
Color newColor = new Color((int) red, selectedColor.getGreen(),
selectedColor.getBlue());
sliders.addComponent(redSlider);
- greenSlider.addValueChangeListener(e -> {
- double green = e.getValue();
+ greenSlider.addValueChangeListener(event -> {
+ double green = event.getValue();
if (!updatingColors) {
Color newColor = new Color(selectedColor.getRed(), (int) green,
selectedColor.getBlue());
});
sliders.addComponent(greenSlider);
- blueSlider.addValueChangeListener(e -> {
- double blue = e.getValue();
+ blueSlider.addValueChangeListener(event -> {
+ double blue = event.getValue();
if (!updatingColors) {
Color newColor = new Color(selectedColor.getRed(),
selectedColor.getGreen(), (int) blue);
* if the {@code rowNumber} is not in the backing data provider
* @see #setEnabled(boolean)
*/
+ @Override
public void editRow(int rowNumber)
throws IllegalStateException, IllegalArgumentException {
if (!isEnabled()) {
@Override
public default Registration addSelectionListener(
SelectionListener<T> listener) {
- return addMultiSelectionListener(e -> listener.selectionChange(e));
+ return addMultiSelectionListener(
+ event -> listener.selectionChange(event));
}
/**
@Override
public default Registration addSelectionListener(
SelectionListener<T> listener) {
- return addSingleSelectionListener(e -> listener.selectionChange(e));
+ return addSingleSelectionListener(
+ event -> listener.selectionChange(event));
}
/**
protected void registerDropTargetRpc() {
registerRpc(
(DropTargetRpc) (types, data, dropEffect, mouseEventDetails) ->
- onDrop(types, data,
+ onDrop(types, data,
DropEffect.valueOf(dropEffect.toUpperCase(Locale.ROOT)),
mouseEventDetails));
}
protected Validator<String> notEmpty = Validator.from(val -> !val.isEmpty(),
EMPTY_ERROR_MESSAGE);
protected Converter<String, Integer> stringToInteger = Converter.from(
- Integer::valueOf, String::valueOf, e -> NOT_NUMBER_ERROR_MESSAGE);
+ Integer::valueOf, String::valueOf,
+ e -> NOT_NUMBER_ERROR_MESSAGE);
protected Validator<Integer> notNegative = Validator.from(x -> x >= 0,
NEGATIVE_ERROR_MESSAGE);
List<String> selectionChanges = new ArrayList<>();
Capture<List<String>> oldSelectionCapture = new Capture<>();
((MultiSelectionModelImpl<String>) customGrid.getSelectionModel())
- .addMultiSelectionListener(e -> {
- selectionChanges.addAll(e.getValue());
+ .addMultiSelectionListener(event -> {
+ selectionChanges.addAll(event.getValue());
oldSelectionCapture
- .setValue(new ArrayList<>(e.getOldSelection()));
+ .setValue(new ArrayList<>(event.getOldSelection()));
});
customGrid.getSelectionModel().select("Foo");
selectionChanges = new ArrayList<>();
selectionModel.addSingleSelectionListener(
- e -> selectionChanges.add(e.getValue()));
+ event -> selectionChanges.add(event.getValue()));
}
@Test(expected = IllegalStateException.class)
List<String> selectionChanges = new ArrayList<>();
List<String> oldSelectionValues = new ArrayList<>();
((SingleSelectionModelImpl<String>) customGrid.getSelectionModel())
- .addSingleSelectionListener(e -> {
- selectionChanges.add(e.getValue());
- oldSelectionValues.add(e.getOldValue());
+ .addSingleSelectionListener(event -> {
+ selectionChanges.add(event.getValue());
+ oldSelectionValues.add(event.getOldValue());
});
customGrid.getSelectionModel().select("Foo");
treeData.addItem("Foo", "Baz");
treeGrid.setDataProvider(new TreeDataProvider<>(treeData));
- treeGrid.addExpandListener(e -> expandEventFired = true);
- treeGrid.addCollapseListener(e -> collapseEventFired = true);
+ treeGrid.addExpandListener(event -> expandEventFired = true);
+ treeGrid.addCollapseListener(event -> collapseEventFired = true);
// Test expand event
assertFalse(expandEventFired);
customField.setPlaceholder("Something");
addComponent(customField);
- ok.addClickListener(e -> Notification.show("OK"));
+ ok.addClickListener(event -> Notification.show("OK"));
- CaNCEL.addClickListener(e -> Notification.show("cancel"));
+ CaNCEL.addClickListener(event -> Notification.show("cancel"));
}
}
public void clickDetachedButton() {
Button b = new Button();
AtomicInteger counter = new AtomicInteger(0);
- b.addClickListener(e -> counter.incrementAndGet());
+ b.addClickListener(event -> counter.incrementAndGet());
b.click();
assertEquals(1, counter.get());
private void addClickListener(Button b) {
clicked = false;
- b.addClickListener(e -> clicked = true);
+ b.addClickListener(event -> clicked = true);
}
}
Button b3 = new Button("b3");
Button b4 = new Button("b4");
TestTabsheet tabsheet = new TestTabsheet(b1, b2, b3, b4);
- tabsheet.addSelectedTabChangeListener(e -> {
- userOriginated.set(e.isUserOriginated());
- selected.set(e.getTabSheet().getSelectedTab());
+ tabsheet.addSelectedTabChangeListener(event -> {
+ userOriginated.set(event.isUserOriginated());
+ selected.set(event.getTabSheet().getSelectedTab());
});
tabsheet.setSelectedTab(b2);
final boolean[] eventFired = new boolean[1];
ui.addComponentAttachListener(
- e -> eventFired[0] = e.getAttachedComponent().equals(window));
+ event -> eventFired[0] = event.getAttachedComponent()
+ .equals(window));
ui.addWindow(window);
assertTrue("Attach event is not fired for added window", eventFired[0]);
}
final boolean[] eventFired = new boolean[1];
ui.addComponentDetachListener(
- e -> eventFired[0] = e.getDetachedComponent().equals(window));
+ event -> eventFired[0] = event.getDetachedComponent()
+ .equals(window));
ui.addWindow(window);
ui.removeWindow(window);
AtomicReference<Map<String, String>> mapRef = new AtomicReference<>();
AtomicReference<Map<String, String>> mapRefB = new AtomicReference<>();
- navigator.addViewChangeListener(new ViewChangeListener() {
- @Override
- public boolean beforeViewChange(ViewChangeEvent event) {
- mapRef.set(event.getParameterMap());
- mapRefB.set(event.getParameterMap("b"));
- return true;
- }
+ navigator.addViewChangeListener(event -> {
+ mapRef.set(event.getParameterMap());
+ mapRefB.set(event.getParameterMap("b"));
+ return true;
});
navigator.navigateTo("view1");
selectionChanges = new ArrayList<>();
oldSelections = new ArrayList<>();
- listing.addSelectionListener(e -> selectionChanges.add(e.getValue()));
- listing.addSelectionListener(e -> oldSelections.add(e.getOldValue()));
+ listing.addSelectionListener(
+ event -> selectionChanges.add(event.getValue()));
+ listing.addSelectionListener(
+ event -> oldSelections.add(event.getOldValue()));
}
public static final Person PERSON_C = new Person("c", 3);
ui.setContent(cb);
AtomicBoolean userOriginated = new AtomicBoolean(false);
cb.addValueChangeListener(
- e -> userOriginated.set(e.isUserOriginated()));
+ event -> userOriginated.set(event.isUserOriginated()));
ComponentTest.syncToClient(cb);
ServerRpcManager.getRpcProxy(cb, CheckBoxServerRpc.class)
.setChecked(true, new MouseEventDetails());
ui.setContent(cb);
AtomicBoolean userOriginated = new AtomicBoolean(true);
cb.addValueChangeListener(
- e -> userOriginated.set(e.isUserOriginated()));
+ event -> userOriginated.set(event.isUserOriginated()));
cb.setValue(true);
assertFalse(userOriginated.get());
userOriginated.set(true);
// Reset value whenever it changes (in a real case, this listener would
// do something with the selected value before discarding it)
- comboBox.addValueChangeListener(e -> comboBox.setValue(null));
+ comboBox.addValueChangeListener(event -> comboBox.setValue(null));
// "Attach" the component and initialize diffstate
new MockUI().setContent(comboBox);
@Override
protected void init(VaadinRequest request) {
setContent(new Button("Click Me",
- e -> Notification.show(service.getText())));
+ event -> Notification.show(service.getText())));
}
}
@Parameter(1)
public String path;
+ @Override
@Before
public void setup() throws Exception {
Assume.assumeTrue(
*/
package com.vaadin.tests.integration.push;
+import java.util.Timer;
+import java.util.TimerTask;
+
import com.vaadin.annotations.Push;
import com.vaadin.server.VaadinRequest;
import com.vaadin.shared.ui.ContentMode;
import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickEvent;
import com.vaadin.ui.Button.ClickListener;
import com.vaadin.ui.Label;
-import java.util.Timer;
-import java.util.TimerTask;
-
@Push
public class BasicPush extends AbstractTestUI {
addComponent(lbl);
Button incrementButton = new Button("Increment",
- new ClickListener() {
-
- @Override
- public void buttonClick(ClickEvent event) {
- clientCounter++;
- lbl.setValue(String.valueOf(clientCounter));
- }
+ event -> {
+ clientCounter++;
+ lbl.setValue(String.valueOf(clientCounter));
});
incrementButton.setId(INCREMENT_BUTTON_ID);
addComponent(incrementButton);
startTimer.setId(START_TIMER_ID);
addComponent(startTimer);
- Button stopTimer = new Button("Stop timer", new ClickListener() {
- @Override
- public void buttonClick(ClickEvent event) {
- if (task != null) {
- task.cancel();
- task = null;
- }
+ Button stopTimer = new Button("Stop timer", event -> {
+ if (task != null) {
+ task.cancel();
+ task = null;
}
});
stopTimer.setId(STOP_TIMER_ID);
name.setCaption("Type your name here:");
Button button = new Button("Click Me");
- button.addClickListener(e -> layout.addComponent(
+ button.addClickListener(event -> layout.addComponent(
new Label("Thanks " + name.getValue() + ", it works!")));
layout.addComponents(name, button);
name.setCaption("Type your name here:");
Button button = new Button("Click Me");
- button.addClickListener(e -> layout.addComponent(
+ button.addClickListener(event -> layout.addComponent(
new Label("Thanks " + name.getValue() + ", it works!")));
layout.addComponents(name, button);
void init() {
setId("default-view");
Button button = new Button("Click Me!",
- e -> Notification.show(service.getText()));
+ event -> Notification.show(service.getText()));
addComponent(button);
}
void init() {
setId("default-view");
Button button = new Button("Click Me!",
- e -> Notification.show(service.getText()));
+ event -> Notification.show(service.getText()));
addComponent(button);
}
import com.vaadin.server.VaadinRequest;
import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickEvent;
import com.vaadin.ui.Label;
import com.vaadin.ui.TextField;
import com.vaadin.ui.UI;
name.setCaption("Type your name here:");
Button button = new Button("Click Me");
- button.addClickListener(new Button.ClickListener() {
- @Override
- public void buttonClick(ClickEvent clickEvent) {
- layout.addComponent(
- new Label("Thanks " + name.getValue() + ", it works!"));
- }
- });
+ button.addClickListener(
+ event -> new Label(
+ "Thanks " + name.getValue() + ", it works!"));
getPage().getJavaScript().execute(
"widgetsetinfo.innerText=document.querySelector('iframe').id;");
Optional<WebElement> toggleButton = getDriver()
.findElement(By.className("v-grid-sidebar-content"))
.findElements(By.className("column-hiding-toggle")).stream()
- .filter(e -> e.getText().equals(toggleCaption)).findAny();
+ .filter(e -> e.getText().equals(toggleCaption))
+ .findAny();
if (toggleButton.isPresent()) {
toggleButton.ifPresent(e -> e.click());
} else {
import com.vaadin.server.LegacyApplication;
import com.vaadin.server.LegacyVaadinServlet;
import com.vaadin.server.ServiceException;
-import com.vaadin.server.SessionInitEvent;
-import com.vaadin.server.SessionInitListener;
import com.vaadin.server.SystemMessages;
import com.vaadin.server.SystemMessagesInfo;
import com.vaadin.server.SystemMessagesProvider;
@Override
protected void servletInitialized() throws ServletException {
super.servletInitialized();
- getService().addSessionInitListener(new SessionInitListener() {
- @Override
- public void sessionInit(SessionInitEvent event)
- throws ServiceException {
- onVaadinSessionStarted(event.getRequest(), event.getSession());
- }
- });
+ getService().addSessionInitListener(
+ event -> onVaadinSessionStarted(event.getRequest(), event.getSession()));
}
private void addDirectories(File parent, LinkedHashSet<String> packages,
import org.eclipse.jetty.server.Server;
import org.eclipse.jetty.server.ServerConnector;
import org.eclipse.jetty.util.Scanner;
+import org.eclipse.jetty.util.Scanner.BulkListener;
import org.eclipse.jetty.util.log.JavaUtilLog;
import org.eclipse.jetty.util.ssl.SslContextFactory;
import org.eclipse.jetty.webapp.WebAppContext;
scanner.setScanInterval(interval);
scanner.setRecursive(true);
- scanner.addListener(new Scanner.BulkListener() {
- @Override
- public void filesChanged(List<String> filenames)
- throws Exception {
- webappcontext.stop();
- server.stop();
- webappcontext.start();
- server.start();
- }
+ scanner.addListener((BulkListener) e-> {
+ webappcontext.stop();
+ server.stop();
+ webappcontext.start();
+ server.start();
});
scanner.setReportExistingFilesOnStartup(false);
scanner.setFilenameFilter(new FilenameFilter() {
import com.vaadin.server.VaadinRequest;
import com.vaadin.ui.BrowserFrame;
import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickEvent;
import com.vaadin.ui.Button.ClickListener;
import com.vaadin.ui.CustomComponent;
import com.vaadin.ui.HorizontalLayout;
import com.vaadin.ui.Label;
import com.vaadin.ui.UI;
import com.vaadin.ui.VerticalLayout;
-import com.vaadin.v7.data.Property.ValueChangeEvent;
-import com.vaadin.v7.data.Property.ValueChangeListener;
import com.vaadin.v7.data.util.BeanItemContainer;
import com.vaadin.v7.ui.Table;
left.addComponent(createSpacer());
left.addComponent(
- new Button("Commit actions", new Button.ClickListener() {
- @Override
- public void buttonClick(ClickEvent event) {
- commitActions();
- }
- }));
+ new Button("Commit actions", event -> commitActions()));
left.addComponent(createSpacer());
- left.addComponent(new Button("Refresh", new Button.ClickListener() {
- @Override
- public void buttonClick(ClickEvent event) {
- refreshTableContainer();
- }
- }));
+ left.addComponent(
+ new Button("Refresh", event -> refreshTableContainer()));
Label expandSpacer = createSpacer();
left.addComponent(expandSpacer);
}
private ClickListener createSetActionListener(final Action action) {
- return new ClickListener() {
- @Override
- public void buttonClick(ClickEvent event) {
- setActions(action);
- }
- };
+ return event -> setActions(action);
}
public void setActions(final Action action) {
table.setHeight("100%");
table.setMultiSelect(true);
- table.addValueChangeListener(new ValueChangeListener() {
- @Override
- public void valueChange(ValueChangeEvent event) {
- @SuppressWarnings("unchecked")
- Collection<ComparisonFailure> selectedRows = (Collection<ComparisonFailure>) table
- .getValue();
+ table.addValueChangeListener(event -> {
- viewer.setItems(selectedRows);
- }
+ @SuppressWarnings("unchecked")
+ Collection<ComparisonFailure> selectedRows = (Collection<ComparisonFailure>) table
+ .getValue();
+
+ viewer.setItems(selectedRows);
});
table.addShortcutListener(
import com.vaadin.shared.ui.window.WindowRole;
import com.vaadin.tests.components.AbstractReindeerTestUI;
import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickEvent;
-import com.vaadin.ui.Button.ClickListener;
import com.vaadin.ui.Window;
/**
@Override
protected void setup(VaadinRequest request) {
Button closeButton = new Button("Close windows");
- closeButton.addClickListener(new ClickListener() {
-
- @Override
- public void buttonClick(ClickEvent event) {
- while (!windows.isEmpty()) {
- Window window = windows.pop();
- removeWindow(window);
- }
+ closeButton.addClickListener(event -> {
+ while (!windows.isEmpty()) {
+ Window window = windows.pop();
+ removeWindow(window);
}
-
});
Button regularButton = new Button("Regular");
- regularButton.addClickListener(new ClickListener() {
-
- @Override
- public void buttonClick(ClickEvent event) {
- Window regularWindow = new Window("Regular window");
- openWindow(regularWindow);
- }
+ regularButton.addClickListener(event -> {
+ Window regularWindow = new Window("Regular window");
+ openWindow(regularWindow);
});
Button alertButton = new Button("Alert");
- alertButton.addClickListener(new ClickListener() {
- @Override
- public void buttonClick(ClickEvent event) {
- Window alertWindow = new Window("Alert window");
- alertWindow.setAssistiveRole(WindowRole.ALERTDIALOG);
- openWindow(alertWindow);
- }
+ alertButton.addClickListener(event -> {
+ Window alertWindow = new Window("Alert window");
+ alertWindow.setAssistiveRole(WindowRole.ALERTDIALOG);
+ openWindow(alertWindow);
});
addComponent(closeButton);
addComponent(regularButton);
import com.vaadin.server.VaadinRequest;
import com.vaadin.tests.components.AbstractTestUIWithLog;
import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickEvent;
public class ActionsOnInvisibleComponents extends AbstractTestUIWithLog {
Button invisibleButton = new Button("Invisible button with shortcut");
invisibleButton.setClickShortcut(KeyCode.A);
- invisibleButton.addClickListener(new Button.ClickListener() {
- @Override
- public void buttonClick(ClickEvent event) {
- log("Click event for invisible button");
- }
- });
+ invisibleButton
+ .addClickListener(
+ event -> log("Click event for invisible button"));
invisibleButton.setVisible(false);
addComponent(invisibleButton);
Button disabledButton = new Button("Disabled button with shortcut");
disabledButton.setClickShortcut(KeyCode.B);
- disabledButton.addClickListener(new Button.ClickListener() {
- @Override
- public void buttonClick(ClickEvent event) {
- log("Click event for disabled button");
- }
- });
+ disabledButton
+ .addClickListener(
+ event -> log("Click event for disabled button"));
disabledButton.setEnabled(false);
addComponent(disabledButton);
Button enabledButton = new Button("Enabled button with shortcut");
enabledButton.setClickShortcut(KeyCode.C);
- enabledButton.addClickListener(new Button.ClickListener() {
- @Override
- public void buttonClick(ClickEvent event) {
- log("Click event for enabled button");
- }
- });
+ enabledButton
+ .addClickListener(
+ event -> log("Click event for enabled button"));
addComponent(enabledButton);
}
import com.vaadin.shared.ui.ContentMode;
import com.vaadin.tests.components.TestBase;
import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickEvent;
import com.vaadin.ui.Label;
import com.vaadin.ui.LegacyWindow;
addComponent(applications);
Label thisApp = new Label("This applications: " + this);
- Button close = new Button("Close this", new Button.ClickListener() {
-
- @Override
- public void buttonClick(ClickEvent event) {
- LegacyWindow ui = (LegacyWindow) event.getButton().getUI();
- ui.getApplication().close();
- }
+ Button close = new Button("Close this", event -> {
+ LegacyWindow ui = (LegacyWindow) event.getButton().getUI();
+ ui.getApplication().close();
});
StringBuilder sb = new StringBuilder();
import com.vaadin.tests.components.AbstractTestUIWithLog;
import com.vaadin.ui.Alignment;
import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickEvent;
-import com.vaadin.ui.Button.ClickListener;
import com.vaadin.ui.CheckBox;
import com.vaadin.ui.Component;
import com.vaadin.ui.HorizontalLayout;
import com.vaadin.ui.Label;
import com.vaadin.ui.Panel;
import com.vaadin.ui.VerticalLayout;
-import com.vaadin.v7.data.Property.ValueChangeEvent;
-import com.vaadin.v7.data.Property.ValueChangeListener;
import com.vaadin.v7.ui.TextField;
/**
addComponent(createConfigPanel());
addComponent(createServerConfigPanel());
- addComponent(new Button("Say hello", new ClickListener() {
-
- @Override
- public void buttonClick(ClickEvent event) {
- log("Hello");
- }
- }));
+ addComponent(new Button("Say hello", event -> log("Hello")));
}
/**
createTemporaryResponseCodeSetters("UIDL", uidlResponse));
vl.addComponent(createTemporaryResponseCodeSetters("Heartbeat",
heartbeatResponse));
- vl.addComponent(new Button("Activate", new ClickListener() {
- @Override
- public void buttonClick(ClickEvent event) {
- if (uidlResponse.code != null && uidlResponse.code != 200) {
- getServlet().setUIDLResponseCode(CommErrorEmulatorUI.this,
- uidlResponse.code, uidlResponse.time);
- log("Responding with " + uidlResponse.code
- + " to UIDL requests for " + uidlResponse.time
- + "s");
- }
- if (heartbeatResponse.code != null
- && heartbeatResponse.code != 200) {
- getServlet().setHeartbeatResponseCode(
- CommErrorEmulatorUI.this, heartbeatResponse.code,
- heartbeatResponse.time);
- log("Responding with " + heartbeatResponse.code
- + " to heartbeat requests for "
- + heartbeatResponse.time + "s");
- }
+ vl.addComponent(new Button("Activate", event -> {
+ if (uidlResponse.code != null && uidlResponse.code != 200) {
+ getServlet().setUIDLResponseCode(CommErrorEmulatorUI.this,
+ uidlResponse.code, uidlResponse.time);
+ log("Responding with " + uidlResponse.code
+ + " to UIDL requests for " + uidlResponse.time + "s");
+ }
+ if (heartbeatResponse.code != null
+ && heartbeatResponse.code != 200) {
+ getServlet().setHeartbeatResponseCode(CommErrorEmulatorUI.this,
+ heartbeatResponse.code, heartbeatResponse.time);
+ log("Responding with " + heartbeatResponse.code
+ + " to heartbeat requests for " + heartbeatResponse.time
+ + "s");
}
}));
reconnectDialogMessage
.setValue(getReconnectDialogConfiguration().getDialogText());
reconnectDialogMessage
- .addValueChangeListener(new ValueChangeListener() {
- @Override
- public void valueChange(ValueChangeEvent event) {
+ .addValueChangeListener(event ->
getReconnectDialogConfiguration().setDialogText(
- reconnectDialogMessage.getValue());
- }
- });
+ reconnectDialogMessage.getValue()));
final TextField reconnectDialogGaveUpMessage = new TextField(
"Reconnect gave up message");
reconnectDialogGaveUpMessage.setValue(
getReconnectDialogConfiguration().getDialogTextGaveUp());
reconnectDialogGaveUpMessage
- .addValueChangeListener(new ValueChangeListener() {
- @Override
- public void valueChange(ValueChangeEvent event) {
+ .addValueChangeListener(event ->
getReconnectDialogConfiguration().setDialogTextGaveUp(
- reconnectDialogGaveUpMessage.getValue());
- }
- });
+ reconnectDialogGaveUpMessage.getValue()));
final TextField reconnectDialogReconnectAttempts = new TextField(
"Reconnect attempts");
reconnectDialogReconnectAttempts.setConverter(Integer.class);
reconnectDialogReconnectAttempts.setConvertedValue(
getReconnectDialogConfiguration().getReconnectAttempts());
reconnectDialogReconnectAttempts
- .addValueChangeListener(new ValueChangeListener() {
- @Override
- public void valueChange(ValueChangeEvent event) {
+ .addValueChangeListener(event ->
getReconnectDialogConfiguration().setReconnectAttempts(
(Integer) reconnectDialogReconnectAttempts
- .getConvertedValue());
- }
- });
+ .getConvertedValue()));
final TextField reconnectDialogReconnectInterval = new TextField(
"Reconnect interval (ms)");
reconnectDialogReconnectInterval.setConverter(Integer.class);
reconnectDialogReconnectInterval.setConvertedValue(
getReconnectDialogConfiguration().getReconnectInterval());
reconnectDialogReconnectInterval
- .addValueChangeListener(new ValueChangeListener() {
- @Override
- public void valueChange(ValueChangeEvent event) {
+ .addValueChangeListener(event ->
getReconnectDialogConfiguration().setReconnectInterval(
(Integer) reconnectDialogReconnectInterval
- .getConvertedValue());
- }
- });
+ .getConvertedValue()));
final TextField reconnectDialogGracePeriod = new TextField(
"Reconnect dialog grace period (ms)");
reconnectDialogGracePeriod.setConvertedValue(
getReconnectDialogConfiguration().getDialogGracePeriod());
reconnectDialogGracePeriod
- .addValueChangeListener(new ValueChangeListener() {
- @Override
- public void valueChange(ValueChangeEvent event) {
- getReconnectDialogConfiguration().setDialogGracePeriod(
+ .addValueChangeListener(
+ event -> getReconnectDialogConfiguration()
+ .setDialogGracePeriod(
(Integer) reconnectDialogGracePeriod
- .getConvertedValue());
- }
- });
+ .getConvertedValue()));
final CheckBox reconnectDialogModal = new CheckBox(
"Reconnect dialog modality");
timeField.setWidth("5em");
Label l3 = new Label("seconds");
- responseCode.addValueChangeListener(new ValueChangeListener() {
- @Override
- public void valueChange(ValueChangeEvent event) {
- Integer code = (Integer) responseCode.getConvertedValue();
- response.code = code;
- }
+ responseCode.addValueChangeListener(event -> {
+ Integer code = (Integer) responseCode.getConvertedValue();
+ response.code = code;
});
- timeField.addValueChangeListener(new ValueChangeListener() {
- @Override
- public void valueChange(ValueChangeEvent event) {
- Integer time = (Integer) timeField.getConvertedValue();
- response.time = time;
- }
+ timeField.addValueChangeListener(event -> {
+ Integer time = (Integer) timeField.getConvertedValue();
+ response.time = time;
});
hl.addComponents(l1, responseCode, l2, timeField, l3);
import com.vaadin.server.VaadinRequest;
import com.vaadin.tests.components.AbstractTestUIWithLog;
import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickEvent;
import com.vaadin.ui.JavaScript;
public class ConfirmBrowserTabClose extends AbstractTestUIWithLog {
// 3. Choose to stay on the page after all
// 4. Click the button
// There should be no error
- Button b = new Button("Say hello", new Button.ClickListener() {
-
- @Override
- public void buttonClick(ClickEvent event) {
- log("Hello");
- }
- });
+ Button b = new Button("Say hello", event -> log("Hello"));
addComponent(b);
JavaScript
.eval("window.addEventListener('beforeunload', function (e) {"
statusDisplay.setId("bundleStatus");
Button refreshButton = new Button("Refresh status",
- e -> statusDisplay.updateStatus());
+ event -> statusDisplay.updateStatus());
refreshButton.setId("refresh");
Button rtaButton = new Button("Add RichTextArea (in the lazy bundle)",
- e -> addComponent(new RichTextArea()));
+ event -> addComponent(new RichTextArea()));
rtaButton.setId("rta");
addComponents(statusDisplay, refreshButton, rtaButton);
import com.vaadin.shared.JsonConstants;
import com.vaadin.tests.components.AbstractReindeerTestUI;
import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickEvent;
-import com.vaadin.ui.Button.ClickListener;
import com.vaadin.ui.CheckBox;
public class CriticalNotifications extends AbstractReindeerTestUI {
Button sessionExpired = new Button("Session expired");
addComponent(sessionExpired);
- sessionExpired.addClickListener(new ClickListener() {
- @Override
- public void buttonClick(ClickEvent event) {
- showCriticalNotification(
- systemMessages.getSessionExpiredCaption(),
- systemMessages.getSessionExpiredMessage(),
- getDetailsMessage(),
- systemMessages.getSessionExpiredURL());
-
- }
- });
+ sessionExpired.addClickListener(event ->
+ showCriticalNotification(systemMessages.getSessionExpiredCaption(),
+ systemMessages.getSessionExpiredMessage(), getDetailsMessage(),
+ systemMessages.getSessionExpiredURL()));
Button authenticationError = new Button("Authentication error");
addComponent(authenticationError);
- authenticationError.addClickListener(new ClickListener() {
- @Override
- public void buttonClick(ClickEvent event) {
- showCriticalNotification(
- systemMessages.getAuthenticationErrorCaption(),
- systemMessages.getAuthenticationErrorMessage(),
- getDetailsMessage(),
- systemMessages.getAuthenticationErrorURL());
-
- }
- });
+ authenticationError.addClickListener(event ->
+ showCriticalNotification(systemMessages.getAuthenticationErrorCaption(),
+ systemMessages.getAuthenticationErrorMessage(),
+ getDetailsMessage(),
+ systemMessages.getAuthenticationErrorURL()));
Button communicationError = new Button("Communication error");
addComponent(communicationError);
- communicationError.addClickListener(new ClickListener() {
- @Override
- public void buttonClick(ClickEvent event) {
- showCriticalNotification(
- systemMessages.getCommunicationErrorCaption(),
- systemMessages.getCommunicationErrorMessage(),
- getDetailsMessage(),
- systemMessages.getCommunicationErrorURL());
-
- }
- });
+ communicationError.addClickListener(event ->
+ showCriticalNotification(systemMessages.getCommunicationErrorCaption(),
+ systemMessages.getCommunicationErrorMessage(),
+ getDetailsMessage(),
+ systemMessages.getCommunicationErrorURL()));
Button internalError = new Button("Internal error");
addComponent(internalError);
- internalError.addClickListener(new ClickListener() {
- @Override
- public void buttonClick(ClickEvent event) {
- showCriticalNotification(
- systemMessages.getInternalErrorCaption(),
- systemMessages.getInternalErrorMessage(),
- getDetailsMessage(),
- systemMessages.getInternalErrorURL());
-
- }
- });
+ internalError.addClickListener(event ->
+ showCriticalNotification(systemMessages.getInternalErrorCaption(),
+ systemMessages.getInternalErrorMessage(), getDetailsMessage(),
+ systemMessages.getInternalErrorURL()));
Button cookiesDisabled = new Button("Cookies disabled");
addComponent(cookiesDisabled);
- cookiesDisabled.addClickListener(new ClickListener() {
- @Override
- public void buttonClick(ClickEvent event) {
- showCriticalNotification(
- systemMessages.getCookiesDisabledCaption(),
- systemMessages.getCookiesDisabledMessage(),
- getDetailsMessage(),
- systemMessages.getCookiesDisabledURL());
-
- }
- });
+ cookiesDisabled.addClickListener(event -> showCriticalNotification(
+ systemMessages.getCookiesDisabledCaption(),
+ systemMessages.getCookiesDisabledMessage(), getDetailsMessage(),
+ systemMessages.getCookiesDisabledURL()));
Button custom = new Button("Custom");
addComponent(custom);
- custom.addClickListener(new ClickListener() {
- @Override
- public void buttonClick(ClickEvent event) {
+ custom.addClickListener(
+ event ->
showCriticalNotification("Custom caption", "Custom message",
- "Custom details", "custom url");
-
- }
- });
+ "Custom details", "custom url"));
}
protected String getDetailsMessage() {
if (includeDetails.getValue()) {
return "Some details for the error";
- } else {
- return null;
}
+ return null;
}
protected void showCriticalNotification(String caption, String message,
import com.vaadin.server.VaadinRequest;
import com.vaadin.tests.components.AbstractTestUIWithLog;
import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickEvent;
import com.vaadin.ui.Label;
public class DetachOldUIOnReload extends AbstractTestUIWithLog {
@Override
protected void setup(VaadinRequest request) {
addComponent(new Label("This is UI " + getUIId()));
- addComponent(new Button("Reload page", new Button.ClickListener() {
- @Override
- public void buttonClick(ClickEvent event) {
- getPage().reload();
- }
- }));
+ addComponent(new Button("Reload page", event -> getPage().reload()));
addComponent(new Button("Read log messages from session",
- new Button.ClickListener() {
- @Override
- public void buttonClick(ClickEvent event) {
- for (String message : getSessionMessages(false)) {
- log(message);
- }
+ event -> {
+ for (String message : getSessionMessages(false)) {
+ log(message);
}
}));
}
import com.vaadin.event.ShortcutAction.KeyCode;
import com.vaadin.tests.components.AbstractTestCase;
import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickEvent;
-import com.vaadin.ui.Button.ClickListener;
import com.vaadin.ui.Component;
import com.vaadin.ui.FormLayout;
import com.vaadin.ui.HorizontalLayout;
formLayout.addComponent(login);
mainWindow.setContent(formLayout);
- login.addClickListener(new ClickListener() {
- @Override
- public void buttonClick(final ClickEvent event) {
- String username = userField.getValue();
- String password = passwordField.getValue();
+ login.addClickListener(event -> {
+ String username = userField.getValue();
+ String password = passwordField.getValue();
- user = username;
- showMainWindow();
- }
+ user = username;
+ showMainWindow();
});
}
title.addStyleName("header-title");
header.addComponent(title);
Button logout = new Button("Logout");
- logout.addClickListener(new ClickListener() {
- @Override
- public void buttonClick(final ClickEvent event) {
- user = null;
- showLoginWindow();
- }
-
+ logout.addClickListener(event -> {
+ user = null;
+ showLoginWindow();
});
header.addComponent(logout);
return header;
import com.vaadin.server.VaadinRequest;
import com.vaadin.tests.components.AbstractReindeerTestUIWithLog;
import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickEvent;
import com.vaadin.ui.Component;
import com.vaadin.ui.CssLayout;
import com.vaadin.ui.Label;
protected void setup(VaadinRequest request) {
addComponent(brokenLayout);
addComponent(normalLayout);
- addComponent(new Button("Toggle properly", new Button.ClickListener() {
- @Override
- public void buttonClick(ClickEvent event) {
- toggle(true);
- }
- }));
+ addComponent(new Button("Toggle properly", event -> toggle(true)));
addComponent(
- new Button("Toggle improperly", new Button.ClickListener() {
- @Override
- public void buttonClick(ClickEvent event) {
- toggle(false);
- }
- }));
+ new Button("Toggle improperly", event -> toggle(false)));
}
private void toggle(boolean properly) {
import com.vaadin.server.VaadinRequest;
import com.vaadin.tests.components.AbstractReindeerTestUIWithLog;
import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickEvent;
-import com.vaadin.ui.Button.ClickListener;
public class ReconnectDialogUI extends AbstractReindeerTestUIWithLog {
.parseInt(request.getParameter("reconnectAttempts")));
}
Button b = new Button("Say hello");
- b.addClickListener(new ClickListener() {
-
- @Override
- public void buttonClick(ClickEvent event) {
- log("Hello from the server");
- }
- });
+ b.addClickListener(event -> log("Hello from the server"));
addComponent(b);
}
package com.vaadin.tests.application;
import com.vaadin.annotations.PreserveOnRefresh;
-import com.vaadin.server.Page.UriFragmentChangedEvent;
-import com.vaadin.server.Page.UriFragmentChangedListener;
import com.vaadin.server.VaadinRequest;
import com.vaadin.tests.components.AbstractTestUIWithLog;
import com.vaadin.ui.Label;
log("Initial fragment: " + getPage().getUriFragment());
getPage().addUriFragmentChangedListener(
- new UriFragmentChangedListener() {
- @Override
- public void uriFragmentChanged(
- UriFragmentChangedEvent event) {
- log("Fragment changed to " + event.getUriFragment());
- }
- });
+ event -> log("Fragment changed to " + event.getUriFragment()));
}
@Override
import com.vaadin.server.VaadinRequest;
import com.vaadin.tests.components.AbstractTestUIWithLog;
import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickEvent;
-import com.vaadin.ui.Button.ClickListener;
public class ResynchronizeUI extends AbstractTestUIWithLog {
@Override
protected void setup(VaadinRequest request) {
- Button b = new Button("Resynchronize", new ClickListener() {
- @Override
- public void buttonClick(ClickEvent event) {
- // Theme change is currently the only operation which always
- // does resynchronize
- setTheme("runo");
- log("Set theme to runo");
- }
+ Button b = new Button("Resynchronize", event -> {
+ // Theme change is currently the only operation which always
+ // does resynchronize
+ setTheme("runo");
+ log("Set theme to runo");
});
addComponent(b);
}
import com.vaadin.tests.components.TestBase;
import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickEvent;
import com.vaadin.ui.Notification;
import com.vaadin.ui.UI;
@Override
protected void setup() {
Button button = new Button("Throw exception",
- new Button.ClickListener() {
-
- @Override
- public void buttonClick(ClickEvent event) {
- throw new RuntimeException("You asked for it");
- }
+ event -> {
+ throw new RuntimeException("You asked for it");
});
addComponent(button);
import com.vaadin.tests.integration.FlagSeResource;
import com.vaadin.tests.util.Log;
import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickEvent;
import com.vaadin.ui.Embedded;
import com.vaadin.ui.LegacyWindow;
import com.vaadin.ui.UI;
public ThreadLocalInstances() {
mainWindow.addComponent(log);
mainWindow.addComponent(new Embedded("Icon", resource));
- mainWindow.addComponent(new Button("Sync", new Button.ClickListener() {
- @Override
- public void buttonClick(ClickEvent event) {
- reportCurrentStatus("button listener");
- }
- }));
+ mainWindow.addComponent(new Button("Sync",
+ event -> reportCurrentStatus("button listener")));
reportStatus("class init", staticInitApplication, staticInitRoot);
reportCurrentStatus("app constructor");
import com.vaadin.server.VaadinRequest;
import com.vaadin.tests.components.AbstractTestUIWithLog;
import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickEvent;
-import com.vaadin.ui.Button.ClickListener;
import com.vaadin.ui.JavaScriptFunction;
import elemental.json.JsonArray;
}
});
getPage().getJavaScript().execute(reportTimings);
- Button b = new Button("test request", new ClickListener() {
-
- @Override
- public void buttonClick(ClickEvent event) {
- getPage().getJavaScript().execute(reportTimings);
-
- }
- });
+ Button b = new Button("test request",
+ event -> getPage().getJavaScript().execute(reportTimings));
addComponent(b);
}
}
import com.vaadin.server.VaadinRequest;
import com.vaadin.tests.components.AbstractReindeerTestUI;
import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickEvent;
import com.vaadin.ui.Notification;
public class VaadinSessionAttribute extends AbstractReindeerTestUI {
getSession().setAttribute(Integer.class, Integer.valueOf(42 * 2));
addComponent(
- new Button("Show attribute values", new Button.ClickListener() {
- @Override
- public void buttonClick(ClickEvent event) {
- Notification notification = new Notification(
- getSession().getAttribute(ATTR_NAME) + " & "
- + getSession()
- .getAttribute(Integer.class));
- notification.setDelayMsec(Notification.DELAY_FOREVER);
- notification.show(getPage());
- }
+ new Button("Show attribute values", event -> {
+ Notification notification = new Notification(
+ getSession().getAttribute(ATTR_NAME) + " & "
+ + getSession().getAttribute(Integer.class));
+ notification.setDelayMsec(Notification.DELAY_FOREVER);
+ notification.show(getPage());
}));
}
import com.vaadin.server.VaadinRequest;
import com.vaadin.tests.components.AbstractReindeerTestUI;
import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickEvent;
import com.vaadin.ui.Label;
public class WebBrowserSize extends AbstractReindeerTestUI {
final Label browserSizeLabel = new Label("n/a");
browserSizeLabel.setCaption("Client (browser window) size");
- final Button update = new Button("Refresh", new Button.ClickListener() {
-
- @Override
- public void buttonClick(ClickEvent event) {
- screenSizeLabel.setValue(getBrowser().getScreenWidth() + " x "
- + getBrowser().getScreenHeight());
- browserSizeLabel.setValue(getPage().getBrowserWindowWidth()
- + " x " + getPage().getBrowserWindowHeight());
- }
+ final Button update = new Button("Refresh", event -> {
+ screenSizeLabel.setValue(getBrowser().getScreenWidth() + " x "
+ + getBrowser().getScreenHeight());
+ browserSizeLabel.setValue(getPage().getBrowserWindowWidth() + " x "
+ + getPage().getBrowserWindowHeight());
});
addComponent(update);
import com.vaadin.server.VaadinRequest;
import com.vaadin.tests.components.AbstractReindeerTestUI;
-import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickEvent;
import com.vaadin.ui.Label;
public class WebBrowserTimeZone extends AbstractReindeerTestUI {
"Browser to Europe/Helsinki offset difference");
final Label containsLabel = addLabel("Browser could be in Helsinki");
- addButton("Get TimeZone from browser", new Button.ClickListener() {
+ addButton("Get TimeZone from browser", event -> {
+ TimeZone hkiTZ = TimeZone.getTimeZone("Europe/Helsinki");
+ int hkiOffset = hkiTZ.getOffset(new Date().getTime());
- @Override
- public void buttonClick(ClickEvent event) {
- TimeZone hkiTZ = TimeZone.getTimeZone("Europe/Helsinki");
- int hkiOffset = hkiTZ.getOffset(new Date().getTime());
+ int browserOffset = getBrowser().getTimezoneOffset();
+ int browserRawOffset = getBrowser().getRawTimezoneOffset();
+ String[] tzs = TimeZone.getAvailableIDs(browserRawOffset);
- int browserOffset = getBrowser().getTimezoneOffset();
- int browserRawOffset = getBrowser().getRawTimezoneOffset();
- String[] tzs = TimeZone.getAvailableIDs(browserRawOffset);
+ boolean contains = Arrays.asList(tzs).contains(hkiTZ.getID());
- boolean contains = Arrays.asList(tzs).contains(hkiTZ.getID());
-
- offsetLabel.setValue(String.valueOf(browserOffset));
- rawOffsetLabel.setValue(String.valueOf(browserRawOffset));
- diffLabel.setValue(String.valueOf(browserOffset - hkiOffset));
- containsLabel.setValue(contains ? "Yes" : "No");
- dstDiffLabel
- .setValue(String.valueOf(getBrowser().getDSTSavings()));
- dstInEffectLabel
- .setValue(getBrowser().isDSTInEffect() ? "Yes" : "No");
- curDateLabel.setValue(getBrowser().getCurrentDate().toString());
- }
+ offsetLabel.setValue(String.valueOf(browserOffset));
+ rawOffsetLabel.setValue(String.valueOf(browserRawOffset));
+ diffLabel.setValue(String.valueOf(browserOffset - hkiOffset));
+ containsLabel.setValue(contains ? "Yes" : "No");
+ dstDiffLabel.setValue(String.valueOf(getBrowser().getDSTSavings()));
+ dstInEffectLabel
+ .setValue(getBrowser().isDSTInEffect() ? "Yes" : "No");
+ curDateLabel.setValue(getBrowser().getCurrentDate().toString());
});
}
import com.vaadin.tests.components.AbstractReindeerTestUI;
import com.vaadin.ui.Alignment;
import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickEvent;
-import com.vaadin.ui.Button.ClickListener;
import com.vaadin.ui.GridLayout;
import com.vaadin.ui.HorizontalLayout;
import com.vaadin.ui.Label;
addCommentButton = new Button("Add Comment");
addCommentButton.setWidth("100%");
- addCommentButton.addClickListener(new ClickListener() {
- @Override
- public void buttonClick(ClickEvent event) {
-
- final Window w = new Window("Add comment");
- VerticalLayout vl = new VerticalLayout();
- vl.setMargin(true);
-
- final TextField tf = new TextField();
- tf.setSizeFull();
- vl.addComponent(tf);
-
- HorizontalLayout hl = new HorizontalLayout();
-
- Button okButton = new Button("OK");
- okButton.setWidth("100%");
- okButton.addClickListener(new ClickListener() {
- @Override
- public void buttonClick(ClickEvent event) {
- addRow("[ " + tf.getValue() + " ]");
- tf.setValue("");
- w.close();
- removeWindow(w);
- }
- });
-
- Button cancelButton = new Button("Cancel");
- cancelButton.setWidth("100%");
- cancelButton.addClickListener(new ClickListener() {
- @Override
- public void buttonClick(ClickEvent event) {
- tf.setValue("");
- w.close();
- removeWindow(w);
- }
- });
-
- hl.addComponent(cancelButton);
- hl.addComponent(okButton);
- hl.setSpacing(true);
- hl.setWidth("100%");
-
- vl.addComponent(hl);
- vl.setSpacing(true);
-
- w.setContent(vl);
- addWindow(w);
- }
+ addCommentButton.addClickListener(event -> {
+ final Window w = new Window("Add comment");
+ VerticalLayout vl = new VerticalLayout();
+ vl.setMargin(true);
+
+ final TextField tf = new TextField();
+ tf.setSizeFull();
+ vl.addComponent(tf);
+
+ HorizontalLayout hl = new HorizontalLayout();
+
+ Button okButton = new Button("OK");
+ okButton.setWidth("100%");
+ okButton.addClickListener(event2 -> {
+ addRow("[ " + tf.getValue() + " ]");
+ tf.setValue("");
+ w.close();
+ removeWindow(w);
+ });
+
+ Button cancelButton = new Button("Cancel");
+ cancelButton.setWidth("100%");
+ cancelButton.addClickListener(event2 -> {
+ tf.setValue("");
+ w.close();
+ removeWindow(w);
+ });
+
+ hl.addComponent(cancelButton);
+ hl.addComponent(okButton);
+ hl.setSpacing(true);
+ hl.setWidth("100%");
+
+ vl.addComponent(hl);
+ vl.setSpacing(true);
+
+ w.setContent(vl);
+ addWindow(w);
});
addComponent(addCommentButton);
// Create a button and use this application for event handling
Button button = new Button(caption);
button.setWidth("40px");
- button.addClickListener(new ClickListener() {
- @Override
- public void buttonClick(ClickEvent event) {
- // Get the button that was clicked
- Button button = event.getButton();
+ button.addClickListener(event -> {
+ // Get the button that was clicked
+ Button b = event.getButton();
- // Get the requested operation from the button caption
- char requestedOperation = button.getCaption().charAt(0);
+ // Get the requested operation from the button caption
+ char requestedOperation = b.getCaption().charAt(0);
- // Calculate the new value
- double newValue = calculate(requestedOperation);
+ // Calculate the new value
+ double newValue = calculate(requestedOperation);
- // Update the result label with the new value
- display.setValue("" + newValue);
- }
+ // Update the result label with the new value
+ display.setValue("" + newValue);
});
button.setId("button_" + caption);
import com.vaadin.tests.components.AbstractTestCase;
import com.vaadin.tests.util.Log;
import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickEvent;
-import com.vaadin.ui.Button.ClickListener;
import com.vaadin.ui.LegacyWindow;
public class ChangeSessionId extends AbstractTestCase {
mainWindow.addComponent(log);
mainWindow.addComponent(loginButton);
mainWindow.addComponent(
- new Button("Show session id", new Button.ClickListener() {
-
- @Override
- public void buttonClick(ClickEvent event) {
- logSessionId();
- }
- }));
+ new Button("Show session id", event -> logSessionId()));
setMainWindow(mainWindow);
- loginButton.addClickListener(new ClickListener() {
- @Override
- public void buttonClick(ClickEvent event) {
- String oldSessionId = getSessionId();
- VaadinService
- .reinitializeSession(VaadinService.getCurrentRequest());
- String newSessionId = getSessionId();
- if (oldSessionId.equals(newSessionId)) {
- log.log("FAILED! Both old and new session id is "
- + newSessionId);
- } else {
- log.log("Session id changed successfully from "
- + oldSessionId + " to " + newSessionId);
- }
-
+ loginButton.addClickListener(event -> {
+ String oldSessionId = getSessionId();
+ VaadinService
+ .reinitializeSession(VaadinService.getCurrentRequest());
+ String newSessionId = getSessionId();
+ if (oldSessionId.equals(newSessionId)) {
+ log.log("FAILED! Both old and new session id is "
+ + newSessionId);
+ } else {
+ log.log("Session id changed successfully from " + oldSessionId
+ + " to " + newSessionId);
}
});
logSessionId();
import com.vaadin.server.VaadinRequest;
import com.vaadin.tests.components.AbstractTestUIWithLog;
import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickEvent;
import com.vaadin.ui.Label;
/**
}
});
- addComponent(new Button("Ping", new Button.ClickListener() {
- @Override
- public void buttonClick(ClickEvent event) {
- log("pong");
- }
- }));
-
+ addComponent(new Button("Ping", event -> log("pong")));
}
private void logUIs() {
import com.vaadin.tests.components.AbstractReindeerTestUI;
import com.vaadin.tests.util.Log;
import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickEvent;
import com.vaadin.ui.UI;
public class CloseSession extends AbstractReindeerTestUI {
addComponent(log);
addComponent(
new Button("Close VaadinServiceSession and redirect elsewhere",
- new Button.ClickListener() {
- @Override
- public void buttonClick(ClickEvent event) {
- // Assuming Vaadin is deployed to the root
- // context
- getPage().setLocation(
- "/statictestfiles/static.html");
- getSession().close();
- }
+ event -> {
+ // Assuming Vaadin is deployed to the root
+ // context
+ getPage().setLocation(
+ "/statictestfiles/static.html");
+ getSession().close();
}));
addComponent(new Button("Close VaadinServiceSession and reopen page",
- new Button.ClickListener() {
- @Override
- public void buttonClick(ClickEvent event) {
- getPage().setLocation(reopenUrl);
- getSession().close();
- }
+ event -> {
+ getPage().setLocation(reopenUrl);
+ getSession().close();
}));
addComponent(new Button("Just close VaadinSession",
- new Button.ClickListener() {
- @Override
- public void buttonClick(ClickEvent event) {
- getSession().close();
- }
- }));
+ event -> getSession().close()));
addComponent(new Button("Just close HttpSession",
- new Button.ClickListener() {
- @Override
- public void buttonClick(ClickEvent event) {
- getSession().getSession().invalidate();
- }
- }));
+ event -> getSession().getSession().invalidate()));
addComponent(new Button("Invalidate HttpSession and reopen page",
- new Button.ClickListener() {
- @Override
- public void buttonClick(ClickEvent event) {
- VaadinService.getCurrentRequest().getWrappedSession()
- .invalidate();
- getPage().setLocation(reopenUrl);
- }
+ event -> {
+ VaadinService.getCurrentRequest().getWrappedSession()
+ .invalidate();
+ getPage().setLocation(reopenUrl);
}));
addComponent(new Button("Invalidate HttpSession and redirect elsewhere",
- new Button.ClickListener() {
- @Override
- public void buttonClick(ClickEvent event) {
- VaadinService.getCurrentRequest().getWrappedSession()
- .invalidate();
- getPage().setLocation("/statictestfiles/static.html");
- }
+ event -> {
+ VaadinService.getCurrentRequest().getWrappedSession()
+ .invalidate();
+ getPage().setLocation("/statictestfiles/static.html");
}));
addComponent(new Button("Invalidate HttpSession in a background thread",
- new Button.ClickListener() {
- @Override
- public void buttonClick(ClickEvent event) {
- final HttpSession session = ((WrappedHttpSession) VaadinService
- .getCurrentRequest().getWrappedSession())
- .getHttpSession();
- Thread t = new Thread(new Runnable() {
-
- @Override
- public void run() {
- try {
- Thread.sleep(1000);
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
- System.out.println(
- "Invalidating session from thread "
- + session.getId());
- session.invalidate();
- System.out.println(
- "Invalidated session from thread "
- + session.getId());
-
+ event -> {
+ final HttpSession session = ((WrappedHttpSession) VaadinService
+ .getCurrentRequest().getWrappedSession())
+ .getHttpSession();
+ Thread t = new Thread(new Runnable() {
+
+ @Override
+ public void run() {
+ try {
+ Thread.sleep(1000);
+ } catch (InterruptedException e) {
+ e.printStackTrace();
}
- });
- t.start();
- }
+ System.out
+ .println("Invalidating session from thread "
+ + session.getId());
+ session.invalidate();
+ System.out
+ .println("Invalidated session from thread "
+ + session.getId());
+
+ }
+ });
+ t.start();
}));
}
import com.vaadin.server.VaadinService;
import com.vaadin.server.VaadinSession;
import com.vaadin.tests.components.AbstractTestUIWithLog;
-import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickEvent;
import com.vaadin.ui.UI;
public class CloseUI extends AbstractTestUIWithLog {
log("Same WrappedSession id? " + oldSessionId.equals(sessionId));
}
- addButton("Log 'hello'", new Button.ClickListener() {
- @Override
- public void buttonClick(ClickEvent event) {
- log("Hello");
- }
- });
- addButton("Close UI", new Button.ClickListener() {
- @Override
- public void buttonClick(ClickEvent event) {
- close();
- }
- });
+ addButton("Log 'hello'", event -> log("Hello"));
+ addButton("Close UI", event -> close());
- addButton("Close UI (background)", new Button.ClickListener() {
- @Override
- public void buttonClick(ClickEvent event) {
- new UIRunSafelyThread(CloseUI.this) {
- @Override
- protected void runSafely() {
- close();
- }
- }.start();
- }
+ addButton("Close UI (background)", event -> {
+ new UIRunSafelyThread(CloseUI.this) {
+ @Override
+ protected void runSafely() {
+ close();
+ }
+ }.start();
});
addButton("Close UI and redirect to /statictestfiles/static.html",
- new Button.ClickListener() {
- @Override
- public void buttonClick(ClickEvent event) {
- getPage().setLocation("/statictestfiles/static.html");
- close();
- }
+ event -> {
+ getPage().setLocation("/statictestfiles/static.html");
+ close();
});
addButton(
"Close UI and redirect to /statictestfiles/static.html (background)",
- new Button.ClickListener() {
- @Override
- public void buttonClick(ClickEvent event) {
- new UIRunSafelyThread(CloseUI.this) {
-
- @Override
- protected void runSafely() {
- getPage().setLocation(
- "/statictestfiles/static.html");
- close();
- }
- }.start();
- }
+ event -> {
+ new UIRunSafelyThread(CloseUI.this) {
+ @Override
+ protected void runSafely() {
+ getPage().setLocation(
+ "/statictestfiles/static.html");
+ close();
+ }
+ }.start();
});
}
import com.vaadin.server.VaadinRequest;
import com.vaadin.tests.components.AbstractTestUIWithLog;
-import com.vaadin.ui.Button.ClickEvent;
-import com.vaadin.ui.Button.ClickListener;
public class SessionExpiration extends AbstractTestUIWithLog {
@Override
protected void setup(VaadinRequest request) {
getSession().getSession().setMaxInactiveInterval(2);
- addButton("Click to avoid expiration", new ClickListener() {
-
- @Override
- public void buttonClick(ClickEvent event) {
- log("Clicked");
- }
- });
+ addButton("Click to avoid expiration", event -> log("Clicked"));
}
@Override
import com.vaadin.server.VaadinService;
import com.vaadin.tests.components.AbstractReindeerTestUI;
import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickEvent;
-import com.vaadin.ui.Button.ClickListener;
-import com.vaadin.v7.data.Property.ValueChangeEvent;
-import com.vaadin.v7.data.Property.ValueChangeListener;
import com.vaadin.v7.ui.NativeSelect;
import elemental.json.JsonObject;
localeSelect.addItem(new Locale("en", "US"));
localeSelect.addItem(new Locale("fi", "FI"));
localeSelect.addItem(Locale.GERMANY);
- localeSelect.addValueChangeListener(new ValueChangeListener() {
-
- @Override
- public void valueChange(ValueChangeEvent event) {
- Locale locale = (Locale) localeSelect.getValue();
- setLocale(locale);
- }
+ localeSelect.addValueChangeListener(event -> {
+ Locale locale = (Locale) localeSelect.getValue();
+ setLocale(locale);
});
localeSelect.setValue(new Locale("fi", "FI"));
addComponent(localeSelect);
final MyButton failButton = new MyButton();
failButton.setCaption("Generate server side error");
- failButton.addClickListener(new ClickListener() {
-
- @Override
- public void buttonClick(ClickEvent event) {
- failButton.fail = true;
- failButton.markAsDirty();
- }
+ failButton.addClickListener(event -> {
+ failButton.fail = true;
+ failButton.markAsDirty();
});
addComponent(failButton);
import com.vaadin.server.VaadinRequest;
import com.vaadin.tests.components.AbstractReindeerTestUI;
import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickEvent;
import com.vaadin.ui.GridLayout;
import com.vaadin.ui.UI;
import com.vaadin.ui.VerticalLayout;
gl.setMargin(true);
final Button testButton = new Button("Open Window",
- new Button.ClickListener() {
- @Override
- public void buttonClick(ClickEvent event) {
- UI.getCurrent().addWindow(testWindow);
- }
- });
+ event -> UI.getCurrent().addWindow(testWindow));
uiLayout.addComponent(testButton);
-
}
@Override
import com.vaadin.ui.AbsoluteLayout;
import com.vaadin.ui.AbsoluteLayout.ComponentPosition;
import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickEvent;
-import com.vaadin.ui.Button.ClickListener;
import com.vaadin.ui.Label;
public class AbsoluteLayoutCorrectPositioningOfHiddenField extends TestBase {
abs.addComponent(l, "top:20px;left:20px");
final Button action = new Button("Set visible");
- action.addClickListener(new ClickListener() {
-
- @Override
- public void buttonClick(ClickEvent event) {
- if (l.isVisible()) {
- l.setValue("Top 70, Left 20");
- ComponentPosition position = abs.getPosition(l);
- position.setCSSString("top:70px;left:20px;");
- abs.setPosition(l, position);
- } else {
- l.setVisible(true);
- action.setCaption("Move down");
- }
+ action.addClickListener(event -> {
+ if (l.isVisible()) {
+ l.setValue("Top 70, Left 20");
+ ComponentPosition position = abs.getPosition(l);
+ position.setCSSString("top:70px;left:20px;");
+ abs.setPosition(l, position);
+ } else {
+ l.setVisible(true);
+ action.setCaption("Move down");
}
});
action.setId("actionButton");
import com.vaadin.ui.AbsoluteLayout;
import com.vaadin.ui.Alignment;
import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickEvent;
import com.vaadin.ui.Embedded;
import com.vaadin.ui.GridLayout;
import com.vaadin.ui.HorizontalLayout;
btnLogin.setCaption("Login");
btnLogin.setWidth("-1px");
btnLogin.setHeight("-1px");
- btnLogin.addClickListener(new Button.ClickListener() {
- @Override
- public void buttonClick(Button.ClickEvent event) {
- login();
- }
- });
+ btnLogin.addClickListener(event -> login());
layoutLogin.addComponent(btnLogin);
for (int index = 0; index < layoutLogin.getComponentCount(); index++) {
GridLayout gridButtons = new GridLayout(2, 3);
Button btn1 = new Button("Button one");
- btn1.addClickListener(new Button.ClickListener() {
-
- @Override
- public void buttonClick(ClickEvent event) {
- }
+ btn1.addClickListener(event -> {
});
gridButtons.addComponent(btn1, 0, 0);
Button btn2 = new Button("Button two");
- btn2.addClickListener(new Button.ClickListener() {
-
- @Override
- public void buttonClick(ClickEvent event) {
- }
+ btn2.addClickListener(event -> {
});
gridButtons.addComponent(btn2, 0, 1);
Button btn3 = new Button("Button three");
- btn3.addClickListener(new Button.ClickListener() {
-
- @Override
- public void buttonClick(ClickEvent event) {
- }
+ btn3.addClickListener(event -> {
});
gridButtons.addComponent(btn3, 1, 0);
import com.vaadin.tests.components.TestBase;
import com.vaadin.ui.AbsoluteLayout;
import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickEvent;
import com.vaadin.ui.Component;
import com.vaadin.ui.NativeButton;
addComponent(layout);
addComponent(new Button("Change primary stylename",
- new Button.ClickListener() {
- @Override
- public void buttonClick(ClickEvent event) {
- layout.setPrimaryStyleName("my-second-absolute-layout");
- }
- }));
+ event -> layout
+ .setPrimaryStyleName("my-second-absolute-layout")));
}
@Override
import com.vaadin.tests.components.TestBase;
import com.vaadin.ui.AbsoluteLayout;
import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickEvent;
import com.vaadin.ui.ComponentContainer;
import com.vaadin.ui.VerticalLayout;
al.setHeight("200px");
testButton = new Button("Click to move to inner layout",
- new Button.ClickListener() {
-
- @Override
- public void buttonClick(ClickEvent event) {
- vl.addComponent(testButton);
- }
- });
+ event -> vl.addComponent(testButton));
al.addComponent(testButton);
addComponent(al);
Button b = new Button("Repaint inner layout",
- new Button.ClickListener() {
-
- @Override
- public void buttonClick(ClickEvent event) {
- vl.markAsDirty();
- }
- });
+ event -> vl.markAsDirty());
addComponent(b);
}
import com.vaadin.server.VaadinRequest;
import com.vaadin.tests.components.AbstractReindeerTestUI;
import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickEvent;
import com.vaadin.ui.CssLayout;
import com.vaadin.ui.Label;
}
};
- private Button buttonToAdd = new Button("Added from beforeClientResponse",
- new Button.ClickListener() {
- @Override
- public void buttonClick(ClickEvent event) {
- layout.addComponent(labelToRemove);
- }
- }) {
- @Override
- public void beforeClientResponse(boolean initial) {
- super.beforeClientResponse(initial);
- setCaption("Add label to layout");
- }
- };
-
private Label labelToRemove = new Label("Label to remove") {
int count = 0;
}
};
+ private Button buttonToAdd = new Button("Added from beforeClientResponse",
+ event -> layout.addComponent(labelToRemove)) {
+ @Override
+ public void beforeClientResponse(boolean initial) {
+ super.beforeClientResponse(initial);
+ setCaption("Add label to layout");
+ }
+ };
+
@Override
protected void setup(VaadinRequest request) {
layout.addComponent(labelToRemove);
*/
package com.vaadin.tests.components.abstractcomponent;
-import com.vaadin.event.ContextClickEvent;
import com.vaadin.event.ContextClickEvent.ContextClickListener;
import com.vaadin.server.VaadinRequest;
import com.vaadin.tests.components.AbstractTestUIWithLog;
import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickEvent;
public class ContextClickUI extends AbstractTestUIWithLog {
@Override
protected void setup(VaadinRequest request) {
- final ContextClickListener listener = new ContextClickListener() {
-
- @Override
- public void contextClick(ContextClickEvent event) {
- log("Received context click at (" + event.getClientX() + ", "
+ final ContextClickListener listener = event -> log(
+ "Received context click at (" + event.getClientX() + ", "
+ event.getClientY() + ")");
- }
- };
getUI().addContextClickListener(listener);
- addComponent(new Button("Remove listener", new Button.ClickListener() {
-
- @Override
- public void buttonClick(ClickEvent event) {
- getUI().removeContextClickListener(listener);
- }
- }));
+ addComponent(new Button("Remove listener",
+ event -> getUI().removeContextClickListener(listener)));
}
}
import com.vaadin.server.VaadinRequest;
import com.vaadin.tests.components.AbstractReindeerTestUI;
import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickEvent;
import com.vaadin.ui.Label;
import com.vaadin.v7.ui.TextField;
addComponent(tf);
Button updateButton = new Button("Update styles",
- new Button.ClickListener() {
+ event -> {
+ label.setPrimaryStyleName("updated");
+ label.setStyleName("correctly");
- @Override
- public void buttonClick(ClickEvent event) {
- label.setPrimaryStyleName("updated");
- label.setStyleName("correctly");
+ button.setPrimaryStyleName("updated");
+ button.setStyleName("correctly");
- button.setPrimaryStyleName("updated");
- button.setStyleName("correctly");
-
- tf.setPrimaryStyleName("updated");
- tf.setStyleName("correctly");
- }
+ tf.setPrimaryStyleName("updated");
+ tf.setStyleName("correctly");
});
updateButton.setId("update-button");
addComponent(updateButton);
Button button = new Button("Throw in beforeClientResponse") {
private boolean throwInBeforeClientResponse = false;
{
- addClickListener(new ClickListener() {
- @Override
- public void buttonClick(ClickEvent event) {
- throwInBeforeClientResponse = true;
- // Make sure beforeClientResponse is called
- markAsDirty();
- }
+ addClickListener(event -> {
+ throwInBeforeClientResponse = true;
+ // Make sure beforeClientResponse is called
+ markAsDirty();
});
}
import com.vaadin.tests.widgetset.TestingWidgetSet;
import com.vaadin.tests.widgetset.server.UseStateFromHierachyComponent;
import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickEvent;
import com.vaadin.ui.Label;
@Widgetset(TestingWidgetSet.NAME)
component.setContent(new Label("Content child"));
addComponent(component);
- addComponent(new Button("Remove component", new Button.ClickListener() {
- @Override
- public void buttonClick(ClickEvent event) {
- removeComponent(component);
- }
- }));
+ addComponent(new Button("Remove component",
+ event -> removeComponent(component)));
}
@Override
((Container.Sortable) cb.getContainerDataSource())
.sort(new Object[] { CAPTION }, new boolean[] { true });
cb.setImmediate(true);
- cb.addListener(new ValueChangeListener() {
-
- @Override
- public void valueChange(ValueChangeEvent event) {
- updateLocale((Locale) localeSelect.getValue());
- }
- });
+ cb.addValueChangeListener(
+ event -> updateLocale((Locale) localeSelect.getValue()));
return cb;
}
import com.vaadin.tests.components.TestBase;
import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickEvent;
-import com.vaadin.ui.Button.ClickListener;
import com.vaadin.ui.Notification;
import com.vaadin.v7.data.util.ObjectProperty;
import com.vaadin.v7.data.validator.StringLengthValidator;
tf.setBuffered(true);
tf.setRequired(true);
- Button b = new Button("Commit", new ClickListener() {
-
- @Override
- public void buttonClick(ClickEvent event) {
- try {
- tf.commit();
- if (tf.isValid()) {
- getMainWindow().showNotification(
- "OK! Form validated and no error was thrown",
- Notification.TYPE_HUMANIZED_MESSAGE);
- } else {
- getMainWindow().showNotification(
- "Form is invalid but no exception was thrown",
- Notification.TYPE_ERROR_MESSAGE);
- }
- } catch (Exception e) {
- if (tf.isValid()) {
- getMainWindow().showNotification(
- "Form is valid but an exception was thrown",
- Notification.TYPE_ERROR_MESSAGE);
- } else {
- getMainWindow().showNotification(
- "OK! Error was thrown for an invalid input",
- Notification.TYPE_HUMANIZED_MESSAGE);
+ Button b = new Button("Commit", event -> {
+ try {
+ tf.commit();
+ if (tf.isValid()) {
+ getMainWindow().showNotification(
+ "OK! Form validated and no error was thrown",
+ Notification.TYPE_HUMANIZED_MESSAGE);
+ } else {
+ getMainWindow().showNotification(
+ "Form is invalid but no exception was thrown",
+ Notification.TYPE_ERROR_MESSAGE);
+ }
+ } catch (Exception e) {
+ if (tf.isValid()) {
+ getMainWindow().showNotification(
+ "Form is valid but an exception was thrown",
+ Notification.TYPE_ERROR_MESSAGE);
+ } else {
+ getMainWindow().showNotification(
+ "OK! Error was thrown for an invalid input",
+ Notification.TYPE_HUMANIZED_MESSAGE);
- }
}
}
-
});
addComponent(tf);
import com.vaadin.tests.components.TestBase;
import com.vaadin.ui.Button;
-import com.vaadin.ui.Component.Event;
-import com.vaadin.ui.Component.Listener;
import com.vaadin.v7.data.util.ObjectProperty;
import com.vaadin.v7.ui.TextField;
// Button
Button button = new Button("Make data source read-only");
- button.addListener(new Listener() {
- @Override
- public void componentEvent(Event event) {
- stateHolder.buttonClicked();
- }
- });
+ button.addListener(event -> stateHolder.buttonClicked());
// Input field
TextField input = new TextField("Field");
import java.util.Date;
import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickEvent;
import com.vaadin.v7.data.util.ObjectProperty;
import com.vaadin.v7.ui.PopupDateField;
property.setValue(new Date(2011 - 1900, 4, 6).getTime());
addComponent(new Button("Set property value to 10000L",
- new Button.ClickListener() {
-
- @Override
- public void buttonClick(ClickEvent event) {
- property.setValue(10000L);
-
- }
- }));
+ event -> property.setValue(10000L)));
}
}
import com.vaadin.tests.components.TestBase;
import com.vaadin.tests.util.Log;
-import com.vaadin.v7.data.Property.ValueChangeEvent;
-import com.vaadin.v7.data.Property.ValueChangeListener;
import com.vaadin.v7.data.util.ObjectProperty;
import com.vaadin.v7.data.validator.DoubleValidator;
import com.vaadin.v7.data.validator.IntegerValidator;
final TextField tf = new TextField("Enter an integer");
tf.setPropertyDataSource(new ObjectProperty<>(new Integer(2)));
tf.setImmediate(true);
- tf.addListener(new ValueChangeListener() {
-
- @Override
- public void valueChange(ValueChangeEvent event) {
- try {
- log.log("Value for " + tf.getCaption() + " changed to "
- + tf.getValue());
- log.log("Converted value is " + tf.getConvertedValue());
- } catch (Exception e) {
- // TODO: handle exception
- e.printStackTrace();
- }
+ tf.addValueChangeListener(event -> {
+ try {
+ log.log("Value for " + tf.getCaption() + " changed to "
+ + tf.getValue());
+ log.log("Converted value is " + tf.getConvertedValue());
+ } catch (Exception e) {
+ // TODO: handle exception
+ e.printStackTrace();
}
});
import com.vaadin.tests.components.TestBase;
import com.vaadin.tests.util.Log;
-import com.vaadin.v7.data.Property.ValueChangeEvent;
import com.vaadin.v7.data.Property.ValueChangeListener;
import com.vaadin.v7.ui.TextField;
final TextField tf = new TextField("Enter an integer");
tf.setConverter(Integer.class);
tf.setImmediate(true);
- tf.addListener(new ValueChangeListener() {
-
- @Override
- public void valueChange(ValueChangeEvent event) {
- try {
- log.log("Value for " + tf.getCaption() + " changed to "
- + tf.getValue());
- log.log("Converted value is " + tf.getConvertedValue());
- } catch (Exception e) {
- // TODO: handle exception
- e.printStackTrace();
- }
+ tf.addValueChangeListener(event -> {
+ try {
+ log.log("Value for " + tf.getCaption() + " changed to "
+ + tf.getValue());
+ log.log("Converted value is " + tf.getConvertedValue());
+ } catch (Exception e) {
+ // TODO: handle exception
+ e.printStackTrace();
}
});
import com.vaadin.server.VaadinRequest;
import com.vaadin.tests.components.AbstractTestUIWithLog;
import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickEvent;
-import com.vaadin.ui.Button.ClickListener;
import com.vaadin.ui.TextField;
public class ShortcutAddAndRemove extends AbstractTestUIWithLog {
protected void setup(VaadinRequest request) {
final Button logButton = new Button("Log a row (enter shortcut)");
logButton.setClickShortcut(KeyCode.ENTER);
- logButton.addClickListener(new ClickListener() {
- @Override
- public void buttonClick(ClickEvent event) {
- log.log("Log button was clicked");
- }
- });
+ logButton.addClickListener(event -> log.log("Log button was clicked"));
final Button removeShortcut = new Button("Remove shortcut");
- removeShortcut.addClickListener(new ClickListener() {
- @Override
- public void buttonClick(ClickEvent event) {
- logButton.removeClickShortcut();
- logButton.setCaption("Log a row (no shortcut)");
- }
+ removeShortcut.addClickListener(event -> {
+ logButton.removeClickShortcut();
+ logButton.setCaption("Log a row (no shortcut)");
});
final Button addShortcut = new Button("Add shortcut");
- addShortcut.addClickListener(new ClickListener() {
- @Override
- public void buttonClick(ClickEvent event) {
- logButton.setClickShortcut(KeyCode.ENTER);
- logButton.setCaption("Log a row (enter shortcut)");
- }
+ addShortcut.addClickListener(event -> {
+ logButton.setClickShortcut(KeyCode.ENTER);
+ logButton.setCaption("Log a row (enter shortcut)");
});
addComponent(log);
addComponent(logButton);
import com.vaadin.server.VaadinRequest;
import com.vaadin.tests.components.AbstractTestUIWithLog;
import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickEvent;
-import com.vaadin.ui.Button.ClickListener;
public class ShortcutWhenBodyFocused extends AbstractTestUIWithLog {
@Override
protected void setup(VaadinRequest request) {
- Button b = new Button("Hello", new ClickListener() {
- @Override
- public void buttonClick(ClickEvent event) {
- log("Hello clicked");
- }
- });
+ Button b = new Button("Hello", event -> log("Hello clicked"));
b.setClickShortcut(KeyCode.A);
addComponent(b);
import com.vaadin.server.ErrorEvent;
import com.vaadin.server.ErrorHandler;
import com.vaadin.server.UserError;
-import com.vaadin.v7.data.Property.ValueChangeEvent;
-import com.vaadin.v7.data.Property.ValueChangeListener;
import com.vaadin.v7.data.util.ObjectProperty;
import com.vaadin.v7.ui.ComboBox;
import com.vaadin.v7.ui.TextField;
dataType.addItem(Date.class);
dataType.addItem(String.class);
- dataType.addListener(new ValueChangeListener() {
-
- @Override
- public void valueChange(ValueChangeEvent event) {
+ dataType.addValueChangeListener(event ->
tf.setPropertyDataSource(new ObjectProperty<>(o,
- (Class<Object>) dataType.getValue()));
- }
- });
+ (Class<Object>) dataType.getValue())));
addComponent(dataType);
tf = new TextField("TextField");
protected void createListenerMenu() {
createListenerAction("Selection listener", "Listeners",
c -> c.addSelectionListener(
- e -> log("Selected: " + e.getNewSelection())));
+ event -> log("Selected: " + event.getNewSelection())));
}
}
protected void createListenerMenu() {
createListenerAction("Selection listener", "Listeners", c -> c
- .addSelectionListener(e -> log("Selected: " + e.getValue())));
+ .addSelectionListener(
+ event -> log("Selected: " + event.getValue())));
}
protected void createSelectionMenu() {
addComponent(componentSelect);
addComponent(component); // This will be replaced in createComponent
addComponent(
- new Button("Deselect", e -> component.setSelectedItem(null)));
+ new Button("Deselect",
+ event -> component.setSelectedItem(null)));
addComponent(new Button("Select Bar",
- e -> component.setSelectedItem("Bar")));
+ event -> component.setSelectedItem("Bar")));
addComponent(new Button("Refresh",
- e -> component.getDataProvider().refreshAll()));
+ event -> component.getDataProvider().refreshAll()));
// Select a value from native select to create the initial component
componentSelect.getDataProvider().fetch(new Query<>()).findFirst()
select.setItems("Foo", "Bar", "Baz", "Reset");
select.setSelectedItem("Bar");
- select.addValueChangeListener(e -> {
- if ("Reset".equals(e.getValue())) {
+ select.addValueChangeListener(event -> {
+ if ("Reset".equals(event.getValue())) {
select.setSelectedItem("Bar");
}
});
import com.vaadin.tests.components.AbstractReindeerTestUI;
import com.vaadin.ui.Accordion;
import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickEvent;
import com.vaadin.ui.Component;
import com.vaadin.ui.Label;
import com.vaadin.ui.Panel;
tabs.setHeight(500, Unit.PIXELS);
Button remove = new Button("Remove 'First'");
final Tab me = tabs.addTab(addTab("First"));
- remove.addClickListener(new Button.ClickListener() {
-
- @Override
- public void buttonClick(ClickEvent event) {
- tabs.removeTab(me);
- Tab tab = tabs.addTab(addTab("Next"));
- tabs.setSelectedTab(tab);
- }
+ remove.addClickListener(event -> {
+ tabs.removeTab(me);
+ Tab tab = tabs.addTab(addTab("Next"));
+ tabs.setSelectedTab(tab);
});
addComponent(remove);
}
import com.vaadin.tests.components.TestBase;
import com.vaadin.ui.Accordion;
import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickEvent;
import com.vaadin.ui.NativeButton;
public class AccordionPrimaryStylenames extends TestBase {
addComponent(acc);
addComponent(
- new Button("Set primary stylename", new Button.ClickListener() {
- @Override
- public void buttonClick(ClickEvent event) {
- acc.setPrimaryStyleName("my-second-accordion");
- }
- }));
+ new Button("Set primary stylename",
+ event -> acc
+ .setPrimaryStyleName("my-second-accordion")));
}
@Override
import com.vaadin.tests.components.AbstractReindeerTestUI;
import com.vaadin.ui.Accordion;
import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickEvent;
/**
* Test for removing component from Accordion.
protected void setup(VaadinRequest request) {
final Accordion accordion = new Accordion();
Button button = new Button("remove");
- button.addClickListener(new Button.ClickListener() {
-
- @Override
- public void buttonClick(ClickEvent event) {
- accordion.removeComponent(event.getButton());
- }
- });
+ button.addClickListener(
+ event -> accordion.removeComponent(event.getButton()));
accordion.addComponent(button);
addComponent(accordion);
}
import com.vaadin.server.VaadinRequest;
import com.vaadin.tests.components.AbstractReindeerTestUI;
import com.vaadin.ui.Accordion;
-import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickEvent;
import com.vaadin.ui.Label;
import com.vaadin.ui.TabSheet.Tab;
import com.vaadin.ui.VerticalLayout;
Tab last = tabs.addTab(l);
last.setCaption("Three");
- addButton("Remove First", new Button.ClickListener() {
-
- @Override
- public void buttonClick(ClickEvent event) {
- tabs.removeComponent(tabs.iterator().next());
- }
- });
+ addButton("Remove First",
+ event -> tabs.removeComponent(tabs.iterator().next()));
}
@Override
import com.vaadin.tests.components.AbstractReindeerTestUI;
import com.vaadin.ui.Accordion;
import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickEvent;
-import com.vaadin.ui.Button.ClickListener;
import com.vaadin.ui.Label;
import com.vaadin.ui.TabSheet.Tab;
final Tab firstTab = accordion.addTab(new Label(FIRST_TAB_MESSAGE));
firstTab.setId(FIRST_TAB_ID);
Button setIdButton = new Button("Set id");
- setIdButton.addClickListener(new ClickListener() {
-
- @Override
- public void buttonClick(ClickEvent event) {
- firstTab.setId(FIRST_TAB_ID);
- }
- });
+ setIdButton.addClickListener(event -> firstTab.setId(FIRST_TAB_ID));
Button clearIdButton = new Button("Clear id");
- clearIdButton.addClickListener(new ClickListener() {
-
- @Override
- public void buttonClick(ClickEvent event) {
- firstTab.setId(null);
- }
- });
+ clearIdButton.addClickListener(event -> firstTab.setId(null));
addComponents(setIdButton, clearIdButton, accordion);
}
import com.vaadin.ui.AbstractComponentContainer;
import com.vaadin.ui.Accordion;
import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickEvent;
import com.vaadin.ui.Component;
import com.vaadin.ui.Label;
getLayout().addComponent(accordion);
closeCurrent = new Button("Close current tab");
- closeCurrent.addClickListener(new Button.ClickListener() {
- @Override
- public void buttonClick(ClickEvent event) {
- closeCurrentTab();
- }
- });
+ closeCurrent.addClickListener(event -> closeCurrentTab());
closeFirst = new Button("close first tab");
- closeFirst.addClickListener(new Button.ClickListener() {
- @Override
- public void buttonClick(ClickEvent event) {
- closeFirstTab();
- }
- });
+ closeFirst.addClickListener(event -> closeFirstTab());
closeLast = new Button("close last tab");
- closeLast.addClickListener(new Button.ClickListener() {
- @Override
- public void buttonClick(ClickEvent event) {
- closeLastTab();
- }
- });
+ closeLast.addClickListener(event -> closeLastTab());
reorderTabs = new Button("reorder");
- reorderTabs.addClickListener(new Button.ClickListener() {
- @Override
- public void buttonClick(ClickEvent event) {
- reorder();
- }
- });
+ reorderTabs.addClickListener(event -> reorder());
getLayout().addComponent(closeFirst);
getLayout().addComponent(closeLast);
import com.vaadin.tests.components.TestBase;
import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickEvent;
import com.vaadin.v7.ui.Table;
public class BeanItemContainerNullValues extends TestBase {
BeanItemContainerGenerator.createContainer(100, 1));
table.setColumnCollapsingAllowed(true);
- Button b = new Button("Disable sorting", new Button.ClickListener() {
-
- @Override
- public void buttonClick(ClickEvent event) {
- table.setSortEnabled(!table.isSortEnabled());
- if (table.isSortEnabled()) {
- event.getButton().setCaption("Disable sorting");
- } else {
- event.getButton().setCaption("Enable sorting");
- }
+ Button b = new Button("Disable sorting", event -> {
+ table.setSortEnabled(!table.isSortEnabled());
+ if (table.isSortEnabled()) {
+ event.getButton().setCaption("Disable sorting");
+ } else {
+ event.getButton().setCaption("Enable sorting");
}
-
});
addComponent(table);
import com.vaadin.tests.components.TestBase;
import com.vaadin.ui.BrowserFrame;
import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickEvent;
import com.vaadin.ui.HorizontalLayout;
public class BrowserFrameIsVisible extends TestBase {
browser.setSource(textResource);
addComponent(browser);
- page1.addClickListener(new Button.ClickListener() {
-
- @Override
- public void buttonClick(ClickEvent event) {
- TextSource helloSource = new TextSource("Hello World");
- StreamResource helloResource = new StreamResource(helloSource,
- "helloworld.txt");
- helloResource.setMIMEType("text/plain");
- browser.setSource(helloResource);
- }
+ page1.addClickListener(event -> {
+ TextSource helloSource = new TextSource("Hello World");
+ StreamResource helloResource = new StreamResource(helloSource,
+ "helloworld.txt");
+ helloResource.setMIMEType("text/plain");
+ browser.setSource(helloResource);
});
- page2.addClickListener(new Button.ClickListener() {
-
- @Override
- public void buttonClick(ClickEvent event) {
- TextSource helloSource = new TextSource("Lorem Ipsum");
- StreamResource helloResource = new StreamResource(helloSource,
- "loremipsum.txt");
- helloResource.setMIMEType("text/plain");
- browser.setSource(helloResource);
- }
+ page2.addClickListener(event -> {
+ TextSource helloSource = new TextSource("Lorem Ipsum");
+ StreamResource helloResource = new StreamResource(helloSource,
+ "loremipsum.txt");
+ helloResource.setMIMEType("text/plain");
+ browser.setSource(helloResource);
});
- page3.addClickListener(new Button.ClickListener() {
-
- @Override
- public void buttonClick(ClickEvent event) {
- browser.setSource(null);
- }
- });
+ page3.addClickListener(event -> browser.setSource(null));
}
@Override
import com.vaadin.tests.components.AbstractReindeerTestUI;
import com.vaadin.ui.Alignment;
import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickEvent;
-import com.vaadin.ui.Button.ClickListener;
import com.vaadin.ui.Label;
import com.vaadin.ui.VerticalLayout;
protected void setup(VaadinRequest request) {
final VerticalLayout rootLayout = new VerticalLayout();
final Label statusLabel = new Label("Test initialized");
- rootLayout.addComponent(new Button("Click here", new ClickListener() {
-
- @Override
- public void buttonClick(ClickEvent event) {
- statusLabel.setValue(SUCCESS_TEXT);
- }
-
- }));
- Button visitLocation = new Button("Drag here", new ClickListener() {
-
- @Override
- public void buttonClick(ClickEvent event) {
- statusLabel.setValue(WRONG_BUTTON_TEXT);
- }
-
- });
+ rootLayout.addComponent(new Button("Click here", event ->
+ statusLabel.setValue(SUCCESS_TEXT)));
+ Button visitLocation = new Button("Drag here",
+ event ->
+ statusLabel.setValue(WRONG_BUTTON_TEXT)
+ );
rootLayout.addComponent(statusLabel);
rootLayout.addComponent(visitLocation);
rootLayout.setComponentAlignment(visitLocation, Alignment.BOTTOM_RIGHT);
import com.vaadin.tests.components.TestBase;
import com.vaadin.tests.util.Log;
import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickEvent;
-import com.vaadin.ui.Button.ClickListener;
public class ButtonEnterWithWindowShortcut extends TestBase {
Log log = new Log(5);
});
Button button = new Button("Focus me and press enter",
- new ClickListener() {
- @Override
- public void buttonClick(ClickEvent event) {
- log.log("button click listener fired");
- }
- });
+ event -> log.log("button click listener fired"));
button.focus();
addComponent(log);
import com.vaadin.tests.components.TestBase;
import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickEvent;
-import com.vaadin.ui.Button.ClickListener;
public class ButtonErrorMessage extends TestBase {
@Override
protected void setup() {
Button b = new Button("Click for error");
- b.addClickListener(new ClickListener() {
- @Override
- public void buttonClick(ClickEvent event) {
- throw new NullPointerException();
- }
+ b.addClickListener(event -> {
+ throw new NullPointerException();
});
addComponent(b);
}
import com.vaadin.tests.components.TestBase;
import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickEvent;
/*
* NOTE This class is arbitrarily picked to represent a legacy application in
addComponent(b);
final Button swapButton = new Button("<i>Swap button<i>");
- swapButton.addClickListener(new Button.ClickListener() {
-
- @Override
- public void buttonClick(ClickEvent event) {
- swapButton.setCaptionAsHtml(!swapButton.isCaptionAsHtml());
- }
- });
+ swapButton.addClickListener(event -> swapButton
+ .setCaptionAsHtml(!swapButton.isCaptionAsHtml()));
addComponent(swapButton);
}
import com.vaadin.server.VaadinRequest;
import com.vaadin.tests.components.AbstractReindeerTestUI;
import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickListener;
import com.vaadin.ui.DragAndDropWrapper;
import com.vaadin.ui.DragAndDropWrapper.DragStartMode;
import com.vaadin.ui.Notification;
final VerticalLayout layout = new VerticalLayout();
Button offset = new Button("Drag me");
- offset.addClickListener(new ClickListener() {
- @Override
- public void buttonClick(com.vaadin.ui.Button.ClickEvent event) {
- Notification.show("Button clicked!");
- }
- });
+ offset.addClickListener(event -> Notification.show("Button clicked!"));
DragAndDropWrapper dragMe = new DragAndDropWrapper(offset);
dragMe.setDragStartMode(DragStartMode.WRAPPER);
layout.addComponent(dragMe);
import com.vaadin.server.VaadinRequest;
import com.vaadin.tests.components.AbstractReindeerTestUI;
import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickEvent;
-import com.vaadin.ui.Button.ClickListener;
import com.vaadin.ui.Label;
/**
labels[i] = new Label();
}
- Button button = new Button("button", new ClickListener() {
+ Button button = new Button("button", event -> {
+ Label label = new Label(String.valueOf(event.getClientX()));
+ label.addStyleName("x");
+ getLayout().replaceComponent(labels[0], label);
+ labels[0] = label;
- @Override
- public void buttonClick(ClickEvent event) {
- Label label = new Label(String.valueOf(event.getClientX()));
- label.addStyleName("x");
- getLayout().replaceComponent(labels[0], label);
- labels[0] = label;
+ label = new Label(String.valueOf(event.getClientY()));
+ label.addStyleName("y");
+ getLayout().replaceComponent(labels[1], label);
+ labels[1] = label;
- label = new Label(String.valueOf(event.getClientY()));
- label.addStyleName("y");
- getLayout().replaceComponent(labels[1], label);
- labels[1] = label;
+ label = new Label(String.valueOf(event.getRelativeX()));
+ label.addStyleName("xRelative");
+ getLayout().replaceComponent(labels[2], label);
+ labels[2] = label;
- label = new Label(String.valueOf(event.getRelativeX()));
- label.addStyleName("xRelative");
- getLayout().replaceComponent(labels[2], label);
- labels[2] = label;
-
- label = new Label(String.valueOf(event.getRelativeY()));
- label.addStyleName("yRelative");
- getLayout().replaceComponent(labels[3], label);
- labels[3] = label;
- }
+ label = new Label(String.valueOf(event.getRelativeY()));
+ label.addStyleName("yRelative");
+ getLayout().replaceComponent(labels[3], label);
+ labels[3] = label;
});
addComponent(button);
}
import com.vaadin.shared.ui.ContentMode;
import com.vaadin.tests.components.TestBase;
import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickEvent;
import com.vaadin.ui.Label;
public class ButtonMouseDetails extends TestBase {
private int clickCounter = 1;
- private Button.ClickListener clickListener = new Button.ClickListener() {
+ private Button.ClickListener clickListener = event -> {
+ StringBuilder str = new StringBuilder(out.getValue());
+ str.append(clickCounter + ":\t");
- @Override
- public void buttonClick(ClickEvent event) {
- StringBuilder str = new StringBuilder(out.getValue());
- str.append(clickCounter + ":\t");
+ // Modifier keys
+ str.append("ctrl=" + event.isCtrlKey() + ",\t");
+ str.append("alt=" + event.isAltKey() + ",\t");
+ str.append("meta=" + event.isMetaKey() + ",\t");
+ str.append("shift=" + event.isShiftKey() + ",\t");
- // Modifier keys
- str.append("ctrl=" + event.isCtrlKey() + ",\t");
- str.append("alt=" + event.isAltKey() + ",\t");
- str.append("meta=" + event.isMetaKey() + ",\t");
- str.append("shift=" + event.isShiftKey() + ",\t");
+ // Coordinates
+ str.append("X=" + event.getRelativeX() + ",\t");
+ str.append("Y=" + event.getRelativeY() + ",\t");
+ str.append("clientX=" + event.getClientX() + ",\t");
+ str.append("clientY=" + event.getClientY());
- // Coordinates
- str.append("X=" + event.getRelativeX() + ",\t");
- str.append("Y=" + event.getRelativeY() + ",\t");
- str.append("clientX=" + event.getClientX() + ",\t");
- str.append("clientY=" + event.getClientY());
+ str.append("\n");
- str.append("\n");
-
- out.setValue(str.toString());
- clickCounter++;
- }
+ out.setValue(str.toString());
+ clickCounter++;
};
@Override
import com.vaadin.server.ThemeResource;
import com.vaadin.server.VaadinRequest;
import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickEvent;
import com.vaadin.ui.Button.ClickListener;
import com.vaadin.ui.NativeButton;
import com.vaadin.ui.UI;
final ThemeResource iconResource = new ThemeResource(
"../runo/icons/16/arrow-left.png");
- final ClickListener iconToggleListener = new ClickListener() {
- @Override
- public void buttonClick(final ClickEvent event) {
- final Button btn = event.getButton();
- if (btn.getIcon() == null) {
- btn.setIcon(iconResource);
- } else {
- btn.setIcon(null);
- }
+ final ClickListener iconToggleListener = event -> {
+ final Button btn = event.getButton();
+ if (btn.getIcon() == null) {
+ btn.setIcon(iconResource);
+ } else {
+ btn.setIcon(null);
}
};
import com.vaadin.tests.components.TestBase;
import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickEvent;
public class TooltipForDisabledButton extends TestBase {
buttonEnabled.setDescription("Tooltip for enabled");
buttonDisabled.setDescription("Tooltip for disabled");
- buttonDisabled.addClickListener(new Button.ClickListener() {
+ buttonDisabled.addClickListener(
+ event -> getMainWindow().showNotification("Clicked Disabled"));
- @Override
- public void buttonClick(ClickEvent event) {
- getMainWindow().showNotification("Clicked Disabled");
- }
-
- });
-
- buttonEnabled.addClickListener(new Button.ClickListener() {
-
- @Override
- public void buttonClick(ClickEvent event) {
- getMainWindow().showNotification("Clicked Enabled");
- }
-
- });
+ buttonEnabled.addClickListener(
+ event -> getMainWindow().showNotification("Clicked Enabled"));
addComponent(buttonEnabled);
addComponent(buttonDisabled);
*/
package com.vaadin.tests.components.checkbox;
-import com.vaadin.event.ContextClickEvent;
import com.vaadin.server.VaadinRequest;
import com.vaadin.tests.components.AbstractTestUIWithLog;
import com.vaadin.ui.CheckBox;
protected void setup(VaadinRequest request) {
final CheckBox cb = new CheckBox("Right-click me", true);
cb.addContextClickListener(
- new ContextClickEvent.ContextClickListener() {
- @Override
- public void contextClick(ContextClickEvent event) {
- log("checkbox context clicked");
- }
- });
+ event -> log("checkbox context clicked"));
addComponent(cb);
}
import com.vaadin.server.VaadinRequest;
import com.vaadin.tests.components.AbstractReindeerTestUI;
import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickEvent;
import com.vaadin.ui.ColorPicker;
/**
colorPicker.setDefaultCaptionEnabled(true);
Button setWidth = new Button("Set explicit width",
- new Button.ClickListener() {
-
- @Override
- public void buttonClick(ClickEvent event) {
- colorPicker.setCaption(null);
- colorPicker.setWidth("150px");
- }
+ event -> {
+ colorPicker.setCaption(null);
+ colorPicker.setWidth("150px");
});
setWidth.addStyleName("set-width");
addComponent(setWidth);
Button setCaption = new Button("Set explicit caption",
- new Button.ClickListener() {
-
- @Override
- public void buttonClick(ClickEvent event) {
- colorPicker.setCaption("caption");
- colorPicker.setWidthUndefined();
- }
+ event -> {
+ colorPicker.setCaption("caption");
+ colorPicker.setWidthUndefined();
});
setCaption.addStyleName("set-caption");
addComponent(setCaption);
-
}
@Override
protected void setup(VaadinRequest request) {
ComboBox<String> comboBox = new ComboBox<>();
comboBox.setItems(RESET, CHANGE, SOMETHING);
- comboBox.addValueChangeListener(e -> {
- String value = e.getValue();
+ comboBox.addValueChangeListener(event -> {
+ String value = event.getValue();
log("Value changed to " + value);
- if (e.isUserOriginated()) {
+ if (event.isUserOriginated()) {
if (RESET.equals(value)) {
- e.getSource().setValue(null);
+ event.getSource().setValue(null);
} else if (CHANGE.equals(value)) {
- e.getSource().setValue(SOMETHING);
+ event.getSource().setValue(SOMETHING);
}
}
});
import com.vaadin.tests.components.TestBase;
import com.vaadin.tests.util.Log;
import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickEvent;
import com.vaadin.v7.shared.ui.combobox.FilteringMode;
import com.vaadin.v7.ui.ComboBox;
Button aButton = new Button("Show Value");
aButton.setClickShortcut(KeyCode.ENTER);
- aButton.addClickListener(new Button.ClickListener() {
-
- @Override
- public void buttonClick(ClickEvent event) {
- log.log("Button clicked. ComboBox value: " + l.getValue());
-
- }
-
- });
+ aButton.addClickListener(event -> log
+ .log("Button clicked. ComboBox value: " + l.getValue()));
addComponent(log);
addComponent(l);
import com.vaadin.tests.components.TestBase;
import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickEvent;
import com.vaadin.ui.HorizontalLayout;
import com.vaadin.ui.Label;
-import com.vaadin.v7.data.Property;
-import com.vaadin.v7.data.Property.ValueChangeEvent;
import com.vaadin.v7.data.util.IndexedContainer;
import com.vaadin.v7.ui.ComboBox;
import com.vaadin.v7.ui.Table;
state.addComponent(t);
Button b = new Button("Use ds1");
- b.addClickListener(new Button.ClickListener() {
-
- @Override
- public void buttonClick(ClickEvent event) {
- cb2.setContainerDataSource(ds1);
- currentDS.setValue("ds1");
- }
+ b.addClickListener(event -> {
+ cb2.setContainerDataSource(ds1);
+ currentDS.setValue("ds1");
});
state.addComponent(b);
state.addComponent(t);
b = new Button("Use ds2");
- b.addClickListener(new Button.ClickListener() {
-
- @Override
- public void buttonClick(ClickEvent event) {
- cb2.setContainerDataSource(ds2);
- currentDS.setValue("ds2");
- }
+ b.addClickListener(event -> {
+ cb2.setContainerDataSource(ds2);
+ currentDS.setValue("ds2");
});
state.addComponent(b);
addComponent(hl);
- cb2.addListener(new Property.ValueChangeListener() {
- @Override
- public void valueChange(ValueChangeEvent event) {
- currentValue.setValue(
- String.valueOf(event.getProperty().getValue()));
- }
- });
+ cb2.addValueChangeListener(event -> currentValue
+ .setValue(String.valueOf(event.getProperty().getValue())));
}
@Override
import com.vaadin.event.ShortcutAction.KeyCode;
import com.vaadin.tests.components.TestBase;
import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickEvent;
import com.vaadin.ui.ComboBox;
import com.vaadin.ui.Component;
import com.vaadin.ui.VerticalLayout;
final Window w = new Window();
w.setContent(layout);
layout.addComponent(createComboBox());
- Button close = new Button("Close window", new Button.ClickListener() {
-
- @Override
- public void buttonClick(ClickEvent event) {
- w.close();
- }
- });
+ Button close = new Button("Close window", event -> w.close());
close.setClickShortcut(KeyCode.ESCAPE, null);
layout.addComponent(close);
import com.vaadin.tests.components.TestBase;
import com.vaadin.ui.PopupView;
-import com.vaadin.ui.PopupView.PopupVisibilityEvent;
-import com.vaadin.ui.PopupView.PopupVisibilityListener;
import com.vaadin.v7.ui.ComboBox;
public class ComboBoxInPopupView extends TestBase {
final ComboBox cb2 = new ComboBox();
cb2.setWidth("260px");
PopupView pv2 = new PopupView("<u>2. focused (click)</u>", cb2);
- pv2.addPopupVisibilityListener(new PopupVisibilityListener() {
-
- @Override
- public void popupVisibilityChange(PopupVisibilityEvent event) {
- cb2.focus();
- }
- });
+ pv2.addPopupVisibilityListener(event -> cb2.focus());
getLayout().addComponent(pv2);
}
package com.vaadin.tests.components.combobox;
-import com.vaadin.v7.data.Property.ValueChangeEvent;
-import com.vaadin.v7.data.Property.ValueChangeListener;
import com.vaadin.v7.ui.ComboBox;
public class ComboBoxPageLength extends ComboBoxes2<ComboBox> {
@Override
public void initializeComponents() {
super.initializeComponents();
- getComponent().addValueChangeListener(new ValueChangeListener() {
-
- @Override
- public void valueChange(ValueChangeEvent event) {
- if (event.getProperty() != null) {
- if (event.getProperty().getValue() != null) {
- Integer value = Integer.parseInt(
- ((String) event.getProperty().getValue())
- .split(" ")[1]);
- getComponent().setPageLength(value);
- } else {
- getComponent().setPageLength(0);
- }
+ getComponent().addValueChangeListener(event -> {
+ if (event.getProperty() != null) {
+ if (event.getProperty().getValue() != null) {
+ Integer value = Integer
+ .parseInt(((String) event.getProperty().getValue())
+ .split(" ")[1]);
+ getComponent().setPageLength(value);
+ } else {
+ getComponent().setPageLength(0);
}
}
});
import com.vaadin.server.VaadinRequest;
import com.vaadin.tests.components.AbstractReindeerTestUI;
import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickEvent;
-import com.vaadin.ui.Button.ClickListener;
import com.vaadin.ui.HorizontalLayout;
import com.vaadin.ui.VerticalLayout;
import com.vaadin.v7.ui.ComboBox;
final ComboBox cbNullSelectionNotAllowed = getComboBoxWithNullSelectionNotAllowed();
Button b = new Button("Reset");
- b.addClickListener(new ClickListener() {
- @Override
- public void buttonClick(ClickEvent event) {
- cbNullSelectionAllowedWithSetNullSelectionItemId.setValue(null);
- cbNullSelectionAllowedWithoutNullSelectionItemId.setValue(null);
- cbNullSelectionNotAllowed.setValue(null);
- }
+ b.addClickListener(event -> {
+ cbNullSelectionAllowedWithSetNullSelectionItemId.setValue(null);
+ cbNullSelectionAllowedWithoutNullSelectionItemId.setValue(null);
+ cbNullSelectionNotAllowed.setValue(null);
});
addComponents(new HorizontalLayout(new VerticalLayout(
cbNullSelectionAllowedWithSetNullSelectionItemId,
import com.vaadin.server.VaadinRequest;
import com.vaadin.tests.components.AbstractReindeerTestUI;
import com.vaadin.ui.Label;
-import com.vaadin.v7.data.Property;
-import com.vaadin.v7.data.Property.ValueChangeEvent;
import com.vaadin.v7.ui.ComboBox;
public class ComboBoxSetNullWhenNewItemsAllowed extends AbstractReindeerTestUI {
final Label value = new Label("Selected: ");
- comboBox.addValueChangeListener(new Property.ValueChangeListener() {
- @Override
- public void valueChange(ValueChangeEvent event) {
- if (comboBox.getValue() != null) {
- comboBox.setValue(null);
- value.setValue("Selected: " + (String) comboBox.getValue());
- }
+ comboBox.addValueChangeListener(event -> {
+ if (comboBox.getValue() != null) {
+ comboBox.setValue(null);
+ value.setValue("Selected: " + (String) comboBox.getValue());
}
});
addComponent(comboBox);
import com.vaadin.server.VaadinRequest;
import com.vaadin.tests.components.AbstractReindeerTestUI;
import com.vaadin.tests.util.Log;
-import com.vaadin.v7.data.Property.ValueChangeEvent;
-import com.vaadin.v7.data.Property.ValueChangeListener;
public class ComboBoxSlow extends AbstractReindeerTestUI {
for (int i = 0; i <= 1000; i++) {
cb.addItem("Item " + i);
}
- cb.addValueChangeListener(new ValueChangeListener() {
- @Override
- public void valueChange(ValueChangeEvent event) {
- log.log("Value changed to " + cb.getValue());
- }
- });
+ cb.addValueChangeListener(
+ event -> log.log("Value changed to " + cb.getValue()));
addComponent(cb);
}
}
import com.vaadin.tests.components.TestBase;
import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickEvent;
import com.vaadin.ui.Component;
import com.vaadin.ui.VerticalLayout;
import com.vaadin.v7.data.Item;
}
Button fill = new Button("fill it");
- fill.addClickListener(new Button.ClickListener() {
- @Override
- public void buttonClick(ClickEvent event) {
- t.removeAllItems();
- for (int i = 0; i < 200; i++) {
- Item item = t.addItem(i);
- for (int j = 0; j < 5; j++) {
- item.getItemProperty("test" + j)
- .setValue(createComponent(i, j));
- }
+ fill.addClickListener(event -> {
+ t.removeAllItems();
+ for (int i = 0; i < 200; i++) {
+ Item item = t.addItem(i);
+ for (int j = 0; j < 5; j++) {
+ item.getItemProperty("test" + j)
+ .setValue(createComponent(i, j));
}
}
});
import java.util.Arrays;
-import com.vaadin.event.FieldEvents;
-import com.vaadin.event.FieldEvents.FocusEvent;
import com.vaadin.tests.components.TestBase;
import com.vaadin.ui.ComboBox;
import com.vaadin.ui.VerticalLayout;
ComboBox<String> comboBox = new ComboBox<>("Combo box",
Arrays.asList("Option 1", "Option 2", "Option 3"));
- comboBox.addFocusListener(new FieldEvents.FocusListener() {
- @Override
- public void focus(FocusEvent event) {
- popup.close();
- }
- });
+ comboBox.addFocusListener(event -> popup.close());
layout.addComponent(comboBox);
popup.setSizeUndefined();
import java.util.Arrays;
import com.vaadin.tests.components.TestBase;
-import com.vaadin.v7.data.Property.ValueChangeEvent;
-import com.vaadin.v7.data.Property.ValueChangeListener;
import com.vaadin.v7.ui.Select;
import com.vaadin.v7.ui.TextField;
textField.setImmediate(true);
final Select select = new Select("select",
Arrays.asList("1", "2", "3", "4"));
- textField.addListener(new ValueChangeListener() {
- @Override
- public void valueChange(ValueChangeEvent event) {
- select.addItem(Long.valueOf(select.size() + 1).toString()); // or
- // just
- // select.requestRepaint();
- }
- });
+ textField.addValueChangeListener(event ->
+ // or just select.requestRepaint()
+ select.addItem(Long.valueOf(select.size() + 1).toString()));
addComponent(textField);
addComponent(select);
}
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
-import com.vaadin.event.FieldEvents;
-import com.vaadin.event.FieldEvents.BlurEvent;
-import com.vaadin.event.FieldEvents.FocusEvent;
import com.vaadin.server.VaadinSession;
import com.vaadin.tests.components.TestBase;
import com.vaadin.v7.data.util.ObjectProperty;
final ObjectProperty<String> log = new ObjectProperty<>("");
- cb.addFocusListener(new FieldEvents.FocusListener() {
- @Override
- public void focus(FocusEvent event) {
- log.setValue(
- log.getValue() + "<br>" + counter + ": Focus event!");
- counter++;
- changeValue(cb);
- }
+ cb.addFocusListener(event -> {
+ log.setValue(
+ log.getValue() + "<br>" + counter + ": Focus event!");
+ counter++;
+ changeValue(cb);
});
- cb.addBlurListener(new FieldEvents.BlurListener() {
- @Override
- public void blur(BlurEvent event) {
- log.setValue(
- log.getValue() + "<br>" + counter + ": Blur event!");
- counter++;
- }
+ cb.addBlurListener(event -> {
+ log.setValue(log.getValue() + "<br>" + counter + ": Blur event!");
+ counter++;
});
TextField field = new TextField("Some textfield");
import com.vaadin.server.ThemeResource;
import com.vaadin.tests.components.TestBase;
import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickEvent;
import com.vaadin.v7.ui.ComboBox;
@SuppressWarnings("serial")
addComponent(cb2);
Button btClear = new Button("Clear button");
- btClear.addClickListener(new Button.ClickListener() {
-
- @Override
- public void buttonClick(ClickEvent event) {
- cb2.removeAllItems();
- cb2.setContainerDataSource(null);
- }
+ btClear.addClickListener(event -> {
+ cb2.removeAllItems();
+ cb2.setContainerDataSource(null);
});
addComponent(btClear);
addComponent(container);
Button updateCaption = new Button("Update caption");
- updateCaption.addClickListener(e -> innermostComponent
+ updateCaption.addClickListener(event -> innermostComponent
.setCaption(innermostComponent.getCaption() + " - updated"));
addComponent(updateCaption);
Button replaceWithAnotherComposite = new Button(
- "Replace with another Composite", e -> {
+ "Replace with another Composite", event -> {
Composite oldOuter = outerComposite;
createComposite();
layout.replaceComponent(oldOuter, outerComposite);
import com.vaadin.ui.Button;
import com.vaadin.ui.CustomComponent;
import com.vaadin.ui.Label;
-import com.vaadin.v7.data.Property.ValueChangeEvent;
import com.vaadin.v7.ui.TextField;
public class ClipContent extends TestBase {
final TextField w = new TextField("Width");
w.setValue("20px");
- w.addListener(new TextField.ValueChangeListener() {
- @Override
- public void valueChange(ValueChangeEvent event) {
- cc.setWidth(w.getValue());
- }
- });
+ w.addValueChangeListener(event -> cc.setWidth(w.getValue()));
addComponent(w);
final TextField h = new TextField("Height");
h.setValue("20px");
- h.addListener(new TextField.ValueChangeListener() {
- @Override
- public void valueChange(ValueChangeEvent event) {
- cc.setHeight(h.getValue());
- }
- });
+ h.addValueChangeListener(event -> cc.setHeight(h.getValue()));
addComponent(h);
Button b = new Button("apply");
addComponent(b);
addComponent(cc);
-
}
@Override
new Panel("In CustomComponent", label));
Button hideButton = new Button("Hide CustomComponent");
- hideButton.addClickListener(new Button.ClickListener() {
- @Override
- public void buttonClick(Button.ClickEvent event) {
- cc.setVisible(false);
- }
- });
+ hideButton.addClickListener(event -> cc.setVisible(false));
addComponent(cc);
addComponent(hideButton);
-
}
@Override
import com.vaadin.tests.components.TestBase;
import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickEvent;
import com.vaadin.ui.CustomComponent;
import com.vaadin.ui.GridLayout;
import com.vaadin.ui.Label;
}
});
- addComponent(new Button("Set long content", new Button.ClickListener() {
- @Override
- public void buttonClick(ClickEvent event) {
- label.setValue("Longer content that should be fully visible");
- }
- }));
+ addComponent(new Button("Set long content", event -> label
+ .setValue("Longer content that should be fully visible")));
}
@Override
import com.vaadin.server.VaadinRequest;
import com.vaadin.tests.components.AbstractReindeerTestUI;
import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickEvent;
import com.vaadin.ui.CustomComponent;
import com.vaadin.ui.Label;
addComponent(customComponent);
addComponent(new Button("Toggle content visibility",
- new Button.ClickListener() {
- @Override
- public void buttonClick(ClickEvent event) {
- content.setVisible(!content.isVisible());
- }
- }));
+ event -> content.setVisible(!content.isVisible())));
}
@Override
package com.vaadin.tests.components.customcomponent;
import com.vaadin.tests.components.TestBase;
-import com.vaadin.ui.Button.ClickEvent;
-import com.vaadin.ui.Button.ClickListener;
import com.vaadin.ui.CustomComponent;
import com.vaadin.ui.NativeButton;
cc.setWidth("500px");
cc.setHeight("500px");
- nb.addClickListener(new ClickListener() {
-
- @Override
- public void buttonClick(ClickEvent event) {
- cc.setWidth((cc.getWidth() - 20) + "px");
- cc.setHeight((cc.getHeight() - 20) + "px");
-
- }
+ nb.addClickListener(event -> {
+ cc.setWidth((cc.getWidth() - 20) + "px");
+ cc.setHeight((cc.getHeight() - 20) + "px");
});
addComponent(cc);
import com.vaadin.tests.components.TestBase;
import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickEvent;
import com.vaadin.ui.CustomLayout;
import com.vaadin.v7.ui.TextField;
addComponent(cl);
addComponent(new Button("Set primary stylename",
- new Button.ClickListener() {
- @Override
- public void buttonClick(ClickEvent event) {
- cl.setPrimaryStyleName("my-second-customlayout");
- }
- }));
+ event -> cl.setPrimaryStyleName("my-second-customlayout")));
} catch (IOException e) {
e.printStackTrace();
import com.vaadin.annotations.Widgetset;
import com.vaadin.server.VaadinRequest;
import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickEvent;
-import com.vaadin.ui.Button.ClickListener;
import com.vaadin.ui.CustomLayout;
import com.vaadin.ui.TextField;
import com.vaadin.ui.UI;
content.addComponent(new VerticalLayout(username2), "test2");
content.addComponent(loginButton, "okbutton");
- loginButton.addClickListener(new ClickListener() {
- @Override
- public void buttonClick(ClickEvent e) {
- username1.setCaption("updated");
- username2.setCaption("updated");
- }
+ loginButton.addClickListener(event -> {
+ username1.setCaption("updated");
+ username2.setCaption("updated");
});
}
}
layout.setWidth(null);
VerticalLayout menu = new VerticalLayout();
- menu.addComponent(new Button("Set body to label", new ClickListener() {
-
- @Override
- public void buttonClick(ClickEvent event) {
- layout.addComponent(new Label(LoremIpsum.get(200)), "body");
- }
- }));
+ menu.addComponent(new Button("Set body to label", event -> layout
+ .addComponent(new Label(LoremIpsum.get(200)), "body")));
menu.addComponent(new Button("Set body to huge NativeButton",
- new ClickListener() {
-
- @Override
- public void buttonClick(ClickEvent event) {
- layout.addComponent(
- new NativeButton("This is it, the body!"),
- "body");
- }
- }));
+ event -> layout.addComponent(
+ new NativeButton("This is it, the body!"),
+ "body")));
layout.addComponent(menu, "menu");
}
import com.vaadin.server.VaadinRequest;
import com.vaadin.tests.components.AbstractTestUIWithLog;
import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickEvent;
-import com.vaadin.ui.Button.ClickListener;
import com.vaadin.ui.CustomLayout;
import com.vaadin.v7.ui.TextField;
cl.addComponent(new TextField("This should be visible"), "first");
Button button = new Button(
"This button is visible, together with one label");
- button.addClickListener(new ClickListener() {
-
- @Override
- public void buttonClick(ClickEvent event) {
- log("Button clicked");
- }
- });
+ button.addClickListener(event -> log("Button clicked"));
cl.addComponent(button, "second");
cl.addComponent(
new TextField("This won't be as the slot is missing"),
/* NO-OP */ });
df.setRangeStart(LocalDate.now().minusDays(2));
addComponent(df);
- addComponent(new Button("Validate", e -> Notification
+ addComponent(new Button("Validate", event -> Notification
.show(binder.validate().isOk() ? "OK" : "Fail")));
}
addComponent(dateField);
Button nowButton = new Button("Today");
- nowButton.addClickListener(e -> dateField.setValue(LocalDate.now()));
+ nowButton
+ .addClickListener(event -> dateField.setValue(LocalDate.now()));
addComponent(nowButton);
Button clearButton = new Button("Clear");
- clearButton.addClickListener(e -> dateField.clear());
+ clearButton.addClickListener(event -> dateField.clear());
addComponent(clearButton);
}
/* NO-OP */
});
addComponent(df);
- addComponent(new Button("Validate", e -> Notification.show(binder.validate().isOk() ? "OK" : "Fail")));
+ addComponent(new Button("Validate", event -> Notification
+ .show(binder.validate().isOk() ? "OK" : "Fail")));
}
}
package com.vaadin.tests.components.datefield;
+import java.time.LocalDate;
+import java.time.format.DateTimeFormatter;
+import java.time.format.FormatStyle;
+import java.util.Locale;
+
import com.vaadin.annotations.Widgetset;
import com.vaadin.data.Binder;
import com.vaadin.data.Result;
import com.vaadin.ui.Notification;
import com.vaadin.ui.VerticalLayout;
-import java.time.LocalDate;
-import java.time.format.DateTimeFormatter;
-import java.time.format.FormatStyle;
-import java.util.Locale;
-
@Widgetset("com.vaadin.DefaultWidgetSet")
public class DateTextHandling extends AbstractTestUI {
layout.addComponent(buttonValidate);
Button setValueButton = new Button("Set 2011-12-13",
- e -> dateField.setValue(LocalDate.of(2011, 12, 13)));
+ event -> dateField.setValue(LocalDate.of(2011, 12, 13)));
layout.addComponent(setValueButton);
addComponent(layout);
}
CheckBox weekNumbersToggle = new CheckBox("Toggle week numbers",
dateTimeField.isShowISOWeekNumbers());
weekNumbersToggle.addValueChangeListener(
- e -> dateTimeField.setShowISOWeekNumbers(e.getValue()));
+ event -> dateTimeField.setShowISOWeekNumbers(event.getValue()));
Button toEnglish = new Button("Change locale",
click -> dateTimeField.setLocale(Locale.ENGLISH));
package com.vaadin.tests.components.draganddropwrapper;
import com.vaadin.data.HasValue.ValueChangeListener;
-import com.vaadin.event.FieldEvents.FocusEvent;
import com.vaadin.event.FieldEvents.FocusListener;
import com.vaadin.event.dd.DragAndDropEvent;
import com.vaadin.event.dd.DropHandler;
*/
public class DragAndDropFocusObtain extends AbstractTestUIWithLog {
- private FocusListener focusListener = new FocusListener() {
+ private FocusListener focusListener = event -> log(
+ "Field '" + event.getComponent().getCaption() + "' focused");
- @Override
- public void focus(FocusEvent event) {
- log("Field '" + event.getComponent().getCaption() + "' focused");
- }
- };
-
- private ValueChangeListener<String> listener = event -> log(
- "Value of " + ((AbstractTextField) event.getSource()).getCaption()
- + " changed to " + event.getValue());
+ private ValueChangeListener<String> listener = event ->
+ log("Value of " + ((AbstractTextField) event.getSource()).getCaption()
+ + " changed to " + event.getValue());
@Override
protected void setup(VaadinRequest request) {
import com.vaadin.tests.components.TestBase;
import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickEvent;
import com.vaadin.ui.Component;
import com.vaadin.ui.DragAndDropWrapper;
import com.vaadin.ui.Label;
@Override
protected void setup() {
- addComponent(new Button("Click to resize", new Button.ClickListener() {
- @Override
- public void buttonClick(ClickEvent event) {
- for (int i = 1; i < getLayout().getComponentCount(); ++i) {
- Component c = getLayout().getComponent(i);
- c.setWidth("400px");
- c.setHeight("200px");
- }
+ addComponent(new Button("Click to resize", event -> {
+ for (int i = 1; i < getLayout().getComponentCount(); ++i) {
+ Component c = getLayout().getComponent(i);
+ c.setWidth("400px");
+ c.setHeight("200px");
}
}));
import com.vaadin.server.VaadinRequest;
import com.vaadin.tests.components.AbstractTestUIWithLog;
import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickEvent;
import com.vaadin.ui.DragAndDropWrapper;
import com.vaadin.ui.DragAndDropWrapper.DragStartMode;
import com.vaadin.ui.Image;
Button neverButton = new Button("Never accepts drop");
neverButton.setId("never");
- neverButton.addClickListener(new Button.ClickListener() {
- @Override
- public void buttonClick(ClickEvent event) {
- log("click on " + event.getButton().getCaption());
- }
- });
+ neverButton.addClickListener(
+ event -> log("click on " + event.getButton().getCaption()));
DragAndDropWrapper neverAccept = new DragAndDropWrapper(neverButton);
neverAccept.setSizeFull();
});
Button alwaysButton = new Button("always accepts drop");
alwaysButton.setId("always");
- alwaysButton.addClickListener(new Button.ClickListener() {
- @Override
- public void buttonClick(ClickEvent event) {
- log("click on " + event.getButton().getCaption());
- }
- });
+ alwaysButton.addClickListener(
+ event -> log("click on " + event.getButton().getCaption()));
DragAndDropWrapper alwaysAccept = new DragAndDropWrapper(alwaysButton);
alwaysAccept.setSizeFull();
import com.vaadin.server.ThemeResource;
import com.vaadin.tests.components.TestBase;
import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickEvent;
import com.vaadin.ui.Embedded;
public class EmbeddedAltText extends TestBase {
addComponent(player);
Button changeAltTexts = new Button("Change alt texts",
- new Button.ClickListener() {
- @Override
- public void buttonClick(ClickEvent event) {
- e.setAlternateText("New alt text of the image!");
- player.setAlternateText("New alt text of the object!");
- }
+ event -> {
+ e.setAlternateText("New alt text of the image!");
+ player.setAlternateText("New alt text of the object!");
});
addComponent(changeAltTexts);
}
import com.vaadin.server.ExternalResource;
import com.vaadin.tests.components.TestBase;
import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickEvent;
import com.vaadin.ui.Embedded;
import com.vaadin.ui.Label;
import com.vaadin.ui.VerticalLayout;
applet.setSource(new ExternalResource("/statictestfiles/applet.html"));
addComponent(applet);
- addComponent(new Button("Remove applet", new Button.ClickListener() {
- @Override
- public void buttonClick(ClickEvent event) {
- removeComponent(applet);
- }
- }));
+ addComponent(
+ new Button("Remove applet", event -> removeComponent(applet)));
VerticalLayout layout = new VerticalLayout();
layout.setMargin(true);
package com.vaadin.tests.components.embedded;
-import com.vaadin.event.MouseEvents.ClickEvent;
-import com.vaadin.event.MouseEvents.ClickListener;
import com.vaadin.server.ThemeResource;
import com.vaadin.tests.components.TestBase;
import com.vaadin.ui.Embedded;
xLabel.setId("x");
final Label yLabel = new Label();
yLabel.setId("y");
- e.addClickListener(new ClickListener() {
-
- @Override
- public void click(ClickEvent event) {
- xLabel.setValue("" + event.getRelativeX());
- yLabel.setValue("" + event.getRelativeY());
- }
+ e.addClickListener(event -> {
+ xLabel.setValue("" + event.getRelativeX());
+ yLabel.setValue("" + event.getRelativeY());
});
addComponent(e);
addComponent(xLabel);
import com.vaadin.server.StreamResource;
import com.vaadin.tests.components.TestBase;
import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickEvent;
import com.vaadin.ui.Embedded;
public class EmbeddedImageRefresh extends TestBase {
// The button requests repainting the embedded.
Button button = new Button("refr");
- button.addClickListener(new Button.ClickListener() {
- @Override
- public void buttonClick(ClickEvent event) {
- embedded.markAsDirty();
- }
- });
+ button.addClickListener(event -> embedded.markAsDirty());
addComponent(button);
button = new Button("refr name");
- button.addClickListener(new Button.ClickListener() {
- @Override
- public void buttonClick(ClickEvent event) {
- ((StreamResource) embedded.getSource())
- .setFilename(new Date().getTime() + ".png");
- embedded.markAsDirty();
- }
+ button.addClickListener(event -> {
+ ((StreamResource) embedded.getSource())
+ .setFilename(new Date().getTime() + ".png");
+ embedded.markAsDirty();
});
addComponent(button);
button = new Button("200x200");
- button.addClickListener(new Button.ClickListener() {
- @Override
- public void buttonClick(ClickEvent event) {
- embedded.setWidth("200px");
- embedded.setHeight("200px");
- }
+ button.addClickListener(event -> {
+ embedded.setWidth("200px");
+ embedded.setHeight("200px");
});
addComponent(button);
button = new Button("undef");
- button.addClickListener(new Button.ClickListener() {
- @Override
- public void buttonClick(ClickEvent event) {
- embedded.setSizeUndefined();
- }
- });
+ button.addClickListener(event -> embedded.setSizeUndefined());
addComponent(button);
-
}
public class MyImageSource implements StreamResource.StreamSource {
import com.vaadin.server.ClassResource;
import com.vaadin.tests.components.TestBase;
import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickEvent;
import com.vaadin.ui.Embedded;
import com.vaadin.ui.Window;
player.setSource(new ClassResource(getClass(), "test.pdf"));
addComponent(player);
- addComponent(new Button("Remove pdf", new Button.ClickListener() {
- @Override
- public void buttonClick(ClickEvent event) {
- removeComponent(player);
- }
- }));
+ addComponent(
+ new Button("Remove pdf", event -> removeComponent(player)));
player.getUI().addWindow(new Window("Testwindow"));
}
import com.vaadin.server.ThemeResource;
import com.vaadin.server.VaadinRequest;
import com.vaadin.tests.components.AbstractReindeerTestUI;
-import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickEvent;
import com.vaadin.ui.Embedded;
import com.vaadin.ui.Image;
import com.vaadin.v7.ui.themes.Reindeer;
protected void setup(VaadinRequest request) {
setTheme("tests-components");
- addButton("Toggle theme", new Button.ClickListener() {
-
- @Override
- public void buttonClick(ClickEvent event) {
- if (Reindeer.THEME_NAME.equals(getTheme())) {
- setTheme("tests-components");
- } else {
- setTheme(Reindeer.THEME_NAME);
- }
+ addButton("Toggle theme", event -> {
+ if (Reindeer.THEME_NAME.equals(getTheme())) {
+ setTheme("tests-components");
+ } else {
+ setTheme(Reindeer.THEME_NAME);
}
});
player.setHeight("300px");
player.setSource(new ClassResource("simple.swf"));
addComponent(player);
- Button button = new Button("click", e -> player.setSizeFull());
+ Button button = new Button("click", event -> player.setSizeFull());
addComponent(button);
}
import com.vaadin.tests.components.TestBase;
import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickEvent;
import com.vaadin.ui.FormLayout;
import com.vaadin.v7.ui.TextField;
fl.addComponent(f1);
fl.addComponent(new Button("Toggle Text field 2 bold style",
- new Button.ClickListener() {
-
- @Override
- public void buttonClick(ClickEvent event) {
- if ("bold".equals(f2.getStyleName())) {
- f2.setStyleName("");
- } else {
- f2.setStyleName("bold");
- }
-
+ event -> {
+ if ("bold".equals(f2.getStyleName())) {
+ f2.setStyleName("");
+ } else {
+ f2.setStyleName("bold");
}
-
}));
fl.addComponent(f2);
addComponent(fl);
-
}
private TextField createTextField(String caption, String style) {
*/
package com.vaadin.tests.components.formlayout;
-import com.vaadin.event.LayoutEvents.LayoutClickEvent;
-import com.vaadin.event.LayoutEvents.LayoutClickListener;
import com.vaadin.server.VaadinRequest;
import com.vaadin.tests.components.AbstractTestUIWithLog;
import com.vaadin.ui.FormLayout;
label.setId("label");
layout.addComponent(label);
- layout.addLayoutClickListener(new LayoutClickListener() {
-
- @Override
- public void layoutClick(LayoutClickEvent event) {
- log("Child component: " + (event.getChildComponent() == null
- ? null : event.getChildComponent().getId()));
- log("Clicked component: " + (event.getClickedComponent() == null
- ? null : event.getClickedComponent().getId()));
- log("Source component: " + event.getComponent().getId());
- }
+ layout.addLayoutClickListener(event -> {
+ log("Child component: " + (event.getChildComponent() == null ? null
+ : event.getChildComponent().getId()));
+ log("Clicked component: " + (event.getClickedComponent() == null ? null
+ : event.getClickedComponent().getId()));
+ log("Source component: " + event.getComponent().getId());
});
addComponent(layout);
import com.vaadin.server.VaadinRequest;
import com.vaadin.tests.components.AbstractReindeerTestUI;
import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickEvent;
import com.vaadin.ui.Component;
import com.vaadin.ui.CssLayout;
import com.vaadin.ui.FormLayout;
addComponent(view);
- addComponent(new Button("Toggle width", new Button.ClickListener() {
- @Override
- public void buttonClick(ClickEvent event) {
- if ((int) view.getWidth() == 400) {
- view.setWidth("600px");
- } else {
- view.setWidth("400px");
- }
+ addComponent(new Button("Toggle width", event -> {
+ if ((int) view.getWidth() == 400) {
+ view.setWidth("600px");
+ } else {
+ view.setWidth("400px");
}
}));
}
import com.vaadin.server.VaadinRequest;
import com.vaadin.tests.components.AbstractReindeerTestUI;
import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickEvent;
import com.vaadin.ui.FormLayout;
import com.vaadin.v7.ui.TextField;
addComponent(new FormLayout(asHtml, asText));
- addComponent(new Button("Toggle", new Button.ClickListener() {
- @Override
- public void buttonClick(ClickEvent event) {
- asHtml.setCaptionAsHtml(!asHtml.isCaptionAsHtml());
- asText.setCaptionAsHtml(!asText.isCaptionAsHtml());
- }
+ addComponent(new Button("Toggle", event -> {
+ asHtml.setCaptionAsHtml(!asHtml.isCaptionAsHtml());
+ asText.setCaptionAsHtml(!asText.isCaptionAsHtml());
}));
}
}
grid.setItems("a", "aa", "aaa");
addComponent(grid);
- addComponent(new Button("Replace columns", e -> {
+ addComponent(new Button("Replace columns", event -> {
grid.removeAllColumns();
createColumns(grid);
Notification.show("Columns replaced.");
import com.vaadin.shared.ui.ContentMode;
import com.vaadin.tests.components.AbstractTestUI;
import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickEvent;
import com.vaadin.ui.Grid;
import com.vaadin.ui.Label;
import com.vaadin.ui.VerticalLayout;
ContentMode.PREFORMATTED);
final VerticalLayout layout = new VerticalLayout();
final Button btn = new Button("newGrid");
- btn.addClickListener(new Button.ClickListener() {
-
- @Override
- public void buttonClick(ClickEvent event) {
- layout.removeComponent(layout.getComponent(1));
- layout.addComponent(new Grid<String>());
- }
+ btn.addClickListener(event -> {
+ layout.removeComponent(layout.getComponent(1));
+ layout.addComponent(new Grid<String>());
});
layout.addComponent(instructionLabel);
layout.addComponent(btn);
textField.setWidth("100%");
// Make sure all changes are sent immediately
textField.setValueChangeMode(ValueChangeMode.EAGER);
- textField.addValueChangeListener(e -> {
+ textField.addValueChangeListener(event -> {
// Value of text field edited by user, store
textFields.put(string, textField);
});
return null;
}
Button button = new Button("Click Me!",
- e -> Notification.show(
+ event -> Notification.show(
"Clicked button on row for: " + string,
Type.WARNING_MESSAGE));
button.setId(string.replace(' ', '_').toLowerCase(Locale.ROOT));
addComponent(grid);
grid.setSizeFull();
- Button resetData = new Button("Reset data", e -> {
+ Button resetData = new Button("Reset data", event -> {
grid.setItems(IntStream.range(0, 1000).boxed()
.map(i -> "Row " + (i + (counter * 1000))));
textFields.clear();
import com.vaadin.server.VaadinRequest;
import com.vaadin.tests.components.AbstractTestUI;
import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickEvent;
-import com.vaadin.ui.Button.ClickListener;
import com.vaadin.ui.Grid;
import com.vaadin.ui.VerticalLayout;
VerticalLayout v = new VerticalLayout();
- v.addComponent(new Button("Deselect on server", new ClickListener() {
+ v.addComponent(new Button("Deselect on server",
+ event -> grid.getSelectionModel().deselectAll()));
- @Override
- public void buttonClick(ClickEvent event) {
- grid.getSelectionModel().deselectAll();
- }
- }));
-
- v.addComponent(new Button("Select on server", new ClickListener() {
-
- @Override
- public void buttonClick(ClickEvent event) {
- grid.getSelectionModel().select(person1);
- }
- }));
+ v.addComponent(new Button("Select on server",
+ event -> grid.getSelectionModel().select(person1)));
v.addComponent(grid);
addComponent(v);
Button addCaptionToLayoutWithGridButton = new Button(
"Add caption to 'layoutWithGrid' layout");
- addCaptionToLayoutWithGridButton.addClickListener(e -> layoutWithGrid
+ addCaptionToLayoutWithGridButton
+ .addClickListener(event -> layoutWithGrid
.setCaption("Caption added to 'layoutWithGrid' layout"));
layoutWithGrid.addComponent(addCaptionToLayoutWithGridButton);
import com.vaadin.server.VaadinRequest;
import com.vaadin.tests.components.AbstractReindeerTestUI;
-import com.vaadin.ui.Button;
import com.vaadin.ui.Grid;
import com.vaadin.ui.Grid.SelectionMode;
grid.setItems("bar");
addComponent(grid);
- addButton("Multi", new Button.ClickListener() {
- @Override
- public void buttonClick(Button.ClickEvent event) {
- grid.setSelectionMode(SelectionMode.MULTI);
- }
- });
+ addButton("Multi", event -> grid.setSelectionMode(SelectionMode.MULTI));
- addButton("Disable", new Button.ClickListener() {
- @Override
- public void buttonClick(Button.ClickEvent event) {
- grid.setEnabled(!grid.isEnabled());
- }
- });
+ addButton("Disable", event -> grid.setEnabled(!grid.isEnabled()));
}
}
import com.vaadin.server.VaadinRequest;
import com.vaadin.tests.data.bean.Person;
import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickEvent;
import com.vaadin.ui.Grid;
import com.vaadin.ui.GridLayout;
import com.vaadin.ui.Label;
final Grid<Person> grid = createGrid();
grid.setSizeFull();
- addComponent(new Button("Toggle theme", new Button.ClickListener() {
-
- @Override
- public void buttonClick(ClickEvent event) {
- if (ValoTheme.THEME_NAME.equals(getUI().getTheme())) {
- getUI().setTheme(Reindeer.THEME_NAME);
- } else {
- getUI().setTheme(ValoTheme.THEME_NAME);
- }
+ addComponent(new Button("Toggle theme", event -> {
+ if (ValoTheme.THEME_NAME.equals(getUI().getTheme())) {
+ getUI().setTheme(Reindeer.THEME_NAME);
+ } else {
+ getUI().setTheme(ValoTheme.THEME_NAME);
}
}));
detailsLayout.addComponent(lbl4);
final Button button = new Button("Toggle visibility",
- new Button.ClickListener() {
-
- @Override
- public void buttonClick(ClickEvent event) {
- lbl4.setVisible(!lbl4.isVisible());
- }
- });
+ event -> lbl4.setVisible(!lbl4.isVisible()));
button.setId("btn");
detailsLayout.addComponent(button);
grid.setDetailsVisible(person, !grid.isDetailsVisible(person));
});
- addComponent(new Button("Open details", new Button.ClickListener() {
-
- @Override
- public void buttonClick(ClickEvent event) {
- for (Object itemId : ((ListDataProvider<?>) grid
- .getDataProvider()).getItems()) {
- if (itemId instanceof Person) {
- grid.setDetailsVisible((Person) itemId, true);
- }
+ addComponent(new Button("Open details", event -> {
+ for (Object itemId : ((ListDataProvider<?>) grid.getDataProvider())
+ .getItems()) {
+ if (itemId instanceof Person) {
+ grid.setDetailsVisible((Person) itemId, true);
}
}
}));
import com.vaadin.tests.util.Person;
import com.vaadin.tests.util.PersonContainer;
import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickEvent;
-import com.vaadin.ui.Button.ClickListener;
import com.vaadin.ui.CheckBox;
import com.vaadin.ui.Component;
import com.vaadin.ui.HorizontalLayout;
addComponent(grid);
addComponents(new HorizontalLayout(update(0), update(1), update(2)));
- Button refresh10 = new Button("Refresh 0-9", new ClickListener() {
- @Override
- public void buttonClick(ClickEvent event) {
- grid.refreshRows(container.getItemIds(0, 9).toArray());
- }
- });
+ Button refresh10 = new Button("Refresh 0-9",
+ event -> grid
+ .refreshRows(container.getItemIds(0, 9).toArray()));
refresh10.setId("refresh10");
addComponents(new HorizontalLayout(refresh(0), refresh(1), refresh(2),
- new Button("Refresh non-existant", new ClickListener() {
- @Override
- public void buttonClick(ClickEvent event) {
- grid.refreshRows("foobar");
- }
- })), refresh10);
+ new Button("Refresh non-existant",
+ event -> grid.refreshRows("foobar"))),
+ refresh10);
addComponents(new HorizontalLayout(style(0), style(1), style(2)));
}
}
private Component update(final int i) {
- Button button = new Button("Update " + i, new ClickListener() {
- @Override
- public void buttonClick(ClickEvent event) {
- Person p = container.getIdByIndex(i);
- p.setFirstName("!" + p.getFirstName());
- }
+ Button button = new Button("Update " + i, event -> {
+ Person p = container.getIdByIndex(i);
+ p.setFirstName("!" + p.getFirstName());
});
button.setId("update" + i);
return button;
}
protected Component refresh(final int i) {
- Button button = new Button("Refresh row " + i, new ClickListener() {
- @Override
- public void buttonClick(ClickEvent event) {
- grid.refreshRows(container.getIdByIndex(i));
- }
- });
+ Button button = new Button("Refresh row " + i,
+ event -> grid.refreshRows(container.getIdByIndex(i)));
button.setId("refresh" + i);
return button;
}
addComponent(grid);
Button detachButton = new Button("Detach grid",
- e -> removeComponent(grid));
+ event -> removeComponent(grid));
detachButton.setId("detach");
addComponent(detachButton);
for (int i = 0; i < 4; i++) {
final int idx = i;
- Button button = new Button("Remove col " + i, e -> {
+ Button button = new Button("Remove col " + i, event -> {
grid.removeColumn(grid.getColumns().get(idx));
logFrozenColumns();
});
}
textRenderer = !textRenderer;
}));
- addComponent(new Button("Reverse", e -> {
+ addComponent(new Button("Reverse", event -> {
if (reverse) {
grid.setColumnOrder(column, secondColumn);
} else {
protected void setup(VaadinRequest request) {
final Grid<Person> grid = getGrid();
addComponent(grid);
- addComponent(new Button("Sort first", e -> grid
+ addComponent(new Button("Sort first", event -> grid
.sort(grid.getColumn("name"), SortDirection.ASCENDING)));
addComponent(new Button("Sort both",
- e -> grid.setSortOrder(GridSortOrder.asc(grid.getColumn("name"))
+ event -> grid
+ .setSortOrder(GridSortOrder.asc(grid.getColumn("name"))
.thenAsc(grid.getColumn("age")))));
}
oldGrid.setHeightMode(
com.vaadin.v7.shared.ui.grid.HeightMode.UNDEFINED);
- layout.addComponents(grid, oldGrid, new Button("Add header row", e -> {
+ layout.addComponents(grid, oldGrid,
+ new Button("Add header row", event -> {
grid.appendHeaderRow();
oldGrid.appendHeaderRow();
}));
grid = createGrid(items);
addComponent(grid);
- addComponent(new Button("Recreate grid", e -> {
+ addComponent(new Button("Recreate grid", event -> {
Grid<ItemBean> newGrid = createGrid(items);
replaceComponent(grid, newGrid);
grid = newGrid;
cssLayout
.addComponent(new Button("Press me",
- e -> Notification.show("You clicked on the "
+ event -> Notification.show("You clicked on the "
+ "button in the details for " + "row "
+ dataObj.getRowNumber())));
return cssLayout;
public void menuSelected(MenuItem selectedItem) {
removeRegistration();
if (selectedItem.isChecked()) {
- registration = grid.addItemClickListener(e -> {
- grid.setDetailsVisible(e.getItem(),
- !grid.isDetailsVisible(e.getItem()));
- log("Item click on row " + e.getItem().getRowNumber()
- + ", Column '" + e.getColumn().getCaption()
+ registration = grid.addItemClickListener(event -> {
+ grid.setDetailsVisible(event.getItem(),
+ !grid.isDetailsVisible(event.getItem()));
+ log("Item click on row "
+ + event.getItem().getRowNumber() + ", Column '"
+ + event.getColumn().getCaption()
+ "'");
});
log("Registered an item click listener.");
.setCheckable(true);
MenuItem enableItem = stateMenu.addItem("Enabled",
- e -> grid.setEnabled(e.isChecked()));
+ event -> grid.setEnabled(event.isChecked()));
enableItem.setCheckable(true);
enableItem.setChecked(true);
.editRow(grid.getDataCommunicator().getDataProviderSize() - 1));
editorMenu.addItem("Change save caption",
- e -> grid.getEditor().setSaveCaption("ǝʌɐS"));
+ event -> grid.getEditor().setSaveCaption("ǝʌɐS"));
editorMenu.addItem("Change cancel caption",
- e -> grid.getEditor().setCancelCaption("ʃǝɔuɐↃ"));
+ event -> grid.getEditor().setCancelCaption("ʃǝɔuɐↃ"));
}
return new Button(
"Align " + topLeft.getVerticalAlignment() + ", "
+ topLeft.getHorizontalAlignment(),
- new Button.ClickListener() {
- @Override
- public void buttonClick(Button.ClickEvent clickEvent) {
- g.setComponentAlignment(g.getComponent(0, 0), topLeft);
- }
- });
+ event -> g.setComponentAlignment(g.getComponent(0, 0),
+ topLeft));
}
}
import com.vaadin.server.VaadinRequest;
import com.vaadin.tests.components.AbstractReindeerTestUI;
import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickEvent;
import com.vaadin.ui.GridLayout;
import com.vaadin.ui.HorizontalLayout;
import com.vaadin.ui.Label;
setExpandRatio();
addComponent(new Button("Hide/show both middle Column and row",
- new Button.ClickListener() {
- @Override
- public void buttonClick(ClickEvent event) {
- hideComponetns();
- }
- }));
+ event -> hideComponetns()));
}
private void hideComponetns() {
import com.vaadin.server.VaadinRequest;
import com.vaadin.tests.components.AbstractTestUIWithLog;
import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickEvent;
import com.vaadin.ui.GridLayout;
import com.vaadin.ui.Label;
import com.vaadin.ui.TextField;
addComponent(gl);
- addComponent(new Button("Show first", new Button.ClickListener() {
- @Override
- public void buttonClick(ClickEvent event) {
- t1.setVisible(true);
- l1.setVisible(true);
- }
+ addComponent(new Button("Show first", event -> {
+ t1.setVisible(true);
+ l1.setVisible(true);
}));
- addComponent(new Button("Show third", new Button.ClickListener() {
- @Override
- public void buttonClick(ClickEvent event) {
- t3.setVisible(true);
- l3.setVisible(true);
- }
+ addComponent(new Button("Show third", event -> {
+ t3.setVisible(true);
+ l3.setVisible(true);
}));
- addComponent(new Button("Show fifth", new Button.ClickListener() {
- @Override
- public void buttonClick(ClickEvent event) {
- t5.setVisible(true);
- l5.setVisible(true);
- }
+ addComponent(new Button("Show fifth", event -> {
+ t5.setVisible(true);
+ l5.setVisible(true);
}));
}
}
import com.vaadin.server.VaadinRequest;
import com.vaadin.tests.components.AbstractReindeerTestUI;
import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickEvent;
import com.vaadin.ui.GridLayout;
import com.vaadin.ui.HorizontalLayout;
import com.vaadin.ui.Label;
mainLayout
.addComponent(new Button("Hide/show both middle Column and row",
- new Button.ClickListener() {
- @Override
- public void buttonClick(ClickEvent event) {
- for (int i = 0; i < ROWS; i++) {
- for (int j = 0; j < COLS; j++) {
- if (j == 2 || i == 2) {
- if (labels[i][j].isVisible()) {
- labels[i][j].setVisible(false);
- } else {
- labels[i][j].setVisible(true);
- }
+ event -> {
+ for (int i = 0; i < ROWS; i++) {
+ for (int j = 0; j < COLS; j++) {
+ if (j == 2 || i == 2) {
+ if (labels[i][j].isVisible()) {
+ labels[i][j].setVisible(false);
+ } else {
+ labels[i][j].setVisible(true);
}
}
}
}
}));
mainLayout.addComponent(new Button("Hide/show middle Column",
- new Button.ClickListener() {
- @Override
- public void buttonClick(ClickEvent event) {
- for (int i = 0; i < ROWS; i++) {
- if (labels[i][2].isVisible()) {
- labels[i][2].setVisible(false);
- } else {
- labels[i][2].setVisible(true);
- }
+ event -> {
+ for (int i = 0; i < ROWS; i++) {
+ if (labels[i][2].isVisible()) {
+ labels[i][2].setVisible(false);
+ } else {
+ labels[i][2].setVisible(true);
}
}
}));
mainLayout.addComponent(
- new Button("Hide/show middle Row", new Button.ClickListener() {
- @Override
- public void buttonClick(ClickEvent event) {
- for (int j = 0; j < COLS; j++) {
- if (labels[2][j].isVisible()) {
- labels[2][j].setVisible(false);
- } else {
- labels[2][j].setVisible(true);
- }
+ new Button("Hide/show middle Row", event -> {
+ for (int j = 0; j < COLS; j++) {
+ if (labels[2][j].isVisible()) {
+ labels[2][j].setVisible(false);
+ } else {
+ labels[2][j].setVisible(true);
}
}
-
}));
mainLayout.addComponent(
- new Button("Hide Random button", new Button.ClickListener() {
-
- @Override
- public void buttonClick(ClickEvent event) {
- // TODO Auto-generated method stub
- Random rand = new Random();
- int i = rand.nextInt(ROWS);
- int j = rand.nextInt(COLS);
- if (labels[i][j].isVisible()) {
- labels[i][j].setVisible(false);
- } else {
- labels[i][j].setVisible(true);
- }
+ new Button("Hide Random button", event -> {
+ // TODO Auto-generated method stub
+ Random rand = new Random();
+ int i = rand.nextInt(ROWS);
+ int j = rand.nextInt(COLS);
+ if (labels[i][j].isVisible()) {
+ labels[i][j].setVisible(false);
+ } else {
+ labels[i][j].setVisible(true);
}
}));
}
import com.vaadin.server.VaadinRequest;
import com.vaadin.tests.components.AbstractReindeerTestUI;
import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickEvent;
import com.vaadin.ui.GridLayout;
import com.vaadin.ui.Label;
final GridLayout layout = new GridLayout(1, 2);
layout.addComponent(new Label("some row"), 0, 0);
Button newRowButton = new Button("Insert Row");
- newRowButton.addClickListener(new Button.ClickListener() {
- @Override
- public void buttonClick(ClickEvent event) {
- layout.insertRow(1);
- layout.addComponent(new Label("some new row"), 0, 1);
- }
+ newRowButton.addClickListener(event -> {
+ layout.insertRow(1);
+ layout.addComponent(new Label("some new row"), 0, 1);
});
layout.addComponent(newRowButton, 0, 1);
addComponent(layout);
import com.vaadin.tests.components.TestDateField;
import com.vaadin.ui.AbstractDateField;
import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickEvent;
-import com.vaadin.ui.Button.ClickListener;
import com.vaadin.ui.GridLayout;
import com.vaadin.ui.Panel;
gl.addComponent(df);
Button err = new Button("Set error");
- err.addClickListener(new ClickListener() {
-
- @Override
- public void buttonClick(ClickEvent event) {
- df.setComponentError(new UserError("foo"));
- }
- });
+ err.addClickListener(
+ event -> df.setComponentError(new UserError("foo")));
gl.addComponent(err);
err = new Button("Clear error");
- err.addClickListener(new ClickListener() {
-
- @Override
- public void buttonClick(ClickEvent event) {
- df.setComponentError(null);
- }
- });
+ err.addClickListener(event -> df.setComponentError(null));
gl.addComponent(err);
}
import com.vaadin.tests.components.AbstractReindeerTestUI;
import com.vaadin.ui.AbstractOrderedLayout;
import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickEvent;
import com.vaadin.ui.GridLayout;
import com.vaadin.ui.Label;
import com.vaadin.ui.VerticalLayout;
gl.setHeight("200px");
testButton = new Button("Click to move to inner layout",
- new Button.ClickListener() {
-
- @Override
- public void buttonClick(ClickEvent event) {
- vl.addComponent(testButton);
- }
- });
+ event -> vl.addComponent(testButton));
gl.addComponent(testButton);
addComponent(gl);
Button b = new Button("Repaint inner layout",
- new Button.ClickListener() {
-
- @Override
- public void buttonClick(ClickEvent event) {
- vl.markAsDirty();
- }
- });
+ event -> vl.markAsDirty());
addComponent(b);
}
import com.vaadin.server.ThemeResource;
import com.vaadin.tests.components.TestBase;
import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickEvent;
import com.vaadin.ui.Image;
public class ImageAltText extends TestBase {
addComponent(image);
Button changeAltTexts = new Button("Change alt text",
- new Button.ClickListener() {
- @Override
- public void buttonClick(ClickEvent event) {
- image.setAlternateText("New alt text!");
- }
- });
+ event -> image.setAlternateText("New alt text!"));
addComponent(changeAltTexts);
}
import javax.imageio.ImageIO;
-import com.vaadin.event.MouseEvents.ClickEvent;
-import com.vaadin.event.MouseEvents.ClickListener;
import com.vaadin.server.StreamResource;
import com.vaadin.tests.components.TestBase;
import com.vaadin.ui.Image;
final StreamResource imageResource = new StreamResource(imageSource,
"testimage.png");
image.setSource(imageResource);
- image.addClickListener(new ClickListener() {
-
- @Override
- public void click(ClickEvent event) {
- ++clickCounter;
- imageResource
- .setFilename("testimage.png?" + new Date().getTime());
- image.markAsDirty();
- label.setValue(labelText());
- }
-
+ image.addClickListener(event -> {
+ ++clickCounter;
+ imageResource.setFilename("testimage.png?" + new Date().getTime());
+ image.markAsDirty();
+ label.setValue(labelText());
});
addComponent(image);
-
}
private String labelText() {
@Override
protected void setup(VaadinRequest request) {
addComponent(new Button("Test",
- e -> addComponent(new ResultLabel("It works"))));
+ event -> addComponent(new ResultLabel("It works"))));
}
}
protected void setup(VaadinRequest request) {
StateTrackingComponent stateTrackingComponent = new StateTrackingComponent();
- Button setField2 = new Button("Set field2", e -> {
+ Button setField2 = new Button("Set field2", event -> {
stateTrackingComponent.getState().counter++;
stateTrackingComponent.getState().field2 = "updated value "
+ stateTrackingComponent.getState().counter;
});
setField2.setId("setField2");
- Button clearField1 = new Button("Clear field1", e -> {
+ Button clearField1 = new Button("Clear field1", event -> {
stateTrackingComponent.getState().counter++;
stateTrackingComponent.getState().field1 = null;
});
nativeSelect.addStyleName("custominitial");
addComponent(nativeSelect);
- Button button = new Button("Add style 'new'", e -> {
+ Button button = new Button("Add style 'new'", event -> {
testselect.addStyleName("new");
nativeSelect.addStyleName("new");
});
button.setId("add");
addComponent(button);
- button = new Button("Change primary style to 'newprimary'", e -> {
+ button = new Button("Change primary style to 'newprimary'", event -> {
testselect.setPrimaryStyleName("newprimary");
nativeSelect.setPrimaryStyleName("newprimary");
});
buttons.addComponents(
new Button("toString",
- e -> nativeSelect
+ event -> nativeSelect
.setItemCaptionGenerator(String::toString)),
new Button("Only number",
- e -> nativeSelect.setItemCaptionGenerator(
+ event -> nativeSelect.setItemCaptionGenerator(
str -> str.substring(7))),
- new Button("Declarative", e -> nativeSelect
+ new Button("Declarative", event -> nativeSelect
.setItemCaptionGenerator(declarative)));
}
}
protected void createListenerMenu() {
createListenerAction("Selection listener", "Listeners",
c -> c.addSelectionListener(
- e -> log("Selected: " + e.getSelectedItem())));
+ event -> log("Selected: " + event.getSelectedItem())));
}
private int getIndex(Object item) {
@Override
protected void setup(VaadinRequest request) {
final Slider slider = new Slider(0, 100, 1);
- slider.addValueChangeListener(e -> {
- Double value = e.getValue();
+ slider.addValueChangeListener(event -> {
+ Double value = event.getValue();
if (value < 100.0) {
slider.setValue(100.0);
}
import com.vaadin.tests.components.TestBase;
import com.vaadin.ui.Button;
import com.vaadin.v7.data.Item;
-import com.vaadin.v7.data.Property;
-import com.vaadin.v7.data.Property.ValueChangeEvent;
import com.vaadin.v7.data.util.IndexedContainer;
import com.vaadin.v7.ui.Table;
import com.vaadin.v7.ui.TextField;
final TextField tf = new TextField("Rows");
tf.setValue(String.valueOf(100000));
- tf.addListener(new Property.ValueChangeListener() {
- @Override
- public void valueChange(ValueChangeEvent event) {
- container.setSize(Integer.parseInt(tf.getValue().toString()));
- }
- });
+ tf.addValueChangeListener(event -> container
+ .setSize(Integer.parseInt(tf.getValue().toString())));
addComponent(tf);
addComponent(new Button("Update rowcount"));
import com.vaadin.ui.VerticalLayout;
import com.vaadin.v7.data.Container;
import com.vaadin.v7.data.Item;
-import com.vaadin.v7.data.Property.ValueChangeEvent;
import com.vaadin.v7.data.util.IndexedContainer;
import com.vaadin.v7.ui.Table;
table1.setImmediate(true);
layout1.addComponent(table1);
- table1.addListener(new Table.ValueChangeListener() {
- @Override
- public void valueChange(ValueChangeEvent event) {
- @SuppressWarnings("unchecked")
- Set<String> value = (Set<String>) table1.getValue();
- selected1.setValue(value + " TOTAL: " + value.size());
- }
+ table1.addValueChangeListener(event -> {
+ @SuppressWarnings("unchecked")
+ Set<String> value = (Set<String>) table1.getValue();
+ selected1.setValue(value + " TOTAL: " + value.size());
});
layout1.addComponent(selected1);
table2.setImmediate(true);
layout2.addComponent(table2);
- table2.addListener(new Table.ValueChangeListener() {
- @Override
- public void valueChange(ValueChangeEvent event) {
- String value = table2.getValue() == null ? "No selected items"
- : table2.getValue().toString();
- selected2.setValue(value);
- }
+ table2.addValueChangeListener(event -> {
+ String value = table2.getValue() == null ? "No selected items"
+ : table2.getValue().toString();
+ selected2.setValue(value);
});
layout2.addComponent(selected2);
table3.setImmediate(true);
layout3.addComponent(table3);
- table3.addListener(new Table.ValueChangeListener() {
- @Override
- public void valueChange(ValueChangeEvent event) {
- @SuppressWarnings("unchecked")
- Set<String> value = (Set<String>) table3.getValue();
- selected3.setValue(value.isEmpty() ? "No selected items"
- : value + ": Total " + value.size() + " items");
- }
+ table3.addValueChangeListener(event -> {
+ @SuppressWarnings("unchecked")
+ Set<String> value = (Set<String>) table3.getValue();
+ selected3.setValue(value.isEmpty() ? "No selected items"
+ : value + ": Total " + value.size() + " items");
});
selected3.setWidth("300px");
import com.vaadin.server.Sizeable;
import com.vaadin.tests.components.TestBase;
import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickEvent;
-import com.vaadin.ui.Button.ClickListener;
import com.vaadin.v7.data.util.BeanItemContainer;
import com.vaadin.v7.ui.Table;
getLayout().addComponent(t);
getLayout().addComponent(new Button("Change elements and selection",
- new ClickListener() {
+ event -> {
+ bic.removeAllItems();
+ ValueHolder<String> v4 = null;
+ for (int i = 4; i < 30; i++) {
+ v4 = new ValueHolder<>("test" + i);
+ bic.addBean(v4);
- @Override
- public void buttonClick(ClickEvent event) {
-
- bic.removeAllItems();
- ValueHolder<String> v4 = null;
- for (int i = 4; i < 30; i++) {
- v4 = new ValueHolder<>("test" + i);
- bic.addBean(v4);
-
- }
- t.select(t.firstItemId());
- t.focus();
}
+ t.select(t.firstItemId());
+ t.focus();
}));
}
import com.vaadin.shared.ui.MarginInfo;
import com.vaadin.tests.components.TestBase;
import com.vaadin.ui.Button;
-import com.vaadin.ui.Button.ClickEvent;
import com.vaadin.ui.Label;
import com.vaadin.ui.VerticalLayout;
import com.vaadin.v7.data.Item;
}
};
- Button.ClickListener clickListener = new Button.ClickListener() {
-
- @Override
- public void buttonClick(ClickEvent event) {
- Property nameProperty = table.getContainerProperty(0, NAME);
- if (("0").equals(nameLabel.getValue())) {
- nameProperty.setValue(NAME + "0-version2");
- nameLabel.setValue("0-version2");
- } else {
- nameProperty.setValue(NAME + 0);
- nameLabel.setValue("0");
- }
+ Button.ClickListener clickListener = event -> {
+ Property nameProperty = table.getContainerProperty(0, NAME);
+ if (("0").equals(nameLabel.getValue())) {
+ nameProperty.setValue(NAME + "0-version2");
+ nameLabel.setValue("0-version2");
+ } else {
+ nameProperty.setValue(NAME + 0);
+ nameLabel.setValue("0");
}
};
tree.setDataProvider(inMemoryDataProvider);
tree.addSelectionListener(
- e -> log("SelectionEvent: " + e.getAllSelectedItems()));
+ event -> log("SelectionEvent: " + event.getAllSelectedItems()));
- tree.addExpandListener(e -> log("ExpandEvent: " + e.getExpandedItem()));
+ tree.addExpandListener(
+ event -> log("ExpandEvent: " + event.getExpandedItem()));
tree.addCollapseListener(
- e -> log("ExpandEvent: " + e.getCollapsedItem()));
+ event -> log("ExpandEvent: " + event.getCollapsedItem()));
layout.addComponents(createMenu(), tree);
if (selectedItem.isChecked()) {
registration = tree.addItemClickListener(
- e -> log("ItemClick: " + e.getItem()));
+ event -> log("ItemClick: " + event.getItem()));
}
}
tree.expand("Foo");
addComponent(tree);
- addComponent(new Button("Toggle auto recalc", e -> tree
+ addComponent(new Button("Toggle auto recalc", event -> tree
.setAutoRecalculateWidth(!tree.isAutoRecalculateWidth())));
}
protected void init(VaadinRequest vaadinRequest) {
Button button = new Button(BUTTON_CAPTION);
- button.addClickListener(e -> {
+ button.addClickListener(event -> {
gc();
long memory = Runtime.getRuntime().totalMemory();
System.out.println("Before: " + memory);
private static void updatePanel(CssLayout panel, List<String> items) {
panel.removeAllComponents();
- items.forEach(i -> panel.addComponent(new Button(i, e -> {
+ items.forEach(i -> panel.addComponent(new Button(i, event -> {
Window w = new Window();
UI.getCurrent().addWindow(w);
})));
center.addClickListener(event -> w.center());
((ComponentContainer) w.getContent()).addComponent(center);
- w.addCloseListener(e -> {
+ w.addCloseListener(event -> {
windowList.add(w);
addWindowAgain.setItems(windowList);
});
grid.addColumn(Object::toString).setCaption("toString");
addComponent(grid);
addComponent(new Button("Replace item",
- e -> dataProvider.refreshItem(new Bean("Bar", 10))));
- addComponent(new Button("Select old", e -> grid.select(foo)));
+ event -> dataProvider.refreshItem(new Bean("Bar", 10))));
+ addComponent(new Button("Select old", event -> grid.select(foo)));
}
}
HorizontalLayout controls = new HorizontalLayout();
addComponent(controls);
controls.addComponent(
- new Button("Select Foo 20", e -> dummy.setValue("Foo " + 20)));
+ new Button("Select Foo 20",
+ event -> dummy.setValue("Foo " + 20)));
controls.addComponent(new Button("Reset data provider",
- e -> dummy.setDataProvider(new LoggingDataProvider(items))));
+ event -> dummy
+ .setDataProvider(new LoggingDataProvider(items))));
controls.addComponent(
- new Button("Remove all data", e -> dummy.setDataProvider(
+ new Button("Remove all data", event -> dummy.setDataProvider(
new LoggingDataProvider(Collections.emptyList()))));
addComponent(dummy);
}
dragSource.setPayload("card_value", cardValue);
// Add listeners
- dragSource.addDragStartListener(e -> log(
- e.getComponent().getValue() + " dragstart, effectsAllowed="
- + e.getEffectAllowed()));
+ dragSource.addDragStartListener(event -> log(
+ event.getComponent().getValue() + " dragstart, effectsAllowed="
+ + event.getEffectAllowed()));
- dragSource.addDragEndListener(e -> log(e.getComponent().getValue()
- + " dragend, dropEffect=" + e.getDropEffect()));
+ dragSource
+ .addDragEndListener(event -> log(event.getComponent().getValue()
+ + " dragend, dropEffect=" + event.getDropEffect()));
sources.add(dragSource);
}
static Component createGrid() {
Grid grid = new Grid();
- grid.addColumn(e -> "foo");
+ grid.addColumn(event -> "foo");
return grid;
}
ComboBox<String> comboBox = new ComboBox<>("", ITEMS);
comboBox.setTextInputAllowed(false);
comboBox.addValueChangeListener(
- e -> addComponent(new Label("Value is now: " + e.getValue())));
+ event -> addComponent(
+ new Label("Value is now: " + event.getValue())));
addComponent(comboBox);
}
combobox.setItems(options);
layout.addComponent(combobox);
- combobox.addValueChangeListener(e -> layout.addComponent(
- new Label("Value is now '" + e.getValue() + "'")));
+ combobox.addValueChangeListener(event -> layout.addComponent(
+ new Label("Value is now '" + event.getValue() + "'")));
}
@Override
addComponent(checkBox);
Notification notification = Notification.show("something");
- notification.addCloseListener(e -> checkBox.setValue(true));
+ notification.addCloseListener(event -> checkBox.setValue(true));
}
@Override
input = new TextField("Enter a value");
input.setId("input");
Button navigateAway = new Button("Navigate to the other view",
- e -> getUI().getNavigator().navigateTo("other"));
- Button logout = new Button("Simulate logout", e -> getUI()
+ event -> getUI().getNavigator().navigateTo("other"));
+ Button logout = new Button("Simulate logout", event -> getUI()
.getNavigator().runAfterLeaveConfirmation(() -> {
removeAllComponents();
addComponent(new Label("You have been logged out"));
VerticalLayout layout = new VerticalLayout();
layout.addComponent(new Label(
"You have unsaved changes. Are you sure you want to leave?"));
- Button leave = new Button("YES, LEAVE!", e -> {
+ Button leave = new Button("YES, LEAVE!", event -> {
close();
action.run();
});
leave.setId("leave");
- Button stay = new Button("NO, STAY!", e -> close());
+ Button stay = new Button("NO, STAY!", event -> close());
stay.setId("stay");
layout.addComponents(new HorizontalLayout(leave, stay));
setContent(layout);
@Override
protected void setup(VaadinRequest request) {
Button b = new MyButton();
- b.addClickListener(e -> getPage().getJavaScript()
+ b.addClickListener(event -> getPage().getJavaScript()
.execute("document.body.innerHTML=window.jsFile;\n"));
addComponent(b);
}
@Test
public void testDisabled() {
List<String> optionsCssClasses = getSelect().getOptionElements()
- .stream().map(e -> e.getAttribute("class"))
+ .stream().map(event -> event.getAttribute("class"))
.collect(Collectors.toList());
for (int i = 0; i < optionsCssClasses.size(); i++) {
String cssClassList = optionsCssClasses.get(i);
private List<String> getSelectedValues() {
Select select = new Select(
getListSelect().findElement(By.tagName("select")));
- return select.getAllSelectedOptions().stream().map(e -> e.getText())
+ return select.getAllSelectedOptions().stream()
+ .map(event -> event.getText())
.collect(Collectors.toList());
}
private static final Predicate<TestBenchElement> THEME_RESOURCE =
e -> e.isElementPresent(By.tagName("img"))
- && e.findElement(By.tagName("img")).getAttribute("src")
+ && e.findElement(By.tagName("img")).getAttribute("src")
.contains("bullet.png");
private static final Predicate<TestBenchElement> VAADIN_ICON =
- e -> e.isElementPresent(By.className("v-icon"))
- && e.findElement(By.className("v-icon")).getAttribute("class")
+ e -> e.isElementPresent(By.className("v-icon")) && e
+ .findElement(By.className("v-icon")).getAttribute("class")
.contains("Vaadin-Icons");
private static final Predicate<TestBenchElement> CLASS_RESOURCE =
e -> e.isElementPresent(By.tagName("img"))
- && e.findElement(By.tagName("img")).getAttribute("src")
+ && e.findElement(By.tagName("img")).getAttribute("src")
.contains("m.gif");
@Before
projects / vaadin-framework.git / commitdiff