protected void extend(ServerConnector target) {
// NOOP
}
-
}
}
/**
- * Custom implementation of the custom grid column using a JSONObject to
+ * Custom implementation of the custom grid column using a JSONObject to
* represent the cell value and String as a column type.
*/
private class CustomGridColumn extends Grid.Column<Object, JsonObject> {
import java.util.ArrayList;
import java.util.Collection;
+import java.util.logging.Logger;
import com.google.gwt.core.client.JavaScriptObject;
import com.google.gwt.core.client.JsArrayString;
+ " must have a function named 'render'");
}
+ if (hasFunction("destory")) {
+ getLogger().severe("Your JavaScript connector ("
+ + helper.getInitFunctionName()
+ + ") has a typo. The destory method should be renamed to destroy.");
+
+ }
+
final boolean hasInit = hasFunction("init");
- final boolean hasDestroy = hasFunction("destroy");
+ final boolean hasDestroy = hasFunction("destroy")
+ || hasFunction("destory");
final boolean hasOnActivate = hasFunction("onActivate");
final boolean hasGetConsumedEvents = hasFunction("getConsumedEvents");
final boolean hasOnBrowserEvent = hasFunction("onBrowserEvent");
@Override
public void destroy(RendererCellReference cell) {
if (hasDestroy) {
- destory(helper.getConnectorWrapper(), getJsCell(cell));
+ destroy(helper.getConnectorWrapper(), getJsCell(cell));
} else {
super.destroy(cell);
}
}
- private native void destory(JavaScriptObject wrapper,
+ private native void destroy(JavaScriptObject wrapper,
JavaScriptObject cell)
/*-{
- wrapper.destory(cell);
+ if (wrapper.destroy) {
+ wrapper.destroy(cell);
+ } else {
+ wrapper.destory(cell);
+ }
}-*/;
@Override
};
}
+ private Logger getLogger() {
+ return Logger.getLogger(JavaScriptRendererConnector.class.getName());
+ }
+
@Override
public Object decode(JsonValue value) {
// Let the js logic decode the raw json that the server sent
import java.util.HashSet;
import java.util.List;
import java.util.Set;
+import java.util.logging.Logger;
import com.google.gwt.event.shared.HandlerRegistration;
import com.google.gwt.user.client.ui.CheckBox;
import com.vaadin.v7.client.widget.grid.DataAvailableHandler;
import com.vaadin.v7.client.widget.grid.events.SelectAllEvent;
import com.vaadin.v7.client.widget.grid.events.SelectAllHandler;
+import com.vaadin.v7.client.widget.grid.selection.HasUserSelectionAllowed;
import com.vaadin.v7.client.widget.grid.selection.MultiSelectionRenderer;
import com.vaadin.v7.client.widget.grid.selection.SelectionModel;
import com.vaadin.v7.client.widget.grid.selection.SelectionModel.Multi;
import com.vaadin.v7.client.widget.grid.selection.SpaceSelectHandler;
import com.vaadin.v7.client.widgets.Grid;
+import com.vaadin.v7.client.widgets.Grid.Column;
import com.vaadin.v7.client.widgets.Grid.HeaderCell;
+import com.vaadin.v7.client.widgets.Grid.SelectionColumn;
import com.vaadin.v7.shared.ui.grid.GridState;
import com.vaadin.v7.shared.ui.grid.selection.MultiSelectionModelServerRpc;
import com.vaadin.v7.shared.ui.grid.selection.MultiSelectionModelState;
}
}
+ @OnStateChange("userSelectionAllowed")
+ void updateUserSelectionAllowed() {
+ if (selectionModel instanceof HasUserSelectionAllowed) {
+ ((HasUserSelectionAllowed) selectionModel)
+ .setUserSelectionAllowed(getState().userSelectionAllowed);
+ } else {
+ getLogger().warning("userSelectionAllowed set to "
+ + getState().userSelectionAllowed
+ + " but the selection model does not implement "
+ + HasUserSelectionAllowed.class.getSimpleName());
+ }
+ }
+
+ private static Logger getLogger() {
+ return Logger.getLogger(MultiSelectionModelConnector.class.getName());
+ }
+
+ /**
+ * The default multi selection model used for this connector.
+ *
+ */
protected class MultiSelectionModel extends AbstractSelectionModel
- implements SelectionModel.Multi.Batched<JsonObject> {
+ implements SelectionModel.Multi.Batched<JsonObject>,
+ HasUserSelectionAllowed<JsonObject> {
private ComplexRenderer<Boolean> renderer = null;
private Set<RowHandle<JsonObject>> selected = new HashSet<RowHandle<JsonObject>>();
private HandlerRegistration dataAvailable;
private Range availableRows;
private boolean batchSelect = false;
+ private boolean userSelectionAllowed = true;
@Override
public void setGrid(Grid<JsonObject> grid) {
public Collection<JsonObject> getDeselectedRowsBatch() {
return Collections.unmodifiableSet(getRows(deselected));
}
+
+ @Override
+ public boolean isUserSelectionAllowed() {
+ return userSelectionAllowed;
+ }
+
+ @Override
+ public void setUserSelectionAllowed(boolean userSelectionAllowed) {
+ this.userSelectionAllowed = userSelectionAllowed;
+ for (Column<?, JsonObject> c : getGrid().getColumns()) {
+ if (c instanceof SelectionColumn) {
+ ((SelectionColumn) c)
+ .setUserSelectionAllowed(userSelectionAllowed);
+ }
+ }
+ }
}
}
*/
package com.vaadin.v7.client.connectors;
+import java.util.logging.Logger;
+
import com.vaadin.client.ServerConnector;
import com.vaadin.client.annotations.OnStateChange;
import com.vaadin.client.data.DataSource.RowHandle;
import com.vaadin.shared.ui.Connect;
import com.vaadin.v7.client.renderers.Renderer;
import com.vaadin.v7.client.widget.grid.selection.ClickSelectHandler;
+import com.vaadin.v7.client.widget.grid.selection.HasUserSelectionAllowed;
import com.vaadin.v7.client.widget.grid.selection.SelectionModel;
import com.vaadin.v7.client.widget.grid.selection.SelectionModel.Single;
import com.vaadin.v7.client.widget.grid.selection.SpaceSelectHandler;
selectionModel.setDeselectAllowed(getState().deselectAllowed);
}
+ @OnStateChange("userSelectionAllowed")
+ void updateUserSelectionAllowed() {
+
+ if (selectionModel instanceof HasUserSelectionAllowed) {
+ ((HasUserSelectionAllowed) selectionModel)
+ .setUserSelectionAllowed(getState().userSelectionAllowed);
+ } else {
+ getLogger().warning("userSelectionAllowed set to "
+ + getState().userSelectionAllowed
+ + " but the selection model does not implement "
+ + HasUserSelectionAllowed.class.getSimpleName());
+ }
+ }
+
+ private static Logger getLogger() {
+ return Logger.getLogger(SingleSelectionModelConnector.class.getName());
+ }
+
/**
* SingleSelectionModel without a selection column renderer.
*/
public class SingleSelectionModel extends AbstractSelectionModel
- implements SelectionModel.Single<JsonObject> {
+ implements SelectionModel.Single<JsonObject>,
+ HasUserSelectionAllowed<JsonObject> {
private RowHandle<JsonObject> selectedRow;
private boolean deselectAllowed;
+ private boolean userSelectionAllowed = true;
@Override
public Renderer<Boolean> getSelectionColumnRenderer() {
@Override
public boolean deselect(JsonObject row) {
- if (getRowHandle(row).equals(selectedRow)) {
- select(null);
+ if (isSelected(row)) {
+ // If no selection has happened client side, then selectedRow is
+ // null but must be set so that a deselection event with the
+ // correct key can be sent to the server
+ selectedRow = getRowHandle(row);
+ selectedRow.pin();
+
+ return select(null);
}
return false;
}
public boolean isDeselectAllowed() {
return deselectAllowed;
}
+
+ @Override
+ public boolean isUserSelectionAllowed() {
+ return userSelectionAllowed;
+ }
+
+ @Override
+ public void setUserSelectionAllowed(boolean userSelectionAllowed) {
+ this.userSelectionAllowed = userSelectionAllowed;
+ }
}
-}
\ No newline at end of file
+}
*/
public class ImageRenderer extends ClickableRenderer<String, Image> {
- public static final String TRANSPARENT_GIF_1PX = "data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACwAAAAAAQABAAACAkQBADs=";
+ public static final String TRANSPARENT_GIF_1PX = "data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7";
@Override
public Image createWidget() {
private ListBox createListBox() {
ListBox lb = new ListBox();
- lb.setStyleName("v-select");
+ lb.setStyleName(VNativeSelect.CLASSNAME);
lb.addChangeHandler(this);
lb.addBlurHandler(VCalendarPanel.this);
lb.addFocusHandler(VCalendarPanel.this);
};
private class IconWidget extends Widget {
+ private Icon icon;
+
IconWidget(Icon icon) {
+ this.icon = icon;
setElement(icon.getElement());
addDomHandler(VFilterSelect.this, ClickEvent.getType());
}
afterSelectedItemIconChange();
}
} else {
+ IconWidget newIcon = new IconWidget(client.getIcon(iconUri));
+ if (iconEquals(newIcon, selectedItemIcon)) {
+ /*
+ * Do not update the icon if nothing has changed. Otherwise we
+ * can cause problems such as not being able to click in the
+ * icon to open the popup (blur might occur and call this
+ * method, icon is replaced and the click event is not delivered
+ * to the new icon)
+ */
+ return;
+ }
+
if (selectedItemIcon != null) {
panel.remove(selectedItemIcon);
}
- selectedItemIcon = new IconWidget(client.getIcon(iconUri));
+
// Older IE versions don't scale icon correctly if DOM
// contains height and width attributes.
- selectedItemIcon.getElement().removeAttribute("height");
- selectedItemIcon.getElement().removeAttribute("width");
- selectedItemIcon.addDomHandler(new LoadHandler() {
+ newIcon.getElement().removeAttribute("height");
+ newIcon.getElement().removeAttribute("width");
+ newIcon.addDomHandler(new LoadHandler() {
@Override
public void onLoad(LoadEvent event) {
afterSelectedItemIconChange();
}
}, LoadEvent.getType());
- panel.insert(selectedItemIcon, 0);
+ panel.insert(newIcon, 0);
+ selectedItemIcon = newIcon;
afterSelectedItemIconChange();
}
}
+ /**
+ * Checks if the icon widgets show the same icon.
+ *
+ * @param icon1
+ * the first widget
+ * @param icon2
+ * the second widget
+ * @return <code>true</code> if they show the same icon, <code>false</code>
+ * otherwise
+ */
+ private static boolean iconEquals(IconWidget icon1, IconWidget icon2) {
+ if (icon1 == null) {
+ return icon2 == null;
+ } else if (icon2 == null) {
+ return false;
+ } else {
+ return icon1.icon.getUri().equals(icon2.icon.getUri());
+ }
+
+ }
+
private void afterSelectedItemIconChange() {
if (BrowserInfo.get().isWebkit() || BrowserInfo.get().isIE8()) {
// Some browsers need a nudge to reposition the text field
}
} else if (currentSuggestion != null) {
setPromptingOff(currentSuggestion.caption);
+ setSelectedItemIcon(currentSuggestion.getIconUri());
}
}
removeStyleDependentName("focus");
}
}
+ // Vaadin 8 does not support IE8, no override for setText
}
private boolean readonly;
+ // Intentional removal of cols in compatibility package
+
/** For internal use only. May be removed or replaced in the future. */
public int rows = 0;
return nullSelectionItemAvailable;
}
+ // Intentional removal of getColumns in compatibility package
+
/**
* For internal use only. May be removed or replaced in the future.
*
* selector.
*
* <b>Note:</b> To change the keyboard assignments used in the popup dialog you
- * should extend <code>com.vaadin.v7.client.ui.VCalendarPanel</code> and then
- * pass set it by calling the
+ * should extend <code>VCalendarPanel</code> and then pass set it by calling the
* <code>setCalendarPanel(VCalendarPanel panel)</code> method.
*
*/
* Sets the state of the text field of this component. By default the text
* field is enabled. Disabling it causes only the button for date selection
* to be active, thus preventing the user from entering invalid dates. See
- * {@link http://dev.vaadin.com/ticket/6790}.
+ * <a href="http://dev.vaadin.com/ticket/6790">6790</a>.
*
- * @param state
+ * @param textFieldEnabled
*/
public void setTextFieldEnabled(boolean textFieldEnabled) {
this.textFieldEnabled = textFieldEnabled;
}
}
- /*
- * (non-Javadoc)
- *
- * @see
- * com.google.gwt.user.client.ui.UIObject#setStyleName(java.lang.String)
- */
@Override
public void setStyleName(String style) {
super.setStyleName(style);
}
}
- /*
- * (non-Javadoc)
- *
- * @see
- * com.google.gwt.event.dom.client.ClickHandler#onClick(com.google.gwt.event
- * .dom.client.ClickEvent)
- */
@Override
public void onClick(ClickEvent event) {
if (event.getSource() == calendarToggle && isEnabled()) {
}
}
- /*
- * (non-Javadoc)
- *
- * @see
- * com.google.gwt.event.logical.shared.CloseHandler#onClose(com.google.gwt
- * .event.logical.shared.CloseEvent)
- */
@Override
public void onClose(CloseEvent<PopupPanel> event) {
if (event.getSource() == popup) {
buildDate();
}
- /*
- * (non-Javadoc)
- *
- * @see com.vaadin.client.ui.VDateField#onBrowserEvent(com.google
- * .gwt.user.client.Event)
- */
@Override
public void onBrowserEvent(com.google.gwt.user.client.Event event) {
super.onBrowserEvent(event);
* and it depends on the current resolution, what is considered inside the
* range.
*
- * @param startDate
+ * @param rangeStart
* - the allowed range's start date
*/
public void setRangeStart(Date rangeStart) {
* Sets the end range for this component. The end range is inclusive, and it
* depends on the current resolution, what is considered inside the range.
*
- * @param endDate
+ * @param rangeEnd
* - the allowed range's end date
*/
public void setRangeEnd(Date rangeEnd) {
}
} else {
c.setText(caption);
+ // IE10 is no longer supported
}
c.setSorted(false);
if (info.isSafari()) {
return true;
}
+ // Vaadin 8 no longer supports IE10
if (info.isIE11() || info.isEdge()) {
return true;
}
/** For internal use only. May be removed or replaced in the future. */
public void clearInternalWidths() {
+ // Intentional removal of cols in compatibility package
int cols = DEFAULT_COLUMN_COUNT;
if (cols >= 0) {
private static native void setEncoding(Element form, String encoding)
/*-{
form.enctype = encoding;
+ // IE8 not supported in Vaadin 8
}-*/;
/** For internal use only. May be removed or replaced in the future. */
@Override
public boolean isReadOnly() {
+ // Class hierarchy has changed for FormConnector
return getState().readOnly || getState().propertyReadOnly;
}
getWidget().selectedKeys = uidl.getStringArrayVariableAsSet("selected");
getWidget().setReadonly(isReadOnly());
+ // Intentional change to use state over UIDL in compatibility package
getWidget().multiselect = getState().multiSelect;
getWidget().immediate = getState().immediate;
getWidget().nullSelectionAllowed = uidl
getWidget().nullSelectionItemAvailable = uidl
.getBooleanAttribute("nullselectitem");
+ // Support for cols has been dropped.
+
if (uidl.hasAttribute("rows")) {
getWidget().rows = uidl.getIntAttribute("rows");
}
final UIDL ops = uidl.getChildUIDL(0);
+ // Method getColumns has been removed
+
getWidget().buildOptions(ops);
if (uidl.getBooleanAttribute("allownewitem")) {
@Override
public void updateFromUIDL(UIDL uidl, ApplicationConnection client) {
+ // HTML Content has been moved to state.
super.updateFromUIDL(uidl, client);
getWidget().sendFocusEvents = client.hasEventListeners(this,
public void updateEnabledState(boolean enabledState) {
super.updateEnabledState(enabledState);
getWidget().enabled = isEnabled();
+
+ // IE8 is no longer supported
}
@Override
Scheduler.get().scheduleFinally(new ScheduledCommand() {
@Override
public void execute() {
+ // IE8 is no longer supported
getLayoutManager().setNeedsMeasure(TableConnector.this);
ServerConnector parent = getParent();
if (parent instanceof ComponentConnector) {
if (uidl.hasAttribute("partialUpdate")) {
handleUpdate(uidl);
+ // IE8 is no longer supported with Vaadin 8
+
getWidget().rendering = false;
return;
}
getWidget().focusedNode.setFocused(false);
}
+ // IE8 is no longer supported with Vaadin 8
+
getWidget().rendering = false;
}
private HandlerRegistration scrollSizeTemporaryScrollHandler;
private HandlerRegistration offsetSizeTemporaryScrollHandler;
+ private HandlerRegistration scrollInProgress;
private ScrollbarBundle() {
root.appendChild(scrollSizeElement);
boolean offsetSizeBecomesGreaterThanScrollSize = showsScrollHandle()
&& newOffsetSizeIsGreaterThanScrollSize;
if (offsetSizeBecomesGreaterThanScrollSize && getScrollPos() != 0) {
+ if (offsetSizeTemporaryScrollHandler != null) {
+ offsetSizeTemporaryScrollHandler.removeHandler();
+ }
// must be a field because Java insists.
offsetSizeTemporaryScrollHandler = addScrollHandler(
new ScrollHandler() {
scrollPos = Math.max(0, Math.min(maxScrollPos, truncate(px)));
if (!WidgetUtil.pixelValuesEqual(oldScrollPos, scrollPos)) {
+ if (scrollInProgress == null) {
+ // Only used for tracking that there is "workPending"
+ scrollInProgress = addScrollHandler(new ScrollHandler() {
+ @Override
+ public void onScroll(ScrollEvent event) {
+ scrollInProgress.removeHandler();
+ scrollInProgress = null;
+ }
+ });
+ }
+
if (isInvisibleScrollbar) {
invisibleScrollbarTemporaryResizer.show();
}
* This needs to be made step-by-step because IE8 flat-out refuses to
* fire a scroll event when the scroll size becomes smaller than the
* offset size. All other browser need to suffer alongside.
- *
+ *
* This really should be changed to not use any temporary scroll
* handlers at all once IE8 support is dropped, like now done only for
* Firefox.
* 'delayedSizeSet'
*/
boolean delayedSizeSet = !BrowserInfo.get().isFirefox();
+ // must be a field because Java insists.
if (delayedSizeSet) {
+ if (scrollSizeTemporaryScrollHandler != null) {
+ scrollSizeTemporaryScrollHandler.removeHandler();
+ }
scrollSizeTemporaryScrollHandler = addScrollHandler(
new ScrollHandler() {
@Override
// requestAnimationFrame - which is not automatically checked
return scrollSizeTemporaryScrollHandler != null
|| offsetSizeTemporaryScrollHandler != null
- || scrollEventFirer.isBeingFired;
+ || scrollInProgress != null || scrollEventFirer.isBeingFired;
}
}
public int getRowIndex();
/**
- * Returns the index of the column being focused.
+ * Returns the DOM index of the column being focused.
*
- * @return the column index
+ * @return the column index (excluding hidden columns)
*/
public int getColumnIndex();
/**
* Attempts to handle the given grid event.
*
- * @param gridEvent
+ * @param event
* the event that occurred
*/
- public void onEvent(GridEvent<T> gridEvent);
-}
\ No newline at end of file
+ public void onEvent(GridEvent<T> event);
+}
@Override
public void onClick(GridClickEvent event) {
+ if (!grid.isUserSelectionAllowed()) {
+ return;
+ }
+
T row = (T) event.getTargetCell().getRow();
if (!grid.isSelected(row)) {
grid.select(row);
--- /dev/null
+/*
+ * Copyright 2000-2016 Vaadin Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.vaadin.v7.client.widget.grid.selection;
+
+/**
+ * Interface implemented by selection models which support disabling client side
+ * selection while still allowing programmatic selection on the server.
+ *
+ * @param <T>
+ * Grid's row type
+ *
+ * @since 7.7.7
+ */
+public interface HasUserSelectionAllowed<T> extends SelectionModel<T> {
+
+ /**
+ * Checks if the user is allowed to change the selection.
+ *
+ * @return <code>true</code> if the user is allowed to change the selection,
+ * <code>false</code> otherwise
+ */
+ public boolean isUserSelectionAllowed();
+
+ /**
+ * Sets whether the user is allowed to change the selection.
+ *
+ * @param userSelectionAllowed
+ * <code>true</code> if the user is allowed to change the
+ * selection, <code>false</code> otherwise
+ */
+ public void setUserSelectionAllowed(boolean userSelectionAllowed);
+
+}
public void render(final RendererCellReference cell, final Boolean data,
CheckBox checkBox) {
checkBox.setValue(data, false);
- checkBox.setEnabled(grid.isEnabled() && !grid.isEditorActive());
+ checkBox.setEnabled(grid.isEnabled() && !grid.isEditorActive()
+ && grid.isUserSelectionAllowed());
}
@Override
}
protected void setSelected(final int logicalRow, final boolean select) {
+ if (!grid.isUserSelectionAllowed()) {
+ return;
+ }
+
T row = grid.getDataSource().getRow(logicalRow);
if (select) {
grid.select(row);
* @since 7.4
*/
public class SelectionModelMulti<T> extends AbstractRowHandleSelectionModel<T>
- implements SelectionModel.Multi.Batched<T> {
+ implements SelectionModel.Multi.Batched<T>, HasUserSelectionAllowed<T> {
private final LinkedHashSet<RowHandle<T>> selectedRows;
private Renderer<Boolean> renderer;
/* Event handling for selection with space key */
private SpaceSelectHandler<T> spaceSelectHandler;
+ private boolean userSelectionAllowed = true;
public SelectionModelMulti() {
grid = null;
}
return rows;
}
+
+ @Override
+ public boolean isUserSelectionAllowed() {
+ return userSelectionAllowed;
+ }
+
+ @Override
+ public void setUserSelectionAllowed(boolean userSelectionAllowed) {
+ this.userSelectionAllowed = userSelectionAllowed;
+ }
}
* @since 7.4
*/
public class SelectionModelSingle<T> extends AbstractRowHandleSelectionModel<T>
- implements SelectionModel.Single<T> {
+ implements SelectionModel.Single<T>, HasUserSelectionAllowed<T> {
private Grid<T> grid;
private RowHandle<T> selectedRow;
private ClickSelectHandler<T> clickSelectHandler;
private boolean deselectAllowed = true;
+ private boolean userSelectionAllowed = true;
@Override
public boolean isSelected(T row) {
}
}
+ @Override
+ public boolean isUserSelectionAllowed() {
+ return userSelectionAllowed;
+ }
+
+ @Override
+ public void setUserSelectionAllowed(boolean userSelectionAllowed) {
+ this.userSelectionAllowed = userSelectionAllowed;
+ }
}
@Override
public void onKeyDown(GridKeyDownEvent event) {
+ if (!grid.isUserSelectionAllowed()) {
+ return;
+ }
+
if (event.getNativeKeyCode() != KeyCodes.KEY_SPACE || spaceDown) {
return;
}
static class JsniUtil {
public static class TouchHandlerBundle {
+ public static final String POINTER_EVENT_TYPE_TOUCH = "touch";
+
/**
* A <a href=
* "http://www.gwtproject.org/doc/latest/DevGuideCodingBasicsOverlay.html"
/*-{
return this.targetTouches[0].pageY;
}-*/;
+
+ public native String getPointerType()
+ /*-{
+ return this.pointerType;
+ }-*/;
}
private final Escalator escalator;
}
int pagePosition(CustomTouchEvent event) {
+ // Use native event's screen x and y for IE11 and Edge
+ // since there is no touches for these browsers (#18737)
+ if (isCurrentBrowserIE11OrEdge()) {
+ return vertical
+ ? event.getNativeEvent().getClientY()
+ + Window.getScrollTop()
+ : event.getNativeEvent().getClientX()
+ + Window.getScrollLeft();
+ }
JsArray<Touch> a = event.getNativeEvent().getTouches();
return vertical ? a.get(0).getPageY() : a.get(0).getPageX();
}
};
public void touchStart(final CustomTouchEvent event) {
- if (event.getNativeEvent().getTouches().length() == 1) {
+ if (allowTouch(event)) {
if (yMov == null) {
yMov = new Movement(true);
xMov = new Movement(false);
}
}
+ // Allow touchStart for IE11 and Edge even though there is no touch
+ // (#18737),
+ // otherwise allow touch only if there is a single touch in the
+ // event
+ private boolean allowTouch(
+ final TouchHandlerBundle.CustomTouchEvent event) {
+ if (isCurrentBrowserIE11OrEdge()) {
+ return (POINTER_EVENT_TYPE_TOUCH
+ .equals(event.getPointerType()));
+ } else {
+ return (event.getNativeEvent().getTouches().length() == 1);
+ }
+ }
+
private double easingInOutCos(double val, double max) {
return 0.5 - 0.5 * Math.cos(Math.PI * Math.signum(val)
* Math.min(Math.abs(val), max) / max);
if (position instanceof AbsolutePosition) {
/*
* we don't want to put "top: 0" on the footer, since it'll
- * render wrong, as we already have "bottom: $footer-height"
- * .
+ * render wrong, as we already have
+ * "bottom: $footer-height".
*/
footElem.getStyle().setLeft(-scrollLeft, Unit.PX);
} else {
public native void detachScrollListener(Element element)
/*
- * Attaching events with JSNI instead of the GWT event mechanism because
+ * Detaching events with JSNI instead of the GWT event mechanism because
* GWT didn't provide enough details in events, or triggering the event
* handlers with GWT bindings was unsuccessful. Maybe, with more time
* and skill, it could be done with better success. JavaScript overlay
element.removeEventListener("touchcancel", this.@com.vaadin.v7.client.widgets.JsniWorkaround::touchEndFunction);
}-*/;
+ /**
+ * Using pointerdown, pointermove, pointerup, and pointercancel for IE11
+ * and Edge instead of touch* listeners (#18737)
+ *
+ * @param element
+ */
+ public native void attachPointerEventListeners(Element element)
+ /*
+ * Attaching events with JSNI instead of the GWT event mechanism because
+ * GWT didn't provide enough details in events, or triggering the event
+ * handlers with GWT bindings was unsuccessful. Maybe, with more time
+ * and skill, it could be done with better success. JavaScript overlay
+ * types might work. This might also get rid of the JsniWorkaround
+ * class.
+ */
+ /*-{
+ element.addEventListener("pointerdown", this.@com.vaadin.client.widgets.JsniWorkaround::touchStartFunction);
+ element.addEventListener("pointermove", this.@com.vaadin.client.widgets.JsniWorkaround::touchMoveFunction);
+ element.addEventListener("pointerup", this.@com.vaadin.client.widgets.JsniWorkaround::touchEndFunction);
+ element.addEventListener("pointercancel", this.@com.vaadin.client.widgets.JsniWorkaround::touchEndFunction);
+ }-*/;
+
+ /**
+ * Using pointerdown, pointermove, pointerup, and pointercancel for IE11
+ * and Edge instead of touch* listeners (#18737)
+ *
+ * @param element
+ */
+ public native void detachPointerEventListeners(Element element)
+ /*
+ * Detaching events with JSNI instead of the GWT event mechanism because
+ * GWT didn't provide enough details in events, or triggering the event
+ * handlers with GWT bindings was unsuccessful. Maybe, with more time
+ * and skill, it could be done with better success. JavaScript overlay
+ * types might work. This might also get rid of the JsniWorkaround
+ * class.
+ */
+ /*-{
+ element.removeEventListener("pointerdown", this.@com.vaadin.client.widgets.JsniWorkaround::touchStartFunction);
+ element.removeEventListener("pointermove", this.@com.vaadin.client.widgets.JsniWorkaround::touchMoveFunction);
+ element.removeEventListener("pointerup", this.@com.vaadin.client.widgets.JsniWorkaround::touchEndFunction);
+ element.removeEventListener("pointercancel", this.@com.vaadin.client.widgets.JsniWorkaround::touchEndFunction);
+ }-*/;
+
public void scrollToColumn(final int columnIndex,
final ScrollDestination destination, final int padding) {
assert columnIndex >= columnConfiguration.frozenColumns : "Can't scroll to a frozen column";
frozenColumns += numberOfColumns;
}
+ // Add to DOM
+ header.paintInsertColumns(index, numberOfColumns, frozen);
+ body.paintInsertColumns(index, numberOfColumns, frozen);
+ footer.paintInsertColumns(index, numberOfColumns, frozen);
+
// this needs to be before the scrollbar adjustment.
boolean scrollbarWasNeeded = horizontalScrollbar
.getOffsetSize() < horizontalScrollbar.getScrollSize();
boolean scrollbarIsNowNeeded = horizontalScrollbar
.getOffsetSize() < horizontalScrollbar.getScrollSize();
if (!scrollbarWasNeeded && scrollbarIsNowNeeded) {
+ // This might as a side effect move rows around (when scrolled
+ // all the way down) and require the DOM to be up to date, i.e.
+ // the column to be added
body.verifyEscalatorCount();
}
- // Add to DOM
- header.paintInsertColumns(index, numberOfColumns, frozen);
- body.paintInsertColumns(index, numberOfColumns, frozen);
- footer.paintInsertColumns(index, numberOfColumns, frozen);
-
// fix initial width
if (header.getRowCount() > 0 || body.getRowCount() > 0
|| footer.getRowCount() > 0) {
scroller.attachScrollListener(verticalScrollbar.getElement());
scroller.attachScrollListener(horizontalScrollbar.getElement());
scroller.attachMousewheelListener(getElement());
- scroller.attachTouchListeners(getElement());
+
+ if (isCurrentBrowserIE11OrEdge()) {
+ // Touch listeners doesn't work for IE11 and Edge (#18737)
+ scroller.attachPointerEventListeners(getElement());
+ } else {
+ scroller.attachTouchListeners(getElement());
+ }
}
@Override
scroller.detachScrollListener(verticalScrollbar.getElement());
scroller.detachScrollListener(horizontalScrollbar.getElement());
scroller.detachMousewheelListener(getElement());
- scroller.detachTouchListeners(getElement());
+
+ if (isCurrentBrowserIE11OrEdge()) {
+ // Touch listeners doesn't work for IE11 and Edge (#18737)
+ scroller.detachPointerEventListeners(getElement());
+ } else {
+ scroller.detachTouchListeners(getElement());
+ }
/*
* We can call paintRemoveRows here, because static ranges are simple to
double getMinCellWidth(int colIndex) {
return columnConfiguration.getMinCellWidth(colIndex);
}
+
+ /**
+ * Internal method for checking whether the browser is IE11 or Edge
+ *
+ * @return true only if the current browser is IE11, or Edge
+ */
+ private static boolean isCurrentBrowserIE11OrEdge() {
+ return BrowserInfo.get().isIE11() || BrowserInfo.get().isEdge();
+ }
}
import com.vaadin.client.DeferredWorker;
import com.vaadin.client.Focusable;
import com.vaadin.client.WidgetUtil;
+import com.vaadin.client.data.AbstractRemoteDataSource;
import com.vaadin.client.data.DataChangeHandler;
import com.vaadin.client.data.DataSource;
import com.vaadin.client.data.DataSource.RowHandle;
import com.vaadin.shared.data.sort.SortDirection;
import com.vaadin.shared.util.SharedUtil;
import com.vaadin.v7.client.renderers.ComplexRenderer;
+import com.vaadin.v7.client.renderers.ProgressBarRenderer;
import com.vaadin.v7.client.renderers.Renderer;
+import com.vaadin.v7.client.renderers.TextRenderer;
import com.vaadin.v7.client.renderers.WidgetRenderer;
import com.vaadin.v7.client.widget.escalator.Cell;
import com.vaadin.v7.client.widget.escalator.ColumnConfiguration;
import com.vaadin.v7.client.widget.grid.RendererCellReference;
import com.vaadin.v7.client.widget.grid.RowReference;
import com.vaadin.v7.client.widget.grid.RowStyleGenerator;
+import com.vaadin.v7.client.widget.grid.datasources.ListDataSource;
import com.vaadin.v7.client.widget.grid.events.AbstractGridKeyEventHandler;
import com.vaadin.v7.client.widget.grid.events.AbstractGridMouseEventHandler;
import com.vaadin.v7.client.widget.grid.events.BodyClickHandler;
import com.vaadin.v7.client.widget.grid.events.SelectAllEvent;
import com.vaadin.v7.client.widget.grid.events.SelectAllHandler;
import com.vaadin.v7.client.widget.grid.selection.HasSelectionHandlers;
+import com.vaadin.v7.client.widget.grid.selection.HasUserSelectionAllowed;
import com.vaadin.v7.client.widget.grid.selection.MultiSelectionRenderer;
import com.vaadin.v7.client.widget.grid.selection.SelectionEvent;
import com.vaadin.v7.client.widget.grid.selection.SelectionHandler;
* <p>
* Each column also has a Renderer. Its function is to take the value that is
* given by the {@code GridColumn} and display it to the user. A simple column
- * might have a {@link com.vaadin.v7.client.renderers.TextRenderer TextRenderer}
- * that simply takes in a {@code String} and displays it as the cell's content.
- * A more complex renderer might be
- * {@link com.vaadin.v7.client.renderers.ProgressBarRenderer
- * ProgressBarRenderer} that takes in a floating point number, and displays a
- * progress bar instead, based on the given number.
+ * might have a {@link TextRenderer} that simply takes in a {@code String} and
+ * displays it as the cell's content. A more complex renderer might be
+ * {@link ProgressBarRenderer} that takes in a floating point number, and
+ * displays a progress bar instead, based on the given number.
* <p>
* <em>See:</em> {@link #addColumn(Column)}, {@link #addColumn(Column, int)} and
* {@link #addColumns(Column...)}. <em>Also</em>
* <p>
* Grid gets its data from a {@link DataSource}, providing row objects to Grid
* from a user-defined endpoint. It can be either a local in-memory data source
- * (e.g. {@link com.vaadin.v7.client.widget.grid.datasources.ListDataSource
- * ListDataSource}) or even a remote one, retrieving data from e.g. a REST API
- * (see {@link com.vaadin.client.data.AbstractRemoteDataSource
- * AbstractRemoteDataSource}).
+ * (e.g. {@link ListDataSource}) or even a remote one, retrieving data from e.g.
+ * a REST API (see {@link AbstractRemoteDataSource}).
*
*
* @param <T>
*/
public abstract static class StaticRow<CELLTYPE extends StaticCell> {
- private Map<Column<?, ?>, CELLTYPE> cells = new HashMap<>();
+ private Map<Column<?, ?>, CELLTYPE> cells = new HashMap<Column<?, ?>, CELLTYPE>();
private StaticSection<?> section;
/**
* Map from set of spanned columns to cell meta data.
*/
- private Map<Set<Column<?, ?>>, CELLTYPE> cellGroups = new HashMap<>();
+ private Map<Set<Column<?, ?>>, CELLTYPE> cellGroups = new HashMap<Set<Column<?, ?>>, CELLTYPE>();
/**
* A custom style name for the row or null if none is set.
"You can't merge less than 2 columns together.");
}
- HashSet<Column<?, ?>> columnGroup = new HashSet<>();
+ HashSet<Column<?, ?>> columnGroup = new HashSet<Column<?, ?>>();
// NOTE: this doesn't care about hidden columns, those are
// filtered in calculateColspans()
for (Column<?, ?> column : columns) {
private boolean checkMergedCellIsContinuous(
Set<Column<?, ?>> mergedCell) {
// no matter if hidden or not, just check for continuous order
- final List<Column<?, ?>> columnOrder = new ArrayList<>(
+ final List<Column<?, ?>> columnOrder = new ArrayList<Column<?, ?>>(
section.grid.getColumns());
if (!columnOrder.containsAll(mergedCell)) {
*/
void detach() {
// Avoid calling detach twice for a merged cell
- HashSet<CELLTYPE> cells = new HashSet<>();
+ HashSet<CELLTYPE> cells = new HashSet<CELLTYPE>();
for (Column<?, ?> column : getSection().grid.getColumns()) {
cells.add(getCell(column));
}
private Grid<?> grid;
- private List<ROWTYPE> rows = new ArrayList<>();
+ private List<ROWTYPE> rows = new ArrayList<ROWTYPE>();
private boolean visible = true;
private Grid<T> grid;
private final int rowIndex;
- private final int columnIndex;
+ private final int columnIndexDOM;
private RequestCallback<T> callback;
private boolean completed = false;
- public EditorRequestImpl(Grid<T> grid, int rowIndex, int columnIndex,
+ public EditorRequestImpl(Grid<T> grid, int rowIndex, int columnIndexDOM,
RequestCallback<T> callback) {
this.grid = grid;
this.rowIndex = rowIndex;
- this.columnIndex = columnIndex;
+ this.columnIndexDOM = columnIndexDOM;
this.callback = callback;
}
@Override
public int getColumnIndex() {
- return columnIndex;
+ return columnIndexDOM;
}
@Override
}
/**
- * Returns the column index the editor was opened at. If the editor is
- * not open, returns -1.
+ * Returns the DOM column index (excluding hidden columns) the editor
+ * was opened at. If the editor is not open, returns -1.
*
* @return the column index or -1 if editor is not open
*/
public int getFocusedColumnIndex() {
- return getEditor().focusedColumnIndex;
+ return getEditor().focusedColumnIndexDOM;
}
}
private static final String ERROR_CLASS_NAME = "error";
private static final String NOT_EDITABLE_CLASS_NAME = "not-editable";
+ ScheduledCommand fieldFocusCommand = new ScheduledCommand() {
+ private int count = 0;
+
+ @Override
+ public void execute() {
+ Element focusedElement = WidgetUtil.getFocusedElement();
+ if (focusedElement == grid.getElement()
+ || focusedElement == Document.get().getBody()
+ || count > 2) {
+ focusColumn(focusedColumnIndexDOM);
+ } else {
+ ++count;
+ Scheduler.get().scheduleDeferred(this);
+ }
+ }
+ };
+
/**
* A handler for events related to the Grid editor. Responsible for
* opening, moving or closing the editor based on the received event.
// Should only be added to the DOM when there's a message to show
private DivElement message = DivElement.as(DOM.createDiv());
- private Map<Column<?, T>, Widget> columnToWidget = new HashMap<>();
- private List<HandlerRegistration> focusHandlers = new ArrayList<>();
+ private Map<Column<?, T>, Widget> columnToWidget = new HashMap<Column<?, T>, Widget>();
+ private List<HandlerRegistration> focusHandlers = new ArrayList<HandlerRegistration>();
private boolean enabled = false;
private State state = State.INACTIVE;
private int rowIndex = -1;
- private int focusedColumnIndex = -1;
+ private int focusedColumnIndexDOM = -1;
private String styleName = null;
private HandlerRegistration hScrollHandler;
bindTimeout.cancel();
rowIndex = request.getRowIndex();
- focusedColumnIndex = request.getColumnIndex();
- if (focusedColumnIndex >= 0) {
+ focusedColumnIndexDOM = request.getColumnIndex();
+ if (focusedColumnIndexDOM >= 0) {
// Update internal focus of Grid
- grid.focusCell(rowIndex, focusedColumnIndex);
+ grid.focusCell(rowIndex, focusedColumnIndexDOM);
}
showOverlay();
};
/** A set of all the columns that display an error flag. */
- private final Set<Column<?, T>> columnErrors = new HashSet<>();
+ private final Set<Column<?, T>> columnErrors = new HashSet<Column<?, T>>();
private boolean buffered = true;
/** Original position of editor */
*
* @param rowIndex
* the index of the row to be edited
- * @param columnIndex
- * the column index of the editor widget that should be
- * initially focused or -1 to not set focus
+ * @param columnIndexDOM
+ * the column index (excluding hidden columns) of the editor
+ * widget that should be initially focused or -1 to not set
+ * focus
*
* @throws IllegalStateException
* if this editor is not enabled
*
* @since 7.5
*/
- public void editRow(final int rowIndex, final int columnIndex) {
+ public void editRow(final int rowIndex, final int columnIndexDOM) {
if (!enabled) {
throw new IllegalStateException(
"Cannot edit row: editor is not enabled");
return;
}
}
- if (columnIndex >= grid.getVisibleColumns().size()) {
+ if (columnIndexDOM >= grid.getVisibleColumns().size()) {
throw new IllegalArgumentException(
- "Edited column index " + columnIndex
+ "Edited column index " + columnIndexDOM
+ " was bigger than visible column count.");
}
if (this.rowIndex == rowIndex
- && focusedColumnIndex == columnIndex) {
+ && focusedColumnIndexDOM == columnIndexDOM) {
// NO-OP
return;
}
if (this.rowIndex == rowIndex) {
- if (focusedColumnIndex != columnIndex) {
- if (columnIndex >= grid.getFrozenColumnCount()) {
+ if (focusedColumnIndexDOM != columnIndexDOM) {
+ if (columnIndexDOM >= grid.getFrozenColumnCount()) {
// Scroll to new focused column.
- grid.getEscalator().scrollToColumn(columnIndex,
+ grid.getEscalator().scrollToColumn(columnIndexDOM,
ScrollDestination.ANY, 0);
}
- focusedColumnIndex = columnIndex;
+ focusedColumnIndexDOM = columnIndexDOM;
}
updateHorizontalScrollPosition();
// Update Grid internal focus and focus widget if possible
- if (focusedColumnIndex >= 0) {
- grid.focusCell(rowIndex, focusedColumnIndex);
- focusColumn(focusedColumnIndex);
+ if (focusedColumnIndexDOM >= 0) {
+ grid.focusCell(rowIndex, focusedColumnIndexDOM);
+ focusColumn(focusedColumnIndexDOM);
}
// No need to request anything from the editor handler.
final Escalator escalator = grid.getEscalator();
if (escalator.getVisibleRowRange().contains(rowIndex)) {
- show(rowIndex, columnIndex);
+ show(rowIndex, columnIndexDOM);
} else {
vScrollHandler = grid.addScrollHandler(new ScrollHandler() {
@Override
public void onScroll(ScrollEvent event) {
if (escalator.getVisibleRowRange().contains(rowIndex)) {
- show(rowIndex, columnIndex);
+ show(rowIndex, columnIndexDOM);
vScrollHandler.removeHandler();
}
}
throw new IllegalStateException(
"Cannot cancel edit: editor is not in edit mode");
}
- handler.cancel(new EditorRequestImpl<>(grid, rowIndex,
- focusedColumnIndex, null));
+ handler.cancel(new EditorRequestImpl<T>(grid, rowIndex,
+ focusedColumnIndexDOM, null));
doCancel();
}
hideOverlay();
state = State.INACTIVE;
rowIndex = -1;
- focusedColumnIndex = -1;
+ focusedColumnIndexDOM = -1;
grid.getEscalator().setScrollLocked(Direction.VERTICAL, false);
updateSelectionCheckboxesAsNeeded(true);
}
state = State.SAVING;
setButtonsEnabled(false);
saveTimeout.schedule(SAVE_TIMEOUT_MS);
- EditorRequest<T> request = new EditorRequestImpl<>(grid, rowIndex,
- focusedColumnIndex, saveRequestCallback);
+ EditorRequest<T> request = new EditorRequestImpl<T>(grid, rowIndex,
+ focusedColumnIndexDOM, saveRequestCallback);
handler.save(request);
updateSelectionCheckboxesAsNeeded(true);
}
if (state == State.ACTIVATING) {
state = State.BINDING;
bindTimeout.schedule(BIND_TIMEOUT_MS);
- EditorRequest<T> request = new EditorRequestImpl<>(grid,
+ EditorRequest<T> request = new EditorRequestImpl<T>(grid,
rowIndex, columnIndex, bindRequestCallback);
handler.bind(request);
grid.getEscalator().setScrollLocked(Direction.VERTICAL,
grid.attachWidget(editor, cell);
}
- if (i == focusedColumnIndex) {
- focusColumn(focusedColumnIndex);
+ if (i == focusedColumnIndexDOM) {
+ focusColumn(focusedColumnIndexDOM);
}
} else {
cell.addClassName(NOT_EDITABLE_CLASS_NAME);
checkBox.addClickHandler(new ClickHandler() {
@Override
public void onClick(ClickEvent event) {
+ if (!grid.isUserSelectionAllowed()) {
+ return;
+ }
T row = pinnedRowHandle.getRow();
if (grid.isSelected(row)) {
grid.deselect(row);
Unit.PX);
}
- private void focusColumn(int colIndex) {
- if (colIndex < 0 || colIndex >= grid.getVisibleColumns().size()) {
+ private void focusColumn(int columnIndexDOM) {
+ if (columnIndexDOM < 0
+ || columnIndexDOM >= grid.getVisibleColumns().size()) {
// NO-OP
return;
}
- Widget editor = getWidget(grid.getVisibleColumn(colIndex));
+ Widget editor = getWidget(grid.getVisibleColumn(columnIndexDOM));
if (editor instanceof Focusable) {
((Focusable) editor).focus();
} else if (editor instanceof com.google.gwt.user.client.ui.Focusable) {
extends KeyEvent<HANDLER> {
private Grid<?> grid;
- private final Type<HANDLER> associatedType = new Type<>(
+ private final Type<HANDLER> associatedType = new Type<HANDLER>(
getBrowserEventType(), this);
private final CellReference<?> targetCell;
private Grid<?> grid;
private final CellReference<?> targetCell;
- private final Type<HANDLER> associatedType = new Type<>(
+ private final Type<HANDLER> associatedType = new Type<HANDLER>(
getBrowserEventType(), this);
public AbstractGridMouseEvent(Grid<?> grid,
*/
private static final double DETAILS_ROW_INITIAL_HEIGHT = 50;
- private EventCellReference<T> eventCell = new EventCellReference<>(this);
+ private EventCellReference<T> eventCell = new EventCellReference<T>(this);
private GridKeyDownEvent keyDown = new GridKeyDownEvent(this, eventCell);
private GridKeyUpEvent keyUp = new GridKeyUpEvent(this, eventCell);
private GridKeyPressEvent keyPress = new GridKeyPressEvent(this, eventCell);
setStyleName(rowWithFocusStyle, rowFocusStyleName, true);
}
} else if (rowWithFocusStyle == row.getElement()
- || (containerWithFocus != escalator.getBody()
- && rowWithFocusStyle != null)) {
+ || containerWithFocus != escalator.getBody()
+ && rowWithFocusStyle != null) {
// Remove focus style.
setStyleName(rowWithFocusStyle, rowFocusStyleName, false);
rowWithFocusStyle = null;
++i;
} while (cell != null);
}
- int columnIndex = getColumns()
- .indexOf(getVisibleColumn(columnIndexDOM));
- if (columnIndex >= escalator.getColumnConfiguration()
+ if (columnIndexDOM >= escalator.getColumnConfiguration()
.getFrozenColumnCount()) {
escalator.scrollToColumn(columnIndexDOM, ScrollDestination.ANY,
10);
* a range of added rows
*/
public void rowsAddedToBody(Range added) {
- boolean bodyHasFocus = (containerWithFocus == escalator.getBody());
- boolean insertionIsAboveFocusedCell = (added
- .getStart() <= rowWithFocus);
+ boolean bodyHasFocus = containerWithFocus == escalator.getBody();
+ boolean insertionIsAboveFocusedCell = added
+ .getStart() <= rowWithFocus;
if (bodyHasFocus && insertionIsAboveFocusedCell) {
rowWithFocus += added.length();
rowWithFocus = Math.min(rowWithFocus,
}
}
- private final List<GridEventHandler<T>> browserEventHandlers = new ArrayList<>();
+ private final List<GridEventHandler<T>> browserEventHandlers = new ArrayList<GridEventHandler<T>>();
private CellStyleGenerator<T> cellStyleGenerator;
private RowStyleGenerator<T> rowStyleGenerator;
- private RowReference<T> rowReference = new RowReference<>(this);
- private CellReference<T> cellReference = new CellReference<>(rowReference);
+ private RowReference<T> rowReference = new RowReference<T>(this);
+ private CellReference<T> cellReference = new CellReference<T>(rowReference);
private RendererCellReference rendererCellReference = new RendererCellReference(
(RowReference<Object>) rowReference);
private boolean initDone = false;
private boolean selected = false;
private CheckBox selectAllCheckBox;
+ private boolean userSelectionAllowed = true;
+ private boolean enabled = true;
SelectionColumn(final Renderer<Boolean> selectColumnRenderer) {
super(selectColumnRenderer);
if (selectAllCheckBox == null) {
selectAllCheckBox = GWT.create(CheckBox.class);
+ selectAllCheckBox.setEnabled(enabled && userSelectionAllowed);
selectAllCheckBox.setStylePrimaryName(
getStylePrimaryName() + SELECT_ALL_CHECKBOX_CLASSNAME);
selectAllCheckBox.addValueChangeHandler(
@Override
public void onValueChange(
ValueChangeEvent<Boolean> event) {
+ if (!isUserSelectionAllowed()) {
+ return;
+ }
if (event.getValue()) {
- fireEvent(new SelectAllEvent<>(model));
+ fireEvent(new SelectAllEvent<T>(model));
selected = true;
} else {
model.deselectAll();
addHeaderClickHandler(new HeaderClickHandler() {
@Override
public void onClick(GridClickEvent event) {
+ if (!userSelectionAllowed) {
+ return;
+ }
+
CellReference<?> targetCell = event.getTargetCell();
int defaultRowIndex = getHeader().getRows()
.indexOf(getDefaultHeaderRow());
if (event.getNativeKeyCode() != KeyCodes.KEY_SPACE) {
return;
}
+ if (!isUserSelectionAllowed()) {
+ return;
+ }
+
HeaderRow targetHeaderRow = getHeader()
.getRow(event.getFocusedCell().getRowIndex());
if (!targetHeaderRow.isDefault()) {
* to disable it.
*/
public void setEnabled(boolean enabled) {
+ this.enabled = enabled;
if (selectAllCheckBox != null) {
- selectAllCheckBox.setEnabled(enabled);
+ selectAllCheckBox.setEnabled(enabled && userSelectionAllowed);
}
}
public void onEnabled(boolean enabled) {
setEnabled(enabled);
}
+
+ /**
+ * Sets whether the user is allowed to change the selection.
+ *
+ * @param userSelectionAllowed
+ * <code>true</code> if the user is allowed to change the
+ * selection, <code>false</code> otherwise
+ * @since 7.7.7
+ */
+ public void setUserSelectionAllowed(boolean userSelectionAllowed) {
+ if (userSelectionAllowed == this.userSelectionAllowed) {
+ return;
+ }
+
+ this.userSelectionAllowed = userSelectionAllowed;
+ // Update checkbox state
+ setEnabled(enabled);
+ // Re-render select checkboxes
+ getEscalator().getBody().refreshRows(0,
+ getEscalator().getBody().getRowCount());
+ }
}
/**
}
} else if (currentDataAvailable.isEmpty()
&& dataSource.isWaitingForData()) {
+ // No data available yet but something is incoming soon
Scheduler.get().scheduleDeferred(this);
} else {
calculate();
private void calculate() {
isScheduled = false;
rescheduleCount = 0;
-
assert !(currentDataAvailable.isEmpty() && dataSource
.isWaitingForData()) : "Trying to calculate column widths without data while data is still being fetched.";
/* Step 1: Apply all column widths as they are. */
- Map<Integer, Double> selfWidths = new LinkedHashMap<>();
+ Map<Integer, Double> selfWidths = new LinkedHashMap<Integer, Double>();
List<Column<?, T>> columns = getVisibleColumns();
for (int index = 0; index < columns.size(); index++) {
selfWidths.put(index, columns.get(index).getWidth());
* violated, fix it.
*/
- Map<Integer, Double> constrainedWidths = new LinkedHashMap<>();
+ Map<Integer, Double> constrainedWidths = new LinkedHashMap<Integer, Double>();
for (int index = 0; index < columns.size(); index++) {
Column<?, T> column = columns.get(index);
boolean defaultExpandRatios = true;
int totalRatios = 0;
double reservedPixels = 0;
- final Set<Column<?, T>> columnsToExpand = new HashSet<>();
- List<Column<?, T>> nonFixedColumns = new ArrayList<>();
- Map<Integer, Double> columnSizes = new HashMap<>();
+ final Set<Column<?, T>> columnsToExpand = new HashSet<Column<?, T>>();
+ List<Column<?, T>> nonFixedColumns = new ArrayList<Column<?, T>>();
+ Map<Integer, Double> columnSizes = new HashMap<Integer, Double>();
final List<Column<?, T>> visibleColumns = getVisibleColumns();
/*
setColumnSizes(columnSizes);
for (Column<?, T> column : nonFixedColumns) {
- final int expandRatio = (defaultExpandRatios ? 1
- : column.getExpandRatio());
+ final int expandRatio = defaultExpandRatios ? 1
+ : column.getExpandRatio();
final double maxWidth = getMaxWidth(column);
final double newWidth = Math.min(maxWidth,
column.getWidthActual());
boolean hasAutoWidth = column.getWidth() < 0;
if (hasAutoWidth && currentWidth < minWidth) {
columnSizes.put(columnIndex, minWidth);
- pixelsToRemoveFromOtherColumns += (minWidth
- - currentWidth);
+ pixelsToRemoveFromOtherColumns += minWidth
+ - currentWidth;
minWidthsCausedReflows = true;
/*
private static final String STRIPE_CLASSNAME = "stripe";
- private final Map<Element, Widget> elementToWidgetMap = new HashMap<>();
+ private final Map<Element, Widget> elementToWidgetMap = new HashMap<Element, Widget>();
@Override
public void init(Spacer spacer) {
.getFirstChildElement();
double height = WidgetUtil
.getRequiredHeightBoundingClientRectDouble(firstHeaderCell)
- - (WidgetUtil.measureVerticalBorder(getElement()) / 2);
+ - WidgetUtil.measureVerticalBorder(getElement()) / 2;
openCloseButton.setHeight(height + "px");
}
private final class ColumnHider {
/** Map from columns to their hiding toggles, component might change */
- private HashMap<Column<?, T>, MenuItem> columnToHidingToggleMap = new HashMap<>();
+ private HashMap<Column<?, T>, MenuItem> columnToHidingToggleMap = new HashMap<Column<?, T>, MenuItem>();
/**
* When column is being hidden with a toggle, do not refresh toggles for
toggle.setStyleName("hidden", column.isHidden());
} else if (columnToHidingToggleMap.containsKey(column)) {
sidebar.menuBar
- .removeItem((columnToHidingToggleMap.remove(column)));
+ .removeItem(columnToHidingToggleMap.remove(column));
}
updateTogglesOrder();
}
/**
* List of columns in the grid. Order defines the visible order.
*/
- private List<Column<?, T>> columns = new ArrayList<>();
+ private List<Column<?, T>> columns = new ArrayList<Column<?, T>>();
/**
* The datasource currently in use. <em>Note:</em> it is <code>null</code>
* Current sort order. The (private) sort() method reads this list to
* determine the order in which to present rows.
*/
- private List<SortOrder> sortOrder = new ArrayList<>();
+ private List<SortOrder> sortOrder = new ArrayList<SortOrder>();
private Renderer<Boolean> selectColumnRenderer = null;
private DetailsGenerator detailsGenerator = DetailsGenerator.NULL;
private GridSpacerUpdater gridSpacerUpdater = new GridSpacerUpdater();
/** A set keeping track of the indices of all currently open details */
- private Set<Integer> visibleDetails = new HashSet<>();
+ private Set<Integer> visibleDetails = new HashSet<Integer>();
/** A set of indices of details to reopen after detach and on attach */
- private final Set<Integer> reattachVisibleDetails = new HashSet<>();
+ private final Set<Integer> reattachVisibleDetails = new HashSet<Integer>();
private boolean columnReorderingAllowed;
* Map of possible drop positions for the column and the corresponding
* column index.
*/
- private final TreeMap<Double, Integer> possibleDropPositions = new TreeMap<>();
+ private final TreeMap<Double, Integer> possibleDropPositions = new TreeMap<Double, Integer>();
/**
* Makes sure that drag cancel doesn't cause anything unwanted like sort
*/
final int colspan = header.getRow(eventCell.getRowIndex())
.getCell(eventCell.getColumn()).getColspan();
if (latestColumnDropIndex != draggedColumnIndex
- && latestColumnDropIndex != (draggedColumnIndex
- + colspan)) {
+ && latestColumnDropIndex != draggedColumnIndex + colspan) {
List<Column<?, T>> columns = getColumns();
- List<Column<?, T>> reordered = new ArrayList<>();
+ List<Column<?, T>> reordered = new ArrayList<Column<?, T>>();
if (draggedColumnIndex < latestColumnDropIndex) {
reordered.addAll(columns.subList(0, draggedColumnIndex));
reordered.addAll(
reordered.addAll(columns.subList(
draggedColumnIndex + colspan, columns.size()));
}
- reordered.remove(selectionColumn); // since
- // setColumnOrder
- // will
- // add
- // it
- // anyway!
+ reordered.remove(selectionColumn); // since setColumnOrder will
+ // add it anyway!
// capture focused cell column before reorder
Cell focusedCell = cellFocusHandler.getFocusedCell();
.toArray(new Column[reordered.size()]);
setColumnOrder(array);
transferCellFocusOnDrop();
- } // else
- // no
- // reordering
+ } // else no reordering
}
private void transferCellFocusOnDrop() {
int leftBound = -1;
int rightBound = getColumnCount() + 1;
- final HashSet<Integer> unavailableColumnDropIndices = new HashSet<>();
- final List<StaticRow<?>> rows = new ArrayList<>();
+ final HashSet<Integer> unavailableColumnDropIndices = new HashSet<Integer>();
+ final List<StaticRow<?>> rows = new ArrayList<StaticRow<?>>();
rows.addAll(header.getRows());
rows.addAll(footer.getRows());
for (StaticRow<?> row : rows) {
}
}
- if (leftBound == (rightBound - 1)) {
+ if (leftBound == rightBound - 1) {
return;
}
grid.header.updateColSpans();
grid.footer.updateColSpans();
scheduleColumnWidthRecalculator();
- this.grid.fireEvent(new ColumnVisibilityChangeEvent<>(this,
+ this.grid.fireEvent(new ColumnVisibilityChangeEvent<T>(this,
hidden, userOriginated));
}
}
setStyleName(rowElement, rowHasDataStyleName, hasData);
}
- boolean isEvenIndex = (row.getRow() % 2 == 0);
+ boolean isEvenIndex = row.getRow() % 2 == 0;
setStyleName(rowElement, rowStripeStyleName, !isEvenIndex);
rowReference.set(rowIndex, rowData, rowElement);
if (c.getWidth() < 0) {
c.setWidth(c.getWidthActual());
- fireEvent(new ColumnResizeEvent<>(c));
+ fireEvent(new ColumnResizeEvent<T>(c));
}
}
dragEnded();
col.setWidth(width);
- fireEvent(new ColumnResizeEvent<>(col));
+ fireEvent(new ColumnResizeEvent<T>(col));
}
};
public void onComplete() {
dragEnded();
col.setWidth(width);
- fireEvent(new ColumnResizeEvent<>(col));
+ fireEvent(new ColumnResizeEvent<T>(col));
}
};
escalator.getColumnConfiguration().setColumnWidth(colIndex,
minWidth);
- fireEvent(new ColumnResizeEvent<>(column));
+ fireEvent(new ColumnResizeEvent<T>(column));
}
}
new RendererEventHandler(),
// Moving cell focus by keyboard or mouse
new CellFocusEventHandler()));
-
}
@Override
return enabled;
}
- /**
- * Sets the column resize mode to use. The default mode is
- * {@link ColumnResizeMode.ANIMATED}.
- *
- * @param mode
- * a ColumnResizeMode value
- * @since 7.7.5
- */
- public void setColumnResizeMode(ColumnResizeMode mode) {
- columnResizeMode = mode;
- }
-
- /**
- * Returns the current column resize mode. The default mode is
- * {@link ColumnResizeMode.ANIMATED}.
- *
- * @return a ColumnResizeMode value
- * @since 7.7.5
- */
- public ColumnResizeMode getColumnResizeMode() {
- return columnResizeMode;
- }
-
@Override
public void setEnabled(boolean enabled) {
if (enabled == this.enabled) {
}
}
+ /**
+ * Sets the column resize mode to use. The default mode is
+ * {@link ColumnResizeMode.ANIMATED}.
+ *
+ * @param mode
+ * a ColumnResizeMode value
+ * @since 7.7.5
+ */
+ public void setColumnResizeMode(ColumnResizeMode mode) {
+ columnResizeMode = mode;
+ }
+
+ /**
+ * Returns the current column resize mode. The default mode is
+ * {@link ColumnResizeMode.ANIMATED}.
+ *
+ * @return a ColumnResizeMode value
+ * @since 7.7.5
+ */
+ public ColumnResizeMode getColumnResizeMode() {
+ return columnResizeMode;
+ }
+
/**
* Creates the escalator updater used to update the header rows in this
* grid. The updater is invoked when header rows or columns are added or
*
* @param rowIndex
* index of row to focus
- * @param columnIndex
- * index of cell to focus
+ * @param columnIndexDOM
+ * index (excluding hidden columns) of cell to focus
*/
- void focusCell(int rowIndex, int columnIndex) {
+ void focusCell(int rowIndex, int columnIndexDOM) {
final Range rowRange = Range.between(0, dataSource.size());
final Range columnRange = Range.between(0, getVisibleColumns().size());
assert rowRange.contains(
rowIndex) : "Illegal row index. Should be in range " + rowRange;
assert columnRange.contains(
- columnIndex) : "Illegal column index. Should be in range "
+ columnIndexDOM) : "Illegal column index. Should be in range "
+ columnRange;
- if (rowRange.contains(rowIndex) && columnRange.contains(columnIndex)) {
- cellFocusHandler.setCellFocus(rowIndex, columnIndex,
+ if (rowRange.contains(rowIndex)
+ && columnRange.contains(columnIndexDOM)) {
+ cellFocusHandler.setCellFocus(rowIndex, columnIndexDOM,
escalator.getBody());
WidgetUtil.focus(getElement());
}
column.reapplyWidth();
// Sink all renderer events
- Set<String> events = new HashSet<>();
+ Set<String> events = new HashSet<String>();
events.addAll(getConsumedEventsForRenderer(column.getRenderer()));
if (column.isHidable()) {
* @return A unmodifiable list of the columns in the grid
*/
public List<Column<?, T>> getColumns() {
- return Collections.unmodifiableList(new ArrayList<>(columns));
+ return Collections
+ .unmodifiableList(new ArrayList<Column<?, T>>(columns));
}
/**
* @return A unmodifiable list of the currently visible columns in the grid
*/
public List<Column<?, T>> getVisibleColumns() {
- ArrayList<Column<?, T>> visible = new ArrayList<>();
+ ArrayList<Column<?, T>> visible = new ArrayList<Column<?, T>>();
for (Column<?, T> c : columns) {
if (!c.isHidden()) {
visible.add(c);
return columns.get(index);
}
- private Column<?, T> getVisibleColumn(int index)
+ private Column<?, T> getVisibleColumn(int columnIndexDOM)
throws IllegalArgumentException {
List<Column<?, T>> visibleColumns = getVisibleColumns();
- if (index < 0 || index >= visibleColumns.size()) {
+ if (columnIndexDOM < 0 || columnIndexDOM >= visibleColumns.size()) {
throw new IllegalStateException("Column not found.");
}
- return visibleColumns.get(index);
+ return visibleColumns.get(columnIndexDOM);
}
/**
int oldSize = body.getRowCount();
// Hide all details.
- Set<Integer> oldDetails = new HashSet<>(visibleDetails);
+ Set<Integer> oldDetails = new HashSet<Integer>(
+ visibleDetails);
for (int i : oldDetails) {
setDetailsVisible(i, false);
}
}
private Set<String> getConsumedEventsForRenderer(Renderer<?> renderer) {
- Set<String> events = new HashSet<>();
+ Set<String> events = new HashSet<String>();
if (renderer instanceof ComplexRenderer) {
Collection<String> consumedEvents = ((ComplexRenderer<?>) renderer)
.getConsumedEvents();
+ "-event with a null cell target";
eventCell.set(cell, getSectionFromContainer(container));
- GridEvent<T> gridEvent = new GridEvent<>(event, eventCell);
+ GridEvent<T> gridEvent = new GridEvent<T>(event, eventCell);
for (GridEventHandler<T> handler : browserEventHandlers) {
handler.onEvent(gridEvent);
}
}
Widget widget;
- if (editor.focusedColumnIndex < 0) {
+ if (editor.focusedColumnIndexDOM < 0) {
widget = null;
} else {
- widget = editor.getWidget(getColumn(editor.focusedColumnIndex));
+ widget = editor.getWidget(
+ getVisibleColumn(editor.focusedColumnIndexDOM));
}
- EditorDomEvent<T> editorEvent = new EditorDomEvent<>(
+ EditorDomEvent<T> editorEvent = new EditorDomEvent<T>(
event.getDomEvent(), event.getCell(), widget);
event.setHandled(
if (!event.getCell().isHeader()) {
return;
}
- if (event.getCell().getColumnIndex() < escalator
- .getColumnConfiguration().getFrozenColumnCount()) {
+ if (event.getCell().getColumnIndex() < getFrozenColumnCount()) {
return;
}
/**
* Deselect all rows using the current selection model.
*
- * @param row
- * a row object
* @return <code>true</code> iff the current selection changed
* @throws IllegalStateException
* if the current selection model is not an instance of
*/
public boolean deselectAll() {
if (selectionModel instanceof SelectionModel.Single<?>) {
- Single<T> single = ((SelectionModel.Single<T>) selectionModel);
+ Single<T> single = (SelectionModel.Single<T>) selectionModel;
if (single.getSelectedRow() != null) {
return single.deselect(single.getSelectedRow());
} else {
*/
private void sort(boolean userOriginated) {
refreshHeader();
- fireEvent(new SortEvent<>(this, Collections.unmodifiableList(sortOrder),
- userOriginated));
+ fireEvent(new SortEvent<T>(this,
+ Collections.unmodifiableList(sortOrder), userOriginated));
}
private int getLastVisibleRowIndex() {
// Trigger ComplexRenderer.destroy for old content
conf.removeColumns(0, conf.getColumnCount());
- List<Column<?, T>> newOrder = new ArrayList<>();
+ List<Column<?, T>> newOrder = new ArrayList<Column<?, T>>();
if (selectionColumn != null) {
newOrder.add(selectionColumn);
}
// Grid was just attached to DOM. Column widths should be calculated.
recalculateColumnWidths();
+ for (int row : reattachVisibleDetails) {
+ setDetailsVisible(row, true);
+ }
+ reattachVisibleDetails.clear();
}
@Override
protected void onDetach() {
- Set<Integer> details = new HashSet<>(visibleDetails);
+ Set<Integer> details = new HashSet<Integer>(visibleDetails);
reattachVisibleDetails.clear();
reattachVisibleDetails.addAll(details);
for (int row : details) {
if (container != null) {
Cell cell = container.getCell(element);
if (cell != null) {
- EventCellReference<T> cellRef = new EventCellReference<>(this);
+ EventCellReference<T> cellRef = new EventCellReference<T>(this);
cellRef.set(cell, getSectionFromContainer(container));
return cellRef;
}
}
return null;
}
+
+ /**
+ * Checks if selection by the user is allowed in the grid.
+ *
+ * @return <code>true</code> if selection by the user is allowed by the
+ * selection model (the default), <code>false</code> otherwise
+ * @since 7.7.7
+ */
+ public boolean isUserSelectionAllowed() {
+ if (!(getSelectionModel() instanceof HasUserSelectionAllowed)) {
+ // Selection model does not support toggling user selection allowed
+ // - old default is to always allow selection
+ return true;
+ }
+ return ((HasUserSelectionAllowed) getSelectionModel())
+ .isUserSelectionAllowed();
+ }
}
VaadinSession vaadinSession = (VaadinSession) ois.readObject();
getService().storeSession(vaadinSession,
new WrappedHttpSession(session));
- } catch (IOException | ClassNotFoundException e) {
+ } catch (IOException e) {
+ getLogger().log(Level.WARNING,
+ "Could not de-serialize ApplicationContext for "
+ + session.getId()
+ + " A new one will be created. ",
+ e);
+ } catch (ClassNotFoundException e) {
getLogger().log(Level.WARNING,
"Could not de-serialize ApplicationContext for "
+ session.getId()
return source;
}
+ // Intentional change in compatibility package
@Override
public ErrorMessage getErrorMessage() {
// no message, only the causes to be painted
return causes;
}
+ // Intentional change in compatibility package
@Override
public ErrorMessage getErrorMessage() {
UserError error = new UserError(getHtmlMessage(), ContentMode.HTML,
* @since 7.4
* @param fieldType
* the type of the field
- * @return true if any LegacyAbstractField can be assigned to the field
+ * @return true if any AbstractField can be assigned to the field
*/
protected boolean anyField(Class<?> fieldType) {
return fieldType == Field.class || fieldType == AbstractField.class;
* FieldGroup provides an easy way of binding fields to data and handling
* commits of these fields.
* <p>
- * The typical use case is to create a layout outside the FieldGroup and then
- * use FieldGroup to bind the fields to a data source.
+ * The functionality of FieldGroup is similar to {@link Form} but
+ * {@link FieldGroup} does not handle layouts in any way. The typical use case
+ * is to create a layout outside the FieldGroup and then use FieldGroup to bind
+ * the fields to a data source.
* </p>
* <p>
* {@link FieldGroup} is not a UI component so it cannot be added to a layout.
.createCaptionByPropertyId(propertyId);
}
- // Create the component (LegacyField)
+ // Create the component (Field)
field = build(caption, propertyType, fieldType);
// Store it in the field
* <p>
* The data type is the type that we want to edit using the field. The field
* type is the type of field we want to create, can be {@link Field} if any
- * LegacyField is good.
+ * Field is good.
* </p>
*
* @param caption
* The data model type that we want to edit using the field
* @param fieldType
* The type of field that we want to create
- * @return A LegacyField capable of editing the given type
+ * @return A Field capable of editing the given type
* @throws BindException
* If the field could not be created
*/
}
/**
- * Returns an array containing LegacyField objects reflecting all the fields
- * of the class or interface represented by this Class object. The elements
- * in the array returned are sorted in declare order from sub class to super
+ * Returns an array containing Field objects reflecting all the fields of
+ * the class or interface represented by this Class object. The elements in
+ * the array returned are sorted in declare order from sub class to super
* class.
*
* @param searchClass
import com.vaadin.v7.ui.Field;
/**
- * Factory interface for creating new LegacyField-instances based on the data
- * type that should be edited.
+ * Factory interface for creating new Field-instances based on the data type
+ * that should be edited.
*
* @author Vaadin Ltd.
* @since 7.0
model = BeanItem.getPropertyDescriptors((Class<BEANTYPE>) type);
}
- /*
- * (non-Javadoc)
- *
- * @see com.vaadin.data.Container#getType(java.lang.Object)
- */
@Override
public Class<?> getType(Object propertyId) {
VaadinPropertyDescriptor<BEANTYPE> descriptor = model.get(propertyId);
return type;
}
- /*
- * (non-Javadoc)
- *
- * @see com.vaadin.data.Container#getContainerPropertyIds()
- */
@Override
public Collection<String> getContainerPropertyIds() {
return model.keySet();
}
- /*
- * (non-Javadoc)
- *
- * @see com.vaadin.data.Container#removeAllItems()
- */
@Override
public boolean removeAllItems() {
int origSize = size();
return true;
}
- /*
- * (non-Javadoc)
- *
- * @see com.vaadin.data.Container#getItem(java.lang.Object)
- */
@Override
public BeanItem<BEANTYPE> getItem(Object itemId) {
// TODO return only if visible?
return itemIdToItem.get(itemId);
}
- /*
- * (non-Javadoc)
- *
- * @see com.vaadin.data.Container#getItemIds()
- */
@Override
@SuppressWarnings("unchecked")
public List<IDTYPE> getItemIds() {
return (List<IDTYPE>) super.getItemIds();
}
- /*
- * (non-Javadoc)
- *
- * @see com.vaadin.data.Container#getContainerProperty(java.lang.Object,
- * java.lang.Object)
- */
@Override
public Property getContainerProperty(Object itemId, Object propertyId) {
Item item = getItem(itemId);
return item.getItemProperty(propertyId);
}
- /*
- * (non-Javadoc)
- *
- * @see com.vaadin.data.Container#removeItem(java.lang.Object)
- */
@Override
public boolean removeItem(Object itemId) {
// TODO should also remove items that are filtered out
filterAll();
}
- /*
- * (non-Javadoc)
- *
- * @see
- * com.vaadin.data.Container.Filterable#addContainerFilter(java.lang.Object,
- * java.lang.String, boolean, boolean)
- */
@Override
public void addContainerFilter(Object propertyId, String filterString,
boolean ignoreCase, boolean onlyMatchPrefix) {
}
}
- /*
- * (non-Javadoc)
- *
- * @see com.vaadin.data.Container.Filterable#removeAllContainerFilters()
- */
@Override
public void removeAllContainerFilters() {
if (!getFilters().isEmpty()) {
}
}
- /*
- * (non-Javadoc)
- *
- * @see
- * com.vaadin.data.Container.Filterable#removeContainerFilters(java.lang
- * .Object)
- */
@Override
public void removeContainerFilters(Object propertyId) {
Collection<Filter> removedFilters = super.removeFilters(propertyId);
removeFilter(filter);
}
- /*
- * (non-Javadoc)
- *
- * @see com.vaadin.data.util.AbstractInMemoryContainer#hasContainerFilters()
- */
@Override
public boolean hasContainerFilters() {
return super.hasContainerFilters();
}
- /*
- * (non-Javadoc)
- *
- * @see com.vaadin.data.util.AbstractInMemoryContainer#getContainerFilters()
- */
@Override
public Collection<Filter> getContainerFilters() {
return super.getContainerFilters();
}
}
- /*
- * (non-Javadoc)
- *
- * @see com.vaadin.data.Container.Sortable#getSortableContainerPropertyIds()
- */
@Override
public Collection<?> getSortableContainerPropertyIds() {
return getSortablePropertyIds();
}
- /*
- * (non-Javadoc)
- *
- * @see com.vaadin.data.Container.Sortable#sort(java.lang.Object[],
- * boolean[])
- */
@Override
public void sort(Object[] propertyId, boolean[] ascending) {
sortContainer(propertyId, ascending);
return !getContainerFilters().isEmpty();
}
- /*
- * (non-Javadoc)
- *
- * @see com.vaadin.data.Container.Filterable#getContainerFilters()
- */
protected Collection<Filter> getContainerFilters() {
return Collections.unmodifiableCollection(filters);
}
}
}
+ // LegacyPropertyHelper has been removed in Vaadin 8
+
/* Events */
/**
*/
public void addNestedProperty(String nestedPropertyId) {
addItemProperty(nestedPropertyId,
- new NestedMethodProperty<BT>(getBean(), nestedPropertyId));
+ new NestedMethodProperty<Object>(getBean(), nestedPropertyId));
}
/**
*
* @param bean
* The new bean to use for this item, not <code>null</code>
+ * @since 7.7.7
*/
public void setBean(BT bean) {
if (bean == null) {
}
- /*
- * (non-Javadoc)
- *
- * @see com.vaadin.data.util.IndexedContainer#addItem()
- */
@Override
public Object addItem() {
disableContentsChangeEvents();
}
}
- /*
- * (non-Javadoc)
- *
- * @see com.vaadin.data.util.IndexedContainer#addItem(java.lang.Object)
- */
@Override
public Item addItem(Object itemId) {
disableContentsChangeEvents();
}
}
- /*
- * (non-Javadoc)
- *
- * @see com.vaadin.data.util.IndexedContainer#removeAllItems()
- */
@Override
public boolean removeAllItems() {
disableContentsChangeEvents();
}
}
- /*
- * (non-Javadoc)
- *
- * @see com.vaadin.data.util.IndexedContainer#removeItem(java.lang.Object )
- */
@Override
public boolean removeItem(Object itemId) {
disableContentsChangeEvents();
}
- /*
- * (non-Javadoc)
- *
- * @see com.vaadin.data.util.IndexedContainer#doSort()
- */
@Override
protected void doSort() {
super.doSort();
}
}
- /*
- * Overridden to provide filtering for root & children items.
- *
- * (non-Javadoc)
- *
- * @see com.vaadin.data.util.IndexedContainer#updateContainerFiltering()
- */
@Override
protected boolean doFilterContainer(boolean hasFilters) {
if (!hasFilters) {
private Set<Object> filterOverride = null;
- /*
- * (non-Javadoc)
- *
- * @see
- * com.vaadin.data.util.IndexedContainer#passesFilters(java.lang.Object)
- */
@Override
protected boolean passesFilters(Object itemId) {
if (filterOverride != null) {
firePropertyValueChange(this);
}
+ // LegacyPropertyHelper has been removed in Vaadin 8
+
/**
* Calculates a integer hash-code for the Property that's unique inside
* the Item containing the Property. Two different Properties inside the
? (ListSet<Object>) ((ListSet<Object>) getAllItemIds()).clone()
: null);
nc.setItemSetChangeListeners(getItemSetChangeListeners() != null
- ? new LinkedList<ItemSetChangeListener>(
+ ? new LinkedList<Container.ItemSetChangeListener>(
getItemSetChangeListeners())
: null);
nc.propertyIds = propertyIds != null
? (ArrayList<Object>) propertyIds.clone() : null;
nc.setPropertySetChangeListeners(getPropertySetChangeListeners() != null
- ? new LinkedList<PropertySetChangeListener>(
+ ? new LinkedList<Container.PropertySetChangeListener>(
getPropertySetChangeListeners())
: null);
nc.propertyValueChangeListeners = propertyValueChangeListeners != null
* The instance used by this property
*
* @return the instance used for fetching the property value
+ * @since 7.7.7
*/
public Object getInstance() {
return instance;
*
* @param instance
* the instance to use
+ * @since 7.7.7
*/
public void setInstance(Object instance) {
if (this.instance.getClass() != instance.getClass()) {
* The instance used by this property
*
* @return the instance used for fetching the property value
+ * @since 7.7.7
*/
public Object getInstance() {
return instance;
*
* @param instance
* the instance to use
+ * @since 7.7.7
*/
public void setInstance(Object instance) {
if (this.instance.getClass() != instance.getClass()) {
public NestedPropertyDescriptor(String name, Class<BT> beanType)
throws IllegalArgumentException {
this.name = name;
- NestedMethodProperty<?> property = new NestedMethodProperty<BT>(
+ NestedMethodProperty<?> property = new NestedMethodProperty<Object>(
beanType, name);
this.propertyType = property.getType();
}
@Override
public Property<?> createProperty(BT bean) {
- return new NestedMethodProperty<BT>(bean, name);
+ return new NestedMethodProperty<Object>(bean, name);
}
}
public void addPropertySetChangeListener(
Item.PropertySetChangeListener listener) {
if (propertySetChangeListeners == null) {
- propertySetChangeListeners = new LinkedList<Item.PropertySetChangeListener>();
+ propertySetChangeListeners = new LinkedList<PropertySetChangeListener>();
}
propertySetChangeListeners.add(listener);
}
}
if (session != null) {
+ // Intentional change in compatibility package
ConverterFactory factory = (ConverterFactory) session
.getConverterFactory();
if (factory == null) {
return propertyId;
}
+ // LegacyPropertyHelper has been removed in Vaadin 8
+
private static Logger getLogger() {
return Logger.getLogger(ColumnProperty.class.getName());
}
public void addItemSetChangeListener(
Container.ItemSetChangeListener listener) {
if (itemSetChangeListeners == null) {
- itemSetChangeListeners = new LinkedList<ItemSetChangeListener>();
+ itemSetChangeListeners = new LinkedList<Container.ItemSetChangeListener>();
}
itemSetChangeListeners.add(listener);
}
* field instead or bind the field to a {@link Property} of type
* {@link Double}.
*/
-@SuppressWarnings("serial")
@Deprecated
+@SuppressWarnings("serial")
public class DoubleValidator extends AbstractStringValidator {
/**
* <p>
* Abstract field component for implementing buffered property editors. The
* field may hold an internal value, or it may be connected to any data source
- * that implements the {@link Property}interface.
- * <code>LegacyAbstractField</code> implements that interface itself, too, so
- * accessing the Property value represented by it is straightforward.
+ * that implements the {@link Property} interface. <code>AbstractField</code>
+ * implements that interface itself, too, so accessing the Property value
+ * represented by it is straightforward.
* </p>
*
* <p>
- * LegacyAbstractField also provides the {@link Buffered} interface for
- * buffering the data source value. By default the LegacyField is in write
- * through-mode and {@link #setWriteThrough(boolean)}should be called to enable
- * buffering.
+ * AbstractField also provides the {@link Buffered} interface for buffering the
+ * data source value. By default the Field is in write through-mode and
+ * {@link #setWriteThrough(boolean)}should be called to enable buffering.
* </p>
*
* <p>
}
/**
- * Returns the type of the LegacyField. The methods <code>getValue</code>
- * and <code>setValue</code> must be compatible with this type: one must be
- * able to safely cast the value returned from <code>getValue</code> to the
- * given type and pass any variable assignable to this type as an argument
- * to <code>setValue</code>.
+ * Returns the type of the Field. The methods <code>getValue</code> and
+ * <code>setValue</code> must be compatible with this type: one must be able
+ * to safely cast the value returned from <code>getValue</code> to the given
+ * type and pass any variable assignable to this type as an argument to
+ * <code>setValue</code>.
*
- * @return the type of the LegacyField
+ * @return the type of the Field
*/
@Override
public abstract Class<? extends T> getType();
}
/**
- * Sets the buffered mode of this LegacyField.
+ * Sets the buffered mode of this Field.
* <p>
* When the field is in buffered mode, changes will not be committed to the
* property data source until {@link #commit()} is called.
}
/**
- * Checks the buffered mode of this LegacyField.
+ * Checks the buffered mode of this Field.
*
* @return true if buffered mode is on, false otherwise
*/
return buffered;
}
+ // LegacyPropertyHelper has been removed in Vaadin 8
+
/* Property interface implementation */
/**
}
/**
- * Checks the validity of the LegacyField.
+ * Checks the validity of the Field.
*
* A field is invalid if it is set as required (using
* {@link #setRequired(boolean)} and is empty, if one or several of the
} catch (final java.lang.NoSuchMethodException e) {
// This should never happen
throw new java.lang.RuntimeException(
- "Internal error finding methods in LegacyAbstractField");
+ "Internal error finding methods in AbstractField");
}
}
} catch (final java.lang.NoSuchMethodException e) {
// This should never happen
throw new java.lang.RuntimeException(
- "Internal error finding methods in LegacyAbstractField");
+ "Internal error finding methods in AbstractField");
}
}
}
/**
- * Sets the internal field value. This is purely used by LegacyAbstractField
- * to change the internal LegacyField value. It does not trigger valuechange
- * events. It can be overridden by the inheriting classes to update all
- * dependent variables.
+ * Sets the internal field value. This is purely used by AbstractField to
+ * change the internal Field value. It does not trigger valuechange events.
+ * It can be overridden by the inheriting classes to update all dependent
+ * variables.
*
* Subclasses can also override {@link #getInternalValue()} if necessary.
*
* Make sure w reset lastKnownTextContent field on value change. The
* clearing must happen here as well because TextChangeListener can
* revert the original value. Client must respect the value in this
- * case. LegacyAbstractField optimizes value change if the existing
- * value is reset. Also we need to force repaint if the flag is on.
+ * case. AbstractField optimizes value change if the existing value is
+ * reset. Also we need to force repaint if the flag is on.
*/
if (lastKnownTextContent != null) {
lastKnownTextContent = null;
}
/**
- * <p>
* This method restricts the hours that are shown per day. This affects the
* weekly view. The general contract is that <b>firstHour < lastHour</b>.
- * </p>
- *
* <p>
* Note that this only affects the rendering process. Events are still
* requested by the dates set by {@link #setStartDate(Date)} and
* {@link #setEndDate(Date)}.
- * </p>
+ * <p>
* You can use {@link #autoScaleVisibleHoursOfDay()} for automatic scaling
* of the visible hours based on current events.
*
}
/*
- * Overridden to keep the shared state in sync with the LegacyAbstractField
- * internal value. Should be removed once LegacyAbstractField is refactored
- * to use shared state.
+ * Overridden to keep the shared state in sync with the AbstractField
+ * internal value. Should be removed once AbstractField is refactored to use
+ * shared state.
*
* See tickets #10921 and #11064.
*/
* compatible with <code>java.util.Date</code>.
* </p>
* <p>
- * Since <code>DateField</code> extends <code>LegacyAbstractField</code> it
- * implements the {@link Buffered}interface.
+ * Since <code>DateField</code> extends <code>AbstractField</code> it implements
+ * the {@link Buffered}interface.
* </p>
* <p>
* A <code>DateField</code> is in write-through mode by default, so
* and flags about invalid input.
*/
setInternalValue(null);
+
+ /*
+ * Due to DateField's special implementation of isValid(),
+ * datefields validity may change although the logical value does
+ * not change. This is an issue for Form which expects that validity
+ * of Fields cannot change unless actual value changes.
+ *
+ * So we check if this field is inside a form and the form has
+ * registered this as a field. In this case we repaint the form.
+ * Without this hacky solution the form might not be able to clean
+ * validation errors etc. We could avoid this by firing an extra
+ * value change event, but feels like at least as bad solution as
+ * this.
+ */
+ notifyFormOfValidityChange();
markAsDirty();
return;
}
/**
* Creates fields based on the property type.
* <p>
- * The default field type is {@link LegacyTextField}. Other field types
- * generated by this method:
+ * The default field type is {@link TextField}. Other field types generated
+ * by this method:
* <p>
* <b>Boolean</b>: {@link CheckBox}.<br/>
- * <b>Date</b>: {@link LegacyDateField}(resolution: day).<br/>
+ * <b>Date</b>: {@link DateField}(resolution: day).<br/>
* <b>Item</b>: {@link Form}. <br/>
- * <b>default field type</b>: {@link LegacyTextField}.
+ * <b>default field type</b>: {@link TextField}.
* <p>
*
* @param type
import com.vaadin.v7.data.Property;
/**
- * LegacyField interface is implemented by all legacy field components that have
- * a value that the user can change through the user interface.
+ * Field interface is implemented by all classes (field components) that have a
+ * value that the user can change through the user interface.
*
- * LegacyField components are built upon the framework defined in the
- * LegacyField interface and the {@link AbstractField} base class.
+ * Field components are built upon the framework defined in the Field interface
+ * and the {@link AbstractField} base class.
*
- * The LegacyField interface inherits the {@link Component} superinterface and
- * also the {@link Property} interface to have a value for the field.
+ * The Field interface inherits the {@link Component} superinterface and also
+ * the {@link Property} interface to have a value for the field.
*
* @author Vaadin Ltd.
*
public String getRequiredError();
/**
- * An <code>Event</code> object specifying the LegacyField whose value has
- * been changed.
+ * An <code>Event</code> object specifying the Field whose value has been
+ * changed.
*
* @author Vaadin Ltd.
* @since 3.0
import com.vaadin.v7.data.Property;
import com.vaadin.v7.data.Validatable;
import com.vaadin.v7.data.Validator;
+import com.vaadin.v7.data.Validator.InvalidValueException;
import com.vaadin.v7.data.fieldgroup.FieldGroup;
import com.vaadin.v7.data.util.BeanItem;
import com.vaadin.v7.shared.form.FormState;
* @param formLayout
* the layout of the form.
* @param fieldFactory
- * the TableFieldFactory of the form.
+ * the FieldFactory of the form.
*/
public Form(Layout formLayout, FormFieldFactory fieldFactory) {
super();
*/
@Override
public void commit()
- throws Buffered.SourceException, Validator.InvalidValueException {
+ throws Buffered.SourceException, InvalidValueException {
LinkedList<SourceException> problems = null;
* @see Validatable#validate()
*/
@Override
- public void validate() throws Validator.InvalidValueException {
+ public void validate() throws InvalidValueException {
super.validate();
for (final Iterator<Object> i = propertyIds.iterator(); i.hasNext();) {
fields.get(i.next()).validate();
/*
* Copyright 2000-2016 Vaadin Ltd.
- *
+ *
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the License. You may obtain a copy of
* the License at
- *
+ *
* http://www.apache.org/licenses/LICENSE-2.0
- *
+ *
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* property id and uiContext (the component responsible for displaying fields).
* Currently this interface is used by {@link Form}, but might later be used by
* some other components for {@link Field} generation.
- *
+ *
* <p>
- *
+ *
* @author Vaadin Ltd.
* @since 6.0
* @see TableFieldFactory
/**
* Creates a field based on the item, property id and the component (most
* commonly {@link Form}) where the Field will be presented.
- *
+ *
* @param item
* the item where the property belongs to.
* @param propertyId
import com.vaadin.v7.shared.ui.grid.selection.MultiSelectionModelState;
import com.vaadin.v7.shared.ui.grid.selection.SingleSelectionModelServerRpc;
import com.vaadin.v7.shared.ui.grid.selection.SingleSelectionModelState;
+import com.vaadin.v7.ui.Grid.SelectionModel.HasUserSelectionAllowed;
import com.vaadin.v7.ui.renderers.HtmlRenderer;
import com.vaadin.v7.ui.renderers.Renderer;
import com.vaadin.v7.ui.renderers.TextRenderer;
*/
@Deprecated
public interface SelectionModel extends Serializable, Extension {
+
+ /**
+ * Interface implemented by selection models which support disabling
+ * client side selection while still allowing programmatic selection on
+ * the server.
+ *
+ * @since 7.7.7
+ */
+ public interface HasUserSelectionAllowed extends SelectionModel {
+
+ /**
+ * Checks if the user is allowed to change the selection.
+ *
+ * @return <code>true</code> if the user is allowed to change the
+ * selection, <code>false</code> otherwise
+ */
+ public boolean isUserSelectionAllowed();
+
+ /**
+ * Sets whether the user is allowed to change the selection.
+ *
+ * @param userSelectionAllowed
+ * <code>true</code> if the user is allowed to change the
+ * selection, <code>false</code> otherwise
+ */
+ public void setUserSelectionAllowed(boolean userSelectionAllowed);
+
+ }
+
/**
* Checks whether an item is selected or not.
*
*/
@Deprecated
public static class SingleSelectionModel extends AbstractSelectionModel
- implements SelectionModel.Single {
+ implements SelectionModel.Single, HasUserSelectionAllowed {
@Override
protected void extend(AbstractClientConnector target) {
@Override
public void select(String rowKey) {
+ if (!isUserSelectionAllowed()) {
+ throw new IllegalStateException(
+ "Client tried to select '" + rowKey
+ + "' although user selection is disallowed");
+ }
SingleSelectionModel.this.select(getItemId(rowKey), false);
}
});
protected SingleSelectionModelState getState() {
return (SingleSelectionModelState) super.getState();
}
+
+ @Override
+ protected SingleSelectionModelState getState(boolean markAsDirty) {
+ return (SingleSelectionModelState) super.getState(markAsDirty);
+ }
+
+ @Override
+ public boolean isUserSelectionAllowed() {
+ return getState(false).userSelectionAllowed;
+ }
+
+ @Override
+ public void setUserSelectionAllowed(boolean userSelectionAllowed) {
+ getState().userSelectionAllowed = userSelectionAllowed;
+ }
}
/**
*/
@Deprecated
public static class MultiSelectionModel extends AbstractSelectionModel
- implements SelectionModel.Multi {
+ implements SelectionModel.Multi,
+ SelectionModel.HasUserSelectionAllowed {
/**
* The default selection size limit.
@Override
public void select(List<String> rowKeys) {
+ if (!isUserSelectionAllowed()) {
+ throw new IllegalStateException(
+ "Client tried to select '" + rowKeys
+ + "' although user selection is disallowed");
+ }
+
List<Object> items = new ArrayList<Object>();
for (String rowKey : rowKeys) {
items.add(getItemId(rowKey));
@Override
public void deselect(List<String> rowKeys) {
+ if (!isUserSelectionAllowed()) {
+ throw new IllegalStateException(
+ "Client tried to deselect '" + rowKeys
+ + "' although user selection is disallowed");
+ }
+
List<Object> items = new ArrayList<Object>();
for (String rowKey : rowKeys) {
items.add(getItemId(rowKey));
@Override
public void selectAll() {
+ if (!isUserSelectionAllowed()) {
+ throw new IllegalStateException(
+ "Client tried to select all although user selection is disallowed");
+ }
+
MultiSelectionModel.this.selectAll(false);
}
@Override
public void deselectAll() {
+ if (!isUserSelectionAllowed()) {
+ throw new IllegalStateException(
+ "Client tried to deselect all although user selection is disallowed");
+ }
+
MultiSelectionModel.this.deselectAll(false);
}
});
protected MultiSelectionModelState getState() {
return (MultiSelectionModelState) super.getState();
}
+
+ @Override
+ protected MultiSelectionModelState getState(boolean markAsDirty) {
+ return (MultiSelectionModelState) super.getState(markAsDirty);
+ }
+
+ @Override
+ public boolean isUserSelectionAllowed() {
+ return getState(false).userSelectionAllowed;
+ }
+
+ @Override
+ public void setUserSelectionAllowed(boolean userSelectionAllowed) {
+ getState().userSelectionAllowed = userSelectionAllowed;
+ }
}
/**
}
/**
- * Merges columns cells in a row
+ * Merges columns cells in a row.
*
* @param propertyIds
* The property ids of columns to merge
* @return The remaining visible cell after the merge
*/
public CELLTYPE join(Object... propertyIds) {
- assert propertyIds.length > 1 : "You need to merge at least 2 properties";
+ if (propertyIds.length < 2) {
+ throw new IllegalArgumentException(
+ "You need to merge at least 2 properties");
+ }
Set<CELLTYPE> cells = new HashSet<CELLTYPE>();
for (int i = 0; i < propertyIds.length; ++i) {
}
/**
- * Merges columns cells in a row
+ * Merges columns cells in a row.
*
* @param cells
* The cells to merge. Must be from the same row.
* @return The remaining visible cell after the merge
*/
public CELLTYPE join(CELLTYPE... cells) {
- assert cells.length > 1 : "You need to merge at least 2 cells";
+ if (cells.length < 2) {
+ throw new IllegalArgumentException(
+ "You need to merge at least 2 cells");
+ }
return join(new HashSet<CELLTYPE>(Arrays.asList(cells)));
}
* own Container.
*
* @see #setContainerDataSource(Indexed)
- * @see #LegacyGrid()
+ * @see #Grid()
*/
private boolean defaultContainer = true;
* @return unmodifiable copy of current columns in visual order
*/
public List<Column> getColumns() {
- List<Column> columns = new ArrayList<Column>();
+ List<Column> columns = new ArrayList<Grid.Column>();
for (String columnId : getState(false).columnOrder) {
columns.add(getColumnByColumnId(columnId));
}
}
}
+ /**
+ * Refreshes, i.e. causes the client side to re-render all rows.
+ *
+ * @since 7.7.7
+ */
+ public void refreshAllRows() {
+ datasourceExtension.refreshCache();
+ }
+
private static Logger getLogger() {
return Logger.getLogger(Grid.class.getName());
}
* spacing on by default
*/
@Deprecated
+@SuppressWarnings("serial")
public class HorizontalLayout extends com.vaadin.ui.HorizontalLayout {
/**
* Constructs an empty HorizontalLayout.
markAsDirty();
}
+ // LegacyPropertyHelper has been removed in Vaadin 8
+
/*
* (non-Javadoc)
*
super(caption);
}
+ // Columns are no longer used for width.
+
public int getRows() {
return rows;
}
@Override
public void paintContent(PaintTarget target) throws PaintException {
+ // Width is no longer based on columns
// Adds the number of rows
if (rows != 0) {
target.addAttribute("rows", rows);
}
/*
- * Overridden to keep the shared state in sync with the LegacyAbstractField
- * internal value. Should be removed once LegacyAbstractField is refactored
- * to use shared state.
+ * Overridden to keep the shared state in sync with the AbstractField
+ * internal value. Should be removed once AbstractField is refactored to use
+ * shared state.
*
* See tickets #10921 and #11064.
*/
/**
* Binds an item property to a field generated by TableFieldFactory. The
- * default behavior is to bind property straight to LegacyField. If
+ * default behavior is to bind property straight to Field. If
* Property.Viewer type property (e.g. PropertyFormatter) is already set for
* field, the property is bound to that Property.Viewer.
*
*
* The FieldFactory is only used if the Table is editable.
*
- * @return TableFieldFactory used to create the LegacyField instances.
+ * @return TableFieldFactory used to create the Field instances.
* @see #isEditable
*/
public TableFieldFactory getTableFieldFactory() {
/**
* Is table editable.
*
- * If table is editable a editor of type LegacyField is created for each
- * table cell. The assigned FieldFactory is used to create the instances.
+ * If table is editable a editor of type Field is created for each table
+ * cell. The assigned FieldFactory is used to create the instances.
*
* To provide custom editors for table cells create a class implementing the
* FieldFactory interface, and assign it to table, and set the editable
/**
* Sets the editable property.
*
- * If table is editable a editor of type LegacyField is created for each
- * table cell. The assigned FieldFactory is used to create the instances.
+ * If table is editable a editor of type Field is created for each table
+ * cell. The assigned FieldFactory is used to create the instances.
*
* To provide custom editors for table cells create a class implementing the
* FieldFactory interface, and assign it to table, and set the editable
import com.vaadin.v7.data.Container;
/**
- * Factory interface for creating new LegacyField-instances based on Container
+ * Factory interface for creating new Field-instances based on Container
* (datasource), item id, property id and uiContext (the component responsible
* for displaying fields). Currently this interface is used by {@link Table},
* but might later be used by some other components for {@link Field}
* </p>
*
* <p>
- * Since <code>TextField</code> extends <code>LegacyAbstractField</code> it
- * implements the {@link Buffered} interface. A <code>TextField</code> is in
- * write-through mode by default, so
- * {@link AbstractField#setWriteThrough(boolean)} must be called to enable
- * buffering.
+ * Since <code>TextField</code> extends <code>AbstractField</code> it implements
+ * the {@link Buffered} interface. A <code>TextField</code> is in write-through
+ * mode by default, so {@link AbstractField#setWriteThrough(boolean)} must be
+ * called to enable buffering.
* </p>
*
* @author Vaadin Ltd.
if (actionHandler != null) {
if (actionHandlers == null) {
- actionHandlers = new LinkedList<Handler>();
+ actionHandlers = new LinkedList<Action.Handler>();
actionMapper = new KeyMapper<Action>();
}
setMultiSelect(true);
}
+ // Columns are no longer used for width.
+
public int getRows() {
return rows;
}
@Override
public void paintContent(PaintTarget target) throws PaintException {
- // Adds the number of columns
+ // Width is no longer based on columns
// Adds the number of rows
if (rows != 0) {
target.addAttribute("rows", rows);
return event;
}
- /*
- * (non-Javadoc)
- *
- * @see
- * com.vaadin.addon.calendar.event.CalendarEventProvider#getEvents(java.
- * util.Date, java.util.Date)
- */
@Override
public List<CalendarEvent> getEvents(Date startDate, Date endDate) {
eventCache.clear();
return Collections.unmodifiableList(eventCache);
}
- /*
- * (non-Javadoc)
- *
- * @see com.vaadin.addon.calendar.event.CalendarEventProvider.
- * EventSetChangeNotifier
- * #addListener(com.vaadin.addon.calendar.event.CalendarEventProvider.
- * EventSetChangeListener)
- */
@Override
public void addEventSetChangeListener(EventSetChangeListener listener) {
if (!eventSetChangeListeners.contains(listener)) {
}
}
- /*
- * (non-Javadoc)
- *
- * @see com.vaadin.addon.calendar.event.CalendarEventProvider.
- * EventSetChangeNotifier
- * #removeListener(com.vaadin.addon.calendar.event.CalendarEventProvider.
- * EventSetChangeListener)
- */
@Override
public void removeEventSetChangeListener(EventSetChangeListener listener) {
eventSetChangeListeners.remove(listener);
}
- /*
- * (non-Javadoc)
- *
- * @see com.vaadin.addon.calendar.event.CalendarEvent.EventChangeNotifier#
- * addListener
- * (com.vaadin.addon.calendar.event.CalendarEvent.EventChangeListener)
- */
@Override
public void addEventChangeListener(EventChangeListener listener) {
if (eventChangeListeners.contains(listener)) {
}
}
- /*
- * (non-Javadoc)
- *
- * @see com.vaadin.addon.calendar.event.CalendarEvent.EventChangeNotifier#
- * removeListener
- * (com.vaadin.addon.calendar.event.CalendarEvent.EventChangeListener)
- */
@Override
public void removeEventChangeListener(EventChangeListener listener) {
eventChangeListeners.remove(listener);
return allDayProperty;
}
- /*
- * (non-Javadoc)
- *
- * @see
- * com.vaadin.data.Container.ItemSetChangeListener#containerItemSetChange
- * (com.vaadin.data.Container.ItemSetChangeEvent)
- */
@Override
public void containerItemSetChange(ItemSetChangeEvent event) {
if (event.getContainer() == container) {
}
}
- /*
- * (non-Javadoc)
- *
- * @see
- * com.vaadin.data.Property.ValueChangeListener#valueChange(com.vaadin.data
- * .Property.ValueChangeEvent)
- */
@Override
public void valueChange(ValueChangeEvent event) {
/*
*/
}
- /*
- * (non-Javadoc)
- *
- * @see
- * com.vaadin.addon.calendar.ui.CalendarComponentEvents.EventMoveHandler
- * #eventMove
- * (com.vaadin.addon.calendar.ui.CalendarComponentEvents.MoveEvent)
- */
@Override
public void eventMove(MoveEvent event) {
CalendarEvent ce = event.getCalendarEvent();
}
}
- /*
- * (non-Javadoc)
- *
- * @see
- * com.vaadin.addon.calendar.ui.CalendarComponentEvents.EventResizeHandler
- * #eventResize
- * (com.vaadin.addon.calendar.ui.CalendarComponentEvents.EventResize)
- */
@Override
public void eventResize(EventResize event) {
CalendarEvent ce = event.getCalendarEvent();
ignoreContainerEvents();
}
- /*
- * (non-Javadoc)
- *
- * @see
- * com.vaadin.addon.calendar.event.CalendarEditableEventProvider#addEvent
- * (com.vaadin.addon.calendar.event.CalendarEvent)
- */
@Override
public void addEvent(CalendarEvent event) {
Item item;
}
}
- /*
- * (non-Javadoc)
- *
- * @see
- * com.vaadin.addon.calendar.event.CalendarEditableEventProvider#removeEvent
- * (com.vaadin.addon.calendar.event.CalendarEvent)
- */
@Override
public void removeEvent(CalendarEvent event) {
container.removeItem(event);
/*
* Copyright 2000-2016 Vaadin Ltd.
- *
+ *
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the License. You may obtain a copy of
* the License at
- *
+ *
* http://www.apache.org/licenses/LICENSE-2.0
- *
+ *
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
/**
* A component that represents color selection preview within a color picker.
- *
+ *
* @since 7.0.0
*/
@Deprecated
-public class ColorPickerPreview extends CssLayout implements ColorSelector,
- ValueChangeListener {
+public class ColorPickerPreview extends CssLayout
+ implements ColorSelector, ValueChangeListener {
private static final String STYLE_DARK_COLOR = "v-textfield-dark";
private static final String STYLE_LIGHT_COLOR = "v-textfield-light";
// Set the text color
field.removeStyleName(STYLE_DARK_COLOR);
field.removeStyleName(STYLE_LIGHT_COLOR);
- if (this.color.getRed() + this.color.getGreen() + this.color
- .getBlue() < 3 * 128) {
+ if (this.color.getRed() + this.color.getGreen()
+ + this.color.getBlue() < 3 * 128) {
field.addStyleName(STYLE_DARK_COLOR);
} else {
field.addStyleName(STYLE_LIGHT_COLOR);
value.length() - 1).split(",");
int hue = Integer.parseInt(colors[0]);
- int saturation = Integer.parseInt(colors[1]
- .replace("%", ""));
+ int saturation = Integer
+ .parseInt(colors[1].replace("%", ""));
int lightness = Integer
.parseInt(colors[2].replace("%", ""));
int rgb = Color.HSLtoRGB(hue, saturation, lightness);
/*
* Copyright 2000-2016 Vaadin Ltd.
- *
+ *
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the License. You may obtain a copy of
* the License at
- *
+ *
* http://www.apache.org/licenses/LICENSE-2.0
- *
+ *
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
/**
* A component that represents color selection swatches within a color picker.
- *
+ *
* @since 7.0.0
*/
@Deprecated
-public class ColorPickerSelect extends CustomComponent implements
- ColorSelector, ValueChangeListener {
+public class ColorPickerSelect extends CustomComponent
+ implements ColorSelector, ValueChangeListener {
/** The range. */
private final ComboBox range;
/**
* Instantiates a new color range property id.
- *
+ *
* @param caption
* the caption
*/
/**
* Instantiates a new color picker select.
- *
+ *
* @param rows
* the rows
* @param columns
/**
* Creates the all colors.
- *
+ *
* @param rows
* the rows
* @param columns
* the columns
- *
+ *
* @return the color[][]
*/
private Color[][] createAllColors(int rows, int columns) {
value = 1f - ((row - (rows / 2f)) / (rows / 2f));
}
- colors[row][col] = new Color(Color.HSVtoRGB(hue,
- saturation, value));
+ colors[row][col] = new Color(
+ Color.HSVtoRGB(hue, saturation, value));
}
// The last row should have the black&white gradient
float saturation = 0f;
float value = 1f - ((float) col / (float) columns);
- colors[row][col] = new Color(Color.HSVtoRGB(hue,
- saturation, value));
+ colors[row][col] = new Color(
+ Color.HSVtoRGB(hue, saturation, value));
}
}
}
/**
* Creates the color.
- *
+ *
* @param color
* the color
* @param rows
* the rows
* @param columns
* the columns
- *
+ *
* @return the color[][]
*/
private Color[][] createColors(Color color, int rows, int columns) {
/ (((float) rows * (float) columns) / 2f);
} else {
index -= ((rows * columns) / 2);
- value = 1f - index
- / (((float) rows * (float) columns) / 2f);
+ value = 1f
+ - index / (((float) rows * (float) columns) / 2f);
}
- colors[row][col] = new Color(Color.HSVtoRGB(hue, saturation,
- value));
+ colors[row][col] = new Color(
+ Color.HSVtoRGB(hue, saturation, value));
}
}
* <li><code>init(cell)</code> - Prepares a cell for rendering. Corresponds to
* {@link com.vaadin.client.renderers.ComplexRenderer#init(com.vaadin.client.widget.grid.RendererCellReference)}
* .</li>
- * <li><code>destory(cell)</code> - Allows the renderer to release resources
+ * <li><code>destroy(cell)</code> - Allows the renderer to release resources
* allocate for a cell that will no longer be used. Corresponds to
* {@link com.vaadin.client.renderers.ComplexRenderer#destroy(com.vaadin.client.widget.grid.RendererCellReference)}
* .</li>
for (Class<?> c : classes) {
boolean found = false;
for (Method m : c.getDeclaredMethods()) {
+ // Intentional change in compatibility package
String methodName = m.getName();
if (methodName.startsWith("add")
&& methodName.endsWith("Listener")
private Method getAddListenerMethod(Class<?> cls, Class<?> listenerClass)
throws SecurityException, NoSuchMethodException {
+ // Intentional change in compatibility package
return cls.getMethod("add" + listenerClass.getSimpleName(),
listenerClass);
private Method getRemoveListenerMethod(Class<?> cls, Class<?> listenerClass)
throws SecurityException, NoSuchMethodException {
+ // Intentional change in compatibility package
return cls.getMethod("remove" + listenerClass.getSimpleName(),
listenerClass);
registeredListeners.toArray());
}
-}
\ No newline at end of file
+}
slider.setValue(-1.0);
} catch (Slider.ValueOutOfBoundsException e) {
- assertThat(e.getMessage(),
- containsString("Value -1.0 is out of bounds: [0.0, 100.0]"));
+ assertThat(e.getMessage(), containsString(
+ "Value -1.0 is out of bounds: [0.0, 100.0]"));
}
}
// TODO should improve performance of these methods
private static final long ADD_ITEM_AT_FAIL_THRESHOLD = 5000;
private static final long ADD_ITEM_AFTER_FAIL_THRESHOLD = 5000;
+ // FIXME: Vaadin 7 compatibility version fails this check with original
+ // value of 5000
private static final long ADD_ITEM_AFTER_LAST_FAIL_THRESHOLD = 6000;
private static final long ADD_ITEMS_CONSTRUCTOR_FAIL_THRESHOLD = 200;
container.commit();
Item item = getItem(container.lastItemId());
- assertThat(item.getItemProperty(NAME).getValue(), is("foo"));
+ assertThat(item.getItemProperty(NAME).getValue().toString(), is("foo"));
}
@Test
container.refresh();
- assertThat(getItem(existingItemId).getItemProperty(NAME).getValue(),
- is("foo"));
+ assertThat(getItem(existingItemId).getItemProperty(NAME).getValue()
+ .toString(), is("foo"));
}
@Test
@Test
public void generateSelectQuery_filtersAndOrderingSet_shouldSucceed() {
SQLGenerator sg = new DefaultSQLGenerator();
- List<com.vaadin.v7.data.Container.Filter> f = new ArrayList<Filter>();
+ List<Filter> f = new ArrayList<Filter>();
f.add(new Like("name", "%lle"));
List<OrderBy> ob = Arrays.asList(new OrderBy("name", true));
StatementHelper sh = sg.generateSelectQuery("TABLE", f, ob, 0, 0, null);
private void checkNode(Node node) {
if (node instanceof Element) {
- assertTrue("Expected " + node.nodeName() + " to start with v-",
+ assertTrue("Wrong design element prefix",
node.nodeName().startsWith("v-"));
for (Node child : node.childNodes()) {
checkNode(child);
assertFalse(field.getValidators().contains(validator2));
}
+ @Test
+ public void validatorShouldMakeImmediate() {
+ assertFalse("field should not be immediate by default",
+ field.isImmediate());
+ field.addValidator(validator);
+ assertTrue("field should be immediate when it has a validator",
+ field.isImmediate());
+ }
+
@Test
public void nonImmediateFieldWithValidator() {
field.setImmediate(false);
field.isImmediate());
}
+ @Test
+ public void removeValidatorMakesNonImmediate() {
+ field.addValidator(validator);
+ field.removeValidator(validator);
+ assertFalse("field should be non-immediate after validator was removed",
+ field.isImmediate());
+ }
+
+ @Test
+ public void requiredMakesImmediate() {
+ assertFalse("field should not be immediate by default",
+ field.isImmediate());
+ field.setRequired(true);
+ assertTrue("field should be immediate when it is required",
+ field.isImmediate());
+ }
+
+ @Test
+ public void removeRequiredMakesNonImmediate() {
+ assertFalse("field should not be immediate by default",
+ field.isImmediate());
+ field.setRequired(true);
+ field.setRequired(false);
+ assertFalse("field should not be immediate even though it was required",
+ field.isImmediate());
+ }
}
package com.vaadin.v7.tests.server.component.abstractfield;
import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import java.util.Locale;
import com.vaadin.v7.data.util.converter.Converter;
import com.vaadin.v7.data.util.converter.Converter.ConversionException;
import com.vaadin.v7.data.util.converter.StringToIntegerConverter;
+import com.vaadin.v7.ui.CheckBox;
import com.vaadin.v7.ui.TextField;
public class AbsFieldValueConversionsTest {
tf.getValue());
}
+ @Test
+ public void testBooleanNullConversion() {
+ CheckBox cb = new CheckBox();
+ cb.setConverter(new Converter<Boolean, Boolean>() {
+
+ @Override
+ public Boolean convertToModel(Boolean value,
+ Class<? extends Boolean> targetType, Locale locale) {
+ // value from a CheckBox should never be null as long as it is
+ // not set to null (handled by conversion below).
+ assertNotNull(value);
+ return value;
+ }
+
+ @Override
+ public Boolean convertToPresentation(Boolean value,
+ Class<? extends Boolean> targetType, Locale locale) {
+ // Datamodel -> field
+ if (value == null) {
+ return false;
+ }
+
+ return value;
+ }
+
+ @Override
+ public Class<Boolean> getModelType() {
+ return Boolean.class;
+ }
+
+ @Override
+ public Class<Boolean> getPresentationType() {
+ return Boolean.class;
+ }
+
+ });
+ MethodProperty<Boolean> property = new MethodProperty<Boolean>(
+ paulaBean, "deceased");
+ cb.setPropertyDataSource(property);
+ assertEquals(Boolean.FALSE, property.getValue());
+ assertEquals(Boolean.FALSE, cb.getValue());
+ Boolean newDmValue = cb.getConverter().convertToPresentation(
+ cb.getValue(), Boolean.class, new Locale("fi", "FI"));
+ assertEquals(Boolean.FALSE, newDmValue);
+
+ // FIXME: Should be able to set to false here to cause datamodel to be
+ // set to false but the change will not be propagated to the Property
+ // (field value is already false)
+
+ cb.setValue(true);
+ assertEquals(Boolean.TRUE, cb.getValue());
+ assertEquals(Boolean.TRUE, property.getValue());
+
+ cb.setValue(false);
+ assertEquals(Boolean.FALSE, cb.getValue());
+ assertEquals(Boolean.FALSE, property.getValue());
+
+ }
+
// Now specific to Integer because StringToNumberConverter has been removed
public static class NumberBean {
private Integer number;
import com.vaadin.v7.data.Property.ReadOnlyStatusChangeListener;
import com.vaadin.v7.data.Property.ValueChangeEvent;
import com.vaadin.v7.data.Property.ValueChangeListener;
-import com.vaadin.v7.ui.Table;
+import com.vaadin.v7.ui.CheckBox;
public class AbstractFieldListenersTest
extends AbstractListenerMethodsTestBase {
@Test
public void testReadOnlyStatusChangeListenerAddGetRemove()
throws Exception {
- testListenerAddGetRemove(Table.class, ReadOnlyStatusChangeEvent.class,
+ testListenerAddGetRemove(CheckBox.class,
+ ReadOnlyStatusChangeEvent.class,
ReadOnlyStatusChangeListener.class);
}
@Test
public void testValueChangeListenerAddGetRemove() throws Exception {
- testListenerAddGetRemove(Table.class, ValueChangeEvent.class,
+ testListenerAddGetRemove(CheckBox.class, ValueChangeEvent.class,
ValueChangeListener.class);
}
}
.applyInvocation(invocation);
}
-}
\ No newline at end of file
+}
import org.junit.Before;
import org.junit.Test;
+import com.vaadin.ui.ComponentTest;
import com.vaadin.v7.data.Container;
import com.vaadin.v7.data.util.IndexedContainer;
import com.vaadin.v7.event.SelectionEvent;
import com.vaadin.v7.event.SelectionEvent.SelectionListener;
+import com.vaadin.v7.shared.ui.grid.selection.MultiSelectionModelServerRpc;
import com.vaadin.v7.shared.ui.grid.selection.MultiSelectionModelState;
import com.vaadin.v7.ui.Grid;
}
Assert.fail("Not all items were correctly selected");
}
+
+ @Test(expected = IllegalStateException.class)
+ public void refuseSelectWhenUserSelectionDisallowed() {
+ ((HasUserSelectionAllowed) grid.getSelectionModel())
+ .setUserSelectionAllowed(false);
+ MultiSelectionModelServerRpc serverRpc = ComponentTest.getRpcProxy(
+ grid.getSelectionModel(), MultiSelectionModelServerRpc.class);
+ serverRpc.select(Collections.singletonList("a"));
+ }
+
+ @Test(expected = IllegalStateException.class)
+ public void refuseDeselectWhenUserSelectionDisallowed() {
+ ((HasUserSelectionAllowed) grid.getSelectionModel())
+ .setUserSelectionAllowed(false);
+ MultiSelectionModelServerRpc serverRpc = ComponentTest.getRpcProxy(
+ grid.getSelectionModel(), MultiSelectionModelServerRpc.class);
+ serverRpc.deselect(Collections.singletonList("a"));
+ }
+
+ @Test(expected = IllegalStateException.class)
+ public void refuseSelectAllWhenUserSelectionDisallowed() {
+ ((HasUserSelectionAllowed) grid.getSelectionModel())
+ .setUserSelectionAllowed(false);
+ MultiSelectionModelServerRpc serverRpc = ComponentTest.getRpcProxy(
+ grid.getSelectionModel(), MultiSelectionModelServerRpc.class);
+ serverRpc.selectAll();
+ }
+
+ @Test(expected = IllegalStateException.class)
+ public void refuseDeselectAllWhenUserSelectionDisallowed() {
+ ((HasUserSelectionAllowed) grid.getSelectionModel())
+ .setUserSelectionAllowed(false);
+ MultiSelectionModelServerRpc serverRpc = ComponentTest.getRpcProxy(
+ grid.getSelectionModel(), MultiSelectionModelServerRpc.class);
+ serverRpc.deselectAll();
+ }
}
import org.junit.Before;
import org.junit.Test;
+import com.vaadin.ui.ComponentTest;
import com.vaadin.v7.data.Container;
import com.vaadin.v7.data.util.IndexedContainer;
import com.vaadin.v7.event.SelectionEvent;
import com.vaadin.v7.event.SelectionEvent.SelectionListener;
+import com.vaadin.v7.shared.ui.grid.selection.SingleSelectionModelServerRpc;
import com.vaadin.v7.ui.Grid;
import com.vaadin.v7.ui.Grid.SelectionMode;
import com.vaadin.v7.ui.Grid.SingleSelectionModel;
}
});
}
+
+ @Test(expected = IllegalStateException.class)
+ public void refuseSelectionWhenUserSelectionDisallowed() {
+ ((HasUserSelectionAllowed) grid.getSelectionModel())
+ .setUserSelectionAllowed(false);
+ SingleSelectionModelServerRpc serverRpc = ComponentTest.getRpcProxy(
+ grid.getSelectionModel(), SingleSelectionModelServerRpc.class);
+ serverRpc.select("a");
+ }
}
}
protected String getTag() {
+ // Compatibility classes have a different prefix
return "vaadin7-table";
}
/**
* Collection of modes used for resizing columns in the Grid.
- *
+ *
* @since 7.7.5
*/
public enum ColumnResizeMode {
*/
SIMPLE
-}
\ No newline at end of file
+}
/* Select All -checkbox status */
public boolean allSelected;
-
+ public boolean userSelectionAllowed = true;
}
/* Allow deselecting rows */
public boolean deselectAllowed = true;
+ public boolean userSelectionAllowed = true;
}
import java.io.Serializable;
public class OptionGroupConstants implements Serializable {
+ // Vaadin 8 option group uses state for HTML content
public static final String ATTRIBUTE_OPTION_DISABLED = "disabled";
}
}
public boolean indeterminate = false;
@NoLayout
- public float state = 0.0f;
+ public Float state = 0.0f;
}
projects / vaadin-framework.git / commitdiff