target stringlengths 20 113k | src_fm stringlengths 11 86.3k | src_fm_fc stringlengths 21 86.4k | src_fm_fc_co stringlengths 30 86.4k | src_fm_fc_ms stringlengths 42 86.8k | src_fm_fc_ms_ff stringlengths 43 86.8k |
|---|---|---|---|---|---|
@Test public void testNewShapeControl() { final WiresShapeControl wiresShapeControl = tested.newShapeControl(wiresShape, wiresManager); assertNotNull(wiresShapeControl); assertTrue(wiresShapeControl instanceof StunnerWiresShapeControl); } | @Override public WiresShapeControl newShapeControl(final WiresShape shape, final WiresManager wiresManager) { return new StunnerWiresShapeControl(new WiresShapeControlImpl(shape)); } | StunnerWiresControlFactory implements WiresControlFactory { @Override public WiresShapeControl newShapeControl(final WiresShape shape, final WiresManager wiresManager) { return new StunnerWiresShapeControl(new WiresShapeControlImpl(shape)); } } | StunnerWiresControlFactory implements WiresControlFactory { @Override public WiresShapeControl newShapeControl(final WiresShape shape, final WiresManager wiresManager) { return new StunnerWiresShapeControl(new WiresShapeControlImpl(shape)); } @Inject StunnerWiresControlFactory(final Event<CanvasUnhighlightEvent> unhighlightEvent); StunnerWiresControlFactory(final WiresControlFactoryImpl delegate,
final Event<CanvasUnhighlightEvent> unhighlightEvent); } | StunnerWiresControlFactory implements WiresControlFactory { @Override public WiresShapeControl newShapeControl(final WiresShape shape, final WiresManager wiresManager) { return new StunnerWiresShapeControl(new WiresShapeControlImpl(shape)); } @Inject StunnerWiresControlFactory(final Event<CanvasUnhighlightEvent> unhighlightEvent); StunnerWiresControlFactory(final WiresControlFactoryImpl delegate,
final Event<CanvasUnhighlightEvent> unhighlightEvent); @Override WiresShapeControl newShapeControl(final WiresShape shape,
final WiresManager wiresManager); @Override WiresConnectorControl newConnectorControl(final WiresConnector connector,
final WiresManager wiresManager); @Override WiresConnectionControl newConnectionControl(final WiresConnector connector,
final boolean headNotTail,
final WiresManager wiresManager); @Override WiresCompositeControl newCompositeControl(final WiresCompositeControl.Context context,
final WiresManager wiresManager); @Override WiresShapeHighlight<PickerPart.ShapePart> newShapeHighlight(final WiresManager wiresManager); @Override WiresLayerIndex newIndex(final WiresManager manager); } | StunnerWiresControlFactory implements WiresControlFactory { @Override public WiresShapeControl newShapeControl(final WiresShape shape, final WiresManager wiresManager) { return new StunnerWiresShapeControl(new WiresShapeControlImpl(shape)); } @Inject StunnerWiresControlFactory(final Event<CanvasUnhighlightEvent> unhighlightEvent); StunnerWiresControlFactory(final WiresControlFactoryImpl delegate,
final Event<CanvasUnhighlightEvent> unhighlightEvent); @Override WiresShapeControl newShapeControl(final WiresShape shape,
final WiresManager wiresManager); @Override WiresConnectorControl newConnectorControl(final WiresConnector connector,
final WiresManager wiresManager); @Override WiresConnectionControl newConnectionControl(final WiresConnector connector,
final boolean headNotTail,
final WiresManager wiresManager); @Override WiresCompositeControl newCompositeControl(final WiresCompositeControl.Context context,
final WiresManager wiresManager); @Override WiresShapeHighlight<PickerPart.ShapePart> newShapeHighlight(final WiresManager wiresManager); @Override WiresLayerIndex newIndex(final WiresManager manager); } |
@Test public void testNewConnectorControl() { assertEquals(connectorControl, tested.newConnectorControl(wiresConnector, wiresManager)); verify(connectorControl).setPointHandleDecorator(any(StunnerPointHandleDecorator.class)); } | @Override public WiresConnectorControl newConnectorControl(final WiresConnector connector, final WiresManager wiresManager) { final WiresConnectorControlImpl wiresConnectorControl = (WiresConnectorControlImpl) delegate.newConnectorControl(connector, wiresManager); wiresConnectorControl.setPointHandleDecorator(new StunnerPointHandleDecorator()); return wiresConnectorControl; } | StunnerWiresControlFactory implements WiresControlFactory { @Override public WiresConnectorControl newConnectorControl(final WiresConnector connector, final WiresManager wiresManager) { final WiresConnectorControlImpl wiresConnectorControl = (WiresConnectorControlImpl) delegate.newConnectorControl(connector, wiresManager); wiresConnectorControl.setPointHandleDecorator(new StunnerPointHandleDecorator()); return wiresConnectorControl; } } | StunnerWiresControlFactory implements WiresControlFactory { @Override public WiresConnectorControl newConnectorControl(final WiresConnector connector, final WiresManager wiresManager) { final WiresConnectorControlImpl wiresConnectorControl = (WiresConnectorControlImpl) delegate.newConnectorControl(connector, wiresManager); wiresConnectorControl.setPointHandleDecorator(new StunnerPointHandleDecorator()); return wiresConnectorControl; } @Inject StunnerWiresControlFactory(final Event<CanvasUnhighlightEvent> unhighlightEvent); StunnerWiresControlFactory(final WiresControlFactoryImpl delegate,
final Event<CanvasUnhighlightEvent> unhighlightEvent); } | StunnerWiresControlFactory implements WiresControlFactory { @Override public WiresConnectorControl newConnectorControl(final WiresConnector connector, final WiresManager wiresManager) { final WiresConnectorControlImpl wiresConnectorControl = (WiresConnectorControlImpl) delegate.newConnectorControl(connector, wiresManager); wiresConnectorControl.setPointHandleDecorator(new StunnerPointHandleDecorator()); return wiresConnectorControl; } @Inject StunnerWiresControlFactory(final Event<CanvasUnhighlightEvent> unhighlightEvent); StunnerWiresControlFactory(final WiresControlFactoryImpl delegate,
final Event<CanvasUnhighlightEvent> unhighlightEvent); @Override WiresShapeControl newShapeControl(final WiresShape shape,
final WiresManager wiresManager); @Override WiresConnectorControl newConnectorControl(final WiresConnector connector,
final WiresManager wiresManager); @Override WiresConnectionControl newConnectionControl(final WiresConnector connector,
final boolean headNotTail,
final WiresManager wiresManager); @Override WiresCompositeControl newCompositeControl(final WiresCompositeControl.Context context,
final WiresManager wiresManager); @Override WiresShapeHighlight<PickerPart.ShapePart> newShapeHighlight(final WiresManager wiresManager); @Override WiresLayerIndex newIndex(final WiresManager manager); } | StunnerWiresControlFactory implements WiresControlFactory { @Override public WiresConnectorControl newConnectorControl(final WiresConnector connector, final WiresManager wiresManager) { final WiresConnectorControlImpl wiresConnectorControl = (WiresConnectorControlImpl) delegate.newConnectorControl(connector, wiresManager); wiresConnectorControl.setPointHandleDecorator(new StunnerPointHandleDecorator()); return wiresConnectorControl; } @Inject StunnerWiresControlFactory(final Event<CanvasUnhighlightEvent> unhighlightEvent); StunnerWiresControlFactory(final WiresControlFactoryImpl delegate,
final Event<CanvasUnhighlightEvent> unhighlightEvent); @Override WiresShapeControl newShapeControl(final WiresShape shape,
final WiresManager wiresManager); @Override WiresConnectorControl newConnectorControl(final WiresConnector connector,
final WiresManager wiresManager); @Override WiresConnectionControl newConnectionControl(final WiresConnector connector,
final boolean headNotTail,
final WiresManager wiresManager); @Override WiresCompositeControl newCompositeControl(final WiresCompositeControl.Context context,
final WiresManager wiresManager); @Override WiresShapeHighlight<PickerPart.ShapePart> newShapeHighlight(final WiresManager wiresManager); @Override WiresLayerIndex newIndex(final WiresManager manager); } |
@Test public void testNewConnectionControl() { assertEquals(connectionControl, tested.newConnectionControl(wiresConnector, true, wiresManager)); } | @Override public WiresConnectionControl newConnectionControl(final WiresConnector connector, final boolean headNotTail, final WiresManager wiresManager) { return delegate.newConnectionControl(connector, headNotTail, wiresManager); } | StunnerWiresControlFactory implements WiresControlFactory { @Override public WiresConnectionControl newConnectionControl(final WiresConnector connector, final boolean headNotTail, final WiresManager wiresManager) { return delegate.newConnectionControl(connector, headNotTail, wiresManager); } } | StunnerWiresControlFactory implements WiresControlFactory { @Override public WiresConnectionControl newConnectionControl(final WiresConnector connector, final boolean headNotTail, final WiresManager wiresManager) { return delegate.newConnectionControl(connector, headNotTail, wiresManager); } @Inject StunnerWiresControlFactory(final Event<CanvasUnhighlightEvent> unhighlightEvent); StunnerWiresControlFactory(final WiresControlFactoryImpl delegate,
final Event<CanvasUnhighlightEvent> unhighlightEvent); } | StunnerWiresControlFactory implements WiresControlFactory { @Override public WiresConnectionControl newConnectionControl(final WiresConnector connector, final boolean headNotTail, final WiresManager wiresManager) { return delegate.newConnectionControl(connector, headNotTail, wiresManager); } @Inject StunnerWiresControlFactory(final Event<CanvasUnhighlightEvent> unhighlightEvent); StunnerWiresControlFactory(final WiresControlFactoryImpl delegate,
final Event<CanvasUnhighlightEvent> unhighlightEvent); @Override WiresShapeControl newShapeControl(final WiresShape shape,
final WiresManager wiresManager); @Override WiresConnectorControl newConnectorControl(final WiresConnector connector,
final WiresManager wiresManager); @Override WiresConnectionControl newConnectionControl(final WiresConnector connector,
final boolean headNotTail,
final WiresManager wiresManager); @Override WiresCompositeControl newCompositeControl(final WiresCompositeControl.Context context,
final WiresManager wiresManager); @Override WiresShapeHighlight<PickerPart.ShapePart> newShapeHighlight(final WiresManager wiresManager); @Override WiresLayerIndex newIndex(final WiresManager manager); } | StunnerWiresControlFactory implements WiresControlFactory { @Override public WiresConnectionControl newConnectionControl(final WiresConnector connector, final boolean headNotTail, final WiresManager wiresManager) { return delegate.newConnectionControl(connector, headNotTail, wiresManager); } @Inject StunnerWiresControlFactory(final Event<CanvasUnhighlightEvent> unhighlightEvent); StunnerWiresControlFactory(final WiresControlFactoryImpl delegate,
final Event<CanvasUnhighlightEvent> unhighlightEvent); @Override WiresShapeControl newShapeControl(final WiresShape shape,
final WiresManager wiresManager); @Override WiresConnectorControl newConnectorControl(final WiresConnector connector,
final WiresManager wiresManager); @Override WiresConnectionControl newConnectionControl(final WiresConnector connector,
final boolean headNotTail,
final WiresManager wiresManager); @Override WiresCompositeControl newCompositeControl(final WiresCompositeControl.Context context,
final WiresManager wiresManager); @Override WiresShapeHighlight<PickerPart.ShapePart> newShapeHighlight(final WiresManager wiresManager); @Override WiresLayerIndex newIndex(final WiresManager manager); } |
@Test public void testNewCompositeControl() { assertEquals(compositeControl, tested.newCompositeControl(compositeContext, wiresManager)); } | @Override public WiresCompositeControl newCompositeControl(final WiresCompositeControl.Context context, final WiresManager wiresManager) { return delegate.newCompositeControl(context, wiresManager); } | StunnerWiresControlFactory implements WiresControlFactory { @Override public WiresCompositeControl newCompositeControl(final WiresCompositeControl.Context context, final WiresManager wiresManager) { return delegate.newCompositeControl(context, wiresManager); } } | StunnerWiresControlFactory implements WiresControlFactory { @Override public WiresCompositeControl newCompositeControl(final WiresCompositeControl.Context context, final WiresManager wiresManager) { return delegate.newCompositeControl(context, wiresManager); } @Inject StunnerWiresControlFactory(final Event<CanvasUnhighlightEvent> unhighlightEvent); StunnerWiresControlFactory(final WiresControlFactoryImpl delegate,
final Event<CanvasUnhighlightEvent> unhighlightEvent); } | StunnerWiresControlFactory implements WiresControlFactory { @Override public WiresCompositeControl newCompositeControl(final WiresCompositeControl.Context context, final WiresManager wiresManager) { return delegate.newCompositeControl(context, wiresManager); } @Inject StunnerWiresControlFactory(final Event<CanvasUnhighlightEvent> unhighlightEvent); StunnerWiresControlFactory(final WiresControlFactoryImpl delegate,
final Event<CanvasUnhighlightEvent> unhighlightEvent); @Override WiresShapeControl newShapeControl(final WiresShape shape,
final WiresManager wiresManager); @Override WiresConnectorControl newConnectorControl(final WiresConnector connector,
final WiresManager wiresManager); @Override WiresConnectionControl newConnectionControl(final WiresConnector connector,
final boolean headNotTail,
final WiresManager wiresManager); @Override WiresCompositeControl newCompositeControl(final WiresCompositeControl.Context context,
final WiresManager wiresManager); @Override WiresShapeHighlight<PickerPart.ShapePart> newShapeHighlight(final WiresManager wiresManager); @Override WiresLayerIndex newIndex(final WiresManager manager); } | StunnerWiresControlFactory implements WiresControlFactory { @Override public WiresCompositeControl newCompositeControl(final WiresCompositeControl.Context context, final WiresManager wiresManager) { return delegate.newCompositeControl(context, wiresManager); } @Inject StunnerWiresControlFactory(final Event<CanvasUnhighlightEvent> unhighlightEvent); StunnerWiresControlFactory(final WiresControlFactoryImpl delegate,
final Event<CanvasUnhighlightEvent> unhighlightEvent); @Override WiresShapeControl newShapeControl(final WiresShape shape,
final WiresManager wiresManager); @Override WiresConnectorControl newConnectorControl(final WiresConnector connector,
final WiresManager wiresManager); @Override WiresConnectionControl newConnectionControl(final WiresConnector connector,
final boolean headNotTail,
final WiresManager wiresManager); @Override WiresCompositeControl newCompositeControl(final WiresCompositeControl.Context context,
final WiresManager wiresManager); @Override WiresShapeHighlight<PickerPart.ShapePart> newShapeHighlight(final WiresManager wiresManager); @Override WiresLayerIndex newIndex(final WiresManager manager); } |
@Test public void testNewShapeHighlight() { final WiresShapeHighlight<PickerPart.ShapePart> instance = tested.newShapeHighlight(wiresManager); assertNotNull(instance); assertTrue(instance instanceof StunnerWiresShapeStateHighlight); } | @Override public WiresShapeHighlight<PickerPart.ShapePart> newShapeHighlight(final WiresManager wiresManager) { return new StunnerWiresShapeStateHighlight(wiresManager, unhighlightEvent); } | StunnerWiresControlFactory implements WiresControlFactory { @Override public WiresShapeHighlight<PickerPart.ShapePart> newShapeHighlight(final WiresManager wiresManager) { return new StunnerWiresShapeStateHighlight(wiresManager, unhighlightEvent); } } | StunnerWiresControlFactory implements WiresControlFactory { @Override public WiresShapeHighlight<PickerPart.ShapePart> newShapeHighlight(final WiresManager wiresManager) { return new StunnerWiresShapeStateHighlight(wiresManager, unhighlightEvent); } @Inject StunnerWiresControlFactory(final Event<CanvasUnhighlightEvent> unhighlightEvent); StunnerWiresControlFactory(final WiresControlFactoryImpl delegate,
final Event<CanvasUnhighlightEvent> unhighlightEvent); } | StunnerWiresControlFactory implements WiresControlFactory { @Override public WiresShapeHighlight<PickerPart.ShapePart> newShapeHighlight(final WiresManager wiresManager) { return new StunnerWiresShapeStateHighlight(wiresManager, unhighlightEvent); } @Inject StunnerWiresControlFactory(final Event<CanvasUnhighlightEvent> unhighlightEvent); StunnerWiresControlFactory(final WiresControlFactoryImpl delegate,
final Event<CanvasUnhighlightEvent> unhighlightEvent); @Override WiresShapeControl newShapeControl(final WiresShape shape,
final WiresManager wiresManager); @Override WiresConnectorControl newConnectorControl(final WiresConnector connector,
final WiresManager wiresManager); @Override WiresConnectionControl newConnectionControl(final WiresConnector connector,
final boolean headNotTail,
final WiresManager wiresManager); @Override WiresCompositeControl newCompositeControl(final WiresCompositeControl.Context context,
final WiresManager wiresManager); @Override WiresShapeHighlight<PickerPart.ShapePart> newShapeHighlight(final WiresManager wiresManager); @Override WiresLayerIndex newIndex(final WiresManager manager); } | StunnerWiresControlFactory implements WiresControlFactory { @Override public WiresShapeHighlight<PickerPart.ShapePart> newShapeHighlight(final WiresManager wiresManager) { return new StunnerWiresShapeStateHighlight(wiresManager, unhighlightEvent); } @Inject StunnerWiresControlFactory(final Event<CanvasUnhighlightEvent> unhighlightEvent); StunnerWiresControlFactory(final WiresControlFactoryImpl delegate,
final Event<CanvasUnhighlightEvent> unhighlightEvent); @Override WiresShapeControl newShapeControl(final WiresShape shape,
final WiresManager wiresManager); @Override WiresConnectorControl newConnectorControl(final WiresConnector connector,
final WiresManager wiresManager); @Override WiresConnectionControl newConnectionControl(final WiresConnector connector,
final boolean headNotTail,
final WiresManager wiresManager); @Override WiresCompositeControl newCompositeControl(final WiresCompositeControl.Context context,
final WiresManager wiresManager); @Override WiresShapeHighlight<PickerPart.ShapePart> newShapeHighlight(final WiresManager wiresManager); @Override WiresLayerIndex newIndex(final WiresManager manager); } |
@Test public void decorateValidNone() { tested.decorate(shape, IShapeDecorator.ShapeState.VALID); tested.decorate(shape, IShapeDecorator.ShapeState.NONE); verify(shape, times(2)).setFillColor(StunnerPointHandleDecorator.MAIN_COLOR); verify(shape, times(2)).setFillAlpha(0.8); verify(shape, times(2)).setStrokeAlpha(1); verify(shape, times(2)).setShadow(SHADOW_SELECTED); verify(shape, times(2)).setStrokeWidth(2); verify(shape, times(2)).setStrokeColor(StunnerPointHandleDecorator.STROKE_COLOR); } | @Override public Shape decorate(Shape shape, ShapeState state) { switch (state) { case NONE: case VALID: shape.setFillColor(MAIN_COLOR) .setFillAlpha(0.8) .setStrokeAlpha(1) .setShadow(SHADOW_SELECTED) .setStrokeWidth(2) .setStrokeColor(STROKE_COLOR); break; case INVALID: shape.setFillColor(ColorName.WHITE) .setFillAlpha(1) .setShadow(SHADOW_SELECTED) .setStrokeAlpha(1) .setStrokeWidth(2) .setStrokeColor(MAIN_COLOR); break; } return shape; } | StunnerPointHandleDecorator extends PointHandleDecorator { @Override public Shape decorate(Shape shape, ShapeState state) { switch (state) { case NONE: case VALID: shape.setFillColor(MAIN_COLOR) .setFillAlpha(0.8) .setStrokeAlpha(1) .setShadow(SHADOW_SELECTED) .setStrokeWidth(2) .setStrokeColor(STROKE_COLOR); break; case INVALID: shape.setFillColor(ColorName.WHITE) .setFillAlpha(1) .setShadow(SHADOW_SELECTED) .setStrokeAlpha(1) .setStrokeWidth(2) .setStrokeColor(MAIN_COLOR); break; } return shape; } } | StunnerPointHandleDecorator extends PointHandleDecorator { @Override public Shape decorate(Shape shape, ShapeState state) { switch (state) { case NONE: case VALID: shape.setFillColor(MAIN_COLOR) .setFillAlpha(0.8) .setStrokeAlpha(1) .setShadow(SHADOW_SELECTED) .setStrokeWidth(2) .setStrokeColor(STROKE_COLOR); break; case INVALID: shape.setFillColor(ColorName.WHITE) .setFillAlpha(1) .setShadow(SHADOW_SELECTED) .setStrokeAlpha(1) .setStrokeWidth(2) .setStrokeColor(MAIN_COLOR); break; } return shape; } } | StunnerPointHandleDecorator extends PointHandleDecorator { @Override public Shape decorate(Shape shape, ShapeState state) { switch (state) { case NONE: case VALID: shape.setFillColor(MAIN_COLOR) .setFillAlpha(0.8) .setStrokeAlpha(1) .setShadow(SHADOW_SELECTED) .setStrokeWidth(2) .setStrokeColor(STROKE_COLOR); break; case INVALID: shape.setFillColor(ColorName.WHITE) .setFillAlpha(1) .setShadow(SHADOW_SELECTED) .setStrokeAlpha(1) .setStrokeWidth(2) .setStrokeColor(MAIN_COLOR); break; } return shape; } @Override Shape decorate(Shape shape, ShapeState state); } | StunnerPointHandleDecorator extends PointHandleDecorator { @Override public Shape decorate(Shape shape, ShapeState state) { switch (state) { case NONE: case VALID: shape.setFillColor(MAIN_COLOR) .setFillAlpha(0.8) .setStrokeAlpha(1) .setShadow(SHADOW_SELECTED) .setStrokeWidth(2) .setStrokeColor(STROKE_COLOR); break; case INVALID: shape.setFillColor(ColorName.WHITE) .setFillAlpha(1) .setShadow(SHADOW_SELECTED) .setStrokeAlpha(1) .setStrokeWidth(2) .setStrokeColor(MAIN_COLOR); break; } return shape; } @Override Shape decorate(Shape shape, ShapeState state); static final String MAIN_COLOR; static final String STROKE_COLOR; } |
@Test public void decorateInvalid() { tested.decorate(shape, IShapeDecorator.ShapeState.INVALID); verify(shape).setFillColor(ColorName.WHITE); verify(shape).setShadow(SHADOW_SELECTED); verify(shape).setFillAlpha(1); verify(shape).setStrokeAlpha(1); verify(shape).setStrokeWidth(2); verify(shape).setStrokeColor(StunnerPointHandleDecorator.MAIN_COLOR); } | @Override public Shape decorate(Shape shape, ShapeState state) { switch (state) { case NONE: case VALID: shape.setFillColor(MAIN_COLOR) .setFillAlpha(0.8) .setStrokeAlpha(1) .setShadow(SHADOW_SELECTED) .setStrokeWidth(2) .setStrokeColor(STROKE_COLOR); break; case INVALID: shape.setFillColor(ColorName.WHITE) .setFillAlpha(1) .setShadow(SHADOW_SELECTED) .setStrokeAlpha(1) .setStrokeWidth(2) .setStrokeColor(MAIN_COLOR); break; } return shape; } | StunnerPointHandleDecorator extends PointHandleDecorator { @Override public Shape decorate(Shape shape, ShapeState state) { switch (state) { case NONE: case VALID: shape.setFillColor(MAIN_COLOR) .setFillAlpha(0.8) .setStrokeAlpha(1) .setShadow(SHADOW_SELECTED) .setStrokeWidth(2) .setStrokeColor(STROKE_COLOR); break; case INVALID: shape.setFillColor(ColorName.WHITE) .setFillAlpha(1) .setShadow(SHADOW_SELECTED) .setStrokeAlpha(1) .setStrokeWidth(2) .setStrokeColor(MAIN_COLOR); break; } return shape; } } | StunnerPointHandleDecorator extends PointHandleDecorator { @Override public Shape decorate(Shape shape, ShapeState state) { switch (state) { case NONE: case VALID: shape.setFillColor(MAIN_COLOR) .setFillAlpha(0.8) .setStrokeAlpha(1) .setShadow(SHADOW_SELECTED) .setStrokeWidth(2) .setStrokeColor(STROKE_COLOR); break; case INVALID: shape.setFillColor(ColorName.WHITE) .setFillAlpha(1) .setShadow(SHADOW_SELECTED) .setStrokeAlpha(1) .setStrokeWidth(2) .setStrokeColor(MAIN_COLOR); break; } return shape; } } | StunnerPointHandleDecorator extends PointHandleDecorator { @Override public Shape decorate(Shape shape, ShapeState state) { switch (state) { case NONE: case VALID: shape.setFillColor(MAIN_COLOR) .setFillAlpha(0.8) .setStrokeAlpha(1) .setShadow(SHADOW_SELECTED) .setStrokeWidth(2) .setStrokeColor(STROKE_COLOR); break; case INVALID: shape.setFillColor(ColorName.WHITE) .setFillAlpha(1) .setShadow(SHADOW_SELECTED) .setStrokeAlpha(1) .setStrokeWidth(2) .setStrokeColor(MAIN_COLOR); break; } return shape; } @Override Shape decorate(Shape shape, ShapeState state); } | StunnerPointHandleDecorator extends PointHandleDecorator { @Override public Shape decorate(Shape shape, ShapeState state) { switch (state) { case NONE: case VALID: shape.setFillColor(MAIN_COLOR) .setFillAlpha(0.8) .setStrokeAlpha(1) .setShadow(SHADOW_SELECTED) .setStrokeWidth(2) .setStrokeColor(STROKE_COLOR); break; case INVALID: shape.setFillColor(ColorName.WHITE) .setFillAlpha(1) .setShadow(SHADOW_SELECTED) .setStrokeAlpha(1) .setStrokeWidth(2) .setStrokeColor(MAIN_COLOR); break; } return shape; } @Override Shape decorate(Shape shape, ShapeState state); static final String MAIN_COLOR; static final String STROKE_COLOR; } |
@Test public void decorate() { tested.decorate(shape, IShapeDecorator.ShapeState.VALID); tested.decorate(shape, IShapeDecorator.ShapeState.INVALID); tested.decorate(shape, IShapeDecorator.ShapeState.NONE); verify(shape, times(3)).setFillColor("#0088CE"); verify(shape, times(3)).setFillAlpha(0.7); verify(shape, times(3)).setStrokeAlpha(1); verify(shape, times(3)).setStrokeWidth(0); verify(shape, times(3)).moveToTop(); } | @Override public Shape decorate(Shape shape, ShapeState state) { switch (state) { case VALID: case INVALID: case NONE: shape.setFillColor(StunnerPointHandleDecorator.MAIN_COLOR) .setFillAlpha(0.7) .setStrokeAlpha(1) .setStrokeWidth(0) .moveToTop(); } return shape; } | StunnerMagnetDecorator extends MagnetDecorator { @Override public Shape decorate(Shape shape, ShapeState state) { switch (state) { case VALID: case INVALID: case NONE: shape.setFillColor(StunnerPointHandleDecorator.MAIN_COLOR) .setFillAlpha(0.7) .setStrokeAlpha(1) .setStrokeWidth(0) .moveToTop(); } return shape; } } | StunnerMagnetDecorator extends MagnetDecorator { @Override public Shape decorate(Shape shape, ShapeState state) { switch (state) { case VALID: case INVALID: case NONE: shape.setFillColor(StunnerPointHandleDecorator.MAIN_COLOR) .setFillAlpha(0.7) .setStrokeAlpha(1) .setStrokeWidth(0) .moveToTop(); } return shape; } } | StunnerMagnetDecorator extends MagnetDecorator { @Override public Shape decorate(Shape shape, ShapeState state) { switch (state) { case VALID: case INVALID: case NONE: shape.setFillColor(StunnerPointHandleDecorator.MAIN_COLOR) .setFillAlpha(0.7) .setStrokeAlpha(1) .setStrokeWidth(0) .moveToTop(); } return shape; } @Override Shape decorate(Shape shape, ShapeState state); } | StunnerMagnetDecorator extends MagnetDecorator { @Override public Shape decorate(Shape shape, ShapeState state) { switch (state) { case VALID: case INVALID: case NONE: shape.setFillColor(StunnerPointHandleDecorator.MAIN_COLOR) .setFillAlpha(0.7) .setStrokeAlpha(1) .setStrokeWidth(0) .moveToTop(); } return shape; } @Override Shape decorate(Shape shape, ShapeState state); } |
@Test public void testGetItems() { final Diagram stunnerDiagram1 = mock(Diagram.class); final Diagram stunnerDiagram2 = mock(Diagram.class); final DMNDiagramElement dmnDiagramElement1 = mock(DMNDiagramElement.class); final DMNDiagramElement dmnDiagramElement2 = mock(DMNDiagramElement.class); final DMNDiagramTuple dmnDiagramTuple1 = new DMNDiagramTuple(stunnerDiagram1, dmnDiagramElement1); final DMNDiagramTuple dmnDiagramTuple2 = new DMNDiagramTuple(stunnerDiagram2, dmnDiagramElement2); final DecisionNavigatorItem decisionNavigatorItem1 = mock(DecisionNavigatorItem.class); final DecisionNavigatorItem decisionNavigatorItem2 = mock(DecisionNavigatorItem.class); final DecisionNavigatorItem decisionNavigatorItem3 = mock(DecisionNavigatorItem.class); final DecisionNavigatorItem decisionNavigatorItem4 = mock(DecisionNavigatorItem.class); final DecisionNavigatorItem decisionNavigatorItem5 = mock(DecisionNavigatorItem.class); final DecisionNavigatorItem decisionNavigatorItem6 = mock(DecisionNavigatorItem.class); final DecisionNavigatorItem decisionNavigatorItem7 = mock(DecisionNavigatorItem.class); final DecisionNavigatorItem decisionNavigatorItem8 = mock(DecisionNavigatorItem.class); final DecisionNavigatorItem decisionNavigatorItem9 = mock(DecisionNavigatorItem.class); final DecisionNavigatorItem decisionNavigatorItem10 = mock(DecisionNavigatorItem.class); final List<DMNDiagramTuple> diagramTuples = asList(dmnDiagramTuple1, dmnDiagramTuple2); final Node node1 = mockNode(new Decision()); final Node node2 = mockNode(new InputData()); final Node node3 = mockNode(new TextAnnotation()); final Node node4 = mockNode(new BusinessKnowledgeModel()); final Node node5 = mockNode(new KnowledgeSource()); final Node node6 = mockNode(new TextAnnotation()); final Stream<Node> stunnerNodes1 = Stream.of(node1, node2, node3); final Stream<Node> stunnerNodes2 = Stream.of(node4, node5, node6); when(dmnDiagramElement1.getName()).thenReturn(new Name("DRD")); when(dmnDiagramElement2.getName()).thenReturn(new Name("DRG")); when(dmnDiagramsSession.getDMNDiagrams()).thenReturn(diagramTuples); when(itemFactory.makeRoot(dmnDiagramTuple1)).thenReturn(decisionNavigatorItem1); when(itemFactory.makeRoot(dmnDiagramTuple2)).thenReturn(decisionNavigatorItem2); when(itemFactory.makeItem(node1)).thenReturn(decisionNavigatorItem5); when(itemFactory.makeItem(node2)).thenReturn(decisionNavigatorItem6); when(itemFactory.makeItem(node3)).thenReturn(decisionNavigatorItem7); when(itemFactory.makeItem(node4)).thenReturn(decisionNavigatorItem8); when(itemFactory.makeItem(node5)).thenReturn(decisionNavigatorItem9); when(itemFactory.makeItem(node6)).thenReturn(decisionNavigatorItem10); when(itemFactory.makeSeparator(DRG)).thenReturn(decisionNavigatorItem3); when(itemFactory.makeSeparator(DRDs)).thenReturn(decisionNavigatorItem4); when(dmnDiagramUtils.getNodeStream(stunnerDiagram1)).thenReturn(stunnerNodes1); when(dmnDiagramUtils.getNodeStream(stunnerDiagram2)).thenReturn(stunnerNodes2); final List<DecisionNavigatorItem> actualItems = itemsProvider.getItems(); final List<DecisionNavigatorItem> expectedItems = asList(decisionNavigatorItem3, decisionNavigatorItem2, decisionNavigatorItem4, decisionNavigatorItem1); assertEquals(expectedItems, actualItems); verify(decisionNavigatorItem1).addChild(decisionNavigatorItem5); verify(decisionNavigatorItem1).addChild(decisionNavigatorItem6); verify(decisionNavigatorItem1).addChild(decisionNavigatorItem7); verify(decisionNavigatorItem2).addChild(decisionNavigatorItem8); verify(decisionNavigatorItem2).addChild(decisionNavigatorItem9); verify(decisionNavigatorItem2).addChild(decisionNavigatorItem10); } | public List<DecisionNavigatorItem> getItems() { final List<DecisionNavigatorItem> items = new ArrayList<>(); dmnDiagramsSession.getDMNDiagrams().stream() .sorted((e1, e2) -> { final String dmnElementName1 = e1.getDMNDiagram().getName().getValue(); final String dmnElementName2 = e2.getDMNDiagram().getName().getValue(); return DRG.equals(dmnElementName1) ? -1 : DRG.equals(dmnElementName2) ? 1 : 0; }) .forEach(diagramTuple -> { final Diagram stunner = diagramTuple.getStunnerDiagram(); final DecisionNavigatorItem root = makeRoot(diagramTuple); items.add(root); getNodes(stunner).forEach(node -> makeItem(root, node)); }); if (items.size() > 1) { items.add(0, itemFactory.makeSeparator(DRG)); items.add(2, itemFactory.makeSeparator(DRDs)); } return items; } | DecisionNavigatorItemsProvider { public List<DecisionNavigatorItem> getItems() { final List<DecisionNavigatorItem> items = new ArrayList<>(); dmnDiagramsSession.getDMNDiagrams().stream() .sorted((e1, e2) -> { final String dmnElementName1 = e1.getDMNDiagram().getName().getValue(); final String dmnElementName2 = e2.getDMNDiagram().getName().getValue(); return DRG.equals(dmnElementName1) ? -1 : DRG.equals(dmnElementName2) ? 1 : 0; }) .forEach(diagramTuple -> { final Diagram stunner = diagramTuple.getStunnerDiagram(); final DecisionNavigatorItem root = makeRoot(diagramTuple); items.add(root); getNodes(stunner).forEach(node -> makeItem(root, node)); }); if (items.size() > 1) { items.add(0, itemFactory.makeSeparator(DRG)); items.add(2, itemFactory.makeSeparator(DRDs)); } return items; } } | DecisionNavigatorItemsProvider { public List<DecisionNavigatorItem> getItems() { final List<DecisionNavigatorItem> items = new ArrayList<>(); dmnDiagramsSession.getDMNDiagrams().stream() .sorted((e1, e2) -> { final String dmnElementName1 = e1.getDMNDiagram().getName().getValue(); final String dmnElementName2 = e2.getDMNDiagram().getName().getValue(); return DRG.equals(dmnElementName1) ? -1 : DRG.equals(dmnElementName2) ? 1 : 0; }) .forEach(diagramTuple -> { final Diagram stunner = diagramTuple.getStunnerDiagram(); final DecisionNavigatorItem root = makeRoot(diagramTuple); items.add(root); getNodes(stunner).forEach(node -> makeItem(root, node)); }); if (items.size() > 1) { items.add(0, itemFactory.makeSeparator(DRG)); items.add(2, itemFactory.makeSeparator(DRDs)); } return items; } @Inject DecisionNavigatorItemsProvider(final DecisionNavigatorItemFactory itemFactory,
final DMNDiagramsSession dmnDiagramsSession,
final DMNDiagramUtils dmnDiagramUtils); } | DecisionNavigatorItemsProvider { public List<DecisionNavigatorItem> getItems() { final List<DecisionNavigatorItem> items = new ArrayList<>(); dmnDiagramsSession.getDMNDiagrams().stream() .sorted((e1, e2) -> { final String dmnElementName1 = e1.getDMNDiagram().getName().getValue(); final String dmnElementName2 = e2.getDMNDiagram().getName().getValue(); return DRG.equals(dmnElementName1) ? -1 : DRG.equals(dmnElementName2) ? 1 : 0; }) .forEach(diagramTuple -> { final Diagram stunner = diagramTuple.getStunnerDiagram(); final DecisionNavigatorItem root = makeRoot(diagramTuple); items.add(root); getNodes(stunner).forEach(node -> makeItem(root, node)); }); if (items.size() > 1) { items.add(0, itemFactory.makeSeparator(DRG)); items.add(2, itemFactory.makeSeparator(DRDs)); } return items; } @Inject DecisionNavigatorItemsProvider(final DecisionNavigatorItemFactory itemFactory,
final DMNDiagramsSession dmnDiagramsSession,
final DMNDiagramUtils dmnDiagramUtils); List<DecisionNavigatorItem> getItems(); } | DecisionNavigatorItemsProvider { public List<DecisionNavigatorItem> getItems() { final List<DecisionNavigatorItem> items = new ArrayList<>(); dmnDiagramsSession.getDMNDiagrams().stream() .sorted((e1, e2) -> { final String dmnElementName1 = e1.getDMNDiagram().getName().getValue(); final String dmnElementName2 = e2.getDMNDiagram().getName().getValue(); return DRG.equals(dmnElementName1) ? -1 : DRG.equals(dmnElementName2) ? 1 : 0; }) .forEach(diagramTuple -> { final Diagram stunner = diagramTuple.getStunnerDiagram(); final DecisionNavigatorItem root = makeRoot(diagramTuple); items.add(root); getNodes(stunner).forEach(node -> makeItem(root, node)); }); if (items.size() > 1) { items.add(0, itemFactory.makeSeparator(DRG)); items.add(2, itemFactory.makeSeparator(DRDs)); } return items; } @Inject DecisionNavigatorItemsProvider(final DecisionNavigatorItemFactory itemFactory,
final DMNDiagramsSession dmnDiagramsSession,
final DMNDiagramUtils dmnDiagramUtils); List<DecisionNavigatorItem> getItems(); } |
@Test(expected = DMNIncludeModelCouldNotBeCreatedException.class) public void testCreateUnknownIncludeRaisesAnError() throws Exception { when(importTypesHelper.isDMN(includedModelPath)).thenReturn(false); when(importTypesHelper.isPMML(includedModelPath)).thenReturn(false); factory.create(dmnModelPath, includedModelPath); } | public IncludedModel create(final Path dmnModelPath, final Path includedModelPath) throws DMNIncludeModelCouldNotBeCreatedException { try { if (importTypesHelper.isDMN(includedModelPath)) { return makeDMNIncludedModel(dmnModelPath, includedModelPath); } else if (importTypesHelper.isPMML(includedModelPath)) { return makePMMLIncludedModel(dmnModelPath, includedModelPath); } else { throw new IllegalArgumentException("Unsupported external model type."); } } catch (final Exception e) { throw new DMNIncludeModelCouldNotBeCreatedException(); } } | IncludedModelFactory { public IncludedModel create(final Path dmnModelPath, final Path includedModelPath) throws DMNIncludeModelCouldNotBeCreatedException { try { if (importTypesHelper.isDMN(includedModelPath)) { return makeDMNIncludedModel(dmnModelPath, includedModelPath); } else if (importTypesHelper.isPMML(includedModelPath)) { return makePMMLIncludedModel(dmnModelPath, includedModelPath); } else { throw new IllegalArgumentException("Unsupported external model type."); } } catch (final Exception e) { throw new DMNIncludeModelCouldNotBeCreatedException(); } } } | IncludedModelFactory { public IncludedModel create(final Path dmnModelPath, final Path includedModelPath) throws DMNIncludeModelCouldNotBeCreatedException { try { if (importTypesHelper.isDMN(includedModelPath)) { return makeDMNIncludedModel(dmnModelPath, includedModelPath); } else if (importTypesHelper.isPMML(includedModelPath)) { return makePMMLIncludedModel(dmnModelPath, includedModelPath); } else { throw new IllegalArgumentException("Unsupported external model type."); } } catch (final Exception e) { throw new DMNIncludeModelCouldNotBeCreatedException(); } } @Inject IncludedModelFactory(final DMNDiagramHelper diagramHelper,
final DMNPathsHelper pathsHelper,
final DMNImportTypesHelper importTypesHelper,
final PMMLIncludedDocumentFactory pmmlDocumentFactory,
final KieModuleService moduleService); } | IncludedModelFactory { public IncludedModel create(final Path dmnModelPath, final Path includedModelPath) throws DMNIncludeModelCouldNotBeCreatedException { try { if (importTypesHelper.isDMN(includedModelPath)) { return makeDMNIncludedModel(dmnModelPath, includedModelPath); } else if (importTypesHelper.isPMML(includedModelPath)) { return makePMMLIncludedModel(dmnModelPath, includedModelPath); } else { throw new IllegalArgumentException("Unsupported external model type."); } } catch (final Exception e) { throw new DMNIncludeModelCouldNotBeCreatedException(); } } @Inject IncludedModelFactory(final DMNDiagramHelper diagramHelper,
final DMNPathsHelper pathsHelper,
final DMNImportTypesHelper importTypesHelper,
final PMMLIncludedDocumentFactory pmmlDocumentFactory,
final KieModuleService moduleService); IncludedModel create(final Path dmnModelPath,
final Path includedModelPath); } | IncludedModelFactory { public IncludedModel create(final Path dmnModelPath, final Path includedModelPath) throws DMNIncludeModelCouldNotBeCreatedException { try { if (importTypesHelper.isDMN(includedModelPath)) { return makeDMNIncludedModel(dmnModelPath, includedModelPath); } else if (importTypesHelper.isPMML(includedModelPath)) { return makePMMLIncludedModel(dmnModelPath, includedModelPath); } else { throw new IllegalArgumentException("Unsupported external model type."); } } catch (final Exception e) { throw new DMNIncludeModelCouldNotBeCreatedException(); } } @Inject IncludedModelFactory(final DMNDiagramHelper diagramHelper,
final DMNPathsHelper pathsHelper,
final DMNImportTypesHelper importTypesHelper,
final PMMLIncludedDocumentFactory pmmlDocumentFactory,
final KieModuleService moduleService); IncludedModel create(final Path dmnModelPath,
final Path includedModelPath); } |
@Test public void testMoveViewsTopTop() { tested.onMoveStart(10d, 10d); verify(delegate, times(1)).onMoveStart(eq(10d), eq(10d)); verify(shapeView, times(1)).moveToTop(); } | @Override public void onMoveStart(final double x, final double y) { super.onMoveStart(x, y); getShapeView().moveToTop(); } | StunnerWiresShapeControl extends DelegateWiresShapeControl { @Override public void onMoveStart(final double x, final double y) { super.onMoveStart(x, y); getShapeView().moveToTop(); } } | StunnerWiresShapeControl extends DelegateWiresShapeControl { @Override public void onMoveStart(final double x, final double y) { super.onMoveStart(x, y); getShapeView().moveToTop(); } StunnerWiresShapeControl(final WiresShapeControlImpl delegate); } | StunnerWiresShapeControl extends DelegateWiresShapeControl { @Override public void onMoveStart(final double x, final double y) { super.onMoveStart(x, y); getShapeView().moveToTop(); } StunnerWiresShapeControl(final WiresShapeControlImpl delegate); @Override void onMoveStart(final double x,
final double y); @Override WiresShapeControlImpl getDelegate(); } | StunnerWiresShapeControl extends DelegateWiresShapeControl { @Override public void onMoveStart(final double x, final double y) { super.onMoveStart(x, y); getShapeView().moveToTop(); } StunnerWiresShapeControl(final WiresShapeControlImpl delegate); @Override void onMoveStart(final double x,
final double y); @Override WiresShapeControlImpl getDelegate(); } |
@Test public void testHighlightBodyForNonHasShapeStateView() { tested.highlight(view, PickerPart.ShapePart.BODY); verify(delegate, times(1)).highlight(eq(view), eq(PickerPart.ShapePart.BODY)); verify(stateExecutor, never()).accept(any(ShapeState.class)); } | @Override public void highlight(final WiresShape shape, final PickerPart.ShapePart part) { highlight(shape, part, ShapeState.HIGHLIGHT); } | StunnerWiresShapeStateHighlight implements WiresShapeHighlight<PickerPart.ShapePart> { @Override public void highlight(final WiresShape shape, final PickerPart.ShapePart part) { highlight(shape, part, ShapeState.HIGHLIGHT); } } | StunnerWiresShapeStateHighlight implements WiresShapeHighlight<PickerPart.ShapePart> { @Override public void highlight(final WiresShape shape, final PickerPart.ShapePart part) { highlight(shape, part, ShapeState.HIGHLIGHT); } StunnerWiresShapeStateHighlight(final WiresManager wiresManager,
final Event<CanvasUnhighlightEvent> unhighlightEvent); StunnerWiresShapeStateHighlight(final StunnerWiresShapeHighlight delegate); } | StunnerWiresShapeStateHighlight implements WiresShapeHighlight<PickerPart.ShapePart> { @Override public void highlight(final WiresShape shape, final PickerPart.ShapePart part) { highlight(shape, part, ShapeState.HIGHLIGHT); } StunnerWiresShapeStateHighlight(final WiresManager wiresManager,
final Event<CanvasUnhighlightEvent> unhighlightEvent); StunnerWiresShapeStateHighlight(final StunnerWiresShapeHighlight delegate); @Override void highlight(final WiresShape shape,
final PickerPart.ShapePart part); @Override void error(final WiresShape shape,
final PickerPart.ShapePart shapePart); @Override void restore(); } | StunnerWiresShapeStateHighlight implements WiresShapeHighlight<PickerPart.ShapePart> { @Override public void highlight(final WiresShape shape, final PickerPart.ShapePart part) { highlight(shape, part, ShapeState.HIGHLIGHT); } StunnerWiresShapeStateHighlight(final WiresManager wiresManager,
final Event<CanvasUnhighlightEvent> unhighlightEvent); StunnerWiresShapeStateHighlight(final StunnerWiresShapeHighlight delegate); @Override void highlight(final WiresShape shape,
final PickerPart.ShapePart part); @Override void error(final WiresShape shape,
final PickerPart.ShapePart shapePart); @Override void restore(); } |
@Test public void testHighlightBodyForHasShapeStateView() { tested.highlight(viewWithState, PickerPart.ShapePart.BODY); verify(stateExecutor, times(1)).accept(eq(ShapeState.HIGHLIGHT)); verify(delegate, never()).highlight(eq(viewWithState), any(PickerPart.ShapePart.class)); } | @Override public void highlight(final WiresShape shape, final PickerPart.ShapePart part) { highlight(shape, part, ShapeState.HIGHLIGHT); } | StunnerWiresShapeStateHighlight implements WiresShapeHighlight<PickerPart.ShapePart> { @Override public void highlight(final WiresShape shape, final PickerPart.ShapePart part) { highlight(shape, part, ShapeState.HIGHLIGHT); } } | StunnerWiresShapeStateHighlight implements WiresShapeHighlight<PickerPart.ShapePart> { @Override public void highlight(final WiresShape shape, final PickerPart.ShapePart part) { highlight(shape, part, ShapeState.HIGHLIGHT); } StunnerWiresShapeStateHighlight(final WiresManager wiresManager,
final Event<CanvasUnhighlightEvent> unhighlightEvent); StunnerWiresShapeStateHighlight(final StunnerWiresShapeHighlight delegate); } | StunnerWiresShapeStateHighlight implements WiresShapeHighlight<PickerPart.ShapePart> { @Override public void highlight(final WiresShape shape, final PickerPart.ShapePart part) { highlight(shape, part, ShapeState.HIGHLIGHT); } StunnerWiresShapeStateHighlight(final WiresManager wiresManager,
final Event<CanvasUnhighlightEvent> unhighlightEvent); StunnerWiresShapeStateHighlight(final StunnerWiresShapeHighlight delegate); @Override void highlight(final WiresShape shape,
final PickerPart.ShapePart part); @Override void error(final WiresShape shape,
final PickerPart.ShapePart shapePart); @Override void restore(); } | StunnerWiresShapeStateHighlight implements WiresShapeHighlight<PickerPart.ShapePart> { @Override public void highlight(final WiresShape shape, final PickerPart.ShapePart part) { highlight(shape, part, ShapeState.HIGHLIGHT); } StunnerWiresShapeStateHighlight(final WiresManager wiresManager,
final Event<CanvasUnhighlightEvent> unhighlightEvent); StunnerWiresShapeStateHighlight(final StunnerWiresShapeHighlight delegate); @Override void highlight(final WiresShape shape,
final PickerPart.ShapePart part); @Override void error(final WiresShape shape,
final PickerPart.ShapePart shapePart); @Override void restore(); } |
@Test public void testHighlightBorderForNonStateView() { tested.highlight(view, PickerPart.ShapePart.BORDER); verify(delegate, times(1)).highlight(eq(view), eq(PickerPart.ShapePart.BORDER)); verify(stateExecutor, never()).accept(any(ShapeState.class)); } | @Override public void highlight(final WiresShape shape, final PickerPart.ShapePart part) { highlight(shape, part, ShapeState.HIGHLIGHT); } | StunnerWiresShapeStateHighlight implements WiresShapeHighlight<PickerPart.ShapePart> { @Override public void highlight(final WiresShape shape, final PickerPart.ShapePart part) { highlight(shape, part, ShapeState.HIGHLIGHT); } } | StunnerWiresShapeStateHighlight implements WiresShapeHighlight<PickerPart.ShapePart> { @Override public void highlight(final WiresShape shape, final PickerPart.ShapePart part) { highlight(shape, part, ShapeState.HIGHLIGHT); } StunnerWiresShapeStateHighlight(final WiresManager wiresManager,
final Event<CanvasUnhighlightEvent> unhighlightEvent); StunnerWiresShapeStateHighlight(final StunnerWiresShapeHighlight delegate); } | StunnerWiresShapeStateHighlight implements WiresShapeHighlight<PickerPart.ShapePart> { @Override public void highlight(final WiresShape shape, final PickerPart.ShapePart part) { highlight(shape, part, ShapeState.HIGHLIGHT); } StunnerWiresShapeStateHighlight(final WiresManager wiresManager,
final Event<CanvasUnhighlightEvent> unhighlightEvent); StunnerWiresShapeStateHighlight(final StunnerWiresShapeHighlight delegate); @Override void highlight(final WiresShape shape,
final PickerPart.ShapePart part); @Override void error(final WiresShape shape,
final PickerPart.ShapePart shapePart); @Override void restore(); } | StunnerWiresShapeStateHighlight implements WiresShapeHighlight<PickerPart.ShapePart> { @Override public void highlight(final WiresShape shape, final PickerPart.ShapePart part) { highlight(shape, part, ShapeState.HIGHLIGHT); } StunnerWiresShapeStateHighlight(final WiresManager wiresManager,
final Event<CanvasUnhighlightEvent> unhighlightEvent); StunnerWiresShapeStateHighlight(final StunnerWiresShapeHighlight delegate); @Override void highlight(final WiresShape shape,
final PickerPart.ShapePart part); @Override void error(final WiresShape shape,
final PickerPart.ShapePart shapePart); @Override void restore(); } |
@Test public void testHighlightBorderForStateView() { tested.highlight(viewWithState, PickerPart.ShapePart.BORDER); verify(delegate, times(1)).highlight(eq(viewWithState), eq(PickerPart.ShapePart.BORDER)); verify(stateExecutor, never()).accept(any(ShapeState.class)); } | @Override public void highlight(final WiresShape shape, final PickerPart.ShapePart part) { highlight(shape, part, ShapeState.HIGHLIGHT); } | StunnerWiresShapeStateHighlight implements WiresShapeHighlight<PickerPart.ShapePart> { @Override public void highlight(final WiresShape shape, final PickerPart.ShapePart part) { highlight(shape, part, ShapeState.HIGHLIGHT); } } | StunnerWiresShapeStateHighlight implements WiresShapeHighlight<PickerPart.ShapePart> { @Override public void highlight(final WiresShape shape, final PickerPart.ShapePart part) { highlight(shape, part, ShapeState.HIGHLIGHT); } StunnerWiresShapeStateHighlight(final WiresManager wiresManager,
final Event<CanvasUnhighlightEvent> unhighlightEvent); StunnerWiresShapeStateHighlight(final StunnerWiresShapeHighlight delegate); } | StunnerWiresShapeStateHighlight implements WiresShapeHighlight<PickerPart.ShapePart> { @Override public void highlight(final WiresShape shape, final PickerPart.ShapePart part) { highlight(shape, part, ShapeState.HIGHLIGHT); } StunnerWiresShapeStateHighlight(final WiresManager wiresManager,
final Event<CanvasUnhighlightEvent> unhighlightEvent); StunnerWiresShapeStateHighlight(final StunnerWiresShapeHighlight delegate); @Override void highlight(final WiresShape shape,
final PickerPart.ShapePart part); @Override void error(final WiresShape shape,
final PickerPart.ShapePart shapePart); @Override void restore(); } | StunnerWiresShapeStateHighlight implements WiresShapeHighlight<PickerPart.ShapePart> { @Override public void highlight(final WiresShape shape, final PickerPart.ShapePart part) { highlight(shape, part, ShapeState.HIGHLIGHT); } StunnerWiresShapeStateHighlight(final WiresManager wiresManager,
final Event<CanvasUnhighlightEvent> unhighlightEvent); StunnerWiresShapeStateHighlight(final StunnerWiresShapeHighlight delegate); @Override void highlight(final WiresShape shape,
final PickerPart.ShapePart part); @Override void error(final WiresShape shape,
final PickerPart.ShapePart shapePart); @Override void restore(); } |
@Test public void testRestore() { tested.setCurrent(viewWithState); tested.restore(); verify(stateExecutor, times(1)).accept(eq(ShapeState.NONE)); verify(delegate, never()).highlight(eq(viewWithState), any(PickerPart.ShapePart.class)); } | @Override public void restore() { if (null != current && (Objects.isNull(currentPartState) || Objects.equals(PickerPart.ShapePart.BODY, currentPartState))) { current.applyState(ShapeState.NONE); setCurrent(null); } else { delegate.restore(); } currentPartState = null; } | StunnerWiresShapeStateHighlight implements WiresShapeHighlight<PickerPart.ShapePart> { @Override public void restore() { if (null != current && (Objects.isNull(currentPartState) || Objects.equals(PickerPart.ShapePart.BODY, currentPartState))) { current.applyState(ShapeState.NONE); setCurrent(null); } else { delegate.restore(); } currentPartState = null; } } | StunnerWiresShapeStateHighlight implements WiresShapeHighlight<PickerPart.ShapePart> { @Override public void restore() { if (null != current && (Objects.isNull(currentPartState) || Objects.equals(PickerPart.ShapePart.BODY, currentPartState))) { current.applyState(ShapeState.NONE); setCurrent(null); } else { delegate.restore(); } currentPartState = null; } StunnerWiresShapeStateHighlight(final WiresManager wiresManager,
final Event<CanvasUnhighlightEvent> unhighlightEvent); StunnerWiresShapeStateHighlight(final StunnerWiresShapeHighlight delegate); } | StunnerWiresShapeStateHighlight implements WiresShapeHighlight<PickerPart.ShapePart> { @Override public void restore() { if (null != current && (Objects.isNull(currentPartState) || Objects.equals(PickerPart.ShapePart.BODY, currentPartState))) { current.applyState(ShapeState.NONE); setCurrent(null); } else { delegate.restore(); } currentPartState = null; } StunnerWiresShapeStateHighlight(final WiresManager wiresManager,
final Event<CanvasUnhighlightEvent> unhighlightEvent); StunnerWiresShapeStateHighlight(final StunnerWiresShapeHighlight delegate); @Override void highlight(final WiresShape shape,
final PickerPart.ShapePart part); @Override void error(final WiresShape shape,
final PickerPart.ShapePart shapePart); @Override void restore(); } | StunnerWiresShapeStateHighlight implements WiresShapeHighlight<PickerPart.ShapePart> { @Override public void restore() { if (null != current && (Objects.isNull(currentPartState) || Objects.equals(PickerPart.ShapePart.BODY, currentPartState))) { current.applyState(ShapeState.NONE); setCurrent(null); } else { delegate.restore(); } currentPartState = null; } StunnerWiresShapeStateHighlight(final WiresManager wiresManager,
final Event<CanvasUnhighlightEvent> unhighlightEvent); StunnerWiresShapeStateHighlight(final StunnerWiresShapeHighlight delegate); @Override void highlight(final WiresShape shape,
final PickerPart.ShapePart part); @Override void error(final WiresShape shape,
final PickerPart.ShapePart shapePart); @Override void restore(); } |
@Test public void testAdd() { tested.add(shape); verify(layer, times(1)).add(eq(shape)); tested.add(emptyLayer); verify(scene, times(1)).add(eq(emptyLayer)); } | public LienzoLayer add(final IPrimitive<?> shape) { if (layer.getChildNodes().contains(shape)) { LOGGER.log(Level.WARNING, "Cannot add a primitive shape into the layer twice!"); } else { layer.add(shape); } return this; } | LienzoLayer { public LienzoLayer add(final IPrimitive<?> shape) { if (layer.getChildNodes().contains(shape)) { LOGGER.log(Level.WARNING, "Cannot add a primitive shape into the layer twice!"); } else { layer.add(shape); } return this; } } | LienzoLayer { public LienzoLayer add(final IPrimitive<?> shape) { if (layer.getChildNodes().contains(shape)) { LOGGER.log(Level.WARNING, "Cannot add a primitive shape into the layer twice!"); } else { layer.add(shape); } return this; } LienzoLayer(); LienzoLayer(final LienzoCustomLayer layer); } | LienzoLayer { public LienzoLayer add(final IPrimitive<?> shape) { if (layer.getChildNodes().contains(shape)) { LOGGER.log(Level.WARNING, "Cannot add a primitive shape into the layer twice!"); } else { layer.add(shape); } return this; } LienzoLayer(); LienzoLayer(final LienzoCustomLayer layer); void setSkipDraw(final boolean skipDraw); LienzoLayer add(final IPrimitive<?> shape); LienzoLayer delete(final IPrimitive<?> shape); void clear(); void onAfterDraw(final Command callback); Layer getTopLayer(); void add(final Layer layer); boolean isReady(); void remove(final Layer layer); void destroy(); Layer getLienzoLayer(); org.kie.workbench.common.stunner.core.client.canvas.Transform getTransform(); void translate(final double tx,
final double ty); void scale(final double sx,
final double sy); void scale(final double delta); } | LienzoLayer { public LienzoLayer add(final IPrimitive<?> shape) { if (layer.getChildNodes().contains(shape)) { LOGGER.log(Level.WARNING, "Cannot add a primitive shape into the layer twice!"); } else { layer.add(shape); } return this; } LienzoLayer(); LienzoLayer(final LienzoCustomLayer layer); void setSkipDraw(final boolean skipDraw); LienzoLayer add(final IPrimitive<?> shape); LienzoLayer delete(final IPrimitive<?> shape); void clear(); void onAfterDraw(final Command callback); Layer getTopLayer(); void add(final Layer layer); boolean isReady(); void remove(final Layer layer); void destroy(); Layer getLienzoLayer(); org.kie.workbench.common.stunner.core.client.canvas.Transform getTransform(); void translate(final double tx,
final double ty); void scale(final double sx,
final double sy); void scale(final double delta); } |
@Test public void testAddTwice() { when(layer.getChildNodes()).thenReturn(new NFastArrayList<>(shape)); tested.add(shape); verify(layer, never()).add(eq(shape)); } | public LienzoLayer add(final IPrimitive<?> shape) { if (layer.getChildNodes().contains(shape)) { LOGGER.log(Level.WARNING, "Cannot add a primitive shape into the layer twice!"); } else { layer.add(shape); } return this; } | LienzoLayer { public LienzoLayer add(final IPrimitive<?> shape) { if (layer.getChildNodes().contains(shape)) { LOGGER.log(Level.WARNING, "Cannot add a primitive shape into the layer twice!"); } else { layer.add(shape); } return this; } } | LienzoLayer { public LienzoLayer add(final IPrimitive<?> shape) { if (layer.getChildNodes().contains(shape)) { LOGGER.log(Level.WARNING, "Cannot add a primitive shape into the layer twice!"); } else { layer.add(shape); } return this; } LienzoLayer(); LienzoLayer(final LienzoCustomLayer layer); } | LienzoLayer { public LienzoLayer add(final IPrimitive<?> shape) { if (layer.getChildNodes().contains(shape)) { LOGGER.log(Level.WARNING, "Cannot add a primitive shape into the layer twice!"); } else { layer.add(shape); } return this; } LienzoLayer(); LienzoLayer(final LienzoCustomLayer layer); void setSkipDraw(final boolean skipDraw); LienzoLayer add(final IPrimitive<?> shape); LienzoLayer delete(final IPrimitive<?> shape); void clear(); void onAfterDraw(final Command callback); Layer getTopLayer(); void add(final Layer layer); boolean isReady(); void remove(final Layer layer); void destroy(); Layer getLienzoLayer(); org.kie.workbench.common.stunner.core.client.canvas.Transform getTransform(); void translate(final double tx,
final double ty); void scale(final double sx,
final double sy); void scale(final double delta); } | LienzoLayer { public LienzoLayer add(final IPrimitive<?> shape) { if (layer.getChildNodes().contains(shape)) { LOGGER.log(Level.WARNING, "Cannot add a primitive shape into the layer twice!"); } else { layer.add(shape); } return this; } LienzoLayer(); LienzoLayer(final LienzoCustomLayer layer); void setSkipDraw(final boolean skipDraw); LienzoLayer add(final IPrimitive<?> shape); LienzoLayer delete(final IPrimitive<?> shape); void clear(); void onAfterDraw(final Command callback); Layer getTopLayer(); void add(final Layer layer); boolean isReady(); void remove(final Layer layer); void destroy(); Layer getLienzoLayer(); org.kie.workbench.common.stunner.core.client.canvas.Transform getTransform(); void translate(final double tx,
final double ty); void scale(final double sx,
final double sy); void scale(final double delta); } |
@Test public void testDelete() { tested.delete(shape); verify(layer, times(1)).remove(eq(shape)); } | public LienzoLayer delete(final IPrimitive<?> shape) { layer.remove(shape); return this; } | LienzoLayer { public LienzoLayer delete(final IPrimitive<?> shape) { layer.remove(shape); return this; } } | LienzoLayer { public LienzoLayer delete(final IPrimitive<?> shape) { layer.remove(shape); return this; } LienzoLayer(); LienzoLayer(final LienzoCustomLayer layer); } | LienzoLayer { public LienzoLayer delete(final IPrimitive<?> shape) { layer.remove(shape); return this; } LienzoLayer(); LienzoLayer(final LienzoCustomLayer layer); void setSkipDraw(final boolean skipDraw); LienzoLayer add(final IPrimitive<?> shape); LienzoLayer delete(final IPrimitive<?> shape); void clear(); void onAfterDraw(final Command callback); Layer getTopLayer(); void add(final Layer layer); boolean isReady(); void remove(final Layer layer); void destroy(); Layer getLienzoLayer(); org.kie.workbench.common.stunner.core.client.canvas.Transform getTransform(); void translate(final double tx,
final double ty); void scale(final double sx,
final double sy); void scale(final double delta); } | LienzoLayer { public LienzoLayer delete(final IPrimitive<?> shape) { layer.remove(shape); return this; } LienzoLayer(); LienzoLayer(final LienzoCustomLayer layer); void setSkipDraw(final boolean skipDraw); LienzoLayer add(final IPrimitive<?> shape); LienzoLayer delete(final IPrimitive<?> shape); void clear(); void onAfterDraw(final Command callback); Layer getTopLayer(); void add(final Layer layer); boolean isReady(); void remove(final Layer layer); void destroy(); Layer getLienzoLayer(); org.kie.workbench.common.stunner.core.client.canvas.Transform getTransform(); void translate(final double tx,
final double ty); void scale(final double sx,
final double sy); void scale(final double delta); } |
@Test public void testRemove() { tested.remove(emptyLayer); verify(scene, times(1)).remove(eq(emptyLayer)); } | public void remove(final Layer layer) { if (isReady()) { this.layer.getScene().remove(layer); } } | LienzoLayer { public void remove(final Layer layer) { if (isReady()) { this.layer.getScene().remove(layer); } } } | LienzoLayer { public void remove(final Layer layer) { if (isReady()) { this.layer.getScene().remove(layer); } } LienzoLayer(); LienzoLayer(final LienzoCustomLayer layer); } | LienzoLayer { public void remove(final Layer layer) { if (isReady()) { this.layer.getScene().remove(layer); } } LienzoLayer(); LienzoLayer(final LienzoCustomLayer layer); void setSkipDraw(final boolean skipDraw); LienzoLayer add(final IPrimitive<?> shape); LienzoLayer delete(final IPrimitive<?> shape); void clear(); void onAfterDraw(final Command callback); Layer getTopLayer(); void add(final Layer layer); boolean isReady(); void remove(final Layer layer); void destroy(); Layer getLienzoLayer(); org.kie.workbench.common.stunner.core.client.canvas.Transform getTransform(); void translate(final double tx,
final double ty); void scale(final double sx,
final double sy); void scale(final double delta); } | LienzoLayer { public void remove(final Layer layer) { if (isReady()) { this.layer.getScene().remove(layer); } } LienzoLayer(); LienzoLayer(final LienzoCustomLayer layer); void setSkipDraw(final boolean skipDraw); LienzoLayer add(final IPrimitive<?> shape); LienzoLayer delete(final IPrimitive<?> shape); void clear(); void onAfterDraw(final Command callback); Layer getTopLayer(); void add(final Layer layer); boolean isReady(); void remove(final Layer layer); void destroy(); Layer getLienzoLayer(); org.kie.workbench.common.stunner.core.client.canvas.Transform getTransform(); void translate(final double tx,
final double ty); void scale(final double sx,
final double sy); void scale(final double delta); } |
@Test public void testOnOpen() { tested.onOpen(); verify(tested).showPreview(any()); } | @OnOpen @SuppressWarnings("unused") public void onOpen() { final ClientSession current = clientSessionManager.getCurrentSession(); if (Objects.nonNull(current)) { showPreview(current); } } | PreviewDiagramScreen { @OnOpen @SuppressWarnings("unused") public void onOpen() { final ClientSession current = clientSessionManager.getCurrentSession(); if (Objects.nonNull(current)) { showPreview(current); } } } | PreviewDiagramScreen { @OnOpen @SuppressWarnings("unused") public void onOpen() { final ClientSession current = clientSessionManager.getCurrentSession(); if (Objects.nonNull(current)) { showPreview(current); } } protected PreviewDiagramScreen(); @Inject PreviewDiagramScreen(final SessionManager clientSessionManager,
final @Any @DMNEditor ManagedInstance<SessionDiagramPreview<AbstractSession>> sessionPreviews,
final View view,
final DMNDiagramsSession session); } | PreviewDiagramScreen { @OnOpen @SuppressWarnings("unused") public void onOpen() { final ClientSession current = clientSessionManager.getCurrentSession(); if (Objects.nonNull(current)) { showPreview(current); } } protected PreviewDiagramScreen(); @Inject PreviewDiagramScreen(final SessionManager clientSessionManager,
final @Any @DMNEditor ManagedInstance<SessionDiagramPreview<AbstractSession>> sessionPreviews,
final View view,
final DMNDiagramsSession session); @OnStartup @SuppressWarnings("unused") void onStartup(final PlaceRequest placeRequest); @OnOpen @SuppressWarnings("unused") void onOpen(); @OnClose @SuppressWarnings("unused") void onClose(); @WorkbenchPartTitle @SuppressWarnings("unused") String getTitle(); @WorkbenchPartView @SuppressWarnings("unused") IsWidget getWidget(); @WorkbenchContextId @SuppressWarnings("unused") String getMyContextRef(); } | PreviewDiagramScreen { @OnOpen @SuppressWarnings("unused") public void onOpen() { final ClientSession current = clientSessionManager.getCurrentSession(); if (Objects.nonNull(current)) { showPreview(current); } } protected PreviewDiagramScreen(); @Inject PreviewDiagramScreen(final SessionManager clientSessionManager,
final @Any @DMNEditor ManagedInstance<SessionDiagramPreview<AbstractSession>> sessionPreviews,
final View view,
final DMNDiagramsSession session); @OnStartup @SuppressWarnings("unused") void onStartup(final PlaceRequest placeRequest); @OnOpen @SuppressWarnings("unused") void onOpen(); @OnClose @SuppressWarnings("unused") void onClose(); @WorkbenchPartTitle @SuppressWarnings("unused") String getTitle(); @WorkbenchPartView @SuppressWarnings("unused") IsWidget getWidget(); @WorkbenchContextId @SuppressWarnings("unused") String getMyContextRef(); static final String SCREEN_ID; } |
@Test public void testClear() { tested.clear(); verify(layer, times(1)).clear(); } | public void clear() { layer.clear(); } | LienzoLayer { public void clear() { layer.clear(); } } | LienzoLayer { public void clear() { layer.clear(); } LienzoLayer(); LienzoLayer(final LienzoCustomLayer layer); } | LienzoLayer { public void clear() { layer.clear(); } LienzoLayer(); LienzoLayer(final LienzoCustomLayer layer); void setSkipDraw(final boolean skipDraw); LienzoLayer add(final IPrimitive<?> shape); LienzoLayer delete(final IPrimitive<?> shape); void clear(); void onAfterDraw(final Command callback); Layer getTopLayer(); void add(final Layer layer); boolean isReady(); void remove(final Layer layer); void destroy(); Layer getLienzoLayer(); org.kie.workbench.common.stunner.core.client.canvas.Transform getTransform(); void translate(final double tx,
final double ty); void scale(final double sx,
final double sy); void scale(final double delta); } | LienzoLayer { public void clear() { layer.clear(); } LienzoLayer(); LienzoLayer(final LienzoCustomLayer layer); void setSkipDraw(final boolean skipDraw); LienzoLayer add(final IPrimitive<?> shape); LienzoLayer delete(final IPrimitive<?> shape); void clear(); void onAfterDraw(final Command callback); Layer getTopLayer(); void add(final Layer layer); boolean isReady(); void remove(final Layer layer); void destroy(); Layer getLienzoLayer(); org.kie.workbench.common.stunner.core.client.canvas.Transform getTransform(); void translate(final double tx,
final double ty); void scale(final double sx,
final double sy); void scale(final double delta); } |
@Test public void testIsReady() { LienzoCustomLayer layer1 = mock(LienzoCustomLayer.class); LienzoLayer tested1 = new LienzoLayer(layer1); when(layer1.getScene()).thenReturn(scene); LienzoCustomLayer layer2 = mock(LienzoCustomLayer.class); LienzoLayer tested2 = new LienzoLayer(layer2); when(layer2.getScene()).thenReturn(null); assertTrue(tested1.isReady()); assertFalse(tested2.isReady()); } | public boolean isReady() { return null != layer.getScene(); } | LienzoLayer { public boolean isReady() { return null != layer.getScene(); } } | LienzoLayer { public boolean isReady() { return null != layer.getScene(); } LienzoLayer(); LienzoLayer(final LienzoCustomLayer layer); } | LienzoLayer { public boolean isReady() { return null != layer.getScene(); } LienzoLayer(); LienzoLayer(final LienzoCustomLayer layer); void setSkipDraw(final boolean skipDraw); LienzoLayer add(final IPrimitive<?> shape); LienzoLayer delete(final IPrimitive<?> shape); void clear(); void onAfterDraw(final Command callback); Layer getTopLayer(); void add(final Layer layer); boolean isReady(); void remove(final Layer layer); void destroy(); Layer getLienzoLayer(); org.kie.workbench.common.stunner.core.client.canvas.Transform getTransform(); void translate(final double tx,
final double ty); void scale(final double sx,
final double sy); void scale(final double delta); } | LienzoLayer { public boolean isReady() { return null != layer.getScene(); } LienzoLayer(); LienzoLayer(final LienzoCustomLayer layer); void setSkipDraw(final boolean skipDraw); LienzoLayer add(final IPrimitive<?> shape); LienzoLayer delete(final IPrimitive<?> shape); void clear(); void onAfterDraw(final Command callback); Layer getTopLayer(); void add(final Layer layer); boolean isReady(); void remove(final Layer layer); void destroy(); Layer getLienzoLayer(); org.kie.workbench.common.stunner.core.client.canvas.Transform getTransform(); void translate(final double tx,
final double ty); void scale(final double sx,
final double sy); void scale(final double delta); } |
@Test public void testOnAfterDraw() { tested.onAfterDraw(mock(Command.class)); verify(layer, times(1)).setOnLayerAfterDraw(any(OnLayerAfterDraw.class)); } | public void onAfterDraw(final Command callback) { layer.setOnLayerAfterDraw(layer1 -> callback.execute()); } | LienzoLayer { public void onAfterDraw(final Command callback) { layer.setOnLayerAfterDraw(layer1 -> callback.execute()); } } | LienzoLayer { public void onAfterDraw(final Command callback) { layer.setOnLayerAfterDraw(layer1 -> callback.execute()); } LienzoLayer(); LienzoLayer(final LienzoCustomLayer layer); } | LienzoLayer { public void onAfterDraw(final Command callback) { layer.setOnLayerAfterDraw(layer1 -> callback.execute()); } LienzoLayer(); LienzoLayer(final LienzoCustomLayer layer); void setSkipDraw(final boolean skipDraw); LienzoLayer add(final IPrimitive<?> shape); LienzoLayer delete(final IPrimitive<?> shape); void clear(); void onAfterDraw(final Command callback); Layer getTopLayer(); void add(final Layer layer); boolean isReady(); void remove(final Layer layer); void destroy(); Layer getLienzoLayer(); org.kie.workbench.common.stunner.core.client.canvas.Transform getTransform(); void translate(final double tx,
final double ty); void scale(final double sx,
final double sy); void scale(final double delta); } | LienzoLayer { public void onAfterDraw(final Command callback) { layer.setOnLayerAfterDraw(layer1 -> callback.execute()); } LienzoLayer(); LienzoLayer(final LienzoCustomLayer layer); void setSkipDraw(final boolean skipDraw); LienzoLayer add(final IPrimitive<?> shape); LienzoLayer delete(final IPrimitive<?> shape); void clear(); void onAfterDraw(final Command callback); Layer getTopLayer(); void add(final Layer layer); boolean isReady(); void remove(final Layer layer); void destroy(); Layer getLienzoLayer(); org.kie.workbench.common.stunner.core.client.canvas.Transform getTransform(); void translate(final double tx,
final double ty); void scale(final double sx,
final double sy); void scale(final double delta); } |
@Test public void testGetTopLayer() { assertEquals(topLayer, tested.getTopLayer()); } | public Layer getTopLayer() { return isReady() ? layer.getScene().getTopLayer() : null; } | LienzoLayer { public Layer getTopLayer() { return isReady() ? layer.getScene().getTopLayer() : null; } } | LienzoLayer { public Layer getTopLayer() { return isReady() ? layer.getScene().getTopLayer() : null; } LienzoLayer(); LienzoLayer(final LienzoCustomLayer layer); } | LienzoLayer { public Layer getTopLayer() { return isReady() ? layer.getScene().getTopLayer() : null; } LienzoLayer(); LienzoLayer(final LienzoCustomLayer layer); void setSkipDraw(final boolean skipDraw); LienzoLayer add(final IPrimitive<?> shape); LienzoLayer delete(final IPrimitive<?> shape); void clear(); void onAfterDraw(final Command callback); Layer getTopLayer(); void add(final Layer layer); boolean isReady(); void remove(final Layer layer); void destroy(); Layer getLienzoLayer(); org.kie.workbench.common.stunner.core.client.canvas.Transform getTransform(); void translate(final double tx,
final double ty); void scale(final double sx,
final double sy); void scale(final double delta); } | LienzoLayer { public Layer getTopLayer() { return isReady() ? layer.getScene().getTopLayer() : null; } LienzoLayer(); LienzoLayer(final LienzoCustomLayer layer); void setSkipDraw(final boolean skipDraw); LienzoLayer add(final IPrimitive<?> shape); LienzoLayer delete(final IPrimitive<?> shape); void clear(); void onAfterDraw(final Command callback); Layer getTopLayer(); void add(final Layer layer); boolean isReady(); void remove(final Layer layer); void destroy(); Layer getLienzoLayer(); org.kie.workbench.common.stunner.core.client.canvas.Transform getTransform(); void translate(final double tx,
final double ty); void scale(final double sx,
final double sy); void scale(final double delta); } |
@Test public void testDestroy() { tested.destroy(); verify(layer, times(1)).removeAll(); verify(layer, times(1)).removeFromParent(); } | public void destroy() { layer.removeAll(); layer.removeFromParent(); } | LienzoLayer { public void destroy() { layer.removeAll(); layer.removeFromParent(); } } | LienzoLayer { public void destroy() { layer.removeAll(); layer.removeFromParent(); } LienzoLayer(); LienzoLayer(final LienzoCustomLayer layer); } | LienzoLayer { public void destroy() { layer.removeAll(); layer.removeFromParent(); } LienzoLayer(); LienzoLayer(final LienzoCustomLayer layer); void setSkipDraw(final boolean skipDraw); LienzoLayer add(final IPrimitive<?> shape); LienzoLayer delete(final IPrimitive<?> shape); void clear(); void onAfterDraw(final Command callback); Layer getTopLayer(); void add(final Layer layer); boolean isReady(); void remove(final Layer layer); void destroy(); Layer getLienzoLayer(); org.kie.workbench.common.stunner.core.client.canvas.Transform getTransform(); void translate(final double tx,
final double ty); void scale(final double sx,
final double sy); void scale(final double delta); } | LienzoLayer { public void destroy() { layer.removeAll(); layer.removeFromParent(); } LienzoLayer(); LienzoLayer(final LienzoCustomLayer layer); void setSkipDraw(final boolean skipDraw); LienzoLayer add(final IPrimitive<?> shape); LienzoLayer delete(final IPrimitive<?> shape); void clear(); void onAfterDraw(final Command callback); Layer getTopLayer(); void add(final Layer layer); boolean isReady(); void remove(final Layer layer); void destroy(); Layer getLienzoLayer(); org.kie.workbench.common.stunner.core.client.canvas.Transform getTransform(); void translate(final double tx,
final double ty); void scale(final double sx,
final double sy); void scale(final double delta); } |
@Test public void testGetTranslate() { transform.translate(11, 33); Point2D translate = tested.getTranslate(); assertEquals(11d, translate.getX(), 0d); assertEquals(33d, translate.getY(), 0d); } | protected Point2D getTranslate() { return new Point2D( layer.getAbsoluteTransform().getTranslateX(), layer.getAbsoluteTransform().getTranslateY() ); } | LienzoLayer { protected Point2D getTranslate() { return new Point2D( layer.getAbsoluteTransform().getTranslateX(), layer.getAbsoluteTransform().getTranslateY() ); } } | LienzoLayer { protected Point2D getTranslate() { return new Point2D( layer.getAbsoluteTransform().getTranslateX(), layer.getAbsoluteTransform().getTranslateY() ); } LienzoLayer(); LienzoLayer(final LienzoCustomLayer layer); } | LienzoLayer { protected Point2D getTranslate() { return new Point2D( layer.getAbsoluteTransform().getTranslateX(), layer.getAbsoluteTransform().getTranslateY() ); } LienzoLayer(); LienzoLayer(final LienzoCustomLayer layer); void setSkipDraw(final boolean skipDraw); LienzoLayer add(final IPrimitive<?> shape); LienzoLayer delete(final IPrimitive<?> shape); void clear(); void onAfterDraw(final Command callback); Layer getTopLayer(); void add(final Layer layer); boolean isReady(); void remove(final Layer layer); void destroy(); Layer getLienzoLayer(); org.kie.workbench.common.stunner.core.client.canvas.Transform getTransform(); void translate(final double tx,
final double ty); void scale(final double sx,
final double sy); void scale(final double delta); } | LienzoLayer { protected Point2D getTranslate() { return new Point2D( layer.getAbsoluteTransform().getTranslateX(), layer.getAbsoluteTransform().getTranslateY() ); } LienzoLayer(); LienzoLayer(final LienzoCustomLayer layer); void setSkipDraw(final boolean skipDraw); LienzoLayer add(final IPrimitive<?> shape); LienzoLayer delete(final IPrimitive<?> shape); void clear(); void onAfterDraw(final Command callback); Layer getTopLayer(); void add(final Layer layer); boolean isReady(); void remove(final Layer layer); void destroy(); Layer getLienzoLayer(); org.kie.workbench.common.stunner.core.client.canvas.Transform getTransform(); void translate(final double tx,
final double ty); void scale(final double sx,
final double sy); void scale(final double delta); } |
@Test public void testGetScale() { transform.scale(0.11, 0.666); Point2D translate = tested.getScale(); assertEquals(0.11d, translate.getX(), 0d); assertEquals(0.666d, translate.getY(), 0d); } | protected Point2D getScale() { return new Point2D( layer.getAbsoluteTransform().getScaleX(), layer.getAbsoluteTransform().getScaleY() ); } | LienzoLayer { protected Point2D getScale() { return new Point2D( layer.getAbsoluteTransform().getScaleX(), layer.getAbsoluteTransform().getScaleY() ); } } | LienzoLayer { protected Point2D getScale() { return new Point2D( layer.getAbsoluteTransform().getScaleX(), layer.getAbsoluteTransform().getScaleY() ); } LienzoLayer(); LienzoLayer(final LienzoCustomLayer layer); } | LienzoLayer { protected Point2D getScale() { return new Point2D( layer.getAbsoluteTransform().getScaleX(), layer.getAbsoluteTransform().getScaleY() ); } LienzoLayer(); LienzoLayer(final LienzoCustomLayer layer); void setSkipDraw(final boolean skipDraw); LienzoLayer add(final IPrimitive<?> shape); LienzoLayer delete(final IPrimitive<?> shape); void clear(); void onAfterDraw(final Command callback); Layer getTopLayer(); void add(final Layer layer); boolean isReady(); void remove(final Layer layer); void destroy(); Layer getLienzoLayer(); org.kie.workbench.common.stunner.core.client.canvas.Transform getTransform(); void translate(final double tx,
final double ty); void scale(final double sx,
final double sy); void scale(final double delta); } | LienzoLayer { protected Point2D getScale() { return new Point2D( layer.getAbsoluteTransform().getScaleX(), layer.getAbsoluteTransform().getScaleY() ); } LienzoLayer(); LienzoLayer(final LienzoCustomLayer layer); void setSkipDraw(final boolean skipDraw); LienzoLayer add(final IPrimitive<?> shape); LienzoLayer delete(final IPrimitive<?> shape); void clear(); void onAfterDraw(final Command callback); Layer getTopLayer(); void add(final Layer layer); boolean isReady(); void remove(final Layer layer); void destroy(); Layer getLienzoLayer(); org.kie.workbench.common.stunner.core.client.canvas.Transform getTransform(); void translate(final double tx,
final double ty); void scale(final double sx,
final double sy); void scale(final double delta); } |
@Test public void testTranslate() { tested.translate(11, 33); assertEquals(11d, transform.getTranslateX(), 0d); assertEquals(33d, transform.getTranslateY(), 0d); } | public void translate(final double tx, final double ty) { setTransform(t -> translate(t, tx, ty)); } | LienzoLayer { public void translate(final double tx, final double ty) { setTransform(t -> translate(t, tx, ty)); } } | LienzoLayer { public void translate(final double tx, final double ty) { setTransform(t -> translate(t, tx, ty)); } LienzoLayer(); LienzoLayer(final LienzoCustomLayer layer); } | LienzoLayer { public void translate(final double tx, final double ty) { setTransform(t -> translate(t, tx, ty)); } LienzoLayer(); LienzoLayer(final LienzoCustomLayer layer); void setSkipDraw(final boolean skipDraw); LienzoLayer add(final IPrimitive<?> shape); LienzoLayer delete(final IPrimitive<?> shape); void clear(); void onAfterDraw(final Command callback); Layer getTopLayer(); void add(final Layer layer); boolean isReady(); void remove(final Layer layer); void destroy(); Layer getLienzoLayer(); org.kie.workbench.common.stunner.core.client.canvas.Transform getTransform(); void translate(final double tx,
final double ty); void scale(final double sx,
final double sy); void scale(final double delta); } | LienzoLayer { public void translate(final double tx, final double ty) { setTransform(t -> translate(t, tx, ty)); } LienzoLayer(); LienzoLayer(final LienzoCustomLayer layer); void setSkipDraw(final boolean skipDraw); LienzoLayer add(final IPrimitive<?> shape); LienzoLayer delete(final IPrimitive<?> shape); void clear(); void onAfterDraw(final Command callback); Layer getTopLayer(); void add(final Layer layer); boolean isReady(); void remove(final Layer layer); void destroy(); Layer getLienzoLayer(); org.kie.workbench.common.stunner.core.client.canvas.Transform getTransform(); void translate(final double tx,
final double ty); void scale(final double sx,
final double sy); void scale(final double delta); } |
@Test public void testScaleUnit() { tested.scale(0.22d); assertEquals(0.22d, transform.getScaleX(), 0d); assertEquals(0.22d, transform.getScaleY(), 0d); } | public void scale(final double sx, final double sy) { setTransform(t -> scale(t, sx, sy)); } | LienzoLayer { public void scale(final double sx, final double sy) { setTransform(t -> scale(t, sx, sy)); } } | LienzoLayer { public void scale(final double sx, final double sy) { setTransform(t -> scale(t, sx, sy)); } LienzoLayer(); LienzoLayer(final LienzoCustomLayer layer); } | LienzoLayer { public void scale(final double sx, final double sy) { setTransform(t -> scale(t, sx, sy)); } LienzoLayer(); LienzoLayer(final LienzoCustomLayer layer); void setSkipDraw(final boolean skipDraw); LienzoLayer add(final IPrimitive<?> shape); LienzoLayer delete(final IPrimitive<?> shape); void clear(); void onAfterDraw(final Command callback); Layer getTopLayer(); void add(final Layer layer); boolean isReady(); void remove(final Layer layer); void destroy(); Layer getLienzoLayer(); org.kie.workbench.common.stunner.core.client.canvas.Transform getTransform(); void translate(final double tx,
final double ty); void scale(final double sx,
final double sy); void scale(final double delta); } | LienzoLayer { public void scale(final double sx, final double sy) { setTransform(t -> scale(t, sx, sy)); } LienzoLayer(); LienzoLayer(final LienzoCustomLayer layer); void setSkipDraw(final boolean skipDraw); LienzoLayer add(final IPrimitive<?> shape); LienzoLayer delete(final IPrimitive<?> shape); void clear(); void onAfterDraw(final Command callback); Layer getTopLayer(); void add(final Layer layer); boolean isReady(); void remove(final Layer layer); void destroy(); Layer getLienzoLayer(); org.kie.workbench.common.stunner.core.client.canvas.Transform getTransform(); void translate(final double tx,
final double ty); void scale(final double sx,
final double sy); void scale(final double delta); } |
@Test public void testScaleUnits() { tested.scale(0.22d, 0.33d); assertEquals(0.22d, transform.getScaleX(), 0d); assertEquals(0.33d, transform.getScaleY(), 0d); } | public void scale(final double sx, final double sy) { setTransform(t -> scale(t, sx, sy)); } | LienzoLayer { public void scale(final double sx, final double sy) { setTransform(t -> scale(t, sx, sy)); } } | LienzoLayer { public void scale(final double sx, final double sy) { setTransform(t -> scale(t, sx, sy)); } LienzoLayer(); LienzoLayer(final LienzoCustomLayer layer); } | LienzoLayer { public void scale(final double sx, final double sy) { setTransform(t -> scale(t, sx, sy)); } LienzoLayer(); LienzoLayer(final LienzoCustomLayer layer); void setSkipDraw(final boolean skipDraw); LienzoLayer add(final IPrimitive<?> shape); LienzoLayer delete(final IPrimitive<?> shape); void clear(); void onAfterDraw(final Command callback); Layer getTopLayer(); void add(final Layer layer); boolean isReady(); void remove(final Layer layer); void destroy(); Layer getLienzoLayer(); org.kie.workbench.common.stunner.core.client.canvas.Transform getTransform(); void translate(final double tx,
final double ty); void scale(final double sx,
final double sy); void scale(final double delta); } | LienzoLayer { public void scale(final double sx, final double sy) { setTransform(t -> scale(t, sx, sy)); } LienzoLayer(); LienzoLayer(final LienzoCustomLayer layer); void setSkipDraw(final boolean skipDraw); LienzoLayer add(final IPrimitive<?> shape); LienzoLayer delete(final IPrimitive<?> shape); void clear(); void onAfterDraw(final Command callback); Layer getTopLayer(); void add(final Layer layer); boolean isReady(); void remove(final Layer layer); void destroy(); Layer getLienzoLayer(); org.kie.workbench.common.stunner.core.client.canvas.Transform getTransform(); void translate(final double tx,
final double ty); void scale(final double sx,
final double sy); void scale(final double delta); } |
@Test public void testOnClose() { tested.onClose(); verify(tested).closePreview(); } | @OnClose @SuppressWarnings("unused") public void onClose() { closePreview(); } | PreviewDiagramScreen { @OnClose @SuppressWarnings("unused") public void onClose() { closePreview(); } } | PreviewDiagramScreen { @OnClose @SuppressWarnings("unused") public void onClose() { closePreview(); } protected PreviewDiagramScreen(); @Inject PreviewDiagramScreen(final SessionManager clientSessionManager,
final @Any @DMNEditor ManagedInstance<SessionDiagramPreview<AbstractSession>> sessionPreviews,
final View view,
final DMNDiagramsSession session); } | PreviewDiagramScreen { @OnClose @SuppressWarnings("unused") public void onClose() { closePreview(); } protected PreviewDiagramScreen(); @Inject PreviewDiagramScreen(final SessionManager clientSessionManager,
final @Any @DMNEditor ManagedInstance<SessionDiagramPreview<AbstractSession>> sessionPreviews,
final View view,
final DMNDiagramsSession session); @OnStartup @SuppressWarnings("unused") void onStartup(final PlaceRequest placeRequest); @OnOpen @SuppressWarnings("unused") void onOpen(); @OnClose @SuppressWarnings("unused") void onClose(); @WorkbenchPartTitle @SuppressWarnings("unused") String getTitle(); @WorkbenchPartView @SuppressWarnings("unused") IsWidget getWidget(); @WorkbenchContextId @SuppressWarnings("unused") String getMyContextRef(); } | PreviewDiagramScreen { @OnClose @SuppressWarnings("unused") public void onClose() { closePreview(); } protected PreviewDiagramScreen(); @Inject PreviewDiagramScreen(final SessionManager clientSessionManager,
final @Any @DMNEditor ManagedInstance<SessionDiagramPreview<AbstractSession>> sessionPreviews,
final View view,
final DMNDiagramsSession session); @OnStartup @SuppressWarnings("unused") void onStartup(final PlaceRequest placeRequest); @OnOpen @SuppressWarnings("unused") void onOpen(); @OnClose @SuppressWarnings("unused") void onClose(); @WorkbenchPartTitle @SuppressWarnings("unused") String getTitle(); @WorkbenchPartView @SuppressWarnings("unused") IsWidget getWidget(); @WorkbenchContextId @SuppressWarnings("unused") String getMyContextRef(); static final String SCREEN_ID; } |
@Test public void testInit() { tested.init(canvasHandler); assertEquals(canvasHandler, tested.getCanvasHandler()); verify(highlight, times(1)).setCanvasHandler(eq(canvasHandler)); verify(wiresManager, times(1)).setConnectionAcceptor(any(IConnectionAcceptor.class)); verify(wiresManager, never()).setDockingAcceptor(any(IDockingAcceptor.class)); verify(wiresManager, never()).setContainmentAcceptor(any(IContainmentAcceptor.class)); } | @SuppressWarnings("unchecked") private static boolean eq(final Object n1, final Object n2) { if (n1 == null && n2 == null) { return true; } return null != n1 && n1.equals(n2); } | ConnectionAcceptorControlImpl extends AbstractAcceptorControl implements ConnectionAcceptorControl<AbstractCanvasHandler> { @SuppressWarnings("unchecked") private static boolean eq(final Object n1, final Object n2) { if (n1 == null && n2 == null) { return true; } return null != n1 && n1.equals(n2); } } | ConnectionAcceptorControlImpl extends AbstractAcceptorControl implements ConnectionAcceptorControl<AbstractCanvasHandler> { @SuppressWarnings("unchecked") private static boolean eq(final Object n1, final Object n2) { if (n1 == null && n2 == null) { return true; } return null != n1 && n1.equals(n2); } @Inject ConnectionAcceptorControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory,
final CanvasHighlight canvasHighlight); } | ConnectionAcceptorControlImpl extends AbstractAcceptorControl implements ConnectionAcceptorControl<AbstractCanvasHandler> { @SuppressWarnings("unchecked") private static boolean eq(final Object n1, final Object n2) { if (n1 == null && n2 == null) { return true; } return null != n1 && n1.equals(n2); } @Inject ConnectionAcceptorControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory,
final CanvasHighlight canvasHighlight); @Override @SuppressWarnings("unchecked") boolean allowSource(final Node source,
final Edge<ViewConnector<?>, Node> connector,
final Connection connection); @Override @SuppressWarnings("unchecked") boolean allowTarget(final Node target,
final Edge<ViewConnector<?>, Node> connector,
final Connection connection); @Override @SuppressWarnings("unchecked") boolean acceptSource(final Node source,
final Edge<ViewConnector<?>, Node> connector,
final Connection connection); @Override @SuppressWarnings("unchecked") boolean acceptTarget(final Node target,
final Edge<ViewConnector<?>, Node> connector,
final Connection connection); static Connection createConnection(final WiresConnection wiresConnection,
final WiresMagnet wiresMagnet); @SuppressWarnings("unchecked") static MagnetConnection createConnection(final Element element); } | ConnectionAcceptorControlImpl extends AbstractAcceptorControl implements ConnectionAcceptorControl<AbstractCanvasHandler> { @SuppressWarnings("unchecked") private static boolean eq(final Object n1, final Object n2) { if (n1 == null && n2 == null) { return true; } return null != n1 && n1.equals(n2); } @Inject ConnectionAcceptorControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory,
final CanvasHighlight canvasHighlight); @Override @SuppressWarnings("unchecked") boolean allowSource(final Node source,
final Edge<ViewConnector<?>, Node> connector,
final Connection connection); @Override @SuppressWarnings("unchecked") boolean allowTarget(final Node target,
final Edge<ViewConnector<?>, Node> connector,
final Connection connection); @Override @SuppressWarnings("unchecked") boolean acceptSource(final Node source,
final Edge<ViewConnector<?>, Node> connector,
final Connection connection); @Override @SuppressWarnings("unchecked") boolean acceptTarget(final Node target,
final Edge<ViewConnector<?>, Node> connector,
final Connection connection); static Connection createConnection(final WiresConnection wiresConnection,
final WiresMagnet wiresMagnet); @SuppressWarnings("unchecked") static MagnetConnection createConnection(final Element element); } |
@Test public void testAllowSource() { tested.init(canvasHandler); final boolean allow = tested.allowSource(node, edge, connection); assertTrue(allow); verify(commandManager, times(1)).allow(eq(canvasHandler), eq(setConnectionSourceNodeCommand)); verify(commandManager, never()).execute(any(AbstractCanvasHandler.class), any(SetConnectionSourceNodeCommand.class)); assertEquals(node, setConnectionSourceNodeCommand.getNode()); assertEquals(edge, setConnectionSourceNodeCommand.getEdge()); assertEquals(connection, setConnectionSourceNodeCommand.getConnection()); verify(highlight, times(1)).unhighLight(); } | @Override @SuppressWarnings("unchecked") public boolean allowSource(final Node source, final Edge<ViewConnector<?>, Node> connector, final Connection connection) { if (isSourceConnectionChanged(connector, connection)) { final CommandResult<CanvasViolation> violations = getCommandManager().allow(getCanvasHandler(), canvasCommandFactory.setSourceNode(source, connector, connection)); final boolean accepts = isAccept(violations); if (isSourceChanged(source, connector)) { highlight(source, connector, accepts); } return accepts; } return true; } | ConnectionAcceptorControlImpl extends AbstractAcceptorControl implements ConnectionAcceptorControl<AbstractCanvasHandler> { @Override @SuppressWarnings("unchecked") public boolean allowSource(final Node source, final Edge<ViewConnector<?>, Node> connector, final Connection connection) { if (isSourceConnectionChanged(connector, connection)) { final CommandResult<CanvasViolation> violations = getCommandManager().allow(getCanvasHandler(), canvasCommandFactory.setSourceNode(source, connector, connection)); final boolean accepts = isAccept(violations); if (isSourceChanged(source, connector)) { highlight(source, connector, accepts); } return accepts; } return true; } } | ConnectionAcceptorControlImpl extends AbstractAcceptorControl implements ConnectionAcceptorControl<AbstractCanvasHandler> { @Override @SuppressWarnings("unchecked") public boolean allowSource(final Node source, final Edge<ViewConnector<?>, Node> connector, final Connection connection) { if (isSourceConnectionChanged(connector, connection)) { final CommandResult<CanvasViolation> violations = getCommandManager().allow(getCanvasHandler(), canvasCommandFactory.setSourceNode(source, connector, connection)); final boolean accepts = isAccept(violations); if (isSourceChanged(source, connector)) { highlight(source, connector, accepts); } return accepts; } return true; } @Inject ConnectionAcceptorControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory,
final CanvasHighlight canvasHighlight); } | ConnectionAcceptorControlImpl extends AbstractAcceptorControl implements ConnectionAcceptorControl<AbstractCanvasHandler> { @Override @SuppressWarnings("unchecked") public boolean allowSource(final Node source, final Edge<ViewConnector<?>, Node> connector, final Connection connection) { if (isSourceConnectionChanged(connector, connection)) { final CommandResult<CanvasViolation> violations = getCommandManager().allow(getCanvasHandler(), canvasCommandFactory.setSourceNode(source, connector, connection)); final boolean accepts = isAccept(violations); if (isSourceChanged(source, connector)) { highlight(source, connector, accepts); } return accepts; } return true; } @Inject ConnectionAcceptorControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory,
final CanvasHighlight canvasHighlight); @Override @SuppressWarnings("unchecked") boolean allowSource(final Node source,
final Edge<ViewConnector<?>, Node> connector,
final Connection connection); @Override @SuppressWarnings("unchecked") boolean allowTarget(final Node target,
final Edge<ViewConnector<?>, Node> connector,
final Connection connection); @Override @SuppressWarnings("unchecked") boolean acceptSource(final Node source,
final Edge<ViewConnector<?>, Node> connector,
final Connection connection); @Override @SuppressWarnings("unchecked") boolean acceptTarget(final Node target,
final Edge<ViewConnector<?>, Node> connector,
final Connection connection); static Connection createConnection(final WiresConnection wiresConnection,
final WiresMagnet wiresMagnet); @SuppressWarnings("unchecked") static MagnetConnection createConnection(final Element element); } | ConnectionAcceptorControlImpl extends AbstractAcceptorControl implements ConnectionAcceptorControl<AbstractCanvasHandler> { @Override @SuppressWarnings("unchecked") public boolean allowSource(final Node source, final Edge<ViewConnector<?>, Node> connector, final Connection connection) { if (isSourceConnectionChanged(connector, connection)) { final CommandResult<CanvasViolation> violations = getCommandManager().allow(getCanvasHandler(), canvasCommandFactory.setSourceNode(source, connector, connection)); final boolean accepts = isAccept(violations); if (isSourceChanged(source, connector)) { highlight(source, connector, accepts); } return accepts; } return true; } @Inject ConnectionAcceptorControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory,
final CanvasHighlight canvasHighlight); @Override @SuppressWarnings("unchecked") boolean allowSource(final Node source,
final Edge<ViewConnector<?>, Node> connector,
final Connection connection); @Override @SuppressWarnings("unchecked") boolean allowTarget(final Node target,
final Edge<ViewConnector<?>, Node> connector,
final Connection connection); @Override @SuppressWarnings("unchecked") boolean acceptSource(final Node source,
final Edge<ViewConnector<?>, Node> connector,
final Connection connection); @Override @SuppressWarnings("unchecked") boolean acceptTarget(final Node target,
final Edge<ViewConnector<?>, Node> connector,
final Connection connection); static Connection createConnection(final WiresConnection wiresConnection,
final WiresMagnet wiresMagnet); @SuppressWarnings("unchecked") static MagnetConnection createConnection(final Element element); } |
@Test public void testAllowTarget() { tested.init(canvasHandler); final boolean allow = tested.allowTarget(node, edge, connection); assertTrue(allow); verify(commandManager, times(1)).allow(eq(canvasHandler), eq(setConnectionTargetNodeCommand)); verify(commandManager, never()).execute(any(AbstractCanvasHandler.class), any(SetConnectionTargetNodeCommand.class)); assertEquals(node, setConnectionTargetNodeCommand.getNode()); assertEquals(edge, setConnectionTargetNodeCommand.getEdge()); assertEquals(connection, setConnectionTargetNodeCommand.getConnection()); verify(highlight, times(1)).unhighLight(); } | @Override @SuppressWarnings("unchecked") public boolean allowTarget(final Node target, final Edge<ViewConnector<?>, Node> connector, final Connection connection) { if (isTargetConnectionChanged(connector, connection)) { final CommandResult<CanvasViolation> violations = getCommandManager().allow(getCanvasHandler(), canvasCommandFactory.setTargetNode(target, connector, connection)); final boolean accepts = isAccept(violations); if (isTargetChanged(target, connector)) { highlight(target, connector, accepts); } return accepts; } return true; } | ConnectionAcceptorControlImpl extends AbstractAcceptorControl implements ConnectionAcceptorControl<AbstractCanvasHandler> { @Override @SuppressWarnings("unchecked") public boolean allowTarget(final Node target, final Edge<ViewConnector<?>, Node> connector, final Connection connection) { if (isTargetConnectionChanged(connector, connection)) { final CommandResult<CanvasViolation> violations = getCommandManager().allow(getCanvasHandler(), canvasCommandFactory.setTargetNode(target, connector, connection)); final boolean accepts = isAccept(violations); if (isTargetChanged(target, connector)) { highlight(target, connector, accepts); } return accepts; } return true; } } | ConnectionAcceptorControlImpl extends AbstractAcceptorControl implements ConnectionAcceptorControl<AbstractCanvasHandler> { @Override @SuppressWarnings("unchecked") public boolean allowTarget(final Node target, final Edge<ViewConnector<?>, Node> connector, final Connection connection) { if (isTargetConnectionChanged(connector, connection)) { final CommandResult<CanvasViolation> violations = getCommandManager().allow(getCanvasHandler(), canvasCommandFactory.setTargetNode(target, connector, connection)); final boolean accepts = isAccept(violations); if (isTargetChanged(target, connector)) { highlight(target, connector, accepts); } return accepts; } return true; } @Inject ConnectionAcceptorControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory,
final CanvasHighlight canvasHighlight); } | ConnectionAcceptorControlImpl extends AbstractAcceptorControl implements ConnectionAcceptorControl<AbstractCanvasHandler> { @Override @SuppressWarnings("unchecked") public boolean allowTarget(final Node target, final Edge<ViewConnector<?>, Node> connector, final Connection connection) { if (isTargetConnectionChanged(connector, connection)) { final CommandResult<CanvasViolation> violations = getCommandManager().allow(getCanvasHandler(), canvasCommandFactory.setTargetNode(target, connector, connection)); final boolean accepts = isAccept(violations); if (isTargetChanged(target, connector)) { highlight(target, connector, accepts); } return accepts; } return true; } @Inject ConnectionAcceptorControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory,
final CanvasHighlight canvasHighlight); @Override @SuppressWarnings("unchecked") boolean allowSource(final Node source,
final Edge<ViewConnector<?>, Node> connector,
final Connection connection); @Override @SuppressWarnings("unchecked") boolean allowTarget(final Node target,
final Edge<ViewConnector<?>, Node> connector,
final Connection connection); @Override @SuppressWarnings("unchecked") boolean acceptSource(final Node source,
final Edge<ViewConnector<?>, Node> connector,
final Connection connection); @Override @SuppressWarnings("unchecked") boolean acceptTarget(final Node target,
final Edge<ViewConnector<?>, Node> connector,
final Connection connection); static Connection createConnection(final WiresConnection wiresConnection,
final WiresMagnet wiresMagnet); @SuppressWarnings("unchecked") static MagnetConnection createConnection(final Element element); } | ConnectionAcceptorControlImpl extends AbstractAcceptorControl implements ConnectionAcceptorControl<AbstractCanvasHandler> { @Override @SuppressWarnings("unchecked") public boolean allowTarget(final Node target, final Edge<ViewConnector<?>, Node> connector, final Connection connection) { if (isTargetConnectionChanged(connector, connection)) { final CommandResult<CanvasViolation> violations = getCommandManager().allow(getCanvasHandler(), canvasCommandFactory.setTargetNode(target, connector, connection)); final boolean accepts = isAccept(violations); if (isTargetChanged(target, connector)) { highlight(target, connector, accepts); } return accepts; } return true; } @Inject ConnectionAcceptorControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory,
final CanvasHighlight canvasHighlight); @Override @SuppressWarnings("unchecked") boolean allowSource(final Node source,
final Edge<ViewConnector<?>, Node> connector,
final Connection connection); @Override @SuppressWarnings("unchecked") boolean allowTarget(final Node target,
final Edge<ViewConnector<?>, Node> connector,
final Connection connection); @Override @SuppressWarnings("unchecked") boolean acceptSource(final Node source,
final Edge<ViewConnector<?>, Node> connector,
final Connection connection); @Override @SuppressWarnings("unchecked") boolean acceptTarget(final Node target,
final Edge<ViewConnector<?>, Node> connector,
final Connection connection); static Connection createConnection(final WiresConnection wiresConnection,
final WiresMagnet wiresMagnet); @SuppressWarnings("unchecked") static MagnetConnection createConnection(final Element element); } |
@Test public void testAcceptSource() { tested.init(canvasHandler); final boolean allow = tested.acceptSource(node, edge, connection); assertTrue(allow); verify(commandManager, times(1)).execute(eq(canvasHandler), eq(setConnectionSourceNodeCommand)); verify(commandManager, never()).allow(any(AbstractCanvasHandler.class), any(SetConnectionSourceNodeCommand.class)); assertEquals(node, setConnectionSourceNodeCommand.getNode()); assertEquals(edge, setConnectionSourceNodeCommand.getEdge()); assertEquals(connection, setConnectionSourceNodeCommand.getConnection()); verify(highlight, times(1)).unhighLight(); } | @Override @SuppressWarnings("unchecked") public boolean acceptSource(final Node source, final Edge<ViewConnector<?>, Node> connector, final Connection connection) { ensureUnHighLight(); if (isSourceChanged(source, connector)) { final CommandResult<CanvasViolation> violations = getCommandManager().execute(getCanvasHandler(), canvasCommandFactory.setSourceNode(source, connector, connection)); return isAccept(violations); } return true; } | ConnectionAcceptorControlImpl extends AbstractAcceptorControl implements ConnectionAcceptorControl<AbstractCanvasHandler> { @Override @SuppressWarnings("unchecked") public boolean acceptSource(final Node source, final Edge<ViewConnector<?>, Node> connector, final Connection connection) { ensureUnHighLight(); if (isSourceChanged(source, connector)) { final CommandResult<CanvasViolation> violations = getCommandManager().execute(getCanvasHandler(), canvasCommandFactory.setSourceNode(source, connector, connection)); return isAccept(violations); } return true; } } | ConnectionAcceptorControlImpl extends AbstractAcceptorControl implements ConnectionAcceptorControl<AbstractCanvasHandler> { @Override @SuppressWarnings("unchecked") public boolean acceptSource(final Node source, final Edge<ViewConnector<?>, Node> connector, final Connection connection) { ensureUnHighLight(); if (isSourceChanged(source, connector)) { final CommandResult<CanvasViolation> violations = getCommandManager().execute(getCanvasHandler(), canvasCommandFactory.setSourceNode(source, connector, connection)); return isAccept(violations); } return true; } @Inject ConnectionAcceptorControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory,
final CanvasHighlight canvasHighlight); } | ConnectionAcceptorControlImpl extends AbstractAcceptorControl implements ConnectionAcceptorControl<AbstractCanvasHandler> { @Override @SuppressWarnings("unchecked") public boolean acceptSource(final Node source, final Edge<ViewConnector<?>, Node> connector, final Connection connection) { ensureUnHighLight(); if (isSourceChanged(source, connector)) { final CommandResult<CanvasViolation> violations = getCommandManager().execute(getCanvasHandler(), canvasCommandFactory.setSourceNode(source, connector, connection)); return isAccept(violations); } return true; } @Inject ConnectionAcceptorControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory,
final CanvasHighlight canvasHighlight); @Override @SuppressWarnings("unchecked") boolean allowSource(final Node source,
final Edge<ViewConnector<?>, Node> connector,
final Connection connection); @Override @SuppressWarnings("unchecked") boolean allowTarget(final Node target,
final Edge<ViewConnector<?>, Node> connector,
final Connection connection); @Override @SuppressWarnings("unchecked") boolean acceptSource(final Node source,
final Edge<ViewConnector<?>, Node> connector,
final Connection connection); @Override @SuppressWarnings("unchecked") boolean acceptTarget(final Node target,
final Edge<ViewConnector<?>, Node> connector,
final Connection connection); static Connection createConnection(final WiresConnection wiresConnection,
final WiresMagnet wiresMagnet); @SuppressWarnings("unchecked") static MagnetConnection createConnection(final Element element); } | ConnectionAcceptorControlImpl extends AbstractAcceptorControl implements ConnectionAcceptorControl<AbstractCanvasHandler> { @Override @SuppressWarnings("unchecked") public boolean acceptSource(final Node source, final Edge<ViewConnector<?>, Node> connector, final Connection connection) { ensureUnHighLight(); if (isSourceChanged(source, connector)) { final CommandResult<CanvasViolation> violations = getCommandManager().execute(getCanvasHandler(), canvasCommandFactory.setSourceNode(source, connector, connection)); return isAccept(violations); } return true; } @Inject ConnectionAcceptorControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory,
final CanvasHighlight canvasHighlight); @Override @SuppressWarnings("unchecked") boolean allowSource(final Node source,
final Edge<ViewConnector<?>, Node> connector,
final Connection connection); @Override @SuppressWarnings("unchecked") boolean allowTarget(final Node target,
final Edge<ViewConnector<?>, Node> connector,
final Connection connection); @Override @SuppressWarnings("unchecked") boolean acceptSource(final Node source,
final Edge<ViewConnector<?>, Node> connector,
final Connection connection); @Override @SuppressWarnings("unchecked") boolean acceptTarget(final Node target,
final Edge<ViewConnector<?>, Node> connector,
final Connection connection); static Connection createConnection(final WiresConnection wiresConnection,
final WiresMagnet wiresMagnet); @SuppressWarnings("unchecked") static MagnetConnection createConnection(final Element element); } |
@Test public void testAcceptTarget() { tested.init(canvasHandler); final boolean allow = tested.acceptTarget(node, edge, connection); assertTrue(allow); verify(commandManager, times(1)).execute(eq(canvasHandler), eq(setConnectionTargetNodeCommand)); verify(commandManager, never()).allow(any(AbstractCanvasHandler.class), any(SetConnectionSourceNodeCommand.class)); assertEquals(node, setConnectionTargetNodeCommand.getNode()); assertEquals(edge, setConnectionTargetNodeCommand.getEdge()); assertEquals(connection, setConnectionTargetNodeCommand.getConnection()); verify(highlight, times(1)).unhighLight(); } | @Override @SuppressWarnings("unchecked") public boolean acceptTarget(final Node target, final Edge<ViewConnector<?>, Node> connector, final Connection connection) { ensureUnHighLight(); if (isTargetChanged(target, connector)) { final CommandResult<CanvasViolation> violations = getCommandManager().execute(getCanvasHandler(), canvasCommandFactory.setTargetNode(target, connector, connection)); return isAccept(violations); } return true; } | ConnectionAcceptorControlImpl extends AbstractAcceptorControl implements ConnectionAcceptorControl<AbstractCanvasHandler> { @Override @SuppressWarnings("unchecked") public boolean acceptTarget(final Node target, final Edge<ViewConnector<?>, Node> connector, final Connection connection) { ensureUnHighLight(); if (isTargetChanged(target, connector)) { final CommandResult<CanvasViolation> violations = getCommandManager().execute(getCanvasHandler(), canvasCommandFactory.setTargetNode(target, connector, connection)); return isAccept(violations); } return true; } } | ConnectionAcceptorControlImpl extends AbstractAcceptorControl implements ConnectionAcceptorControl<AbstractCanvasHandler> { @Override @SuppressWarnings("unchecked") public boolean acceptTarget(final Node target, final Edge<ViewConnector<?>, Node> connector, final Connection connection) { ensureUnHighLight(); if (isTargetChanged(target, connector)) { final CommandResult<CanvasViolation> violations = getCommandManager().execute(getCanvasHandler(), canvasCommandFactory.setTargetNode(target, connector, connection)); return isAccept(violations); } return true; } @Inject ConnectionAcceptorControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory,
final CanvasHighlight canvasHighlight); } | ConnectionAcceptorControlImpl extends AbstractAcceptorControl implements ConnectionAcceptorControl<AbstractCanvasHandler> { @Override @SuppressWarnings("unchecked") public boolean acceptTarget(final Node target, final Edge<ViewConnector<?>, Node> connector, final Connection connection) { ensureUnHighLight(); if (isTargetChanged(target, connector)) { final CommandResult<CanvasViolation> violations = getCommandManager().execute(getCanvasHandler(), canvasCommandFactory.setTargetNode(target, connector, connection)); return isAccept(violations); } return true; } @Inject ConnectionAcceptorControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory,
final CanvasHighlight canvasHighlight); @Override @SuppressWarnings("unchecked") boolean allowSource(final Node source,
final Edge<ViewConnector<?>, Node> connector,
final Connection connection); @Override @SuppressWarnings("unchecked") boolean allowTarget(final Node target,
final Edge<ViewConnector<?>, Node> connector,
final Connection connection); @Override @SuppressWarnings("unchecked") boolean acceptSource(final Node source,
final Edge<ViewConnector<?>, Node> connector,
final Connection connection); @Override @SuppressWarnings("unchecked") boolean acceptTarget(final Node target,
final Edge<ViewConnector<?>, Node> connector,
final Connection connection); static Connection createConnection(final WiresConnection wiresConnection,
final WiresMagnet wiresMagnet); @SuppressWarnings("unchecked") static MagnetConnection createConnection(final Element element); } | ConnectionAcceptorControlImpl extends AbstractAcceptorControl implements ConnectionAcceptorControl<AbstractCanvasHandler> { @Override @SuppressWarnings("unchecked") public boolean acceptTarget(final Node target, final Edge<ViewConnector<?>, Node> connector, final Connection connection) { ensureUnHighLight(); if (isTargetChanged(target, connector)) { final CommandResult<CanvasViolation> violations = getCommandManager().execute(getCanvasHandler(), canvasCommandFactory.setTargetNode(target, connector, connection)); return isAccept(violations); } return true; } @Inject ConnectionAcceptorControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory,
final CanvasHighlight canvasHighlight); @Override @SuppressWarnings("unchecked") boolean allowSource(final Node source,
final Edge<ViewConnector<?>, Node> connector,
final Connection connection); @Override @SuppressWarnings("unchecked") boolean allowTarget(final Node target,
final Edge<ViewConnector<?>, Node> connector,
final Connection connection); @Override @SuppressWarnings("unchecked") boolean acceptSource(final Node source,
final Edge<ViewConnector<?>, Node> connector,
final Connection connection); @Override @SuppressWarnings("unchecked") boolean acceptTarget(final Node target,
final Edge<ViewConnector<?>, Node> connector,
final Connection connection); static Connection createConnection(final WiresConnection wiresConnection,
final WiresMagnet wiresMagnet); @SuppressWarnings("unchecked") static MagnetConnection createConnection(final Element element); } |
@Test public void testAcceptTargetNotNewConnection() { when(edge.getTargetNode()).thenReturn(node); tested.init(canvasHandler); final boolean allow = tested.acceptTarget(node, edge, connection); assertTrue(allow); verify(commandManager, never()).allow(any(AbstractCanvasHandler.class), any(SetConnectionTargetNodeCommand.class)); verify(highlight, times(1)).unhighLight(); } | @Override @SuppressWarnings("unchecked") public boolean acceptTarget(final Node target, final Edge<ViewConnector<?>, Node> connector, final Connection connection) { ensureUnHighLight(); if (isTargetChanged(target, connector)) { final CommandResult<CanvasViolation> violations = getCommandManager().execute(getCanvasHandler(), canvasCommandFactory.setTargetNode(target, connector, connection)); return isAccept(violations); } return true; } | ConnectionAcceptorControlImpl extends AbstractAcceptorControl implements ConnectionAcceptorControl<AbstractCanvasHandler> { @Override @SuppressWarnings("unchecked") public boolean acceptTarget(final Node target, final Edge<ViewConnector<?>, Node> connector, final Connection connection) { ensureUnHighLight(); if (isTargetChanged(target, connector)) { final CommandResult<CanvasViolation> violations = getCommandManager().execute(getCanvasHandler(), canvasCommandFactory.setTargetNode(target, connector, connection)); return isAccept(violations); } return true; } } | ConnectionAcceptorControlImpl extends AbstractAcceptorControl implements ConnectionAcceptorControl<AbstractCanvasHandler> { @Override @SuppressWarnings("unchecked") public boolean acceptTarget(final Node target, final Edge<ViewConnector<?>, Node> connector, final Connection connection) { ensureUnHighLight(); if (isTargetChanged(target, connector)) { final CommandResult<CanvasViolation> violations = getCommandManager().execute(getCanvasHandler(), canvasCommandFactory.setTargetNode(target, connector, connection)); return isAccept(violations); } return true; } @Inject ConnectionAcceptorControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory,
final CanvasHighlight canvasHighlight); } | ConnectionAcceptorControlImpl extends AbstractAcceptorControl implements ConnectionAcceptorControl<AbstractCanvasHandler> { @Override @SuppressWarnings("unchecked") public boolean acceptTarget(final Node target, final Edge<ViewConnector<?>, Node> connector, final Connection connection) { ensureUnHighLight(); if (isTargetChanged(target, connector)) { final CommandResult<CanvasViolation> violations = getCommandManager().execute(getCanvasHandler(), canvasCommandFactory.setTargetNode(target, connector, connection)); return isAccept(violations); } return true; } @Inject ConnectionAcceptorControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory,
final CanvasHighlight canvasHighlight); @Override @SuppressWarnings("unchecked") boolean allowSource(final Node source,
final Edge<ViewConnector<?>, Node> connector,
final Connection connection); @Override @SuppressWarnings("unchecked") boolean allowTarget(final Node target,
final Edge<ViewConnector<?>, Node> connector,
final Connection connection); @Override @SuppressWarnings("unchecked") boolean acceptSource(final Node source,
final Edge<ViewConnector<?>, Node> connector,
final Connection connection); @Override @SuppressWarnings("unchecked") boolean acceptTarget(final Node target,
final Edge<ViewConnector<?>, Node> connector,
final Connection connection); static Connection createConnection(final WiresConnection wiresConnection,
final WiresMagnet wiresMagnet); @SuppressWarnings("unchecked") static MagnetConnection createConnection(final Element element); } | ConnectionAcceptorControlImpl extends AbstractAcceptorControl implements ConnectionAcceptorControl<AbstractCanvasHandler> { @Override @SuppressWarnings("unchecked") public boolean acceptTarget(final Node target, final Edge<ViewConnector<?>, Node> connector, final Connection connection) { ensureUnHighLight(); if (isTargetChanged(target, connector)) { final CommandResult<CanvasViolation> violations = getCommandManager().execute(getCanvasHandler(), canvasCommandFactory.setTargetNode(target, connector, connection)); return isAccept(violations); } return true; } @Inject ConnectionAcceptorControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory,
final CanvasHighlight canvasHighlight); @Override @SuppressWarnings("unchecked") boolean allowSource(final Node source,
final Edge<ViewConnector<?>, Node> connector,
final Connection connection); @Override @SuppressWarnings("unchecked") boolean allowTarget(final Node target,
final Edge<ViewConnector<?>, Node> connector,
final Connection connection); @Override @SuppressWarnings("unchecked") boolean acceptSource(final Node source,
final Edge<ViewConnector<?>, Node> connector,
final Connection connection); @Override @SuppressWarnings("unchecked") boolean acceptTarget(final Node target,
final Edge<ViewConnector<?>, Node> connector,
final Connection connection); static Connection createConnection(final WiresConnection wiresConnection,
final WiresMagnet wiresMagnet); @SuppressWarnings("unchecked") static MagnetConnection createConnection(final Element element); } |
@Test public void testCreateConnections() { Element element = mock(Element.class); View<?> content = mock(View.class); Bounds bounds = Bounds.create(0d, 0d, 10d, 20d); when(element.getContent()).thenReturn(content); when(content.getBounds()).thenReturn(bounds); MagnetConnection c1 = ConnectionAcceptorControlImpl.createConnection(element); assertEquals(5, c1.getLocation().getX(), 0); assertEquals(10, c1.getLocation().getY(), 0); assertEquals(MagnetConnection.MAGNET_CENTER, c1.getMagnetIndex().getAsInt()); assertFalse(c1.isAuto()); WiresConnection wiresConnection = mock(WiresConnection.class); when(wiresConnection.isAutoConnection()).thenReturn(true); WiresMagnet wiresMagnet = mock(WiresMagnet.class); when(wiresMagnet.getX()).thenReturn(122d); when(wiresMagnet.getY()).thenReturn(543d); when(wiresMagnet.getIndex()).thenReturn(7); MagnetConnection c2 = (MagnetConnection) ConnectionAcceptorControlImpl.createConnection(wiresConnection, wiresMagnet); assertEquals(122, c2.getLocation().getX(), 0); assertEquals(543, c2.getLocation().getY(), 0); assertEquals(7, c2.getMagnetIndex().getAsInt()); assertTrue(c2.isAuto()); when(wiresConnection.getPoint()).thenReturn(new Point2D(122d, 543d)); final Connection pointConnection = ConnectionAcceptorControlImpl.createConnection(wiresConnection, null); assertEquals(122d, pointConnection.getLocation().getX(), 0); assertEquals(543d, pointConnection.getLocation().getY(), 0); assertNull(ConnectionAcceptorControlImpl.createConnection(null)); assertNull(ConnectionAcceptorControlImpl.createConnection(null, null)); } | public static Connection createConnection(final WiresConnection wiresConnection, final WiresMagnet wiresMagnet) { if (null == wiresMagnet && null == wiresConnection) { return null; } if (null == wiresMagnet) { return Point2DConnection.at(Point2D.create(wiresConnection.getPoint().getX(), wiresConnection.getPoint().getY())); } return new MagnetConnection.Builder() .atX(wiresMagnet.getX()) .atY(wiresMagnet.getY()) .auto(null != wiresConnection && wiresConnection.isAutoConnection()) .magnet(wiresMagnet.getIndex()) .build(); } | ConnectionAcceptorControlImpl extends AbstractAcceptorControl implements ConnectionAcceptorControl<AbstractCanvasHandler> { public static Connection createConnection(final WiresConnection wiresConnection, final WiresMagnet wiresMagnet) { if (null == wiresMagnet && null == wiresConnection) { return null; } if (null == wiresMagnet) { return Point2DConnection.at(Point2D.create(wiresConnection.getPoint().getX(), wiresConnection.getPoint().getY())); } return new MagnetConnection.Builder() .atX(wiresMagnet.getX()) .atY(wiresMagnet.getY()) .auto(null != wiresConnection && wiresConnection.isAutoConnection()) .magnet(wiresMagnet.getIndex()) .build(); } } | ConnectionAcceptorControlImpl extends AbstractAcceptorControl implements ConnectionAcceptorControl<AbstractCanvasHandler> { public static Connection createConnection(final WiresConnection wiresConnection, final WiresMagnet wiresMagnet) { if (null == wiresMagnet && null == wiresConnection) { return null; } if (null == wiresMagnet) { return Point2DConnection.at(Point2D.create(wiresConnection.getPoint().getX(), wiresConnection.getPoint().getY())); } return new MagnetConnection.Builder() .atX(wiresMagnet.getX()) .atY(wiresMagnet.getY()) .auto(null != wiresConnection && wiresConnection.isAutoConnection()) .magnet(wiresMagnet.getIndex()) .build(); } @Inject ConnectionAcceptorControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory,
final CanvasHighlight canvasHighlight); } | ConnectionAcceptorControlImpl extends AbstractAcceptorControl implements ConnectionAcceptorControl<AbstractCanvasHandler> { public static Connection createConnection(final WiresConnection wiresConnection, final WiresMagnet wiresMagnet) { if (null == wiresMagnet && null == wiresConnection) { return null; } if (null == wiresMagnet) { return Point2DConnection.at(Point2D.create(wiresConnection.getPoint().getX(), wiresConnection.getPoint().getY())); } return new MagnetConnection.Builder() .atX(wiresMagnet.getX()) .atY(wiresMagnet.getY()) .auto(null != wiresConnection && wiresConnection.isAutoConnection()) .magnet(wiresMagnet.getIndex()) .build(); } @Inject ConnectionAcceptorControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory,
final CanvasHighlight canvasHighlight); @Override @SuppressWarnings("unchecked") boolean allowSource(final Node source,
final Edge<ViewConnector<?>, Node> connector,
final Connection connection); @Override @SuppressWarnings("unchecked") boolean allowTarget(final Node target,
final Edge<ViewConnector<?>, Node> connector,
final Connection connection); @Override @SuppressWarnings("unchecked") boolean acceptSource(final Node source,
final Edge<ViewConnector<?>, Node> connector,
final Connection connection); @Override @SuppressWarnings("unchecked") boolean acceptTarget(final Node target,
final Edge<ViewConnector<?>, Node> connector,
final Connection connection); static Connection createConnection(final WiresConnection wiresConnection,
final WiresMagnet wiresMagnet); @SuppressWarnings("unchecked") static MagnetConnection createConnection(final Element element); } | ConnectionAcceptorControlImpl extends AbstractAcceptorControl implements ConnectionAcceptorControl<AbstractCanvasHandler> { public static Connection createConnection(final WiresConnection wiresConnection, final WiresMagnet wiresMagnet) { if (null == wiresMagnet && null == wiresConnection) { return null; } if (null == wiresMagnet) { return Point2DConnection.at(Point2D.create(wiresConnection.getPoint().getX(), wiresConnection.getPoint().getY())); } return new MagnetConnection.Builder() .atX(wiresMagnet.getX()) .atY(wiresMagnet.getY()) .auto(null != wiresConnection && wiresConnection.isAutoConnection()) .magnet(wiresMagnet.getIndex()) .build(); } @Inject ConnectionAcceptorControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory,
final CanvasHighlight canvasHighlight); @Override @SuppressWarnings("unchecked") boolean allowSource(final Node source,
final Edge<ViewConnector<?>, Node> connector,
final Connection connection); @Override @SuppressWarnings("unchecked") boolean allowTarget(final Node target,
final Edge<ViewConnector<?>, Node> connector,
final Connection connection); @Override @SuppressWarnings("unchecked") boolean acceptSource(final Node source,
final Edge<ViewConnector<?>, Node> connector,
final Connection connection); @Override @SuppressWarnings("unchecked") boolean acceptTarget(final Node target,
final Edge<ViewConnector<?>, Node> connector,
final Connection connection); static Connection createConnection(final WiresConnection wiresConnection,
final WiresMagnet wiresMagnet); @SuppressWarnings("unchecked") static MagnetConnection createConnection(final Element element); } |
@Test @SuppressWarnings("unchecked") public void testAddControlPoint() { final int index = 1; final ControlPoint controlPoint = ControlPoint.build(2, 2); CanvasCommand<AbstractCanvasHandler> addControlPointCommand = mock(CanvasCommand.class); doReturn(addControlPointCommand).when(canvasCommandFactory).addControlPoint(eq(edge), eq(controlPoint), eq(index)); tested.init(canvasHandler); tested.addControlPoint(edge, controlPoint, index); ArgumentCaptor<Command> commandArgumentCaptor = ArgumentCaptor.forClass(Command.class); verify(commandManager, times(1)).execute(eq(canvasHandler), commandArgumentCaptor.capture()); Command<AbstractCanvasHandler, CanvasViolation> command = commandArgumentCaptor.getValue(); assertEquals(addControlPointCommand, command); } | @Override public void addControlPoint(final Edge candidate, final ControlPoint controlPoint, final int index) { selectionEvent.fire(new CanvasSelectionEvent(canvasHandler, candidate.getUUID())); execute(canvasCommandFactory.addControlPoint(candidate, controlPoint, index)); } | ControlPointControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements ControlPointControl<AbstractCanvasHandler> { @Override public void addControlPoint(final Edge candidate, final ControlPoint controlPoint, final int index) { selectionEvent.fire(new CanvasSelectionEvent(canvasHandler, candidate.getUUID())); execute(canvasCommandFactory.addControlPoint(candidate, controlPoint, index)); } } | ControlPointControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements ControlPointControl<AbstractCanvasHandler> { @Override public void addControlPoint(final Edge candidate, final ControlPoint controlPoint, final int index) { selectionEvent.fire(new CanvasSelectionEvent(canvasHandler, candidate.getUUID())); execute(canvasCommandFactory.addControlPoint(candidate, controlPoint, index)); } @Inject ControlPointControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory,
final Event<CanvasSelectionEvent> selectionEvent); } | ControlPointControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements ControlPointControl<AbstractCanvasHandler> { @Override public void addControlPoint(final Edge candidate, final ControlPoint controlPoint, final int index) { selectionEvent.fire(new CanvasSelectionEvent(canvasHandler, candidate.getUUID())); execute(canvasCommandFactory.addControlPoint(candidate, controlPoint, index)); } @Inject ControlPointControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory,
final Event<CanvasSelectionEvent> selectionEvent); @Override void register(final Element element); @Override void addControlPoint(final Edge candidate,
final ControlPoint controlPoint,
final int index); @Override void updateControlPoints(final Edge candidate,
final ControlPoint[] controlPoints); @Override void deleteControlPoint(final Edge candidate,
final int index); @Override void setCommandManagerProvider(final CommandManagerProvider<AbstractCanvasHandler> provider); } | ControlPointControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements ControlPointControl<AbstractCanvasHandler> { @Override public void addControlPoint(final Edge candidate, final ControlPoint controlPoint, final int index) { selectionEvent.fire(new CanvasSelectionEvent(canvasHandler, candidate.getUUID())); execute(canvasCommandFactory.addControlPoint(candidate, controlPoint, index)); } @Inject ControlPointControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory,
final Event<CanvasSelectionEvent> selectionEvent); @Override void register(final Element element); @Override void addControlPoint(final Edge candidate,
final ControlPoint controlPoint,
final int index); @Override void updateControlPoints(final Edge candidate,
final ControlPoint[] controlPoints); @Override void deleteControlPoint(final Edge candidate,
final int index); @Override void setCommandManagerProvider(final CommandManagerProvider<AbstractCanvasHandler> provider); } |
@Test @SuppressWarnings("unchecked") public void testDeleteControlPoint() { CanvasCommand<AbstractCanvasHandler> deleteControlPointCommand = mock(CanvasCommand.class); doReturn(deleteControlPointCommand).when(canvasCommandFactory).deleteControlPoint(eq(edge), eq(0)); tested.init(canvasHandler); tested.deleteControlPoint(edge, 0); ArgumentCaptor<Command> commandArgumentCaptor = ArgumentCaptor.forClass(Command.class); verify(commandManager, times(1)).execute(eq(canvasHandler), commandArgumentCaptor.capture()); Command<AbstractCanvasHandler, CanvasViolation> command = commandArgumentCaptor.getValue(); assertEquals(deleteControlPointCommand, command); } | @Override public void deleteControlPoint(final Edge candidate, final int index) { execute(canvasCommandFactory.deleteControlPoint(candidate, index)); } | ControlPointControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements ControlPointControl<AbstractCanvasHandler> { @Override public void deleteControlPoint(final Edge candidate, final int index) { execute(canvasCommandFactory.deleteControlPoint(candidate, index)); } } | ControlPointControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements ControlPointControl<AbstractCanvasHandler> { @Override public void deleteControlPoint(final Edge candidate, final int index) { execute(canvasCommandFactory.deleteControlPoint(candidate, index)); } @Inject ControlPointControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory,
final Event<CanvasSelectionEvent> selectionEvent); } | ControlPointControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements ControlPointControl<AbstractCanvasHandler> { @Override public void deleteControlPoint(final Edge candidate, final int index) { execute(canvasCommandFactory.deleteControlPoint(candidate, index)); } @Inject ControlPointControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory,
final Event<CanvasSelectionEvent> selectionEvent); @Override void register(final Element element); @Override void addControlPoint(final Edge candidate,
final ControlPoint controlPoint,
final int index); @Override void updateControlPoints(final Edge candidate,
final ControlPoint[] controlPoints); @Override void deleteControlPoint(final Edge candidate,
final int index); @Override void setCommandManagerProvider(final CommandManagerProvider<AbstractCanvasHandler> provider); } | ControlPointControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements ControlPointControl<AbstractCanvasHandler> { @Override public void deleteControlPoint(final Edge candidate, final int index) { execute(canvasCommandFactory.deleteControlPoint(candidate, index)); } @Inject ControlPointControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory,
final Event<CanvasSelectionEvent> selectionEvent); @Override void register(final Element element); @Override void addControlPoint(final Edge candidate,
final ControlPoint controlPoint,
final int index); @Override void updateControlPoints(final Edge candidate,
final ControlPoint[] controlPoints); @Override void deleteControlPoint(final Edge candidate,
final int index); @Override void setCommandManagerProvider(final CommandManagerProvider<AbstractCanvasHandler> provider); } |
@Test public void testStunnerControlPointsAcceptorAdd() { final HandlerRegistration mouseUpHandlerRegistration = mock(HandlerRegistration.class); final NodeMouseUpHandler[] mouseUpHandlerCaptured = new NodeMouseUpHandler[1]; doAnswer(invocationOnMock -> { mouseUpHandlerCaptured[0] = (NodeMouseUpHandler) invocationOnMock.getArguments()[0]; mouseUpHandlerCaptured[0].onNodeMouseUp(mock(NodeMouseUpEvent.class)); return mouseUpHandlerRegistration; }).when(layer).addNodeMouseUpHandler(any(NodeMouseUpHandler.class)); ControlPointControl control = mock(ControlPointControl.class); ControlPointControlImpl.StunnerControlPointsAcceptor acceptor = createStunnerControlPointsAcceptor(control); boolean addResult = acceptor.add(connector, 1, new com.ait.lienzo.client.core.types.Point2D(2, 2)); assertTrue(addResult); verify(connector, times(1)).addControlPoint(eq(2d), eq(2d), eq(1)); verify(control, times(1)).addControlPoint(eq(edge), eq(ControlPoint.build(2, 2)), eq(0)); } | @Override public void addControlPoint(final Edge candidate, final ControlPoint controlPoint, final int index) { selectionEvent.fire(new CanvasSelectionEvent(canvasHandler, candidate.getUUID())); execute(canvasCommandFactory.addControlPoint(candidate, controlPoint, index)); } | ControlPointControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements ControlPointControl<AbstractCanvasHandler> { @Override public void addControlPoint(final Edge candidate, final ControlPoint controlPoint, final int index) { selectionEvent.fire(new CanvasSelectionEvent(canvasHandler, candidate.getUUID())); execute(canvasCommandFactory.addControlPoint(candidate, controlPoint, index)); } } | ControlPointControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements ControlPointControl<AbstractCanvasHandler> { @Override public void addControlPoint(final Edge candidate, final ControlPoint controlPoint, final int index) { selectionEvent.fire(new CanvasSelectionEvent(canvasHandler, candidate.getUUID())); execute(canvasCommandFactory.addControlPoint(candidate, controlPoint, index)); } @Inject ControlPointControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory,
final Event<CanvasSelectionEvent> selectionEvent); } | ControlPointControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements ControlPointControl<AbstractCanvasHandler> { @Override public void addControlPoint(final Edge candidate, final ControlPoint controlPoint, final int index) { selectionEvent.fire(new CanvasSelectionEvent(canvasHandler, candidate.getUUID())); execute(canvasCommandFactory.addControlPoint(candidate, controlPoint, index)); } @Inject ControlPointControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory,
final Event<CanvasSelectionEvent> selectionEvent); @Override void register(final Element element); @Override void addControlPoint(final Edge candidate,
final ControlPoint controlPoint,
final int index); @Override void updateControlPoints(final Edge candidate,
final ControlPoint[] controlPoints); @Override void deleteControlPoint(final Edge candidate,
final int index); @Override void setCommandManagerProvider(final CommandManagerProvider<AbstractCanvasHandler> provider); } | ControlPointControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements ControlPointControl<AbstractCanvasHandler> { @Override public void addControlPoint(final Edge candidate, final ControlPoint controlPoint, final int index) { selectionEvent.fire(new CanvasSelectionEvent(canvasHandler, candidate.getUUID())); execute(canvasCommandFactory.addControlPoint(candidate, controlPoint, index)); } @Inject ControlPointControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory,
final Event<CanvasSelectionEvent> selectionEvent); @Override void register(final Element element); @Override void addControlPoint(final Edge candidate,
final ControlPoint controlPoint,
final int index); @Override void updateControlPoints(final Edge candidate,
final ControlPoint[] controlPoints); @Override void deleteControlPoint(final Edge candidate,
final int index); @Override void setCommandManagerProvider(final CommandManagerProvider<AbstractCanvasHandler> provider); } |
@Test public void testView() { assertEquals(view, tested.getWidget()); } | @WorkbenchPartView @SuppressWarnings("unused") public IsWidget getWidget() { return view; } | PreviewDiagramScreen { @WorkbenchPartView @SuppressWarnings("unused") public IsWidget getWidget() { return view; } } | PreviewDiagramScreen { @WorkbenchPartView @SuppressWarnings("unused") public IsWidget getWidget() { return view; } protected PreviewDiagramScreen(); @Inject PreviewDiagramScreen(final SessionManager clientSessionManager,
final @Any @DMNEditor ManagedInstance<SessionDiagramPreview<AbstractSession>> sessionPreviews,
final View view,
final DMNDiagramsSession session); } | PreviewDiagramScreen { @WorkbenchPartView @SuppressWarnings("unused") public IsWidget getWidget() { return view; } protected PreviewDiagramScreen(); @Inject PreviewDiagramScreen(final SessionManager clientSessionManager,
final @Any @DMNEditor ManagedInstance<SessionDiagramPreview<AbstractSession>> sessionPreviews,
final View view,
final DMNDiagramsSession session); @OnStartup @SuppressWarnings("unused") void onStartup(final PlaceRequest placeRequest); @OnOpen @SuppressWarnings("unused") void onOpen(); @OnClose @SuppressWarnings("unused") void onClose(); @WorkbenchPartTitle @SuppressWarnings("unused") String getTitle(); @WorkbenchPartView @SuppressWarnings("unused") IsWidget getWidget(); @WorkbenchContextId @SuppressWarnings("unused") String getMyContextRef(); } | PreviewDiagramScreen { @WorkbenchPartView @SuppressWarnings("unused") public IsWidget getWidget() { return view; } protected PreviewDiagramScreen(); @Inject PreviewDiagramScreen(final SessionManager clientSessionManager,
final @Any @DMNEditor ManagedInstance<SessionDiagramPreview<AbstractSession>> sessionPreviews,
final View view,
final DMNDiagramsSession session); @OnStartup @SuppressWarnings("unused") void onStartup(final PlaceRequest placeRequest); @OnOpen @SuppressWarnings("unused") void onOpen(); @OnClose @SuppressWarnings("unused") void onClose(); @WorkbenchPartTitle @SuppressWarnings("unused") String getTitle(); @WorkbenchPartView @SuppressWarnings("unused") IsWidget getWidget(); @WorkbenchContextId @SuppressWarnings("unused") String getMyContextRef(); static final String SCREEN_ID; } |
@Test public void testStunnerControlPointsAcceptorDelete() { ControlPointControl control = mock(ControlPointControl.class); ControlPointControlImpl.StunnerControlPointsAcceptor acceptor = createStunnerControlPointsAcceptor(control); final boolean deleteResult = acceptor.delete(connector, 1); assertTrue(deleteResult); verify(control, times(1)).deleteControlPoint(eq(edge), eq(0)); } | @Override public void deleteControlPoint(final Edge candidate, final int index) { execute(canvasCommandFactory.deleteControlPoint(candidate, index)); } | ControlPointControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements ControlPointControl<AbstractCanvasHandler> { @Override public void deleteControlPoint(final Edge candidate, final int index) { execute(canvasCommandFactory.deleteControlPoint(candidate, index)); } } | ControlPointControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements ControlPointControl<AbstractCanvasHandler> { @Override public void deleteControlPoint(final Edge candidate, final int index) { execute(canvasCommandFactory.deleteControlPoint(candidate, index)); } @Inject ControlPointControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory,
final Event<CanvasSelectionEvent> selectionEvent); } | ControlPointControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements ControlPointControl<AbstractCanvasHandler> { @Override public void deleteControlPoint(final Edge candidate, final int index) { execute(canvasCommandFactory.deleteControlPoint(candidate, index)); } @Inject ControlPointControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory,
final Event<CanvasSelectionEvent> selectionEvent); @Override void register(final Element element); @Override void addControlPoint(final Edge candidate,
final ControlPoint controlPoint,
final int index); @Override void updateControlPoints(final Edge candidate,
final ControlPoint[] controlPoints); @Override void deleteControlPoint(final Edge candidate,
final int index); @Override void setCommandManagerProvider(final CommandManagerProvider<AbstractCanvasHandler> provider); } | ControlPointControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements ControlPointControl<AbstractCanvasHandler> { @Override public void deleteControlPoint(final Edge candidate, final int index) { execute(canvasCommandFactory.deleteControlPoint(candidate, index)); } @Inject ControlPointControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory,
final Event<CanvasSelectionEvent> selectionEvent); @Override void register(final Element element); @Override void addControlPoint(final Edge candidate,
final ControlPoint controlPoint,
final int index); @Override void updateControlPoints(final Edge candidate,
final ControlPoint[] controlPoints); @Override void deleteControlPoint(final Edge candidate,
final int index); @Override void setCommandManagerProvider(final CommandManagerProvider<AbstractCanvasHandler> provider); } |
@Test public void testStunnerControlPointsAcceptorMove() { ControlPointControl control = mock(ControlPointControl.class); ControlPointControlImpl.StunnerControlPointsAcceptor acceptor = createStunnerControlPointsAcceptor(control); Point2DArray locationArray = new Point2DArray(new com.ait.lienzo.client.core.types.Point2D(0, 0), new com.ait.lienzo.client.core.types.Point2D(5, 5), new com.ait.lienzo.client.core.types.Point2D(10, 10)); final boolean moveResult = acceptor.move(connector, locationArray); assertTrue(moveResult); ArgumentCaptor<ControlPoint[]> controlPointsExpected = ArgumentCaptor.forClass(ControlPoint[].class); verify(control, times(1)).updateControlPoints(eq(edge), controlPointsExpected.capture()); ControlPoint[] cps = controlPointsExpected.getValue(); assertNotNull(cps); assertEquals(1, cps.length); assertEquals(ControlPoint.build(5, 5), cps[0]); } | @Override public void updateControlPoints(final Edge candidate, final ControlPoint[] controlPoints) { execute(canvasCommandFactory.updateControlPointPosition(candidate, controlPoints)); } | ControlPointControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements ControlPointControl<AbstractCanvasHandler> { @Override public void updateControlPoints(final Edge candidate, final ControlPoint[] controlPoints) { execute(canvasCommandFactory.updateControlPointPosition(candidate, controlPoints)); } } | ControlPointControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements ControlPointControl<AbstractCanvasHandler> { @Override public void updateControlPoints(final Edge candidate, final ControlPoint[] controlPoints) { execute(canvasCommandFactory.updateControlPointPosition(candidate, controlPoints)); } @Inject ControlPointControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory,
final Event<CanvasSelectionEvent> selectionEvent); } | ControlPointControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements ControlPointControl<AbstractCanvasHandler> { @Override public void updateControlPoints(final Edge candidate, final ControlPoint[] controlPoints) { execute(canvasCommandFactory.updateControlPointPosition(candidate, controlPoints)); } @Inject ControlPointControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory,
final Event<CanvasSelectionEvent> selectionEvent); @Override void register(final Element element); @Override void addControlPoint(final Edge candidate,
final ControlPoint controlPoint,
final int index); @Override void updateControlPoints(final Edge candidate,
final ControlPoint[] controlPoints); @Override void deleteControlPoint(final Edge candidate,
final int index); @Override void setCommandManagerProvider(final CommandManagerProvider<AbstractCanvasHandler> provider); } | ControlPointControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements ControlPointControl<AbstractCanvasHandler> { @Override public void updateControlPoints(final Edge candidate, final ControlPoint[] controlPoints) { execute(canvasCommandFactory.updateControlPointPosition(candidate, controlPoints)); } @Inject ControlPointControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory,
final Event<CanvasSelectionEvent> selectionEvent); @Override void register(final Element element); @Override void addControlPoint(final Edge candidate,
final ControlPoint controlPoint,
final int index); @Override void updateControlPoints(final Edge candidate,
final ControlPoint[] controlPoints); @Override void deleteControlPoint(final Edge candidate,
final int index); @Override void setCommandManagerProvider(final CommandManagerProvider<AbstractCanvasHandler> provider); } |
@Test public void testRegisterAndSetBounds() { tested.init(canvasHandler); assertFalse(tested.isRegistered(element)); tested.register(element); assertTrue(tested.isRegistered(element)); verify(shapeView, times(1)).setDragEnabled(eq(true)); verify(shapeEventHandler, times(1)).supports(eq(ViewEventType.MOUSE_ENTER)); verify(shapeEventHandler, times(1)).addHandler(eq(ViewEventType.MOUSE_ENTER), any(MouseEnterHandler.class)); verify(shapeEventHandler, times(1)).supports(eq(ViewEventType.MOUSE_EXIT)); verify(shapeEventHandler, times(1)).addHandler(eq(ViewEventType.MOUSE_EXIT), any(MouseEnterHandler.class)); ArgumentCaptor<DragHandler> dragHandlerArgumentCaptor = forClass(DragHandler.class); verify(shapeEventHandler).addHandler(eq(ViewEventType.DRAG), dragHandlerArgumentCaptor.capture()); dragHandlerArgumentCaptor.getValue().start(mock(DragEvent.class)); dragHandlerArgumentCaptor.getValue().end(mock(DragEvent.class)); ArgumentCaptor<CanvasSelectionEvent> canvasSelectionEventArgumentCaptor = forClass(CanvasSelectionEvent.class); verify(canvasSelectionEvent).fire(canvasSelectionEventArgumentCaptor.capture()); assertTrue(canvasSelectionEventArgumentCaptor.getValue().getIdentifiers().contains(element.getUUID())); } | @Override @SuppressWarnings("unchecked") public void register(final Element element) { if (null != element.asNode() && checkNotRegistered(element)) { final AbstractCanvas<?> canvas = canvasHandler.getAbstractCanvas(); final Shape<?> shape = canvas.getShape(element.getUUID()); final ShapeView shapeView = shape.getShapeView(); shapeView.setDragEnabled(true); ensureDragConstraints(canvas, shapeView); if (shape.getShapeView() instanceof HasEventHandlers) { final HasEventHandlers hasEventHandlers = (HasEventHandlers) shapeView; if (supportsMouseEnter(hasEventHandlers) && supportsMouseExit(hasEventHandlers)) { final MouseEnterHandler overHandler = new MouseEnterHandler() { @Override public void handle(MouseEnterEvent event) { canvasHandler.getAbstractCanvas().getView().setCursor(AbstractCanvas.Cursors.MOVE); } }; hasEventHandlers.addHandler(ViewEventType.MOUSE_ENTER, overHandler); registerHandler(shape.getUUID(), overHandler); final MouseExitHandler outHandler = new MouseExitHandler() { @Override public void handle(MouseExitEvent event) { canvasHandler.getAbstractCanvas().getView().setCursor(AbstractCanvas.Cursors.DEFAULT); } }; hasEventHandlers.addHandler(ViewEventType.MOUSE_EXIT, outHandler); registerHandler(shape.getUUID(), outHandler); final DragHandler dragHandler = new DragHandler() { @Override public void start(DragEvent event) { } @Override public void end(DragEvent event) { selectionEvent.fire(new CanvasSelectionEvent(canvasHandler, shape.getUUID())); } @Override public void handle(DragEvent event) { } }; hasEventHandlers.addHandler(ViewEventType.DRAG, dragHandler); registerHandler(shape.getUUID(), dragHandler); } } } } | LocationControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements LocationControl<AbstractCanvasHandler, Element>,
CanvasControl.SessionAware<EditorSession> { @Override @SuppressWarnings("unchecked") public void register(final Element element) { if (null != element.asNode() && checkNotRegistered(element)) { final AbstractCanvas<?> canvas = canvasHandler.getAbstractCanvas(); final Shape<?> shape = canvas.getShape(element.getUUID()); final ShapeView shapeView = shape.getShapeView(); shapeView.setDragEnabled(true); ensureDragConstraints(canvas, shapeView); if (shape.getShapeView() instanceof HasEventHandlers) { final HasEventHandlers hasEventHandlers = (HasEventHandlers) shapeView; if (supportsMouseEnter(hasEventHandlers) && supportsMouseExit(hasEventHandlers)) { final MouseEnterHandler overHandler = new MouseEnterHandler() { @Override public void handle(MouseEnterEvent event) { canvasHandler.getAbstractCanvas().getView().setCursor(AbstractCanvas.Cursors.MOVE); } }; hasEventHandlers.addHandler(ViewEventType.MOUSE_ENTER, overHandler); registerHandler(shape.getUUID(), overHandler); final MouseExitHandler outHandler = new MouseExitHandler() { @Override public void handle(MouseExitEvent event) { canvasHandler.getAbstractCanvas().getView().setCursor(AbstractCanvas.Cursors.DEFAULT); } }; hasEventHandlers.addHandler(ViewEventType.MOUSE_EXIT, outHandler); registerHandler(shape.getUUID(), outHandler); final DragHandler dragHandler = new DragHandler() { @Override public void start(DragEvent event) { } @Override public void end(DragEvent event) { selectionEvent.fire(new CanvasSelectionEvent(canvasHandler, shape.getUUID())); } @Override public void handle(DragEvent event) { } }; hasEventHandlers.addHandler(ViewEventType.DRAG, dragHandler); registerHandler(shape.getUUID(), dragHandler); } } } } } | LocationControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements LocationControl<AbstractCanvasHandler, Element>,
CanvasControl.SessionAware<EditorSession> { @Override @SuppressWarnings("unchecked") public void register(final Element element) { if (null != element.asNode() && checkNotRegistered(element)) { final AbstractCanvas<?> canvas = canvasHandler.getAbstractCanvas(); final Shape<?> shape = canvas.getShape(element.getUUID()); final ShapeView shapeView = shape.getShapeView(); shapeView.setDragEnabled(true); ensureDragConstraints(canvas, shapeView); if (shape.getShapeView() instanceof HasEventHandlers) { final HasEventHandlers hasEventHandlers = (HasEventHandlers) shapeView; if (supportsMouseEnter(hasEventHandlers) && supportsMouseExit(hasEventHandlers)) { final MouseEnterHandler overHandler = new MouseEnterHandler() { @Override public void handle(MouseEnterEvent event) { canvasHandler.getAbstractCanvas().getView().setCursor(AbstractCanvas.Cursors.MOVE); } }; hasEventHandlers.addHandler(ViewEventType.MOUSE_ENTER, overHandler); registerHandler(shape.getUUID(), overHandler); final MouseExitHandler outHandler = new MouseExitHandler() { @Override public void handle(MouseExitEvent event) { canvasHandler.getAbstractCanvas().getView().setCursor(AbstractCanvas.Cursors.DEFAULT); } }; hasEventHandlers.addHandler(ViewEventType.MOUSE_EXIT, outHandler); registerHandler(shape.getUUID(), outHandler); final DragHandler dragHandler = new DragHandler() { @Override public void start(DragEvent event) { } @Override public void end(DragEvent event) { selectionEvent.fire(new CanvasSelectionEvent(canvasHandler, shape.getUUID())); } @Override public void handle(DragEvent event) { } }; hasEventHandlers.addHandler(ViewEventType.DRAG, dragHandler); registerHandler(shape.getUUID(), dragHandler); } } } } protected LocationControlImpl(); @Inject LocationControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory,
final Event<ShapeLocationsChangedEvent> shapeLocationsChangedEvent,
final Event<CanvasSelectionEvent> selectionEvent); } | LocationControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements LocationControl<AbstractCanvasHandler, Element>,
CanvasControl.SessionAware<EditorSession> { @Override @SuppressWarnings("unchecked") public void register(final Element element) { if (null != element.asNode() && checkNotRegistered(element)) { final AbstractCanvas<?> canvas = canvasHandler.getAbstractCanvas(); final Shape<?> shape = canvas.getShape(element.getUUID()); final ShapeView shapeView = shape.getShapeView(); shapeView.setDragEnabled(true); ensureDragConstraints(canvas, shapeView); if (shape.getShapeView() instanceof HasEventHandlers) { final HasEventHandlers hasEventHandlers = (HasEventHandlers) shapeView; if (supportsMouseEnter(hasEventHandlers) && supportsMouseExit(hasEventHandlers)) { final MouseEnterHandler overHandler = new MouseEnterHandler() { @Override public void handle(MouseEnterEvent event) { canvasHandler.getAbstractCanvas().getView().setCursor(AbstractCanvas.Cursors.MOVE); } }; hasEventHandlers.addHandler(ViewEventType.MOUSE_ENTER, overHandler); registerHandler(shape.getUUID(), overHandler); final MouseExitHandler outHandler = new MouseExitHandler() { @Override public void handle(MouseExitEvent event) { canvasHandler.getAbstractCanvas().getView().setCursor(AbstractCanvas.Cursors.DEFAULT); } }; hasEventHandlers.addHandler(ViewEventType.MOUSE_EXIT, outHandler); registerHandler(shape.getUUID(), outHandler); final DragHandler dragHandler = new DragHandler() { @Override public void start(DragEvent event) { } @Override public void end(DragEvent event) { selectionEvent.fire(new CanvasSelectionEvent(canvasHandler, shape.getUUID())); } @Override public void handle(DragEvent event) { } }; hasEventHandlers.addHandler(ViewEventType.DRAG, dragHandler); registerHandler(shape.getUUID(), dragHandler); } } } } protected LocationControlImpl(); @Inject LocationControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory,
final Event<ShapeLocationsChangedEvent> shapeLocationsChangedEvent,
final Event<CanvasSelectionEvent> selectionEvent); Collection<String> getSelectedIDs(); @Override void bind(final EditorSession session); void handleArrowKeys(final Key... keys); @Override void setCommandManagerProvider(final CommandManagerProvider<AbstractCanvasHandler> provider); @Override @SuppressWarnings("unchecked") void register(final Element element); @Override @SuppressWarnings("unchecked") CommandResult<CanvasViolation> move(final Element[] elements,
final Point2D[] locations); } | LocationControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements LocationControl<AbstractCanvasHandler, Element>,
CanvasControl.SessionAware<EditorSession> { @Override @SuppressWarnings("unchecked") public void register(final Element element) { if (null != element.asNode() && checkNotRegistered(element)) { final AbstractCanvas<?> canvas = canvasHandler.getAbstractCanvas(); final Shape<?> shape = canvas.getShape(element.getUUID()); final ShapeView shapeView = shape.getShapeView(); shapeView.setDragEnabled(true); ensureDragConstraints(canvas, shapeView); if (shape.getShapeView() instanceof HasEventHandlers) { final HasEventHandlers hasEventHandlers = (HasEventHandlers) shapeView; if (supportsMouseEnter(hasEventHandlers) && supportsMouseExit(hasEventHandlers)) { final MouseEnterHandler overHandler = new MouseEnterHandler() { @Override public void handle(MouseEnterEvent event) { canvasHandler.getAbstractCanvas().getView().setCursor(AbstractCanvas.Cursors.MOVE); } }; hasEventHandlers.addHandler(ViewEventType.MOUSE_ENTER, overHandler); registerHandler(shape.getUUID(), overHandler); final MouseExitHandler outHandler = new MouseExitHandler() { @Override public void handle(MouseExitEvent event) { canvasHandler.getAbstractCanvas().getView().setCursor(AbstractCanvas.Cursors.DEFAULT); } }; hasEventHandlers.addHandler(ViewEventType.MOUSE_EXIT, outHandler); registerHandler(shape.getUUID(), outHandler); final DragHandler dragHandler = new DragHandler() { @Override public void start(DragEvent event) { } @Override public void end(DragEvent event) { selectionEvent.fire(new CanvasSelectionEvent(canvasHandler, shape.getUUID())); } @Override public void handle(DragEvent event) { } }; hasEventHandlers.addHandler(ViewEventType.DRAG, dragHandler); registerHandler(shape.getUUID(), dragHandler); } } } } protected LocationControlImpl(); @Inject LocationControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory,
final Event<ShapeLocationsChangedEvent> shapeLocationsChangedEvent,
final Event<CanvasSelectionEvent> selectionEvent); Collection<String> getSelectedIDs(); @Override void bind(final EditorSession session); void handleArrowKeys(final Key... keys); @Override void setCommandManagerProvider(final CommandManagerProvider<AbstractCanvasHandler> provider); @Override @SuppressWarnings("unchecked") void register(final Element element); @Override @SuppressWarnings("unchecked") CommandResult<CanvasViolation> move(final Element[] elements,
final Point2D[] locations); } |
@Test @SuppressWarnings("unchecked") public void testMove() throws Exception { final WiresShapeView wiresShape = mock(WiresShapeView.class); final WiresShapeView childWiresShape = mock(WiresShapeView.class); final MagnetManager.Magnets magnets = mock(MagnetManager.Magnets.class); final WiresMagnet magnet = mock(WiresMagnet.class); final WiresConnection connection = mock(WiresConnection.class); final NFastArrayList<WiresConnection> connections = new NFastArrayList<>(connection); final WiresConnector connector = mock(WiresConnector.class); final String connectorUUID = UUID.uuid(); final NFastArrayList<WiresShape> children = new NFastArrayList<>(childWiresShape); final Group connectorGroup = mock(Group.class); final Edge connectorEdge = mock(Edge.class); final com.ait.lienzo.client.core.types.Point2D controlPointLienzo = new com.ait.lienzo.client.core.types.Point2D(100, 100); final Point2DArray controlPointsLienzo = new Point2DArray(controlPointLienzo); final ViewConnector viewConnector = mock(ViewConnector.class); Group parentGroup = mock(Group.class); BoundingBox parentBB = new BoundingBox(0, 0, 200, 200); MultiPath head = mock(MultiPath.class); MultiPath tail = mock(MultiPath.class); when(childWiresShape.getMagnets()).thenReturn(magnets); when(childWiresShape.getParent()).thenReturn(wiresShape); when(wiresShape.getGroup()).thenReturn(parentGroup); when(parentGroup.getBoundingBox()).thenReturn(parentBB); when(wiresShape.getX()).thenReturn(0d); when(wiresShape.getY()).thenReturn(0d); when(magnets.size()).thenReturn(1); when(magnets.getMagnet(0)).thenReturn(magnet); when(magnet.getConnectionsSize()).thenReturn(connections.size()); when(magnet.getConnections()).thenReturn(connections); when(connection.getConnector()).thenReturn(connector); when(connector.getGroup()).thenReturn(connectorGroup); when(connectorGroup.uuid()).thenReturn(connectorUUID); when(connector.getControlPoints()).thenReturn(controlPointsLienzo); when(connector.getHead()).thenReturn(head); when(connector.getTail()).thenReturn(tail); when(head.getLocation()).thenReturn(new com.ait.lienzo.client.core.types.Point2D(1, 1)); when(tail.getLocation()).thenReturn(new com.ait.lienzo.client.core.types.Point2D(2, 2)); when(wiresShape.getChildShapes()).thenReturn(children); when(shape.getShapeView()).thenReturn(wiresShape); when(graphIndex.getEdge(connectorUUID)).thenReturn(connectorEdge); when(connectorEdge.getContent()).thenReturn(viewConnector); when(connectorGroup.getUserData()).thenReturn(new WiresUtils.UserData(connectorUUID, "")); tested.init(canvasHandler); tested.register(element); Point2D location = new Point2D(45d, 65.5d); tested.move(new Element[]{element}, new Point2D[]{location}); ArgumentCaptor<CanvasCommand> commandArgumentCaptor = forClass(CanvasCommand.class); verify(commandManager, times(1)).execute(eq(canvasHandler), commandArgumentCaptor.capture()); ArgumentCaptor<ShapeLocationsChangedEvent> shapeLocationsChangedEventCaptor = forClass(ShapeLocationsChangedEvent.class); verify(shapeLocationsChangedEvent, times(1)).fire(shapeLocationsChangedEventCaptor.capture()); assertTrue(shapeLocationsChangedEventCaptor.getValue() instanceof ShapeLocationsChangedEvent); final CompositeCommand command = (CompositeCommand) commandArgumentCaptor.getValue(); UpdateElementPositionCommand updateElementPositionCommand = (UpdateElementPositionCommand) command.getCommands().get(0); assertEquals(element, updateElementPositionCommand.getElement()); assertEquals(location, updateElementPositionCommand.getLocation()); } | @Override @SuppressWarnings("unchecked") public CommandResult<CanvasViolation> move(final Element[] elements, final Point2D[] locations) { if (elements.length != locations.length) { throw new IllegalArgumentException("The length for the elements to move " + "does not match the locations provided."); } final CompositeCommand.Builder<AbstractCanvasHandler, CanvasViolation> builder = new CompositeCommand.Builder<AbstractCanvasHandler, CanvasViolation>() .forward(); for (int i = 0; i < elements.length; i++) { final Element element = elements[i]; builder.addCommand(createMoveCommand(element, locations[i])); } final Command<AbstractCanvasHandler, CanvasViolation> command = builder.build(); CommandResult<CanvasViolation> result = getCommandManager().allow(canvasHandler, command); if (!CommandUtils.isError(result)) { result = getCommandManager().execute(canvasHandler, command); if (!CommandUtils.isError(result)) { List<String> uuids = Arrays.stream(elements).map(Element::getUUID).collect(Collectors.toList()); shapeLocationsChangedEvent.fire(new ShapeLocationsChangedEvent(uuids, canvasHandler)); } } return result; } | LocationControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements LocationControl<AbstractCanvasHandler, Element>,
CanvasControl.SessionAware<EditorSession> { @Override @SuppressWarnings("unchecked") public CommandResult<CanvasViolation> move(final Element[] elements, final Point2D[] locations) { if (elements.length != locations.length) { throw new IllegalArgumentException("The length for the elements to move " + "does not match the locations provided."); } final CompositeCommand.Builder<AbstractCanvasHandler, CanvasViolation> builder = new CompositeCommand.Builder<AbstractCanvasHandler, CanvasViolation>() .forward(); for (int i = 0; i < elements.length; i++) { final Element element = elements[i]; builder.addCommand(createMoveCommand(element, locations[i])); } final Command<AbstractCanvasHandler, CanvasViolation> command = builder.build(); CommandResult<CanvasViolation> result = getCommandManager().allow(canvasHandler, command); if (!CommandUtils.isError(result)) { result = getCommandManager().execute(canvasHandler, command); if (!CommandUtils.isError(result)) { List<String> uuids = Arrays.stream(elements).map(Element::getUUID).collect(Collectors.toList()); shapeLocationsChangedEvent.fire(new ShapeLocationsChangedEvent(uuids, canvasHandler)); } } return result; } } | LocationControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements LocationControl<AbstractCanvasHandler, Element>,
CanvasControl.SessionAware<EditorSession> { @Override @SuppressWarnings("unchecked") public CommandResult<CanvasViolation> move(final Element[] elements, final Point2D[] locations) { if (elements.length != locations.length) { throw new IllegalArgumentException("The length for the elements to move " + "does not match the locations provided."); } final CompositeCommand.Builder<AbstractCanvasHandler, CanvasViolation> builder = new CompositeCommand.Builder<AbstractCanvasHandler, CanvasViolation>() .forward(); for (int i = 0; i < elements.length; i++) { final Element element = elements[i]; builder.addCommand(createMoveCommand(element, locations[i])); } final Command<AbstractCanvasHandler, CanvasViolation> command = builder.build(); CommandResult<CanvasViolation> result = getCommandManager().allow(canvasHandler, command); if (!CommandUtils.isError(result)) { result = getCommandManager().execute(canvasHandler, command); if (!CommandUtils.isError(result)) { List<String> uuids = Arrays.stream(elements).map(Element::getUUID).collect(Collectors.toList()); shapeLocationsChangedEvent.fire(new ShapeLocationsChangedEvent(uuids, canvasHandler)); } } return result; } protected LocationControlImpl(); @Inject LocationControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory,
final Event<ShapeLocationsChangedEvent> shapeLocationsChangedEvent,
final Event<CanvasSelectionEvent> selectionEvent); } | LocationControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements LocationControl<AbstractCanvasHandler, Element>,
CanvasControl.SessionAware<EditorSession> { @Override @SuppressWarnings("unchecked") public CommandResult<CanvasViolation> move(final Element[] elements, final Point2D[] locations) { if (elements.length != locations.length) { throw new IllegalArgumentException("The length for the elements to move " + "does not match the locations provided."); } final CompositeCommand.Builder<AbstractCanvasHandler, CanvasViolation> builder = new CompositeCommand.Builder<AbstractCanvasHandler, CanvasViolation>() .forward(); for (int i = 0; i < elements.length; i++) { final Element element = elements[i]; builder.addCommand(createMoveCommand(element, locations[i])); } final Command<AbstractCanvasHandler, CanvasViolation> command = builder.build(); CommandResult<CanvasViolation> result = getCommandManager().allow(canvasHandler, command); if (!CommandUtils.isError(result)) { result = getCommandManager().execute(canvasHandler, command); if (!CommandUtils.isError(result)) { List<String> uuids = Arrays.stream(elements).map(Element::getUUID).collect(Collectors.toList()); shapeLocationsChangedEvent.fire(new ShapeLocationsChangedEvent(uuids, canvasHandler)); } } return result; } protected LocationControlImpl(); @Inject LocationControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory,
final Event<ShapeLocationsChangedEvent> shapeLocationsChangedEvent,
final Event<CanvasSelectionEvent> selectionEvent); Collection<String> getSelectedIDs(); @Override void bind(final EditorSession session); void handleArrowKeys(final Key... keys); @Override void setCommandManagerProvider(final CommandManagerProvider<AbstractCanvasHandler> provider); @Override @SuppressWarnings("unchecked") void register(final Element element); @Override @SuppressWarnings("unchecked") CommandResult<CanvasViolation> move(final Element[] elements,
final Point2D[] locations); } | LocationControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements LocationControl<AbstractCanvasHandler, Element>,
CanvasControl.SessionAware<EditorSession> { @Override @SuppressWarnings("unchecked") public CommandResult<CanvasViolation> move(final Element[] elements, final Point2D[] locations) { if (elements.length != locations.length) { throw new IllegalArgumentException("The length for the elements to move " + "does not match the locations provided."); } final CompositeCommand.Builder<AbstractCanvasHandler, CanvasViolation> builder = new CompositeCommand.Builder<AbstractCanvasHandler, CanvasViolation>() .forward(); for (int i = 0; i < elements.length; i++) { final Element element = elements[i]; builder.addCommand(createMoveCommand(element, locations[i])); } final Command<AbstractCanvasHandler, CanvasViolation> command = builder.build(); CommandResult<CanvasViolation> result = getCommandManager().allow(canvasHandler, command); if (!CommandUtils.isError(result)) { result = getCommandManager().execute(canvasHandler, command); if (!CommandUtils.isError(result)) { List<String> uuids = Arrays.stream(elements).map(Element::getUUID).collect(Collectors.toList()); shapeLocationsChangedEvent.fire(new ShapeLocationsChangedEvent(uuids, canvasHandler)); } } return result; } protected LocationControlImpl(); @Inject LocationControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory,
final Event<ShapeLocationsChangedEvent> shapeLocationsChangedEvent,
final Event<CanvasSelectionEvent> selectionEvent); Collection<String> getSelectedIDs(); @Override void bind(final EditorSession session); void handleArrowKeys(final Key... keys); @Override void setCommandManagerProvider(final CommandManagerProvider<AbstractCanvasHandler> provider); @Override @SuppressWarnings("unchecked") void register(final Element element); @Override @SuppressWarnings("unchecked") CommandResult<CanvasViolation> move(final Element[] elements,
final Point2D[] locations); } |
@Test @SuppressWarnings("unchecked") public void testLocationAcceptor() { tested.init(canvasHandler); tested.register(element); ArgumentCaptor<ILocationAcceptor> locationAcceptorArgumentCaptor = ArgumentCaptor.forClass(ILocationAcceptor.class); verify(wiresManager, times(1)).setLocationAcceptor(locationAcceptorArgumentCaptor.capture()); final ILocationAcceptor locationAcceptor = locationAcceptorArgumentCaptor.getValue(); final WiresShapeView wiresContainer = mock(WiresShapeView.class); when(wiresContainer.getUUID()).thenReturn(ELEMENT_UUID); final com.ait.lienzo.client.core.types.Point2D point = new com.ait.lienzo.client.core.types.Point2D(40d, 50d); locationAcceptor.accept(new WiresContainer[]{wiresContainer}, new com.ait.lienzo.client.core.types.Point2D[]{point}); ArgumentCaptor<CanvasCommand> commandArgumentCaptor = forClass(CanvasCommand.class); verify(commandManager, times(1)).execute(eq(canvasHandler), commandArgumentCaptor.capture()); final CompositeCommand command = (CompositeCommand) commandArgumentCaptor.getValue(); UpdateElementPositionCommand updateElementPositionCommand = (UpdateElementPositionCommand) command.getCommands().get(0); assertEquals(element, updateElementPositionCommand.getElement()); assertEquals(new Point2D(40d, 50d), updateElementPositionCommand.getLocation()); } | @Override @SuppressWarnings("unchecked") public void register(final Element element) { if (null != element.asNode() && checkNotRegistered(element)) { final AbstractCanvas<?> canvas = canvasHandler.getAbstractCanvas(); final Shape<?> shape = canvas.getShape(element.getUUID()); final ShapeView shapeView = shape.getShapeView(); shapeView.setDragEnabled(true); ensureDragConstraints(canvas, shapeView); if (shape.getShapeView() instanceof HasEventHandlers) { final HasEventHandlers hasEventHandlers = (HasEventHandlers) shapeView; if (supportsMouseEnter(hasEventHandlers) && supportsMouseExit(hasEventHandlers)) { final MouseEnterHandler overHandler = new MouseEnterHandler() { @Override public void handle(MouseEnterEvent event) { canvasHandler.getAbstractCanvas().getView().setCursor(AbstractCanvas.Cursors.MOVE); } }; hasEventHandlers.addHandler(ViewEventType.MOUSE_ENTER, overHandler); registerHandler(shape.getUUID(), overHandler); final MouseExitHandler outHandler = new MouseExitHandler() { @Override public void handle(MouseExitEvent event) { canvasHandler.getAbstractCanvas().getView().setCursor(AbstractCanvas.Cursors.DEFAULT); } }; hasEventHandlers.addHandler(ViewEventType.MOUSE_EXIT, outHandler); registerHandler(shape.getUUID(), outHandler); final DragHandler dragHandler = new DragHandler() { @Override public void start(DragEvent event) { } @Override public void end(DragEvent event) { selectionEvent.fire(new CanvasSelectionEvent(canvasHandler, shape.getUUID())); } @Override public void handle(DragEvent event) { } }; hasEventHandlers.addHandler(ViewEventType.DRAG, dragHandler); registerHandler(shape.getUUID(), dragHandler); } } } } | LocationControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements LocationControl<AbstractCanvasHandler, Element>,
CanvasControl.SessionAware<EditorSession> { @Override @SuppressWarnings("unchecked") public void register(final Element element) { if (null != element.asNode() && checkNotRegistered(element)) { final AbstractCanvas<?> canvas = canvasHandler.getAbstractCanvas(); final Shape<?> shape = canvas.getShape(element.getUUID()); final ShapeView shapeView = shape.getShapeView(); shapeView.setDragEnabled(true); ensureDragConstraints(canvas, shapeView); if (shape.getShapeView() instanceof HasEventHandlers) { final HasEventHandlers hasEventHandlers = (HasEventHandlers) shapeView; if (supportsMouseEnter(hasEventHandlers) && supportsMouseExit(hasEventHandlers)) { final MouseEnterHandler overHandler = new MouseEnterHandler() { @Override public void handle(MouseEnterEvent event) { canvasHandler.getAbstractCanvas().getView().setCursor(AbstractCanvas.Cursors.MOVE); } }; hasEventHandlers.addHandler(ViewEventType.MOUSE_ENTER, overHandler); registerHandler(shape.getUUID(), overHandler); final MouseExitHandler outHandler = new MouseExitHandler() { @Override public void handle(MouseExitEvent event) { canvasHandler.getAbstractCanvas().getView().setCursor(AbstractCanvas.Cursors.DEFAULT); } }; hasEventHandlers.addHandler(ViewEventType.MOUSE_EXIT, outHandler); registerHandler(shape.getUUID(), outHandler); final DragHandler dragHandler = new DragHandler() { @Override public void start(DragEvent event) { } @Override public void end(DragEvent event) { selectionEvent.fire(new CanvasSelectionEvent(canvasHandler, shape.getUUID())); } @Override public void handle(DragEvent event) { } }; hasEventHandlers.addHandler(ViewEventType.DRAG, dragHandler); registerHandler(shape.getUUID(), dragHandler); } } } } } | LocationControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements LocationControl<AbstractCanvasHandler, Element>,
CanvasControl.SessionAware<EditorSession> { @Override @SuppressWarnings("unchecked") public void register(final Element element) { if (null != element.asNode() && checkNotRegistered(element)) { final AbstractCanvas<?> canvas = canvasHandler.getAbstractCanvas(); final Shape<?> shape = canvas.getShape(element.getUUID()); final ShapeView shapeView = shape.getShapeView(); shapeView.setDragEnabled(true); ensureDragConstraints(canvas, shapeView); if (shape.getShapeView() instanceof HasEventHandlers) { final HasEventHandlers hasEventHandlers = (HasEventHandlers) shapeView; if (supportsMouseEnter(hasEventHandlers) && supportsMouseExit(hasEventHandlers)) { final MouseEnterHandler overHandler = new MouseEnterHandler() { @Override public void handle(MouseEnterEvent event) { canvasHandler.getAbstractCanvas().getView().setCursor(AbstractCanvas.Cursors.MOVE); } }; hasEventHandlers.addHandler(ViewEventType.MOUSE_ENTER, overHandler); registerHandler(shape.getUUID(), overHandler); final MouseExitHandler outHandler = new MouseExitHandler() { @Override public void handle(MouseExitEvent event) { canvasHandler.getAbstractCanvas().getView().setCursor(AbstractCanvas.Cursors.DEFAULT); } }; hasEventHandlers.addHandler(ViewEventType.MOUSE_EXIT, outHandler); registerHandler(shape.getUUID(), outHandler); final DragHandler dragHandler = new DragHandler() { @Override public void start(DragEvent event) { } @Override public void end(DragEvent event) { selectionEvent.fire(new CanvasSelectionEvent(canvasHandler, shape.getUUID())); } @Override public void handle(DragEvent event) { } }; hasEventHandlers.addHandler(ViewEventType.DRAG, dragHandler); registerHandler(shape.getUUID(), dragHandler); } } } } protected LocationControlImpl(); @Inject LocationControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory,
final Event<ShapeLocationsChangedEvent> shapeLocationsChangedEvent,
final Event<CanvasSelectionEvent> selectionEvent); } | LocationControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements LocationControl<AbstractCanvasHandler, Element>,
CanvasControl.SessionAware<EditorSession> { @Override @SuppressWarnings("unchecked") public void register(final Element element) { if (null != element.asNode() && checkNotRegistered(element)) { final AbstractCanvas<?> canvas = canvasHandler.getAbstractCanvas(); final Shape<?> shape = canvas.getShape(element.getUUID()); final ShapeView shapeView = shape.getShapeView(); shapeView.setDragEnabled(true); ensureDragConstraints(canvas, shapeView); if (shape.getShapeView() instanceof HasEventHandlers) { final HasEventHandlers hasEventHandlers = (HasEventHandlers) shapeView; if (supportsMouseEnter(hasEventHandlers) && supportsMouseExit(hasEventHandlers)) { final MouseEnterHandler overHandler = new MouseEnterHandler() { @Override public void handle(MouseEnterEvent event) { canvasHandler.getAbstractCanvas().getView().setCursor(AbstractCanvas.Cursors.MOVE); } }; hasEventHandlers.addHandler(ViewEventType.MOUSE_ENTER, overHandler); registerHandler(shape.getUUID(), overHandler); final MouseExitHandler outHandler = new MouseExitHandler() { @Override public void handle(MouseExitEvent event) { canvasHandler.getAbstractCanvas().getView().setCursor(AbstractCanvas.Cursors.DEFAULT); } }; hasEventHandlers.addHandler(ViewEventType.MOUSE_EXIT, outHandler); registerHandler(shape.getUUID(), outHandler); final DragHandler dragHandler = new DragHandler() { @Override public void start(DragEvent event) { } @Override public void end(DragEvent event) { selectionEvent.fire(new CanvasSelectionEvent(canvasHandler, shape.getUUID())); } @Override public void handle(DragEvent event) { } }; hasEventHandlers.addHandler(ViewEventType.DRAG, dragHandler); registerHandler(shape.getUUID(), dragHandler); } } } } protected LocationControlImpl(); @Inject LocationControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory,
final Event<ShapeLocationsChangedEvent> shapeLocationsChangedEvent,
final Event<CanvasSelectionEvent> selectionEvent); Collection<String> getSelectedIDs(); @Override void bind(final EditorSession session); void handleArrowKeys(final Key... keys); @Override void setCommandManagerProvider(final CommandManagerProvider<AbstractCanvasHandler> provider); @Override @SuppressWarnings("unchecked") void register(final Element element); @Override @SuppressWarnings("unchecked") CommandResult<CanvasViolation> move(final Element[] elements,
final Point2D[] locations); } | LocationControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements LocationControl<AbstractCanvasHandler, Element>,
CanvasControl.SessionAware<EditorSession> { @Override @SuppressWarnings("unchecked") public void register(final Element element) { if (null != element.asNode() && checkNotRegistered(element)) { final AbstractCanvas<?> canvas = canvasHandler.getAbstractCanvas(); final Shape<?> shape = canvas.getShape(element.getUUID()); final ShapeView shapeView = shape.getShapeView(); shapeView.setDragEnabled(true); ensureDragConstraints(canvas, shapeView); if (shape.getShapeView() instanceof HasEventHandlers) { final HasEventHandlers hasEventHandlers = (HasEventHandlers) shapeView; if (supportsMouseEnter(hasEventHandlers) && supportsMouseExit(hasEventHandlers)) { final MouseEnterHandler overHandler = new MouseEnterHandler() { @Override public void handle(MouseEnterEvent event) { canvasHandler.getAbstractCanvas().getView().setCursor(AbstractCanvas.Cursors.MOVE); } }; hasEventHandlers.addHandler(ViewEventType.MOUSE_ENTER, overHandler); registerHandler(shape.getUUID(), overHandler); final MouseExitHandler outHandler = new MouseExitHandler() { @Override public void handle(MouseExitEvent event) { canvasHandler.getAbstractCanvas().getView().setCursor(AbstractCanvas.Cursors.DEFAULT); } }; hasEventHandlers.addHandler(ViewEventType.MOUSE_EXIT, outHandler); registerHandler(shape.getUUID(), outHandler); final DragHandler dragHandler = new DragHandler() { @Override public void start(DragEvent event) { } @Override public void end(DragEvent event) { selectionEvent.fire(new CanvasSelectionEvent(canvasHandler, shape.getUUID())); } @Override public void handle(DragEvent event) { } }; hasEventHandlers.addHandler(ViewEventType.DRAG, dragHandler); registerHandler(shape.getUUID(), dragHandler); } } } } protected LocationControlImpl(); @Inject LocationControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory,
final Event<ShapeLocationsChangedEvent> shapeLocationsChangedEvent,
final Event<CanvasSelectionEvent> selectionEvent); Collection<String> getSelectedIDs(); @Override void bind(final EditorSession session); void handleArrowKeys(final Key... keys); @Override void setCommandManagerProvider(final CommandManagerProvider<AbstractCanvasHandler> provider); @Override @SuppressWarnings("unchecked") void register(final Element element); @Override @SuppressWarnings("unchecked") CommandResult<CanvasViolation> move(final Element[] elements,
final Point2D[] locations); } |
@Test public void testEnsureDragConstraints() throws Exception { tested.init(canvasHandler); Bounds bounds = Bounds.create(0d, 0d, 600d, 600d); when(canvasPanel.getLocationConstraints()).thenReturn(bounds); tested.register(element); verify(shapeView, times(1)).setDragBounds(eq(bounds)); } | @SuppressWarnings("unchecked") private static void ensureDragConstraints(final AbstractCanvas<?> canvas, final ShapeView shapeView) { final Bounds bounds = canvas.getView().getPanel().getLocationConstraints(); ShapeUtils.enforceLocationConstraints(shapeView, bounds); } | LocationControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements LocationControl<AbstractCanvasHandler, Element>,
CanvasControl.SessionAware<EditorSession> { @SuppressWarnings("unchecked") private static void ensureDragConstraints(final AbstractCanvas<?> canvas, final ShapeView shapeView) { final Bounds bounds = canvas.getView().getPanel().getLocationConstraints(); ShapeUtils.enforceLocationConstraints(shapeView, bounds); } } | LocationControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements LocationControl<AbstractCanvasHandler, Element>,
CanvasControl.SessionAware<EditorSession> { @SuppressWarnings("unchecked") private static void ensureDragConstraints(final AbstractCanvas<?> canvas, final ShapeView shapeView) { final Bounds bounds = canvas.getView().getPanel().getLocationConstraints(); ShapeUtils.enforceLocationConstraints(shapeView, bounds); } protected LocationControlImpl(); @Inject LocationControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory,
final Event<ShapeLocationsChangedEvent> shapeLocationsChangedEvent,
final Event<CanvasSelectionEvent> selectionEvent); } | LocationControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements LocationControl<AbstractCanvasHandler, Element>,
CanvasControl.SessionAware<EditorSession> { @SuppressWarnings("unchecked") private static void ensureDragConstraints(final AbstractCanvas<?> canvas, final ShapeView shapeView) { final Bounds bounds = canvas.getView().getPanel().getLocationConstraints(); ShapeUtils.enforceLocationConstraints(shapeView, bounds); } protected LocationControlImpl(); @Inject LocationControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory,
final Event<ShapeLocationsChangedEvent> shapeLocationsChangedEvent,
final Event<CanvasSelectionEvent> selectionEvent); Collection<String> getSelectedIDs(); @Override void bind(final EditorSession session); void handleArrowKeys(final Key... keys); @Override void setCommandManagerProvider(final CommandManagerProvider<AbstractCanvasHandler> provider); @Override @SuppressWarnings("unchecked") void register(final Element element); @Override @SuppressWarnings("unchecked") CommandResult<CanvasViolation> move(final Element[] elements,
final Point2D[] locations); } | LocationControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements LocationControl<AbstractCanvasHandler, Element>,
CanvasControl.SessionAware<EditorSession> { @SuppressWarnings("unchecked") private static void ensureDragConstraints(final AbstractCanvas<?> canvas, final ShapeView shapeView) { final Bounds bounds = canvas.getView().getPanel().getLocationConstraints(); ShapeUtils.enforceLocationConstraints(shapeView, bounds); } protected LocationControlImpl(); @Inject LocationControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory,
final Event<ShapeLocationsChangedEvent> shapeLocationsChangedEvent,
final Event<CanvasSelectionEvent> selectionEvent); Collection<String> getSelectedIDs(); @Override void bind(final EditorSession session); void handleArrowKeys(final Key... keys); @Override void setCommandManagerProvider(final CommandManagerProvider<AbstractCanvasHandler> provider); @Override @SuppressWarnings("unchecked") void register(final Element element); @Override @SuppressWarnings("unchecked") CommandResult<CanvasViolation> move(final Element[] elements,
final Point2D[] locations); } |
@Test @SuppressWarnings("unchecked") public void testDeregister() { tested.init(canvasHandler); tested.register(element); tested.deregister(element); verify(shapeEventHandler, atLeastOnce()).removeHandler(any(ViewHandler.class)); assertFalse(tested.isRegistered(element)); } | @Override @SuppressWarnings("unchecked") public void register(final Element element) { if (null != element.asNode() && checkNotRegistered(element)) { final AbstractCanvas<?> canvas = canvasHandler.getAbstractCanvas(); final Shape<?> shape = canvas.getShape(element.getUUID()); final ShapeView shapeView = shape.getShapeView(); shapeView.setDragEnabled(true); ensureDragConstraints(canvas, shapeView); if (shape.getShapeView() instanceof HasEventHandlers) { final HasEventHandlers hasEventHandlers = (HasEventHandlers) shapeView; if (supportsMouseEnter(hasEventHandlers) && supportsMouseExit(hasEventHandlers)) { final MouseEnterHandler overHandler = new MouseEnterHandler() { @Override public void handle(MouseEnterEvent event) { canvasHandler.getAbstractCanvas().getView().setCursor(AbstractCanvas.Cursors.MOVE); } }; hasEventHandlers.addHandler(ViewEventType.MOUSE_ENTER, overHandler); registerHandler(shape.getUUID(), overHandler); final MouseExitHandler outHandler = new MouseExitHandler() { @Override public void handle(MouseExitEvent event) { canvasHandler.getAbstractCanvas().getView().setCursor(AbstractCanvas.Cursors.DEFAULT); } }; hasEventHandlers.addHandler(ViewEventType.MOUSE_EXIT, outHandler); registerHandler(shape.getUUID(), outHandler); final DragHandler dragHandler = new DragHandler() { @Override public void start(DragEvent event) { } @Override public void end(DragEvent event) { selectionEvent.fire(new CanvasSelectionEvent(canvasHandler, shape.getUUID())); } @Override public void handle(DragEvent event) { } }; hasEventHandlers.addHandler(ViewEventType.DRAG, dragHandler); registerHandler(shape.getUUID(), dragHandler); } } } } | LocationControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements LocationControl<AbstractCanvasHandler, Element>,
CanvasControl.SessionAware<EditorSession> { @Override @SuppressWarnings("unchecked") public void register(final Element element) { if (null != element.asNode() && checkNotRegistered(element)) { final AbstractCanvas<?> canvas = canvasHandler.getAbstractCanvas(); final Shape<?> shape = canvas.getShape(element.getUUID()); final ShapeView shapeView = shape.getShapeView(); shapeView.setDragEnabled(true); ensureDragConstraints(canvas, shapeView); if (shape.getShapeView() instanceof HasEventHandlers) { final HasEventHandlers hasEventHandlers = (HasEventHandlers) shapeView; if (supportsMouseEnter(hasEventHandlers) && supportsMouseExit(hasEventHandlers)) { final MouseEnterHandler overHandler = new MouseEnterHandler() { @Override public void handle(MouseEnterEvent event) { canvasHandler.getAbstractCanvas().getView().setCursor(AbstractCanvas.Cursors.MOVE); } }; hasEventHandlers.addHandler(ViewEventType.MOUSE_ENTER, overHandler); registerHandler(shape.getUUID(), overHandler); final MouseExitHandler outHandler = new MouseExitHandler() { @Override public void handle(MouseExitEvent event) { canvasHandler.getAbstractCanvas().getView().setCursor(AbstractCanvas.Cursors.DEFAULT); } }; hasEventHandlers.addHandler(ViewEventType.MOUSE_EXIT, outHandler); registerHandler(shape.getUUID(), outHandler); final DragHandler dragHandler = new DragHandler() { @Override public void start(DragEvent event) { } @Override public void end(DragEvent event) { selectionEvent.fire(new CanvasSelectionEvent(canvasHandler, shape.getUUID())); } @Override public void handle(DragEvent event) { } }; hasEventHandlers.addHandler(ViewEventType.DRAG, dragHandler); registerHandler(shape.getUUID(), dragHandler); } } } } } | LocationControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements LocationControl<AbstractCanvasHandler, Element>,
CanvasControl.SessionAware<EditorSession> { @Override @SuppressWarnings("unchecked") public void register(final Element element) { if (null != element.asNode() && checkNotRegistered(element)) { final AbstractCanvas<?> canvas = canvasHandler.getAbstractCanvas(); final Shape<?> shape = canvas.getShape(element.getUUID()); final ShapeView shapeView = shape.getShapeView(); shapeView.setDragEnabled(true); ensureDragConstraints(canvas, shapeView); if (shape.getShapeView() instanceof HasEventHandlers) { final HasEventHandlers hasEventHandlers = (HasEventHandlers) shapeView; if (supportsMouseEnter(hasEventHandlers) && supportsMouseExit(hasEventHandlers)) { final MouseEnterHandler overHandler = new MouseEnterHandler() { @Override public void handle(MouseEnterEvent event) { canvasHandler.getAbstractCanvas().getView().setCursor(AbstractCanvas.Cursors.MOVE); } }; hasEventHandlers.addHandler(ViewEventType.MOUSE_ENTER, overHandler); registerHandler(shape.getUUID(), overHandler); final MouseExitHandler outHandler = new MouseExitHandler() { @Override public void handle(MouseExitEvent event) { canvasHandler.getAbstractCanvas().getView().setCursor(AbstractCanvas.Cursors.DEFAULT); } }; hasEventHandlers.addHandler(ViewEventType.MOUSE_EXIT, outHandler); registerHandler(shape.getUUID(), outHandler); final DragHandler dragHandler = new DragHandler() { @Override public void start(DragEvent event) { } @Override public void end(DragEvent event) { selectionEvent.fire(new CanvasSelectionEvent(canvasHandler, shape.getUUID())); } @Override public void handle(DragEvent event) { } }; hasEventHandlers.addHandler(ViewEventType.DRAG, dragHandler); registerHandler(shape.getUUID(), dragHandler); } } } } protected LocationControlImpl(); @Inject LocationControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory,
final Event<ShapeLocationsChangedEvent> shapeLocationsChangedEvent,
final Event<CanvasSelectionEvent> selectionEvent); } | LocationControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements LocationControl<AbstractCanvasHandler, Element>,
CanvasControl.SessionAware<EditorSession> { @Override @SuppressWarnings("unchecked") public void register(final Element element) { if (null != element.asNode() && checkNotRegistered(element)) { final AbstractCanvas<?> canvas = canvasHandler.getAbstractCanvas(); final Shape<?> shape = canvas.getShape(element.getUUID()); final ShapeView shapeView = shape.getShapeView(); shapeView.setDragEnabled(true); ensureDragConstraints(canvas, shapeView); if (shape.getShapeView() instanceof HasEventHandlers) { final HasEventHandlers hasEventHandlers = (HasEventHandlers) shapeView; if (supportsMouseEnter(hasEventHandlers) && supportsMouseExit(hasEventHandlers)) { final MouseEnterHandler overHandler = new MouseEnterHandler() { @Override public void handle(MouseEnterEvent event) { canvasHandler.getAbstractCanvas().getView().setCursor(AbstractCanvas.Cursors.MOVE); } }; hasEventHandlers.addHandler(ViewEventType.MOUSE_ENTER, overHandler); registerHandler(shape.getUUID(), overHandler); final MouseExitHandler outHandler = new MouseExitHandler() { @Override public void handle(MouseExitEvent event) { canvasHandler.getAbstractCanvas().getView().setCursor(AbstractCanvas.Cursors.DEFAULT); } }; hasEventHandlers.addHandler(ViewEventType.MOUSE_EXIT, outHandler); registerHandler(shape.getUUID(), outHandler); final DragHandler dragHandler = new DragHandler() { @Override public void start(DragEvent event) { } @Override public void end(DragEvent event) { selectionEvent.fire(new CanvasSelectionEvent(canvasHandler, shape.getUUID())); } @Override public void handle(DragEvent event) { } }; hasEventHandlers.addHandler(ViewEventType.DRAG, dragHandler); registerHandler(shape.getUUID(), dragHandler); } } } } protected LocationControlImpl(); @Inject LocationControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory,
final Event<ShapeLocationsChangedEvent> shapeLocationsChangedEvent,
final Event<CanvasSelectionEvent> selectionEvent); Collection<String> getSelectedIDs(); @Override void bind(final EditorSession session); void handleArrowKeys(final Key... keys); @Override void setCommandManagerProvider(final CommandManagerProvider<AbstractCanvasHandler> provider); @Override @SuppressWarnings("unchecked") void register(final Element element); @Override @SuppressWarnings("unchecked") CommandResult<CanvasViolation> move(final Element[] elements,
final Point2D[] locations); } | LocationControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements LocationControl<AbstractCanvasHandler, Element>,
CanvasControl.SessionAware<EditorSession> { @Override @SuppressWarnings("unchecked") public void register(final Element element) { if (null != element.asNode() && checkNotRegistered(element)) { final AbstractCanvas<?> canvas = canvasHandler.getAbstractCanvas(); final Shape<?> shape = canvas.getShape(element.getUUID()); final ShapeView shapeView = shape.getShapeView(); shapeView.setDragEnabled(true); ensureDragConstraints(canvas, shapeView); if (shape.getShapeView() instanceof HasEventHandlers) { final HasEventHandlers hasEventHandlers = (HasEventHandlers) shapeView; if (supportsMouseEnter(hasEventHandlers) && supportsMouseExit(hasEventHandlers)) { final MouseEnterHandler overHandler = new MouseEnterHandler() { @Override public void handle(MouseEnterEvent event) { canvasHandler.getAbstractCanvas().getView().setCursor(AbstractCanvas.Cursors.MOVE); } }; hasEventHandlers.addHandler(ViewEventType.MOUSE_ENTER, overHandler); registerHandler(shape.getUUID(), overHandler); final MouseExitHandler outHandler = new MouseExitHandler() { @Override public void handle(MouseExitEvent event) { canvasHandler.getAbstractCanvas().getView().setCursor(AbstractCanvas.Cursors.DEFAULT); } }; hasEventHandlers.addHandler(ViewEventType.MOUSE_EXIT, outHandler); registerHandler(shape.getUUID(), outHandler); final DragHandler dragHandler = new DragHandler() { @Override public void start(DragEvent event) { } @Override public void end(DragEvent event) { selectionEvent.fire(new CanvasSelectionEvent(canvasHandler, shape.getUUID())); } @Override public void handle(DragEvent event) { } }; hasEventHandlers.addHandler(ViewEventType.DRAG, dragHandler); registerHandler(shape.getUUID(), dragHandler); } } } } protected LocationControlImpl(); @Inject LocationControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory,
final Event<ShapeLocationsChangedEvent> shapeLocationsChangedEvent,
final Event<CanvasSelectionEvent> selectionEvent); Collection<String> getSelectedIDs(); @Override void bind(final EditorSession session); void handleArrowKeys(final Key... keys); @Override void setCommandManagerProvider(final CommandManagerProvider<AbstractCanvasHandler> provider); @Override @SuppressWarnings("unchecked") void register(final Element element); @Override @SuppressWarnings("unchecked") CommandResult<CanvasViolation> move(final Element[] elements,
final Point2D[] locations); } |
@Test public void testAllow() { tested.init(canvasHandler); final boolean allow = tested.allow(source, docked); assertTrue(allow); verify(commandManager, times(1)).allow(eq(canvasHandler), eq(updateDockNodeCommand)); assertEquals(source, updateDockNodeCommand.getParent()); assertEquals(docked, updateDockNodeCommand.getCandidate()); } | @Override public boolean allow(final Node parent, final Node child) { return evaluate(parent, child, command -> getCommandManager().allow(getCanvasHandler(), command)); } | DockingAcceptorControlImpl extends AbstractAcceptorControl implements DockingAcceptorControl<AbstractCanvasHandler> { @Override public boolean allow(final Node parent, final Node child) { return evaluate(parent, child, command -> getCommandManager().allow(getCanvasHandler(), command)); } } | DockingAcceptorControlImpl extends AbstractAcceptorControl implements DockingAcceptorControl<AbstractCanvasHandler> { @Override public boolean allow(final Node parent, final Node child) { return evaluate(parent, child, command -> getCommandManager().allow(getCanvasHandler(), command)); } @Inject DockingAcceptorControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory); } | DockingAcceptorControlImpl extends AbstractAcceptorControl implements DockingAcceptorControl<AbstractCanvasHandler> { @Override public boolean allow(final Node parent, final Node child) { return evaluate(parent, child, command -> getCommandManager().allow(getCanvasHandler(), command)); } @Inject DockingAcceptorControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory); @Override boolean allow(final Node parent,
final Node child); @Override boolean accept(final Node parent,
final Node child); } | DockingAcceptorControlImpl extends AbstractAcceptorControl implements DockingAcceptorControl<AbstractCanvasHandler> { @Override public boolean allow(final Node parent, final Node child) { return evaluate(parent, child, command -> getCommandManager().allow(getCanvasHandler(), command)); } @Inject DockingAcceptorControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory); @Override boolean allow(final Node parent,
final Node child); @Override boolean accept(final Node parent,
final Node child); } |
@Test public void testAllowNoParent() { tested.init(canvasHandler); final boolean allow = tested.allow(null, docked); assertFalse(allow); verify(commandManager, times(0)).allow(any(AbstractCanvasHandler.class), any(UpdateDockNodeCommand.class)); } | @Override public boolean allow(final Node parent, final Node child) { return evaluate(parent, child, command -> getCommandManager().allow(getCanvasHandler(), command)); } | DockingAcceptorControlImpl extends AbstractAcceptorControl implements DockingAcceptorControl<AbstractCanvasHandler> { @Override public boolean allow(final Node parent, final Node child) { return evaluate(parent, child, command -> getCommandManager().allow(getCanvasHandler(), command)); } } | DockingAcceptorControlImpl extends AbstractAcceptorControl implements DockingAcceptorControl<AbstractCanvasHandler> { @Override public boolean allow(final Node parent, final Node child) { return evaluate(parent, child, command -> getCommandManager().allow(getCanvasHandler(), command)); } @Inject DockingAcceptorControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory); } | DockingAcceptorControlImpl extends AbstractAcceptorControl implements DockingAcceptorControl<AbstractCanvasHandler> { @Override public boolean allow(final Node parent, final Node child) { return evaluate(parent, child, command -> getCommandManager().allow(getCanvasHandler(), command)); } @Inject DockingAcceptorControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory); @Override boolean allow(final Node parent,
final Node child); @Override boolean accept(final Node parent,
final Node child); } | DockingAcceptorControlImpl extends AbstractAcceptorControl implements DockingAcceptorControl<AbstractCanvasHandler> { @Override public boolean allow(final Node parent, final Node child) { return evaluate(parent, child, command -> getCommandManager().allow(getCanvasHandler(), command)); } @Inject DockingAcceptorControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory); @Override boolean allow(final Node parent,
final Node child); @Override boolean accept(final Node parent,
final Node child); } |
@Test public void testAccept() { tested.init(canvasHandler); final boolean accept = tested.accept(source, docked); assertTrue(accept); verify(commandManager, times(1)).execute(eq(canvasHandler), eq(updateDockNodeCommand)); assertEquals(source, updateDockNodeCommand.getParent()); assertEquals(docked, updateDockNodeCommand.getCandidate()); } | @Override public boolean accept(final Node parent, final Node child) { return evaluate(parent, child, command -> getCommandManager().execute(getCanvasHandler(), command)); } | DockingAcceptorControlImpl extends AbstractAcceptorControl implements DockingAcceptorControl<AbstractCanvasHandler> { @Override public boolean accept(final Node parent, final Node child) { return evaluate(parent, child, command -> getCommandManager().execute(getCanvasHandler(), command)); } } | DockingAcceptorControlImpl extends AbstractAcceptorControl implements DockingAcceptorControl<AbstractCanvasHandler> { @Override public boolean accept(final Node parent, final Node child) { return evaluate(parent, child, command -> getCommandManager().execute(getCanvasHandler(), command)); } @Inject DockingAcceptorControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory); } | DockingAcceptorControlImpl extends AbstractAcceptorControl implements DockingAcceptorControl<AbstractCanvasHandler> { @Override public boolean accept(final Node parent, final Node child) { return evaluate(parent, child, command -> getCommandManager().execute(getCanvasHandler(), command)); } @Inject DockingAcceptorControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory); @Override boolean allow(final Node parent,
final Node child); @Override boolean accept(final Node parent,
final Node child); } | DockingAcceptorControlImpl extends AbstractAcceptorControl implements DockingAcceptorControl<AbstractCanvasHandler> { @Override public boolean accept(final Node parent, final Node child) { return evaluate(parent, child, command -> getCommandManager().execute(getCanvasHandler(), command)); } @Inject DockingAcceptorControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory); @Override boolean allow(final Node parent,
final Node child); @Override boolean accept(final Node parent,
final Node child); } |
@Test @SuppressWarnings("unchecked") public void testShowPreview() { tested.showPreview(session); verify(sessionPreview).open(eq(session), anyInt(), anyInt(), sessionViewerCallbackArgumentCaptor.capture()); final SessionViewer.SessionViewerCallback sessionViewerCallback = sessionViewerCallbackArgumentCaptor.getValue(); sessionViewerCallback.onSuccess(); verify(sessionPreview, never()).clear(); verify(view).setPreviewWidget(previewWidget); } | void showPreview(final ClientSession session) { if (Objects.isNull(session)) { return; } if (session instanceof AbstractSession) { if (Objects.nonNull(previewWidget)) { closePreview(); } previewWidget = sessionPreviews.get(); previewWidget.open((AbstractSession) session, PREVIEW_WIDTH, PREVIEW_HEIGHT, new SessionViewer.SessionViewerCallback<Diagram>() { @Override public void afterCanvasInitialized() { } @Override public void onSuccess() { view.setPreviewWidget(previewWidget.getView()); } @Override public void onError(final ClientRuntimeError error) { LOGGER.log(Level.SEVERE, error.getMessage()); } }); } } | PreviewDiagramScreen { void showPreview(final ClientSession session) { if (Objects.isNull(session)) { return; } if (session instanceof AbstractSession) { if (Objects.nonNull(previewWidget)) { closePreview(); } previewWidget = sessionPreviews.get(); previewWidget.open((AbstractSession) session, PREVIEW_WIDTH, PREVIEW_HEIGHT, new SessionViewer.SessionViewerCallback<Diagram>() { @Override public void afterCanvasInitialized() { } @Override public void onSuccess() { view.setPreviewWidget(previewWidget.getView()); } @Override public void onError(final ClientRuntimeError error) { LOGGER.log(Level.SEVERE, error.getMessage()); } }); } } } | PreviewDiagramScreen { void showPreview(final ClientSession session) { if (Objects.isNull(session)) { return; } if (session instanceof AbstractSession) { if (Objects.nonNull(previewWidget)) { closePreview(); } previewWidget = sessionPreviews.get(); previewWidget.open((AbstractSession) session, PREVIEW_WIDTH, PREVIEW_HEIGHT, new SessionViewer.SessionViewerCallback<Diagram>() { @Override public void afterCanvasInitialized() { } @Override public void onSuccess() { view.setPreviewWidget(previewWidget.getView()); } @Override public void onError(final ClientRuntimeError error) { LOGGER.log(Level.SEVERE, error.getMessage()); } }); } } protected PreviewDiagramScreen(); @Inject PreviewDiagramScreen(final SessionManager clientSessionManager,
final @Any @DMNEditor ManagedInstance<SessionDiagramPreview<AbstractSession>> sessionPreviews,
final View view,
final DMNDiagramsSession session); } | PreviewDiagramScreen { void showPreview(final ClientSession session) { if (Objects.isNull(session)) { return; } if (session instanceof AbstractSession) { if (Objects.nonNull(previewWidget)) { closePreview(); } previewWidget = sessionPreviews.get(); previewWidget.open((AbstractSession) session, PREVIEW_WIDTH, PREVIEW_HEIGHT, new SessionViewer.SessionViewerCallback<Diagram>() { @Override public void afterCanvasInitialized() { } @Override public void onSuccess() { view.setPreviewWidget(previewWidget.getView()); } @Override public void onError(final ClientRuntimeError error) { LOGGER.log(Level.SEVERE, error.getMessage()); } }); } } protected PreviewDiagramScreen(); @Inject PreviewDiagramScreen(final SessionManager clientSessionManager,
final @Any @DMNEditor ManagedInstance<SessionDiagramPreview<AbstractSession>> sessionPreviews,
final View view,
final DMNDiagramsSession session); @OnStartup @SuppressWarnings("unused") void onStartup(final PlaceRequest placeRequest); @OnOpen @SuppressWarnings("unused") void onOpen(); @OnClose @SuppressWarnings("unused") void onClose(); @WorkbenchPartTitle @SuppressWarnings("unused") String getTitle(); @WorkbenchPartView @SuppressWarnings("unused") IsWidget getWidget(); @WorkbenchContextId @SuppressWarnings("unused") String getMyContextRef(); } | PreviewDiagramScreen { void showPreview(final ClientSession session) { if (Objects.isNull(session)) { return; } if (session instanceof AbstractSession) { if (Objects.nonNull(previewWidget)) { closePreview(); } previewWidget = sessionPreviews.get(); previewWidget.open((AbstractSession) session, PREVIEW_WIDTH, PREVIEW_HEIGHT, new SessionViewer.SessionViewerCallback<Diagram>() { @Override public void afterCanvasInitialized() { } @Override public void onSuccess() { view.setPreviewWidget(previewWidget.getView()); } @Override public void onError(final ClientRuntimeError error) { LOGGER.log(Level.SEVERE, error.getMessage()); } }); } } protected PreviewDiagramScreen(); @Inject PreviewDiagramScreen(final SessionManager clientSessionManager,
final @Any @DMNEditor ManagedInstance<SessionDiagramPreview<AbstractSession>> sessionPreviews,
final View view,
final DMNDiagramsSession session); @OnStartup @SuppressWarnings("unused") void onStartup(final PlaceRequest placeRequest); @OnOpen @SuppressWarnings("unused") void onOpen(); @OnClose @SuppressWarnings("unused") void onClose(); @WorkbenchPartTitle @SuppressWarnings("unused") String getTitle(); @WorkbenchPartView @SuppressWarnings("unused") IsWidget getWidget(); @WorkbenchContextId @SuppressWarnings("unused") String getMyContextRef(); static final String SCREEN_ID; } |
@Test public void testAceeptNoParent() { tested.init(canvasHandler); final boolean accept = tested.accept(null, docked); assertFalse(accept); verify(commandManager, times(0)).execute(any(AbstractCanvasHandler.class), any(UpdateDockNodeCommand.class)); } | @Override public boolean accept(final Node parent, final Node child) { return evaluate(parent, child, command -> getCommandManager().execute(getCanvasHandler(), command)); } | DockingAcceptorControlImpl extends AbstractAcceptorControl implements DockingAcceptorControl<AbstractCanvasHandler> { @Override public boolean accept(final Node parent, final Node child) { return evaluate(parent, child, command -> getCommandManager().execute(getCanvasHandler(), command)); } } | DockingAcceptorControlImpl extends AbstractAcceptorControl implements DockingAcceptorControl<AbstractCanvasHandler> { @Override public boolean accept(final Node parent, final Node child) { return evaluate(parent, child, command -> getCommandManager().execute(getCanvasHandler(), command)); } @Inject DockingAcceptorControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory); } | DockingAcceptorControlImpl extends AbstractAcceptorControl implements DockingAcceptorControl<AbstractCanvasHandler> { @Override public boolean accept(final Node parent, final Node child) { return evaluate(parent, child, command -> getCommandManager().execute(getCanvasHandler(), command)); } @Inject DockingAcceptorControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory); @Override boolean allow(final Node parent,
final Node child); @Override boolean accept(final Node parent,
final Node child); } | DockingAcceptorControlImpl extends AbstractAcceptorControl implements DockingAcceptorControl<AbstractCanvasHandler> { @Override public boolean accept(final Node parent, final Node child) { return evaluate(parent, child, command -> getCommandManager().execute(getCanvasHandler(), command)); } @Inject DockingAcceptorControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory); @Override boolean allow(final Node parent,
final Node child); @Override boolean accept(final Node parent,
final Node child); } |
@Test public void testSetMinScale() { tested.setMinScale(0.4d); verify(mediators, times(1)).setMinScale(eq(0.4d)); } | @Override public MediatorsControl<C> setMinScale(final double minScale) { mediators.setMinScale(minScale); return this; } | LienzoMediatorsControl extends AbstractCanvasControl<C> implements MediatorsControl<C> { @Override public MediatorsControl<C> setMinScale(final double minScale) { mediators.setMinScale(minScale); return this; } } | LienzoMediatorsControl extends AbstractCanvasControl<C> implements MediatorsControl<C> { @Override public MediatorsControl<C> setMinScale(final double minScale) { mediators.setMinScale(minScale); return this; } @Inject LienzoMediatorsControl(final LienzoPanelMediators mediators); } | LienzoMediatorsControl extends AbstractCanvasControl<C> implements MediatorsControl<C> { @Override public MediatorsControl<C> setMinScale(final double minScale) { mediators.setMinScale(minScale); return this; } @Inject LienzoMediatorsControl(final LienzoPanelMediators mediators); @Override MediatorsControl<C> setMinScale(final double minScale); @Override MediatorsControl<C> setMaxScale(final double maxScale); @Override MediatorsControl<C> setZoomFactor(final double factor); @Override MediatorsControl<C> scale(final double factor); @Override MediatorsControl<C> scale(final double sx,
final double sy); @Override MediatorsControl<C> translate(final double tx,
final double ty); } | LienzoMediatorsControl extends AbstractCanvasControl<C> implements MediatorsControl<C> { @Override public MediatorsControl<C> setMinScale(final double minScale) { mediators.setMinScale(minScale); return this; } @Inject LienzoMediatorsControl(final LienzoPanelMediators mediators); @Override MediatorsControl<C> setMinScale(final double minScale); @Override MediatorsControl<C> setMaxScale(final double maxScale); @Override MediatorsControl<C> setZoomFactor(final double factor); @Override MediatorsControl<C> scale(final double factor); @Override MediatorsControl<C> scale(final double sx,
final double sy); @Override MediatorsControl<C> translate(final double tx,
final double ty); } |
@Test public void testSetMaxScale() { tested.setMaxScale(0.4d); verify(mediators, times(1)).setMaxScale(eq(0.4d)); } | @Override public MediatorsControl<C> setMaxScale(final double maxScale) { mediators.setMaxScale(maxScale); return this; } | LienzoMediatorsControl extends AbstractCanvasControl<C> implements MediatorsControl<C> { @Override public MediatorsControl<C> setMaxScale(final double maxScale) { mediators.setMaxScale(maxScale); return this; } } | LienzoMediatorsControl extends AbstractCanvasControl<C> implements MediatorsControl<C> { @Override public MediatorsControl<C> setMaxScale(final double maxScale) { mediators.setMaxScale(maxScale); return this; } @Inject LienzoMediatorsControl(final LienzoPanelMediators mediators); } | LienzoMediatorsControl extends AbstractCanvasControl<C> implements MediatorsControl<C> { @Override public MediatorsControl<C> setMaxScale(final double maxScale) { mediators.setMaxScale(maxScale); return this; } @Inject LienzoMediatorsControl(final LienzoPanelMediators mediators); @Override MediatorsControl<C> setMinScale(final double minScale); @Override MediatorsControl<C> setMaxScale(final double maxScale); @Override MediatorsControl<C> setZoomFactor(final double factor); @Override MediatorsControl<C> scale(final double factor); @Override MediatorsControl<C> scale(final double sx,
final double sy); @Override MediatorsControl<C> translate(final double tx,
final double ty); } | LienzoMediatorsControl extends AbstractCanvasControl<C> implements MediatorsControl<C> { @Override public MediatorsControl<C> setMaxScale(final double maxScale) { mediators.setMaxScale(maxScale); return this; } @Inject LienzoMediatorsControl(final LienzoPanelMediators mediators); @Override MediatorsControl<C> setMinScale(final double minScale); @Override MediatorsControl<C> setMaxScale(final double maxScale); @Override MediatorsControl<C> setZoomFactor(final double factor); @Override MediatorsControl<C> scale(final double factor); @Override MediatorsControl<C> scale(final double sx,
final double sy); @Override MediatorsControl<C> translate(final double tx,
final double ty); } |
@Test public void testSetZoomFactor() { tested.setZoomFactor(0.4d); verify(mediators, times(1)).setZoomFactor(eq(0.4d)); } | @Override public MediatorsControl<C> setZoomFactor(final double factor) { mediators.setZoomFactor(factor); return this; } | LienzoMediatorsControl extends AbstractCanvasControl<C> implements MediatorsControl<C> { @Override public MediatorsControl<C> setZoomFactor(final double factor) { mediators.setZoomFactor(factor); return this; } } | LienzoMediatorsControl extends AbstractCanvasControl<C> implements MediatorsControl<C> { @Override public MediatorsControl<C> setZoomFactor(final double factor) { mediators.setZoomFactor(factor); return this; } @Inject LienzoMediatorsControl(final LienzoPanelMediators mediators); } | LienzoMediatorsControl extends AbstractCanvasControl<C> implements MediatorsControl<C> { @Override public MediatorsControl<C> setZoomFactor(final double factor) { mediators.setZoomFactor(factor); return this; } @Inject LienzoMediatorsControl(final LienzoPanelMediators mediators); @Override MediatorsControl<C> setMinScale(final double minScale); @Override MediatorsControl<C> setMaxScale(final double maxScale); @Override MediatorsControl<C> setZoomFactor(final double factor); @Override MediatorsControl<C> scale(final double factor); @Override MediatorsControl<C> scale(final double sx,
final double sy); @Override MediatorsControl<C> translate(final double tx,
final double ty); } | LienzoMediatorsControl extends AbstractCanvasControl<C> implements MediatorsControl<C> { @Override public MediatorsControl<C> setZoomFactor(final double factor) { mediators.setZoomFactor(factor); return this; } @Inject LienzoMediatorsControl(final LienzoPanelMediators mediators); @Override MediatorsControl<C> setMinScale(final double minScale); @Override MediatorsControl<C> setMaxScale(final double maxScale); @Override MediatorsControl<C> setZoomFactor(final double factor); @Override MediatorsControl<C> scale(final double factor); @Override MediatorsControl<C> scale(final double sx,
final double sy); @Override MediatorsControl<C> translate(final double tx,
final double ty); } |
@Test public void testScale() { tested.scale(0.2d, 0.4d); verify(layer, times(1)).scale(0.2d, 0.4d); tested.scale(0.5d); verify(layer, times(1)).scale(0.5d); } | @Override public MediatorsControl<C> scale(final double factor) { getLayer().scale(factor); return this; } | LienzoMediatorsControl extends AbstractCanvasControl<C> implements MediatorsControl<C> { @Override public MediatorsControl<C> scale(final double factor) { getLayer().scale(factor); return this; } } | LienzoMediatorsControl extends AbstractCanvasControl<C> implements MediatorsControl<C> { @Override public MediatorsControl<C> scale(final double factor) { getLayer().scale(factor); return this; } @Inject LienzoMediatorsControl(final LienzoPanelMediators mediators); } | LienzoMediatorsControl extends AbstractCanvasControl<C> implements MediatorsControl<C> { @Override public MediatorsControl<C> scale(final double factor) { getLayer().scale(factor); return this; } @Inject LienzoMediatorsControl(final LienzoPanelMediators mediators); @Override MediatorsControl<C> setMinScale(final double minScale); @Override MediatorsControl<C> setMaxScale(final double maxScale); @Override MediatorsControl<C> setZoomFactor(final double factor); @Override MediatorsControl<C> scale(final double factor); @Override MediatorsControl<C> scale(final double sx,
final double sy); @Override MediatorsControl<C> translate(final double tx,
final double ty); } | LienzoMediatorsControl extends AbstractCanvasControl<C> implements MediatorsControl<C> { @Override public MediatorsControl<C> scale(final double factor) { getLayer().scale(factor); return this; } @Inject LienzoMediatorsControl(final LienzoPanelMediators mediators); @Override MediatorsControl<C> setMinScale(final double minScale); @Override MediatorsControl<C> setMaxScale(final double maxScale); @Override MediatorsControl<C> setZoomFactor(final double factor); @Override MediatorsControl<C> scale(final double factor); @Override MediatorsControl<C> scale(final double sx,
final double sy); @Override MediatorsControl<C> translate(final double tx,
final double ty); } |
@Test public void testTranslate() { tested.translate(0.2d, 0.4d); verify(layer, times(1)).translate(0.2d, 0.4d); } | @Override public MediatorsControl<C> translate(final double tx, final double ty) { getLayer().translate(tx, ty); return this; } | LienzoMediatorsControl extends AbstractCanvasControl<C> implements MediatorsControl<C> { @Override public MediatorsControl<C> translate(final double tx, final double ty) { getLayer().translate(tx, ty); return this; } } | LienzoMediatorsControl extends AbstractCanvasControl<C> implements MediatorsControl<C> { @Override public MediatorsControl<C> translate(final double tx, final double ty) { getLayer().translate(tx, ty); return this; } @Inject LienzoMediatorsControl(final LienzoPanelMediators mediators); } | LienzoMediatorsControl extends AbstractCanvasControl<C> implements MediatorsControl<C> { @Override public MediatorsControl<C> translate(final double tx, final double ty) { getLayer().translate(tx, ty); return this; } @Inject LienzoMediatorsControl(final LienzoPanelMediators mediators); @Override MediatorsControl<C> setMinScale(final double minScale); @Override MediatorsControl<C> setMaxScale(final double maxScale); @Override MediatorsControl<C> setZoomFactor(final double factor); @Override MediatorsControl<C> scale(final double factor); @Override MediatorsControl<C> scale(final double sx,
final double sy); @Override MediatorsControl<C> translate(final double tx,
final double ty); } | LienzoMediatorsControl extends AbstractCanvasControl<C> implements MediatorsControl<C> { @Override public MediatorsControl<C> translate(final double tx, final double ty) { getLayer().translate(tx, ty); return this; } @Inject LienzoMediatorsControl(final LienzoPanelMediators mediators); @Override MediatorsControl<C> setMinScale(final double minScale); @Override MediatorsControl<C> setMaxScale(final double maxScale); @Override MediatorsControl<C> setZoomFactor(final double factor); @Override MediatorsControl<C> scale(final double factor); @Override MediatorsControl<C> scale(final double sx,
final double sy); @Override MediatorsControl<C> translate(final double tx,
final double ty); } |
@Test public void testOnCanvasFocusedEvent() { CanvasFocusedEvent event = new CanvasFocusedEvent(canvas); tested.onCanvasFocusedEvent(event); verify(mediators, times(1)).enable(); verify(mediators, never()).disable(); } | void onCanvasFocusedEvent(final @Observes CanvasFocusedEvent focusedEvent) { if (null != canvas && canvas.equals(focusedEvent.getCanvas())) { mediators.enable(); } } | LienzoMediatorsControl extends AbstractCanvasControl<C> implements MediatorsControl<C> { void onCanvasFocusedEvent(final @Observes CanvasFocusedEvent focusedEvent) { if (null != canvas && canvas.equals(focusedEvent.getCanvas())) { mediators.enable(); } } } | LienzoMediatorsControl extends AbstractCanvasControl<C> implements MediatorsControl<C> { void onCanvasFocusedEvent(final @Observes CanvasFocusedEvent focusedEvent) { if (null != canvas && canvas.equals(focusedEvent.getCanvas())) { mediators.enable(); } } @Inject LienzoMediatorsControl(final LienzoPanelMediators mediators); } | LienzoMediatorsControl extends AbstractCanvasControl<C> implements MediatorsControl<C> { void onCanvasFocusedEvent(final @Observes CanvasFocusedEvent focusedEvent) { if (null != canvas && canvas.equals(focusedEvent.getCanvas())) { mediators.enable(); } } @Inject LienzoMediatorsControl(final LienzoPanelMediators mediators); @Override MediatorsControl<C> setMinScale(final double minScale); @Override MediatorsControl<C> setMaxScale(final double maxScale); @Override MediatorsControl<C> setZoomFactor(final double factor); @Override MediatorsControl<C> scale(final double factor); @Override MediatorsControl<C> scale(final double sx,
final double sy); @Override MediatorsControl<C> translate(final double tx,
final double ty); } | LienzoMediatorsControl extends AbstractCanvasControl<C> implements MediatorsControl<C> { void onCanvasFocusedEvent(final @Observes CanvasFocusedEvent focusedEvent) { if (null != canvas && canvas.equals(focusedEvent.getCanvas())) { mediators.enable(); } } @Inject LienzoMediatorsControl(final LienzoPanelMediators mediators); @Override MediatorsControl<C> setMinScale(final double minScale); @Override MediatorsControl<C> setMaxScale(final double maxScale); @Override MediatorsControl<C> setZoomFactor(final double factor); @Override MediatorsControl<C> scale(final double factor); @Override MediatorsControl<C> scale(final double sx,
final double sy); @Override MediatorsControl<C> translate(final double tx,
final double ty); } |
@Test public void testOnCanvasLostFocusEvent() { CanvasLostFocusEvent event = new CanvasLostFocusEvent(canvas); tested.onCanvasLostFocusEvent(event); verify(mediators, times(1)).disable(); verify(mediators, never()).enable(); } | void onCanvasLostFocusEvent(final @Observes CanvasLostFocusEvent lostFocusEvent) { if (null != canvas && canvas.equals(lostFocusEvent.getCanvas())) { mediators.disable(); } } | LienzoMediatorsControl extends AbstractCanvasControl<C> implements MediatorsControl<C> { void onCanvasLostFocusEvent(final @Observes CanvasLostFocusEvent lostFocusEvent) { if (null != canvas && canvas.equals(lostFocusEvent.getCanvas())) { mediators.disable(); } } } | LienzoMediatorsControl extends AbstractCanvasControl<C> implements MediatorsControl<C> { void onCanvasLostFocusEvent(final @Observes CanvasLostFocusEvent lostFocusEvent) { if (null != canvas && canvas.equals(lostFocusEvent.getCanvas())) { mediators.disable(); } } @Inject LienzoMediatorsControl(final LienzoPanelMediators mediators); } | LienzoMediatorsControl extends AbstractCanvasControl<C> implements MediatorsControl<C> { void onCanvasLostFocusEvent(final @Observes CanvasLostFocusEvent lostFocusEvent) { if (null != canvas && canvas.equals(lostFocusEvent.getCanvas())) { mediators.disable(); } } @Inject LienzoMediatorsControl(final LienzoPanelMediators mediators); @Override MediatorsControl<C> setMinScale(final double minScale); @Override MediatorsControl<C> setMaxScale(final double maxScale); @Override MediatorsControl<C> setZoomFactor(final double factor); @Override MediatorsControl<C> scale(final double factor); @Override MediatorsControl<C> scale(final double sx,
final double sy); @Override MediatorsControl<C> translate(final double tx,
final double ty); } | LienzoMediatorsControl extends AbstractCanvasControl<C> implements MediatorsControl<C> { void onCanvasLostFocusEvent(final @Observes CanvasLostFocusEvent lostFocusEvent) { if (null != canvas && canvas.equals(lostFocusEvent.getCanvas())) { mediators.disable(); } } @Inject LienzoMediatorsControl(final LienzoPanelMediators mediators); @Override MediatorsControl<C> setMinScale(final double minScale); @Override MediatorsControl<C> setMaxScale(final double maxScale); @Override MediatorsControl<C> setZoomFactor(final double factor); @Override MediatorsControl<C> scale(final double factor); @Override MediatorsControl<C> scale(final double sx,
final double sy); @Override MediatorsControl<C> translate(final double tx,
final double ty); } |
@Test public void testGroupSelectionWithMultipleItems() { final SelectionManager.SelectedItems selectedItems = mock(SelectionManager.SelectedItems.class); final LienzoMultipleSelectionControl.CursoredSelectionShapeProvider ssp = mock(LienzoMultipleSelectionControl.CursoredSelectionShapeProvider.class); tested = new LienzoMultipleSelectionControl<>(selectionControl, canvasSelectionEvent, clearSelectionEvent, ssp); tested.init(canvasHandler); when(selectionManager.getSelectedItems()).thenReturn(selectedItems); when(selectionManager.getSelectedItems().isSelectionGroup()).thenReturn(true); tested.onCanvasSelection(new CanvasSelectionEvent(canvasHandler, Arrays.asList(ELEMENT_UUID, ELEMENT_UUID_2, ELEMENT_UUID_3, ELEMENT_UUID_4, ELEMENT_UUID_5))); verify(selectionControl, never()).clearSelection(); verify(selectionManager, never()).clearSelection(); } | void onCanvasSelection(final @Observes CanvasSelectionEvent event) { checkNotNull("event", event); if (Objects.equals(getCanvasHandler(), event.getCanvasHandler())) { if (event.getIdentifiers().size() == 1) { onClearSelection(); } selectionShapeProvider.moveShapeToTop(); } } | LienzoMultipleSelectionControl extends AbstractSelectionControl<H> { void onCanvasSelection(final @Observes CanvasSelectionEvent event) { checkNotNull("event", event); if (Objects.equals(getCanvasHandler(), event.getCanvasHandler())) { if (event.getIdentifiers().size() == 1) { onClearSelection(); } selectionShapeProvider.moveShapeToTop(); } } } | LienzoMultipleSelectionControl extends AbstractSelectionControl<H> { void onCanvasSelection(final @Observes CanvasSelectionEvent event) { checkNotNull("event", event); if (Objects.equals(getCanvasHandler(), event.getCanvasHandler())) { if (event.getIdentifiers().size() == 1) { onClearSelection(); } selectionShapeProvider.moveShapeToTop(); } } @Inject LienzoMultipleSelectionControl(final Event<CanvasSelectionEvent> canvasSelectionEvent,
final Event<CanvasClearSelectionEvent> clearSelectionEvent); LienzoMultipleSelectionControl(final MapSelectionControl<H> selectionControl,
final Event<CanvasSelectionEvent> canvasSelectionEvent,
final Event<CanvasClearSelectionEvent> clearSelectionEvent,
final CursoredSelectionShapeProvider selectionShapeProvider); } | LienzoMultipleSelectionControl extends AbstractSelectionControl<H> { void onCanvasSelection(final @Observes CanvasSelectionEvent event) { checkNotNull("event", event); if (Objects.equals(getCanvasHandler(), event.getCanvasHandler())) { if (event.getIdentifiers().size() == 1) { onClearSelection(); } selectionShapeProvider.moveShapeToTop(); } } @Inject LienzoMultipleSelectionControl(final Event<CanvasSelectionEvent> canvasSelectionEvent,
final Event<CanvasClearSelectionEvent> clearSelectionEvent); LienzoMultipleSelectionControl(final MapSelectionControl<H> selectionControl,
final Event<CanvasSelectionEvent> canvasSelectionEvent,
final Event<CanvasClearSelectionEvent> clearSelectionEvent,
final CursoredSelectionShapeProvider selectionShapeProvider); } | LienzoMultipleSelectionControl extends AbstractSelectionControl<H> { void onCanvasSelection(final @Observes CanvasSelectionEvent event) { checkNotNull("event", event); if (Objects.equals(getCanvasHandler(), event.getCanvasHandler())) { if (event.getIdentifiers().size() == 1) { onClearSelection(); } selectionShapeProvider.moveShapeToTop(); } } @Inject LienzoMultipleSelectionControl(final Event<CanvasSelectionEvent> canvasSelectionEvent,
final Event<CanvasClearSelectionEvent> clearSelectionEvent); LienzoMultipleSelectionControl(final MapSelectionControl<H> selectionControl,
final Event<CanvasSelectionEvent> canvasSelectionEvent,
final Event<CanvasClearSelectionEvent> clearSelectionEvent,
final CursoredSelectionShapeProvider selectionShapeProvider); } |
@Test public void testSingleSelectionFromGroupSelection() { final SelectionManager.SelectedItems selectedItems = mock(SelectionManager.SelectedItems.class); final LienzoMultipleSelectionControl.CursoredSelectionShapeProvider ssp = mock(LienzoMultipleSelectionControl.CursoredSelectionShapeProvider.class); tested = new LienzoMultipleSelectionControl<>(selectionControl, canvasSelectionEvent, clearSelectionEvent, ssp); tested.init(canvasHandler); when(selectionManager.getSelectedItems()).thenReturn(selectedItems); when(selectionManager.getSelectedItems().isSelectionGroup()).thenReturn(true); tested.onCanvasSelection(new CanvasSelectionEvent(canvasHandler, Arrays.asList(ELEMENT_UUID))); verify(selectionControl, never()).clearSelection(); verify(selectionManager, times(1)).clearSelection(); } | void onCanvasSelection(final @Observes CanvasSelectionEvent event) { checkNotNull("event", event); if (Objects.equals(getCanvasHandler(), event.getCanvasHandler())) { if (event.getIdentifiers().size() == 1) { onClearSelection(); } selectionShapeProvider.moveShapeToTop(); } } | LienzoMultipleSelectionControl extends AbstractSelectionControl<H> { void onCanvasSelection(final @Observes CanvasSelectionEvent event) { checkNotNull("event", event); if (Objects.equals(getCanvasHandler(), event.getCanvasHandler())) { if (event.getIdentifiers().size() == 1) { onClearSelection(); } selectionShapeProvider.moveShapeToTop(); } } } | LienzoMultipleSelectionControl extends AbstractSelectionControl<H> { void onCanvasSelection(final @Observes CanvasSelectionEvent event) { checkNotNull("event", event); if (Objects.equals(getCanvasHandler(), event.getCanvasHandler())) { if (event.getIdentifiers().size() == 1) { onClearSelection(); } selectionShapeProvider.moveShapeToTop(); } } @Inject LienzoMultipleSelectionControl(final Event<CanvasSelectionEvent> canvasSelectionEvent,
final Event<CanvasClearSelectionEvent> clearSelectionEvent); LienzoMultipleSelectionControl(final MapSelectionControl<H> selectionControl,
final Event<CanvasSelectionEvent> canvasSelectionEvent,
final Event<CanvasClearSelectionEvent> clearSelectionEvent,
final CursoredSelectionShapeProvider selectionShapeProvider); } | LienzoMultipleSelectionControl extends AbstractSelectionControl<H> { void onCanvasSelection(final @Observes CanvasSelectionEvent event) { checkNotNull("event", event); if (Objects.equals(getCanvasHandler(), event.getCanvasHandler())) { if (event.getIdentifiers().size() == 1) { onClearSelection(); } selectionShapeProvider.moveShapeToTop(); } } @Inject LienzoMultipleSelectionControl(final Event<CanvasSelectionEvent> canvasSelectionEvent,
final Event<CanvasClearSelectionEvent> clearSelectionEvent); LienzoMultipleSelectionControl(final MapSelectionControl<H> selectionControl,
final Event<CanvasSelectionEvent> canvasSelectionEvent,
final Event<CanvasClearSelectionEvent> clearSelectionEvent,
final CursoredSelectionShapeProvider selectionShapeProvider); } | LienzoMultipleSelectionControl extends AbstractSelectionControl<H> { void onCanvasSelection(final @Observes CanvasSelectionEvent event) { checkNotNull("event", event); if (Objects.equals(getCanvasHandler(), event.getCanvasHandler())) { if (event.getIdentifiers().size() == 1) { onClearSelection(); } selectionShapeProvider.moveShapeToTop(); } } @Inject LienzoMultipleSelectionControl(final Event<CanvasSelectionEvent> canvasSelectionEvent,
final Event<CanvasClearSelectionEvent> clearSelectionEvent); LienzoMultipleSelectionControl(final MapSelectionControl<H> selectionControl,
final Event<CanvasSelectionEvent> canvasSelectionEvent,
final Event<CanvasClearSelectionEvent> clearSelectionEvent,
final CursoredSelectionShapeProvider selectionShapeProvider); } |
@Test public void wbFromDMN_DMNImport() { when(jsitImportMock.getImportType()).thenReturn(DMN_IMPORT_TYPE); when(jsitDefinitionsMock.getDrgElement()).thenReturn(new ArrayList<>(Arrays.asList(mock(JSITDRGElement.class), mock(JSITDRGElement.class)))); when(jsitDefinitionsMock.getItemDefinition()).thenReturn(new ArrayList<>(Arrays.asList(mock(JSITItemDefinition.class)))); Import resultImport = ImportConverter.wbFromDMN(jsitImportMock, jsitDefinitionsMock, null); assertTrue(resultImport instanceof ImportDMN); assertEquals(NAMESPACE, resultImport.getNamespace()); assertEquals(LOCATION_URI, resultImport.getLocationURI().getValue()); assertEquals(DESCRIPTION, resultImport.getDescription().getValue()); assertEquals(NAME, resultImport.getName().getValue()); assertEquals(DMN_IMPORT_TYPE, resultImport.getImportType()); assertEquals(2, ((ImportDMN) resultImport).getDrgElementsCount()); assertEquals(1, ((ImportDMN) resultImport).getItemDefinitionsCount()); } | public static Import wbFromDMN(final JSITImport dmn, final JSITDefinitions definitions, final PMMLDocumentMetadata pmmlDocument) { final Import result = createWBImport(dmn, definitions, pmmlDocument); final Map<QName, String> additionalAttributes = new HashMap<>(); final Map<javax.xml.namespace.QName, String> otherAttributes = JSITUnaryTests.getOtherAttributesMap(dmn); for (Map.Entry<javax.xml.namespace.QName, String> entry : otherAttributes.entrySet()) { additionalAttributes.put(QNamePropertyConverter.wbFromDMN(entry.getKey().toString()), entry.getValue()); } result.setAdditionalAttributes(additionalAttributes); final String name = dmn.getName(); final String description = dmn.getDescription(); result.setId(IdPropertyConverter.wbFromDMN(dmn.getId())); result.setName(new Name(name)); result.setDescription(DescriptionPropertyConverter.wbFromDMN(description)); NameSpaceUtils.extractNamespacesKeyedByPrefix(dmn).forEach((key, value) -> result.getNsContext().put(key, value)); return result; } | ImportConverter { public static Import wbFromDMN(final JSITImport dmn, final JSITDefinitions definitions, final PMMLDocumentMetadata pmmlDocument) { final Import result = createWBImport(dmn, definitions, pmmlDocument); final Map<QName, String> additionalAttributes = new HashMap<>(); final Map<javax.xml.namespace.QName, String> otherAttributes = JSITUnaryTests.getOtherAttributesMap(dmn); for (Map.Entry<javax.xml.namespace.QName, String> entry : otherAttributes.entrySet()) { additionalAttributes.put(QNamePropertyConverter.wbFromDMN(entry.getKey().toString()), entry.getValue()); } result.setAdditionalAttributes(additionalAttributes); final String name = dmn.getName(); final String description = dmn.getDescription(); result.setId(IdPropertyConverter.wbFromDMN(dmn.getId())); result.setName(new Name(name)); result.setDescription(DescriptionPropertyConverter.wbFromDMN(description)); NameSpaceUtils.extractNamespacesKeyedByPrefix(dmn).forEach((key, value) -> result.getNsContext().put(key, value)); return result; } } | ImportConverter { public static Import wbFromDMN(final JSITImport dmn, final JSITDefinitions definitions, final PMMLDocumentMetadata pmmlDocument) { final Import result = createWBImport(dmn, definitions, pmmlDocument); final Map<QName, String> additionalAttributes = new HashMap<>(); final Map<javax.xml.namespace.QName, String> otherAttributes = JSITUnaryTests.getOtherAttributesMap(dmn); for (Map.Entry<javax.xml.namespace.QName, String> entry : otherAttributes.entrySet()) { additionalAttributes.put(QNamePropertyConverter.wbFromDMN(entry.getKey().toString()), entry.getValue()); } result.setAdditionalAttributes(additionalAttributes); final String name = dmn.getName(); final String description = dmn.getDescription(); result.setId(IdPropertyConverter.wbFromDMN(dmn.getId())); result.setName(new Name(name)); result.setDescription(DescriptionPropertyConverter.wbFromDMN(description)); NameSpaceUtils.extractNamespacesKeyedByPrefix(dmn).forEach((key, value) -> result.getNsContext().put(key, value)); return result; } } | ImportConverter { public static Import wbFromDMN(final JSITImport dmn, final JSITDefinitions definitions, final PMMLDocumentMetadata pmmlDocument) { final Import result = createWBImport(dmn, definitions, pmmlDocument); final Map<QName, String> additionalAttributes = new HashMap<>(); final Map<javax.xml.namespace.QName, String> otherAttributes = JSITUnaryTests.getOtherAttributesMap(dmn); for (Map.Entry<javax.xml.namespace.QName, String> entry : otherAttributes.entrySet()) { additionalAttributes.put(QNamePropertyConverter.wbFromDMN(entry.getKey().toString()), entry.getValue()); } result.setAdditionalAttributes(additionalAttributes); final String name = dmn.getName(); final String description = dmn.getDescription(); result.setId(IdPropertyConverter.wbFromDMN(dmn.getId())); result.setName(new Name(name)); result.setDescription(DescriptionPropertyConverter.wbFromDMN(description)); NameSpaceUtils.extractNamespacesKeyedByPrefix(dmn).forEach((key, value) -> result.getNsContext().put(key, value)); return result; } static Import wbFromDMN(final JSITImport dmn,
final JSITDefinitions definitions,
final PMMLDocumentMetadata pmmlDocument); } | ImportConverter { public static Import wbFromDMN(final JSITImport dmn, final JSITDefinitions definitions, final PMMLDocumentMetadata pmmlDocument) { final Import result = createWBImport(dmn, definitions, pmmlDocument); final Map<QName, String> additionalAttributes = new HashMap<>(); final Map<javax.xml.namespace.QName, String> otherAttributes = JSITUnaryTests.getOtherAttributesMap(dmn); for (Map.Entry<javax.xml.namespace.QName, String> entry : otherAttributes.entrySet()) { additionalAttributes.put(QNamePropertyConverter.wbFromDMN(entry.getKey().toString()), entry.getValue()); } result.setAdditionalAttributes(additionalAttributes); final String name = dmn.getName(); final String description = dmn.getDescription(); result.setId(IdPropertyConverter.wbFromDMN(dmn.getId())); result.setName(new Name(name)); result.setDescription(DescriptionPropertyConverter.wbFromDMN(description)); NameSpaceUtils.extractNamespacesKeyedByPrefix(dmn).forEach((key, value) -> result.getNsContext().put(key, value)); return result; } static Import wbFromDMN(final JSITImport dmn,
final JSITDefinitions definitions,
final PMMLDocumentMetadata pmmlDocument); } |
@Test public void testOnSelectEvent() { final SelectionManager.SelectedItems selectedItems = mock(SelectionManager.SelectedItems.class); when(selectionManager.getSelectedItems()).thenReturn(selectedItems); tested.init(canvasHandler); tested.register(element); tested.onSelect(Collections.singletonList(ELEMENT_UUID)); verify(selectedItems, times(1)).add(eq(shapeView)); verify(selectionControl, never()).clearSelection(); } | @Override protected void onSelect(final Collection<String> uuids) { super.onSelect(uuids); final Collection<ShapeView> shapeViews = uuids.stream() .map(uuid -> getCanvasHandler().getCanvas().getShape(uuid)) .filter(Objects::nonNull) .map(org.kie.workbench.common.stunner.core.client.shape.Shape::getShapeView) .collect(Collectors.toList()); shapeViews.stream() .filter(view -> view instanceof WiresShapeView) .forEach(view -> getSelectionManager().getSelectedItems().add((WiresShape) view)); shapeViews.stream() .filter(view -> view instanceof WiresConnectorView) .forEach(view -> getSelectionManager().getSelectedItems().add((WiresConnector) view)); } | LienzoMultipleSelectionControl extends AbstractSelectionControl<H> { @Override protected void onSelect(final Collection<String> uuids) { super.onSelect(uuids); final Collection<ShapeView> shapeViews = uuids.stream() .map(uuid -> getCanvasHandler().getCanvas().getShape(uuid)) .filter(Objects::nonNull) .map(org.kie.workbench.common.stunner.core.client.shape.Shape::getShapeView) .collect(Collectors.toList()); shapeViews.stream() .filter(view -> view instanceof WiresShapeView) .forEach(view -> getSelectionManager().getSelectedItems().add((WiresShape) view)); shapeViews.stream() .filter(view -> view instanceof WiresConnectorView) .forEach(view -> getSelectionManager().getSelectedItems().add((WiresConnector) view)); } } | LienzoMultipleSelectionControl extends AbstractSelectionControl<H> { @Override protected void onSelect(final Collection<String> uuids) { super.onSelect(uuids); final Collection<ShapeView> shapeViews = uuids.stream() .map(uuid -> getCanvasHandler().getCanvas().getShape(uuid)) .filter(Objects::nonNull) .map(org.kie.workbench.common.stunner.core.client.shape.Shape::getShapeView) .collect(Collectors.toList()); shapeViews.stream() .filter(view -> view instanceof WiresShapeView) .forEach(view -> getSelectionManager().getSelectedItems().add((WiresShape) view)); shapeViews.stream() .filter(view -> view instanceof WiresConnectorView) .forEach(view -> getSelectionManager().getSelectedItems().add((WiresConnector) view)); } @Inject LienzoMultipleSelectionControl(final Event<CanvasSelectionEvent> canvasSelectionEvent,
final Event<CanvasClearSelectionEvent> clearSelectionEvent); LienzoMultipleSelectionControl(final MapSelectionControl<H> selectionControl,
final Event<CanvasSelectionEvent> canvasSelectionEvent,
final Event<CanvasClearSelectionEvent> clearSelectionEvent,
final CursoredSelectionShapeProvider selectionShapeProvider); } | LienzoMultipleSelectionControl extends AbstractSelectionControl<H> { @Override protected void onSelect(final Collection<String> uuids) { super.onSelect(uuids); final Collection<ShapeView> shapeViews = uuids.stream() .map(uuid -> getCanvasHandler().getCanvas().getShape(uuid)) .filter(Objects::nonNull) .map(org.kie.workbench.common.stunner.core.client.shape.Shape::getShapeView) .collect(Collectors.toList()); shapeViews.stream() .filter(view -> view instanceof WiresShapeView) .forEach(view -> getSelectionManager().getSelectedItems().add((WiresShape) view)); shapeViews.stream() .filter(view -> view instanceof WiresConnectorView) .forEach(view -> getSelectionManager().getSelectedItems().add((WiresConnector) view)); } @Inject LienzoMultipleSelectionControl(final Event<CanvasSelectionEvent> canvasSelectionEvent,
final Event<CanvasClearSelectionEvent> clearSelectionEvent); LienzoMultipleSelectionControl(final MapSelectionControl<H> selectionControl,
final Event<CanvasSelectionEvent> canvasSelectionEvent,
final Event<CanvasClearSelectionEvent> clearSelectionEvent,
final CursoredSelectionShapeProvider selectionShapeProvider); } | LienzoMultipleSelectionControl extends AbstractSelectionControl<H> { @Override protected void onSelect(final Collection<String> uuids) { super.onSelect(uuids); final Collection<ShapeView> shapeViews = uuids.stream() .map(uuid -> getCanvasHandler().getCanvas().getShape(uuid)) .filter(Objects::nonNull) .map(org.kie.workbench.common.stunner.core.client.shape.Shape::getShapeView) .collect(Collectors.toList()); shapeViews.stream() .filter(view -> view instanceof WiresShapeView) .forEach(view -> getSelectionManager().getSelectedItems().add((WiresShape) view)); shapeViews.stream() .filter(view -> view instanceof WiresConnectorView) .forEach(view -> getSelectionManager().getSelectedItems().add((WiresConnector) view)); } @Inject LienzoMultipleSelectionControl(final Event<CanvasSelectionEvent> canvasSelectionEvent,
final Event<CanvasClearSelectionEvent> clearSelectionEvent); LienzoMultipleSelectionControl(final MapSelectionControl<H> selectionControl,
final Event<CanvasSelectionEvent> canvasSelectionEvent,
final Event<CanvasClearSelectionEvent> clearSelectionEvent,
final CursoredSelectionShapeProvider selectionShapeProvider); } |
@Test public void testOnShapeLocationsChanged() { when(shapeLocationsChangedEvent.getCanvasHandler()).thenReturn(mock(CanvasHandler.class)); tested.onShapeLocationsChanged(shapeLocationsChangedEvent); verify(selectedItems, never()).rebuildBoundingBox(); verify(selectionManager, never()).drawSelectionShape(eq(MIN_WIDTH), eq(MIN_HEIGHT), eq(MAX_WIDTH), eq(MAX_HEIGHT), eq(overLayer)); when(shapeLocationsChangedEvent.getCanvasHandler()).thenReturn(canvasHandler); when(shapeLocationsChangedEvent.getUuids()).thenReturn(new ArrayList<>()); tested.onShapeLocationsChanged(shapeLocationsChangedEvent); verify(selectedItems, never()).rebuildBoundingBox(); verify(selectionManager, never()).drawSelectionShape(eq(MIN_WIDTH), eq(MIN_HEIGHT), eq(MAX_WIDTH), eq(MAX_HEIGHT), eq(overLayer)); when(shapeLocationsChangedEvent.getCanvasHandler()).thenReturn(canvasHandler); List<String> selectedUUIds = new ArrayList<>(); selectedUUIds.add("ELEMENT"); when(shapeLocationsChangedEvent.getUuids()).thenReturn(selectedUUIds); when(tested.getSelectedItems()).thenReturn(selectedUUIds); when(delegateShapeProvider.getShape()).thenReturn(mock(com.ait.lienzo.client.core.shape.Shape.class)); when(selectionManager.getSelectedItems()).thenReturn(selectedItems); when(selectedItems.getBoundingBox()).thenReturn(new BoundingBox(MIN_WIDTH, MIN_HEIGHT, MAX_WIDTH, MAX_HEIGHT)); when(shapeLocationsChangedEvent.getCanvasHandler()).thenReturn(canvasHandler); tested.onShapeLocationsChanged(shapeLocationsChangedEvent); verify(selectedItems, times(1)).rebuildBoundingBox(); verify(selectionManager, times(1)).drawSelectionShapeForSelection(); } | protected void onShapeLocationsChanged(@Observes ShapeLocationsChangedEvent event) { if (isSameCanvas(event.getCanvasHandler()) && areSelected(event.getUuids())) { rebuildSelectionArea(); } } | LienzoMultipleSelectionControl extends AbstractSelectionControl<H> { protected void onShapeLocationsChanged(@Observes ShapeLocationsChangedEvent event) { if (isSameCanvas(event.getCanvasHandler()) && areSelected(event.getUuids())) { rebuildSelectionArea(); } } } | LienzoMultipleSelectionControl extends AbstractSelectionControl<H> { protected void onShapeLocationsChanged(@Observes ShapeLocationsChangedEvent event) { if (isSameCanvas(event.getCanvasHandler()) && areSelected(event.getUuids())) { rebuildSelectionArea(); } } @Inject LienzoMultipleSelectionControl(final Event<CanvasSelectionEvent> canvasSelectionEvent,
final Event<CanvasClearSelectionEvent> clearSelectionEvent); LienzoMultipleSelectionControl(final MapSelectionControl<H> selectionControl,
final Event<CanvasSelectionEvent> canvasSelectionEvent,
final Event<CanvasClearSelectionEvent> clearSelectionEvent,
final CursoredSelectionShapeProvider selectionShapeProvider); } | LienzoMultipleSelectionControl extends AbstractSelectionControl<H> { protected void onShapeLocationsChanged(@Observes ShapeLocationsChangedEvent event) { if (isSameCanvas(event.getCanvasHandler()) && areSelected(event.getUuids())) { rebuildSelectionArea(); } } @Inject LienzoMultipleSelectionControl(final Event<CanvasSelectionEvent> canvasSelectionEvent,
final Event<CanvasClearSelectionEvent> clearSelectionEvent); LienzoMultipleSelectionControl(final MapSelectionControl<H> selectionControl,
final Event<CanvasSelectionEvent> canvasSelectionEvent,
final Event<CanvasClearSelectionEvent> clearSelectionEvent,
final CursoredSelectionShapeProvider selectionShapeProvider); } | LienzoMultipleSelectionControl extends AbstractSelectionControl<H> { protected void onShapeLocationsChanged(@Observes ShapeLocationsChangedEvent event) { if (isSameCanvas(event.getCanvasHandler()) && areSelected(event.getUuids())) { rebuildSelectionArea(); } } @Inject LienzoMultipleSelectionControl(final Event<CanvasSelectionEvent> canvasSelectionEvent,
final Event<CanvasClearSelectionEvent> clearSelectionEvent); LienzoMultipleSelectionControl(final MapSelectionControl<H> selectionControl,
final Event<CanvasSelectionEvent> canvasSelectionEvent,
final Event<CanvasClearSelectionEvent> clearSelectionEvent,
final CursoredSelectionShapeProvider selectionShapeProvider); } |
@Test public void testOnClearSelectionEvent() { tested.init(canvasHandler); tested.onClearSelection(); verify(selectionControl, never()).clearSelection(); verify(selectionManager, times(1)).clearSelection(); } | @Override protected void onClearSelection() { super.onClearSelection(); if (Objects.nonNull(getSelectionControl().getCanvasHandler())) { getSelectionManager().clearSelection(); } } | LienzoMultipleSelectionControl extends AbstractSelectionControl<H> { @Override protected void onClearSelection() { super.onClearSelection(); if (Objects.nonNull(getSelectionControl().getCanvasHandler())) { getSelectionManager().clearSelection(); } } } | LienzoMultipleSelectionControl extends AbstractSelectionControl<H> { @Override protected void onClearSelection() { super.onClearSelection(); if (Objects.nonNull(getSelectionControl().getCanvasHandler())) { getSelectionManager().clearSelection(); } } @Inject LienzoMultipleSelectionControl(final Event<CanvasSelectionEvent> canvasSelectionEvent,
final Event<CanvasClearSelectionEvent> clearSelectionEvent); LienzoMultipleSelectionControl(final MapSelectionControl<H> selectionControl,
final Event<CanvasSelectionEvent> canvasSelectionEvent,
final Event<CanvasClearSelectionEvent> clearSelectionEvent,
final CursoredSelectionShapeProvider selectionShapeProvider); } | LienzoMultipleSelectionControl extends AbstractSelectionControl<H> { @Override protected void onClearSelection() { super.onClearSelection(); if (Objects.nonNull(getSelectionControl().getCanvasHandler())) { getSelectionManager().clearSelection(); } } @Inject LienzoMultipleSelectionControl(final Event<CanvasSelectionEvent> canvasSelectionEvent,
final Event<CanvasClearSelectionEvent> clearSelectionEvent); LienzoMultipleSelectionControl(final MapSelectionControl<H> selectionControl,
final Event<CanvasSelectionEvent> canvasSelectionEvent,
final Event<CanvasClearSelectionEvent> clearSelectionEvent,
final CursoredSelectionShapeProvider selectionShapeProvider); } | LienzoMultipleSelectionControl extends AbstractSelectionControl<H> { @Override protected void onClearSelection() { super.onClearSelection(); if (Objects.nonNull(getSelectionControl().getCanvasHandler())) { getSelectionManager().clearSelection(); } } @Inject LienzoMultipleSelectionControl(final Event<CanvasSelectionEvent> canvasSelectionEvent,
final Event<CanvasClearSelectionEvent> clearSelectionEvent); LienzoMultipleSelectionControl(final MapSelectionControl<H> selectionControl,
final Event<CanvasSelectionEvent> canvasSelectionEvent,
final Event<CanvasClearSelectionEvent> clearSelectionEvent,
final CursoredSelectionShapeProvider selectionShapeProvider); } |
@Test public void testMoveSelectionShapeToTop() { final LienzoMultipleSelectionControl.CursoredSelectionShapeProvider ssp = mock(LienzoMultipleSelectionControl.CursoredSelectionShapeProvider.class); tested = new LienzoMultipleSelectionControl<>(selectionControl, canvasSelectionEvent, clearSelectionEvent, ssp); tested.init(canvasHandler); tested.onCanvasSelection(new CanvasSelectionEvent(canvasHandler, Collections.emptyList())); verify(ssp, times(1)).moveShapeToTop(); } | void onCanvasSelection(final @Observes CanvasSelectionEvent event) { checkNotNull("event", event); if (Objects.equals(getCanvasHandler(), event.getCanvasHandler())) { if (event.getIdentifiers().size() == 1) { onClearSelection(); } selectionShapeProvider.moveShapeToTop(); } } | LienzoMultipleSelectionControl extends AbstractSelectionControl<H> { void onCanvasSelection(final @Observes CanvasSelectionEvent event) { checkNotNull("event", event); if (Objects.equals(getCanvasHandler(), event.getCanvasHandler())) { if (event.getIdentifiers().size() == 1) { onClearSelection(); } selectionShapeProvider.moveShapeToTop(); } } } | LienzoMultipleSelectionControl extends AbstractSelectionControl<H> { void onCanvasSelection(final @Observes CanvasSelectionEvent event) { checkNotNull("event", event); if (Objects.equals(getCanvasHandler(), event.getCanvasHandler())) { if (event.getIdentifiers().size() == 1) { onClearSelection(); } selectionShapeProvider.moveShapeToTop(); } } @Inject LienzoMultipleSelectionControl(final Event<CanvasSelectionEvent> canvasSelectionEvent,
final Event<CanvasClearSelectionEvent> clearSelectionEvent); LienzoMultipleSelectionControl(final MapSelectionControl<H> selectionControl,
final Event<CanvasSelectionEvent> canvasSelectionEvent,
final Event<CanvasClearSelectionEvent> clearSelectionEvent,
final CursoredSelectionShapeProvider selectionShapeProvider); } | LienzoMultipleSelectionControl extends AbstractSelectionControl<H> { void onCanvasSelection(final @Observes CanvasSelectionEvent event) { checkNotNull("event", event); if (Objects.equals(getCanvasHandler(), event.getCanvasHandler())) { if (event.getIdentifiers().size() == 1) { onClearSelection(); } selectionShapeProvider.moveShapeToTop(); } } @Inject LienzoMultipleSelectionControl(final Event<CanvasSelectionEvent> canvasSelectionEvent,
final Event<CanvasClearSelectionEvent> clearSelectionEvent); LienzoMultipleSelectionControl(final MapSelectionControl<H> selectionControl,
final Event<CanvasSelectionEvent> canvasSelectionEvent,
final Event<CanvasClearSelectionEvent> clearSelectionEvent,
final CursoredSelectionShapeProvider selectionShapeProvider); } | LienzoMultipleSelectionControl extends AbstractSelectionControl<H> { void onCanvasSelection(final @Observes CanvasSelectionEvent event) { checkNotNull("event", event); if (Objects.equals(getCanvasHandler(), event.getCanvasHandler())) { if (event.getIdentifiers().size() == 1) { onClearSelection(); } selectionShapeProvider.moveShapeToTop(); } } @Inject LienzoMultipleSelectionControl(final Event<CanvasSelectionEvent> canvasSelectionEvent,
final Event<CanvasClearSelectionEvent> clearSelectionEvent); LienzoMultipleSelectionControl(final MapSelectionControl<H> selectionControl,
final Event<CanvasSelectionEvent> canvasSelectionEvent,
final Event<CanvasClearSelectionEvent> clearSelectionEvent,
final CursoredSelectionShapeProvider selectionShapeProvider); } |
@Test public void testDestroy() { tested.destroy(); verify(tested).onDestroy(); verify(selectionManager).destroy(); verify(selectionShapeProvider).destroy(); } | @Override protected void onDestroy() { getSelectionManager().destroy(); selectionShapeProvider.destroy(); super.onDestroy(); } | LienzoMultipleSelectionControl extends AbstractSelectionControl<H> { @Override protected void onDestroy() { getSelectionManager().destroy(); selectionShapeProvider.destroy(); super.onDestroy(); } } | LienzoMultipleSelectionControl extends AbstractSelectionControl<H> { @Override protected void onDestroy() { getSelectionManager().destroy(); selectionShapeProvider.destroy(); super.onDestroy(); } @Inject LienzoMultipleSelectionControl(final Event<CanvasSelectionEvent> canvasSelectionEvent,
final Event<CanvasClearSelectionEvent> clearSelectionEvent); LienzoMultipleSelectionControl(final MapSelectionControl<H> selectionControl,
final Event<CanvasSelectionEvent> canvasSelectionEvent,
final Event<CanvasClearSelectionEvent> clearSelectionEvent,
final CursoredSelectionShapeProvider selectionShapeProvider); } | LienzoMultipleSelectionControl extends AbstractSelectionControl<H> { @Override protected void onDestroy() { getSelectionManager().destroy(); selectionShapeProvider.destroy(); super.onDestroy(); } @Inject LienzoMultipleSelectionControl(final Event<CanvasSelectionEvent> canvasSelectionEvent,
final Event<CanvasClearSelectionEvent> clearSelectionEvent); LienzoMultipleSelectionControl(final MapSelectionControl<H> selectionControl,
final Event<CanvasSelectionEvent> canvasSelectionEvent,
final Event<CanvasClearSelectionEvent> clearSelectionEvent,
final CursoredSelectionShapeProvider selectionShapeProvider); } | LienzoMultipleSelectionControl extends AbstractSelectionControl<H> { @Override protected void onDestroy() { getSelectionManager().destroy(); selectionShapeProvider.destroy(); super.onDestroy(); } @Inject LienzoMultipleSelectionControl(final Event<CanvasSelectionEvent> canvasSelectionEvent,
final Event<CanvasClearSelectionEvent> clearSelectionEvent); LienzoMultipleSelectionControl(final MapSelectionControl<H> selectionControl,
final Event<CanvasSelectionEvent> canvasSelectionEvent,
final Event<CanvasClearSelectionEvent> clearSelectionEvent,
final CursoredSelectionShapeProvider selectionShapeProvider); } |
@Test public void testAllow() { tested.init(canvasHandler); final boolean allow = tested.allow(parent, new Node[]{candidate}); assertTrue(allow); verify(commandManager, times(1)).allow(eq(canvasHandler), eq(updateChildrenCommand)); assertEquals(parent, updateChildrenCommand.getParent()); assertEquals(candidate, updateChildrenCommand.getCandidates().iterator().next()); verify(highlight, times(1)).unhighLight(); } | @Override public boolean allow(final Element parent, final Node[] children) { return evaluate(parent, children, command -> getCommandManager().allow(getCanvasHandler(), command), true); } | ContainmentAcceptorControlImpl extends AbstractAcceptorControl implements ContainmentAcceptorControl<AbstractCanvasHandler> { @Override public boolean allow(final Element parent, final Node[] children) { return evaluate(parent, children, command -> getCommandManager().allow(getCanvasHandler(), command), true); } } | ContainmentAcceptorControlImpl extends AbstractAcceptorControl implements ContainmentAcceptorControl<AbstractCanvasHandler> { @Override public boolean allow(final Element parent, final Node[] children) { return evaluate(parent, children, command -> getCommandManager().allow(getCanvasHandler(), command), true); } @Inject ContainmentAcceptorControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory,
final CanvasHighlight canvasHighlight); } | ContainmentAcceptorControlImpl extends AbstractAcceptorControl implements ContainmentAcceptorControl<AbstractCanvasHandler> { @Override public boolean allow(final Element parent, final Node[] children) { return evaluate(parent, children, command -> getCommandManager().allow(getCanvasHandler(), command), true); } @Inject ContainmentAcceptorControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory,
final CanvasHighlight canvasHighlight); @Override boolean allow(final Element parent,
final Node[] children); @Override boolean accept(final Element parent,
final Node[] children); } | ContainmentAcceptorControlImpl extends AbstractAcceptorControl implements ContainmentAcceptorControl<AbstractCanvasHandler> { @Override public boolean allow(final Element parent, final Node[] children) { return evaluate(parent, children, command -> getCommandManager().allow(getCanvasHandler(), command), true); } @Inject ContainmentAcceptorControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory,
final CanvasHighlight canvasHighlight); @Override boolean allow(final Element parent,
final Node[] children); @Override boolean accept(final Element parent,
final Node[] children); } |
@Test public void testAccept() { tested.init(canvasHandler); final boolean accept = tested.accept(parent, new Node[]{candidate}); assertTrue(accept); verify(commandManager, times(1)).execute(eq(canvasHandler), eq(updateChildrenCommand)); assertEquals(parent, updateChildrenCommand.getParent()); assertEquals(candidate, updateChildrenCommand.getCandidates().iterator().next()); verify(highlight, times(1)).unhighLight(); } | @Override public boolean accept(final Element parent, final Node[] children) { return evaluate(parent, children, command -> getCommandManager().execute(getCanvasHandler(), command), false); } | ContainmentAcceptorControlImpl extends AbstractAcceptorControl implements ContainmentAcceptorControl<AbstractCanvasHandler> { @Override public boolean accept(final Element parent, final Node[] children) { return evaluate(parent, children, command -> getCommandManager().execute(getCanvasHandler(), command), false); } } | ContainmentAcceptorControlImpl extends AbstractAcceptorControl implements ContainmentAcceptorControl<AbstractCanvasHandler> { @Override public boolean accept(final Element parent, final Node[] children) { return evaluate(parent, children, command -> getCommandManager().execute(getCanvasHandler(), command), false); } @Inject ContainmentAcceptorControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory,
final CanvasHighlight canvasHighlight); } | ContainmentAcceptorControlImpl extends AbstractAcceptorControl implements ContainmentAcceptorControl<AbstractCanvasHandler> { @Override public boolean accept(final Element parent, final Node[] children) { return evaluate(parent, children, command -> getCommandManager().execute(getCanvasHandler(), command), false); } @Inject ContainmentAcceptorControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory,
final CanvasHighlight canvasHighlight); @Override boolean allow(final Element parent,
final Node[] children); @Override boolean accept(final Element parent,
final Node[] children); } | ContainmentAcceptorControlImpl extends AbstractAcceptorControl implements ContainmentAcceptorControl<AbstractCanvasHandler> { @Override public boolean accept(final Element parent, final Node[] children) { return evaluate(parent, children, command -> getCommandManager().execute(getCanvasHandler(), command), false); } @Inject ContainmentAcceptorControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory,
final CanvasHighlight canvasHighlight); @Override boolean allow(final Element parent,
final Node[] children); @Override boolean accept(final Element parent,
final Node[] children); } |
@Test public void testIsSameParent() { Node parent = new NodeImpl<>("parentUUID"); Node child1 = new NodeImpl<>("child1"); setAsChild(parent, child1); Node child2 = new NodeImpl<>("child2"); setAsChild(parent, child2); Node[] children = {child1, child2}; boolean isSameParent = ContainmentAcceptorControlImpl.areInSameParent(parent, children); assertTrue(isSameParent); } | static boolean areInSameParent(final Element parent, final Node[] children) { return Stream.of(children) .map(GraphUtils::getParent) .noneMatch(childParent -> !Objects.equals(parent, childParent)); } | ContainmentAcceptorControlImpl extends AbstractAcceptorControl implements ContainmentAcceptorControl<AbstractCanvasHandler> { static boolean areInSameParent(final Element parent, final Node[] children) { return Stream.of(children) .map(GraphUtils::getParent) .noneMatch(childParent -> !Objects.equals(parent, childParent)); } } | ContainmentAcceptorControlImpl extends AbstractAcceptorControl implements ContainmentAcceptorControl<AbstractCanvasHandler> { static boolean areInSameParent(final Element parent, final Node[] children) { return Stream.of(children) .map(GraphUtils::getParent) .noneMatch(childParent -> !Objects.equals(parent, childParent)); } @Inject ContainmentAcceptorControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory,
final CanvasHighlight canvasHighlight); } | ContainmentAcceptorControlImpl extends AbstractAcceptorControl implements ContainmentAcceptorControl<AbstractCanvasHandler> { static boolean areInSameParent(final Element parent, final Node[] children) { return Stream.of(children) .map(GraphUtils::getParent) .noneMatch(childParent -> !Objects.equals(parent, childParent)); } @Inject ContainmentAcceptorControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory,
final CanvasHighlight canvasHighlight); @Override boolean allow(final Element parent,
final Node[] children); @Override boolean accept(final Element parent,
final Node[] children); } | ContainmentAcceptorControlImpl extends AbstractAcceptorControl implements ContainmentAcceptorControl<AbstractCanvasHandler> { static boolean areInSameParent(final Element parent, final Node[] children) { return Stream.of(children) .map(GraphUtils::getParent) .noneMatch(childParent -> !Objects.equals(parent, childParent)); } @Inject ContainmentAcceptorControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory,
final CanvasHighlight canvasHighlight); @Override boolean allow(final Element parent,
final Node[] children); @Override boolean accept(final Element parent,
final Node[] children); } |
@Test public void testIsNotSameParent1() { Node parent = new NodeImpl<>("parentUUID"); Node child1 = new NodeImpl<>("child1"); Node child2 = new NodeImpl<>("child2"); setAsChild(parent, child2); Node[] children = {child1, child2}; boolean isSameParent = ContainmentAcceptorControlImpl.areInSameParent(parent, children); assertFalse(isSameParent); } | static boolean areInSameParent(final Element parent, final Node[] children) { return Stream.of(children) .map(GraphUtils::getParent) .noneMatch(childParent -> !Objects.equals(parent, childParent)); } | ContainmentAcceptorControlImpl extends AbstractAcceptorControl implements ContainmentAcceptorControl<AbstractCanvasHandler> { static boolean areInSameParent(final Element parent, final Node[] children) { return Stream.of(children) .map(GraphUtils::getParent) .noneMatch(childParent -> !Objects.equals(parent, childParent)); } } | ContainmentAcceptorControlImpl extends AbstractAcceptorControl implements ContainmentAcceptorControl<AbstractCanvasHandler> { static boolean areInSameParent(final Element parent, final Node[] children) { return Stream.of(children) .map(GraphUtils::getParent) .noneMatch(childParent -> !Objects.equals(parent, childParent)); } @Inject ContainmentAcceptorControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory,
final CanvasHighlight canvasHighlight); } | ContainmentAcceptorControlImpl extends AbstractAcceptorControl implements ContainmentAcceptorControl<AbstractCanvasHandler> { static boolean areInSameParent(final Element parent, final Node[] children) { return Stream.of(children) .map(GraphUtils::getParent) .noneMatch(childParent -> !Objects.equals(parent, childParent)); } @Inject ContainmentAcceptorControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory,
final CanvasHighlight canvasHighlight); @Override boolean allow(final Element parent,
final Node[] children); @Override boolean accept(final Element parent,
final Node[] children); } | ContainmentAcceptorControlImpl extends AbstractAcceptorControl implements ContainmentAcceptorControl<AbstractCanvasHandler> { static boolean areInSameParent(final Element parent, final Node[] children) { return Stream.of(children) .map(GraphUtils::getParent) .noneMatch(childParent -> !Objects.equals(parent, childParent)); } @Inject ContainmentAcceptorControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory,
final CanvasHighlight canvasHighlight); @Override boolean allow(final Element parent,
final Node[] children); @Override boolean accept(final Element parent,
final Node[] children); } |
@Test public void testIsNotSameParent2() { Node parent = new NodeImpl<>("parentUUID"); Node child1 = new NodeImpl<>("child1"); setAsChild(parent, child1); Node child2 = new NodeImpl<>("child2"); Node[] children = {child1, child2}; boolean isSameParent = ContainmentAcceptorControlImpl.areInSameParent(parent, children); assertFalse(isSameParent); } | static boolean areInSameParent(final Element parent, final Node[] children) { return Stream.of(children) .map(GraphUtils::getParent) .noneMatch(childParent -> !Objects.equals(parent, childParent)); } | ContainmentAcceptorControlImpl extends AbstractAcceptorControl implements ContainmentAcceptorControl<AbstractCanvasHandler> { static boolean areInSameParent(final Element parent, final Node[] children) { return Stream.of(children) .map(GraphUtils::getParent) .noneMatch(childParent -> !Objects.equals(parent, childParent)); } } | ContainmentAcceptorControlImpl extends AbstractAcceptorControl implements ContainmentAcceptorControl<AbstractCanvasHandler> { static boolean areInSameParent(final Element parent, final Node[] children) { return Stream.of(children) .map(GraphUtils::getParent) .noneMatch(childParent -> !Objects.equals(parent, childParent)); } @Inject ContainmentAcceptorControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory,
final CanvasHighlight canvasHighlight); } | ContainmentAcceptorControlImpl extends AbstractAcceptorControl implements ContainmentAcceptorControl<AbstractCanvasHandler> { static boolean areInSameParent(final Element parent, final Node[] children) { return Stream.of(children) .map(GraphUtils::getParent) .noneMatch(childParent -> !Objects.equals(parent, childParent)); } @Inject ContainmentAcceptorControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory,
final CanvasHighlight canvasHighlight); @Override boolean allow(final Element parent,
final Node[] children); @Override boolean accept(final Element parent,
final Node[] children); } | ContainmentAcceptorControlImpl extends AbstractAcceptorControl implements ContainmentAcceptorControl<AbstractCanvasHandler> { static boolean areInSameParent(final Element parent, final Node[] children) { return Stream.of(children) .map(GraphUtils::getParent) .noneMatch(childParent -> !Objects.equals(parent, childParent)); } @Inject ContainmentAcceptorControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory,
final CanvasHighlight canvasHighlight); @Override boolean allow(final Element parent,
final Node[] children); @Override boolean accept(final Element parent,
final Node[] children); } |
@Test public void wbFromDMN_DMNImportNoDefinition() { when(jsitImportMock.getImportType()).thenReturn(DMN_IMPORT_TYPE); when(jsitDefinitionsMock.getDrgElement()).thenReturn(new ArrayList<>(Arrays.asList(mock(JSITDRGElement.class), mock(JSITDRGElement.class)))); when(jsitDefinitionsMock.getItemDefinition()).thenReturn(new ArrayList<>(Arrays.asList(mock(JSITItemDefinition.class)))); Import resultImport = ImportConverter.wbFromDMN(jsitImportMock, null, null); assertTrue(resultImport instanceof ImportDMN); assertEquals(NAMESPACE, resultImport.getNamespace()); assertEquals(LOCATION_URI, resultImport.getLocationURI().getValue()); assertEquals(DESCRIPTION, resultImport.getDescription().getValue()); assertEquals(NAME, resultImport.getName().getValue()); assertEquals(DMN_IMPORT_TYPE, resultImport.getImportType()); assertEquals(0, ((ImportDMN) resultImport).getDrgElementsCount()); assertEquals(0, ((ImportDMN) resultImport).getItemDefinitionsCount()); } | public static Import wbFromDMN(final JSITImport dmn, final JSITDefinitions definitions, final PMMLDocumentMetadata pmmlDocument) { final Import result = createWBImport(dmn, definitions, pmmlDocument); final Map<QName, String> additionalAttributes = new HashMap<>(); final Map<javax.xml.namespace.QName, String> otherAttributes = JSITUnaryTests.getOtherAttributesMap(dmn); for (Map.Entry<javax.xml.namespace.QName, String> entry : otherAttributes.entrySet()) { additionalAttributes.put(QNamePropertyConverter.wbFromDMN(entry.getKey().toString()), entry.getValue()); } result.setAdditionalAttributes(additionalAttributes); final String name = dmn.getName(); final String description = dmn.getDescription(); result.setId(IdPropertyConverter.wbFromDMN(dmn.getId())); result.setName(new Name(name)); result.setDescription(DescriptionPropertyConverter.wbFromDMN(description)); NameSpaceUtils.extractNamespacesKeyedByPrefix(dmn).forEach((key, value) -> result.getNsContext().put(key, value)); return result; } | ImportConverter { public static Import wbFromDMN(final JSITImport dmn, final JSITDefinitions definitions, final PMMLDocumentMetadata pmmlDocument) { final Import result = createWBImport(dmn, definitions, pmmlDocument); final Map<QName, String> additionalAttributes = new HashMap<>(); final Map<javax.xml.namespace.QName, String> otherAttributes = JSITUnaryTests.getOtherAttributesMap(dmn); for (Map.Entry<javax.xml.namespace.QName, String> entry : otherAttributes.entrySet()) { additionalAttributes.put(QNamePropertyConverter.wbFromDMN(entry.getKey().toString()), entry.getValue()); } result.setAdditionalAttributes(additionalAttributes); final String name = dmn.getName(); final String description = dmn.getDescription(); result.setId(IdPropertyConverter.wbFromDMN(dmn.getId())); result.setName(new Name(name)); result.setDescription(DescriptionPropertyConverter.wbFromDMN(description)); NameSpaceUtils.extractNamespacesKeyedByPrefix(dmn).forEach((key, value) -> result.getNsContext().put(key, value)); return result; } } | ImportConverter { public static Import wbFromDMN(final JSITImport dmn, final JSITDefinitions definitions, final PMMLDocumentMetadata pmmlDocument) { final Import result = createWBImport(dmn, definitions, pmmlDocument); final Map<QName, String> additionalAttributes = new HashMap<>(); final Map<javax.xml.namespace.QName, String> otherAttributes = JSITUnaryTests.getOtherAttributesMap(dmn); for (Map.Entry<javax.xml.namespace.QName, String> entry : otherAttributes.entrySet()) { additionalAttributes.put(QNamePropertyConverter.wbFromDMN(entry.getKey().toString()), entry.getValue()); } result.setAdditionalAttributes(additionalAttributes); final String name = dmn.getName(); final String description = dmn.getDescription(); result.setId(IdPropertyConverter.wbFromDMN(dmn.getId())); result.setName(new Name(name)); result.setDescription(DescriptionPropertyConverter.wbFromDMN(description)); NameSpaceUtils.extractNamespacesKeyedByPrefix(dmn).forEach((key, value) -> result.getNsContext().put(key, value)); return result; } } | ImportConverter { public static Import wbFromDMN(final JSITImport dmn, final JSITDefinitions definitions, final PMMLDocumentMetadata pmmlDocument) { final Import result = createWBImport(dmn, definitions, pmmlDocument); final Map<QName, String> additionalAttributes = new HashMap<>(); final Map<javax.xml.namespace.QName, String> otherAttributes = JSITUnaryTests.getOtherAttributesMap(dmn); for (Map.Entry<javax.xml.namespace.QName, String> entry : otherAttributes.entrySet()) { additionalAttributes.put(QNamePropertyConverter.wbFromDMN(entry.getKey().toString()), entry.getValue()); } result.setAdditionalAttributes(additionalAttributes); final String name = dmn.getName(); final String description = dmn.getDescription(); result.setId(IdPropertyConverter.wbFromDMN(dmn.getId())); result.setName(new Name(name)); result.setDescription(DescriptionPropertyConverter.wbFromDMN(description)); NameSpaceUtils.extractNamespacesKeyedByPrefix(dmn).forEach((key, value) -> result.getNsContext().put(key, value)); return result; } static Import wbFromDMN(final JSITImport dmn,
final JSITDefinitions definitions,
final PMMLDocumentMetadata pmmlDocument); } | ImportConverter { public static Import wbFromDMN(final JSITImport dmn, final JSITDefinitions definitions, final PMMLDocumentMetadata pmmlDocument) { final Import result = createWBImport(dmn, definitions, pmmlDocument); final Map<QName, String> additionalAttributes = new HashMap<>(); final Map<javax.xml.namespace.QName, String> otherAttributes = JSITUnaryTests.getOtherAttributesMap(dmn); for (Map.Entry<javax.xml.namespace.QName, String> entry : otherAttributes.entrySet()) { additionalAttributes.put(QNamePropertyConverter.wbFromDMN(entry.getKey().toString()), entry.getValue()); } result.setAdditionalAttributes(additionalAttributes); final String name = dmn.getName(); final String description = dmn.getDescription(); result.setId(IdPropertyConverter.wbFromDMN(dmn.getId())); result.setName(new Name(name)); result.setDescription(DescriptionPropertyConverter.wbFromDMN(description)); NameSpaceUtils.extractNamespacesKeyedByPrefix(dmn).forEach((key, value) -> result.getNsContext().put(key, value)); return result; } static Import wbFromDMN(final JSITImport dmn,
final JSITDefinitions definitions,
final PMMLDocumentMetadata pmmlDocument); } |
@Test public void testIsNotSameParentAll() { Node parent = new NodeImpl<>("parentUUID"); Node child1 = new NodeImpl<>("child1"); Node child2 = new NodeImpl<>("child2"); Node[] children = {child1, child2}; boolean isSameParent = ContainmentAcceptorControlImpl.areInSameParent(parent, children); assertFalse(isSameParent); } | static boolean areInSameParent(final Element parent, final Node[] children) { return Stream.of(children) .map(GraphUtils::getParent) .noneMatch(childParent -> !Objects.equals(parent, childParent)); } | ContainmentAcceptorControlImpl extends AbstractAcceptorControl implements ContainmentAcceptorControl<AbstractCanvasHandler> { static boolean areInSameParent(final Element parent, final Node[] children) { return Stream.of(children) .map(GraphUtils::getParent) .noneMatch(childParent -> !Objects.equals(parent, childParent)); } } | ContainmentAcceptorControlImpl extends AbstractAcceptorControl implements ContainmentAcceptorControl<AbstractCanvasHandler> { static boolean areInSameParent(final Element parent, final Node[] children) { return Stream.of(children) .map(GraphUtils::getParent) .noneMatch(childParent -> !Objects.equals(parent, childParent)); } @Inject ContainmentAcceptorControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory,
final CanvasHighlight canvasHighlight); } | ContainmentAcceptorControlImpl extends AbstractAcceptorControl implements ContainmentAcceptorControl<AbstractCanvasHandler> { static boolean areInSameParent(final Element parent, final Node[] children) { return Stream.of(children) .map(GraphUtils::getParent) .noneMatch(childParent -> !Objects.equals(parent, childParent)); } @Inject ContainmentAcceptorControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory,
final CanvasHighlight canvasHighlight); @Override boolean allow(final Element parent,
final Node[] children); @Override boolean accept(final Element parent,
final Node[] children); } | ContainmentAcceptorControlImpl extends AbstractAcceptorControl implements ContainmentAcceptorControl<AbstractCanvasHandler> { static boolean areInSameParent(final Element parent, final Node[] children) { return Stream.of(children) .map(GraphUtils::getParent) .noneMatch(childParent -> !Objects.equals(parent, childParent)); } @Inject ContainmentAcceptorControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory,
final CanvasHighlight canvasHighlight); @Override boolean allow(final Element parent,
final Node[] children); @Override boolean accept(final Element parent,
final Node[] children); } |
@Test public void testIsNotSameParentNull() { Node parent = new NodeImpl<>("parentUUID"); Node child1 = new NodeImpl<>("child1"); setAsChild(parent, child1); Node child2 = new NodeImpl<>("child2"); setAsChild(parent, child2); Node[] children = {child1, child2}; boolean isSameParent = ContainmentAcceptorControlImpl.areInSameParent(null, children); assertFalse(isSameParent); } | static boolean areInSameParent(final Element parent, final Node[] children) { return Stream.of(children) .map(GraphUtils::getParent) .noneMatch(childParent -> !Objects.equals(parent, childParent)); } | ContainmentAcceptorControlImpl extends AbstractAcceptorControl implements ContainmentAcceptorControl<AbstractCanvasHandler> { static boolean areInSameParent(final Element parent, final Node[] children) { return Stream.of(children) .map(GraphUtils::getParent) .noneMatch(childParent -> !Objects.equals(parent, childParent)); } } | ContainmentAcceptorControlImpl extends AbstractAcceptorControl implements ContainmentAcceptorControl<AbstractCanvasHandler> { static boolean areInSameParent(final Element parent, final Node[] children) { return Stream.of(children) .map(GraphUtils::getParent) .noneMatch(childParent -> !Objects.equals(parent, childParent)); } @Inject ContainmentAcceptorControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory,
final CanvasHighlight canvasHighlight); } | ContainmentAcceptorControlImpl extends AbstractAcceptorControl implements ContainmentAcceptorControl<AbstractCanvasHandler> { static boolean areInSameParent(final Element parent, final Node[] children) { return Stream.of(children) .map(GraphUtils::getParent) .noneMatch(childParent -> !Objects.equals(parent, childParent)); } @Inject ContainmentAcceptorControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory,
final CanvasHighlight canvasHighlight); @Override boolean allow(final Element parent,
final Node[] children); @Override boolean accept(final Element parent,
final Node[] children); } | ContainmentAcceptorControlImpl extends AbstractAcceptorControl implements ContainmentAcceptorControl<AbstractCanvasHandler> { static boolean areInSameParent(final Element parent, final Node[] children) { return Stream.of(children) .map(GraphUtils::getParent) .noneMatch(childParent -> !Objects.equals(parent, childParent)); } @Inject ContainmentAcceptorControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory,
final CanvasHighlight canvasHighlight); @Override boolean allow(final Element parent,
final Node[] children); @Override boolean accept(final Element parent,
final Node[] children); } |
@Test public void testRegister() { tested.init(canvasHandler); assertFalse(tested.isRegistered(element)); tested.register(element); verify(shapeView, times(1)).supports(eq(ViewEventType.RESIZE)); verify(shapeView, times(1)).addHandler(eq(ViewEventType.RESIZE), any(ResizeHandler.class)); assertTrue(tested.isRegistered(element)); } | @Override @SuppressWarnings("unchecked") public void register(final Element element) { if (checkNotRegistered(element)) { final Canvas<?> canvas = canvasHandler.getCanvas(); final Shape<?> shape = canvas.getShape(element.getUUID()); if (supportsResize(shape)) { registerResizeHandlers(element, shape); } } } | ResizeControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements ResizeControl<AbstractCanvasHandler, Element> { @Override @SuppressWarnings("unchecked") public void register(final Element element) { if (checkNotRegistered(element)) { final Canvas<?> canvas = canvasHandler.getCanvas(); final Shape<?> shape = canvas.getShape(element.getUUID()); if (supportsResize(shape)) { registerResizeHandlers(element, shape); } } } } | ResizeControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements ResizeControl<AbstractCanvasHandler, Element> { @Override @SuppressWarnings("unchecked") public void register(final Element element) { if (checkNotRegistered(element)) { final Canvas<?> canvas = canvasHandler.getCanvas(); final Shape<?> shape = canvas.getShape(element.getUUID()); if (supportsResize(shape)) { registerResizeHandlers(element, shape); } } } protected ResizeControlImpl(); @Inject ResizeControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory); } | ResizeControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements ResizeControl<AbstractCanvasHandler, Element> { @Override @SuppressWarnings("unchecked") public void register(final Element element) { if (checkNotRegistered(element)) { final Canvas<?> canvas = canvasHandler.getCanvas(); final Shape<?> shape = canvas.getShape(element.getUUID()); if (supportsResize(shape)) { registerResizeHandlers(element, shape); } } } protected ResizeControlImpl(); @Inject ResizeControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory); @Override @SuppressWarnings("unchecked") void register(final Element element); @Override @SuppressWarnings("unchecked") CommandResult<CanvasViolation> resize(final Element element,
final double width,
final double height); @Override void setCommandManagerProvider(final RequiresCommandManager.CommandManagerProvider<AbstractCanvasHandler> provider); } | ResizeControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements ResizeControl<AbstractCanvasHandler, Element> { @Override @SuppressWarnings("unchecked") public void register(final Element element) { if (checkNotRegistered(element)) { final Canvas<?> canvas = canvasHandler.getCanvas(); final Shape<?> shape = canvas.getShape(element.getUUID()); if (supportsResize(shape)) { registerResizeHandlers(element, shape); } } } protected ResizeControlImpl(); @Inject ResizeControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory); @Override @SuppressWarnings("unchecked") void register(final Element element); @Override @SuppressWarnings("unchecked") CommandResult<CanvasViolation> resize(final Element element,
final double width,
final double height); @Override void setCommandManagerProvider(final RequiresCommandManager.CommandManagerProvider<AbstractCanvasHandler> provider); } |
@Test @SuppressWarnings("unchecked") public void testDeregister() { tested.init(canvasHandler); tested.register(element); tested.deregister(element); verify(shapeView, times(1)).removeHandler(any(ViewHandler.class)); assertFalse(tested.isRegistered(element)); } | @Override @SuppressWarnings("unchecked") public void register(final Element element) { if (checkNotRegistered(element)) { final Canvas<?> canvas = canvasHandler.getCanvas(); final Shape<?> shape = canvas.getShape(element.getUUID()); if (supportsResize(shape)) { registerResizeHandlers(element, shape); } } } | ResizeControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements ResizeControl<AbstractCanvasHandler, Element> { @Override @SuppressWarnings("unchecked") public void register(final Element element) { if (checkNotRegistered(element)) { final Canvas<?> canvas = canvasHandler.getCanvas(); final Shape<?> shape = canvas.getShape(element.getUUID()); if (supportsResize(shape)) { registerResizeHandlers(element, shape); } } } } | ResizeControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements ResizeControl<AbstractCanvasHandler, Element> { @Override @SuppressWarnings("unchecked") public void register(final Element element) { if (checkNotRegistered(element)) { final Canvas<?> canvas = canvasHandler.getCanvas(); final Shape<?> shape = canvas.getShape(element.getUUID()); if (supportsResize(shape)) { registerResizeHandlers(element, shape); } } } protected ResizeControlImpl(); @Inject ResizeControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory); } | ResizeControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements ResizeControl<AbstractCanvasHandler, Element> { @Override @SuppressWarnings("unchecked") public void register(final Element element) { if (checkNotRegistered(element)) { final Canvas<?> canvas = canvasHandler.getCanvas(); final Shape<?> shape = canvas.getShape(element.getUUID()); if (supportsResize(shape)) { registerResizeHandlers(element, shape); } } } protected ResizeControlImpl(); @Inject ResizeControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory); @Override @SuppressWarnings("unchecked") void register(final Element element); @Override @SuppressWarnings("unchecked") CommandResult<CanvasViolation> resize(final Element element,
final double width,
final double height); @Override void setCommandManagerProvider(final RequiresCommandManager.CommandManagerProvider<AbstractCanvasHandler> provider); } | ResizeControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements ResizeControl<AbstractCanvasHandler, Element> { @Override @SuppressWarnings("unchecked") public void register(final Element element) { if (checkNotRegistered(element)) { final Canvas<?> canvas = canvasHandler.getCanvas(); final Shape<?> shape = canvas.getShape(element.getUUID()); if (supportsResize(shape)) { registerResizeHandlers(element, shape); } } } protected ResizeControlImpl(); @Inject ResizeControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory); @Override @SuppressWarnings("unchecked") void register(final Element element); @Override @SuppressWarnings("unchecked") CommandResult<CanvasViolation> resize(final Element element,
final double width,
final double height); @Override void setCommandManagerProvider(final RequiresCommandManager.CommandManagerProvider<AbstractCanvasHandler> provider); } |
@Test @SuppressWarnings("unchecked") public void testResize() { tested.init(canvasHandler); assertFalse(tested.isRegistered(element)); tested.register(element); verify(shapeView, times(1)).supports(eq(ViewEventType.RESIZE)); ArgumentCaptor<ResizeHandler> resizeHandlerArgumentCaptor = ArgumentCaptor.forClass(ResizeHandler.class); verify(shapeView, times(1)).addHandler(eq(ViewEventType.RESIZE), resizeHandlerArgumentCaptor.capture()); final CanvasCommand expectedCommand = mock(CanvasCommand.class); doAnswer(invocationOnMock -> expectedCommand).when(canvasCommandFactory).resize(eq(element), any(BoundingBox.class)); ResizeHandler resizeHandler = resizeHandlerArgumentCaptor.getValue(); double x = 121.45d; double y = 23.456d; double width = 100d; double height = 200d; ResizeEvent event = new ResizeEvent(x, y, x, y, width, height); resizeHandler.end(event); ArgumentCaptor<CanvasCommand> commandArgumentCaptor = ArgumentCaptor.forClass(CanvasCommand.class); verify(commandManager, times(1)).execute(eq(canvasHandler), commandArgumentCaptor.capture()); CanvasCommand command = commandArgumentCaptor.getValue(); assertNotNull(command); assertEquals(expectedCommand, command); } | @Override @SuppressWarnings("unchecked") public CommandResult<CanvasViolation> resize(final Element element, final double width, final double height) { return doResize(element, width, height); } | ResizeControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements ResizeControl<AbstractCanvasHandler, Element> { @Override @SuppressWarnings("unchecked") public CommandResult<CanvasViolation> resize(final Element element, final double width, final double height) { return doResize(element, width, height); } } | ResizeControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements ResizeControl<AbstractCanvasHandler, Element> { @Override @SuppressWarnings("unchecked") public CommandResult<CanvasViolation> resize(final Element element, final double width, final double height) { return doResize(element, width, height); } protected ResizeControlImpl(); @Inject ResizeControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory); } | ResizeControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements ResizeControl<AbstractCanvasHandler, Element> { @Override @SuppressWarnings("unchecked") public CommandResult<CanvasViolation> resize(final Element element, final double width, final double height) { return doResize(element, width, height); } protected ResizeControlImpl(); @Inject ResizeControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory); @Override @SuppressWarnings("unchecked") void register(final Element element); @Override @SuppressWarnings("unchecked") CommandResult<CanvasViolation> resize(final Element element,
final double width,
final double height); @Override void setCommandManagerProvider(final RequiresCommandManager.CommandManagerProvider<AbstractCanvasHandler> provider); } | ResizeControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements ResizeControl<AbstractCanvasHandler, Element> { @Override @SuppressWarnings("unchecked") public CommandResult<CanvasViolation> resize(final Element element, final double width, final double height) { return doResize(element, width, height); } protected ResizeControlImpl(); @Inject ResizeControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory); @Override @SuppressWarnings("unchecked") void register(final Element element); @Override @SuppressWarnings("unchecked") CommandResult<CanvasViolation> resize(final Element element,
final double width,
final double height); @Override void setCommandManagerProvider(final RequiresCommandManager.CommandManagerProvider<AbstractCanvasHandler> provider); } |
@Test public void testOnCanvasSelectionEvent() { tested.onCanvasSelectionEvent(elementsSelectedEvent); verify(elementsSelectedEvent, times(2)).getIdentifiers(); } | @SuppressWarnings("unchecked") protected void onCanvasSelectionEvent(@Observes CanvasSelectionEvent event) { checkNotNull("event", event); if (event.getIdentifiers().size() == 1) { final String uuid = event.getIdentifiers().iterator().next(); if (isSameCanvas(event) && isRegistered(uuid)) { hideALLCPs(); final HasControlPoints<?> hasControlPoints = getControlPointsInstance(uuid); if (!hasControlPoints.areControlsVisible()) { showCPs(hasControlPoints); } } } else if (event.getIdentifiers().size() > 1){ hideALLCPs(); } } | ResizeControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements ResizeControl<AbstractCanvasHandler, Element> { @SuppressWarnings("unchecked") protected void onCanvasSelectionEvent(@Observes CanvasSelectionEvent event) { checkNotNull("event", event); if (event.getIdentifiers().size() == 1) { final String uuid = event.getIdentifiers().iterator().next(); if (isSameCanvas(event) && isRegistered(uuid)) { hideALLCPs(); final HasControlPoints<?> hasControlPoints = getControlPointsInstance(uuid); if (!hasControlPoints.areControlsVisible()) { showCPs(hasControlPoints); } } } else if (event.getIdentifiers().size() > 1){ hideALLCPs(); } } } | ResizeControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements ResizeControl<AbstractCanvasHandler, Element> { @SuppressWarnings("unchecked") protected void onCanvasSelectionEvent(@Observes CanvasSelectionEvent event) { checkNotNull("event", event); if (event.getIdentifiers().size() == 1) { final String uuid = event.getIdentifiers().iterator().next(); if (isSameCanvas(event) && isRegistered(uuid)) { hideALLCPs(); final HasControlPoints<?> hasControlPoints = getControlPointsInstance(uuid); if (!hasControlPoints.areControlsVisible()) { showCPs(hasControlPoints); } } } else if (event.getIdentifiers().size() > 1){ hideALLCPs(); } } protected ResizeControlImpl(); @Inject ResizeControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory); } | ResizeControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements ResizeControl<AbstractCanvasHandler, Element> { @SuppressWarnings("unchecked") protected void onCanvasSelectionEvent(@Observes CanvasSelectionEvent event) { checkNotNull("event", event); if (event.getIdentifiers().size() == 1) { final String uuid = event.getIdentifiers().iterator().next(); if (isSameCanvas(event) && isRegistered(uuid)) { hideALLCPs(); final HasControlPoints<?> hasControlPoints = getControlPointsInstance(uuid); if (!hasControlPoints.areControlsVisible()) { showCPs(hasControlPoints); } } } else if (event.getIdentifiers().size() > 1){ hideALLCPs(); } } protected ResizeControlImpl(); @Inject ResizeControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory); @Override @SuppressWarnings("unchecked") void register(final Element element); @Override @SuppressWarnings("unchecked") CommandResult<CanvasViolation> resize(final Element element,
final double width,
final double height); @Override void setCommandManagerProvider(final RequiresCommandManager.CommandManagerProvider<AbstractCanvasHandler> provider); } | ResizeControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements ResizeControl<AbstractCanvasHandler, Element> { @SuppressWarnings("unchecked") protected void onCanvasSelectionEvent(@Observes CanvasSelectionEvent event) { checkNotNull("event", event); if (event.getIdentifiers().size() == 1) { final String uuid = event.getIdentifiers().iterator().next(); if (isSameCanvas(event) && isRegistered(uuid)) { hideALLCPs(); final HasControlPoints<?> hasControlPoints = getControlPointsInstance(uuid); if (!hasControlPoints.areControlsVisible()) { showCPs(hasControlPoints); } } } else if (event.getIdentifiers().size() > 1){ hideALLCPs(); } } protected ResizeControlImpl(); @Inject ResizeControlImpl(final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory); @Override @SuppressWarnings("unchecked") void register(final Element element); @Override @SuppressWarnings("unchecked") CommandResult<CanvasViolation> resize(final Element element,
final double width,
final double height); @Override void setCommandManagerProvider(final RequiresCommandManager.CommandManagerProvider<AbstractCanvasHandler> provider); } |
@Test public void testRegisterAndClick() { tested.init(canvasHandler); tested.register(element); verify(selectionControl, times(1)).register(eq(element)); ArgumentCaptor<MouseClickHandler> clickHandlerCaptor = ArgumentCaptor.forClass(MouseClickHandler.class); verify(shapeViewHandlers, times(1)).supports(eq(ViewEventType.MOUSE_CLICK)); verify(shapeViewHandlers, times(1)).addHandler(eq(ViewEventType.MOUSE_CLICK), clickHandlerCaptor.capture()); final MouseClickHandler clickHandler = clickHandlerCaptor.getValue(); assertEquals(clickHandler, tested.getHandlers().get(ELEMENT_UUID)); MouseClickEvent event = mock(MouseClickEvent.class); when(event.isButtonLeft()).thenReturn(true); clickHandler.handle(event); verify(selectionControl, times(1)).select(eq(element.getUUID())); } | Map<String, ViewHandler<?>> getHandlers() { return handlers; } | LienzoSelectionControl extends AbstractSelectionControl<H> { Map<String, ViewHandler<?>> getHandlers() { return handlers; } } | LienzoSelectionControl extends AbstractSelectionControl<H> { Map<String, ViewHandler<?>> getHandlers() { return handlers; } @Inject LienzoSelectionControl(final Event<CanvasSelectionEvent> canvasSelectionEvent,
final Event<CanvasClearSelectionEvent> clearSelectionEvent); LienzoSelectionControl(final MapSelectionControl<H> selectionControl,
final Event<CanvasSelectionEvent> canvasSelectionEvent,
final Event<CanvasClearSelectionEvent> clearSelectionEvent); } | LienzoSelectionControl extends AbstractSelectionControl<H> { Map<String, ViewHandler<?>> getHandlers() { return handlers; } @Inject LienzoSelectionControl(final Event<CanvasSelectionEvent> canvasSelectionEvent,
final Event<CanvasClearSelectionEvent> clearSelectionEvent); LienzoSelectionControl(final MapSelectionControl<H> selectionControl,
final Event<CanvasSelectionEvent> canvasSelectionEvent,
final Event<CanvasClearSelectionEvent> clearSelectionEvent); } | LienzoSelectionControl extends AbstractSelectionControl<H> { Map<String, ViewHandler<?>> getHandlers() { return handlers; } @Inject LienzoSelectionControl(final Event<CanvasSelectionEvent> canvasSelectionEvent,
final Event<CanvasClearSelectionEvent> clearSelectionEvent); LienzoSelectionControl(final MapSelectionControl<H> selectionControl,
final Event<CanvasSelectionEvent> canvasSelectionEvent,
final Event<CanvasClearSelectionEvent> clearSelectionEvent); } |
@Test public void testSelectionIsSingle() { when(selectionControl.getSelectedItems()).thenReturn(Collections.singletonList(ELEMENT_UUID)); tested.init(canvasHandler); tested.register(element); tested.singleSelect(element); verify(selectionControl, times(1)).clearSelection(); verify(selectionControl, times(1)).select(eq(element.getUUID())); } | void singleSelect(final Element element) { if (!getSelectedItems().isEmpty()) { clearSelection(); } select(element.getUUID()); } | LienzoSelectionControl extends AbstractSelectionControl<H> { void singleSelect(final Element element) { if (!getSelectedItems().isEmpty()) { clearSelection(); } select(element.getUUID()); } } | LienzoSelectionControl extends AbstractSelectionControl<H> { void singleSelect(final Element element) { if (!getSelectedItems().isEmpty()) { clearSelection(); } select(element.getUUID()); } @Inject LienzoSelectionControl(final Event<CanvasSelectionEvent> canvasSelectionEvent,
final Event<CanvasClearSelectionEvent> clearSelectionEvent); LienzoSelectionControl(final MapSelectionControl<H> selectionControl,
final Event<CanvasSelectionEvent> canvasSelectionEvent,
final Event<CanvasClearSelectionEvent> clearSelectionEvent); } | LienzoSelectionControl extends AbstractSelectionControl<H> { void singleSelect(final Element element) { if (!getSelectedItems().isEmpty()) { clearSelection(); } select(element.getUUID()); } @Inject LienzoSelectionControl(final Event<CanvasSelectionEvent> canvasSelectionEvent,
final Event<CanvasClearSelectionEvent> clearSelectionEvent); LienzoSelectionControl(final MapSelectionControl<H> selectionControl,
final Event<CanvasSelectionEvent> canvasSelectionEvent,
final Event<CanvasClearSelectionEvent> clearSelectionEvent); } | LienzoSelectionControl extends AbstractSelectionControl<H> { void singleSelect(final Element element) { if (!getSelectedItems().isEmpty()) { clearSelection(); } select(element.getUUID()); } @Inject LienzoSelectionControl(final Event<CanvasSelectionEvent> canvasSelectionEvent,
final Event<CanvasClearSelectionEvent> clearSelectionEvent); LienzoSelectionControl(final MapSelectionControl<H> selectionControl,
final Event<CanvasSelectionEvent> canvasSelectionEvent,
final Event<CanvasClearSelectionEvent> clearSelectionEvent); } |
@Test public void testClearSelection() { tested.init(canvasHandler); tested.register(element); tested.singleSelect(element); tested.clearSelection(); verify(selectionControl, times(1)).clearSelection(); } | void singleSelect(final Element element) { if (!getSelectedItems().isEmpty()) { clearSelection(); } select(element.getUUID()); } | LienzoSelectionControl extends AbstractSelectionControl<H> { void singleSelect(final Element element) { if (!getSelectedItems().isEmpty()) { clearSelection(); } select(element.getUUID()); } } | LienzoSelectionControl extends AbstractSelectionControl<H> { void singleSelect(final Element element) { if (!getSelectedItems().isEmpty()) { clearSelection(); } select(element.getUUID()); } @Inject LienzoSelectionControl(final Event<CanvasSelectionEvent> canvasSelectionEvent,
final Event<CanvasClearSelectionEvent> clearSelectionEvent); LienzoSelectionControl(final MapSelectionControl<H> selectionControl,
final Event<CanvasSelectionEvent> canvasSelectionEvent,
final Event<CanvasClearSelectionEvent> clearSelectionEvent); } | LienzoSelectionControl extends AbstractSelectionControl<H> { void singleSelect(final Element element) { if (!getSelectedItems().isEmpty()) { clearSelection(); } select(element.getUUID()); } @Inject LienzoSelectionControl(final Event<CanvasSelectionEvent> canvasSelectionEvent,
final Event<CanvasClearSelectionEvent> clearSelectionEvent); LienzoSelectionControl(final MapSelectionControl<H> selectionControl,
final Event<CanvasSelectionEvent> canvasSelectionEvent,
final Event<CanvasClearSelectionEvent> clearSelectionEvent); } | LienzoSelectionControl extends AbstractSelectionControl<H> { void singleSelect(final Element element) { if (!getSelectedItems().isEmpty()) { clearSelection(); } select(element.getUUID()); } @Inject LienzoSelectionControl(final Event<CanvasSelectionEvent> canvasSelectionEvent,
final Event<CanvasClearSelectionEvent> clearSelectionEvent); LienzoSelectionControl(final MapSelectionControl<H> selectionControl,
final Event<CanvasSelectionEvent> canvasSelectionEvent,
final Event<CanvasClearSelectionEvent> clearSelectionEvent); } |
@Test @SuppressWarnings("unchecked") public void testDeregister() { tested.init(canvasHandler); tested.register(element); tested.deregister(element); verify(selectionControl, times(1)).deregister(eq(element)); verify(shapeViewHandlers, times(1)).removeHandler(any(ViewHandler.class)); assertTrue(tested.getHandlers().isEmpty()); } | protected void deregister(final String uuid) { final Shape shape = getSelectionControl().getCanvas().getShape(uuid); final ViewHandler<?> handler = handlers.get(uuid); doDeregisterHandler(shape, handler); } | LienzoSelectionControl extends AbstractSelectionControl<H> { protected void deregister(final String uuid) { final Shape shape = getSelectionControl().getCanvas().getShape(uuid); final ViewHandler<?> handler = handlers.get(uuid); doDeregisterHandler(shape, handler); } } | LienzoSelectionControl extends AbstractSelectionControl<H> { protected void deregister(final String uuid) { final Shape shape = getSelectionControl().getCanvas().getShape(uuid); final ViewHandler<?> handler = handlers.get(uuid); doDeregisterHandler(shape, handler); } @Inject LienzoSelectionControl(final Event<CanvasSelectionEvent> canvasSelectionEvent,
final Event<CanvasClearSelectionEvent> clearSelectionEvent); LienzoSelectionControl(final MapSelectionControl<H> selectionControl,
final Event<CanvasSelectionEvent> canvasSelectionEvent,
final Event<CanvasClearSelectionEvent> clearSelectionEvent); } | LienzoSelectionControl extends AbstractSelectionControl<H> { protected void deregister(final String uuid) { final Shape shape = getSelectionControl().getCanvas().getShape(uuid); final ViewHandler<?> handler = handlers.get(uuid); doDeregisterHandler(shape, handler); } @Inject LienzoSelectionControl(final Event<CanvasSelectionEvent> canvasSelectionEvent,
final Event<CanvasClearSelectionEvent> clearSelectionEvent); LienzoSelectionControl(final MapSelectionControl<H> selectionControl,
final Event<CanvasSelectionEvent> canvasSelectionEvent,
final Event<CanvasClearSelectionEvent> clearSelectionEvent); } | LienzoSelectionControl extends AbstractSelectionControl<H> { protected void deregister(final String uuid) { final Shape shape = getSelectionControl().getCanvas().getShape(uuid); final ViewHandler<?> handler = handlers.get(uuid); doDeregisterHandler(shape, handler); } @Inject LienzoSelectionControl(final Event<CanvasSelectionEvent> canvasSelectionEvent,
final Event<CanvasClearSelectionEvent> clearSelectionEvent); LienzoSelectionControl(final MapSelectionControl<H> selectionControl,
final Event<CanvasSelectionEvent> canvasSelectionEvent,
final Event<CanvasClearSelectionEvent> clearSelectionEvent); } |
@Test public void wbFromDMN_PMMLImportNoModels() { when(jsitImportMock.getImportType()).thenReturn(PMML_IMPORT_TYPE); Import resultImport = ImportConverter.wbFromDMN(jsitImportMock, null, pmmlDocumentMetadata); assertTrue(resultImport instanceof ImportPMML); assertEquals(LOCATION_URI, resultImport.getLocationURI().getValue()); assertEquals(NAME, resultImport.getNamespace()); assertEquals(DESCRIPTION, resultImport.getDescription().getValue()); assertEquals(NAME, resultImport.getName().getValue()); assertEquals(PMML_IMPORT_TYPE, resultImport.getImportType()); assertNotNull(resultImport.getId().getValue()); assertEquals(0, ((ImportPMML) resultImport).getModelCount()); } | public static Import wbFromDMN(final JSITImport dmn, final JSITDefinitions definitions, final PMMLDocumentMetadata pmmlDocument) { final Import result = createWBImport(dmn, definitions, pmmlDocument); final Map<QName, String> additionalAttributes = new HashMap<>(); final Map<javax.xml.namespace.QName, String> otherAttributes = JSITUnaryTests.getOtherAttributesMap(dmn); for (Map.Entry<javax.xml.namespace.QName, String> entry : otherAttributes.entrySet()) { additionalAttributes.put(QNamePropertyConverter.wbFromDMN(entry.getKey().toString()), entry.getValue()); } result.setAdditionalAttributes(additionalAttributes); final String name = dmn.getName(); final String description = dmn.getDescription(); result.setId(IdPropertyConverter.wbFromDMN(dmn.getId())); result.setName(new Name(name)); result.setDescription(DescriptionPropertyConverter.wbFromDMN(description)); NameSpaceUtils.extractNamespacesKeyedByPrefix(dmn).forEach((key, value) -> result.getNsContext().put(key, value)); return result; } | ImportConverter { public static Import wbFromDMN(final JSITImport dmn, final JSITDefinitions definitions, final PMMLDocumentMetadata pmmlDocument) { final Import result = createWBImport(dmn, definitions, pmmlDocument); final Map<QName, String> additionalAttributes = new HashMap<>(); final Map<javax.xml.namespace.QName, String> otherAttributes = JSITUnaryTests.getOtherAttributesMap(dmn); for (Map.Entry<javax.xml.namespace.QName, String> entry : otherAttributes.entrySet()) { additionalAttributes.put(QNamePropertyConverter.wbFromDMN(entry.getKey().toString()), entry.getValue()); } result.setAdditionalAttributes(additionalAttributes); final String name = dmn.getName(); final String description = dmn.getDescription(); result.setId(IdPropertyConverter.wbFromDMN(dmn.getId())); result.setName(new Name(name)); result.setDescription(DescriptionPropertyConverter.wbFromDMN(description)); NameSpaceUtils.extractNamespacesKeyedByPrefix(dmn).forEach((key, value) -> result.getNsContext().put(key, value)); return result; } } | ImportConverter { public static Import wbFromDMN(final JSITImport dmn, final JSITDefinitions definitions, final PMMLDocumentMetadata pmmlDocument) { final Import result = createWBImport(dmn, definitions, pmmlDocument); final Map<QName, String> additionalAttributes = new HashMap<>(); final Map<javax.xml.namespace.QName, String> otherAttributes = JSITUnaryTests.getOtherAttributesMap(dmn); for (Map.Entry<javax.xml.namespace.QName, String> entry : otherAttributes.entrySet()) { additionalAttributes.put(QNamePropertyConverter.wbFromDMN(entry.getKey().toString()), entry.getValue()); } result.setAdditionalAttributes(additionalAttributes); final String name = dmn.getName(); final String description = dmn.getDescription(); result.setId(IdPropertyConverter.wbFromDMN(dmn.getId())); result.setName(new Name(name)); result.setDescription(DescriptionPropertyConverter.wbFromDMN(description)); NameSpaceUtils.extractNamespacesKeyedByPrefix(dmn).forEach((key, value) -> result.getNsContext().put(key, value)); return result; } } | ImportConverter { public static Import wbFromDMN(final JSITImport dmn, final JSITDefinitions definitions, final PMMLDocumentMetadata pmmlDocument) { final Import result = createWBImport(dmn, definitions, pmmlDocument); final Map<QName, String> additionalAttributes = new HashMap<>(); final Map<javax.xml.namespace.QName, String> otherAttributes = JSITUnaryTests.getOtherAttributesMap(dmn); for (Map.Entry<javax.xml.namespace.QName, String> entry : otherAttributes.entrySet()) { additionalAttributes.put(QNamePropertyConverter.wbFromDMN(entry.getKey().toString()), entry.getValue()); } result.setAdditionalAttributes(additionalAttributes); final String name = dmn.getName(); final String description = dmn.getDescription(); result.setId(IdPropertyConverter.wbFromDMN(dmn.getId())); result.setName(new Name(name)); result.setDescription(DescriptionPropertyConverter.wbFromDMN(description)); NameSpaceUtils.extractNamespacesKeyedByPrefix(dmn).forEach((key, value) -> result.getNsContext().put(key, value)); return result; } static Import wbFromDMN(final JSITImport dmn,
final JSITDefinitions definitions,
final PMMLDocumentMetadata pmmlDocument); } | ImportConverter { public static Import wbFromDMN(final JSITImport dmn, final JSITDefinitions definitions, final PMMLDocumentMetadata pmmlDocument) { final Import result = createWBImport(dmn, definitions, pmmlDocument); final Map<QName, String> additionalAttributes = new HashMap<>(); final Map<javax.xml.namespace.QName, String> otherAttributes = JSITUnaryTests.getOtherAttributesMap(dmn); for (Map.Entry<javax.xml.namespace.QName, String> entry : otherAttributes.entrySet()) { additionalAttributes.put(QNamePropertyConverter.wbFromDMN(entry.getKey().toString()), entry.getValue()); } result.setAdditionalAttributes(additionalAttributes); final String name = dmn.getName(); final String description = dmn.getDescription(); result.setId(IdPropertyConverter.wbFromDMN(dmn.getId())); result.setName(new Name(name)); result.setDescription(DescriptionPropertyConverter.wbFromDMN(description)); NameSpaceUtils.extractNamespacesKeyedByPrefix(dmn).forEach((key, value) -> result.getNsContext().put(key, value)); return result; } static Import wbFromDMN(final JSITImport dmn,
final JSITDefinitions definitions,
final PMMLDocumentMetadata pmmlDocument); } |
@Test public void testInitialize() { CanvasPanel panel = mock(CanvasPanel.class); CanvasSettings settings = mock(CanvasSettings.class); when(settings.isHiDPIEnabled()).thenReturn(true); assertEquals(tested, tested.initialize(panel, settings)); assertTrue(LienzoCore.get().isHidpiEnabled()); assertNotNull(tested.getEventHandlerManager()); verify(view, times(1)).initialize(eq(panel), eq(settings)); } | public AbstractCanvas<V> initialize(final CanvasPanel panel, final CanvasSettings settings) { eventHandlerManager = new ViewEventHandlerManager(getView().getLayer().getLienzoLayer(), SUPPORTED_EVENT_TYPES); return initialize(panel, settings, eventHandlerManager); } | LienzoCanvas extends AbstractCanvas<V> { public AbstractCanvas<V> initialize(final CanvasPanel panel, final CanvasSettings settings) { eventHandlerManager = new ViewEventHandlerManager(getView().getLayer().getLienzoLayer(), SUPPORTED_EVENT_TYPES); return initialize(panel, settings, eventHandlerManager); } } | LienzoCanvas extends AbstractCanvas<V> { public AbstractCanvas<V> initialize(final CanvasPanel panel, final CanvasSettings settings) { eventHandlerManager = new ViewEventHandlerManager(getView().getLayer().getLienzoLayer(), SUPPORTED_EVENT_TYPES); return initialize(panel, settings, eventHandlerManager); } protected LienzoCanvas(final Event<CanvasClearEvent> canvasClearEvent,
final Event<CanvasShapeAddedEvent> canvasShapeAddedEvent,
final Event<CanvasShapeRemovedEvent> canvasShapeRemovedEvent,
final Event<CanvasDrawnEvent> canvasDrawnEvent,
final Event<CanvasFocusedEvent> canvasFocusedEvent); } | LienzoCanvas extends AbstractCanvas<V> { public AbstractCanvas<V> initialize(final CanvasPanel panel, final CanvasSettings settings) { eventHandlerManager = new ViewEventHandlerManager(getView().getLayer().getLienzoLayer(), SUPPORTED_EVENT_TYPES); return initialize(panel, settings, eventHandlerManager); } protected LienzoCanvas(final Event<CanvasClearEvent> canvasClearEvent,
final Event<CanvasShapeAddedEvent> canvasShapeAddedEvent,
final Event<CanvasShapeRemovedEvent> canvasShapeRemovedEvent,
final Event<CanvasDrawnEvent> canvasDrawnEvent,
final Event<CanvasFocusedEvent> canvasFocusedEvent); AbstractCanvas<V> initialize(final CanvasPanel panel,
final CanvasSettings settings); @Override Optional<Shape> getShapeAt(final double x,
final double y); @Override void onAfterDraw(final Command callback); @Override void focus(); @Override boolean supports(final ViewEventType type); @Override AbstractCanvas<V> addHandler(final ViewEventType type,
final ViewHandler<? extends ViewEvent> eventHandler); @Override AbstractCanvas<V> removeHandler(final ViewHandler<? extends ViewEvent> eventHandler); @Override AbstractCanvas<V> enableHandlers(); @Override AbstractCanvas<V> disableHandlers(); @Override Shape<?> getAttachableShape(); @Override void destroy(); } | LienzoCanvas extends AbstractCanvas<V> { public AbstractCanvas<V> initialize(final CanvasPanel panel, final CanvasSettings settings) { eventHandlerManager = new ViewEventHandlerManager(getView().getLayer().getLienzoLayer(), SUPPORTED_EVENT_TYPES); return initialize(panel, settings, eventHandlerManager); } protected LienzoCanvas(final Event<CanvasClearEvent> canvasClearEvent,
final Event<CanvasShapeAddedEvent> canvasShapeAddedEvent,
final Event<CanvasShapeRemovedEvent> canvasShapeRemovedEvent,
final Event<CanvasDrawnEvent> canvasDrawnEvent,
final Event<CanvasFocusedEvent> canvasFocusedEvent); AbstractCanvas<V> initialize(final CanvasPanel panel,
final CanvasSettings settings); @Override Optional<Shape> getShapeAt(final double x,
final double y); @Override void onAfterDraw(final Command callback); @Override void focus(); @Override boolean supports(final ViewEventType type); @Override AbstractCanvas<V> addHandler(final ViewEventType type,
final ViewHandler<? extends ViewEvent> eventHandler); @Override AbstractCanvas<V> removeHandler(final ViewHandler<? extends ViewEvent> eventHandler); @Override AbstractCanvas<V> enableHandlers(); @Override AbstractCanvas<V> disableHandlers(); @Override Shape<?> getAttachableShape(); @Override void destroy(); } |
@Test @SuppressWarnings("unchecked") public void testGetShapeAt() { double x = 10; double y = 33; com.ait.lienzo.client.core.shape.Shape lienzoShape = mock(com.ait.lienzo.client.core.shape.Shape.class); WiresUtils.UserData userData = new WiresUtils.UserData("uuid1", "group1"); when(lienzoShape.getUserData()).thenReturn(userData); when(layer.findShapeAtPoint(eq(10), eq(33))).thenReturn(lienzoShape); Shape stunnerShape = mock(Shape.class); when(tested.getShape(eq("uuid1"))).thenReturn(stunnerShape); Optional<Shape> shape = tested.getShapeAt(x, y); assertTrue(shape.isPresent()); assertEquals(stunnerShape, shape.get()); } | @Override public Optional<Shape> getShapeAt(final double x, final double y) { final LienzoLayer lienzoLayer = getView().getLayer(); final String uuid = LienzoLayerUtils.getUUID_At(lienzoLayer, x, y); return Optional.ofNullable(getShape(uuid)); } | LienzoCanvas extends AbstractCanvas<V> { @Override public Optional<Shape> getShapeAt(final double x, final double y) { final LienzoLayer lienzoLayer = getView().getLayer(); final String uuid = LienzoLayerUtils.getUUID_At(lienzoLayer, x, y); return Optional.ofNullable(getShape(uuid)); } } | LienzoCanvas extends AbstractCanvas<V> { @Override public Optional<Shape> getShapeAt(final double x, final double y) { final LienzoLayer lienzoLayer = getView().getLayer(); final String uuid = LienzoLayerUtils.getUUID_At(lienzoLayer, x, y); return Optional.ofNullable(getShape(uuid)); } protected LienzoCanvas(final Event<CanvasClearEvent> canvasClearEvent,
final Event<CanvasShapeAddedEvent> canvasShapeAddedEvent,
final Event<CanvasShapeRemovedEvent> canvasShapeRemovedEvent,
final Event<CanvasDrawnEvent> canvasDrawnEvent,
final Event<CanvasFocusedEvent> canvasFocusedEvent); } | LienzoCanvas extends AbstractCanvas<V> { @Override public Optional<Shape> getShapeAt(final double x, final double y) { final LienzoLayer lienzoLayer = getView().getLayer(); final String uuid = LienzoLayerUtils.getUUID_At(lienzoLayer, x, y); return Optional.ofNullable(getShape(uuid)); } protected LienzoCanvas(final Event<CanvasClearEvent> canvasClearEvent,
final Event<CanvasShapeAddedEvent> canvasShapeAddedEvent,
final Event<CanvasShapeRemovedEvent> canvasShapeRemovedEvent,
final Event<CanvasDrawnEvent> canvasDrawnEvent,
final Event<CanvasFocusedEvent> canvasFocusedEvent); AbstractCanvas<V> initialize(final CanvasPanel panel,
final CanvasSettings settings); @Override Optional<Shape> getShapeAt(final double x,
final double y); @Override void onAfterDraw(final Command callback); @Override void focus(); @Override boolean supports(final ViewEventType type); @Override AbstractCanvas<V> addHandler(final ViewEventType type,
final ViewHandler<? extends ViewEvent> eventHandler); @Override AbstractCanvas<V> removeHandler(final ViewHandler<? extends ViewEvent> eventHandler); @Override AbstractCanvas<V> enableHandlers(); @Override AbstractCanvas<V> disableHandlers(); @Override Shape<?> getAttachableShape(); @Override void destroy(); } | LienzoCanvas extends AbstractCanvas<V> { @Override public Optional<Shape> getShapeAt(final double x, final double y) { final LienzoLayer lienzoLayer = getView().getLayer(); final String uuid = LienzoLayerUtils.getUUID_At(lienzoLayer, x, y); return Optional.ofNullable(getShape(uuid)); } protected LienzoCanvas(final Event<CanvasClearEvent> canvasClearEvent,
final Event<CanvasShapeAddedEvent> canvasShapeAddedEvent,
final Event<CanvasShapeRemovedEvent> canvasShapeRemovedEvent,
final Event<CanvasDrawnEvent> canvasDrawnEvent,
final Event<CanvasFocusedEvent> canvasFocusedEvent); AbstractCanvas<V> initialize(final CanvasPanel panel,
final CanvasSettings settings); @Override Optional<Shape> getShapeAt(final double x,
final double y); @Override void onAfterDraw(final Command callback); @Override void focus(); @Override boolean supports(final ViewEventType type); @Override AbstractCanvas<V> addHandler(final ViewEventType type,
final ViewHandler<? extends ViewEvent> eventHandler); @Override AbstractCanvas<V> removeHandler(final ViewHandler<? extends ViewEvent> eventHandler); @Override AbstractCanvas<V> enableHandlers(); @Override AbstractCanvas<V> disableHandlers(); @Override Shape<?> getAttachableShape(); @Override void destroy(); } |
@Test public void testOnAfterDraw() { Command callback = mock(Command.class); tested.onAfterDraw(callback); verify(lienzoLayer, times(1)).onAfterDraw(eq(callback)); } | @Override public void onAfterDraw(final Command callback) { getView().getLayer().onAfterDraw(callback); } | LienzoCanvas extends AbstractCanvas<V> { @Override public void onAfterDraw(final Command callback) { getView().getLayer().onAfterDraw(callback); } } | LienzoCanvas extends AbstractCanvas<V> { @Override public void onAfterDraw(final Command callback) { getView().getLayer().onAfterDraw(callback); } protected LienzoCanvas(final Event<CanvasClearEvent> canvasClearEvent,
final Event<CanvasShapeAddedEvent> canvasShapeAddedEvent,
final Event<CanvasShapeRemovedEvent> canvasShapeRemovedEvent,
final Event<CanvasDrawnEvent> canvasDrawnEvent,
final Event<CanvasFocusedEvent> canvasFocusedEvent); } | LienzoCanvas extends AbstractCanvas<V> { @Override public void onAfterDraw(final Command callback) { getView().getLayer().onAfterDraw(callback); } protected LienzoCanvas(final Event<CanvasClearEvent> canvasClearEvent,
final Event<CanvasShapeAddedEvent> canvasShapeAddedEvent,
final Event<CanvasShapeRemovedEvent> canvasShapeRemovedEvent,
final Event<CanvasDrawnEvent> canvasDrawnEvent,
final Event<CanvasFocusedEvent> canvasFocusedEvent); AbstractCanvas<V> initialize(final CanvasPanel panel,
final CanvasSettings settings); @Override Optional<Shape> getShapeAt(final double x,
final double y); @Override void onAfterDraw(final Command callback); @Override void focus(); @Override boolean supports(final ViewEventType type); @Override AbstractCanvas<V> addHandler(final ViewEventType type,
final ViewHandler<? extends ViewEvent> eventHandler); @Override AbstractCanvas<V> removeHandler(final ViewHandler<? extends ViewEvent> eventHandler); @Override AbstractCanvas<V> enableHandlers(); @Override AbstractCanvas<V> disableHandlers(); @Override Shape<?> getAttachableShape(); @Override void destroy(); } | LienzoCanvas extends AbstractCanvas<V> { @Override public void onAfterDraw(final Command callback) { getView().getLayer().onAfterDraw(callback); } protected LienzoCanvas(final Event<CanvasClearEvent> canvasClearEvent,
final Event<CanvasShapeAddedEvent> canvasShapeAddedEvent,
final Event<CanvasShapeRemovedEvent> canvasShapeRemovedEvent,
final Event<CanvasDrawnEvent> canvasDrawnEvent,
final Event<CanvasFocusedEvent> canvasFocusedEvent); AbstractCanvas<V> initialize(final CanvasPanel panel,
final CanvasSettings settings); @Override Optional<Shape> getShapeAt(final double x,
final double y); @Override void onAfterDraw(final Command callback); @Override void focus(); @Override boolean supports(final ViewEventType type); @Override AbstractCanvas<V> addHandler(final ViewEventType type,
final ViewHandler<? extends ViewEvent> eventHandler); @Override AbstractCanvas<V> removeHandler(final ViewHandler<? extends ViewEvent> eventHandler); @Override AbstractCanvas<V> enableHandlers(); @Override AbstractCanvas<V> disableHandlers(); @Override Shape<?> getAttachableShape(); @Override void destroy(); } |
@Test public void testFocus() { LienzoPanel panel = mock(LienzoPanel.class); when(view.getLienzoPanel()).thenReturn(panel); tested.focus(); verify(panel, times(1)).focus(); } | @Override public void focus() { getView().getLienzoPanel().focus(); } | LienzoCanvas extends AbstractCanvas<V> { @Override public void focus() { getView().getLienzoPanel().focus(); } } | LienzoCanvas extends AbstractCanvas<V> { @Override public void focus() { getView().getLienzoPanel().focus(); } protected LienzoCanvas(final Event<CanvasClearEvent> canvasClearEvent,
final Event<CanvasShapeAddedEvent> canvasShapeAddedEvent,
final Event<CanvasShapeRemovedEvent> canvasShapeRemovedEvent,
final Event<CanvasDrawnEvent> canvasDrawnEvent,
final Event<CanvasFocusedEvent> canvasFocusedEvent); } | LienzoCanvas extends AbstractCanvas<V> { @Override public void focus() { getView().getLienzoPanel().focus(); } protected LienzoCanvas(final Event<CanvasClearEvent> canvasClearEvent,
final Event<CanvasShapeAddedEvent> canvasShapeAddedEvent,
final Event<CanvasShapeRemovedEvent> canvasShapeRemovedEvent,
final Event<CanvasDrawnEvent> canvasDrawnEvent,
final Event<CanvasFocusedEvent> canvasFocusedEvent); AbstractCanvas<V> initialize(final CanvasPanel panel,
final CanvasSettings settings); @Override Optional<Shape> getShapeAt(final double x,
final double y); @Override void onAfterDraw(final Command callback); @Override void focus(); @Override boolean supports(final ViewEventType type); @Override AbstractCanvas<V> addHandler(final ViewEventType type,
final ViewHandler<? extends ViewEvent> eventHandler); @Override AbstractCanvas<V> removeHandler(final ViewHandler<? extends ViewEvent> eventHandler); @Override AbstractCanvas<V> enableHandlers(); @Override AbstractCanvas<V> disableHandlers(); @Override Shape<?> getAttachableShape(); @Override void destroy(); } | LienzoCanvas extends AbstractCanvas<V> { @Override public void focus() { getView().getLienzoPanel().focus(); } protected LienzoCanvas(final Event<CanvasClearEvent> canvasClearEvent,
final Event<CanvasShapeAddedEvent> canvasShapeAddedEvent,
final Event<CanvasShapeRemovedEvent> canvasShapeRemovedEvent,
final Event<CanvasDrawnEvent> canvasDrawnEvent,
final Event<CanvasFocusedEvent> canvasFocusedEvent); AbstractCanvas<V> initialize(final CanvasPanel panel,
final CanvasSettings settings); @Override Optional<Shape> getShapeAt(final double x,
final double y); @Override void onAfterDraw(final Command callback); @Override void focus(); @Override boolean supports(final ViewEventType type); @Override AbstractCanvas<V> addHandler(final ViewEventType type,
final ViewHandler<? extends ViewEvent> eventHandler); @Override AbstractCanvas<V> removeHandler(final ViewHandler<? extends ViewEvent> eventHandler); @Override AbstractCanvas<V> enableHandlers(); @Override AbstractCanvas<V> disableHandlers(); @Override Shape<?> getAttachableShape(); @Override void destroy(); } |
@Test public void testDestroy() { CanvasPanel panel = mock(CanvasPanel.class); CanvasSettings settings = mock(CanvasSettings.class); ViewEventHandlerManager eventHandler = mock(ViewEventHandlerManager.class); tested.initialize(panel, settings, eventHandler); tested.destroy(); verify(eventHandler, times(1)).destroy(); verify(view, times(1)).destroy(); } | @Override public void destroy() { if (null != eventHandlerManager) { eventHandlerManager.destroy(); eventHandlerManager = null; } super.destroy(); } | LienzoCanvas extends AbstractCanvas<V> { @Override public void destroy() { if (null != eventHandlerManager) { eventHandlerManager.destroy(); eventHandlerManager = null; } super.destroy(); } } | LienzoCanvas extends AbstractCanvas<V> { @Override public void destroy() { if (null != eventHandlerManager) { eventHandlerManager.destroy(); eventHandlerManager = null; } super.destroy(); } protected LienzoCanvas(final Event<CanvasClearEvent> canvasClearEvent,
final Event<CanvasShapeAddedEvent> canvasShapeAddedEvent,
final Event<CanvasShapeRemovedEvent> canvasShapeRemovedEvent,
final Event<CanvasDrawnEvent> canvasDrawnEvent,
final Event<CanvasFocusedEvent> canvasFocusedEvent); } | LienzoCanvas extends AbstractCanvas<V> { @Override public void destroy() { if (null != eventHandlerManager) { eventHandlerManager.destroy(); eventHandlerManager = null; } super.destroy(); } protected LienzoCanvas(final Event<CanvasClearEvent> canvasClearEvent,
final Event<CanvasShapeAddedEvent> canvasShapeAddedEvent,
final Event<CanvasShapeRemovedEvent> canvasShapeRemovedEvent,
final Event<CanvasDrawnEvent> canvasDrawnEvent,
final Event<CanvasFocusedEvent> canvasFocusedEvent); AbstractCanvas<V> initialize(final CanvasPanel panel,
final CanvasSettings settings); @Override Optional<Shape> getShapeAt(final double x,
final double y); @Override void onAfterDraw(final Command callback); @Override void focus(); @Override boolean supports(final ViewEventType type); @Override AbstractCanvas<V> addHandler(final ViewEventType type,
final ViewHandler<? extends ViewEvent> eventHandler); @Override AbstractCanvas<V> removeHandler(final ViewHandler<? extends ViewEvent> eventHandler); @Override AbstractCanvas<V> enableHandlers(); @Override AbstractCanvas<V> disableHandlers(); @Override Shape<?> getAttachableShape(); @Override void destroy(); } | LienzoCanvas extends AbstractCanvas<V> { @Override public void destroy() { if (null != eventHandlerManager) { eventHandlerManager.destroy(); eventHandlerManager = null; } super.destroy(); } protected LienzoCanvas(final Event<CanvasClearEvent> canvasClearEvent,
final Event<CanvasShapeAddedEvent> canvasShapeAddedEvent,
final Event<CanvasShapeRemovedEvent> canvasShapeRemovedEvent,
final Event<CanvasDrawnEvent> canvasDrawnEvent,
final Event<CanvasFocusedEvent> canvasFocusedEvent); AbstractCanvas<V> initialize(final CanvasPanel panel,
final CanvasSettings settings); @Override Optional<Shape> getShapeAt(final double x,
final double y); @Override void onAfterDraw(final Command callback); @Override void focus(); @Override boolean supports(final ViewEventType type); @Override AbstractCanvas<V> addHandler(final ViewEventType type,
final ViewHandler<? extends ViewEvent> eventHandler); @Override AbstractCanvas<V> removeHandler(final ViewHandler<? extends ViewEvent> eventHandler); @Override AbstractCanvas<V> enableHandlers(); @Override AbstractCanvas<V> disableHandlers(); @Override Shape<?> getAttachableShape(); @Override void destroy(); } |
@Test @SuppressWarnings("unchecked") public void testCreateResizeCommand() { Element element = mock(Element.class); BoundingBox boundingBox = new BoundingBox(0, 0, 1, 2); final CanvasCommand<AbstractCanvasHandler> command = tested.resize(element, boundingBox); assertNotNull(command); assertTrue(command instanceof LienzoResizeNodeCommand); LienzoResizeNodeCommand lienzoCommand = (LienzoResizeNodeCommand) command; assertEquals(element, lienzoCommand.getCandidate()); assertEquals(boundingBox, lienzoCommand.getBoundingBox()); } | @Override public CanvasCommand<AbstractCanvasHandler> resize(final Element<? extends View<?>> element, final BoundingBox boundingBox) { return new LienzoResizeNodeCommand(element, boundingBox); } | LienzoCanvasCommandFactory extends DefaultCanvasCommandFactory { @Override public CanvasCommand<AbstractCanvasHandler> resize(final Element<? extends View<?>> element, final BoundingBox boundingBox) { return new LienzoResizeNodeCommand(element, boundingBox); } } | LienzoCanvasCommandFactory extends DefaultCanvasCommandFactory { @Override public CanvasCommand<AbstractCanvasHandler> resize(final Element<? extends View<?>> element, final BoundingBox boundingBox) { return new LienzoResizeNodeCommand(element, boundingBox); } protected LienzoCanvasCommandFactory(); @Inject LienzoCanvasCommandFactory(final @Any ManagedInstance<ChildrenTraverseProcessor> childrenTraverseProcessors,
final @Any ManagedInstance<ViewTraverseProcessor> viewTraverseProcessors); } | LienzoCanvasCommandFactory extends DefaultCanvasCommandFactory { @Override public CanvasCommand<AbstractCanvasHandler> resize(final Element<? extends View<?>> element, final BoundingBox boundingBox) { return new LienzoResizeNodeCommand(element, boundingBox); } protected LienzoCanvasCommandFactory(); @Inject LienzoCanvasCommandFactory(final @Any ManagedInstance<ChildrenTraverseProcessor> childrenTraverseProcessors,
final @Any ManagedInstance<ViewTraverseProcessor> viewTraverseProcessors); @Override CanvasCommand<AbstractCanvasHandler> resize(final Element<? extends View<?>> element,
final BoundingBox boundingBox); } | LienzoCanvasCommandFactory extends DefaultCanvasCommandFactory { @Override public CanvasCommand<AbstractCanvasHandler> resize(final Element<? extends View<?>> element, final BoundingBox boundingBox) { return new LienzoResizeNodeCommand(element, boundingBox); } protected LienzoCanvasCommandFactory(); @Inject LienzoCanvasCommandFactory(final @Any ManagedInstance<ChildrenTraverseProcessor> childrenTraverseProcessors,
final @Any ManagedInstance<ViewTraverseProcessor> viewTraverseProcessors); @Override CanvasCommand<AbstractCanvasHandler> resize(final Element<? extends View<?>> element,
final BoundingBox boundingBox); } |
@Test public void testUseWiresManager() { WiresManager wiresManager = mock(WiresManager.class); tested.use(wiresManager); verify(wiresLayer, times(1)).use(eq(wiresManager)); } | public void use(final WiresManager wiresManager) { layer.use(wiresManager); } | WiresCanvasView extends LienzoCanvasView<WiresLayer> { public void use(final WiresManager wiresManager) { layer.use(wiresManager); } } | WiresCanvasView extends LienzoCanvasView<WiresLayer> { public void use(final WiresManager wiresManager) { layer.use(wiresManager); } @Inject WiresCanvasView(final WiresLayer layer); } | WiresCanvasView extends LienzoCanvasView<WiresLayer> { public void use(final WiresManager wiresManager) { layer.use(wiresManager); } @Inject WiresCanvasView(final WiresLayer layer); void use(final WiresManager wiresManager); @Override LienzoCanvasView<WiresLayer> add(final ShapeView<?> shape); LienzoCanvasView addRoot(final ShapeView<?> shape); @Override LienzoCanvasView<WiresLayer> delete(final ShapeView<?> shape); LienzoCanvasView deleteRoot(final ShapeView<?> shape); @Override LienzoCanvasView addChild(final ShapeView<?> parent,
final ShapeView<?> child); @Override LienzoCanvasView deleteChild(final ShapeView<?> parent,
final ShapeView<?> child); @Override LienzoCanvasView dock(final ShapeView<?> parent,
final ShapeView<?> child); @Override LienzoCanvasView undock(final ShapeView<?> childParent,
final ShapeView<?> child); @Override WiresLayer getLayer(); } | WiresCanvasView extends LienzoCanvasView<WiresLayer> { public void use(final WiresManager wiresManager) { layer.use(wiresManager); } @Inject WiresCanvasView(final WiresLayer layer); void use(final WiresManager wiresManager); @Override LienzoCanvasView<WiresLayer> add(final ShapeView<?> shape); LienzoCanvasView addRoot(final ShapeView<?> shape); @Override LienzoCanvasView<WiresLayer> delete(final ShapeView<?> shape); LienzoCanvasView deleteRoot(final ShapeView<?> shape); @Override LienzoCanvasView addChild(final ShapeView<?> parent,
final ShapeView<?> child); @Override LienzoCanvasView deleteChild(final ShapeView<?> parent,
final ShapeView<?> child); @Override LienzoCanvasView dock(final ShapeView<?> parent,
final ShapeView<?> child); @Override LienzoCanvasView undock(final ShapeView<?> childParent,
final ShapeView<?> child); @Override WiresLayer getLayer(); } |
@Test public void testAdd() { WiresShapeView shapeView = new WiresShapeView(new MultiPath().rect(0, 0, 50, 50)); tested.add(shapeView); verify(wiresLayer, times(1)).add(eq(shapeView)); } | @Override public LienzoCanvasView<WiresLayer> add(final ShapeView<?> shape) { if (WiresUtils.isWiresShape(shape)) { layer.add((WiresShape) shape); } else if (WiresUtils.isWiresConnector(shape)) { layer.add((WiresConnector) shape); } else { return super.add(shape); } return this; } | WiresCanvasView extends LienzoCanvasView<WiresLayer> { @Override public LienzoCanvasView<WiresLayer> add(final ShapeView<?> shape) { if (WiresUtils.isWiresShape(shape)) { layer.add((WiresShape) shape); } else if (WiresUtils.isWiresConnector(shape)) { layer.add((WiresConnector) shape); } else { return super.add(shape); } return this; } } | WiresCanvasView extends LienzoCanvasView<WiresLayer> { @Override public LienzoCanvasView<WiresLayer> add(final ShapeView<?> shape) { if (WiresUtils.isWiresShape(shape)) { layer.add((WiresShape) shape); } else if (WiresUtils.isWiresConnector(shape)) { layer.add((WiresConnector) shape); } else { return super.add(shape); } return this; } @Inject WiresCanvasView(final WiresLayer layer); } | WiresCanvasView extends LienzoCanvasView<WiresLayer> { @Override public LienzoCanvasView<WiresLayer> add(final ShapeView<?> shape) { if (WiresUtils.isWiresShape(shape)) { layer.add((WiresShape) shape); } else if (WiresUtils.isWiresConnector(shape)) { layer.add((WiresConnector) shape); } else { return super.add(shape); } return this; } @Inject WiresCanvasView(final WiresLayer layer); void use(final WiresManager wiresManager); @Override LienzoCanvasView<WiresLayer> add(final ShapeView<?> shape); LienzoCanvasView addRoot(final ShapeView<?> shape); @Override LienzoCanvasView<WiresLayer> delete(final ShapeView<?> shape); LienzoCanvasView deleteRoot(final ShapeView<?> shape); @Override LienzoCanvasView addChild(final ShapeView<?> parent,
final ShapeView<?> child); @Override LienzoCanvasView deleteChild(final ShapeView<?> parent,
final ShapeView<?> child); @Override LienzoCanvasView dock(final ShapeView<?> parent,
final ShapeView<?> child); @Override LienzoCanvasView undock(final ShapeView<?> childParent,
final ShapeView<?> child); @Override WiresLayer getLayer(); } | WiresCanvasView extends LienzoCanvasView<WiresLayer> { @Override public LienzoCanvasView<WiresLayer> add(final ShapeView<?> shape) { if (WiresUtils.isWiresShape(shape)) { layer.add((WiresShape) shape); } else if (WiresUtils.isWiresConnector(shape)) { layer.add((WiresConnector) shape); } else { return super.add(shape); } return this; } @Inject WiresCanvasView(final WiresLayer layer); void use(final WiresManager wiresManager); @Override LienzoCanvasView<WiresLayer> add(final ShapeView<?> shape); LienzoCanvasView addRoot(final ShapeView<?> shape); @Override LienzoCanvasView<WiresLayer> delete(final ShapeView<?> shape); LienzoCanvasView deleteRoot(final ShapeView<?> shape); @Override LienzoCanvasView addChild(final ShapeView<?> parent,
final ShapeView<?> child); @Override LienzoCanvasView deleteChild(final ShapeView<?> parent,
final ShapeView<?> child); @Override LienzoCanvasView dock(final ShapeView<?> parent,
final ShapeView<?> child); @Override LienzoCanvasView undock(final ShapeView<?> childParent,
final ShapeView<?> child); @Override WiresLayer getLayer(); } |
@Test public void testDelete() { WiresShapeView shapeView = new WiresShapeView(new MultiPath().rect(0, 0, 50, 50)); tested.delete(shapeView); verify(wiresLayer, times(1)).delete(eq(shapeView)); } | @Override public LienzoCanvasView<WiresLayer> delete(final ShapeView<?> shape) { if (WiresUtils.isWiresShape(shape)) { layer.delete((WiresShape) shape); } else if (WiresUtils.isWiresConnector(shape)) { layer.delete((WiresConnector) shape); } else { return super.delete(shape); } return this; } | WiresCanvasView extends LienzoCanvasView<WiresLayer> { @Override public LienzoCanvasView<WiresLayer> delete(final ShapeView<?> shape) { if (WiresUtils.isWiresShape(shape)) { layer.delete((WiresShape) shape); } else if (WiresUtils.isWiresConnector(shape)) { layer.delete((WiresConnector) shape); } else { return super.delete(shape); } return this; } } | WiresCanvasView extends LienzoCanvasView<WiresLayer> { @Override public LienzoCanvasView<WiresLayer> delete(final ShapeView<?> shape) { if (WiresUtils.isWiresShape(shape)) { layer.delete((WiresShape) shape); } else if (WiresUtils.isWiresConnector(shape)) { layer.delete((WiresConnector) shape); } else { return super.delete(shape); } return this; } @Inject WiresCanvasView(final WiresLayer layer); } | WiresCanvasView extends LienzoCanvasView<WiresLayer> { @Override public LienzoCanvasView<WiresLayer> delete(final ShapeView<?> shape) { if (WiresUtils.isWiresShape(shape)) { layer.delete((WiresShape) shape); } else if (WiresUtils.isWiresConnector(shape)) { layer.delete((WiresConnector) shape); } else { return super.delete(shape); } return this; } @Inject WiresCanvasView(final WiresLayer layer); void use(final WiresManager wiresManager); @Override LienzoCanvasView<WiresLayer> add(final ShapeView<?> shape); LienzoCanvasView addRoot(final ShapeView<?> shape); @Override LienzoCanvasView<WiresLayer> delete(final ShapeView<?> shape); LienzoCanvasView deleteRoot(final ShapeView<?> shape); @Override LienzoCanvasView addChild(final ShapeView<?> parent,
final ShapeView<?> child); @Override LienzoCanvasView deleteChild(final ShapeView<?> parent,
final ShapeView<?> child); @Override LienzoCanvasView dock(final ShapeView<?> parent,
final ShapeView<?> child); @Override LienzoCanvasView undock(final ShapeView<?> childParent,
final ShapeView<?> child); @Override WiresLayer getLayer(); } | WiresCanvasView extends LienzoCanvasView<WiresLayer> { @Override public LienzoCanvasView<WiresLayer> delete(final ShapeView<?> shape) { if (WiresUtils.isWiresShape(shape)) { layer.delete((WiresShape) shape); } else if (WiresUtils.isWiresConnector(shape)) { layer.delete((WiresConnector) shape); } else { return super.delete(shape); } return this; } @Inject WiresCanvasView(final WiresLayer layer); void use(final WiresManager wiresManager); @Override LienzoCanvasView<WiresLayer> add(final ShapeView<?> shape); LienzoCanvasView addRoot(final ShapeView<?> shape); @Override LienzoCanvasView<WiresLayer> delete(final ShapeView<?> shape); LienzoCanvasView deleteRoot(final ShapeView<?> shape); @Override LienzoCanvasView addChild(final ShapeView<?> parent,
final ShapeView<?> child); @Override LienzoCanvasView deleteChild(final ShapeView<?> parent,
final ShapeView<?> child); @Override LienzoCanvasView dock(final ShapeView<?> parent,
final ShapeView<?> child); @Override LienzoCanvasView undock(final ShapeView<?> childParent,
final ShapeView<?> child); @Override WiresLayer getLayer(); } |
@Test public void testAddRoot() { WiresShapeView shapeView = new WiresShapeView(new MultiPath().rect(0, 0, 50, 50)); tested.addRoot(shapeView); verify(wiresLayer, times(1)).add(eq(shapeView.getGroup())); } | public LienzoCanvasView addRoot(final ShapeView<?> shape) { if (WiresUtils.isWiresShape(shape)) { layer.add(((WiresShape) shape).getGroup()); } else if (WiresUtils.isWiresConnector(shape)) { layer.add(((WiresConnector) shape).getGroup()); } else { return super.add(shape); } return this; } | WiresCanvasView extends LienzoCanvasView<WiresLayer> { public LienzoCanvasView addRoot(final ShapeView<?> shape) { if (WiresUtils.isWiresShape(shape)) { layer.add(((WiresShape) shape).getGroup()); } else if (WiresUtils.isWiresConnector(shape)) { layer.add(((WiresConnector) shape).getGroup()); } else { return super.add(shape); } return this; } } | WiresCanvasView extends LienzoCanvasView<WiresLayer> { public LienzoCanvasView addRoot(final ShapeView<?> shape) { if (WiresUtils.isWiresShape(shape)) { layer.add(((WiresShape) shape).getGroup()); } else if (WiresUtils.isWiresConnector(shape)) { layer.add(((WiresConnector) shape).getGroup()); } else { return super.add(shape); } return this; } @Inject WiresCanvasView(final WiresLayer layer); } | WiresCanvasView extends LienzoCanvasView<WiresLayer> { public LienzoCanvasView addRoot(final ShapeView<?> shape) { if (WiresUtils.isWiresShape(shape)) { layer.add(((WiresShape) shape).getGroup()); } else if (WiresUtils.isWiresConnector(shape)) { layer.add(((WiresConnector) shape).getGroup()); } else { return super.add(shape); } return this; } @Inject WiresCanvasView(final WiresLayer layer); void use(final WiresManager wiresManager); @Override LienzoCanvasView<WiresLayer> add(final ShapeView<?> shape); LienzoCanvasView addRoot(final ShapeView<?> shape); @Override LienzoCanvasView<WiresLayer> delete(final ShapeView<?> shape); LienzoCanvasView deleteRoot(final ShapeView<?> shape); @Override LienzoCanvasView addChild(final ShapeView<?> parent,
final ShapeView<?> child); @Override LienzoCanvasView deleteChild(final ShapeView<?> parent,
final ShapeView<?> child); @Override LienzoCanvasView dock(final ShapeView<?> parent,
final ShapeView<?> child); @Override LienzoCanvasView undock(final ShapeView<?> childParent,
final ShapeView<?> child); @Override WiresLayer getLayer(); } | WiresCanvasView extends LienzoCanvasView<WiresLayer> { public LienzoCanvasView addRoot(final ShapeView<?> shape) { if (WiresUtils.isWiresShape(shape)) { layer.add(((WiresShape) shape).getGroup()); } else if (WiresUtils.isWiresConnector(shape)) { layer.add(((WiresConnector) shape).getGroup()); } else { return super.add(shape); } return this; } @Inject WiresCanvasView(final WiresLayer layer); void use(final WiresManager wiresManager); @Override LienzoCanvasView<WiresLayer> add(final ShapeView<?> shape); LienzoCanvasView addRoot(final ShapeView<?> shape); @Override LienzoCanvasView<WiresLayer> delete(final ShapeView<?> shape); LienzoCanvasView deleteRoot(final ShapeView<?> shape); @Override LienzoCanvasView addChild(final ShapeView<?> parent,
final ShapeView<?> child); @Override LienzoCanvasView deleteChild(final ShapeView<?> parent,
final ShapeView<?> child); @Override LienzoCanvasView dock(final ShapeView<?> parent,
final ShapeView<?> child); @Override LienzoCanvasView undock(final ShapeView<?> childParent,
final ShapeView<?> child); @Override WiresLayer getLayer(); } |
@Test public void wbFromDMN_PMMLImportWithModels() { when(jsitImportMock.getImportType()).thenReturn(PMML_IMPORT_TYPE); pmmlDocumentMetadata.getModels().add(new PMMLModelMetadata("modelName", null)); Import resultImport = ImportConverter.wbFromDMN(jsitImportMock, null, pmmlDocumentMetadata); assertTrue(resultImport instanceof ImportPMML); assertEquals(LOCATION_URI, resultImport.getLocationURI().getValue()); assertEquals(NAME, resultImport.getNamespace()); assertEquals(DESCRIPTION, resultImport.getDescription().getValue()); assertEquals(NAME, resultImport.getName().getValue()); assertEquals(PMML_IMPORT_TYPE, resultImport.getImportType()); assertNotNull(resultImport.getId().getValue()); assertEquals(1, ((ImportPMML) resultImport).getModelCount()); } | public static Import wbFromDMN(final JSITImport dmn, final JSITDefinitions definitions, final PMMLDocumentMetadata pmmlDocument) { final Import result = createWBImport(dmn, definitions, pmmlDocument); final Map<QName, String> additionalAttributes = new HashMap<>(); final Map<javax.xml.namespace.QName, String> otherAttributes = JSITUnaryTests.getOtherAttributesMap(dmn); for (Map.Entry<javax.xml.namespace.QName, String> entry : otherAttributes.entrySet()) { additionalAttributes.put(QNamePropertyConverter.wbFromDMN(entry.getKey().toString()), entry.getValue()); } result.setAdditionalAttributes(additionalAttributes); final String name = dmn.getName(); final String description = dmn.getDescription(); result.setId(IdPropertyConverter.wbFromDMN(dmn.getId())); result.setName(new Name(name)); result.setDescription(DescriptionPropertyConverter.wbFromDMN(description)); NameSpaceUtils.extractNamespacesKeyedByPrefix(dmn).forEach((key, value) -> result.getNsContext().put(key, value)); return result; } | ImportConverter { public static Import wbFromDMN(final JSITImport dmn, final JSITDefinitions definitions, final PMMLDocumentMetadata pmmlDocument) { final Import result = createWBImport(dmn, definitions, pmmlDocument); final Map<QName, String> additionalAttributes = new HashMap<>(); final Map<javax.xml.namespace.QName, String> otherAttributes = JSITUnaryTests.getOtherAttributesMap(dmn); for (Map.Entry<javax.xml.namespace.QName, String> entry : otherAttributes.entrySet()) { additionalAttributes.put(QNamePropertyConverter.wbFromDMN(entry.getKey().toString()), entry.getValue()); } result.setAdditionalAttributes(additionalAttributes); final String name = dmn.getName(); final String description = dmn.getDescription(); result.setId(IdPropertyConverter.wbFromDMN(dmn.getId())); result.setName(new Name(name)); result.setDescription(DescriptionPropertyConverter.wbFromDMN(description)); NameSpaceUtils.extractNamespacesKeyedByPrefix(dmn).forEach((key, value) -> result.getNsContext().put(key, value)); return result; } } | ImportConverter { public static Import wbFromDMN(final JSITImport dmn, final JSITDefinitions definitions, final PMMLDocumentMetadata pmmlDocument) { final Import result = createWBImport(dmn, definitions, pmmlDocument); final Map<QName, String> additionalAttributes = new HashMap<>(); final Map<javax.xml.namespace.QName, String> otherAttributes = JSITUnaryTests.getOtherAttributesMap(dmn); for (Map.Entry<javax.xml.namespace.QName, String> entry : otherAttributes.entrySet()) { additionalAttributes.put(QNamePropertyConverter.wbFromDMN(entry.getKey().toString()), entry.getValue()); } result.setAdditionalAttributes(additionalAttributes); final String name = dmn.getName(); final String description = dmn.getDescription(); result.setId(IdPropertyConverter.wbFromDMN(dmn.getId())); result.setName(new Name(name)); result.setDescription(DescriptionPropertyConverter.wbFromDMN(description)); NameSpaceUtils.extractNamespacesKeyedByPrefix(dmn).forEach((key, value) -> result.getNsContext().put(key, value)); return result; } } | ImportConverter { public static Import wbFromDMN(final JSITImport dmn, final JSITDefinitions definitions, final PMMLDocumentMetadata pmmlDocument) { final Import result = createWBImport(dmn, definitions, pmmlDocument); final Map<QName, String> additionalAttributes = new HashMap<>(); final Map<javax.xml.namespace.QName, String> otherAttributes = JSITUnaryTests.getOtherAttributesMap(dmn); for (Map.Entry<javax.xml.namespace.QName, String> entry : otherAttributes.entrySet()) { additionalAttributes.put(QNamePropertyConverter.wbFromDMN(entry.getKey().toString()), entry.getValue()); } result.setAdditionalAttributes(additionalAttributes); final String name = dmn.getName(); final String description = dmn.getDescription(); result.setId(IdPropertyConverter.wbFromDMN(dmn.getId())); result.setName(new Name(name)); result.setDescription(DescriptionPropertyConverter.wbFromDMN(description)); NameSpaceUtils.extractNamespacesKeyedByPrefix(dmn).forEach((key, value) -> result.getNsContext().put(key, value)); return result; } static Import wbFromDMN(final JSITImport dmn,
final JSITDefinitions definitions,
final PMMLDocumentMetadata pmmlDocument); } | ImportConverter { public static Import wbFromDMN(final JSITImport dmn, final JSITDefinitions definitions, final PMMLDocumentMetadata pmmlDocument) { final Import result = createWBImport(dmn, definitions, pmmlDocument); final Map<QName, String> additionalAttributes = new HashMap<>(); final Map<javax.xml.namespace.QName, String> otherAttributes = JSITUnaryTests.getOtherAttributesMap(dmn); for (Map.Entry<javax.xml.namespace.QName, String> entry : otherAttributes.entrySet()) { additionalAttributes.put(QNamePropertyConverter.wbFromDMN(entry.getKey().toString()), entry.getValue()); } result.setAdditionalAttributes(additionalAttributes); final String name = dmn.getName(); final String description = dmn.getDescription(); result.setId(IdPropertyConverter.wbFromDMN(dmn.getId())); result.setName(new Name(name)); result.setDescription(DescriptionPropertyConverter.wbFromDMN(description)); NameSpaceUtils.extractNamespacesKeyedByPrefix(dmn).forEach((key, value) -> result.getNsContext().put(key, value)); return result; } static Import wbFromDMN(final JSITImport dmn,
final JSITDefinitions definitions,
final PMMLDocumentMetadata pmmlDocument); } |
@Test public void testDeleteRoot() { WiresShapeView shapeView = new WiresShapeView(new MultiPath().rect(0, 0, 50, 50)); tested.deleteRoot(shapeView); verify(wiresLayer, times(1)).delete(eq(shapeView.getGroup())); } | public LienzoCanvasView deleteRoot(final ShapeView<?> shape) { if (WiresUtils.isWiresShape(shape)) { layer.delete(((WiresShape) shape).getGroup()); } else if (WiresUtils.isWiresConnector(shape)) { layer.delete(((WiresConnector) shape).getGroup()); } else { return super.delete(shape); } return this; } | WiresCanvasView extends LienzoCanvasView<WiresLayer> { public LienzoCanvasView deleteRoot(final ShapeView<?> shape) { if (WiresUtils.isWiresShape(shape)) { layer.delete(((WiresShape) shape).getGroup()); } else if (WiresUtils.isWiresConnector(shape)) { layer.delete(((WiresConnector) shape).getGroup()); } else { return super.delete(shape); } return this; } } | WiresCanvasView extends LienzoCanvasView<WiresLayer> { public LienzoCanvasView deleteRoot(final ShapeView<?> shape) { if (WiresUtils.isWiresShape(shape)) { layer.delete(((WiresShape) shape).getGroup()); } else if (WiresUtils.isWiresConnector(shape)) { layer.delete(((WiresConnector) shape).getGroup()); } else { return super.delete(shape); } return this; } @Inject WiresCanvasView(final WiresLayer layer); } | WiresCanvasView extends LienzoCanvasView<WiresLayer> { public LienzoCanvasView deleteRoot(final ShapeView<?> shape) { if (WiresUtils.isWiresShape(shape)) { layer.delete(((WiresShape) shape).getGroup()); } else if (WiresUtils.isWiresConnector(shape)) { layer.delete(((WiresConnector) shape).getGroup()); } else { return super.delete(shape); } return this; } @Inject WiresCanvasView(final WiresLayer layer); void use(final WiresManager wiresManager); @Override LienzoCanvasView<WiresLayer> add(final ShapeView<?> shape); LienzoCanvasView addRoot(final ShapeView<?> shape); @Override LienzoCanvasView<WiresLayer> delete(final ShapeView<?> shape); LienzoCanvasView deleteRoot(final ShapeView<?> shape); @Override LienzoCanvasView addChild(final ShapeView<?> parent,
final ShapeView<?> child); @Override LienzoCanvasView deleteChild(final ShapeView<?> parent,
final ShapeView<?> child); @Override LienzoCanvasView dock(final ShapeView<?> parent,
final ShapeView<?> child); @Override LienzoCanvasView undock(final ShapeView<?> childParent,
final ShapeView<?> child); @Override WiresLayer getLayer(); } | WiresCanvasView extends LienzoCanvasView<WiresLayer> { public LienzoCanvasView deleteRoot(final ShapeView<?> shape) { if (WiresUtils.isWiresShape(shape)) { layer.delete(((WiresShape) shape).getGroup()); } else if (WiresUtils.isWiresConnector(shape)) { layer.delete(((WiresConnector) shape).getGroup()); } else { return super.delete(shape); } return this; } @Inject WiresCanvasView(final WiresLayer layer); void use(final WiresManager wiresManager); @Override LienzoCanvasView<WiresLayer> add(final ShapeView<?> shape); LienzoCanvasView addRoot(final ShapeView<?> shape); @Override LienzoCanvasView<WiresLayer> delete(final ShapeView<?> shape); LienzoCanvasView deleteRoot(final ShapeView<?> shape); @Override LienzoCanvasView addChild(final ShapeView<?> parent,
final ShapeView<?> child); @Override LienzoCanvasView deleteChild(final ShapeView<?> parent,
final ShapeView<?> child); @Override LienzoCanvasView dock(final ShapeView<?> parent,
final ShapeView<?> child); @Override LienzoCanvasView undock(final ShapeView<?> childParent,
final ShapeView<?> child); @Override WiresLayer getLayer(); } |
@Test public void testAddChild() { WiresShapeView parent = new WiresShapeView(new MultiPath().rect(0, 0, 50, 50)); WiresShapeView child = new WiresShapeView(new MultiPath().rect(0, 0, 50, 50)); tested.addChild(parent, child); verify(wiresLayer, times(1)).addChild(eq(parent), eq(child)); } | @Override public LienzoCanvasView addChild(final ShapeView<?> parent, final ShapeView<?> child) { final WiresContainer parentShape = (WiresContainer) parent; final WiresShape childShape = (WiresShape) child; layer.addChild(parentShape, childShape); childShape.shapeMoved(); return this; } | WiresCanvasView extends LienzoCanvasView<WiresLayer> { @Override public LienzoCanvasView addChild(final ShapeView<?> parent, final ShapeView<?> child) { final WiresContainer parentShape = (WiresContainer) parent; final WiresShape childShape = (WiresShape) child; layer.addChild(parentShape, childShape); childShape.shapeMoved(); return this; } } | WiresCanvasView extends LienzoCanvasView<WiresLayer> { @Override public LienzoCanvasView addChild(final ShapeView<?> parent, final ShapeView<?> child) { final WiresContainer parentShape = (WiresContainer) parent; final WiresShape childShape = (WiresShape) child; layer.addChild(parentShape, childShape); childShape.shapeMoved(); return this; } @Inject WiresCanvasView(final WiresLayer layer); } | WiresCanvasView extends LienzoCanvasView<WiresLayer> { @Override public LienzoCanvasView addChild(final ShapeView<?> parent, final ShapeView<?> child) { final WiresContainer parentShape = (WiresContainer) parent; final WiresShape childShape = (WiresShape) child; layer.addChild(parentShape, childShape); childShape.shapeMoved(); return this; } @Inject WiresCanvasView(final WiresLayer layer); void use(final WiresManager wiresManager); @Override LienzoCanvasView<WiresLayer> add(final ShapeView<?> shape); LienzoCanvasView addRoot(final ShapeView<?> shape); @Override LienzoCanvasView<WiresLayer> delete(final ShapeView<?> shape); LienzoCanvasView deleteRoot(final ShapeView<?> shape); @Override LienzoCanvasView addChild(final ShapeView<?> parent,
final ShapeView<?> child); @Override LienzoCanvasView deleteChild(final ShapeView<?> parent,
final ShapeView<?> child); @Override LienzoCanvasView dock(final ShapeView<?> parent,
final ShapeView<?> child); @Override LienzoCanvasView undock(final ShapeView<?> childParent,
final ShapeView<?> child); @Override WiresLayer getLayer(); } | WiresCanvasView extends LienzoCanvasView<WiresLayer> { @Override public LienzoCanvasView addChild(final ShapeView<?> parent, final ShapeView<?> child) { final WiresContainer parentShape = (WiresContainer) parent; final WiresShape childShape = (WiresShape) child; layer.addChild(parentShape, childShape); childShape.shapeMoved(); return this; } @Inject WiresCanvasView(final WiresLayer layer); void use(final WiresManager wiresManager); @Override LienzoCanvasView<WiresLayer> add(final ShapeView<?> shape); LienzoCanvasView addRoot(final ShapeView<?> shape); @Override LienzoCanvasView<WiresLayer> delete(final ShapeView<?> shape); LienzoCanvasView deleteRoot(final ShapeView<?> shape); @Override LienzoCanvasView addChild(final ShapeView<?> parent,
final ShapeView<?> child); @Override LienzoCanvasView deleteChild(final ShapeView<?> parent,
final ShapeView<?> child); @Override LienzoCanvasView dock(final ShapeView<?> parent,
final ShapeView<?> child); @Override LienzoCanvasView undock(final ShapeView<?> childParent,
final ShapeView<?> child); @Override WiresLayer getLayer(); } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.