Switch read data to operation handlers Create: - GridOperationHandler - GridItemOperationHandler - GridColumnOperationHandler - GridColumnGroupOperationHandler
diff --git a/bundles/org.eclipse.rap.nebula.widgets.grid/src/org/eclipse/nebula/widgets/grid/internal/gridcolumngroupkit/GridColumnGroupLCA.java b/bundles/org.eclipse.rap.nebula.widgets.grid/src/org/eclipse/nebula/widgets/grid/internal/gridcolumngroupkit/GridColumnGroupLCA.java index 6b8715a..8b2ed6a 100644 --- a/bundles/org.eclipse.rap.nebula.widgets.grid/src/org/eclipse/nebula/widgets/grid/internal/gridcolumngroupkit/GridColumnGroupLCA.java +++ b/bundles/org.eclipse.rap.nebula.widgets.grid/src/org/eclipse/nebula/widgets/grid/internal/gridcolumngroupkit/GridColumnGroupLCA.java
@@ -20,24 +20,18 @@ import static org.eclipse.rap.rwt.lifecycle.WidgetLCAUtil.preserveProperty; import static org.eclipse.rap.rwt.lifecycle.WidgetLCAUtil.renderListener; import static org.eclipse.rap.rwt.lifecycle.WidgetLCAUtil.renderProperty; -import static org.eclipse.rap.rwt.lifecycle.WidgetLCAUtil.wasEventSent; import static org.eclipse.rap.rwt.lifecycle.WidgetUtil.getId; -import static org.eclipse.swt.internal.events.EventLCAUtil.isListening; import java.io.IOException; import org.eclipse.nebula.widgets.grid.Grid; import org.eclipse.nebula.widgets.grid.GridColumn; import org.eclipse.nebula.widgets.grid.GridColumnGroup; -import org.eclipse.rap.rwt.internal.protocol.ClientMessageConst; import org.eclipse.rap.rwt.lifecycle.AbstractWidgetLCA; -import org.eclipse.rap.rwt.lifecycle.ProcessActionRunner; import org.eclipse.rap.rwt.lifecycle.WidgetLCAUtil; import org.eclipse.rap.rwt.remote.RemoteObject; -import org.eclipse.swt.SWT; import org.eclipse.swt.graphics.Font; import org.eclipse.swt.internal.widgets.ItemLCAUtil; -import org.eclipse.swt.widgets.Event; import org.eclipse.swt.widgets.Widget; @@ -62,19 +56,12 @@ public void renderInitialization( Widget widget ) throws IOException { GridColumnGroup group = ( GridColumnGroup )widget; RemoteObject remoteObject = createRemoteObject( group, TYPE ); + remoteObject.setHandler( new GridColumnGroupOperationHandler( group ) ); remoteObject.set( "parent", getId( group.getParent() ) ); remoteObject.set( "style", createJsonArray( getStyles( group, ALLOWED_STYLES ) ) ); } @Override - public void readData( Widget widget ) { - GridColumnGroup group = ( GridColumnGroup )widget; - readExpanded( group ); - processTreeEvent( group, SWT.Expand, ClientMessageConst.EVENT_EXPAND ); - processTreeEvent( group, SWT.Collapse, ClientMessageConst.EVENT_COLLAPSE ); - } - - @Override public void preserveValues( Widget widget ) { GridColumnGroup group = ( GridColumnGroup )widget; WidgetLCAUtil.preserveCustomVariant( group ); @@ -104,27 +91,6 @@ renderListener( group, PROP_COLLAPSE_LISTENER, hasCollapseListener( group ), false ); } - //////////////////////////////////////////// - // Helping methods to read client-side state - - private static void readExpanded( final GridColumnGroup group ) { - final String expanded = WidgetLCAUtil.readPropertyValue( group, PROP_EXPANDED ); - if( expanded != null ) { - ProcessActionRunner.add( new Runnable() { - public void run() { - group.setExpanded( Boolean.valueOf( expanded ).booleanValue() ); -// preserveProperty( group, PROP_EXPANDED, group.getExpanded() ); - } - } ); - } - } - - private static void processTreeEvent( GridColumnGroup group, int eventType, String eventName ) { - if( wasEventSent( group, eventName ) && isListening( group, eventType ) ) { - group.notifyListeners( eventType, new Event() ); - } - } - ////////////////////////////////////////////// // Helping methods to render widget properties @@ -179,12 +145,14 @@ return result; } + @SuppressWarnings( "unused" ) private static boolean hasExpandListener( GridColumnGroup group ) { // Always render listen for Expand and Collapse, currently required for columns // visibility update. return true; } + @SuppressWarnings( "unused" ) private static boolean hasCollapseListener( GridColumnGroup group ) { // Always render listen for Expand and Collapse, currently required for columns // visibility update.
diff --git a/bundles/org.eclipse.rap.nebula.widgets.grid/src/org/eclipse/nebula/widgets/grid/internal/gridcolumngroupkit/GridColumnGroupOperationHandler.java b/bundles/org.eclipse.rap.nebula.widgets.grid/src/org/eclipse/nebula/widgets/grid/internal/gridcolumngroupkit/GridColumnGroupOperationHandler.java new file mode 100644 index 0000000..eb883f0 --- /dev/null +++ b/bundles/org.eclipse.rap.nebula.widgets.grid/src/org/eclipse/nebula/widgets/grid/internal/gridcolumngroupkit/GridColumnGroupOperationHandler.java
@@ -0,0 +1,83 @@ +/******************************************************************************* + * Copyright (c) 2013 EclipseSource and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * EclipseSource - initial API and implementation + ******************************************************************************/ +package org.eclipse.nebula.widgets.grid.internal.gridcolumngroupkit; + +import static org.eclipse.rap.rwt.internal.protocol.ClientMessageConst.EVENT_COLLAPSE; +import static org.eclipse.rap.rwt.internal.protocol.ClientMessageConst.EVENT_EXPAND; + +import org.eclipse.nebula.widgets.grid.GridColumnGroup; +import org.eclipse.rap.json.JsonObject; +import org.eclipse.rap.json.JsonValue; +import org.eclipse.rap.rwt.internal.protocol.WidgetOperationHandler; +import org.eclipse.rap.rwt.lifecycle.ProcessActionRunner; +import org.eclipse.swt.SWT; +import org.eclipse.swt.widgets.Event; + + +@SuppressWarnings( "restriction" ) +public class GridColumnGroupOperationHandler extends WidgetOperationHandler<GridColumnGroup> { + + private static final String PROP_EXPANDED = "expanded"; + + public GridColumnGroupOperationHandler( GridColumnGroup group ) { + super( group ); + } + + @Override + public void handleSet( GridColumnGroup group, JsonObject properties ) { + handleSetExpanded( group, properties ); + } + + @Override + public void handleNotify( GridColumnGroup group, String eventName, JsonObject properties ) { + if( EVENT_EXPAND.equals( eventName ) ) { + handleNotifyExpand( group, properties ); + } else if( EVENT_COLLAPSE.equals( eventName ) ) { + handleNotifyCollapse( group, properties ); + } else { + super.handleNotify( group, eventName, properties ); + } + } + + /* + * PROTOCOL SET expanded + * + * @param expanded (boolean) true if the group was expanded, false otherwise + */ + public void handleSetExpanded( final GridColumnGroup group, JsonObject properties ) { + final JsonValue expanded = properties.get( PROP_EXPANDED ); + if( expanded != null ) { + ProcessActionRunner.add( new Runnable() { + public void run() { + group.setExpanded( expanded.asBoolean() ); +// preserveProperty( group, PROP_EXPANDED, group.getExpanded() ); + } + } ); + } + } + + /* + * PROTOCOL NOTIFY Expand + */ + @SuppressWarnings( "unused" ) + public void handleNotifyExpand( GridColumnGroup group, JsonObject properties ) { + group.notifyListeners( SWT.Expand, new Event() ); + } + + /* + * PROTOCOL NOTIFY Collapse + */ + @SuppressWarnings( "unused" ) + public void handleNotifyCollapse( GridColumnGroup group, JsonObject properties ) { + group.notifyListeners( SWT.Collapse, new Event() ); + } + +}
diff --git a/bundles/org.eclipse.rap.nebula.widgets.grid/src/org/eclipse/nebula/widgets/grid/internal/gridcolumnkit/GridColumnLCA.java b/bundles/org.eclipse.rap.nebula.widgets.grid/src/org/eclipse/nebula/widgets/grid/internal/gridcolumnkit/GridColumnLCA.java index d2cfec2..79733e0 100644 --- a/bundles/org.eclipse.rap.nebula.widgets.grid/src/org/eclipse/nebula/widgets/grid/internal/gridcolumnkit/GridColumnLCA.java +++ b/bundles/org.eclipse.rap.nebula.widgets.grid/src/org/eclipse/nebula/widgets/grid/internal/gridcolumnkit/GridColumnLCA.java
@@ -11,29 +11,20 @@ package org.eclipse.nebula.widgets.grid.internal.gridcolumnkit; import static org.eclipse.rap.rwt.internal.protocol.ProtocolUtil.getJsonForFont; -import static org.eclipse.rap.rwt.internal.protocol.ProtocolUtil.readCallPropertyValueAsString; import static org.eclipse.rap.rwt.internal.protocol.RemoteObjectFactory.createRemoteObject; import static org.eclipse.rap.rwt.internal.protocol.RemoteObjectFactory.getRemoteObject; import static org.eclipse.rap.rwt.lifecycle.WidgetLCAUtil.preserveListener; import static org.eclipse.rap.rwt.lifecycle.WidgetLCAUtil.preserveProperty; import static org.eclipse.rap.rwt.lifecycle.WidgetLCAUtil.renderListener; import static org.eclipse.rap.rwt.lifecycle.WidgetLCAUtil.renderProperty; -import static org.eclipse.rap.rwt.lifecycle.WidgetUtil.getId; import static org.eclipse.swt.internal.events.EventLCAUtil.isListening; import java.io.IOException; -import java.util.Arrays; -import org.eclipse.nebula.widgets.grid.Grid; import org.eclipse.nebula.widgets.grid.GridColumn; import org.eclipse.nebula.widgets.grid.GridColumnGroup; import org.eclipse.nebula.widgets.grid.internal.IGridAdapter; -import org.eclipse.rap.rwt.internal.protocol.ProtocolUtil; -import org.eclipse.rap.rwt.internal.util.NumberFormatUtil; import org.eclipse.rap.rwt.lifecycle.AbstractWidgetLCA; -import org.eclipse.rap.rwt.lifecycle.ControlLCAUtil; -import org.eclipse.rap.rwt.lifecycle.ProcessActionRunner; -import org.eclipse.rap.rwt.lifecycle.WidgetAdapter; import org.eclipse.rap.rwt.lifecycle.WidgetLCAUtil; import org.eclipse.rap.rwt.lifecycle.WidgetUtil; import org.eclipse.rap.rwt.remote.RemoteObject; @@ -69,6 +60,7 @@ public void renderInitialization( Widget widget ) throws IOException { GridColumn column = ( GridColumn )widget; RemoteObject remoteObject = createRemoteObject( column, TYPE ); + remoteObject.setHandler( new GridColumnOperationHandler( column ) ); remoteObject.set( "parent", WidgetUtil.getId( column.getParent() ) ); GridColumnGroup group = column.getColumnGroup(); if( group != null ) { @@ -77,14 +69,6 @@ } @Override - public void readData( Widget widget ) { - GridColumn column = ( GridColumn )widget; - readLeft( column ); - readWidth( column ); - ControlLCAUtil.processSelection( column, null, false ); - } - - @Override public void preserveValues( Widget widget ) { GridColumn column = ( GridColumn )widget; WidgetLCAUtil.preserveToolTipText( column, column.getHeaderTooltip() ); @@ -126,35 +110,6 @@ renderListener( column, PROP_SELECTION_LISTENER, isListening( column, SWT.Selection ), false ); } - //////////////////////////////////////////// - // Helping methods to read client-side state - - private static void readLeft( final GridColumn column ) { - String methodName = "move"; - if( ProtocolUtil.wasCallReceived( getId( column ), methodName ) ) { - String value = readCallPropertyValueAsString( getId( column ), methodName, "left" ); - final int newLeft = NumberFormatUtil.parseInt( value ); - ProcessActionRunner.add( new Runnable() { - public void run() { - moveColumn( column, newLeft ); - } - } ); - } - } - - private static void readWidth( final GridColumn column ) { - String methodName = "resize"; - if( ProtocolUtil.wasCallReceived( getId( column ), methodName ) ) { - String value = readCallPropertyValueAsString( getId( column ), methodName, "width" ); - final int newWidth = NumberFormatUtil.parseInt( value ); - ProcessActionRunner.add( new Runnable() { - public void run() { - column.setWidth( newWidth ); - } - } ); - } - } - ////////////////////////////////////////////// // Helping methods to render widget properties @@ -165,80 +120,11 @@ } } - ///////////////////////////////// - // Helping methods to move column - - static void moveColumn( GridColumn column, int newLeft ) { - Grid grid = column.getParent(); - int index = grid.indexOf( column ); - int targetColumn = findMoveTarget( grid, newLeft ); - int[] columnOrder = grid.getColumnOrder(); - int orderIndex = arrayIndexOf( columnOrder, index ); - columnOrder = arrayRemove( columnOrder, orderIndex ); - if( orderIndex < targetColumn ) { - targetColumn--; - } - columnOrder = arrayInsert( columnOrder, targetColumn, index ); - if( Arrays.equals( columnOrder, grid.getColumnOrder() ) ) { - GridColumn[] columns = grid.getColumns(); - for( int i = 0; i < columns.length; i++ ) { - WidgetAdapter adapter = WidgetUtil.getAdapter( columns[ i ] ); - adapter.preserve( PROP_LEFT, null ); - } - } else { - try { - grid.setColumnOrder( columnOrder ); - } catch( IllegalArgumentException exception ) { - // move the column in/out of a group is invalid - } finally { - WidgetAdapter adapter = WidgetUtil.getAdapter( column ); - adapter.preserve( PROP_LEFT, null ); - } - } - } - - private static int findMoveTarget( Grid grid, int newLeft ) { - int result = -1; - GridColumn[] columns = grid.getColumns(); - int[] columnOrder = grid.getColumnOrder(); - if( newLeft < 0 ) { - result = 0; - } else { - for( int i = 0; result == -1 && i < columns.length; i++ ) { - GridColumn column = columns[ columnOrder[ i ] ]; - int left = getLeft( column ); - int width = getWidth( column ); - if( newLeft >= left && newLeft <= left + width ) { - result = i; - if( newLeft >= left + width / 2 && result < columns.length ) { - result++; - } - } - } - } - if( result == -1 ) { - result = columns.length; - } - return result; - } - ////////////////// // Helping methods - private static int getIndex( GridColumn column ) { - return column.getParent().indexOf( column ); - } - private static int getLeft( GridColumn column ) { - Grid grid = column.getParent(); - IGridAdapter adapter = grid.getAdapter( IGridAdapter.class ); - return adapter.getCellLeft( grid.indexOf( column ) ); - } - - private static int getWidth( GridColumn column ) { - Grid grid = column.getParent(); - IGridAdapter adapter = grid.getAdapter( IGridAdapter.class ); - return adapter.getCellWidth( grid.indexOf( column ) ); + return getGridAdapter( column ).getCellLeft( getIndex( column ) ); } private static String getAlignment( GridColumn column ) { @@ -252,32 +138,12 @@ return result; } - private static int arrayIndexOf( int[] array, int value ) { - int result = -1; - for( int i = 0; result == -1 && i < array.length; i++ ) { - if( array[ i ] == value ) { - result = i; - } - } - return result; + private static int getIndex( GridColumn column ) { + return column.getParent().indexOf( column ); } - private static int[] arrayRemove( int[] array, int index ) { - int length = array.length; - int[] result = new int[ length - 1 ]; - System.arraycopy( array, 0, result, 0, index ); - if( index < length - 1 ) { - System.arraycopy( array, index + 1, result, index, length - index - 1 ); - } - return result; + private static IGridAdapter getGridAdapter( GridColumn column ) { + return column.getParent().getAdapter( IGridAdapter.class ); } - private static int[] arrayInsert( int[] array, int index, int value ) { - int length = array.length; - int[] result = new int[ length + 1 ]; - System.arraycopy( array, 0, result, 0, length ); - System.arraycopy( result, index, result, index + 1, length - index ); - result[ index ] = value; - return result; - } }
diff --git a/bundles/org.eclipse.rap.nebula.widgets.grid/src/org/eclipse/nebula/widgets/grid/internal/gridcolumnkit/GridColumnOperationHandler.java b/bundles/org.eclipse.rap.nebula.widgets.grid/src/org/eclipse/nebula/widgets/grid/internal/gridcolumnkit/GridColumnOperationHandler.java new file mode 100644 index 0000000..2834e5b --- /dev/null +++ b/bundles/org.eclipse.rap.nebula.widgets.grid/src/org/eclipse/nebula/widgets/grid/internal/gridcolumnkit/GridColumnOperationHandler.java
@@ -0,0 +1,213 @@ +/******************************************************************************* + * Copyright (c) 2013 EclipseSource and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * EclipseSource - initial API and implementation + ******************************************************************************/ +package org.eclipse.nebula.widgets.grid.internal.gridcolumnkit; + +import static org.eclipse.rap.rwt.internal.protocol.ClientMessageConst.EVENT_DEFAULT_SELECTION; +import static org.eclipse.rap.rwt.internal.protocol.ClientMessageConst.EVENT_SELECTION; + +import java.util.Arrays; + +import org.eclipse.nebula.widgets.grid.Grid; +import org.eclipse.nebula.widgets.grid.GridColumn; +import org.eclipse.nebula.widgets.grid.internal.IGridAdapter; +import org.eclipse.rap.json.JsonObject; +import org.eclipse.rap.rwt.internal.protocol.WidgetOperationHandler; +import org.eclipse.rap.rwt.lifecycle.ProcessActionRunner; +import org.eclipse.rap.rwt.lifecycle.WidgetAdapter; +import org.eclipse.rap.rwt.lifecycle.WidgetUtil; +import org.eclipse.swt.SWT; +import org.eclipse.swt.widgets.Event; + + +@SuppressWarnings( "restriction" ) +public class GridColumnOperationHandler extends WidgetOperationHandler<GridColumn> { + + private static final String METHOD_MOVE = "move"; + private static final String METHOD_RESIZE = "resize"; + private static final String PROP_LEFT = "left"; + private static final String PROP_WIDTH = "width"; + + public GridColumnOperationHandler( GridColumn column ) { + super( column ); + } + + @Override + public void handleCall( GridColumn column, String method, JsonObject properties ) { + if( METHOD_MOVE.equals( method ) ) { + handleCallMove( column, properties ); + } else if( METHOD_RESIZE.equals( method ) ) { + handleCallResize( column, properties ); + } + } + + @Override + public void handleNotify( GridColumn column, String eventName, JsonObject properties ) { + if( EVENT_SELECTION.equals( eventName ) ) { + handleNotifySelection( column, properties ); + } else if( EVENT_DEFAULT_SELECTION.equals( eventName ) ) { + handleNotifyDefaultSelection( column, properties ); + } else { + super.handleNotify( column, eventName, properties ); + } + } + + /* + * PROTOCOL CALL move + * + * @param left (int) the left position of the column + */ + public void handleCallMove( final GridColumn column, JsonObject properties ) { + final int newLeft = properties.get( PROP_LEFT ).asInt(); + ProcessActionRunner.add( new Runnable() { + public void run() { + moveColumn( column, newLeft ); + } + } ); + } + + /* + * PROTOCOL CALL resize + * + * @param width (int) the width of the column + */ + public void handleCallResize( final GridColumn column, JsonObject properties ) { + final int width = properties.get( PROP_WIDTH ).asInt(); + ProcessActionRunner.add( new Runnable() { + public void run() { + column.setWidth( width ); + } + } ); + } + + /* + * PROTOCOL NOTIFY Selection + * + * @param altKey (boolean) true if the ALT key was pressed + * @param ctrlKey (boolean) true if the CTRL key was pressed + * @param shiftKey (boolean) true if the SHIFT key was pressed + */ + public void handleNotifySelection( GridColumn column, JsonObject properties ) { + Event event = createSelectionEvent( SWT.Selection, properties ); + column.notifyListeners( SWT.Selection, event ); + } + + /* + * PROTOCOL NOTIFY DefaultSelection + * + * @param altKey (boolean) true if the ALT key was pressed + * @param ctrlKey (boolean) true if the CTRL key was pressed + * @param shiftKey (boolean) true if the SHIFT key was pressed + */ + public void handleNotifyDefaultSelection( GridColumn column, JsonObject properties ) { + Event event = createSelectionEvent( SWT.DefaultSelection, properties ); + column.notifyListeners( SWT.DefaultSelection, event ); + } + + static void moveColumn( GridColumn column, int newLeft ) { + Grid grid = column.getParent(); + int index = grid.indexOf( column ); + int targetColumn = findMoveTarget( grid, newLeft ); + int[] columnOrder = grid.getColumnOrder(); + int orderIndex = arrayIndexOf( columnOrder, index ); + columnOrder = arrayRemove( columnOrder, orderIndex ); + if( orderIndex < targetColumn ) { + targetColumn--; + } + columnOrder = arrayInsert( columnOrder, targetColumn, index ); + if( Arrays.equals( columnOrder, grid.getColumnOrder() ) ) { + GridColumn[] columns = grid.getColumns(); + for( int i = 0; i < columns.length; i++ ) { + WidgetAdapter adapter = WidgetUtil.getAdapter( columns[ i ] ); + adapter.preserve( PROP_LEFT, null ); + } + } else { + try { + grid.setColumnOrder( columnOrder ); + } catch( IllegalArgumentException exception ) { + // move the column in/out of a group is invalid + } finally { + WidgetAdapter adapter = WidgetUtil.getAdapter( column ); + adapter.preserve( PROP_LEFT, null ); + } + } + } + + private static int findMoveTarget( Grid grid, int newLeft ) { + int result = -1; + GridColumn[] columns = grid.getColumns(); + int[] columnOrder = grid.getColumnOrder(); + if( newLeft < 0 ) { + result = 0; + } else { + for( int i = 0; result == -1 && i < columns.length; i++ ) { + GridColumn column = columns[ columnOrder[ i ] ]; + int left = getLeft( column ); + int width = getWidth( column ); + if( newLeft >= left && newLeft <= left + width ) { + result = i; + if( newLeft >= left + width / 2 && result < columns.length ) { + result++; + } + } + } + } + if( result == -1 ) { + result = columns.length; + } + return result; + } + + private static int getLeft( GridColumn column ) { + return getGridAdapter( column ).getCellLeft( getIndex( column ) ); + } + + private static int getWidth( GridColumn column ) { + return getGridAdapter( column ).getCellWidth( getIndex( column ) ); + } + + private static int getIndex( GridColumn column ) { + return column.getParent().indexOf( column ); + } + + private static IGridAdapter getGridAdapter( GridColumn column ) { + return column.getParent().getAdapter( IGridAdapter.class ); + } + + private static int arrayIndexOf( int[] array, int value ) { + int result = -1; + for( int i = 0; result == -1 && i < array.length; i++ ) { + if( array[ i ] == value ) { + result = i; + } + } + return result; + } + + private static int[] arrayRemove( int[] array, int index ) { + int length = array.length; + int[] result = new int[ length - 1 ]; + System.arraycopy( array, 0, result, 0, index ); + if( index < length - 1 ) { + System.arraycopy( array, index + 1, result, index, length - index - 1 ); + } + return result; + } + + private static int[] arrayInsert( int[] array, int index, int value ) { + int length = array.length; + int[] result = new int[ length + 1 ]; + System.arraycopy( array, 0, result, 0, length ); + System.arraycopy( result, index, result, index + 1, length - index ); + result[ index ] = value; + return result; + } + +}
diff --git a/bundles/org.eclipse.rap.nebula.widgets.grid/src/org/eclipse/nebula/widgets/grid/internal/griditemkit/GridItemLCA.java b/bundles/org.eclipse.rap.nebula.widgets.grid/src/org/eclipse/nebula/widgets/grid/internal/griditemkit/GridItemLCA.java index d5e2a7e..afe482c 100644 --- a/bundles/org.eclipse.rap.nebula.widgets.grid/src/org/eclipse/nebula/widgets/grid/internal/griditemkit/GridItemLCA.java +++ b/bundles/org.eclipse.rap.nebula.widgets.grid/src/org/eclipse/nebula/widgets/grid/internal/griditemkit/GridItemLCA.java
@@ -14,7 +14,6 @@ import static org.eclipse.rap.rwt.internal.protocol.RemoteObjectFactory.getRemoteObject; import static org.eclipse.rap.rwt.lifecycle.WidgetLCAUtil.preserveProperty; import static org.eclipse.rap.rwt.lifecycle.WidgetLCAUtil.renderProperty; -import static org.eclipse.rap.rwt.lifecycle.WidgetUtil.getId; import java.io.IOException; @@ -22,10 +21,8 @@ import org.eclipse.nebula.widgets.grid.GridItem; import org.eclipse.nebula.widgets.grid.internal.IGridAdapter; import org.eclipse.nebula.widgets.grid.internal.IGridItemAdapter; -import org.eclipse.rap.rwt.internal.protocol.ProtocolUtil; import org.eclipse.rap.rwt.internal.remote.RemoteObjectImpl; import org.eclipse.rap.rwt.lifecycle.AbstractWidgetLCA; -import org.eclipse.rap.rwt.lifecycle.ProcessActionRunner; import org.eclipse.rap.rwt.lifecycle.WidgetLCAUtil; import org.eclipse.rap.rwt.lifecycle.WidgetUtil; import org.eclipse.rap.rwt.remote.RemoteObject; @@ -60,18 +57,12 @@ public void renderInitialization( Widget widget ) throws IOException { GridItem item = ( GridItem )widget; RemoteObject remoteObject = createRemoteObject( item, TYPE ); + remoteObject.setHandler( new GridItemOperationHandler( item ) ); remoteObject.set( "parent", WidgetUtil.getId( getParent( item ) ) ); remoteObject.set( "index", getItemIndex( item ) ); } @Override - public void readData( Widget widget ) { - GridItem item = ( GridItem )widget; - readChecked( item ); - readExpanded( item ); - } - - @Override public void preserveValues( Widget widget ) { GridItem item = ( GridItem )widget; WidgetLCAUtil.preserveCustomVariant( item ); @@ -143,30 +134,6 @@ } } - //////////////////////////////////////////// - // Helping methods to read client-side state - - private static void readChecked( GridItem item ) { - boolean[] value = ProtocolUtil.readPropertyValueAsBooleanArray( getId( item ), "cellChecked" ); - if( value != null ) { - for( int i = 0; i < value.length; i++ ) { - item.setChecked( i, value[ i ] ); - } - } - } - - private static void readExpanded( final GridItem item ) { - final String expanded = WidgetLCAUtil.readPropertyValue( item, PROP_EXPANDED ); - if( expanded != null ) { - ProcessActionRunner.add( new Runnable() { - public void run() { - item.setExpanded( Boolean.valueOf( expanded ).booleanValue() ); - preserveProperty( item, PROP_EXPANDED, item.isExpanded() ); - } - } ); - } - } - ////////////////// // Helping methods
diff --git a/bundles/org.eclipse.rap.nebula.widgets.grid/src/org/eclipse/nebula/widgets/grid/internal/griditemkit/GridItemOperationHandler.java b/bundles/org.eclipse.rap.nebula.widgets.grid/src/org/eclipse/nebula/widgets/grid/internal/griditemkit/GridItemOperationHandler.java new file mode 100644 index 0000000..8873661 --- /dev/null +++ b/bundles/org.eclipse.rap.nebula.widgets.grid/src/org/eclipse/nebula/widgets/grid/internal/griditemkit/GridItemOperationHandler.java
@@ -0,0 +1,71 @@ +/******************************************************************************* + * Copyright (c) 2013 EclipseSource and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * EclipseSource - initial API and implementation + ******************************************************************************/ +package org.eclipse.nebula.widgets.grid.internal.griditemkit; + +import static org.eclipse.rap.rwt.lifecycle.WidgetLCAUtil.preserveProperty; + +import org.eclipse.nebula.widgets.grid.GridItem; +import org.eclipse.rap.json.JsonArray; +import org.eclipse.rap.json.JsonObject; +import org.eclipse.rap.json.JsonValue; +import org.eclipse.rap.rwt.internal.protocol.WidgetOperationHandler; +import org.eclipse.rap.rwt.lifecycle.ProcessActionRunner; + + +@SuppressWarnings( "restriction" ) +public class GridItemOperationHandler extends WidgetOperationHandler<GridItem> { + + private static final String PROP_CELL_CHECKED = "cellChecked"; + private static final String PROP_EXPANDED = "expanded"; + + public GridItemOperationHandler( GridItem item ) { + super( item ); + } + + @Override + public void handleSet( GridItem item, JsonObject properties ) { + handleSetChecked( item, properties ); + handleSetExpanded( item, properties ); + } + + /* + * PROTOCOL SET checked + * + * @param checked ([boolean]) array with item checked states (by column) + */ + public void handleSetChecked( GridItem item, JsonObject properties ) { + JsonValue value = properties.get( PROP_CELL_CHECKED ); + if( value != null ) { + JsonArray arrayValue = value.asArray(); + for( int i = 0; i < arrayValue.size(); i++ ) { + item.setChecked( i, arrayValue.get( i ).asBoolean() ); + } + } + } + + /* + * PROTOCOL SET expanded + * + * @param expanded (boolean) true if the item was expanded, false otherwise + */ + public void handleSetExpanded( final GridItem item, JsonObject properties ) { + final JsonValue expanded = properties.get( PROP_EXPANDED ); + if( expanded != null ) { + ProcessActionRunner.add( new Runnable() { + public void run() { + item.setExpanded( expanded.asBoolean() ); + preserveProperty( item, PROP_EXPANDED, item.isExpanded() ); + } + } ); + } + } + +}
diff --git a/bundles/org.eclipse.rap.nebula.widgets.grid/src/org/eclipse/nebula/widgets/grid/internal/gridkit/GridLCA.java b/bundles/org.eclipse.rap.nebula.widgets.grid/src/org/eclipse/nebula/widgets/grid/internal/gridkit/GridLCA.java index 1d00e5a..1f2c6f5 100644 --- a/bundles/org.eclipse.rap.nebula.widgets.grid/src/org/eclipse/nebula/widgets/grid/internal/gridkit/GridLCA.java +++ b/bundles/org.eclipse.rap.nebula.widgets.grid/src/org/eclipse/nebula/widgets/grid/internal/gridkit/GridLCA.java
@@ -10,23 +10,14 @@ ******************************************************************************/ package org.eclipse.nebula.widgets.grid.internal.gridkit; -import static org.eclipse.rap.rwt.internal.protocol.ClientMessageConst.EVENT_PARAM_DETAIL; -import static org.eclipse.rap.rwt.internal.protocol.ClientMessageConst.EVENT_PARAM_INDEX; -import static org.eclipse.rap.rwt.internal.protocol.ClientMessageConst.EVENT_PARAM_ITEM; import static org.eclipse.rap.rwt.internal.protocol.JsonUtil.createJsonArray; -import static org.eclipse.rap.rwt.internal.protocol.ProtocolUtil.readCallPropertyValueAsString; -import static org.eclipse.rap.rwt.internal.protocol.ProtocolUtil.readPropertyValueAsStringArray; -import static org.eclipse.rap.rwt.internal.protocol.ProtocolUtil.wasCallReceived; import static org.eclipse.rap.rwt.internal.protocol.RemoteObjectFactory.createRemoteObject; import static org.eclipse.rap.rwt.internal.protocol.RemoteObjectFactory.getRemoteObject; import static org.eclipse.rap.rwt.lifecycle.WidgetLCAUtil.getStyles; import static org.eclipse.rap.rwt.lifecycle.WidgetLCAUtil.preserveListener; import static org.eclipse.rap.rwt.lifecycle.WidgetLCAUtil.preserveProperty; -import static org.eclipse.rap.rwt.lifecycle.WidgetLCAUtil.readEventPropertyValue; -import static org.eclipse.rap.rwt.lifecycle.WidgetLCAUtil.readPropertyValue; import static org.eclipse.rap.rwt.lifecycle.WidgetLCAUtil.renderListener; import static org.eclipse.rap.rwt.lifecycle.WidgetLCAUtil.renderProperty; -import static org.eclipse.rap.rwt.lifecycle.WidgetLCAUtil.wasEventSent; import static org.eclipse.rap.rwt.lifecycle.WidgetUtil.getId; import static org.eclipse.swt.internal.events.EventLCAUtil.isListening; import static org.eclipse.swt.internal.widgets.MarkupUtil.isMarkupEnabledFor; @@ -38,20 +29,15 @@ import org.eclipse.nebula.widgets.grid.GridItem; import org.eclipse.nebula.widgets.grid.internal.IGridAdapter; import org.eclipse.rap.json.JsonArray; -import org.eclipse.rap.rwt.internal.protocol.ClientMessageConst; -import org.eclipse.rap.rwt.internal.util.NumberFormatUtil; import org.eclipse.rap.rwt.lifecycle.AbstractWidgetLCA; import org.eclipse.rap.rwt.lifecycle.ControlLCAUtil; import org.eclipse.rap.rwt.lifecycle.WidgetLCAUtil; -import org.eclipse.rap.rwt.lifecycle.WidgetUtil; import org.eclipse.rap.rwt.remote.RemoteObject; import org.eclipse.swt.SWT; import org.eclipse.swt.internal.widgets.CellToolTipUtil; import org.eclipse.swt.internal.widgets.ICellToolTipAdapter; -import org.eclipse.swt.internal.widgets.ICellToolTipProvider; import org.eclipse.swt.internal.widgets.ScrollBarLCAUtil; import org.eclipse.swt.widgets.Control; -import org.eclipse.swt.widgets.Event; import org.eclipse.swt.widgets.ScrollBar; import org.eclipse.swt.widgets.Widget; @@ -105,6 +91,7 @@ public void renderInitialization( Widget widget ) throws IOException { Grid grid = ( Grid )widget; RemoteObject remoteObject = createRemoteObject( grid, TYPE ); + remoteObject.setHandler( new GridOperationHandler( grid ) ); remoteObject.set( "parent", getId( grid.getParent() ) ); remoteObject.set( "style", createJsonArray( getStyles( grid, ALLOWED_STYLES ) ) ); remoteObject.set( "appearance", "tree" ); @@ -116,21 +103,8 @@ @Override public void readData( Widget widget ) { - Grid grid = ( Grid )widget; - readSelection( grid ); - readScrollLeft( grid ); - readTopItemIndex( grid ); - readFocusItem( grid ); - readCellToolTipTextRequested( grid ); - processSelectionEvent( grid, ClientMessageConst.EVENT_SELECTION ); - processSelectionEvent( grid, ClientMessageConst.EVENT_DEFAULT_SELECTION ); - processTreeEvent( grid, SWT.Expand, ClientMessageConst.EVENT_EXPAND ); - processTreeEvent( grid, SWT.Collapse, ClientMessageConst.EVENT_COLLAPSE ); - ControlLCAUtil.processEvents( grid ); - ControlLCAUtil.processKeyEvents( grid ); - ControlLCAUtil.processMenuDetect( grid ); - WidgetLCAUtil.processHelp( grid ); - ScrollBarLCAUtil.processSelectionEvent( grid ); + super.readData( widget ); + ScrollBarLCAUtil.processSelectionEvent( ( Grid )widget ); } @Override @@ -196,7 +170,7 @@ renderListener( grid, PROP_EXPAND_LISTENER, hasExpandListener( grid ), false ); renderListener( grid, PROP_COLLAPSE_LISTENER, hasCollapseListener( grid ), false ); renderProperty( grid, PROP_ENABLE_CELL_TOOLTIP, CellToolTipUtil.isEnabledFor( grid ), false ); - renderProperty( grid, PROP_CELL_TOOLTIP_TEXT, getCellToolTipText( grid ), null ); + renderProperty( grid, PROP_CELL_TOOLTIP_TEXT, getAndResetCellToolTipText( grid ), null ); ScrollBarLCAUtil.renderChanges( grid ); } @@ -205,80 +179,16 @@ getGridAdapter( ( Grid )control ).doRedraw(); } - //////////////////////////////////////////// - // Helping methods to read client-side state - - private static void readSelection( Grid grid ) { - String[] values = readPropertyValueAsStringArray( getId( grid ), "selection" ); - if( values != null ) { - GridItem[] selectedItems = new GridItem[ values.length ]; - boolean validItemFound = false; - for( int i = 0; i < values.length; i++ ) { - selectedItems[ i ] = getItem( grid, values[ i ] ); - if( selectedItems[ i ] != null ) { - validItemFound = true; - } - } - if( !validItemFound ) { - selectedItems = new GridItem[ 0 ]; - } - grid.setSelection( selectedItems ); - } - } - - private static void readScrollLeft( Grid grid ) { - String left = readPropertyValue( grid, "scrollLeft" ); - if( left != null ) { - int leftOffset = NumberFormatUtil.parseInt( left ); - processScrollBarSelection( grid.getHorizontalBar(), leftOffset ); - } - } - - private static void readTopItemIndex( Grid grid ) { - String topItemIndex = readPropertyValue( grid, "topItemIndex" ); - if( topItemIndex != null ) { - int topOffset = NumberFormatUtil.parseInt( topItemIndex ); - getGridAdapter( grid ).invalidateTopIndex(); - processScrollBarSelection( grid.getVerticalBar(), topOffset ); - } - } - - private static void readFocusItem( Grid grid ) { - String value = readPropertyValue( grid, "focusItem" ); - if( value != null ) { - GridItem item = getItem( grid, value ); - if( item != null ) { - grid.setFocusItem( item ); - } - } - } - - //////////////// - // Cell tooltips - - private static void readCellToolTipTextRequested( Grid grid ) { - ICellToolTipAdapter adapter = CellToolTipUtil.getAdapter( grid ); - adapter.setCellToolTipText( null ); - ICellToolTipProvider provider = adapter.getCellToolTipProvider(); - String methodName = "renderToolTipText"; - if( provider != null && wasCallReceived( getId( grid ), methodName ) ) { - String itemId = readCallPropertyValueAsString( getId( grid ), methodName, "item" ); - String column = readCallPropertyValueAsString( getId( grid ), methodName, "column" ); - int columnIndex = NumberFormatUtil.parseInt( column ); - GridItem item = getItem( grid, itemId ); - if( item != null && ( columnIndex == 0 || columnIndex < grid.getColumnCount() ) ) { - provider.getToolTipText( item, columnIndex ); - } - } - } - - private static String getCellToolTipText( Grid grid ) { - return CellToolTipUtil.getAdapter( grid ).getCellToolTipText(); - } - ////////////////// // Helping methods + private static String getAndResetCellToolTipText( Grid grid ) { + ICellToolTipAdapter adapter = CellToolTipUtil.getAdapter( grid ); + String toolTipText = adapter.getCellToolTipText(); + adapter.setCellToolTipText( null ); + return toolTipText; + } + private static boolean listensToSetData( Grid grid ) { return ( grid.getStyle() & SWT.VIRTUAL ) != 0; } @@ -339,59 +249,20 @@ return result; } - private static GridItem getItem( Grid grid, String itemId ) { - return ( GridItem )WidgetUtil.find( grid, itemId ); - } - - private static void processScrollBarSelection( ScrollBar scrollBar, int selection ) { - if( scrollBar != null ) { - scrollBar.setSelection( selection ); - } - } - - private static void processSelectionEvent( Grid grid, String eventName ) { - if( wasEventSent( grid, eventName ) ) { - GridItem item = getItem( grid, readEventPropertyValue( grid, eventName, EVENT_PARAM_ITEM ) ); - if( item != null ) { - if( eventName.equals( ClientMessageConst.EVENT_SELECTION ) ) { - String detail = readEventPropertyValue( grid, eventName, EVENT_PARAM_DETAIL ); - if( "check".equals( detail ) ) { - String index = readEventPropertyValue( grid, eventName, EVENT_PARAM_INDEX ); - item.fireCheckEvent( Integer.valueOf( index ).intValue() ); - } else { - item.fireEvent( SWT.Selection ); - } - } else { - item.fireEvent( SWT.DefaultSelection ); - } - } - } - } - + @SuppressWarnings( "unused" ) private static boolean hasExpandListener( Grid grid ) { // Always render listen for Expand and Collapse, currently required for scrollbar // visibility update and setData events. return true; } + @SuppressWarnings( "unused" ) private static boolean hasCollapseListener( Grid grid ) { // Always render listen for Expand and Collapse, currently required for scrollbar // visibility update and setData events. return true; } - ///////////////////////////////// - // Process expand/collapse events - - private static void processTreeEvent( Grid grid, int eventType, String eventName ) { - if( wasEventSent( grid, eventName ) ) { - String value = readEventPropertyValue( grid, eventName, ClientMessageConst.EVENT_PARAM_ITEM ); - Event event = new Event(); - event.item = getItem( grid, value ); - grid.notifyListeners( eventType, event ); - } - } - /////////////// // Item Metrics
diff --git a/bundles/org.eclipse.rap.nebula.widgets.grid/src/org/eclipse/nebula/widgets/grid/internal/gridkit/GridOperationHandler.java b/bundles/org.eclipse.rap.nebula.widgets.grid/src/org/eclipse/nebula/widgets/grid/internal/gridkit/GridOperationHandler.java new file mode 100644 index 0000000..ee40d41 --- /dev/null +++ b/bundles/org.eclipse.rap.nebula.widgets.grid/src/org/eclipse/nebula/widgets/grid/internal/gridkit/GridOperationHandler.java
@@ -0,0 +1,254 @@ +/******************************************************************************* + * Copyright (c) 2013 EclipseSource and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * EclipseSource - initial API and implementation + ******************************************************************************/ +package org.eclipse.nebula.widgets.grid.internal.gridkit; + +import static org.eclipse.rap.rwt.internal.protocol.ClientMessageConst.EVENT_COLLAPSE; +import static org.eclipse.rap.rwt.internal.protocol.ClientMessageConst.EVENT_DEFAULT_SELECTION; +import static org.eclipse.rap.rwt.internal.protocol.ClientMessageConst.EVENT_EXPAND; +import static org.eclipse.rap.rwt.internal.protocol.ClientMessageConst.EVENT_PARAM_INDEX; +import static org.eclipse.rap.rwt.internal.protocol.ClientMessageConst.EVENT_PARAM_ITEM; +import static org.eclipse.rap.rwt.internal.protocol.ClientMessageConst.EVENT_SELECTION; +import static org.eclipse.rap.rwt.internal.protocol.ClientMessageConst.EVENT_SET_DATA; + +import org.eclipse.nebula.widgets.grid.Grid; +import org.eclipse.nebula.widgets.grid.GridItem; +import org.eclipse.nebula.widgets.grid.internal.IGridAdapter; +import org.eclipse.rap.json.JsonArray; +import org.eclipse.rap.json.JsonObject; +import org.eclipse.rap.json.JsonValue; +import org.eclipse.rap.rwt.internal.protocol.ControlOperationHandler; +import org.eclipse.rap.rwt.lifecycle.WidgetUtil; +import org.eclipse.swt.SWT; +import org.eclipse.swt.internal.widgets.CellToolTipUtil; +import org.eclipse.swt.internal.widgets.ICellToolTipAdapter; +import org.eclipse.swt.internal.widgets.ICellToolTipProvider; +import org.eclipse.swt.widgets.Event; +import org.eclipse.swt.widgets.ScrollBar; + + +@SuppressWarnings( "restriction" ) +public class GridOperationHandler extends ControlOperationHandler<Grid> { + + private static final String PROP_SELECTION = "selection"; + private static final String PROP_SCROLL_LEFT = "scrollLeft"; + private static final String PROP_TOP_ITEM_INDEX = "topItemIndex"; + private static final String PROP_FOCUS_ITEM = "focusItem"; + private static final String METHOD_RENDER_TOOLTIP_TEXT = "renderToolTipText"; + + public GridOperationHandler( Grid grid ) { + super( grid ); + } + + @Override + public void handleSet( Grid grid, JsonObject properties ) { + super.handleSet( grid, properties ); + handleSetSelection( grid, properties ); + handleSetScrollLeft( grid, properties ); + handleSetTopItemIndex( grid, properties ); + handleSetFocusItem( grid, properties ); + } + + @Override + public void handleCall( Grid grid, String method, JsonObject properties ) { + if( METHOD_RENDER_TOOLTIP_TEXT.equals( method ) ) { + handleCallRenderToolTipText( grid, properties ); + } + } + + @Override + public void handleNotify( Grid grid, String eventName, JsonObject properties ) { + if( EVENT_SELECTION.equals( eventName ) ) { + handleNotifySelection( grid, properties ); + } else if( EVENT_DEFAULT_SELECTION.equals( eventName ) ) { + handleNotifyDefaultSelection( grid, properties ); + } else if( EVENT_EXPAND.equals( eventName ) ) { + handleNotifyExpand( grid, properties ); + } else if( EVENT_COLLAPSE.equals( eventName ) ) { + handleNotifyCollapse( grid, properties ); + } else if( EVENT_SET_DATA.equals( eventName ) ) { + handleNotifySetData( grid, properties ); + } else { + super.handleNotify( grid, eventName, properties ); + } + } + + /* + * PROTOCOL SET selection + * + * @param selection ([string]) array with ids of selected items + */ + public void handleSetSelection( Grid grid, JsonObject properties ) { + JsonValue values = properties.get( PROP_SELECTION ); + if( values != null ) { + JsonArray itemIds = values.asArray(); + GridItem[] selectedItems = new GridItem[ itemIds.size() ]; + boolean validItemFound = false; + for( int i = 0; i < itemIds.size(); i++ ) { + selectedItems[ i ] = getItem( grid, itemIds.get( i ).asString() ); + if( selectedItems[ i ] != null ) { + validItemFound = true; + } + } + if( !validItemFound ) { + selectedItems = new GridItem[ 0 ]; + } + grid.setSelection( selectedItems ); + } + } + + /* + * PROTOCOL SET scrollLeft + * + * @param scrollLeft (int) left scroll offset in pixels + */ + public void handleSetScrollLeft( Grid grid, JsonObject properties ) { + JsonValue value = properties.get( PROP_SCROLL_LEFT ); + if( value != null ) { + setScrollBarSelection( grid.getHorizontalBar(), value.asInt() ); + } + } + + /* + * PROTOCOL SET topItemIndex + * + * @param topItemIndex (int) visual index of the item, which is on the top of the grid + */ + public void handleSetTopItemIndex( Grid grid, JsonObject properties ) { + JsonValue value = properties.get( PROP_TOP_ITEM_INDEX ); + if( value != null ) { + getGridAdapter( grid ).invalidateTopIndex(); + setScrollBarSelection( grid.getVerticalBar(), value.asInt() ); + } + } + + /* + * PROTOCOL SET focusItem + * + * @param focusItem (string) id of focus item + */ + public void handleSetFocusItem( Grid grid, JsonObject properties ) { + JsonValue value = properties.get( PROP_FOCUS_ITEM ); + if( value != null ) { + GridItem item = getItem( grid, value.asString() ); + if( item != null ) { + grid.setFocusItem( item ); + } + } + } + + /* + * PROTOCOL CALL renderToolTipText + * + * @param item (string) id of the hovered item + * @param column (int) column index of the hovered cell + */ + public void handleCallRenderToolTipText( Grid grid, JsonObject properties ) { + ICellToolTipAdapter adapter = CellToolTipUtil.getAdapter( grid ); + ICellToolTipProvider provider = adapter.getCellToolTipProvider(); + if( provider != null ) { + GridItem item = getItem( grid, properties.get( "item" ).asString() ); + int columnIndex = properties.get( "column" ).asInt(); + if( item != null && ( columnIndex == 0 || columnIndex < grid.getColumnCount() ) ) { + provider.getToolTipText( item, columnIndex ); + } + } + } + + /* + * PROTOCOL NOTIFY Selection + * + * @param altKey (boolean) true if the ALT key was pressed + * @param ctrlKey (boolean) true if the CTRL key was pressed + * @param shiftKey (boolean) true if the SHIFT key was pressed + * @param detail (string) "check" if checkbox is selected, "hyperlink" if RWT hyperlink is + * selected + * @param item (string) id of selected item + * @param text (string) the value of href attribute or content of the selected RWT hyperlink + * @param index (int) index of the selected column + */ + public void handleNotifySelection( Grid grid, JsonObject properties ) { + GridItem item = getItem( grid, properties.get( EVENT_PARAM_ITEM ).asString() ); + if( item != null ) { + Event event = createSelectionEvent( SWT.Selection, properties ); + event.item = item; + event.index = readIndex( properties ); + grid.notifyListeners( SWT.Selection, event ); + } + } + + /* + * PROTOCOL NOTIFY DefaultSelection + * + * @param altKey (boolean) true if the ALT key was pressed + * @param ctrlKey (boolean) true if the CTRL key was pressed + * @param shiftKey (boolean) true if the SHIFT key was pressed + * @param detail (string) "check" is checkbox is selected + * @param item (string) id of selected item + */ + public void handleNotifyDefaultSelection( Grid grid, JsonObject properties ) { + GridItem item = getItem( grid, properties.get( EVENT_PARAM_ITEM ).asString() ); + if( item != null ) { + Event event = createSelectionEvent( SWT.Selection, properties ); + event.item = item; + grid.notifyListeners( SWT.DefaultSelection, event ); + } + } + + /* + * PROTOCOL NOTIFY Expand + * + * @param item (string) id of expanded item + */ + public void handleNotifyExpand( Grid grid, JsonObject properties ) { + Event event = new Event(); + event.item = getItem( grid, properties.get( EVENT_PARAM_ITEM ).asString() ); + grid.notifyListeners( SWT.Expand, event ); + } + + /* + * PROTOCOL NOTIFY Collapse + * + * @param item (string) id of collapsed item + */ + public void handleNotifyCollapse( Grid grid, JsonObject properties ) { + Event event = new Event(); + event.item = getItem( grid, properties.get( EVENT_PARAM_ITEM ).asString() ); + grid.notifyListeners( SWT.Collapse, event ); + } + + /* + * PROTOCOL NOTIFY SetData + * ignored, SetData event is fired when set topItemIndex + */ + @SuppressWarnings( "unused" ) + public void handleNotifySetData( Grid grid, JsonObject properties ) { + } + + private static GridItem getItem( Grid grid, String itemId ) { + return ( GridItem )WidgetUtil.find( grid, itemId ); + } + + private static void setScrollBarSelection( ScrollBar scrollBar, int selection ) { + if( scrollBar != null ) { + scrollBar.setSelection( selection ); + } + } + + private static int readIndex( JsonObject properties ) { + JsonValue value = properties.get( EVENT_PARAM_INDEX ); + return value == null ? 0 : value.asInt(); + } + + private static IGridAdapter getGridAdapter( Grid grid ) { + return grid.getAdapter( IGridAdapter.class ); + } + +}
diff --git a/tests/org.eclipse.rap.nebula.widgets.grid.test/META-INF/MANIFEST.MF b/tests/org.eclipse.rap.nebula.widgets.grid.test/META-INF/MANIFEST.MF index 0bb4aa7..158ac9c 100644 --- a/tests/org.eclipse.rap.nebula.widgets.grid.test/META-INF/MANIFEST.MF +++ b/tests/org.eclipse.rap.nebula.widgets.grid.test/META-INF/MANIFEST.MF
@@ -17,7 +17,7 @@ org.eclipse.rap.rwt.testfixture.internal.engine;version="[2.0.0,3.0.0)", org.eclipse.rap.rwt.testfixture.internal.service;version="[2.0.0,3.0.0)" Export-Package: org.eclipse.nebula.widgets.grid, - org.eclipse.nebula.widgets.grid.internal.gridcolumngroupkip;x-internal:=true, + org.eclipse.nebula.widgets.grid.internal.gridcolumngroupkit;x-internal:=true, org.eclipse.nebula.widgets.grid.internal.gridcolumnkit;x-internal:=true, org.eclipse.nebula.widgets.grid.internal.griditemkit;x-internal:=true, org.eclipse.nebula.widgets.grid.internal.gridkit;x-internal:=true
diff --git a/tests/org.eclipse.rap.nebula.widgets.grid.test/src/org/eclipse/nebula/widgets/grid/internal/gridcolumngroupkip/GridColumnGroupLCA_Test.java b/tests/org.eclipse.rap.nebula.widgets.grid.test/src/org/eclipse/nebula/widgets/grid/internal/gridcolumngroupkit/GridColumnGroupLCA_Test.java similarity index 86% rename from tests/org.eclipse.rap.nebula.widgets.grid.test/src/org/eclipse/nebula/widgets/grid/internal/gridcolumngroupkip/GridColumnGroupLCA_Test.java rename to tests/org.eclipse.rap.nebula.widgets.grid.test/src/org/eclipse/nebula/widgets/grid/internal/gridcolumngroupkit/GridColumnGroupLCA_Test.java index 4bb381b..dffa383 100644 --- a/tests/org.eclipse.rap.nebula.widgets.grid.test/src/org/eclipse/nebula/widgets/grid/internal/gridcolumngroupkip/GridColumnGroupLCA_Test.java +++ b/tests/org.eclipse.rap.nebula.widgets.grid.test/src/org/eclipse/nebula/widgets/grid/internal/gridcolumngroupkit/GridColumnGroupLCA_Test.java
@@ -8,28 +8,30 @@ * Contributors: * EclipseSource - initial API and implementation ******************************************************************************/ -package org.eclipse.nebula.widgets.grid.internal.gridcolumngroupkip; +package org.eclipse.nebula.widgets.grid.internal.gridcolumngroupkit; import static org.eclipse.nebula.widgets.grid.GridTestUtil.createGridColumns; import static org.eclipse.nebula.widgets.grid.GridTestUtil.loadImage; import static org.eclipse.rap.rwt.lifecycle.WidgetUtil.getId; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertTrue; import java.io.IOException; import java.util.Arrays; -import java.util.LinkedList; import java.util.List; -import junit.framework.TestCase; - import org.eclipse.nebula.widgets.grid.Grid; import org.eclipse.nebula.widgets.grid.GridColumnGroup; import org.eclipse.nebula.widgets.grid.internal.gridcolumngroupkit.GridColumnGroupLCA; +import org.eclipse.nebula.widgets.grid.internal.gridcolumngroupkit.GridColumnGroupOperationHandler; import org.eclipse.rap.json.JsonArray; import org.eclipse.rap.json.JsonObject; import org.eclipse.rap.json.JsonValue; import org.eclipse.rap.rwt.RWT; -import org.eclipse.rap.rwt.internal.protocol.ClientMessageConst; +import org.eclipse.rap.rwt.internal.remote.RemoteObjectRegistry; import org.eclipse.rap.rwt.lifecycle.WidgetUtil; +import org.eclipse.rap.rwt.remote.OperationHandler; import org.eclipse.rap.rwt.testfixture.Fixture; import org.eclipse.rap.rwt.testfixture.Message; import org.eclipse.rap.rwt.testfixture.Message.CreateOperation; @@ -40,13 +42,14 @@ import org.eclipse.swt.graphics.Image; import org.eclipse.swt.internal.graphics.ImageFactory; import org.eclipse.swt.widgets.Display; -import org.eclipse.swt.widgets.Event; -import org.eclipse.swt.widgets.Listener; import org.eclipse.swt.widgets.Shell; +import org.junit.After; +import org.junit.Before; +import org.junit.Test; @SuppressWarnings("restriction") -public class GridColumnGroupLCA_Test extends TestCase { +public class GridColumnGroupLCA_Test { private Display display; private Shell shell; @@ -54,8 +57,8 @@ private GridColumnGroup group; private GridColumnGroupLCA lca; - @Override - protected void setUp() throws Exception { + @Before + public void setUp() { Fixture.setUp(); display = new Display(); shell = new Shell( display ); @@ -65,11 +68,12 @@ Fixture.fakeNewRequest(); } - @Override - protected void tearDown() throws Exception { + @After + public void tearDown() { Fixture.tearDown(); } + @Test public void testRenderCreate() throws IOException { lca.renderInitialization( group ); @@ -78,6 +82,7 @@ assertEquals( "rwt.widgets.GridColumnGroup", operation.getType() ); } + @Test public void testRenderCreateWithAligment() throws IOException { group = new GridColumnGroup( grid, SWT.TOGGLE ); @@ -89,6 +94,17 @@ assertTrue( styles.contains( "TOGGLE" ) ); } + @Test + public void testRenderInitialization_setsOperationHandler() throws IOException { + String id = getId( group ); + + lca.renderInitialization( group ); + + OperationHandler handler = RemoteObjectRegistry.getInstance().get( id ).getHandler(); + assertTrue( handler instanceof GridColumnGroupOperationHandler ); + } + + @Test public void testRenderParent() throws IOException { lca.renderInitialization( group ); @@ -97,6 +113,7 @@ assertEquals( WidgetUtil.getId( group.getParent() ), operation.getParent() ); } + @Test public void testRenderDispose() throws IOException { lca.renderDispose( group ); @@ -106,6 +123,7 @@ assertEquals( WidgetUtil.getId( group ), operation.getTarget() ); } + @Test public void testRenderInitialText() throws IOException { lca.render( group ); @@ -114,6 +132,7 @@ assertTrue( operation.getPropertyNames().indexOf( "text" ) == -1 ); } + @Test public void testRenderText() throws IOException { group.setText( "foo" ); lca.renderChanges( group ); @@ -122,6 +141,7 @@ assertEquals( "foo", message.findSetProperty( group, "text" ).asString() ); } + @Test public void testRenderTextUnchanged() throws IOException { Fixture.markInitialized( display ); Fixture.markInitialized( group ); @@ -134,6 +154,7 @@ assertNull( message.findSetOperation( group, "text" ) ); } + @Test public void testRenderInitialImage() throws IOException { lca.renderChanges( group ); @@ -141,6 +162,7 @@ assertNull( message.findSetOperation( group, "image" ) ); } + @Test public void testRenderImage() throws IOException { Image image = loadImage( display, Fixture.IMAGE_100x50 ); @@ -154,6 +176,7 @@ assertEquals( JsonArray.readFrom( expected ), actual ); } + @Test public void testRenderImageUnchanged() throws IOException { Fixture.markInitialized( display ); Fixture.markInitialized( group ); @@ -167,6 +190,7 @@ assertNull( message.findSetOperation( group, "image" ) ); } + @Test public void testRenderImageReset() throws IOException { Fixture.markInitialized( display ); Fixture.markInitialized( group ); @@ -181,6 +205,7 @@ assertEquals( JsonObject.NULL, message.findSetProperty( group, "image" ) ); } + @Test public void testRenderInitialFont() throws IOException { lca.render( group ); @@ -189,6 +214,7 @@ assertTrue( operation.getPropertyNames().indexOf( "font" ) == -1 ); } + @Test public void testRenderFont() throws IOException { group.setHeaderFont( new Font( display, "Arial", 20, SWT.BOLD ) ); lca.renderChanges( group ); @@ -198,6 +224,7 @@ assertEquals( expected, message.findSetProperty( group, "font" ) ); } + @Test public void testRenderFontUnchanged() throws IOException { Fixture.markInitialized( display ); Fixture.markInitialized( group ); @@ -210,6 +237,7 @@ assertNull( message.findSetOperation( group, "font" ) ); } + @Test public void testRenderInitialExpanded() throws IOException { lca.render( group ); @@ -218,6 +246,7 @@ assertTrue( operation.getPropertyNames().indexOf( "expanded" ) == -1 ); } + @Test public void testRenderExpanded() throws IOException { group.setExpanded( false ); lca.renderChanges( group ); @@ -226,6 +255,7 @@ assertEquals( JsonValue.FALSE, message.findSetProperty( group, "expanded" ) ); } + @Test public void testRenderExpandedUnchanged() throws IOException { Fixture.markInitialized( display ); Fixture.markInitialized( group ); @@ -238,47 +268,7 @@ assertNull( message.findSetOperation( group, "expanded" ) ); } - public void testProcessTreeEvent_Expanded() { - List<Event> events = new LinkedList<Event>(); - group.addListener( SWT.Expand, new LoggingTreeListener( events ) ); - group.setExpanded( false ); - - Fixture.fakeNotifyOperation( getId( group ), ClientMessageConst.EVENT_EXPAND, null ); - Fixture.readDataAndProcessAction( group ); - - assertEquals( 1, events.size() ); - Event event = events.get( 0 ); - assertEquals( group, event.widget ); - } - - public void testProcessTreeEvent_Collapsed() { - List<Event> events = new LinkedList<Event>(); - group.addListener( SWT.Collapse, new LoggingTreeListener( events ) ); - - Fixture.fakeNotifyOperation( getId( group ), ClientMessageConst.EVENT_COLLAPSE, null ); - Fixture.readDataAndProcessAction( group ); - - assertEquals( 1, events.size() ); - Event event = events.get( 0 ); - assertEquals( group, event.widget ); - } - - public void testReadExpanded_Expanded() { - group.setExpanded( false ); - - Fixture.fakeSetProperty( getId( group ), "expanded", true ); - Fixture.readDataAndProcessAction( group ); - - assertTrue( group.getExpanded() ); - } - - public void testReadExpanded_Collapsed() { - Fixture.fakeSetProperty( getId( group ), "expanded", false ); - Fixture.readDataAndProcessAction( group ); - - assertFalse( group.getExpanded() ); - } - + @Test public void testRenderInitialLeft() throws IOException { lca.render( group ); @@ -287,6 +277,7 @@ assertTrue( operation.getPropertyNames().indexOf( "left" ) == -1 ); } + @Test public void testRenderLeft() throws IOException { createGridColumns( grid, 3, SWT.NONE ); grid.getColumn( 1 ).setVisible( false ); @@ -299,6 +290,7 @@ assertEquals( 90, message.findSetProperty( group, "left" ).asInt() ); } + @Test public void testRenderLeftUnchanged() throws IOException { createGridColumns( grid, 3, SWT.NONE ); grid.getColumn( 1 ).setVisible( false ); @@ -314,6 +306,7 @@ assertNull( message.findSetOperation( group, "left" ) ); } + @Test public void testRenderInitialWidth() throws IOException { lca.render( group ); @@ -322,6 +315,7 @@ assertTrue( operation.getPropertyNames().indexOf( "width" ) == -1 ); } + @Test public void testRenderWidth() throws IOException { createGridColumns( group, 1, SWT.NONE ); @@ -331,6 +325,7 @@ assertEquals( 20, message.findSetProperty( group, "width" ).asInt() ); } + @Test public void testRenderWidthUnchanged() throws IOException { Fixture.markInitialized( display ); Fixture.markInitialized( group ); @@ -343,6 +338,7 @@ assertNull( message.findSetOperation( group, "width" ) ); } + @Test public void testRenderInitialHeight() throws IOException { lca.render( group ); @@ -351,6 +347,7 @@ assertTrue( operation.getPropertyNames().indexOf( "height" ) == -1 ); } + @Test public void testRenderHeight() throws IOException { createGridColumns( group, 1, SWT.NONE ); grid.setHeaderVisible( true ); @@ -361,6 +358,7 @@ assertEquals( 31, message.findSetProperty( group, "height" ).asInt() ); } + @Test public void testRenderHeightUnchanged() throws IOException { createGridColumns( group, 1, SWT.NONE ); Fixture.markInitialized( display ); @@ -374,6 +372,7 @@ assertNull( message.findSetOperation( group, "height" ) ); } + @Test public void testRenderInitialVisible() throws IOException { createGridColumns( group, 1, SWT.NONE ); @@ -384,6 +383,7 @@ assertTrue( operation.getPropertyNames().indexOf( "visibility" ) == -1 ); } + @Test public void testRenderVisible() throws IOException { createGridColumns( group, 1, SWT.NONE ); @@ -394,6 +394,7 @@ assertEquals( JsonValue.FALSE, message.findSetProperty( group, "visibility" ) ); } + @Test public void testRenderVisibleUnchanged() throws IOException { createGridColumns( group, 1, SWT.NONE ); Fixture.markInitialized( display ); @@ -407,6 +408,7 @@ assertNull( message.findSetOperation( group, "visibility" ) ); } + @Test public void testRenderInitialCustomVariant() throws IOException { lca.render( group ); @@ -415,6 +417,7 @@ assertTrue( operation.getPropertyNames().indexOf( "customVariant" ) == -1 ); } + @Test public void testRenderCustomVariant() throws IOException { group.setData( RWT.CUSTOM_VARIANT, "blue" ); lca.renderChanges( group ); @@ -423,6 +426,7 @@ assertEquals( "variant_blue", message.findSetProperty( group, "customVariant" ).asString() ); } + @Test public void testRenderCustomVariantUnchanged() throws IOException { Fixture.markInitialized( display ); Fixture.markInitialized( group ); @@ -435,17 +439,4 @@ assertNull( message.findSetOperation( group, "customVariant" ) ); } - ////////////////// - // Helping classes - - private static class LoggingTreeListener implements Listener { - private final List<Event> events; - private LoggingTreeListener( List<Event> events ) { - this.events = events; - } - public void handleEvent( Event event ) { - events.add( event ); - } - } - }
diff --git a/tests/org.eclipse.rap.nebula.widgets.grid.test/src/org/eclipse/nebula/widgets/grid/internal/gridcolumngroupkit/GridColumnGroupOperationHandler_Test.java b/tests/org.eclipse.rap.nebula.widgets.grid.test/src/org/eclipse/nebula/widgets/grid/internal/gridcolumngroupkit/GridColumnGroupOperationHandler_Test.java new file mode 100644 index 0000000..8b51d44 --- /dev/null +++ b/tests/org.eclipse.rap.nebula.widgets.grid.test/src/org/eclipse/nebula/widgets/grid/internal/gridcolumngroupkit/GridColumnGroupOperationHandler_Test.java
@@ -0,0 +1,88 @@ +/******************************************************************************* + * Copyright (c) 2013 EclipseSource and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * EclipseSource - initial API and implementation + ******************************************************************************/ +package org.eclipse.nebula.widgets.grid.internal.gridcolumngroupkit; + +import static org.eclipse.rap.rwt.internal.protocol.ClientMessageConst.EVENT_COLLAPSE; +import static org.eclipse.rap.rwt.internal.protocol.ClientMessageConst.EVENT_EXPAND; +import static org.mockito.Matchers.any; +import static org.mockito.Matchers.eq; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.verify; + +import org.eclipse.nebula.widgets.grid.Grid; +import org.eclipse.nebula.widgets.grid.GridColumnGroup; +import org.eclipse.rap.json.JsonObject; +import org.eclipse.rap.rwt.lifecycle.PhaseId; +import org.eclipse.rap.rwt.testfixture.Fixture; +import org.eclipse.swt.SWT; +import org.eclipse.swt.widgets.Display; +import org.eclipse.swt.widgets.Event; +import org.eclipse.swt.widgets.Shell; +import org.junit.After; +import org.junit.Before; +import org.junit.Test; + + +@SuppressWarnings( "restriction" ) +public class GridColumnGroupOperationHandler_Test { + + private GridColumnGroup group; + private GridColumnGroupOperationHandler handler; + + @Before + public void setUp() { + Fixture.setUp(); + Display display = new Display(); + Shell shell = new Shell( display, SWT.NONE ); + Grid grid = new Grid( shell, SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL ); + grid.setBounds( 0, 0, 100, 100 ); + group = mock( GridColumnGroup.class ); + handler = new GridColumnGroupOperationHandler( group ); + } + + @After + public void tearDown() { + Fixture.tearDown(); + } + + @Test + public void testHandleSetЕxpanded_expand() { + Fixture.fakePhase( PhaseId.PROCESS_ACTION ); + + handler.handleSet( new JsonObject().add( "expanded", true ) ); + + verify( group ).setExpanded( true ); + } + + @Test + public void testHandleSetЕxpanded_collaps() { + Fixture.fakePhase( PhaseId.PROCESS_ACTION ); + + handler.handleSet( new JsonObject().add( "expanded", false ) ); + + verify( group ).setExpanded( false ); + } + + @Test + public void testHandleNotifyExpand() { + handler.handleNotify( EVENT_EXPAND, new JsonObject() ); + + verify( group ).notifyListeners( eq( SWT.Expand ), any( Event.class ) ); + } + + @Test + public void testHandleNotifyCollapse() { + handler.handleNotify( EVENT_COLLAPSE, new JsonObject() ); + + verify( group ).notifyListeners( eq( SWT.Collapse ), any( Event.class ) ); + } + +}
diff --git a/tests/org.eclipse.rap.nebula.widgets.grid.test/src/org/eclipse/nebula/widgets/grid/internal/gridcolumnkit/GridColumnLCA_Test.java b/tests/org.eclipse.rap.nebula.widgets.grid.test/src/org/eclipse/nebula/widgets/grid/internal/gridcolumnkit/GridColumnLCA_Test.java index 2655a65..a66fcf9 100644 --- a/tests/org.eclipse.rap.nebula.widgets.grid.test/src/org/eclipse/nebula/widgets/grid/internal/gridcolumnkit/GridColumnLCA_Test.java +++ b/tests/org.eclipse.rap.nebula.widgets.grid.test/src/org/eclipse/nebula/widgets/grid/internal/gridcolumnkit/GridColumnLCA_Test.java
@@ -14,13 +14,16 @@ import static org.eclipse.nebula.widgets.grid.GridTestUtil.loadImage; import static org.eclipse.rap.rwt.lifecycle.WidgetUtil.getId; import static org.eclipse.rap.rwt.testfixture.Fixture.getProtocolMessage; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertSame; +import static org.junit.Assert.assertTrue; import java.io.IOException; import java.util.LinkedList; import java.util.List; -import junit.framework.TestCase; - import org.eclipse.nebula.widgets.grid.Grid; import org.eclipse.nebula.widgets.grid.GridColumn; import org.eclipse.nebula.widgets.grid.GridColumnGroup; @@ -28,8 +31,9 @@ import org.eclipse.rap.json.JsonObject; import org.eclipse.rap.json.JsonValue; import org.eclipse.rap.rwt.RWT; -import org.eclipse.rap.rwt.internal.protocol.ClientMessageConst; +import org.eclipse.rap.rwt.internal.remote.RemoteObjectRegistry; import org.eclipse.rap.rwt.lifecycle.WidgetUtil; +import org.eclipse.rap.rwt.remote.OperationHandler; import org.eclipse.rap.rwt.testfixture.Fixture; import org.eclipse.rap.rwt.testfixture.Message; import org.eclipse.rap.rwt.testfixture.Message.CreateOperation; @@ -37,7 +41,6 @@ import org.eclipse.rap.rwt.testfixture.Message.Operation; import org.eclipse.swt.SWT; import org.eclipse.swt.events.SelectionAdapter; -import org.eclipse.swt.events.SelectionEvent; import org.eclipse.swt.events.SelectionListener; import org.eclipse.swt.graphics.Font; import org.eclipse.swt.graphics.Image; @@ -46,11 +49,13 @@ import org.eclipse.swt.widgets.Event; import org.eclipse.swt.widgets.Listener; import org.eclipse.swt.widgets.Shell; +import org.junit.After; +import org.junit.Before; import org.junit.Test; @SuppressWarnings("restriction") -public class GridColumnLCA_Test extends TestCase { +public class GridColumnLCA_Test { private Display display; private Shell shell; @@ -58,8 +63,8 @@ private GridColumn column; private GridColumnLCA lca; - @Override - protected void setUp() throws Exception { + @Before + public void setUp() { Fixture.setUp(); display = new Display(); shell = new Shell( display ); @@ -69,11 +74,12 @@ Fixture.fakeNewRequest(); } - @Override - protected void tearDown() throws Exception { + @After + public void tearDown() { Fixture.tearDown(); } + @Test public void testRenderCreate() throws IOException { lca.renderInitialization( column ); @@ -83,6 +89,7 @@ assertFalse( operation.getPropertyNames().contains( "group" ) ); } + @Test public void testRenderCreateWithAligment() throws IOException { column = new GridColumn( grid, SWT.RIGHT ); @@ -94,6 +101,17 @@ assertEquals( "right", message.findCreateProperty( column, "alignment" ).asString() ); } + @Test + public void testRenderInitialization_setsOperationHandler() throws IOException { + String id = getId( column ); + + lca.renderInitialization( column ); + + OperationHandler handler = RemoteObjectRegistry.getInstance().get( id ).getHandler(); + assertTrue( handler instanceof GridColumnOperationHandler ); + } + + @Test public void testRenderParent() throws IOException { lca.renderInitialization( column ); @@ -102,6 +120,7 @@ assertEquals( WidgetUtil.getId( column.getParent() ), operation.getParent() ); } + @Test public void testRenderGroup() throws IOException { GridColumnGroup group = new GridColumnGroup( grid, SWT.NONE ); column = new GridColumn( group, SWT.NONE ); @@ -113,6 +132,7 @@ assertEquals( getId( group ), operation.getProperty( "group" ).asString() ); } + @Test public void testRenderDispose() throws IOException { lca.renderDispose( column ); @@ -143,6 +163,7 @@ assertNull( message.findSetOperation( column, "toolTipMarkupEnabled" ) ); } + @Test public void testRenderInitialToolTip() throws IOException { lca.render( column ); @@ -151,6 +172,7 @@ assertTrue( operation.getPropertyNames().indexOf( "toolTip" ) == -1 ); } + @Test public void testRenderToolTip() throws IOException { column.setHeaderTooltip( "foo" ); lca.renderChanges( column ); @@ -159,6 +181,7 @@ assertEquals( "foo", message.findSetProperty( column, "toolTip" ).asString() ); } + @Test public void testRenderToolTipUnchanged() throws IOException { Fixture.markInitialized( display ); Fixture.markInitialized( column ); @@ -171,6 +194,7 @@ assertNull( message.findSetOperation( column, "toolTip" ) ); } + @Test public void testRenderInitialCustomVariant() throws IOException { lca.render( column ); @@ -179,6 +203,7 @@ assertTrue( operation.getPropertyNames().indexOf( "customVariant" ) == -1 ); } + @Test public void testRenderCustomVariant() throws IOException { column.setData( RWT.CUSTOM_VARIANT, "blue" ); lca.renderChanges( column ); @@ -187,6 +212,7 @@ assertEquals( "variant_blue", message.findSetProperty( column, "customVariant" ).asString() ); } + @Test public void testRenderCustomVariantUnchanged() throws IOException { Fixture.markInitialized( display ); Fixture.markInitialized( column ); @@ -199,6 +225,7 @@ assertNull( message.findSetOperation( column, "customVariant" ) ); } + @Test public void testRenderInitialText() throws IOException { lca.render( column ); @@ -207,6 +234,7 @@ assertTrue( operation.getPropertyNames().indexOf( "text" ) == -1 ); } + @Test public void testRenderText() throws IOException { column.setText( "foo" ); lca.renderChanges( column ); @@ -215,6 +243,7 @@ assertEquals( "foo", message.findSetProperty( column, "text" ).asString() ); } + @Test public void testRenderTextUnchanged() throws IOException { Fixture.markInitialized( display ); Fixture.markInitialized( column ); @@ -227,6 +256,7 @@ assertNull( message.findSetOperation( column, "text" ) ); } + @Test public void testRenderInitialImage() throws IOException { lca.renderChanges( column ); @@ -234,6 +264,7 @@ assertNull( message.findSetOperation( column, "image" ) ); } + @Test public void testRenderImage() throws IOException { Image image = loadImage( display, Fixture.IMAGE_100x50 ); @@ -247,6 +278,7 @@ assertEquals( JsonArray.readFrom( expected ), actual ); } + @Test public void testRenderImageUnchanged() throws IOException { Fixture.markInitialized( display ); Fixture.markInitialized( column ); @@ -260,6 +292,7 @@ assertNull( message.findSetOperation( column, "image" ) ); } + @Test public void testRenderImageReset() throws IOException { Fixture.markInitialized( display ); Fixture.markInitialized( column ); @@ -274,6 +307,7 @@ assertEquals( JsonObject.NULL, message.findSetProperty( column, "image" ) ); } + @Test public void testRenderInitialIndex() throws IOException { lca.render( column ); @@ -281,6 +315,7 @@ assertEquals( 0, message.findCreateProperty( column, "index" ).asInt() ); } + @Test public void testRenderIndex() throws IOException { new GridColumn( grid, SWT.NONE, 0 ); lca.renderChanges( column ); @@ -289,6 +324,7 @@ assertEquals( 1, message.findSetProperty( column, "index" ).asInt() ); } + @Test public void testRenderIndexUnchanged() throws IOException { Fixture.markInitialized( display ); Fixture.markInitialized( column ); @@ -301,6 +337,7 @@ assertNull( message.findSetOperation( column, "index" ) ); } + @Test public void testRenderInitialLeft() throws IOException { lca.render( column ); @@ -309,6 +346,7 @@ assertTrue( operation.getPropertyNames().indexOf( "left" ) == -1 ); } + @Test public void testRenderLeft() throws IOException { GridColumn column2 = new GridColumn( grid, SWT.NONE, 0 ); column2.setWidth( 50 ); @@ -318,6 +356,7 @@ assertEquals( 50, message.findSetProperty( column, "left" ).asInt() ); } + @Test public void testRenderLeftUnchanged() throws IOException { Fixture.markInitialized( display ); Fixture.markInitialized( column ); @@ -331,6 +370,7 @@ assertNull( message.findSetOperation( column, "left" ) ); } + @Test public void testRenderInitialWidth() throws IOException { lca.render( column ); @@ -338,6 +378,7 @@ assertEquals( 10, message.findCreateProperty( column, "width" ).asInt() ); } + @Test public void testRenderWidth() throws IOException { column.setWidth( 50 ); lca.renderChanges( column ); @@ -346,6 +387,7 @@ assertEquals( 50, message.findSetProperty( column, "width" ).asInt() ); } + @Test public void testRenderWidthUnchanged() throws IOException { Fixture.markInitialized( display ); Fixture.markInitialized( column ); @@ -358,6 +400,7 @@ assertNull( message.findSetOperation( column, "width" ) ); } + @Test public void testRenderInitialAlignment() throws IOException { lca.render( column ); @@ -366,6 +409,7 @@ assertTrue( operation.getPropertyNames().indexOf( "alignment" ) == -1 ); } + @Test public void testRenderAlignment() throws IOException { column.setAlignment( SWT.RIGHT ); lca.renderChanges( column ); @@ -374,6 +418,7 @@ assertEquals( "right", message.findSetProperty( column, "alignment" ).asString() ); } + @Test public void testRenderAlignmentUnchanged() throws IOException { Fixture.markInitialized( display ); Fixture.markInitialized( column ); @@ -386,6 +431,7 @@ assertNull( message.findSetOperation( column, "alignment" ) ); } + @Test public void testRenderInitialResizable() throws IOException { lca.render( column ); @@ -394,6 +440,7 @@ assertTrue( operation.getPropertyNames().indexOf( "resizable" ) == -1 ); } + @Test public void testRenderResizable() throws IOException { column.setResizeable( false ); lca.renderChanges( column ); @@ -402,6 +449,7 @@ assertEquals( JsonValue.FALSE, message.findSetProperty( column, "resizable" ) ); } + @Test public void testRenderResizableUnchanged() throws IOException { Fixture.markInitialized( display ); Fixture.markInitialized( column ); @@ -414,6 +462,7 @@ assertNull( message.findSetOperation( column, "resizable" ) ); } + @Test public void testRenderInitialMoveable() throws IOException { lca.render( column ); @@ -422,6 +471,7 @@ assertTrue( operation.getPropertyNames().indexOf( "moveable" ) == -1 ); } + @Test public void testRenderMoveable() throws IOException { column.setMoveable( true ); lca.renderChanges( column ); @@ -430,6 +480,7 @@ assertEquals( JsonValue.TRUE, message.findSetProperty( column, "moveable" ) ); } + @Test public void testRenderMoveableUnchanged() throws IOException { Fixture.markInitialized( display ); Fixture.markInitialized( column ); @@ -442,6 +493,7 @@ assertNull( message.findSetOperation( column, "moveable" ) ); } + @Test public void testRenderInitialVisible() throws IOException { lca.render( column ); @@ -450,6 +502,7 @@ assertTrue( operation.getPropertyNames().indexOf( "visibility" ) == -1 ); } + @Test public void testRenderVisible() throws IOException { column.setVisible( false ); lca.renderChanges( column ); @@ -458,6 +511,7 @@ assertEquals( JsonValue.FALSE, message.findSetProperty( column, "visibility" ) ); } + @Test public void testRenderVisibleUnchanged() throws IOException { Fixture.markInitialized( display ); Fixture.markInitialized( column ); @@ -470,6 +524,7 @@ assertNull( message.findSetOperation( column, "visibility" ) ); } + @Test public void testRenderInitialCheck() throws IOException { lca.render( column ); @@ -478,6 +533,7 @@ assertTrue( operation.getPropertyNames().indexOf( "check" ) == -1 ); } + @Test public void testRenderCheck() throws IOException { column = new GridColumn( grid, SWT.CHECK ); @@ -487,6 +543,7 @@ assertEquals( JsonValue.TRUE, message.findSetProperty( column, "check" ) ); } + @Test public void testRenderCheckUnchanged() throws IOException { column = new GridColumn( grid, SWT.CHECK ); Fixture.markInitialized( display ); @@ -499,6 +556,7 @@ assertNull( message.findSetOperation( column, "check" ) ); } + @Test public void testRenderAddSelectionListener() throws Exception { Fixture.markInitialized( display ); Fixture.markInitialized( column ); @@ -511,6 +569,7 @@ assertEquals( JsonValue.TRUE, message.findListenProperty( column, "Selection" ) ); } + @Test public void testRenderRemoveSelectionListener() throws Exception { SelectionListener listener = new SelectionAdapter() { }; column.addSelectionListener( listener ); @@ -525,6 +584,7 @@ assertEquals( JsonValue.FALSE, message.findListenProperty( column, "Selection" ) ); } + @Test public void testRenderSelectionListenerUnchanged() throws Exception { Fixture.markInitialized( display ); Fixture.markInitialized( column ); @@ -538,6 +598,7 @@ assertNull( message.findListenOperation( column, "Selection" ) ); } + @Test public void testReadWidth() { final List<Event> events = new LinkedList<Event>(); GridColumn[] columns = createGridColumns( grid, 2, SWT.NONE ); @@ -566,6 +627,7 @@ assertEquals( newLeft, message.findSetProperty( columns[ 1 ], "left" ).asInt() ); } + @Test public void testReadLeft() { final List<Event> events = new LinkedList<Event>(); GridColumn[] columns = createGridColumns( grid, 2, SWT.NONE ); @@ -593,266 +655,7 @@ assertEquals( 0, message.findSetProperty( columns[ 0 ], "left" ).asInt() ); } - public void testMoveColumn_1() { - column.dispose(); - GridColumn[] columns = createGridColumns( grid, 3, SWT.NONE ); - columns[ 0 ].setWidth( 10 ); - columns[ 1 ].setWidth( 20 ); - columns[ 2 ].setWidth( 30 ); - // Current order: Col 0: 0..10, Col 1: 11..30, Col 2: 31..60 (as created) - // Move Col 1 over Col 0 (left half), thereafter order should be: - // Col 1, Col 0, Col 2 - grid.setColumnOrder( new int[]{ - 0, 1, 2 - } ); - - GridColumnLCA.moveColumn( columns[ 1 ], 3 ); - - int[] columnOrder = grid.getColumnOrder(); - assertEquals( 1, columnOrder[ 0 ] ); - assertEquals( 0, columnOrder[ 1 ] ); - assertEquals( 2, columnOrder[ 2 ] ); - } - - public void testMoveColumn_2() { - column.dispose(); - GridColumn[] columns = createGridColumns( grid, 3, SWT.NONE ); - columns[ 0 ].setWidth( 10 ); - columns[ 1 ].setWidth( 20 ); - columns[ 2 ].setWidth( 30 ); - // Current order: Col 1: 0..20, Col 0: 21..30, Col 2: 31..60 - // Move Col 1 over Col 0 (right half), thereafter order should be: - // Col 0, Col 1, Col 2 - grid.setColumnOrder( new int[]{ - 1, 0, 2 - } ); - - GridColumnLCA.moveColumn( columns[ 1 ], 27 ); - - int[] columnOrder = grid.getColumnOrder(); - assertEquals( 0, columnOrder[ 0 ] ); - assertEquals( 1, columnOrder[ 1 ] ); - assertEquals( 2, columnOrder[ 2 ] ); - } - - public void testMoveColumn_3() { - column.dispose(); - GridColumn[] columns = createGridColumns( grid, 3, SWT.NONE ); - columns[ 0 ].setWidth( 10 ); - columns[ 1 ].setWidth( 20 ); - columns[ 2 ].setWidth( 30 ); - // Current order: Col 0: 0..10, Col 1: 11..30, Col 2: 31..60 - // Move Col 2 over Col 1 (left half), thereafter order should be: - // Col 0, Col 2, Col 1 - grid.setColumnOrder( new int[]{ - 0, 1, 2 - } ); - - GridColumnLCA.moveColumn( columns[ 2 ], 13 ); - - int[] columnOrder = grid.getColumnOrder(); - assertEquals( 0, columnOrder[ 0 ] ); - assertEquals( 2, columnOrder[ 1 ] ); - assertEquals( 1, columnOrder[ 2 ] ); - } - - public void testMoveColumn_4() { - column.dispose(); - GridColumn[] columns = createGridColumns( grid, 3, SWT.NONE ); - columns[ 0 ].setWidth( 10 ); - columns[ 1 ].setWidth( 20 ); - columns[ 2 ].setWidth( 30 ); - // Current order: Col 0: 0..10, Col 1: 11..30, Col 2: 31..60 - // Move Col 2 over Col 1 (right half), thereafter order should be: - // Col 2, Col 0, Col 1 - grid.setColumnOrder( new int[]{ - 0, 1, 2 - } ); - - GridColumnLCA.moveColumn( columns[ 2 ], 3 ); - - int[] columnOrder = grid.getColumnOrder(); - assertEquals( 2, columnOrder[ 0 ] ); - assertEquals( 0, columnOrder[ 1 ] ); - assertEquals( 1, columnOrder[ 2 ] ); - } - - public void testMoveColumn_5() { - column.dispose(); - GridColumn[] columns = createGridColumns( grid, 3, SWT.NONE ); - columns[ 0 ].setWidth( 10 ); - columns[ 1 ].setWidth( 20 ); - columns[ 2 ].setWidth( 30 ); - // Current order: Col 0: 0..10, Col 1: 11..30, Col 2: 31..60 - // Move Col 2 way left of Col 0, thereafter order should be: - // Col 2, Col 0, Col 1 - grid.setColumnOrder( new int[]{ - 0, 1, 2 - } ); - - GridColumnLCA.moveColumn( columns[ 2 ], -30 ); - - int[] columnOrder = grid.getColumnOrder(); - assertEquals( 2, columnOrder[ 0 ] ); - assertEquals( 0, columnOrder[ 1 ] ); - assertEquals( 1, columnOrder[ 2 ] ); - } - - public void testMoveColumn_6() { - column.dispose(); - GridColumn[] columns = createGridColumns( grid, 3, SWT.NONE ); - columns[ 0 ].setWidth( 10 ); - columns[ 1 ].setWidth( 20 ); - columns[ 2 ].setWidth( 30 ); - // Current order: Col 0: 0..10, Col 1: 11..30, Col 2: 31..60 - // Move Col 0 way right of Col 2, thereafter order should be: - // Col 1, Col 2, Col 0 - grid.setColumnOrder( new int[]{ - 0, 1, 2 - } ); - - GridColumnLCA.moveColumn( columns[ 0 ], 100 ); - - int[] columnOrder = grid.getColumnOrder(); - assertEquals( 1, columnOrder[ 0 ] ); - assertEquals( 2, columnOrder[ 1 ] ); - assertEquals( 0, columnOrder[ 2 ] ); - } - - public void testMoveColumn_7() { - column.dispose(); - GridColumn[] columns = createGridColumns( grid, 3, SWT.NONE ); - columns[ 0 ].setWidth( 10 ); - columns[ 1 ].setWidth( 20 ); - columns[ 2 ].setWidth( 30 ); - // Current order: Col 0: 0..10, Col 1: 11..30, Col 2: 31..60 - // Move Col 1 onto itself (left half), order should stay unchanged: - // Col 1, Col 2, Col 0 - grid.setColumnOrder( new int[]{ - 0, 1, 2 - } ); - - GridColumnLCA.moveColumn( columns[ 1 ], 13 ); - - int[] columnOrder = grid.getColumnOrder(); - assertEquals( 0, columnOrder[ 0 ] ); - assertEquals( 1, columnOrder[ 1 ] ); - assertEquals( 2, columnOrder[ 2 ] ); - } - - public void testMoveColumn_8() { - column.dispose(); - GridColumn[] columns = createGridColumns( grid, 3, SWT.NONE ); - columns[ 0 ].setWidth( 10 ); - columns[ 1 ].setWidth( 20 ); - columns[ 2 ].setWidth( 30 ); - // Current order: Col 0: 0..10, Col 1: 11..30, Col 2: 31..60 - // Move Col 0 over Col 2 (left half), order should be: - // Col 1, Col 0, Col 2 - grid.setColumnOrder( new int[]{ - 0, 1, 2 - } ); - - GridColumnLCA.moveColumn( columns[ 0 ], 33 ); - - int[] columnOrder = grid.getColumnOrder(); - assertEquals( 1, columnOrder[ 0 ] ); - assertEquals( 0, columnOrder[ 1 ] ); - assertEquals( 2, columnOrder[ 2 ] ); - } - - public void testMoveColumn_MoveIntoGroup() { - column.dispose(); - createGridColumns( grid, 2, SWT.NONE ); - GridColumnGroup group = new GridColumnGroup( grid, SWT.NONE ); - createGridColumns( group, 2, SWT.NONE ); - grid.getColumn( 0 ).setWidth( 10 ); - grid.getColumn( 1 ).setWidth( 20 ); - grid.getColumn( 2 ).setWidth( 30 ); - grid.getColumn( 3 ).setWidth( 40 ); - // Current order: Col 0: 0..10, Col 1: 11..30, Col 2: 31..60, Col 3: 61..100 - // Move Col 0 between Col 2 and Col 3 (inside the group) - // Movement should be ignored - grid.setColumnOrder( new int[]{ - 0, 1, 2, 3 - } ); - - GridColumnLCA.moveColumn( grid.getColumn( 0 ), 55 ); - - int[] columnOrder = grid.getColumnOrder(); - assertEquals( 0, columnOrder[ 0 ] ); - assertEquals( 1, columnOrder[ 1 ] ); - assertEquals( 2, columnOrder[ 2 ] ); - assertEquals( 3, columnOrder[ 3 ] ); - } - - public void testMoveColumn_MoveOutsideGroup() { - column.dispose(); - createGridColumns( grid, 2, SWT.NONE ); - GridColumnGroup group = new GridColumnGroup( grid, SWT.NONE ); - createGridColumns( group, 2, SWT.NONE ); - grid.getColumn( 0 ).setWidth( 10 ); - grid.getColumn( 1 ).setWidth( 20 ); - grid.getColumn( 2 ).setWidth( 30 ); - grid.getColumn( 3 ).setWidth( 40 ); - // Current order: Col 0: 0..10, Col 1: 11..30, Col 2: 31..60, Col 3: 61..100 - // Move Col 3 between Col 0 and Col 1 (outside the group) - // Movement should be ignored - grid.setColumnOrder( new int[]{ - 0, 1, 2, 3 - } ); - - GridColumnLCA.moveColumn( grid.getColumn( 3 ), 15 ); - - int[] columnOrder = grid.getColumnOrder(); - assertEquals( 0, columnOrder[ 0 ] ); - assertEquals( 1, columnOrder[ 1 ] ); - assertEquals( 2, columnOrder[ 2 ] ); - assertEquals( 3, columnOrder[ 3 ] ); - } - - public void testMoveColumn_WithInvisibleColumns() { - column.dispose(); - GridColumn[] columns = createGridColumns( grid, 4, SWT.NONE ); - columns[ 0 ].setWidth( 10 ); - columns[ 1 ].setWidth( 20 ); - columns[ 2 ].setWidth( 30 ); - columns[ 2 ].setVisible( false ); - columns[ 3 ].setWidth( 40 ); - // Current order: Col 0: 0..10, Col 1: 11..30, Col 2: not visible, Col 3: 31..70 - // Move Col 0 over Col 3 (left half), order should be: - // Col 1, Col 2, Col 0, Col 3 - grid.setColumnOrder( new int[]{ - 0, 1, 2, 3 - } ); - - GridColumnLCA.moveColumn( grid.getColumn( 0 ), 33 ); - - int[] columnOrder = grid.getColumnOrder(); - assertEquals( 1, columnOrder[ 0 ] ); - assertEquals( 2, columnOrder[ 1 ] ); - assertEquals( 0, columnOrder[ 2 ] ); - assertEquals( 3, columnOrder[ 3 ] ); - } - - public void testReadSelectionEvent() { - final List<SelectionEvent> events = new LinkedList<SelectionEvent>(); - column.addSelectionListener( new SelectionAdapter() { - @Override - public void widgetSelected( SelectionEvent event ) { - events.add( event ); - } - } ); - - Fixture.fakeNewRequest(); - Fixture.fakeNotifyOperation( getId( column ), ClientMessageConst.EVENT_SELECTION, null ); - Fixture.readDataAndProcessAction( column ); - - assertEquals( 1, events.size() ); - SelectionEvent event = events.get( 0 ); - assertSame( column, event.widget ); - } - + @Test public void testRenderInitialFont() throws IOException { lca.render( column ); @@ -861,6 +664,7 @@ assertTrue( operation.getPropertyNames().indexOf( "font" ) == -1 ); } + @Test public void testRenderFont() throws IOException { column.setHeaderFont( new Font( display, "Arial", 20, SWT.BOLD ) ); lca.renderChanges( column ); @@ -870,6 +674,7 @@ assertEquals( JsonArray.readFrom( "[[\"Arial\"], 20, true, false]" ), actual ); } + @Test public void testRenderFontUnchanged() throws IOException { Fixture.markInitialized( display ); Fixture.markInitialized( column ); @@ -882,6 +687,7 @@ assertNull( message.findSetOperation( column, "font" ) ); } + @Test public void testRenderInitialFooterFont() throws IOException { lca.render( column ); @@ -890,6 +696,7 @@ assertTrue( operation.getPropertyNames().indexOf( "footerFont" ) == -1 ); } + @Test public void testRenderFooterFont() throws IOException { column.setFooterFont( new Font( display, "Arial", 20, SWT.BOLD ) ); lca.renderChanges( column ); @@ -899,6 +706,7 @@ assertEquals( JsonArray.readFrom( "[[\"Arial\"], 20, true, false]" ), actual ); } + @Test public void testRenderFooterFontUnchanged() throws IOException { Fixture.markInitialized( display ); Fixture.markInitialized( column ); @@ -911,6 +719,7 @@ assertNull( message.findSetOperation( column, "footerFont" ) ); } + @Test public void testRenderInitialFooterText() throws IOException { lca.render( column ); @@ -919,6 +728,7 @@ assertTrue( operation.getPropertyNames().indexOf( "footerText" ) == -1 ); } + @Test public void testRenderFooterText() throws IOException { column.setFooterText( "foo" ); lca.renderChanges( column ); @@ -927,6 +737,7 @@ assertEquals( "foo", message.findSetProperty( column, "footerText" ).asString() ); } + @Test public void testRenderFooterTextUnchanged() throws IOException { Fixture.markInitialized( display ); Fixture.markInitialized( column ); @@ -939,6 +750,7 @@ assertNull( message.findSetOperation( column, "footerText" ) ); } + @Test public void testRenderInitialFooterImage() throws IOException { lca.renderChanges( column ); @@ -946,6 +758,7 @@ assertNull( message.findSetOperation( column, "footerImage" ) ); } + @Test public void testRenderFooterImage() throws IOException { Image image = loadImage( display, Fixture.IMAGE_100x50 ); @@ -958,6 +771,7 @@ assertEquals( expected, message.findSetProperty( column, "footerImage" ) ); } + @Test public void testRenderFooterImageUnchanged() throws IOException { Fixture.markInitialized( display ); Fixture.markInitialized( column ); @@ -971,6 +785,7 @@ assertNull( message.findSetOperation( column, "footerImage" ) ); } + @Test public void testRenderFooterImageReset() throws IOException { Fixture.markInitialized( display ); Fixture.markInitialized( column );
diff --git a/tests/org.eclipse.rap.nebula.widgets.grid.test/src/org/eclipse/nebula/widgets/grid/internal/gridcolumnkit/GridColumnOperationHandler_Test.java b/tests/org.eclipse.rap.nebula.widgets.grid.test/src/org/eclipse/nebula/widgets/grid/internal/gridcolumnkit/GridColumnOperationHandler_Test.java new file mode 100644 index 0000000..6e194f4 --- /dev/null +++ b/tests/org.eclipse.rap.nebula.widgets.grid.test/src/org/eclipse/nebula/widgets/grid/internal/gridcolumnkit/GridColumnOperationHandler_Test.java
@@ -0,0 +1,372 @@ +/******************************************************************************* + * Copyright (c) 2013 EclipseSource and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * EclipseSource - initial API and implementation + ******************************************************************************/ +package org.eclipse.nebula.widgets.grid.internal.gridcolumnkit; + +import static org.eclipse.nebula.widgets.grid.GridTestUtil.createGridColumns; +import static org.eclipse.nebula.widgets.grid.internal.gridcolumnkit.GridColumnOperationHandler.moveColumn; +import static org.eclipse.rap.rwt.internal.protocol.ClientMessageConst.EVENT_DEFAULT_SELECTION; +import static org.eclipse.rap.rwt.internal.protocol.ClientMessageConst.EVENT_SELECTION; +import static org.junit.Assert.assertArrayEquals; +import static org.junit.Assert.assertEquals; +import static org.mockito.Matchers.eq; +import static org.mockito.Mockito.spy; +import static org.mockito.Mockito.verify; + +import org.eclipse.nebula.widgets.grid.Grid; +import org.eclipse.nebula.widgets.grid.GridColumn; +import org.eclipse.nebula.widgets.grid.GridColumnGroup; +import org.eclipse.rap.json.JsonObject; +import org.eclipse.rap.rwt.lifecycle.PhaseId; +import org.eclipse.rap.rwt.testfixture.Fixture; +import org.eclipse.swt.SWT; +import org.eclipse.swt.widgets.Display; +import org.eclipse.swt.widgets.Event; +import org.eclipse.swt.widgets.Shell; +import org.junit.After; +import org.junit.Before; +import org.junit.Test; +import org.mockito.ArgumentCaptor; + + +@SuppressWarnings( "restriction" ) +public class GridColumnOperationHandler_Test { + + private Display display; + private Shell shell; + private Grid grid; + private GridColumn column; + private GridColumnOperationHandler handler; + + @Before + public void setUp() { + Fixture.setUp(); + display = new Display(); + shell = new Shell( display, SWT.NONE ); + grid = new Grid( shell, SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL ); + grid.setBounds( 0, 0, 100, 100 ); + column = new GridColumn( grid, SWT.NONE ); + column.setWidth( 50 ); + handler = new GridColumnOperationHandler( column ); + } + + @After + public void tearDown() { + Fixture.tearDown(); + } + + @Test + public void testHandleNotifySelection() { + GridColumn spyColumn = spy( column ); + handler = new GridColumnOperationHandler( spyColumn ); + JsonObject properties = new JsonObject() + .add( "altKey", true ) + .add( "shiftKey", true ); + + handler.handleNotify( EVENT_SELECTION, properties ); + + ArgumentCaptor<Event> captor = ArgumentCaptor.forClass( Event.class ); + verify( spyColumn ).notifyListeners( eq( SWT.Selection ), captor.capture() ); + Event event = captor.getValue(); + assertEquals( SWT.ALT | SWT.SHIFT, event.stateMask ); + } + + @Test + public void testHandleNotifyDefaultSelection() { + GridColumn spyColumn = spy( column ); + handler = new GridColumnOperationHandler( spyColumn ); + JsonObject properties = new JsonObject() + .add( "altKey", true ) + .add( "shiftKey", true ); + + handler.handleNotify( EVENT_DEFAULT_SELECTION, properties ); + + ArgumentCaptor<Event> captor = ArgumentCaptor.forClass( Event.class ); + verify( spyColumn ).notifyListeners( eq( SWT.DefaultSelection ), captor.capture() ); + Event event = captor.getValue(); + assertEquals( SWT.ALT | SWT.SHIFT, event.stateMask ); + } + + @Test + public void testHandleCallResize() { + Fixture.fakePhase( PhaseId.PROCESS_ACTION ); + JsonObject properties = new JsonObject().add( "width", 123 ); + + handler.handleCall( "resize", properties ); + + assertEquals( 123, column.getWidth() ); + } + + @Test + public void testHandleCallMove() { + Fixture.fakePhase( PhaseId.PROCESS_ACTION ); + GridColumn column1 = new GridColumn( grid, SWT.NONE ); + column1.setWidth( 100 ); + JsonObject properties = new JsonObject().add( "left", 123 ); + + handler.handleCall( "move", properties ); + + assertArrayEquals( new int[] { 1, 0 }, grid.getColumnOrder() ); + } + + @Test + public void testMoveColumn_1() { + column.dispose(); + GridColumn[] columns = createGridColumns( grid, 3, SWT.NONE ); + columns[ 0 ].setWidth( 10 ); + columns[ 1 ].setWidth( 20 ); + columns[ 2 ].setWidth( 30 ); + // Current order: Col 0: 0..10, Col 1: 11..30, Col 2: 31..60 (as created) + // Move Col 1 over Col 0 (left half), thereafter order should be: + // Col 1, Col 0, Col 2 + grid.setColumnOrder( new int[]{ + 0, 1, 2 + } ); + + moveColumn( columns[ 1 ], 3 ); + + int[] columnOrder = grid.getColumnOrder(); + assertEquals( 1, columnOrder[ 0 ] ); + assertEquals( 0, columnOrder[ 1 ] ); + assertEquals( 2, columnOrder[ 2 ] ); + } + + @Test + public void testMoveColumn_2() { + column.dispose(); + GridColumn[] columns = createGridColumns( grid, 3, SWT.NONE ); + columns[ 0 ].setWidth( 10 ); + columns[ 1 ].setWidth( 20 ); + columns[ 2 ].setWidth( 30 ); + // Current order: Col 1: 0..20, Col 0: 21..30, Col 2: 31..60 + // Move Col 1 over Col 0 (right half), thereafter order should be: + // Col 0, Col 1, Col 2 + grid.setColumnOrder( new int[]{ + 1, 0, 2 + } ); + + moveColumn( columns[ 1 ], 27 ); + + int[] columnOrder = grid.getColumnOrder(); + assertEquals( 0, columnOrder[ 0 ] ); + assertEquals( 1, columnOrder[ 1 ] ); + assertEquals( 2, columnOrder[ 2 ] ); + } + + @Test + public void testMoveColumn_3() { + column.dispose(); + GridColumn[] columns = createGridColumns( grid, 3, SWT.NONE ); + columns[ 0 ].setWidth( 10 ); + columns[ 1 ].setWidth( 20 ); + columns[ 2 ].setWidth( 30 ); + // Current order: Col 0: 0..10, Col 1: 11..30, Col 2: 31..60 + // Move Col 2 over Col 1 (left half), thereafter order should be: + // Col 0, Col 2, Col 1 + grid.setColumnOrder( new int[]{ + 0, 1, 2 + } ); + + moveColumn( columns[ 2 ], 13 ); + + int[] columnOrder = grid.getColumnOrder(); + assertEquals( 0, columnOrder[ 0 ] ); + assertEquals( 2, columnOrder[ 1 ] ); + assertEquals( 1, columnOrder[ 2 ] ); + } + + @Test + public void testMoveColumn_4() { + column.dispose(); + GridColumn[] columns = createGridColumns( grid, 3, SWT.NONE ); + columns[ 0 ].setWidth( 10 ); + columns[ 1 ].setWidth( 20 ); + columns[ 2 ].setWidth( 30 ); + // Current order: Col 0: 0..10, Col 1: 11..30, Col 2: 31..60 + // Move Col 2 over Col 1 (right half), thereafter order should be: + // Col 2, Col 0, Col 1 + grid.setColumnOrder( new int[]{ + 0, 1, 2 + } ); + + moveColumn( columns[ 2 ], 3 ); + + int[] columnOrder = grid.getColumnOrder(); + assertEquals( 2, columnOrder[ 0 ] ); + assertEquals( 0, columnOrder[ 1 ] ); + assertEquals( 1, columnOrder[ 2 ] ); + } + + @Test + public void testMoveColumn_5() { + column.dispose(); + GridColumn[] columns = createGridColumns( grid, 3, SWT.NONE ); + columns[ 0 ].setWidth( 10 ); + columns[ 1 ].setWidth( 20 ); + columns[ 2 ].setWidth( 30 ); + // Current order: Col 0: 0..10, Col 1: 11..30, Col 2: 31..60 + // Move Col 2 way left of Col 0, thereafter order should be: + // Col 2, Col 0, Col 1 + grid.setColumnOrder( new int[]{ + 0, 1, 2 + } ); + + moveColumn( columns[ 2 ], -30 ); + + int[] columnOrder = grid.getColumnOrder(); + assertEquals( 2, columnOrder[ 0 ] ); + assertEquals( 0, columnOrder[ 1 ] ); + assertEquals( 1, columnOrder[ 2 ] ); + } + + @Test + public void testMoveColumn_6() { + column.dispose(); + GridColumn[] columns = createGridColumns( grid, 3, SWT.NONE ); + columns[ 0 ].setWidth( 10 ); + columns[ 1 ].setWidth( 20 ); + columns[ 2 ].setWidth( 30 ); + // Current order: Col 0: 0..10, Col 1: 11..30, Col 2: 31..60 + // Move Col 0 way right of Col 2, thereafter order should be: + // Col 1, Col 2, Col 0 + grid.setColumnOrder( new int[]{ + 0, 1, 2 + } ); + + moveColumn( columns[ 0 ], 100 ); + + int[] columnOrder = grid.getColumnOrder(); + assertEquals( 1, columnOrder[ 0 ] ); + assertEquals( 2, columnOrder[ 1 ] ); + assertEquals( 0, columnOrder[ 2 ] ); + } + + @Test + public void testMoveColumn_7() { + column.dispose(); + GridColumn[] columns = createGridColumns( grid, 3, SWT.NONE ); + columns[ 0 ].setWidth( 10 ); + columns[ 1 ].setWidth( 20 ); + columns[ 2 ].setWidth( 30 ); + // Current order: Col 0: 0..10, Col 1: 11..30, Col 2: 31..60 + // Move Col 1 onto itself (left half), order should stay unchanged: + // Col 1, Col 2, Col 0 + grid.setColumnOrder( new int[]{ + 0, 1, 2 + } ); + + moveColumn( columns[ 1 ], 13 ); + + int[] columnOrder = grid.getColumnOrder(); + assertEquals( 0, columnOrder[ 0 ] ); + assertEquals( 1, columnOrder[ 1 ] ); + assertEquals( 2, columnOrder[ 2 ] ); + } + + @Test + public void testMoveColumn_8() { + column.dispose(); + GridColumn[] columns = createGridColumns( grid, 3, SWT.NONE ); + columns[ 0 ].setWidth( 10 ); + columns[ 1 ].setWidth( 20 ); + columns[ 2 ].setWidth( 30 ); + // Current order: Col 0: 0..10, Col 1: 11..30, Col 2: 31..60 + // Move Col 0 over Col 2 (left half), order should be: + // Col 1, Col 0, Col 2 + grid.setColumnOrder( new int[]{ + 0, 1, 2 + } ); + + moveColumn( columns[ 0 ], 33 ); + + int[] columnOrder = grid.getColumnOrder(); + assertEquals( 1, columnOrder[ 0 ] ); + assertEquals( 0, columnOrder[ 1 ] ); + assertEquals( 2, columnOrder[ 2 ] ); + } + + @Test + public void testMoveColumn_MoveIntoGroup() { + column.dispose(); + createGridColumns( grid, 2, SWT.NONE ); + GridColumnGroup group = new GridColumnGroup( grid, SWT.NONE ); + createGridColumns( group, 2, SWT.NONE ); + grid.getColumn( 0 ).setWidth( 10 ); + grid.getColumn( 1 ).setWidth( 20 ); + grid.getColumn( 2 ).setWidth( 30 ); + grid.getColumn( 3 ).setWidth( 40 ); + // Current order: Col 0: 0..10, Col 1: 11..30, Col 2: 31..60, Col 3: 61..100 + // Move Col 0 between Col 2 and Col 3 (inside the group) + // Movement should be ignored + grid.setColumnOrder( new int[]{ + 0, 1, 2, 3 + } ); + + moveColumn( grid.getColumn( 0 ), 55 ); + + int[] columnOrder = grid.getColumnOrder(); + assertEquals( 0, columnOrder[ 0 ] ); + assertEquals( 1, columnOrder[ 1 ] ); + assertEquals( 2, columnOrder[ 2 ] ); + assertEquals( 3, columnOrder[ 3 ] ); + } + + @Test + public void testMoveColumn_MoveOutsideGroup() { + column.dispose(); + createGridColumns( grid, 2, SWT.NONE ); + GridColumnGroup group = new GridColumnGroup( grid, SWT.NONE ); + createGridColumns( group, 2, SWT.NONE ); + grid.getColumn( 0 ).setWidth( 10 ); + grid.getColumn( 1 ).setWidth( 20 ); + grid.getColumn( 2 ).setWidth( 30 ); + grid.getColumn( 3 ).setWidth( 40 ); + // Current order: Col 0: 0..10, Col 1: 11..30, Col 2: 31..60, Col 3: 61..100 + // Move Col 3 between Col 0 and Col 1 (outside the group) + // Movement should be ignored + grid.setColumnOrder( new int[]{ + 0, 1, 2, 3 + } ); + + moveColumn( grid.getColumn( 3 ), 15 ); + + int[] columnOrder = grid.getColumnOrder(); + assertEquals( 0, columnOrder[ 0 ] ); + assertEquals( 1, columnOrder[ 1 ] ); + assertEquals( 2, columnOrder[ 2 ] ); + assertEquals( 3, columnOrder[ 3 ] ); + } + + @Test + public void testMoveColumn_WithInvisibleColumns() { + column.dispose(); + GridColumn[] columns = createGridColumns( grid, 4, SWT.NONE ); + columns[ 0 ].setWidth( 10 ); + columns[ 1 ].setWidth( 20 ); + columns[ 2 ].setWidth( 30 ); + columns[ 2 ].setVisible( false ); + columns[ 3 ].setWidth( 40 ); + // Current order: Col 0: 0..10, Col 1: 11..30, Col 2: not visible, Col 3: 31..70 + // Move Col 0 over Col 3 (left half), order should be: + // Col 1, Col 2, Col 0, Col 3 + grid.setColumnOrder( new int[]{ + 0, 1, 2, 3 + } ); + + moveColumn( grid.getColumn( 0 ), 33 ); + + int[] columnOrder = grid.getColumnOrder(); + assertEquals( 1, columnOrder[ 0 ] ); + assertEquals( 2, columnOrder[ 1 ] ); + assertEquals( 0, columnOrder[ 2 ] ); + assertEquals( 3, columnOrder[ 3 ] ); + } + +}
diff --git a/tests/org.eclipse.rap.nebula.widgets.grid.test/src/org/eclipse/nebula/widgets/grid/internal/griditemkit/GridItemLCA_Test.java b/tests/org.eclipse.rap.nebula.widgets.grid.test/src/org/eclipse/nebula/widgets/grid/internal/griditemkit/GridItemLCA_Test.java index 3868c03..104167a 100644 --- a/tests/org.eclipse.rap.nebula.widgets.grid.test/src/org/eclipse/nebula/widgets/grid/internal/griditemkit/GridItemLCA_Test.java +++ b/tests/org.eclipse.rap.nebula.widgets.grid.test/src/org/eclipse/nebula/widgets/grid/internal/griditemkit/GridItemLCA_Test.java
@@ -13,13 +13,14 @@ import static org.eclipse.nebula.widgets.grid.GridTestUtil.createGridColumns; import static org.eclipse.nebula.widgets.grid.GridTestUtil.createGridItems; import static org.eclipse.nebula.widgets.grid.GridTestUtil.loadImage; +import static org.eclipse.rap.rwt.internal.protocol.RemoteObjectFactory.getRemoteObject; import static org.eclipse.rap.rwt.lifecycle.WidgetUtil.getId; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertTrue; import java.io.IOException; -import java.util.LinkedList; -import java.util.List; - -import junit.framework.TestCase; import org.eclipse.nebula.widgets.grid.Grid; import org.eclipse.nebula.widgets.grid.GridItem; @@ -27,10 +28,10 @@ import org.eclipse.rap.json.JsonObject; import org.eclipse.rap.json.JsonValue; import org.eclipse.rap.rwt.RWT; -import org.eclipse.rap.rwt.internal.protocol.ClientMessageConst; import org.eclipse.rap.rwt.internal.remote.RemoteObjectImpl; import org.eclipse.rap.rwt.internal.remote.RemoteObjectRegistry; import org.eclipse.rap.rwt.lifecycle.WidgetUtil; +import org.eclipse.rap.rwt.remote.OperationHandler; import org.eclipse.rap.rwt.testfixture.Fixture; import org.eclipse.rap.rwt.testfixture.Message; import org.eclipse.rap.rwt.testfixture.Message.CreateOperation; @@ -39,14 +40,14 @@ import org.eclipse.swt.graphics.Font; import org.eclipse.swt.graphics.Image; import org.eclipse.swt.widgets.Display; -import org.eclipse.swt.widgets.Event; -import org.eclipse.swt.widgets.Listener; import org.eclipse.swt.widgets.Shell; +import org.junit.After; +import org.junit.Before; import org.junit.Test; @SuppressWarnings("restriction") -public class GridItemLCA_Test extends TestCase { +public class GridItemLCA_Test { private Display display; private Shell shell; @@ -54,8 +55,8 @@ private GridItem item; private GridItemLCA lca; - @Override - protected void setUp() throws Exception { + @Before + public void setUp() { Fixture.setUp(); display = new Display(); shell = new Shell( display ); @@ -65,11 +66,12 @@ Fixture.fakeNewRequest(); } - @Override - protected void tearDown() throws Exception { + @After + public void tearDown() { Fixture.tearDown(); } + @Test public void testRenderCreate() throws IOException { GridItem[] items = createGridItems( grid, 3, 3 ); @@ -81,6 +83,7 @@ assertEquals( 3, operation.getProperty( "index" ).asInt() ); } + @Test public void testRenderCreate_WithParentItem() throws IOException { GridItem[] items = createGridItems( grid, 3, 3 ); @@ -92,6 +95,17 @@ assertEquals( 1, operation.getProperty( "index" ).asInt() ); } + @Test + public void testRenderInitialization_setsOperationHandler() throws IOException { + String id = getId( item ); + + lca.renderInitialization( item ); + + OperationHandler handler = RemoteObjectRegistry.getInstance().get( id ).getHandler(); + assertTrue( handler instanceof GridItemOperationHandler ); + } + + @Test public void testRenderParent() throws IOException { lca.renderInitialization( item ); @@ -100,6 +114,7 @@ assertEquals( WidgetUtil.getId( item.getParent() ), operation.getParent() ); } + @Test public void testRenderParent_WithParentItem() throws IOException { GridItem subitem = new GridItem( item, SWT.NONE ); @@ -110,6 +125,7 @@ assertEquals( WidgetUtil.getId( item ), operation.getParent() ); } + @Test public void testRenderDispose() throws IOException { lca.renderDispose( item ); @@ -118,6 +134,7 @@ assertEquals( WidgetUtil.getId( item ), operation.getTarget() ); } + @Test public void testRenderDispose_WithDisposedGrid() throws IOException { grid.dispose(); @@ -127,6 +144,7 @@ assertEquals( 0, message.getOperationCount() ); } + @Test public void testRenderDispose_WithDisposedParentItem() throws IOException { GridItem[] items = createGridItems( grid, 3, 3 ); items[ 0 ].dispose(); @@ -148,6 +166,7 @@ assertTrue( remoteObject.isDestroyed() ); } + @Test public void testRenderInitialCustomVariant() throws IOException { lca.render( item ); @@ -156,6 +175,7 @@ assertTrue( operation.getPropertyNames().indexOf( "customVariant" ) == -1 ); } + @Test public void testRenderCustomVariant() throws IOException { item.setData( RWT.CUSTOM_VARIANT, "blue" ); lca.renderChanges( item ); @@ -164,6 +184,7 @@ assertEquals( "variant_blue", message.findSetProperty( item, "customVariant" ).asString() ); } + @Test public void testRenderCustomVariantUnchanged() throws IOException { Fixture.markInitialized( display ); Fixture.markInitialized( item ); @@ -176,6 +197,7 @@ assertNull( message.findSetOperation( item, "customVariant" ) ); } + @Test public void testRenderInitialItemCount() throws IOException { lca.render( item ); @@ -184,6 +206,7 @@ assertTrue( operation.getPropertyNames().indexOf( "itemCount" ) == -1 ); } + @Test public void testRenderItemCount() throws IOException { GridItem[] items = createGridItems( grid, 1, 10 ); lca.renderChanges( items[ 0 ] ); @@ -192,6 +215,7 @@ assertEquals( 10, message.findSetProperty( items[ 0 ], "itemCount" ).asInt() ); } + @Test public void testRenderItemCountUnchanged() throws IOException { GridItem[] items = createGridItems( grid, 1, 10 ); Fixture.markInitialized( display ); @@ -204,6 +228,7 @@ assertNull( message.findSetOperation( items[ 0 ], "itemCount" ) ); } + @Test public void testRenderInitialHeight() throws IOException { lca.render( item ); @@ -212,6 +237,7 @@ assertTrue( operation.getPropertyNames().indexOf( "height" ) == -1 ); } + @Test public void testRenderHeight() throws IOException { item.setHeight( 10 ); @@ -221,6 +247,7 @@ assertEquals( 10, message.findSetProperty( item, "height" ).asInt() ); } + @Test public void testRenderHeightUnchanged() throws IOException { Fixture.markInitialized( display ); Fixture.markInitialized( item ); @@ -233,6 +260,7 @@ assertNull( message.findSetOperation( item, "height" ) ); } + @Test public void testRenderInitialTexts() throws IOException { createGridColumns( grid, 2, SWT.NONE ); @@ -243,6 +271,7 @@ assertTrue( operation.getPropertyNames().indexOf( "texts" ) == -1 ); } + @Test public void testRenderTexts() throws IOException { createGridColumns( grid, 2, SWT.NONE ); @@ -255,6 +284,7 @@ assertEquals( expected, message.findSetProperty( item, "texts" ) ); } + @Test public void testRenderTextsUnchanged() throws IOException { createGridColumns( grid, 2, SWT.NONE ); Fixture.markInitialized( display ); @@ -269,6 +299,7 @@ assertNull( message.findSetOperation( item, "texts" ) ); } + @Test public void testRenderInitialImages() throws IOException { createGridColumns( grid, 2, SWT.NONE ); @@ -279,6 +310,7 @@ assertTrue( operation.getPropertyNames().indexOf( "images" ) == -1 ); } + @Test public void testRenderImages() throws IOException { createGridColumns( grid, 2, SWT.NONE ); Image image = loadImage( display, Fixture.IMAGE1 ); @@ -292,6 +324,7 @@ assertEquals( JsonArray.readFrom( expected ), actual ); } + @Test public void testRenderImagesUnchanged() throws IOException { createGridColumns( grid, 2, SWT.NONE ); Fixture.markInitialized( display ); @@ -306,6 +339,7 @@ assertNull( message.findSetOperation( item, "images" ) ); } + @Test public void testRenderInitialBackground() throws IOException { lca.render( item ); @@ -314,6 +348,7 @@ assertTrue( operation.getPropertyNames().indexOf( "background" ) == -1 ); } + @Test public void testRenderBackground() throws IOException { item.setBackground( display.getSystemColor( SWT.COLOR_GREEN ) ); lca.renderChanges( item ); @@ -323,6 +358,7 @@ assertEquals( JsonArray.readFrom( "[0,255,0,255]" ), actual ); } + @Test public void testRenderBackgroundUnchanged() throws IOException { Fixture.markInitialized( display ); Fixture.markInitialized( item ); @@ -335,6 +371,7 @@ assertNull( message.findSetOperation( item, "background" ) ); } + @Test public void testRenderInitialForeground() throws IOException { lca.render( item ); @@ -343,6 +380,7 @@ assertTrue( operation.getPropertyNames().indexOf( "foreground" ) == -1 ); } + @Test public void testRenderForeground() throws IOException { item.setForeground( display.getSystemColor( SWT.COLOR_GREEN ) ); lca.renderChanges( item ); @@ -352,6 +390,7 @@ assertEquals( JsonArray.readFrom( "[0,255,0,255]" ), actual ); } + @Test public void testRenderForegroundUnchanged() throws IOException { Fixture.markInitialized( display ); Fixture.markInitialized( item ); @@ -364,6 +403,7 @@ assertNull( message.findSetOperation( item, "foreground" ) ); } + @Test public void testRenderInitialFont() throws IOException { lca.render( item ); @@ -372,6 +412,7 @@ assertTrue( operation.getPropertyNames().indexOf( "font" ) == -1 ); } + @Test public void testRenderFont() throws IOException { item.setFont( new Font( display, "Arial", 20, SWT.BOLD ) ); lca.renderChanges( item ); @@ -381,6 +422,7 @@ assertEquals( JsonArray.readFrom( "[[\"Arial\"], 20, true, false]" ), actual ); } + @Test public void testRenderFontUnchanged() throws IOException { Fixture.markInitialized( display ); Fixture.markInitialized( item ); @@ -393,6 +435,7 @@ assertNull( message.findSetOperation( item, "font" ) ); } + @Test public void testRenderInitialCellBackgrounds() throws IOException { createGridColumns( grid, 2, SWT.NONE ); @@ -403,6 +446,7 @@ assertTrue( operation.getPropertyNames().indexOf( "cellBackgrounds" ) == -1 ); } + @Test public void testRenderCellBackgrounds() throws IOException { createGridColumns( grid, 2, SWT.NONE ); @@ -414,6 +458,7 @@ assertEquals( JsonArray.readFrom( "[null, [0,255,0,255]]" ), actual ); } + @Test public void testRenderCellBackgroundsUnchanged() throws IOException { createGridColumns( grid, 2, SWT.NONE ); Fixture.markInitialized( display ); @@ -427,6 +472,7 @@ assertNull( message.findSetOperation( item, "cellBackgrounds" ) ); } + @Test public void testRenderInitialCellForegrounds() throws IOException { createGridColumns( grid, 2, SWT.NONE ); @@ -437,6 +483,7 @@ assertTrue( operation.getPropertyNames().indexOf( "cellForegrounds" ) == -1 ); } + @Test public void testRenderCellForegrounds() throws IOException { createGridColumns( grid, 2, SWT.NONE ); @@ -448,6 +495,7 @@ assertEquals( JsonArray.readFrom( "[null, [0,255,0,255]]" ), actual ); } + @Test public void testRenderCellForegroundsUnchanged() throws IOException { createGridColumns( grid, 2, SWT.NONE ); Fixture.markInitialized( display ); @@ -461,6 +509,7 @@ assertNull( message.findSetOperation( item, "cellForegrounds" ) ); } + @Test public void testRenderInitialCellFonts() throws IOException { createGridColumns( grid, 2, SWT.NONE ); @@ -471,6 +520,7 @@ assertTrue( operation.getPropertyNames().indexOf( "cellFonts" ) == -1 ); } + @Test public void testRenderCellFonts() throws IOException { createGridColumns( grid, 2, SWT.NONE ); @@ -482,6 +532,7 @@ assertEquals( JsonArray.readFrom( "[null, [[\"Arial\"], 20, true, false]]" ), actual ); } + @Test public void testRenderCellFontsUnchanged() throws IOException { createGridColumns( grid, 2, SWT.NONE ); Fixture.markInitialized( display ); @@ -495,6 +546,7 @@ assertNull( message.findSetOperation( item, "cellFonts" ) ); } + @Test public void testRenderInitialExpanded() throws IOException { lca.render( item ); @@ -503,6 +555,7 @@ assertTrue( operation.getPropertyNames().indexOf( "expanded" ) == -1 ); } + @Test public void testRenderExpanded() throws IOException { new GridItem( item, SWT.NONE ); @@ -513,6 +566,7 @@ assertEquals( JsonValue.TRUE, message.findSetProperty( item, "expanded" ) ); } + @Test public void testRenderExpandedUnchanged() throws IOException { new GridItem( item, SWT.NONE ); Fixture.markInitialized( display ); @@ -526,6 +580,7 @@ assertNull( message.findSetOperation( item, "expanded" ) ); } + @Test public void testRenderInitialCellChecked() throws IOException { grid = new Grid( shell, SWT.CHECK ); createGridColumns( grid, 2, SWT.NONE ); @@ -538,6 +593,7 @@ assertTrue( operation.getPropertyNames().indexOf( "cellChecked" ) == -1 ); } + @Test public void testRenderCellChecked() throws IOException { grid = new Grid( shell, SWT.CHECK ); createGridColumns( grid, 2, SWT.NONE ); @@ -551,6 +607,7 @@ assertEquals( expected, message.findSetProperty( item, "cellChecked" ) ); } + @Test public void testRenderCellCheckedUnchanged() throws IOException { grid = new Grid( shell, SWT.CHECK ); createGridColumns( grid, 2, SWT.NONE ); @@ -566,6 +623,7 @@ assertNull( message.findSetOperation( item, "cellChecked" ) ); } + @Test public void testRenderInitialCellGrayed() throws IOException { grid = new Grid( shell, SWT.CHECK ); createGridColumns( grid, 2, SWT.NONE ); @@ -578,6 +636,7 @@ assertTrue( operation.getPropertyNames().indexOf( "cellGrayed" ) == -1 ); } + @Test public void testRenderCellGrayed() throws IOException { grid = new Grid( shell, SWT.CHECK ); createGridColumns( grid, 2, SWT.NONE ); @@ -591,6 +650,7 @@ assertEquals( expected, message.findSetProperty( item, "cellGrayed" ) ); } + @Test public void testRenderGrayedUnchanged() throws IOException { grid = new Grid( shell, SWT.CHECK ); createGridColumns( grid, 2, SWT.NONE ); @@ -606,6 +666,7 @@ assertNull( message.findSetOperation( item, "cellGrayed" ) ); } + @Test public void testRenderInitialCellCheckable() throws IOException { grid = new Grid( shell, SWT.CHECK ); createGridColumns( grid, 2, SWT.NONE ); @@ -618,6 +679,7 @@ assertTrue( operation.getPropertyNames().indexOf( "cellCheckable" ) == -1 ); } + @Test public void testRenderCellCheckable() throws IOException { grid = new Grid( shell, SWT.CHECK ); createGridColumns( grid, 2, SWT.NONE ); @@ -631,6 +693,7 @@ assertEquals( expected, message.findSetProperty( item, "cellCheckable" ) ); } + @Test public void testRenderCellCheckableUnchanged() throws IOException { grid = new Grid( shell, SWT.CHECK ); createGridColumns( grid, 2, SWT.NONE ); @@ -646,60 +709,13 @@ assertNull( message.findSetOperation( item, "cellCheckable" ) ); } - public void testReadChecked() { - grid = new Grid( shell, SWT.CHECK ); - createGridColumns( grid, 3, SWT.NONE ); - item = new GridItem( grid, SWT.NONE ); - - JsonArray cellChecked = new JsonArray() - .add( true ) - .add( false ) - .add( true ); - Fixture.fakeSetProperty( getId( item ), "cellChecked", cellChecked ); - Fixture.readDataAndProcessAction( item ); - - assertTrue( item.getChecked( 0 ) ); - assertFalse( item.getChecked( 1 ) ); - assertTrue( item.getChecked( 2 ) ); - } - - public void testProcessTreeEvent_Expanded() { - List<Event> events = new LinkedList<Event>(); - grid.addListener( SWT.Expand, new LoggingTreeListener( events ) ); - new GridItem( item, SWT.NONE ); - - Fixture.fakeSetProperty( getId( item ), "expanded", true ); - fakeTreeEvent( item, ClientMessageConst.EVENT_EXPAND ); - Fixture.readDataAndProcessAction( display ); - - assertEquals( 1, events.size() ); - Event event = events.get( 0 ); - assertEquals( grid, event.widget ); - assertEquals( item, event.item ); - assertTrue( item.isExpanded() ); - } - - public void testProcessTreeEvent_Collapsed() { - List<Event> events = new LinkedList<Event>(); - grid.addListener( SWT.Collapse, new LoggingTreeListener( events ) ); - new GridItem( item, SWT.NONE ); - item.setExpanded( true ); - - Fixture.fakeSetProperty( getId( item ), "expanded", false ); - fakeTreeEvent( item, ClientMessageConst.EVENT_COLLAPSE ); - Fixture.readDataAndProcessAction( display ); - - assertEquals( 1, events.size() ); - Event event = events.get( 0 ); - assertEquals( grid, event.widget ); - assertEquals( item, event.item ); - assertFalse( item.isExpanded() ); - } - + @Test public void testRenderScrollbarsVisibleAfterExpanded() { grid.setSize( 200, 200 ); createGridColumns( grid, 3, SWT.NONE ); GridItem[] items = createGridItems( grid, 5, 10 ); + Fixture.markInitialized( items[ 0 ] ); + getRemoteObject( items[ 0 ] ).setHandler( new GridItemOperationHandler( items[ 0 ] ) ); Fixture.markInitialized( grid ); Fixture.fakeSetProperty( getId( items[ 0 ] ), "expanded", true ); @@ -737,23 +753,4 @@ assertEquals( 0, message.getOperationCount() ); } - private static void fakeTreeEvent( GridItem item, String eventName ) { - JsonObject parameters = new JsonObject() - .add( ClientMessageConst.EVENT_PARAM_ITEM, getId( item ) ); - Fixture.fakeNotifyOperation( getId( item.getParent() ), eventName, parameters ); - } - - ////////////////// - // Helping classes - - private static class LoggingTreeListener implements Listener { - private final List<Event> events; - private LoggingTreeListener( List<Event> events ) { - this.events = events; - } - public void handleEvent( Event event ) { - events.add( event ); - } - } - }
diff --git a/tests/org.eclipse.rap.nebula.widgets.grid.test/src/org/eclipse/nebula/widgets/grid/internal/griditemkit/GridItemOperationHandler_Test.java b/tests/org.eclipse.rap.nebula.widgets.grid.test/src/org/eclipse/nebula/widgets/grid/internal/griditemkit/GridItemOperationHandler_Test.java new file mode 100644 index 0000000..e8d8ed7 --- /dev/null +++ b/tests/org.eclipse.rap.nebula.widgets.grid.test/src/org/eclipse/nebula/widgets/grid/internal/griditemkit/GridItemOperationHandler_Test.java
@@ -0,0 +1,89 @@ +/******************************************************************************* + * Copyright (c) 2013 EclipseSource and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * EclipseSource - initial API and implementation + ******************************************************************************/ +package org.eclipse.nebula.widgets.grid.internal.griditemkit; + +import static org.eclipse.nebula.widgets.grid.GridTestUtil.createGridColumns; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; + +import org.eclipse.nebula.widgets.grid.Grid; +import org.eclipse.nebula.widgets.grid.GridItem; +import org.eclipse.rap.json.JsonArray; +import org.eclipse.rap.json.JsonObject; +import org.eclipse.rap.rwt.lifecycle.PhaseId; +import org.eclipse.rap.rwt.testfixture.Fixture; +import org.eclipse.swt.SWT; +import org.eclipse.swt.widgets.Display; +import org.eclipse.swt.widgets.Shell; +import org.junit.After; +import org.junit.Before; +import org.junit.Test; + + +@SuppressWarnings( "restriction" ) +public class GridItemOperationHandler_Test { + + private Grid grid; + private GridItem item; + private GridItemOperationHandler handler; + + @Before + public void setUp() { + Fixture.setUp(); + Display display = new Display(); + Shell shell = new Shell( display, SWT.NONE ); + grid = new Grid( shell, SWT.CHECK ); + grid.setBounds( 0, 0, 100, 100 ); + item = new GridItem( grid, SWT.NONE ); + new GridItem( item, SWT.NONE ); + handler = new GridItemOperationHandler( item ); + } + + @After + public void tearDown() { + Fixture.tearDown(); + } + + @Test + public void testHandleSetChecked() { + createGridColumns( grid, 3, SWT.NONE ); + + JsonArray cellChecked = new JsonArray() + .add( true ) + .add( false ) + .add( true ); + handler.handleSet( new JsonObject().add( "cellChecked", cellChecked ) ); + + assertTrue( item.getChecked( 0 ) ); + assertFalse( item.getChecked( 1 ) ); + assertTrue( item.getChecked( 2 ) ); + } + + @Test + public void testHandleSetЕxpanded_expand() { + Fixture.fakePhase( PhaseId.PROCESS_ACTION ); + + handler.handleSet( new JsonObject().add( "expanded", true ) ); + + assertTrue( item.isExpanded() ); + } + + @Test + public void testHandleSetЕxpanded_collaps() { + Fixture.fakePhase( PhaseId.PROCESS_ACTION ); + item.setExpanded( true ); + + handler.handleSet( new JsonObject().add( "expanded", false ) ); + + assertFalse( item.isExpanded() ); + } + +}
diff --git a/tests/org.eclipse.rap.nebula.widgets.grid.test/src/org/eclipse/nebula/widgets/grid/internal/gridkit/GridLCA_Test.java b/tests/org.eclipse.rap.nebula.widgets.grid.test/src/org/eclipse/nebula/widgets/grid/internal/gridkit/GridLCA_Test.java index a3e4fce..309f78a 100644 --- a/tests/org.eclipse.rap.nebula.widgets.grid.test/src/org/eclipse/nebula/widgets/grid/internal/gridkit/GridLCA_Test.java +++ b/tests/org.eclipse.rap.nebula.widgets.grid.test/src/org/eclipse/nebula/widgets/grid/internal/gridkit/GridLCA_Test.java
@@ -13,15 +13,20 @@ import static org.eclipse.nebula.widgets.grid.GridTestUtil.createGridColumns; import static org.eclipse.nebula.widgets.grid.GridTestUtil.createGridItems; import static org.eclipse.nebula.widgets.grid.GridTestUtil.loadImage; +import static org.eclipse.rap.rwt.internal.protocol.RemoteObjectFactory.getRemoteObject; import static org.eclipse.rap.rwt.lifecycle.WidgetUtil.getId; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertTrue; +import static org.mockito.Mockito.spy; +import static org.mockito.Mockito.verify; import java.io.IOException; import java.util.Arrays; -import java.util.LinkedList; import java.util.List; -import junit.framework.TestCase; - import org.eclipse.nebula.widgets.grid.Grid; import org.eclipse.nebula.widgets.grid.GridColumn; import org.eclipse.nebula.widgets.grid.GridItem; @@ -31,7 +36,9 @@ import org.eclipse.rap.json.JsonObject; import org.eclipse.rap.json.JsonValue; import org.eclipse.rap.rwt.RWT; +import org.eclipse.rap.rwt.internal.remote.RemoteObjectRegistry; import org.eclipse.rap.rwt.lifecycle.WidgetUtil; +import org.eclipse.rap.rwt.remote.OperationHandler; import org.eclipse.rap.rwt.testfixture.Fixture; import org.eclipse.rap.rwt.testfixture.Message; import org.eclipse.rap.rwt.testfixture.Message.CreateOperation; @@ -41,22 +48,28 @@ import org.eclipse.swt.events.SelectionAdapter; import org.eclipse.swt.events.SelectionListener; import org.eclipse.swt.graphics.Image; +import org.eclipse.swt.internal.widgets.CellToolTipUtil; +import org.eclipse.swt.internal.widgets.ICellToolTipAdapter; +import org.eclipse.swt.internal.widgets.ICellToolTipProvider; import org.eclipse.swt.widgets.Display; -import org.eclipse.swt.widgets.Event; -import org.eclipse.swt.widgets.Listener; +import org.eclipse.swt.widgets.Item; import org.eclipse.swt.widgets.ScrollBar; import org.eclipse.swt.widgets.Shell; +import org.junit.After; +import org.junit.Before; +import org.junit.Test; -public class GridLCA_Test extends TestCase { +@SuppressWarnings( "restriction" ) +public class GridLCA_Test { private Display display; private Shell shell; private Grid grid; private GridLCA lca; - @Override - protected void setUp() throws Exception { + @Before + public void setUp() { Fixture.setUp(); display = new Display(); shell = new Shell( display ); @@ -65,11 +78,12 @@ Fixture.fakeNewRequest(); } - @Override - protected void tearDown() throws Exception { + @After + public void tearDown() { Fixture.tearDown(); } + @Test public void testRenderCreate() throws IOException { lca.renderInitialization( grid ); @@ -83,6 +97,7 @@ assertTrue( styles.contains( "FULL_SELECTION" ) ); } + @Test public void testRenderParent() throws IOException { lca.renderInitialization( grid ); @@ -91,6 +106,7 @@ assertEquals( getId( grid.getParent() ), operation.getParent() ); } + @Test public void testRenderCreateWithVirtualMulti() throws IOException { grid = new Grid( shell, SWT.VIRTUAL | SWT.MULTI ); @@ -104,6 +120,28 @@ assertEquals( JsonValue.TRUE, message.findListenProperty( grid, "SetData" ) ); } + @Test + public void testRenderInitialization_setsOperationHandler() throws IOException { + String id = getId( grid ); + + lca.renderInitialization( grid ); + + OperationHandler handler = RemoteObjectRegistry.getInstance().get( id ).getHandler(); + assertTrue( handler instanceof GridOperationHandler ); + } + + @Test + public void testReadData_usesOperationHandler() { + GridOperationHandler handler = spy( new GridOperationHandler( grid ) ); + getRemoteObject( getId( grid ) ).setHandler( handler ); + + Fixture.fakeNotifyOperation( getId( grid ), "Help", new JsonObject() ); + lca.readData( grid ); + + verify( handler ).handleNotifyHelp( grid, new JsonObject() ); + } + + @Test public void testRenderDispose() throws IOException { lca.renderDispose( grid ); @@ -113,6 +151,7 @@ assertEquals( getId( grid ), operation.getTarget() ); } + @Test public void testRenderInitialItemCount() throws IOException { lca.render( grid ); @@ -121,6 +160,7 @@ assertTrue( operation.getPropertyNames().indexOf( "itemCount" ) == -1 ); } + @Test public void testRenderItemCount() throws IOException { createGridItems( grid, 10, 3 ); lca.renderChanges( grid ); @@ -129,6 +169,7 @@ assertEquals( 10, message.findSetProperty( grid, "itemCount" ).asInt() ); } + @Test public void testRenderItemCountUnchanged() throws IOException { Fixture.markInitialized( display ); Fixture.markInitialized( grid ); @@ -141,6 +182,7 @@ assertNull( message.findSetOperation( grid, "itemCount" ) ); } + @Test public void testRenderInitialItemHeight() throws IOException { lca.render( grid ); @@ -148,6 +190,7 @@ assertNotNull( message.findSetOperation( grid, "itemHeight" ) ); } + @Test public void testRenderItemHeight() throws IOException { grid.setItemHeight( 40 ); lca.renderChanges( grid ); @@ -156,6 +199,7 @@ assertEquals( 40, message.findSetProperty( grid, "itemHeight" ).asInt() ); } + @Test public void testRenderItemHeightUnchanged() throws IOException { Fixture.markInitialized( display ); Fixture.markInitialized( grid ); @@ -168,6 +212,7 @@ assertNull( message.findSetOperation( grid, "itemHeight" ) ); } + @Test public void testRenderInitialItemMetrics() throws IOException { lca.render( grid ); @@ -175,6 +220,7 @@ assertNotNull( message.findSetOperation( grid, "itemMetrics" ) ); } + @Test public void testRenderItemMetrics() throws IOException { GridColumn column = new GridColumn( grid, SWT.NONE ); column.setWidth( 50 ); @@ -188,6 +234,7 @@ assertEquals( JsonArray.readFrom( "[0, 0, 50, 0, 0, 0, 44, 0, 0]" ), actual.get( 0 ) ); } + @Test public void testRenderItemMetrics_WithCheck() throws IOException { createGridColumns( grid, 2, SWT.CHECK ); GridItem[] items = createGridItems( grid, 3, 1 ); @@ -201,6 +248,7 @@ assertEquals( JsonArray.readFrom( "[1, 20, 40, 49, 0, 49, 5, 26, 21]" ), actual.get( 1 ) ); } + @Test public void testRenderItemMetricsUnchanged() throws IOException { createGridColumns( grid, 3, SWT.NONE ); GridItem item = new GridItem( grid, SWT.NONE ); @@ -215,6 +263,7 @@ assertNull( message.findSetOperation( grid, "itemMetrics" ) ); } + @Test public void testRenderInitialColumnCount() throws IOException { lca.render( grid ); @@ -223,6 +272,7 @@ assertTrue( operation.getPropertyNames().indexOf( "columnCount" ) == -1 ); } + @Test public void testRenderColumnCount() throws IOException { new GridColumn( grid, SWT.NONE ); lca.renderChanges( grid ); @@ -231,6 +281,7 @@ assertEquals( 1, message.findSetProperty( grid, "columnCount" ).asInt() ); } + @Test public void testRenderColumnCountUnchanged() throws IOException { Fixture.markInitialized( display ); Fixture.markInitialized( grid ); @@ -243,6 +294,7 @@ assertNull( message.findSetOperation( grid, "columnCount" ) ); } + @Test public void testRenderInitialTreeColumn() throws IOException { createGridColumns( grid, 2, SWT.NONE ); @@ -253,6 +305,7 @@ assertTrue( operation.getPropertyNames().indexOf( "treeColumn" ) == -1 ); } + @Test public void testRenderTreeColumn() throws IOException { createGridColumns( grid, 2, SWT.NONE ); @@ -263,6 +316,7 @@ assertEquals( 1, message.findSetProperty( grid, "treeColumn" ).asInt() ); } + @Test public void testRenderTreeColumnUnchanged() throws IOException { createGridColumns( grid, 2, SWT.NONE ); Fixture.markInitialized( display ); @@ -276,6 +330,7 @@ assertNull( message.findSetOperation( grid, "treeColumn" ) ); } + @Test public void testRenderInitialHeaderHeight() throws IOException { new GridColumn( grid, SWT.NONE ); @@ -286,6 +341,7 @@ assertTrue( operation.getPropertyNames().indexOf( "headerHeight" ) == -1 ); } + @Test public void testRenderHeaderHeight() throws IOException { new GridColumn( grid, SWT.NONE ); grid.setHeaderVisible( true ); @@ -296,6 +352,7 @@ assertEquals( 31, message.findSetProperty( grid, "headerHeight" ).asInt() ); } + @Test public void testRenderHeaderHeightUnchanged() throws IOException { new GridColumn( grid, SWT.NONE ); Fixture.markInitialized( display ); @@ -309,6 +366,7 @@ assertNull( message.findSetOperation( grid, "headerHeight" ) ); } + @Test public void testRenderInitialHeaderVisible() throws IOException { lca.render( grid ); @@ -317,6 +375,7 @@ assertTrue( operation.getPropertyNames().indexOf( "headerVisible" ) == -1 ); } + @Test public void testRenderHeaderVisible() throws IOException { grid.setHeaderVisible( true ); lca.renderChanges( grid ); @@ -325,6 +384,7 @@ assertEquals( JsonValue.TRUE, message.findSetProperty( grid, "headerVisible" ) ); } + @Test public void testRenderHeaderVisibleUnchanged() throws IOException { Fixture.markInitialized( display ); Fixture.markInitialized( grid ); @@ -337,6 +397,7 @@ assertNull( message.findSetOperation( grid, "headerVisible" ) ); } + @Test public void testRenderInitialFooterHeight() throws IOException { new GridColumn( grid, SWT.NONE ); @@ -347,6 +408,7 @@ assertTrue( operation.getPropertyNames().indexOf( "footerHeight" ) == -1 ); } + @Test public void testRenderFooterHeight() throws IOException { new GridColumn( grid, SWT.NONE ); grid.setFooterVisible( true ); @@ -357,6 +419,7 @@ assertEquals( 31, message.findSetProperty( grid, "footerHeight" ).asInt() ); } + @Test public void testRenderFooterHeightUnchanged() throws IOException { new GridColumn( grid, SWT.NONE ); Fixture.markInitialized( display ); @@ -370,6 +433,7 @@ assertNull( message.findSetOperation( grid, "footerHeight" ) ); } + @Test public void testRenderInitialFooterVisible() throws IOException { lca.render( grid ); @@ -378,6 +442,7 @@ assertTrue( operation.getPropertyNames().indexOf( "footerVisible" ) == -1 ); } + @Test public void testRenderFooterVisible() throws IOException { grid.setFooterVisible( true ); lca.renderChanges( grid ); @@ -386,6 +451,7 @@ assertEquals( JsonValue.TRUE, message.findSetProperty( grid, "footerVisible" ) ); } + @Test public void testRenderFooterVisibleUnchanged() throws IOException { Fixture.markInitialized( display ); Fixture.markInitialized( grid ); @@ -398,6 +464,7 @@ assertNull( message.findSetOperation( grid, "footerVisible" ) ); } + @Test public void testRenderInitialLinesVisible() throws IOException { lca.render( grid ); @@ -405,6 +472,7 @@ assertEquals( JsonValue.TRUE, message.findSetProperty( grid, "linesVisible" ) ); } + @Test public void testRenderLinesVisible() throws IOException { Fixture.markInitialized( grid ); grid.setLinesVisible( false ); @@ -414,6 +482,7 @@ assertEquals( JsonValue.FALSE, message.findSetProperty( grid, "linesVisible" ) ); } + @Test public void testRenderLinesVisibleUnchanged() throws IOException { Fixture.markInitialized( display ); Fixture.markInitialized( grid ); @@ -426,6 +495,7 @@ assertNull( message.findSetOperation( grid, "linesVisible" ) ); } + @Test public void testRenderInitialTopItemIndex() throws IOException { grid.setSize( 100, 100 ); @@ -436,6 +506,7 @@ assertTrue( operation.getPropertyNames().indexOf( "topItemIndex" ) == -1 ); } + @Test public void testRenderTopItemIndex() throws IOException { grid.setSize( 100, 100 ); createGridItems( grid, 10, 3 ); @@ -448,6 +519,7 @@ assertEquals( 2, message.findSetProperty( grid, "topItemIndex" ).asInt() ); } + @Test public void testRenderTopItemIndexUnchanged() throws IOException { grid.setSize( 100, 100 ); createGridItems( grid, 10, 3 ); @@ -462,6 +534,7 @@ assertNull( message.findSetOperation( grid, "topItemIndex" ) ); } + @Test public void testRenderInitialFocusItem() throws IOException { lca.render( grid ); @@ -470,6 +543,7 @@ assertTrue( operation.getPropertyNames().indexOf( "focusItem" ) == -1 ); } + @Test public void testRenderFocusItem() throws IOException { GridItem[] items = createGridItems( grid, 3, 0 ); @@ -480,6 +554,7 @@ assertEquals( getId( items[ 1 ] ), message.findSetProperty( grid, "focusItem" ).asString() ); } + @Test public void testRenderFocusItemUnchanged() throws IOException { GridItem[] items = createGridItems( grid, 3, 0 ); Fixture.markInitialized( display ); @@ -493,6 +568,7 @@ assertNull( message.findSetOperation( grid, "focusItem" ) ); } + @Test public void testRenderInitialScrollLeft() throws IOException { createGridColumns( grid, 3, SWT.NONE ); lca.render( grid ); @@ -502,6 +578,7 @@ assertTrue( operation.getPropertyNames().indexOf( "scrollLeft" ) == -1 ); } + @Test public void testRenderScrollLeft() throws IOException { createGridColumns( grid, 3, SWT.NONE ); grid.getHorizontalBar().setSelection( 10 ); @@ -511,6 +588,7 @@ assertEquals( 10, message.findSetProperty( grid, "scrollLeft" ).asInt() ); } + @Test public void testRenderScrollLeftUnchanged() throws IOException { createGridColumns( grid, 3, SWT.NONE ); Fixture.markInitialized( display ); @@ -524,6 +602,7 @@ assertNull( message.findSetOperation( grid, "scrollLeft" ) ); } + @Test public void testRenderInitialSelection() throws IOException { lca.render( grid ); @@ -532,6 +611,7 @@ assertTrue( operation.getPropertyNames().indexOf( "selection" ) == -1 ); } + @Test public void testRenderSelection() throws IOException { GridItem[] items = createGridItems( grid, 3, 3 ); @@ -545,6 +625,7 @@ assertEquals( expected, message.findSetProperty( grid, "selection" ) ); } + @Test public void testRenderSelectionUnchanged() throws IOException { createGridItems( grid, 3, 3 ); Fixture.markInitialized( display ); @@ -558,6 +639,7 @@ assertNull( message.findSetOperation( grid, "selection" ) ); } + @Test public void testRenderInitialSortDirection() throws IOException { lca.render( grid ); @@ -566,6 +648,7 @@ assertTrue( operation.getPropertyNames().indexOf( "sortDirection" ) == -1 ); } + @Test public void testRenderSortDirection() throws IOException { GridColumn[] columns = createGridColumns( grid, 3, SWT.NONE ); @@ -576,6 +659,7 @@ assertEquals( "up", message.findSetProperty( grid, "sortDirection" ).asString() ); } + @Test public void testRenderSortDirectionUnchanged() throws IOException { GridColumn[] columns = createGridColumns( grid, 3, SWT.NONE ); Fixture.markInitialized( display ); @@ -589,6 +673,7 @@ assertNull( message.findSetOperation( grid, "sortDirection" ) ); } + @Test public void testRenderInitialSortColumn() throws IOException { lca.render( grid ); @@ -597,6 +682,7 @@ assertTrue( operation.getPropertyNames().indexOf( "sortColumn" ) == -1 ); } + @Test public void testRenderSortColumn() throws IOException { GridColumn[] columns = createGridColumns( grid, 3, SWT.NONE ); @@ -607,6 +693,7 @@ assertEquals( getId( columns[ 1 ] ), message.findSetProperty( grid, "sortColumn" ).asString() ); } + @Test public void testRenderSortColumnUnchanged() throws IOException { GridColumn[] columns = createGridColumns( grid, 3, SWT.NONE ); Fixture.markInitialized( display ); @@ -620,6 +707,7 @@ assertNull( message.findSetOperation( grid, "sortColumn" ) ); } + @Test public void testRenderInitialScrollBarsVisible() throws IOException { doFakeRedraw(); @@ -630,6 +718,7 @@ assertNull( message.findSetOperation( grid.getVerticalBar(), "visibility" ) ); } + @Test public void testRenderScrollBarsVisible_Horizontal() throws IOException { grid.setSize( 200, 200 ); GridColumn[] columns = createGridColumns( grid, 3, SWT.NONE ); @@ -643,6 +732,7 @@ assertNull( message.findSetOperation( grid.getVerticalBar(), "visibility" ) ); } + @Test public void testRenderScrollBarsVisible_Vertical() throws IOException { grid.setSize( 200, 200 ); createGridColumns( grid, 3, SWT.NONE ); @@ -656,6 +746,7 @@ assertEquals( JsonValue.TRUE, message.findSetProperty( grid.getVerticalBar(), "visibility" ) ); } + @Test public void testRenderScrollBarsVisibleUnchanged() throws IOException { grid.setSize( 200, 200 ); GridColumn[] columns = createGridColumns( grid, 3, SWT.NONE ); @@ -675,6 +766,7 @@ assertNull( message.findSetOperation( grid.getVerticalBar(), "visibility" ) ); } + @Test public void testRenderAddScrollBarsSelectionListener_Horizontal() throws Exception { ScrollBar hScroll = grid.getHorizontalBar(); Fixture.markInitialized( display ); @@ -689,6 +781,7 @@ assertEquals( JsonValue.TRUE, message.findListenProperty( hScroll, "Selection" ) ); } + @Test public void testRenderRemoveScrollBarsSelectionListener_Horizontal() throws Exception { ScrollBar hScroll = grid.getHorizontalBar(); SelectionListener listener = new SelectionAdapter() { }; @@ -705,6 +798,7 @@ assertEquals( JsonValue.FALSE, message.findListenProperty( hScroll, "Selection" ) ); } + @Test public void testRenderScrollBarsSelectionListenerUnchanged_Horizontal() throws Exception { ScrollBar hScroll = grid.getHorizontalBar(); Fixture.markInitialized( display ); @@ -720,6 +814,7 @@ assertNull( message.findListenOperation( hScroll, "Selection" ) ); } + @Test public void testRenderAddScrollBarsSelectionListener_Vertical() throws Exception { ScrollBar vScroll = grid.getVerticalBar(); Fixture.markInitialized( display ); @@ -734,6 +829,7 @@ assertEquals( JsonValue.TRUE, message.findListenProperty( vScroll, "Selection" ) ); } + @Test public void testRenderRemoveScrollBarsSelectionListener_Vertical() throws Exception { ScrollBar vScroll = grid.getVerticalBar(); SelectionListener listener = new SelectionAdapter() { }; @@ -750,6 +846,7 @@ assertEquals( JsonValue.FALSE, message.findListenProperty( vScroll, "Selection" ) ); } + @Test public void testRenderScrollBarsSelectionListenerUnchanged_Vertical() throws Exception { ScrollBar vScroll = grid.getVerticalBar(); Fixture.markInitialized( display ); @@ -765,6 +862,7 @@ assertNull( message.findListenOperation( vScroll, "Selection" ) ); } + @Test public void testRenderAddSelectionListener() throws Exception { Fixture.markInitialized( display ); Fixture.markInitialized( grid ); @@ -778,6 +876,7 @@ assertEquals( JsonValue.TRUE, message.findListenProperty( grid, "DefaultSelection" ) ); } + @Test public void testRenderRemoveSelectionListener() throws Exception { SelectionListener listener = new SelectionAdapter() { }; grid.addSelectionListener( listener ); @@ -793,6 +892,7 @@ assertEquals( JsonValue.FALSE, message.findListenProperty( grid, "DefaultSelection" ) ); } + @Test public void testRenderSelectionListenerUnchanged() throws Exception { Fixture.markInitialized( display ); Fixture.markInitialized( grid ); @@ -807,6 +907,7 @@ assertNull( message.findListenOperation( grid, "DefaultSelection" ) ); } + @Test public void testRenderInitialEnableCellToolTip() throws IOException { lca.render( grid ); @@ -815,6 +916,7 @@ assertTrue( operation.getPropertyNames().indexOf( "enableCellToolTip" ) == -1 ); } + @Test public void testRenderEnableCellToolTip() throws IOException { createGridColumns( grid, 3, SWT.NONE ); GridItem item = new GridItem( grid, SWT.NONE ); @@ -826,6 +928,7 @@ assertEquals( JsonValue.TRUE, message.findSetProperty( grid, "enableCellToolTip" ) ); } + @Test public void testRenderEnableCellToolTipUnchanged() throws IOException { createGridColumns( grid, 3, SWT.NONE ); GridItem item = new GridItem( grid, SWT.NONE ); @@ -840,7 +943,9 @@ assertNull( message.findSetOperation( grid, "enableCellToolTip" ) ); } + @Test public void testRenderCellToolTipText() { + getRemoteObject( grid ).setHandler( new GridOperationHandler( grid ) ); createGridColumns( grid, 3, SWT.NONE ); GridItem item = new GridItem( grid, SWT.NONE ); item.setToolTipText( 1, "foo" ); @@ -854,119 +959,37 @@ assertEquals( "foo", message.findSetProperty( grid, "cellToolTipText" ).asString() ); } - public void testReadSelection() { - GridItem[] items = createGridItems( grid, 3, 0 ); - Fixture.fakeNewRequest(); - Fixture.fakeSetProperty( getId( grid ), - "selection", - createArray( getId( items[ 0 ] ), getId( items[ 2 ] ) ) ); - Fixture.readDataAndProcessAction( grid ); + @Test + public void testRenderCellToolTipText_resetsText() throws IOException { + ICellToolTipAdapter adapter = CellToolTipUtil.getAdapter( grid ); + adapter.setCellToolTipText( "foo" ); - GridItem[] selectedItems = grid.getSelection(); - assertEquals( 2, selectedItems.length ); - assertSame( items[ 0 ], selectedItems[ 0 ] ); - assertSame( items[ 2 ], selectedItems[ 1 ] ); + lca.renderChanges( grid ); + + assertNull( adapter.getCellToolTipText() ); } - public void testReadSelectionDisposedItem() { - GridItem[] items = createGridItems( grid, 3, 0 ); - items[ 0 ].dispose(); + @Test + public void testRenderCellToolTipTextNull() { + getRemoteObject( grid ).setHandler( new GridOperationHandler( grid ) ); + Fixture.markInitialized( display ); + Fixture.markInitialized( grid ); + createGridItems( grid, 5, 5 ); + final ICellToolTipAdapter adapter = CellToolTipUtil.getAdapter( grid ); + adapter.setCellToolTipProvider( new ICellToolTipProvider() { + public void getToolTipText( Item item, int columnIndex ) { + adapter.setCellToolTipText( null ); + } + } ); - Fixture.fakeNewRequest(); - Fixture.fakeSetProperty( getId( grid ), - "selection", - createArray( getId( items[ 0 ] ), getId( items[ 2 ] ) ) ); - Fixture.readDataAndProcessAction( grid ); + String itemId = WidgetUtil.getId( grid.getItem( 2 ) ); + processCellToolTipRequest( grid, itemId, 0 ); - GridItem[] selectedItems = grid.getSelection(); - assertEquals( 1, selectedItems.length ); - assertSame( items[ 2 ], selectedItems[ 0 ] ); + Message message = Fixture.getProtocolMessage(); + assertNull( message.findSetOperation( grid, "cellToolTipText" ) ); } - public void testReadScrollLeft() { - grid.setSize( 100, 100 ); - createGridColumns( grid, 5, SWT.NONE ); - createGridItems( grid, 10, 0 ); - - Fixture.fakeNewRequest(); - Fixture.fakeSetProperty( getId( grid ), "scrollLeft", 30 ); - Fixture.readDataAndProcessAction( grid ); - - assertEquals( 30, grid.getHorizontalBar().getSelection() ); - } - - public void testReadTopIndex() { - grid.setSize( 100, 100 ); - createGridColumns( grid, 5, SWT.NONE ); - GridItem[] items = createGridItems( grid, 10, 3 ); - items[ 4 ].setExpanded( true ); - - Fixture.fakeNewRequest(); - Fixture.fakeSetProperty( getId( grid ), "topItemIndex", 3 ); - Fixture.readDataAndProcessAction( grid ); - - assertEquals( 3, grid.getVerticalBar().getSelection() ); - assertEquals( 6, grid.getTopIndex() ); - } - - public void testProcessSelectionEvent() { - List<Event> events = new LinkedList<Event>(); - GridItem item = new GridItem( grid, SWT.NONE ); - grid.addListener( SWT.Selection, new LoggingListener( events ) ); - - Fixture.fakeNewRequest(); - JsonObject parameters = new JsonObject().add( "item", getId( item ) ); - Fixture.fakeNotifyOperation( getId( grid ), "Selection", parameters ); - Fixture.readDataAndProcessAction( display ); - - assertEquals( 1, events.size() ); - Event event = events.get( 0 ); - assertEquals( SWT.Selection, event.type ); - assertEquals( grid, event.widget ); - assertEquals( item, event.item ); - assertEquals( SWT.NONE, event.detail ); - } - - public void testProcessSelectionEvent_Check() { - List<Event> events = new LinkedList<Event>(); - GridItem item = new GridItem( grid, SWT.NONE ); - grid.addListener( SWT.Selection, new LoggingListener( events ) ); - - Fixture.fakeNewRequest(); - JsonObject parameters = new JsonObject() - .add( "item", getId( item ) ) - .add( "detail", "check" ) - .add( "index", 3 ); - Fixture.fakeNotifyOperation( getId( grid ), "Selection", parameters ); - Fixture.readDataAndProcessAction( display ); - - assertEquals( 1, events.size() ); - Event event = events.get( 0 ); - assertEquals( SWT.Selection, event.type ); - assertEquals( grid, event.widget ); - assertEquals( item, event.item ); - assertEquals( SWT.CHECK, event.detail ); - assertEquals( 3, event.index ); - } - - public void testProcessDefaultSelectionEvent() { - List<Event> events = new LinkedList<Event>(); - GridItem item = new GridItem( grid, SWT.NONE ); - grid.addListener( SWT.DefaultSelection, new LoggingListener( events ) ); - - Fixture.fakeNewRequest(); - JsonObject parameters = new JsonObject().add( "item", getId( item ) ); - Fixture.fakeNotifyOperation( getId( grid ), "DefaultSelection", parameters ); - Fixture.readDataAndProcessAction( display ); - - assertEquals( 1, events.size() ); - Event event = events.get( 0 ); - assertEquals( SWT.DefaultSelection, event.type ); - assertEquals( grid, event.widget ); - assertEquals( item, event.item ); - assertEquals( SWT.NONE, event.detail ); - } - + @Test public void testGetItemMetrics_CellLeft() { GridColumn[] columns = createGridColumns( grid, 2, SWT.NONE ); columns[ 0 ].setWidth( 100 ); @@ -978,6 +1001,7 @@ assertEquals( 100, metrics[ 1 ].left ); } + @Test public void testGetItemMetrics_CellWidth() { GridColumn[] columns = createGridColumns( grid, 2, SWT.NONE ); columns[ 0 ].setWidth( 100 ); @@ -989,6 +1013,7 @@ assertEquals( 150, metrics[ 1 ].width ); } + @Test public void testGetItemMetrics_ImageLeft() { Image image1 = loadImage( display, Fixture.IMAGE_100x50 ); Image image2 = loadImage( display, Fixture.IMAGE_50x100 ); @@ -1009,6 +1034,7 @@ assertEquals( 106, metrics[ 1 ].imageLeft ); } + @Test public void testGetItemMetrics_ImageWidth() { Image image1 = loadImage( display, Fixture.IMAGE_100x50 ); Image image2 = loadImage( display, Fixture.IMAGE_50x100 ); @@ -1033,6 +1059,7 @@ assertEquals( 0, metrics[ 0 ].imageWidth ); } + @Test public void testGetItemMetrics_TextLeftWithImage() { Image image = loadImage( display, Fixture.IMAGE_100x50 ); GridColumn[] columns = createGridColumns( grid, 2, SWT.NONE ); @@ -1049,6 +1076,7 @@ assertEquals( 206, metrics[ 1 ].textLeft ); } + @Test public void testGetItemMetrics_TextLeftWithCheckbox() { Image image = loadImage( display, Fixture.IMAGE_100x50 ); grid = new Grid( shell, SWT.CHECK ); @@ -1063,6 +1091,7 @@ assertEquals( 123, metrics[ 0 ].textLeft ); } + @Test public void testGetItemMetrics_TextWidthWithCheckbox() { Image image = loadImage( display, Fixture.IMAGE_100x50 ); grid = new Grid( shell, SWT.CHECK ); @@ -1077,6 +1106,7 @@ assertEquals( 71, metrics[ 0 ].textWidth ); } + @Test public void testRenderMarkupEnabled() throws IOException { grid.setData( RWT.MARKUP_ENABLED, Boolean.TRUE ); @@ -1086,6 +1116,7 @@ assertEquals( JsonValue.TRUE, message.findCreateProperty( grid, "markupEnabled" ) ); } + @Test public void testRenderAddExpandListener() throws Exception { lca.renderChanges( grid ); @@ -1093,6 +1124,7 @@ assertEquals( JsonValue.TRUE, message.findListenProperty( grid, "Expand" ) ); } + @Test public void testRenderAddCollapseListener() throws Exception { lca.renderChanges( grid ); @@ -1100,6 +1132,7 @@ assertEquals( JsonValue.TRUE, message.findListenProperty( grid, "Collapse" ) ); } + @Test public void testDontRenderSetDataListenerTwice() throws Exception { grid = new Grid( shell, SWT.VIRTUAL | SWT.MULTI ); Fixture.markInitialized( display ); @@ -1112,6 +1145,7 @@ assertNull( message.findListenOperation( grid, "SetData" ) ); } + @Test public void testDontRenderSetDataWithoutVirtual() throws Exception { Fixture.markInitialized( display ); Fixture.markInitialized( grid ); @@ -1123,23 +1157,6 @@ assertNull( message.findListenOperation( grid, "SetData" ) ); } - public void testReadFocusItem() { - GridItem[] items = createGridItems( grid, 3, 1 ); - - Fixture.fakeSetProperty( getId( grid ), "focusItem", getId( items[ 2 ] ) ); - lca.readData( grid ); - - assertSame( items[ 2 ], grid.getFocusItem() ); - } - - private static JsonValue createArray( String... values ) { - JsonArray array = new JsonArray(); - for( int i = 0; i < values.length; i++ ) { - array.add( values[ i ] ); - } - return array; - } - ////////////////// // Helping methods @@ -1156,17 +1173,4 @@ grid.getAdapter( IGridAdapter.class ).doRedraw(); } - ////////////////// - // Helping classes - - private static class LoggingListener implements Listener { - private final List<Event> events; - private LoggingListener( List<Event> events ) { - this.events = events; - } - public void handleEvent( Event event ) { - events.add( event ); - } - } - }
diff --git a/tests/org.eclipse.rap.nebula.widgets.grid.test/src/org/eclipse/nebula/widgets/grid/internal/gridkit/GridOperationHandler_Test.java b/tests/org.eclipse.rap.nebula.widgets.grid.test/src/org/eclipse/nebula/widgets/grid/internal/gridkit/GridOperationHandler_Test.java new file mode 100644 index 0000000..e48469b --- /dev/null +++ b/tests/org.eclipse.rap.nebula.widgets.grid.test/src/org/eclipse/nebula/widgets/grid/internal/gridkit/GridOperationHandler_Test.java
@@ -0,0 +1,281 @@ +/******************************************************************************* + * Copyright (c) 2013 EclipseSource and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * EclipseSource - initial API and implementation + ******************************************************************************/ +package org.eclipse.nebula.widgets.grid.internal.gridkit; + +import static org.eclipse.nebula.widgets.grid.GridTestUtil.createGridItems; +import static org.eclipse.rap.rwt.internal.protocol.ClientMessageConst.EVENT_COLLAPSE; +import static org.eclipse.rap.rwt.internal.protocol.ClientMessageConst.EVENT_DEFAULT_SELECTION; +import static org.eclipse.rap.rwt.internal.protocol.ClientMessageConst.EVENT_EXPAND; +import static org.eclipse.rap.rwt.internal.protocol.ClientMessageConst.EVENT_SELECTION; +import static org.eclipse.rap.rwt.internal.protocol.ClientMessageConst.EVENT_SET_DATA; +import static org.eclipse.rap.rwt.lifecycle.WidgetUtil.getId; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertSame; +import static org.mockito.Matchers.any; +import static org.mockito.Matchers.eq; +import static org.mockito.Mockito.never; +import static org.mockito.Mockito.spy; +import static org.mockito.Mockito.verify; + +import org.eclipse.nebula.widgets.grid.Grid; +import org.eclipse.nebula.widgets.grid.GridItem; +import org.eclipse.rap.json.JsonArray; +import org.eclipse.rap.json.JsonObject; +import org.eclipse.rap.rwt.RWT; +import org.eclipse.rap.rwt.testfixture.Fixture; +import org.eclipse.swt.SWT; +import org.eclipse.swt.internal.widgets.CellToolTipUtil; +import org.eclipse.swt.internal.widgets.ICellToolTipAdapter; +import org.eclipse.swt.internal.widgets.ICellToolTipProvider; +import org.eclipse.swt.widgets.Display; +import org.eclipse.swt.widgets.Event; +import org.eclipse.swt.widgets.Item; +import org.eclipse.swt.widgets.Shell; +import org.junit.After; +import org.junit.Before; +import org.junit.Test; +import org.mockito.ArgumentCaptor; + + +@SuppressWarnings( "restriction" ) +public class GridOperationHandler_Test { + + private Display display; + private Shell shell; + private Grid grid; + private GridOperationHandler handler; + + @Before + public void setUp() { + Fixture.setUp(); + display = new Display(); + shell = new Shell( display, SWT.NONE ); + grid = new Grid( shell, SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL ); + grid.setBounds( 0, 0, 100, 100 ); + handler = new GridOperationHandler( grid ); + } + + @After + public void tearDown() { + Fixture.tearDown(); + } + + @Test + public void testHandleSetSelection_single() { + createGridItems( grid, 3, 3 ); + GridItem item = grid.getItem( 1 ); + + JsonArray selection = new JsonArray().add( getId( item ) ); + handler.handleSet( new JsonObject().add( "selection", selection ) ); + + GridItem[] selectedItems = grid.getSelection(); + assertEquals( 1, selectedItems.length ); + assertSame( item, selectedItems[ 0 ] ); + } + + @Test + public void testHandleSetSelection_multi() { + createGridItems( grid, 3, 3 ); + GridItem item1 = grid.getItem( 0 ); + GridItem item2 = grid.getItem( 2 ); + + JsonArray selection = new JsonArray().add( getId( item1 ) ).add( getId( item2 ) ); + handler.handleSet( new JsonObject().add( "selection", selection ) ); + + GridItem[] selectedItems = grid.getSelection(); + assertEquals( 2, selectedItems.length ); + assertSame( item1, selectedItems[ 0 ] ); + assertSame( item2, selectedItems[ 1 ] ); + } + + @Test + public void testHandleSetSelection_disposedItem() { + createGridItems( grid, 3, 3 ); + GridItem item1 = grid.getItem( 0 ); + item1.dispose(); + GridItem item2 = grid.getItem( 2 ); + + JsonArray selection = new JsonArray().add( getId( item1 ) ).add( getId( item2 ) ); + handler.handleSet( new JsonObject().add( "selection", selection ) ); + + GridItem[] selectedItems = grid.getSelection(); + assertEquals( 1, selectedItems.length ); + assertSame( item2, selectedItems[ 0 ] ); + } + + @Test + public void testHandleSetScrollLeft() { + createGridItems( grid, 3, 3 ); + GridItem item = grid.getItem( 0 ); + item.setText( "very long text that makes horizontal bar visible" ); + + handler.handleSet( new JsonObject().add( "scrollLeft", 1 ) ); + + assertEquals( 1, grid.getHorizontalBar().getSelection() ); + } + + @Test + public void testHandleSetTopItemIndex() { + GridItem[] items = createGridItems( grid, 10, 3 ); + items[ 4 ].setExpanded( true ); + + handler.handleSet( new JsonObject().add( "topItemIndex", 3 ) ); + + assertEquals( 3, grid.getVerticalBar().getSelection() ); + assertEquals( 6, grid.getTopIndex() ); + } + + @Test + public void testHandleSetFocusItem() { + GridItem[] items = createGridItems( grid, 3, 1 ); + + handler.handleSet( new JsonObject().add( "focusItem", getId( items[ 2 ] ) ) ); + + assertSame( items[ 2 ], grid.getFocusItem() ); + } + + @Test + public void testHandleCallRenderToolTipText() { + GridItem item = new GridItem( grid, SWT.NONE ); + final ICellToolTipAdapter adapter = CellToolTipUtil.getAdapter( grid ); + adapter.setCellToolTipProvider( new ICellToolTipProvider() { + public void getToolTipText( Item item, int columnIndex ) { + StringBuilder buffer = new StringBuilder(); + buffer.append( getId( item ) ); + buffer.append( "," ); + buffer.append( columnIndex ); + adapter.setCellToolTipText( buffer.toString() ); + } + } ); + + JsonObject properties = new JsonObject().add( "item", getId( item ) ).add( "column", 0 ); + handler.handleCall( "renderToolTipText", properties ); + + assertEquals( getId( item ) + ",0", CellToolTipUtil.getAdapter( grid ).getCellToolTipText() ); + } + + @Test + public void testHandleNotifySelection() { + Grid spyGrid = spy( grid ); + handler = new GridOperationHandler( spyGrid ); + GridItem item = new GridItem( spyGrid, SWT.NONE ); + + JsonObject properties = new JsonObject() + .add( "altKey", true ) + .add( "shiftKey", true ) + .add( "item", getId( item ) ); + handler.handleNotify( EVENT_SELECTION, properties ); + + ArgumentCaptor<Event> captor = ArgumentCaptor.forClass( Event.class ); + verify( spyGrid ).notifyListeners( eq( SWT.Selection ), captor.capture() ); + Event event = captor.getValue(); + assertEquals( SWT.ALT | SWT.SHIFT, event.stateMask ); + assertEquals( item, event.item ); + } + + @Test + public void testHandleNotifySelection_withDetail_hyperlink() { + Grid spyGrid = spy( grid ); + handler = new GridOperationHandler( spyGrid ); + GridItem item = new GridItem( spyGrid, SWT.NONE ); + + JsonObject properties = new JsonObject() + .add( "item", getId( item ) ) + .add( "detail", "hyperlink" ) + .add( "text", "foo" ); + handler.handleNotify( EVENT_SELECTION, properties ); + + ArgumentCaptor<Event> captor = ArgumentCaptor.forClass( Event.class ); + verify( spyGrid ).notifyListeners( eq( SWT.Selection ), captor.capture() ); + Event event = captor.getValue(); + assertEquals( item, event.item ); + assertEquals( RWT.HYPERLINK, event.detail ); + assertEquals( "foo", event.text ); + } + + @Test + public void testHandleNotifySelection_withDetail_check() { + Grid spyGrid = spy( grid ); + handler = new GridOperationHandler( spyGrid ); + GridItem item = new GridItem( spyGrid, SWT.NONE ); + + JsonObject properties = new JsonObject() + .add( "item", getId( item ) ) + .add( "detail", "check" ) + .add( "index", 3 ); + handler.handleNotify( EVENT_SELECTION, properties ); + + ArgumentCaptor<Event> captor = ArgumentCaptor.forClass( Event.class ); + verify( spyGrid ).notifyListeners( eq( SWT.Selection ), captor.capture() ); + Event event = captor.getValue(); + assertEquals( item, event.item ); + assertEquals( SWT.CHECK, event.detail ); + assertEquals( 3, event.index ); + } + + @Test + public void testHandleNotifyDefaultSelection() { + Grid spyGrid = spy( grid ); + handler = new GridOperationHandler( spyGrid ); + GridItem item = new GridItem( spyGrid, SWT.NONE ); + + JsonObject properties = new JsonObject() + .add( "altKey", true ) + .add( "shiftKey", true ) + .add( "item", getId( item ) ); + handler.handleNotify( EVENT_DEFAULT_SELECTION, properties ); + + ArgumentCaptor<Event> captor = ArgumentCaptor.forClass( Event.class ); + verify( spyGrid ).notifyListeners( eq( SWT.DefaultSelection ), captor.capture() ); + Event event = captor.getValue(); + assertEquals( SWT.ALT | SWT.SHIFT, event.stateMask ); + assertEquals( item, event.item ); + } + + @Test + public void testHandleNotifyExpand() { + Grid spyGrid = spy( grid ); + handler = new GridOperationHandler( spyGrid ); + GridItem item = new GridItem( spyGrid, SWT.NONE ); + + JsonObject properties = new JsonObject().add( "item", getId( item ) ); + handler.handleNotify( EVENT_EXPAND, properties ); + + ArgumentCaptor<Event> captor = ArgumentCaptor.forClass( Event.class ); + verify( spyGrid ).notifyListeners( eq( SWT.Expand ), captor.capture() ); + assertEquals( item, captor.getValue().item ); + } + + @Test + public void testHandleNotifyCollapse() { + Grid spyGrid = spy( grid ); + handler = new GridOperationHandler( spyGrid ); + GridItem item = new GridItem( spyGrid, SWT.NONE ); + + JsonObject properties = new JsonObject().add( "item", getId( item ) ); + handler.handleNotify( EVENT_COLLAPSE, properties ); + + ArgumentCaptor<Event> captor = ArgumentCaptor.forClass( Event.class ); + verify( spyGrid ).notifyListeners( eq( SWT.Collapse ), captor.capture() ); + assertEquals( item, captor.getValue().item ); + } + + @Test + public void testHandleNotifySetData() { + Grid spyGrid = spy( grid ); + handler = new GridOperationHandler( spyGrid ); + + handler.handleNotify( EVENT_SET_DATA, new JsonObject() ); + + verify( spyGrid, never() ).notifyListeners( eq( SWT.SetData ), any( Event.class ) ); + } + +}