Event fired for both UI and programmatic changes.
Change-Id: I043e7407ee11547cb3b6639dc14c26ff036a9d82
}
+ /**
+ * An event listener for column reorder events in the Grid.
+ *
+ * @since
+ */
+ public interface ColumnReorderListener extends Serializable {
+ /**
+ * Called when the columns of the grid have been reordered.
+ *
+ * @param event
+ * An event providing more information
+ */
+ void columnReorder(ColumnReorderEvent event);
+ }
+
+ /**
+ * An event that is fired when the columns are reordered.
+ *
+ * @since
+ */
+ public static class ColumnReorderEvent extends Component.Event {
+
+ /**
+ * Is the column reorder related to this event initiated by the user
+ */
+ private final boolean userOriginated;
+
+ /**
+ *
+ * @param source
+ * the grid where the event originated from
+ * @param userOriginated
+ * <code>true</code> if event is a result of user
+ * interaction, <code>false</code> if from API call
+ */
+ public ColumnReorderEvent(Grid source, boolean userOriginated) {
+ super(source);
+ this.userOriginated = userOriginated;
+ }
+
+ /**
+ * Returns <code>true</code> if the column reorder was done by the user,
+ * <code>false</code> if not and it was triggered by server side code.
+ *
+ * @return <code>true</code> if event is a result of user interaction
+ */
+ public boolean isUserOriginated() {
+ return userOriginated;
+ }
+
+ }
+
/**
* Default error handler for the editor
*
private static final Method SORT_ORDER_CHANGE_METHOD = ReflectTools
.findMethod(SortListener.class, "sort", SortEvent.class);
+ private static final Method COLUMN_REORDER_METHOD = ReflectTools
+ .findMethod(ColumnReorderListener.class, "columnReorder",
+ ColumnReorderEvent.class);
+
/**
* Creates a new Grid with a new {@link IndexedContainer} as the data
* source.
connectorTracker);
diffState.put(diffStateKey, encodeResult.getEncodedValue());
- // TODO fire column reorder event
+ fireColumnReorderEvent(true);
} else {
// make sure the client is reverted to the order that the
// server thinks it is
columnOrder.addAll(stateColumnOrder);
}
getState().columnOrder = columnOrder;
+ fireColumnReorderEvent(false);
}
/**
removeListener(SelectionEvent.class, listener, SELECTION_CHANGE_METHOD);
}
+ private void fireColumnReorderEvent(boolean userOriginated) {
+ fireEvent(new ColumnReorderEvent(this, userOriginated));
+ }
+
+ /**
+ * Registers a new column reorder listener.
+ *
+ * @since
+ * @param listener
+ * the listener to register
+ */
+ public void addColumnReorderListener(ColumnReorderListener listener) {
+ addListener(ColumnReorderEvent.class, listener, COLUMN_REORDER_METHOD);
+ }
+
+ /**
+ * Removes a previously registered column reorder listener.
+ *
+ * @since
+ * @param listener
+ * the listener to remove
+ */
+ public void removeColumnReorderListener(ColumnReorderListener listener) {
+ removeListener(ColumnReorderEvent.class, listener,
+ COLUMN_REORDER_METHOD);
+ }
+
/**
* Gets the
* {@link com.vaadin.data.RpcDataProviderExtension.DataProviderKeyMapper
import com.vaadin.ui.Grid.CellReference;
import com.vaadin.ui.Grid.CellStyleGenerator;
import com.vaadin.ui.Grid.Column;
+import com.vaadin.ui.Grid.ColumnReorderEvent;
+import com.vaadin.ui.Grid.ColumnReorderListener;
import com.vaadin.ui.Grid.FooterCell;
import com.vaadin.ui.Grid.HeaderCell;
import com.vaadin.ui.Grid.HeaderRow;
}
};
+ private ColumnReorderListener columnReorderListener = new ColumnReorderListener() {
+
+ @Override
+ public void columnReorder(ColumnReorderEvent event) {
+ log("Columns reordered, userOriginated: "
+ + event.isUserOriginated());
+ }
+ };
+
@Override
@SuppressWarnings("unchecked")
protected Grid constructComponent() {
}
});
+ createBooleanAction("ColumnReorderListener", "State", false,
+ new Command<Grid, Boolean>() {
+
+ @Override
+ public void execute(Grid grid, Boolean value, Object data) {
+ if (value) {
+ grid.addColumnReorderListener(columnReorderListener);
+ } else {
+ grid.removeColumnReorderListener(columnReorderListener);
+ }
+ }
+ });
createBooleanAction("Single select allow deselect", "State",
singleSelectAllowDeselect, new Command<Grid, Boolean>() {
package com.vaadin.tests.components.grid.basicfeatures.server;
import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
import java.util.List;
private static final String[] COLUMN_REORDERING_PATH = { "Component",
"State", "Column Reordering Allowed" };
+ private static final String[] COLUMN_REORDER_LISTENER_PATH = { "Component",
+ "State", "ColumnReorderListener" };
@Before
public void setUp() {
assertColumnHeaderOrder(1, 0, 2);
}
+ @Test
+ public void testColumnReordering_triggersReorderEvent_isUserInitiated() {
+ // given
+ openTestURL();
+ toggleColumnReordering();
+
+ // when
+ toggleColumnReorderListener();
+ dragDefaultColumnHeader(0, 2, 10);
+
+ // then
+ assertColumnReorderEvent(true);
+ }
+
+ @Test
+ public void testColumnReordering_addAndRemoveListener_registerUnRegisterWorks() {
+ // given
+ openTestURL();
+ toggleColumnReordering();
+ dragDefaultColumnHeader(0, 2, 10);
+ assertNoColumnReorderEvent();
+
+ // when
+ toggleColumnReorderListener();
+ dragDefaultColumnHeader(0, 2, 110);
+
+ // then
+ assertColumnReorderEvent(true);
+
+ // when
+ toggleColumnReorderListener();
+ dragDefaultColumnHeader(0, 3, 10);
+
+ // then
+ assertNoColumnReorderEvent();
+ }
+
+ @Test
+ public void testColumnReorderingEvent_serverSideReorder_triggersReorderEvent() {
+ openTestURL();
+
+ // when
+ toggleColumnReorderListener();
+ moveColumnManuallyLeftByOne(3);
+
+ // then
+ assertColumnReorderEvent(false);
+ }
+
private void toggleColumnReordering() {
selectMenuPath(COLUMN_REORDERING_PATH);
}
+ private void toggleColumnReorderListener() {
+ selectMenuPath(COLUMN_REORDER_LISTENER_PATH);
+ }
+
private void moveColumnManuallyLeftByOne(int index) {
selectMenuPath(new String[] { "Component", "Columns",
"Column " + index, "Move left" });
}
+ private void assertColumnReorderEvent(boolean userOriginated) {
+ final String logRow = getLogRow(0);
+ assertTrue(logRow.contains("Columns reordered, userOriginated: "
+ + userOriginated));
+ }
+
+ private void assertNoColumnReorderEvent() {
+ final String logRow = getLogRow(0);
+ assertFalse(logRow.contains("Columns reordered"));
+ }
+
private void assertColumnHeaderOrder(int... indices) {
List<TestBenchElement> headers = getGridHeaderRowCells();
for (int i = 0; i < indices.length; i++) {