Fire server-side event when column order changes. (#16643)

Event fired for both UI and programmatic changes.

Change-Id: I043e7407ee11547cb3b6639dc14c26ff036a9d82

server/src/com/vaadin/ui/Grid.java

@@ -336,6 +336,58 @@ public class Grid extends AbstractComponent implements SelectionNotifier,
 
     }
 
+    /**
+     * 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
      * 
@@ -2896,6 +2948,10 @@ public class Grid extends AbstractComponent implements SelectionNotifier,
     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.
@@ -3120,7 +3176,7 @@ public class Grid extends AbstractComponent implements SelectionNotifier,
                             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
@@ -3632,6 +3688,7 @@ public class Grid extends AbstractComponent implements SelectionNotifier,
             columnOrder.addAll(stateColumnOrder);
         }
         getState().columnOrder = columnOrder;
+        fireColumnReorderEvent(false);
     }
 
     /**
@@ -4098,6 +4155,33 @@ public class Grid extends AbstractComponent implements SelectionNotifier,
         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

uitest/src/com/vaadin/tests/components/grid/basicfeatures/GridBasicFeatures.java

@@ -50,6 +50,8 @@ import com.vaadin.ui.Grid;
 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;
@@ -109,6 +111,15 @@ public class GridBasicFeatures extends AbstractComponentTest<Grid> {
         }
     };
 
+    private ColumnReorderListener columnReorderListener = new ColumnReorderListener() {
+
+        @Override
+        public void columnReorder(ColumnReorderEvent event) {
+            log("Columns reordered, userOriginated: "
+                    + event.isUserOriginated());
+        }
+    };
+
     @Override
     @SuppressWarnings("unchecked")
     protected Grid constructComponent() {
@@ -509,6 +520,18 @@ public class GridBasicFeatures extends AbstractComponentTest<Grid> {
                     }
 
                 });
+        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>() {

uitest/src/com/vaadin/tests/components/grid/basicfeatures/server/GridColumnReorderTest.java

@@ -16,6 +16,8 @@
 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;
 
@@ -36,6 +38,8 @@ public class GridColumnReorderTest extends GridBasicFeaturesTest {
 
     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() {
@@ -135,15 +139,79 @@ public class GridColumnReorderTest extends GridBasicFeaturesTest {
         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++) {