import com.vaadin.shared.ui.grid.Range;
import com.vaadin.shared.ui.grid.ScrollDestination;
import com.vaadin.shared.ui.grid.SortDirection;
+import com.vaadin.shared.ui.grid.SortEventOriginator;
/**
* A data grid view that supports columns and lazy loading of data rows from a
}
}
- // Perform sorting
- Grid.this.sort(sorting);
+ // Perform sorting; indicate originator as user
+ Grid.this.setSortOrder(sorting.build(), SortEventOriginator.USER);
}
}
* a sort order list. If set to null, the sort order is cleared.
*/
public void setSortOrder(List<SortOrder> order) {
+ setSortOrder(order, SortEventOriginator.API);
+ }
+
+ private void setSortOrder(List<SortOrder> order,
+ SortEventOriginator originator) {
sortOrder.clear();
if (order != null) {
sortOrder.addAll(order);
}
- sort();
+ sort(originator);
}
/**
/**
* Apply sorting to data source.
*/
- private void sort() {
+ private void sort(SortEventOriginator originator) {
refreshHeader();
fireEvent(new SortEvent<T>(this,
- Collections.unmodifiableList(sortOrder)));
+ Collections.unmodifiableList(sortOrder), originator));
}
}
if (!Arrays.equals(columnIds, getState().sortColumns)
|| !Arrays.equals(directions, getState().sortDirs)) {
// Report back to server if changed
- getRpcProxy(GridServerRpc.class)
- .sort(columnIds, directions);
+ getRpcProxy(GridServerRpc.class).sort(columnIds,
+ directions, event.getOriginator());
}
}
});
import com.google.gwt.event.shared.GwtEvent;
import com.vaadin.client.data.DataSource;
import com.vaadin.client.ui.grid.Grid;
+import com.vaadin.shared.ui.grid.SortEventOriginator;
/**
* A sort event, fired by the Grid when it needs its data source to provide data
private final Grid<T> grid;
private final List<SortOrder> order;
+ private final SortEventOriginator originator;
/**
* Creates a new Sort Event. All provided parameters are final, and passed
*
* @param grid
* a grid reference
- * @param datasource
- * a reference to the grid's data source
* @param order
* an array dictating the desired sort order of the data source
+ * @param originator
+ * a value indicating where this event originated from
*/
- public SortEvent(Grid<T> grid, List<SortOrder> order) {
+ public SortEvent(Grid<T> grid, List<SortOrder> order,
+ SortEventOriginator originator) {
this.grid = grid;
this.order = order;
+ this.originator = originator;
}
@Override
return order;
}
+ /**
+ * Gets a value describing the originator of this event, i.e. what actions
+ * resulted in this event being fired.
+ *
+ * @return a sort event originator value
+ *
+ * @see SortEventOriginator
+ */
+ public SortEventOriginator getOriginator() {
+ return originator;
+ }
+
@SuppressWarnings("unchecked")
@Override
protected void dispatch(SortEventHandler<?> handler) {
import com.vaadin.shared.ui.grid.HeightMode;
import com.vaadin.shared.ui.grid.ScrollDestination;
import com.vaadin.shared.ui.grid.SortDirection;
+import com.vaadin.shared.ui.grid.SortEventOriginator;
import com.vaadin.ui.AbstractComponent;
import com.vaadin.ui.Component;
import com.vaadin.ui.HasComponents;
}
@Override
- public void sort(String[] columnIds, SortDirection[] directions) {
+ public void sort(String[] columnIds, SortDirection[] directions,
+ SortEventOriginator originator) {
assert columnIds.length == directions.length;
List<SortOrder> order = new ArrayList<SortOrder>(
order.add(new SortOrder(propertyId, directions[i]));
}
- setSortOrder(order);
+ setSortOrder(order, originator);
}
});
}
}
}
- sort();
+ sort(SortEventOriginator.INTERNAL);
} else {
// If the new container is not sortable, we'll just re-set the sort
*/
public void clearSortOrder() {
sortOrder.clear();
- sort();
+ sort(false);
}
/**
* a sort order list.
*/
public void setSortOrder(List<SortOrder> order) {
+ setSortOrder(order, SortEventOriginator.API);
+ }
+
+ private void setSortOrder(List<SortOrder> order,
+ SortEventOriginator originator) {
if (!(getContainerDatasource() instanceof Container.Sortable)) {
throw new IllegalStateException(
"Attached container is not sortable (does not implement Container.Sortable)");
}
sortOrder.addAll(order);
- sort();
+ sort(originator);
}
/**
/**
* Apply sorting to data source.
*/
- private void sort() {
+ private void sort(SortEventOriginator originator) {
Container c = getContainerDatasource();
if (c instanceof Container.Sortable) {
cs.sort(propertyIds, directions);
fireEvent(new SortOrderChangeEvent(this, new ArrayList<SortOrder>(
- sortOrder)));
+ sortOrder), originator));
getState().sortColumns = columnKeys;
getState(false).sortDirs = stateDirs;
import java.util.List;
+import com.vaadin.shared.ui.grid.SortEventOriginator;
import com.vaadin.ui.Component;
import com.vaadin.ui.components.grid.sort.SortOrder;
public class SortOrderChangeEvent extends Component.Event {
private final List<SortOrder> sortOrder;
+ private final SortEventOriginator originator;
/**
* Creates a new sort order change event for a grid and a sort order list.
* the grid from which the event originates
* @param sortOrder
* the new sort order list
+ * @param wasInitiatedByUser
+ * should be set to true if this event results from end-user
+ * interaction instead of an API call or side effect
*/
- public SortOrderChangeEvent(Grid grid, List<SortOrder> sortOrder) {
+ public SortOrderChangeEvent(Grid grid, List<SortOrder> sortOrder,
+ SortEventOriginator originator) {
super(grid);
this.sortOrder = sortOrder;
+ this.originator = originator;
}
/**
return sortOrder;
}
+ /**
+ * Gets a value describing the originator of this event, i.e. what actions
+ * resulted in this event being fired.
+ *
+ * @return a sort event originator value
+ *
+ * @see SortEventOriginator
+ */
+ public SortEventOriginator getOriginator() {
+ return originator;
+ }
+
}
public interface GridServerRpc extends ServerRpc {
void selectionChange(List<String> newSelection);
- void sort(String[] columnIds, SortDirection[] directions);
+ void sort(String[] columnIds, SortDirection[] directions,
+ SortEventOriginator originator);
}
--- /dev/null
+/*
+ * Copyright 2000-2014 Vaadin Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.vaadin.shared.ui.grid;
+
+/**
+ * Identifier for the originator of a sort event or sort order change event.
+ *
+ * @since
+ * @author Vaadin Ltd
+ */
+public enum SortEventOriginator {
+
+ /**
+ * This event was the result of an API call.
+ */
+ API,
+
+ /**
+ * This event was the result of a user interacting with the UI.
+ */
+ USER,
+
+ /**
+ * This event resulted as a side-effect of an internal event.
+ */
+ INTERNAL
+
+}
grid.addSortOrderChangeListener(new SortOrderChangeListener() {
@Override
public void sortOrderChange(SortOrderChangeEvent event) {
- log("Sort order: " + event.getSortOrder());
+
+ String origin;
+ switch (event.getOriginator()) {
+ case API:
+ origin = "API";
+ break;
+ case INTERNAL:
+ origin = "INTERNAL";
+ break;
+ case USER:
+ origin = "USER";
+ break;
+ default:
+ origin = "!!! ERROR !!!";
+ break;
+ }
+
+ log("Sort order: " + event.getSortOrder() + " by " + origin);
}
});
// First cells for first 3 rows are (9, 0), (99, 0) and (999, 0)
sortBy("Column 9, DESC");
+ // Verify that programmatic sorting calls are identified as originating
+ // from API
+ assertEquals("3. Sort order: [Column 9 DESCENDING] by API",
+ getLogRow(0));
+
assertTrue("Column 9 should have the sort-desc stylename", grid
.getHeaderCell(0, 9).getAttribute("class")
.contains("sort-desc"));
"(" + row + ", 0)", grid.getCell(i, 0).getText());
}
- assertEquals("2. Sort order: [Column 9 ASCENDING]", getLogRow(2));
- assertEquals("4. Sort order: [Column 9 DESCENDING]", getLogRow(0));
+ assertEquals("2. Sort order: [Column 9 ASCENDING] by USER",
+ getLogRow(2));
+ assertEquals("4. Sort order: [Column 9 DESCENDING] by USER",
+ getLogRow(0));
// Column 10 is random numbers from Random with seed 13334
// Click header to sort ascending
grid.getHeaderCell(0, 10).click();
- assertEquals("6. Sort order: [Column 10 ASCENDING]", getLogRow(0));
+ assertEquals("6. Sort order: [Column 10 ASCENDING] by USER",
+ getLogRow(0));
// Not cleaning up correctly causes exceptions when scrolling.
grid.scrollToRow(50);
grid.getCell(GridBasicFeatures.ROWS - (i + 1), 0).getText());
}
- assertEquals("9. Sort order: [Column 7 ASCENDING]", getLogRow(3));
- assertEquals("11. Sort order: [Column 7 DESCENDING]", getLogRow(1));
+ assertEquals("9. Sort order: [Column 7 ASCENDING] by USER",
+ getLogRow(3));
+ assertEquals("11. Sort order: [Column 7 DESCENDING] by USER",
+ getLogRow(1));
}
@Test
projects / vaadin-framework.git / commitdiff