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 testDestroy() { tested.init(canvasHandler); tested.destroy(); assertFalse(tested.getSelectedItemDefinition().isPresent()); verify(canvas).removeHandler(any(MouseClickHandler.class)); }
|
@Override public Optional<Object> getSelectedItemDefinition() { String selectedItemUUID = null; final Collection<String> selectedItems = getSelectedItems(); if (null != selectedItems && !selectedItems.isEmpty()) { selectedItemUUID = selectedItems.iterator().next(); } if (Objects.isNull(selectedItemUUID)) { final AbstractCanvasHandler canvasHandler = getCanvasHandler(); if (!Objects.isNull(canvasHandler)) { final Diagram<?, ?> diagram = getCanvasHandler().getDiagram(); if (!Objects.isNull(diagram)) { final String cRoot = diagram.getMetadata().getCanvasRootUUID(); if (!StringUtils.isEmpty(cRoot)) { selectedItemUUID = cRoot; } } } } if (!Objects.isNull(selectedItemUUID)) { final Element<? extends Definition<?>> element = CanvasLayoutUtils.getElement(getCanvasHandler(), selectedItemUUID); return Optional.ofNullable(element); } else { return Optional.empty(); } }
|
MapSelectionControl extends AbstractCanvasHandlerControl<H> implements SelectionControl<H, Element>,
CanvasRegistrationControl<H, Element> { @Override public Optional<Object> getSelectedItemDefinition() { String selectedItemUUID = null; final Collection<String> selectedItems = getSelectedItems(); if (null != selectedItems && !selectedItems.isEmpty()) { selectedItemUUID = selectedItems.iterator().next(); } if (Objects.isNull(selectedItemUUID)) { final AbstractCanvasHandler canvasHandler = getCanvasHandler(); if (!Objects.isNull(canvasHandler)) { final Diagram<?, ?> diagram = getCanvasHandler().getDiagram(); if (!Objects.isNull(diagram)) { final String cRoot = diagram.getMetadata().getCanvasRootUUID(); if (!StringUtils.isEmpty(cRoot)) { selectedItemUUID = cRoot; } } } } if (!Objects.isNull(selectedItemUUID)) { final Element<? extends Definition<?>> element = CanvasLayoutUtils.getElement(getCanvasHandler(), selectedItemUUID); return Optional.ofNullable(element); } else { return Optional.empty(); } } }
|
MapSelectionControl extends AbstractCanvasHandlerControl<H> implements SelectionControl<H, Element>,
CanvasRegistrationControl<H, Element> { @Override public Optional<Object> getSelectedItemDefinition() { String selectedItemUUID = null; final Collection<String> selectedItems = getSelectedItems(); if (null != selectedItems && !selectedItems.isEmpty()) { selectedItemUUID = selectedItems.iterator().next(); } if (Objects.isNull(selectedItemUUID)) { final AbstractCanvasHandler canvasHandler = getCanvasHandler(); if (!Objects.isNull(canvasHandler)) { final Diagram<?, ?> diagram = getCanvasHandler().getDiagram(); if (!Objects.isNull(diagram)) { final String cRoot = diagram.getMetadata().getCanvasRootUUID(); if (!StringUtils.isEmpty(cRoot)) { selectedItemUUID = cRoot; } } } } if (!Objects.isNull(selectedItemUUID)) { final Element<? extends Definition<?>> element = CanvasLayoutUtils.getElement(getCanvasHandler(), selectedItemUUID); return Optional.ofNullable(element); } else { return Optional.empty(); } } MapSelectionControl(final Consumer<CanvasSelectionEvent> selectionEventConsumer,
final Consumer<CanvasClearSelectionEvent> clearSelectionEventConsumer); }
|
MapSelectionControl extends AbstractCanvasHandlerControl<H> implements SelectionControl<H, Element>,
CanvasRegistrationControl<H, Element> { @Override public Optional<Object> getSelectedItemDefinition() { String selectedItemUUID = null; final Collection<String> selectedItems = getSelectedItems(); if (null != selectedItems && !selectedItems.isEmpty()) { selectedItemUUID = selectedItems.iterator().next(); } if (Objects.isNull(selectedItemUUID)) { final AbstractCanvasHandler canvasHandler = getCanvasHandler(); if (!Objects.isNull(canvasHandler)) { final Diagram<?, ?> diagram = getCanvasHandler().getDiagram(); if (!Objects.isNull(diagram)) { final String cRoot = diagram.getMetadata().getCanvasRootUUID(); if (!StringUtils.isEmpty(cRoot)) { selectedItemUUID = cRoot; } } } } if (!Objects.isNull(selectedItemUUID)) { final Element<? extends Definition<?>> element = CanvasLayoutUtils.getElement(getCanvasHandler(), selectedItemUUID); return Optional.ofNullable(element); } else { return Optional.empty(); } } MapSelectionControl(final Consumer<CanvasSelectionEvent> selectionEventConsumer,
final Consumer<CanvasClearSelectionEvent> clearSelectionEventConsumer); static MapSelectionControl<H> build(final Consumer<CanvasSelectionEvent> selectionEventConsumer,
final Consumer<CanvasClearSelectionEvent> clearSelectionEventConsumer); @Override void clear(); @Override void register(final Element element); @Override void deregister(final Element element); @Override SelectionControl<H, Element> select(final String uuid); @Override SelectionControl<H, Element> deselect(final String uuid); @Override boolean isSelected(final Element element); @Override Collection<String> getSelectedItems(); @Override SelectionControl<H, Element> clearSelection(); @Override Optional<Object> getSelectedItemDefinition(); boolean isReadonly(); void setReadonly(boolean readonly); SelectionControl<H, Element> select(final Collection<String> uuids); SelectionControl<H, Element> deselect(final Collection<String> uuids); boolean isSelected(final String uuid); void onShapeRemoved(final CanvasShapeRemovedEvent shapeRemovedEvent); void onCanvasElementSelected(final CanvasSelectionEvent event); void onCanvasClearSelection(final CanvasClearSelectionEvent event); AbstractCanvasHandler getCanvasHandler(); Predicate<String> itemsRegistered(); AbstractCanvas getCanvas(); }
|
MapSelectionControl extends AbstractCanvasHandlerControl<H> implements SelectionControl<H, Element>,
CanvasRegistrationControl<H, Element> { @Override public Optional<Object> getSelectedItemDefinition() { String selectedItemUUID = null; final Collection<String> selectedItems = getSelectedItems(); if (null != selectedItems && !selectedItems.isEmpty()) { selectedItemUUID = selectedItems.iterator().next(); } if (Objects.isNull(selectedItemUUID)) { final AbstractCanvasHandler canvasHandler = getCanvasHandler(); if (!Objects.isNull(canvasHandler)) { final Diagram<?, ?> diagram = getCanvasHandler().getDiagram(); if (!Objects.isNull(diagram)) { final String cRoot = diagram.getMetadata().getCanvasRootUUID(); if (!StringUtils.isEmpty(cRoot)) { selectedItemUUID = cRoot; } } } } if (!Objects.isNull(selectedItemUUID)) { final Element<? extends Definition<?>> element = CanvasLayoutUtils.getElement(getCanvasHandler(), selectedItemUUID); return Optional.ofNullable(element); } else { return Optional.empty(); } } MapSelectionControl(final Consumer<CanvasSelectionEvent> selectionEventConsumer,
final Consumer<CanvasClearSelectionEvent> clearSelectionEventConsumer); static MapSelectionControl<H> build(final Consumer<CanvasSelectionEvent> selectionEventConsumer,
final Consumer<CanvasClearSelectionEvent> clearSelectionEventConsumer); @Override void clear(); @Override void register(final Element element); @Override void deregister(final Element element); @Override SelectionControl<H, Element> select(final String uuid); @Override SelectionControl<H, Element> deselect(final String uuid); @Override boolean isSelected(final Element element); @Override Collection<String> getSelectedItems(); @Override SelectionControl<H, Element> clearSelection(); @Override Optional<Object> getSelectedItemDefinition(); boolean isReadonly(); void setReadonly(boolean readonly); SelectionControl<H, Element> select(final Collection<String> uuids); SelectionControl<H, Element> deselect(final Collection<String> uuids); boolean isSelected(final String uuid); void onShapeRemoved(final CanvasShapeRemovedEvent shapeRemovedEvent); void onCanvasElementSelected(final CanvasSelectionEvent event); void onCanvasClearSelection(final CanvasClearSelectionEvent event); AbstractCanvasHandler getCanvasHandler(); Predicate<String> itemsRegistered(); AbstractCanvas getCanvas(); }
|
@Test public void onPlaceGainFocusEvent() { clipboardControlCleaner.onPlaceGainFocusEvent(placeLostFocusEvent); verify(clipboardControl, times(1)).clear(); }
|
public void onPlaceGainFocusEvent(final @Observes PlaceLostFocusEvent event) { if (verifyIsDiagramEditor(event)) { StreamSupport.stream(clipboardControls.spliterator(), false).forEach(ClipboardControl::clear); } }
|
ClipboardControlCleaner { public void onPlaceGainFocusEvent(final @Observes PlaceLostFocusEvent event) { if (verifyIsDiagramEditor(event)) { StreamSupport.stream(clipboardControls.spliterator(), false).forEach(ClipboardControl::clear); } } }
|
ClipboardControlCleaner { public void onPlaceGainFocusEvent(final @Observes PlaceLostFocusEvent event) { if (verifyIsDiagramEditor(event)) { StreamSupport.stream(clipboardControls.spliterator(), false).forEach(ClipboardControl::clear); } } @Inject ClipboardControlCleaner(final ManagedInstance<ClipboardControl> clipboardControls, final ActivityBeansCache activityBeansCache); }
|
ClipboardControlCleaner { public void onPlaceGainFocusEvent(final @Observes PlaceLostFocusEvent event) { if (verifyIsDiagramEditor(event)) { StreamSupport.stream(clipboardControls.spliterator(), false).forEach(ClipboardControl::clear); } } @Inject ClipboardControlCleaner(final ManagedInstance<ClipboardControl> clipboardControls, final ActivityBeansCache activityBeansCache); void onPlaceGainFocusEvent(final @Observes PlaceLostFocusEvent event); }
|
ClipboardControlCleaner { public void onPlaceGainFocusEvent(final @Observes PlaceLostFocusEvent event) { if (verifyIsDiagramEditor(event)) { StreamSupport.stream(clipboardControls.spliterator(), false).forEach(ClipboardControl::clear); } } @Inject ClipboardControlCleaner(final ManagedInstance<ClipboardControl> clipboardControls, final ActivityBeansCache activityBeansCache); void onPlaceGainFocusEvent(final @Observes PlaceLostFocusEvent event); }
|
@Test public void testRemove() { localClipboardControl.set(graphInstance.startNode); assertTrue(localClipboardControl.hasElements()); localClipboardControl.remove(graphInstance.startNode); assertFalse(localClipboardControl.hasElements()); }
|
@Override public ClipboardControl<Element, AbstractCanvas, ClientSession> remove(Element... element) { elements.removeAll(Arrays.stream(element).collect(Collectors.toSet())); return this; }
|
LocalClipboardControl extends AbstractCanvasControl<AbstractCanvas> implements ClipboardControl<Element, AbstractCanvas, ClientSession> { @Override public ClipboardControl<Element, AbstractCanvas, ClientSession> remove(Element... element) { elements.removeAll(Arrays.stream(element).collect(Collectors.toSet())); return this; } }
|
LocalClipboardControl extends AbstractCanvasControl<AbstractCanvas> implements ClipboardControl<Element, AbstractCanvas, ClientSession> { @Override public ClipboardControl<Element, AbstractCanvas, ClientSession> remove(Element... element) { elements.removeAll(Arrays.stream(element).collect(Collectors.toSet())); return this; } LocalClipboardControl(); }
|
LocalClipboardControl extends AbstractCanvasControl<AbstractCanvas> implements ClipboardControl<Element, AbstractCanvas, ClientSession> { @Override public ClipboardControl<Element, AbstractCanvas, ClientSession> remove(Element... element) { elements.removeAll(Arrays.stream(element).collect(Collectors.toSet())); return this; } LocalClipboardControl(); @Override ClipboardControl<Element, AbstractCanvas, ClientSession> set(Element... element); @Override ClipboardControl<Element, AbstractCanvas, ClientSession> remove(Element... element); @Override Collection<Element> getElements(); @Override ClipboardControl<Element, AbstractCanvas, ClientSession> clear(); @Override boolean hasElements(); @Override String getParent(String uuid); @Override List<Command> getRollbackCommands(); @Override ClipboardControl<Element, AbstractCanvas, ClientSession> setRollbackCommand(Command... command); @Override Map<String, EdgeClipboard> getEdgeMap(); @Override EdgeClipboard buildNewEdgeClipboard(final String source, final Connection sourceConnection, final String target, final Connection targetConnection); }
|
LocalClipboardControl extends AbstractCanvasControl<AbstractCanvas> implements ClipboardControl<Element, AbstractCanvas, ClientSession> { @Override public ClipboardControl<Element, AbstractCanvas, ClientSession> remove(Element... element) { elements.removeAll(Arrays.stream(element).collect(Collectors.toSet())); return this; } LocalClipboardControl(); @Override ClipboardControl<Element, AbstractCanvas, ClientSession> set(Element... element); @Override ClipboardControl<Element, AbstractCanvas, ClientSession> remove(Element... element); @Override Collection<Element> getElements(); @Override ClipboardControl<Element, AbstractCanvas, ClientSession> clear(); @Override boolean hasElements(); @Override String getParent(String uuid); @Override List<Command> getRollbackCommands(); @Override ClipboardControl<Element, AbstractCanvas, ClientSession> setRollbackCommand(Command... command); @Override Map<String, EdgeClipboard> getEdgeMap(); @Override EdgeClipboard buildNewEdgeClipboard(final String source, final Connection sourceConnection, final String target, final Connection targetConnection); }
|
@Test public void testClear() { localClipboardControl.set(graphInstance.startNode, graphInstance.intermNode, graphInstance.endNode); assertTrue(localClipboardControl.hasElements()); localClipboardControl.clear(); assertFalse(localClipboardControl.hasElements()); }
|
@Override public ClipboardControl<Element, AbstractCanvas, ClientSession> clear() { commands.clear(); elements.clear(); elementsParent.clear(); return this; }
|
LocalClipboardControl extends AbstractCanvasControl<AbstractCanvas> implements ClipboardControl<Element, AbstractCanvas, ClientSession> { @Override public ClipboardControl<Element, AbstractCanvas, ClientSession> clear() { commands.clear(); elements.clear(); elementsParent.clear(); return this; } }
|
LocalClipboardControl extends AbstractCanvasControl<AbstractCanvas> implements ClipboardControl<Element, AbstractCanvas, ClientSession> { @Override public ClipboardControl<Element, AbstractCanvas, ClientSession> clear() { commands.clear(); elements.clear(); elementsParent.clear(); return this; } LocalClipboardControl(); }
|
LocalClipboardControl extends AbstractCanvasControl<AbstractCanvas> implements ClipboardControl<Element, AbstractCanvas, ClientSession> { @Override public ClipboardControl<Element, AbstractCanvas, ClientSession> clear() { commands.clear(); elements.clear(); elementsParent.clear(); return this; } LocalClipboardControl(); @Override ClipboardControl<Element, AbstractCanvas, ClientSession> set(Element... element); @Override ClipboardControl<Element, AbstractCanvas, ClientSession> remove(Element... element); @Override Collection<Element> getElements(); @Override ClipboardControl<Element, AbstractCanvas, ClientSession> clear(); @Override boolean hasElements(); @Override String getParent(String uuid); @Override List<Command> getRollbackCommands(); @Override ClipboardControl<Element, AbstractCanvas, ClientSession> setRollbackCommand(Command... command); @Override Map<String, EdgeClipboard> getEdgeMap(); @Override EdgeClipboard buildNewEdgeClipboard(final String source, final Connection sourceConnection, final String target, final Connection targetConnection); }
|
LocalClipboardControl extends AbstractCanvasControl<AbstractCanvas> implements ClipboardControl<Element, AbstractCanvas, ClientSession> { @Override public ClipboardControl<Element, AbstractCanvas, ClientSession> clear() { commands.clear(); elements.clear(); elementsParent.clear(); return this; } LocalClipboardControl(); @Override ClipboardControl<Element, AbstractCanvas, ClientSession> set(Element... element); @Override ClipboardControl<Element, AbstractCanvas, ClientSession> remove(Element... element); @Override Collection<Element> getElements(); @Override ClipboardControl<Element, AbstractCanvas, ClientSession> clear(); @Override boolean hasElements(); @Override String getParent(String uuid); @Override List<Command> getRollbackCommands(); @Override ClipboardControl<Element, AbstractCanvas, ClientSession> setRollbackCommand(Command... command); @Override Map<String, EdgeClipboard> getEdgeMap(); @Override EdgeClipboard buildNewEdgeClipboard(final String source, final Connection sourceConnection, final String target, final Connection targetConnection); }
|
@Test public void testGetParent() { localClipboardControl.set(graphInstance.startNode); String parentUUID = localClipboardControl.getParent(graphInstance.startNode.getUUID()); assertEquals(parentUUID, graphInstance.parentNode.getUUID()); }
|
@Override public String getParent(String uuid) { return elementsParent.get(uuid); }
|
LocalClipboardControl extends AbstractCanvasControl<AbstractCanvas> implements ClipboardControl<Element, AbstractCanvas, ClientSession> { @Override public String getParent(String uuid) { return elementsParent.get(uuid); } }
|
LocalClipboardControl extends AbstractCanvasControl<AbstractCanvas> implements ClipboardControl<Element, AbstractCanvas, ClientSession> { @Override public String getParent(String uuid) { return elementsParent.get(uuid); } LocalClipboardControl(); }
|
LocalClipboardControl extends AbstractCanvasControl<AbstractCanvas> implements ClipboardControl<Element, AbstractCanvas, ClientSession> { @Override public String getParent(String uuid) { return elementsParent.get(uuid); } LocalClipboardControl(); @Override ClipboardControl<Element, AbstractCanvas, ClientSession> set(Element... element); @Override ClipboardControl<Element, AbstractCanvas, ClientSession> remove(Element... element); @Override Collection<Element> getElements(); @Override ClipboardControl<Element, AbstractCanvas, ClientSession> clear(); @Override boolean hasElements(); @Override String getParent(String uuid); @Override List<Command> getRollbackCommands(); @Override ClipboardControl<Element, AbstractCanvas, ClientSession> setRollbackCommand(Command... command); @Override Map<String, EdgeClipboard> getEdgeMap(); @Override EdgeClipboard buildNewEdgeClipboard(final String source, final Connection sourceConnection, final String target, final Connection targetConnection); }
|
LocalClipboardControl extends AbstractCanvasControl<AbstractCanvas> implements ClipboardControl<Element, AbstractCanvas, ClientSession> { @Override public String getParent(String uuid) { return elementsParent.get(uuid); } LocalClipboardControl(); @Override ClipboardControl<Element, AbstractCanvas, ClientSession> set(Element... element); @Override ClipboardControl<Element, AbstractCanvas, ClientSession> remove(Element... element); @Override Collection<Element> getElements(); @Override ClipboardControl<Element, AbstractCanvas, ClientSession> clear(); @Override boolean hasElements(); @Override String getParent(String uuid); @Override List<Command> getRollbackCommands(); @Override ClipboardControl<Element, AbstractCanvas, ClientSession> setRollbackCommand(Command... command); @Override Map<String, EdgeClipboard> getEdgeMap(); @Override EdgeClipboard buildNewEdgeClipboard(final String source, final Connection sourceConnection, final String target, final Connection targetConnection); }
|
@Test public void testInitParameters() { CanvasInlineTextEditorControl tested = mock(CanvasInlineTextEditorControl.class); doCallRealMethod().when(tested).initParameters(); tested.initParameters(); assertTrue(tested.isMultiline); assertEquals(2d, tested.borderOffsetX, 0.001); assertEquals(2d, tested.borderOffsetY, 0.001); assertEquals(2d, tested.underBoxOffset, 0.001); assertEquals(-2d, tested.topBorderOffset, 0.001); assertEquals(4d, tested.fontSizeCorrection, 0.001); assertEquals(190d, tested.maxInnerLeftBoxWidth, 0.001); assertEquals(190d, tested.maxInnerLeftBoxHeight, 0.001); assertEquals(13d, tested.scrollBarOffset, 0.001); assertEquals(0d, tested.paletteOffsetX, 0.001); assertEquals(190d, tested.maxInnerTopBoxWidth, 0.001); assertEquals(190d, tested.maxInnerTopBoxHeight, 0.001); assertEquals(-1.1d, tested.innerBoxOffsetY, 0.001); }
|
@PostConstruct protected void initParameters() { isMultiline = true; borderOffsetX = 2d; borderOffsetY = 2d; underBoxOffset = 2d; topBorderOffset = -2d; fontSizeCorrection = 4d; maxInnerLeftBoxWidth = 190d; maxInnerLeftBoxHeight = 190d; maxInnerTopBoxWidth = 190d; maxInnerTopBoxHeight = 190d; scrollBarOffset = 13d; paletteOffsetX = 0d; innerBoxOffsetY = -1.1d; }
|
CanvasInlineTextEditorControl extends AbstractCanvasInlineTextEditorControl { @PostConstruct protected void initParameters() { isMultiline = true; borderOffsetX = 2d; borderOffsetY = 2d; underBoxOffset = 2d; topBorderOffset = -2d; fontSizeCorrection = 4d; maxInnerLeftBoxWidth = 190d; maxInnerLeftBoxHeight = 190d; maxInnerTopBoxWidth = 190d; maxInnerTopBoxHeight = 190d; scrollBarOffset = 13d; paletteOffsetX = 0d; innerBoxOffsetY = -1.1d; } }
|
CanvasInlineTextEditorControl extends AbstractCanvasInlineTextEditorControl { @PostConstruct protected void initParameters() { isMultiline = true; borderOffsetX = 2d; borderOffsetY = 2d; underBoxOffset = 2d; topBorderOffset = -2d; fontSizeCorrection = 4d; maxInnerLeftBoxWidth = 190d; maxInnerLeftBoxHeight = 190d; maxInnerTopBoxWidth = 190d; maxInnerTopBoxHeight = 190d; scrollBarOffset = 13d; paletteOffsetX = 0d; innerBoxOffsetY = -1.1d; } @Inject CanvasInlineTextEditorControl(final FloatingView<IsWidget> floatingView,
final @InlineTextEditorBox TextEditorBox<AbstractCanvasHandler, Element> textEditorBox); }
|
CanvasInlineTextEditorControl extends AbstractCanvasInlineTextEditorControl { @PostConstruct protected void initParameters() { isMultiline = true; borderOffsetX = 2d; borderOffsetY = 2d; underBoxOffset = 2d; topBorderOffset = -2d; fontSizeCorrection = 4d; maxInnerLeftBoxWidth = 190d; maxInnerLeftBoxHeight = 190d; maxInnerTopBoxWidth = 190d; maxInnerTopBoxHeight = 190d; scrollBarOffset = 13d; paletteOffsetX = 0d; innerBoxOffsetY = -1.1d; } @Inject CanvasInlineTextEditorControl(final FloatingView<IsWidget> floatingView,
final @InlineTextEditorBox TextEditorBox<AbstractCanvasHandler, Element> textEditorBox); }
|
CanvasInlineTextEditorControl extends AbstractCanvasInlineTextEditorControl { @PostConstruct protected void initParameters() { isMultiline = true; borderOffsetX = 2d; borderOffsetY = 2d; underBoxOffset = 2d; topBorderOffset = -2d; fontSizeCorrection = 4d; maxInnerLeftBoxWidth = 190d; maxInnerLeftBoxHeight = 190d; maxInnerTopBoxWidth = 190d; maxInnerTopBoxHeight = 190d; scrollBarOffset = 13d; paletteOffsetX = 0d; innerBoxOffsetY = -1.1d; } @Inject CanvasInlineTextEditorControl(final FloatingView<IsWidget> floatingView,
final @InlineTextEditorBox TextEditorBox<AbstractCanvasHandler, Element> textEditorBox); }
|
@Test public void testBind() { control.bind(session); verify(keyboardControl, times(2)) .addKeyShortcutCallback(any(KeyboardControl.KeyShortcutCallback.class)); }
|
@Override public void bind(final EditorSession session) { keyboardControl = session.getKeyboardControl(); keyboardControl.addKeyShortcutCallback(new KogitoKeyPress(new Key[]{ESC}, "Edit | Hide", this::hide)); keyboardControl.addKeyShortcutCallback(this::onKeyDownEvent); }
|
AbstractCanvasInlineTextEditorControl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements CanvasInlineTextEditorControl<AbstractCanvasHandler, EditorSession, Element> { @Override public void bind(final EditorSession session) { keyboardControl = session.getKeyboardControl(); keyboardControl.addKeyShortcutCallback(new KogitoKeyPress(new Key[]{ESC}, "Edit | Hide", this::hide)); keyboardControl.addKeyShortcutCallback(this::onKeyDownEvent); } }
|
AbstractCanvasInlineTextEditorControl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements CanvasInlineTextEditorControl<AbstractCanvasHandler, EditorSession, Element> { @Override public void bind(final EditorSession session) { keyboardControl = session.getKeyboardControl(); keyboardControl.addKeyShortcutCallback(new KogitoKeyPress(new Key[]{ESC}, "Edit | Hide", this::hide)); keyboardControl.addKeyShortcutCallback(this::onKeyDownEvent); } }
|
AbstractCanvasInlineTextEditorControl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements CanvasInlineTextEditorControl<AbstractCanvasHandler, EditorSession, Element> { @Override public void bind(final EditorSession session) { keyboardControl = session.getKeyboardControl(); keyboardControl.addKeyShortcutCallback(new KogitoKeyPress(new Key[]{ESC}, "Edit | Hide", this::hide)); keyboardControl.addKeyShortcutCallback(this::onKeyDownEvent); } @Override void bind(final EditorSession session); @Override void register(final Element element); @Override CanvasInlineTextEditorControl<AbstractCanvasHandler, EditorSession, Element> show(final Element item); @Override void setCommandManagerProvider(final CommandManagerProvider<AbstractCanvasHandler> provider); @Override CanvasInlineTextEditorControl<AbstractCanvasHandler, EditorSession, Element> rollback(); @Override CanvasInlineTextEditorControl<AbstractCanvasHandler, EditorSession, Element> hide(); void scheduleDeferredCommand(final Scheduler.ScheduledCommand command); }
|
AbstractCanvasInlineTextEditorControl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements CanvasInlineTextEditorControl<AbstractCanvasHandler, EditorSession, Element> { @Override public void bind(final EditorSession session) { keyboardControl = session.getKeyboardControl(); keyboardControl.addKeyShortcutCallback(new KogitoKeyPress(new Key[]{ESC}, "Edit | Hide", this::hide)); keyboardControl.addKeyShortcutCallback(this::onKeyDownEvent); } @Override void bind(final EditorSession session); @Override void register(final Element element); @Override CanvasInlineTextEditorControl<AbstractCanvasHandler, EditorSession, Element> show(final Element item); @Override void setCommandManagerProvider(final CommandManagerProvider<AbstractCanvasHandler> provider); @Override CanvasInlineTextEditorControl<AbstractCanvasHandler, EditorSession, Element> rollback(); @Override CanvasInlineTextEditorControl<AbstractCanvasHandler, EditorSession, Element> hide(); void scheduleDeferredCommand(final Scheduler.ScheduledCommand command); static final double SHAPE_EDIT_ALPHA; static final double TITLE_EDIT_ALPHA; static final double NOT_EDIT_ALPHA; static final String ALIGN_MIDDLE; static final String ALIGN_LEFT; static final String ALIGN_TOP; static final String POSITION_INSIDE; static final String POSITION_OUTSIDE; static final String ORIENTATION_VERTICAL; static final String ORIENTATION_HORIZONTAL; static final double DEFAULT_MARGIN_X; static final double DEFAULT_FONT_SIZE; static final String DEFAULT_FONT_FAMILY; }
|
@Test public void testRegisterTextEnter() { control.init(canvasHandler); when(testShapeView.supports(ViewEventType.TEXT_ENTER)).thenReturn(true); control.register(element); assertTrue(control.isRegistered(element)); verify(testShapeView).addHandler(eq(ViewEventType.TEXT_ENTER), textEnterHandlerCaptor.capture()); final TextEnterHandler textEnterHandler = textEnterHandlerCaptor.getValue(); textEnterHandler.handle(new TextEnterEvent(0, 1, SHAPE_X, SHAPE_Y)); verify(abstractCanvasView).setCursor(eq(AbstractCanvas.Cursors.TEXT)); }
|
@Override public void register(final Element element) { if (checkNotRegistered(element)) { final Shape<?> shape = getShape(element.getUUID()); if (null != shape) { final ShapeView shapeView = shape.getShapeView(); if (shapeView instanceof HasEventHandlers) { final HasEventHandlers hasEventHandlers = (HasEventHandlers) shapeView; if (hasEventHandlers.supports(ViewEventType.TEXT_DBL_CLICK)) { registerTextDoubleClick(shape, element, hasEventHandlers); } if (hasEventHandlers.supports(ViewEventType.TEXT_ENTER)) { changeMouseCursorOnTextEnter(shape, hasEventHandlers); } if (hasEventHandlers.supports(ViewEventType.TEXT_EXIT)) { changeMouseCursorOnTextExit(shape, hasEventHandlers); } } } } }
|
AbstractCanvasInlineTextEditorControl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements CanvasInlineTextEditorControl<AbstractCanvasHandler, EditorSession, Element> { @Override public void register(final Element element) { if (checkNotRegistered(element)) { final Shape<?> shape = getShape(element.getUUID()); if (null != shape) { final ShapeView shapeView = shape.getShapeView(); if (shapeView instanceof HasEventHandlers) { final HasEventHandlers hasEventHandlers = (HasEventHandlers) shapeView; if (hasEventHandlers.supports(ViewEventType.TEXT_DBL_CLICK)) { registerTextDoubleClick(shape, element, hasEventHandlers); } if (hasEventHandlers.supports(ViewEventType.TEXT_ENTER)) { changeMouseCursorOnTextEnter(shape, hasEventHandlers); } if (hasEventHandlers.supports(ViewEventType.TEXT_EXIT)) { changeMouseCursorOnTextExit(shape, hasEventHandlers); } } } } } }
|
AbstractCanvasInlineTextEditorControl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements CanvasInlineTextEditorControl<AbstractCanvasHandler, EditorSession, Element> { @Override public void register(final Element element) { if (checkNotRegistered(element)) { final Shape<?> shape = getShape(element.getUUID()); if (null != shape) { final ShapeView shapeView = shape.getShapeView(); if (shapeView instanceof HasEventHandlers) { final HasEventHandlers hasEventHandlers = (HasEventHandlers) shapeView; if (hasEventHandlers.supports(ViewEventType.TEXT_DBL_CLICK)) { registerTextDoubleClick(shape, element, hasEventHandlers); } if (hasEventHandlers.supports(ViewEventType.TEXT_ENTER)) { changeMouseCursorOnTextEnter(shape, hasEventHandlers); } if (hasEventHandlers.supports(ViewEventType.TEXT_EXIT)) { changeMouseCursorOnTextExit(shape, hasEventHandlers); } } } } } }
|
AbstractCanvasInlineTextEditorControl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements CanvasInlineTextEditorControl<AbstractCanvasHandler, EditorSession, Element> { @Override public void register(final Element element) { if (checkNotRegistered(element)) { final Shape<?> shape = getShape(element.getUUID()); if (null != shape) { final ShapeView shapeView = shape.getShapeView(); if (shapeView instanceof HasEventHandlers) { final HasEventHandlers hasEventHandlers = (HasEventHandlers) shapeView; if (hasEventHandlers.supports(ViewEventType.TEXT_DBL_CLICK)) { registerTextDoubleClick(shape, element, hasEventHandlers); } if (hasEventHandlers.supports(ViewEventType.TEXT_ENTER)) { changeMouseCursorOnTextEnter(shape, hasEventHandlers); } if (hasEventHandlers.supports(ViewEventType.TEXT_EXIT)) { changeMouseCursorOnTextExit(shape, hasEventHandlers); } } } } } @Override void bind(final EditorSession session); @Override void register(final Element element); @Override CanvasInlineTextEditorControl<AbstractCanvasHandler, EditorSession, Element> show(final Element item); @Override void setCommandManagerProvider(final CommandManagerProvider<AbstractCanvasHandler> provider); @Override CanvasInlineTextEditorControl<AbstractCanvasHandler, EditorSession, Element> rollback(); @Override CanvasInlineTextEditorControl<AbstractCanvasHandler, EditorSession, Element> hide(); void scheduleDeferredCommand(final Scheduler.ScheduledCommand command); }
|
AbstractCanvasInlineTextEditorControl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements CanvasInlineTextEditorControl<AbstractCanvasHandler, EditorSession, Element> { @Override public void register(final Element element) { if (checkNotRegistered(element)) { final Shape<?> shape = getShape(element.getUUID()); if (null != shape) { final ShapeView shapeView = shape.getShapeView(); if (shapeView instanceof HasEventHandlers) { final HasEventHandlers hasEventHandlers = (HasEventHandlers) shapeView; if (hasEventHandlers.supports(ViewEventType.TEXT_DBL_CLICK)) { registerTextDoubleClick(shape, element, hasEventHandlers); } if (hasEventHandlers.supports(ViewEventType.TEXT_ENTER)) { changeMouseCursorOnTextEnter(shape, hasEventHandlers); } if (hasEventHandlers.supports(ViewEventType.TEXT_EXIT)) { changeMouseCursorOnTextExit(shape, hasEventHandlers); } } } } } @Override void bind(final EditorSession session); @Override void register(final Element element); @Override CanvasInlineTextEditorControl<AbstractCanvasHandler, EditorSession, Element> show(final Element item); @Override void setCommandManagerProvider(final CommandManagerProvider<AbstractCanvasHandler> provider); @Override CanvasInlineTextEditorControl<AbstractCanvasHandler, EditorSession, Element> rollback(); @Override CanvasInlineTextEditorControl<AbstractCanvasHandler, EditorSession, Element> hide(); void scheduleDeferredCommand(final Scheduler.ScheduledCommand command); static final double SHAPE_EDIT_ALPHA; static final double TITLE_EDIT_ALPHA; static final double NOT_EDIT_ALPHA; static final String ALIGN_MIDDLE; static final String ALIGN_LEFT; static final String ALIGN_TOP; static final String POSITION_INSIDE; static final String POSITION_OUTSIDE; static final String ORIENTATION_VERTICAL; static final String ORIENTATION_HORIZONTAL; static final double DEFAULT_MARGIN_X; static final double DEFAULT_FONT_SIZE; static final String DEFAULT_FONT_FAMILY; }
|
@Test public void testRegisterTextExit() { control.init(canvasHandler); when(testShapeView.supports(ViewEventType.TEXT_EXIT)).thenReturn(true); control.register(element); assertTrue(control.isRegistered(element)); verify(testShapeView).addHandler(eq(ViewEventType.TEXT_EXIT), textExitHandlerCaptor.capture()); final TextExitHandler textExitHandler = textExitHandlerCaptor.getValue(); textExitHandler.handle(new TextExitEvent(0, 1, SHAPE_X, SHAPE_Y)); verify(abstractCanvasView).setCursor(eq(AbstractCanvas.Cursors.DEFAULT)); }
|
@Override public void register(final Element element) { if (checkNotRegistered(element)) { final Shape<?> shape = getShape(element.getUUID()); if (null != shape) { final ShapeView shapeView = shape.getShapeView(); if (shapeView instanceof HasEventHandlers) { final HasEventHandlers hasEventHandlers = (HasEventHandlers) shapeView; if (hasEventHandlers.supports(ViewEventType.TEXT_DBL_CLICK)) { registerTextDoubleClick(shape, element, hasEventHandlers); } if (hasEventHandlers.supports(ViewEventType.TEXT_ENTER)) { changeMouseCursorOnTextEnter(shape, hasEventHandlers); } if (hasEventHandlers.supports(ViewEventType.TEXT_EXIT)) { changeMouseCursorOnTextExit(shape, hasEventHandlers); } } } } }
|
AbstractCanvasInlineTextEditorControl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements CanvasInlineTextEditorControl<AbstractCanvasHandler, EditorSession, Element> { @Override public void register(final Element element) { if (checkNotRegistered(element)) { final Shape<?> shape = getShape(element.getUUID()); if (null != shape) { final ShapeView shapeView = shape.getShapeView(); if (shapeView instanceof HasEventHandlers) { final HasEventHandlers hasEventHandlers = (HasEventHandlers) shapeView; if (hasEventHandlers.supports(ViewEventType.TEXT_DBL_CLICK)) { registerTextDoubleClick(shape, element, hasEventHandlers); } if (hasEventHandlers.supports(ViewEventType.TEXT_ENTER)) { changeMouseCursorOnTextEnter(shape, hasEventHandlers); } if (hasEventHandlers.supports(ViewEventType.TEXT_EXIT)) { changeMouseCursorOnTextExit(shape, hasEventHandlers); } } } } } }
|
AbstractCanvasInlineTextEditorControl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements CanvasInlineTextEditorControl<AbstractCanvasHandler, EditorSession, Element> { @Override public void register(final Element element) { if (checkNotRegistered(element)) { final Shape<?> shape = getShape(element.getUUID()); if (null != shape) { final ShapeView shapeView = shape.getShapeView(); if (shapeView instanceof HasEventHandlers) { final HasEventHandlers hasEventHandlers = (HasEventHandlers) shapeView; if (hasEventHandlers.supports(ViewEventType.TEXT_DBL_CLICK)) { registerTextDoubleClick(shape, element, hasEventHandlers); } if (hasEventHandlers.supports(ViewEventType.TEXT_ENTER)) { changeMouseCursorOnTextEnter(shape, hasEventHandlers); } if (hasEventHandlers.supports(ViewEventType.TEXT_EXIT)) { changeMouseCursorOnTextExit(shape, hasEventHandlers); } } } } } }
|
AbstractCanvasInlineTextEditorControl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements CanvasInlineTextEditorControl<AbstractCanvasHandler, EditorSession, Element> { @Override public void register(final Element element) { if (checkNotRegistered(element)) { final Shape<?> shape = getShape(element.getUUID()); if (null != shape) { final ShapeView shapeView = shape.getShapeView(); if (shapeView instanceof HasEventHandlers) { final HasEventHandlers hasEventHandlers = (HasEventHandlers) shapeView; if (hasEventHandlers.supports(ViewEventType.TEXT_DBL_CLICK)) { registerTextDoubleClick(shape, element, hasEventHandlers); } if (hasEventHandlers.supports(ViewEventType.TEXT_ENTER)) { changeMouseCursorOnTextEnter(shape, hasEventHandlers); } if (hasEventHandlers.supports(ViewEventType.TEXT_EXIT)) { changeMouseCursorOnTextExit(shape, hasEventHandlers); } } } } } @Override void bind(final EditorSession session); @Override void register(final Element element); @Override CanvasInlineTextEditorControl<AbstractCanvasHandler, EditorSession, Element> show(final Element item); @Override void setCommandManagerProvider(final CommandManagerProvider<AbstractCanvasHandler> provider); @Override CanvasInlineTextEditorControl<AbstractCanvasHandler, EditorSession, Element> rollback(); @Override CanvasInlineTextEditorControl<AbstractCanvasHandler, EditorSession, Element> hide(); void scheduleDeferredCommand(final Scheduler.ScheduledCommand command); }
|
AbstractCanvasInlineTextEditorControl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements CanvasInlineTextEditorControl<AbstractCanvasHandler, EditorSession, Element> { @Override public void register(final Element element) { if (checkNotRegistered(element)) { final Shape<?> shape = getShape(element.getUUID()); if (null != shape) { final ShapeView shapeView = shape.getShapeView(); if (shapeView instanceof HasEventHandlers) { final HasEventHandlers hasEventHandlers = (HasEventHandlers) shapeView; if (hasEventHandlers.supports(ViewEventType.TEXT_DBL_CLICK)) { registerTextDoubleClick(shape, element, hasEventHandlers); } if (hasEventHandlers.supports(ViewEventType.TEXT_ENTER)) { changeMouseCursorOnTextEnter(shape, hasEventHandlers); } if (hasEventHandlers.supports(ViewEventType.TEXT_EXIT)) { changeMouseCursorOnTextExit(shape, hasEventHandlers); } } } } } @Override void bind(final EditorSession session); @Override void register(final Element element); @Override CanvasInlineTextEditorControl<AbstractCanvasHandler, EditorSession, Element> show(final Element item); @Override void setCommandManagerProvider(final CommandManagerProvider<AbstractCanvasHandler> provider); @Override CanvasInlineTextEditorControl<AbstractCanvasHandler, EditorSession, Element> rollback(); @Override CanvasInlineTextEditorControl<AbstractCanvasHandler, EditorSession, Element> hide(); void scheduleDeferredCommand(final Scheduler.ScheduledCommand command); static final double SHAPE_EDIT_ALPHA; static final double TITLE_EDIT_ALPHA; static final double NOT_EDIT_ALPHA; static final String ALIGN_MIDDLE; static final String ALIGN_LEFT; static final String ALIGN_TOP; static final String POSITION_INSIDE; static final String POSITION_OUTSIDE; static final String ORIENTATION_VERTICAL; static final String ORIENTATION_HORIZONTAL; static final double DEFAULT_MARGIN_X; static final double DEFAULT_FONT_SIZE; static final String DEFAULT_FONT_FAMILY; }
|
@Test @SuppressWarnings("unchecked") public void testSetOnClosedByKeyboardCallbackNullControl() { popover.setOnClosedByKeyboardCallback(callback); verify(view, never()).setOnClosedByKeyboardCallback(any(Consumer.class)); }
|
@Override public void setOnClosedByKeyboardCallback(final Consumer<CanBeClosedByKeyboard> callback) { binding.ifPresent(b -> view.setOnClosedByKeyboardCallback(callback)); }
|
AbstractPopoverImpl implements HasCellEditorControls.Editor<B> { @Override public void setOnClosedByKeyboardCallback(final Consumer<CanBeClosedByKeyboard> callback) { binding.ifPresent(b -> view.setOnClosedByKeyboardCallback(callback)); } }
|
AbstractPopoverImpl implements HasCellEditorControls.Editor<B> { @Override public void setOnClosedByKeyboardCallback(final Consumer<CanBeClosedByKeyboard> callback) { binding.ifPresent(b -> view.setOnClosedByKeyboardCallback(callback)); } protected AbstractPopoverImpl(); protected AbstractPopoverImpl(final V view); }
|
AbstractPopoverImpl implements HasCellEditorControls.Editor<B> { @Override public void setOnClosedByKeyboardCallback(final Consumer<CanBeClosedByKeyboard> callback) { binding.ifPresent(b -> view.setOnClosedByKeyboardCallback(callback)); } protected AbstractPopoverImpl(); protected AbstractPopoverImpl(final V view); @Override HTMLElement getElement(); @Override void bind(final B bound,
final int uiRowIndex,
final int uiColumnIndex); @Override void setOnClosedByKeyboardCallback(final Consumer<CanBeClosedByKeyboard> callback); @Override void show(); @Override void hide(); }
|
AbstractPopoverImpl implements HasCellEditorControls.Editor<B> { @Override public void setOnClosedByKeyboardCallback(final Consumer<CanBeClosedByKeyboard> callback) { binding.ifPresent(b -> view.setOnClosedByKeyboardCallback(callback)); } protected AbstractPopoverImpl(); protected AbstractPopoverImpl(final V view); @Override HTMLElement getElement(); @Override void bind(final B bound,
final int uiRowIndex,
final int uiColumnIndex); @Override void setOnClosedByKeyboardCallback(final Consumer<CanBeClosedByKeyboard> callback); @Override void show(); @Override void hide(); }
|
@Test public void testSetCommandManagerProvider() { control.setCommandManagerProvider(commandManagerProvider); verify(textEditorBox).setCommandManagerProvider(eq(commandManagerProvider)); }
|
@Override public void setCommandManagerProvider(final CommandManagerProvider<AbstractCanvasHandler> provider) { getTextEditorBox().setCommandManagerProvider(provider); }
|
AbstractCanvasInlineTextEditorControl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements CanvasInlineTextEditorControl<AbstractCanvasHandler, EditorSession, Element> { @Override public void setCommandManagerProvider(final CommandManagerProvider<AbstractCanvasHandler> provider) { getTextEditorBox().setCommandManagerProvider(provider); } }
|
AbstractCanvasInlineTextEditorControl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements CanvasInlineTextEditorControl<AbstractCanvasHandler, EditorSession, Element> { @Override public void setCommandManagerProvider(final CommandManagerProvider<AbstractCanvasHandler> provider) { getTextEditorBox().setCommandManagerProvider(provider); } }
|
AbstractCanvasInlineTextEditorControl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements CanvasInlineTextEditorControl<AbstractCanvasHandler, EditorSession, Element> { @Override public void setCommandManagerProvider(final CommandManagerProvider<AbstractCanvasHandler> provider) { getTextEditorBox().setCommandManagerProvider(provider); } @Override void bind(final EditorSession session); @Override void register(final Element element); @Override CanvasInlineTextEditorControl<AbstractCanvasHandler, EditorSession, Element> show(final Element item); @Override void setCommandManagerProvider(final CommandManagerProvider<AbstractCanvasHandler> provider); @Override CanvasInlineTextEditorControl<AbstractCanvasHandler, EditorSession, Element> rollback(); @Override CanvasInlineTextEditorControl<AbstractCanvasHandler, EditorSession, Element> hide(); void scheduleDeferredCommand(final Scheduler.ScheduledCommand command); }
|
AbstractCanvasInlineTextEditorControl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements CanvasInlineTextEditorControl<AbstractCanvasHandler, EditorSession, Element> { @Override public void setCommandManagerProvider(final CommandManagerProvider<AbstractCanvasHandler> provider) { getTextEditorBox().setCommandManagerProvider(provider); } @Override void bind(final EditorSession session); @Override void register(final Element element); @Override CanvasInlineTextEditorControl<AbstractCanvasHandler, EditorSession, Element> show(final Element item); @Override void setCommandManagerProvider(final CommandManagerProvider<AbstractCanvasHandler> provider); @Override CanvasInlineTextEditorControl<AbstractCanvasHandler, EditorSession, Element> rollback(); @Override CanvasInlineTextEditorControl<AbstractCanvasHandler, EditorSession, Element> hide(); void scheduleDeferredCommand(final Scheduler.ScheduledCommand command); static final double SHAPE_EDIT_ALPHA; static final double TITLE_EDIT_ALPHA; static final double NOT_EDIT_ALPHA; static final String ALIGN_MIDDLE; static final String ALIGN_LEFT; static final String ALIGN_TOP; static final String POSITION_INSIDE; static final String POSITION_OUTSIDE; static final String ORIENTATION_VERTICAL; static final String ORIENTATION_HORIZONTAL; static final double DEFAULT_MARGIN_X; static final double DEFAULT_FONT_SIZE; static final String DEFAULT_FONT_FAMILY; }
|
@Test public void testAllowOnlyVisualChanges() { final Element element = mock(Element.class); final Definition definition = mock(Definition.class); final DynamicReadOnly dynamicReadOnly = mock(DynamicReadOnly.class); when(element.getContent()).thenReturn(definition); when(definition.getDefinition()).thenReturn(dynamicReadOnly); boolean actual = control.allowOnlyVisualChanges(element); assertFalse(actual); when(dynamicReadOnly.isAllowOnlyVisualChange()).thenReturn(true); actual = control.allowOnlyVisualChanges(element); assertTrue(actual); }
|
boolean allowOnlyVisualChanges(final Element element) { if (element.getContent() instanceof Definition) { final Definition definition = (Definition) element.getContent(); if (definition.getDefinition() instanceof DynamicReadOnly) { return ((DynamicReadOnly) definition.getDefinition()).isAllowOnlyVisualChange(); } } return false; }
|
AbstractCanvasInlineTextEditorControl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements CanvasInlineTextEditorControl<AbstractCanvasHandler, EditorSession, Element> { boolean allowOnlyVisualChanges(final Element element) { if (element.getContent() instanceof Definition) { final Definition definition = (Definition) element.getContent(); if (definition.getDefinition() instanceof DynamicReadOnly) { return ((DynamicReadOnly) definition.getDefinition()).isAllowOnlyVisualChange(); } } return false; } }
|
AbstractCanvasInlineTextEditorControl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements CanvasInlineTextEditorControl<AbstractCanvasHandler, EditorSession, Element> { boolean allowOnlyVisualChanges(final Element element) { if (element.getContent() instanceof Definition) { final Definition definition = (Definition) element.getContent(); if (definition.getDefinition() instanceof DynamicReadOnly) { return ((DynamicReadOnly) definition.getDefinition()).isAllowOnlyVisualChange(); } } return false; } }
|
AbstractCanvasInlineTextEditorControl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements CanvasInlineTextEditorControl<AbstractCanvasHandler, EditorSession, Element> { boolean allowOnlyVisualChanges(final Element element) { if (element.getContent() instanceof Definition) { final Definition definition = (Definition) element.getContent(); if (definition.getDefinition() instanceof DynamicReadOnly) { return ((DynamicReadOnly) definition.getDefinition()).isAllowOnlyVisualChange(); } } return false; } @Override void bind(final EditorSession session); @Override void register(final Element element); @Override CanvasInlineTextEditorControl<AbstractCanvasHandler, EditorSession, Element> show(final Element item); @Override void setCommandManagerProvider(final CommandManagerProvider<AbstractCanvasHandler> provider); @Override CanvasInlineTextEditorControl<AbstractCanvasHandler, EditorSession, Element> rollback(); @Override CanvasInlineTextEditorControl<AbstractCanvasHandler, EditorSession, Element> hide(); void scheduleDeferredCommand(final Scheduler.ScheduledCommand command); }
|
AbstractCanvasInlineTextEditorControl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements CanvasInlineTextEditorControl<AbstractCanvasHandler, EditorSession, Element> { boolean allowOnlyVisualChanges(final Element element) { if (element.getContent() instanceof Definition) { final Definition definition = (Definition) element.getContent(); if (definition.getDefinition() instanceof DynamicReadOnly) { return ((DynamicReadOnly) definition.getDefinition()).isAllowOnlyVisualChange(); } } return false; } @Override void bind(final EditorSession session); @Override void register(final Element element); @Override CanvasInlineTextEditorControl<AbstractCanvasHandler, EditorSession, Element> show(final Element item); @Override void setCommandManagerProvider(final CommandManagerProvider<AbstractCanvasHandler> provider); @Override CanvasInlineTextEditorControl<AbstractCanvasHandler, EditorSession, Element> rollback(); @Override CanvasInlineTextEditorControl<AbstractCanvasHandler, EditorSession, Element> hide(); void scheduleDeferredCommand(final Scheduler.ScheduledCommand command); static final double SHAPE_EDIT_ALPHA; static final double TITLE_EDIT_ALPHA; static final double NOT_EDIT_ALPHA; static final String ALIGN_MIDDLE; static final String ALIGN_LEFT; static final String ALIGN_TOP; static final String POSITION_INSIDE; static final String POSITION_OUTSIDE; static final String ORIENTATION_VERTICAL; static final String ORIENTATION_HORIZONTAL; static final double DEFAULT_MARGIN_X; static final double DEFAULT_FONT_SIZE; static final String DEFAULT_FONT_FAMILY; }
|
@Test public void testAllowOnlyVisualChangesDefaultValue() { final Element element = mock(Element.class); final boolean actual = control.allowOnlyVisualChanges(element); assertFalse(actual); }
|
boolean allowOnlyVisualChanges(final Element element) { if (element.getContent() instanceof Definition) { final Definition definition = (Definition) element.getContent(); if (definition.getDefinition() instanceof DynamicReadOnly) { return ((DynamicReadOnly) definition.getDefinition()).isAllowOnlyVisualChange(); } } return false; }
|
AbstractCanvasInlineTextEditorControl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements CanvasInlineTextEditorControl<AbstractCanvasHandler, EditorSession, Element> { boolean allowOnlyVisualChanges(final Element element) { if (element.getContent() instanceof Definition) { final Definition definition = (Definition) element.getContent(); if (definition.getDefinition() instanceof DynamicReadOnly) { return ((DynamicReadOnly) definition.getDefinition()).isAllowOnlyVisualChange(); } } return false; } }
|
AbstractCanvasInlineTextEditorControl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements CanvasInlineTextEditorControl<AbstractCanvasHandler, EditorSession, Element> { boolean allowOnlyVisualChanges(final Element element) { if (element.getContent() instanceof Definition) { final Definition definition = (Definition) element.getContent(); if (definition.getDefinition() instanceof DynamicReadOnly) { return ((DynamicReadOnly) definition.getDefinition()).isAllowOnlyVisualChange(); } } return false; } }
|
AbstractCanvasInlineTextEditorControl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements CanvasInlineTextEditorControl<AbstractCanvasHandler, EditorSession, Element> { boolean allowOnlyVisualChanges(final Element element) { if (element.getContent() instanceof Definition) { final Definition definition = (Definition) element.getContent(); if (definition.getDefinition() instanceof DynamicReadOnly) { return ((DynamicReadOnly) definition.getDefinition()).isAllowOnlyVisualChange(); } } return false; } @Override void bind(final EditorSession session); @Override void register(final Element element); @Override CanvasInlineTextEditorControl<AbstractCanvasHandler, EditorSession, Element> show(final Element item); @Override void setCommandManagerProvider(final CommandManagerProvider<AbstractCanvasHandler> provider); @Override CanvasInlineTextEditorControl<AbstractCanvasHandler, EditorSession, Element> rollback(); @Override CanvasInlineTextEditorControl<AbstractCanvasHandler, EditorSession, Element> hide(); void scheduleDeferredCommand(final Scheduler.ScheduledCommand command); }
|
AbstractCanvasInlineTextEditorControl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements CanvasInlineTextEditorControl<AbstractCanvasHandler, EditorSession, Element> { boolean allowOnlyVisualChanges(final Element element) { if (element.getContent() instanceof Definition) { final Definition definition = (Definition) element.getContent(); if (definition.getDefinition() instanceof DynamicReadOnly) { return ((DynamicReadOnly) definition.getDefinition()).isAllowOnlyVisualChange(); } } return false; } @Override void bind(final EditorSession session); @Override void register(final Element element); @Override CanvasInlineTextEditorControl<AbstractCanvasHandler, EditorSession, Element> show(final Element item); @Override void setCommandManagerProvider(final CommandManagerProvider<AbstractCanvasHandler> provider); @Override CanvasInlineTextEditorControl<AbstractCanvasHandler, EditorSession, Element> rollback(); @Override CanvasInlineTextEditorControl<AbstractCanvasHandler, EditorSession, Element> hide(); void scheduleDeferredCommand(final Scheduler.ScheduledCommand command); static final double SHAPE_EDIT_ALPHA; static final double TITLE_EDIT_ALPHA; static final double NOT_EDIT_ALPHA; static final String ALIGN_MIDDLE; static final String ALIGN_LEFT; static final String ALIGN_TOP; static final String POSITION_INSIDE; static final String POSITION_OUTSIDE; static final String ORIENTATION_VERTICAL; static final String ORIENTATION_HORIZONTAL; static final double DEFAULT_MARGIN_X; static final double DEFAULT_FONT_SIZE; static final String DEFAULT_FONT_FAMILY; }
|
@Test public void testGetTheRightFactories() { final List<ActionsToolboxFactory> factories = this.tested.getFactories(); assertEquals(3, factories.size()); assertTrue(factories.contains(flowActionsToolboxFactoryInstance)); assertTrue(factories.contains(morphActionsToolboxFactoryInstance)); assertTrue(factories.contains(commonActionsToolboxFactoryInstance)); }
|
@Override protected List<ActionsToolboxFactory> getFactories() { return Arrays.asList(flowActionsToolboxFactories.get(), morphActionsToolboxFactories.get(), commonActionsToolboxFactories.get()); }
|
DefaultToolboxControl extends AbstractToolboxControl { @Override protected List<ActionsToolboxFactory> getFactories() { return Arrays.asList(flowActionsToolboxFactories.get(), morphActionsToolboxFactories.get(), commonActionsToolboxFactories.get()); } }
|
DefaultToolboxControl extends AbstractToolboxControl { @Override protected List<ActionsToolboxFactory> getFactories() { return Arrays.asList(flowActionsToolboxFactories.get(), morphActionsToolboxFactories.get(), commonActionsToolboxFactories.get()); } @Inject DefaultToolboxControl(final @Any @FlowActionsToolbox ManagedInstance<ActionsToolboxFactory> flowActionsToolboxFactories,
final @Any @MorphActionsToolbox ManagedInstance<ActionsToolboxFactory> morphActionsToolboxFactories,
final @Any @CommonActionsToolbox ManagedInstance<ActionsToolboxFactory> commonActionsToolboxFactories); DefaultToolboxControl(final @Any @FlowActionsToolbox ManagedInstance<ActionsToolboxFactory> flowActionsToolboxFactories,
final @Any @MorphActionsToolbox ManagedInstance<ActionsToolboxFactory> morphActionsToolboxFactories,
final @Any @CommonActionsToolbox ManagedInstance<ActionsToolboxFactory> commonActionsToolboxFactories,
final ToolboxControlImpl<ActionsToolboxFactory> toolboxControl); }
|
DefaultToolboxControl extends AbstractToolboxControl { @Override protected List<ActionsToolboxFactory> getFactories() { return Arrays.asList(flowActionsToolboxFactories.get(), morphActionsToolboxFactories.get(), commonActionsToolboxFactories.get()); } @Inject DefaultToolboxControl(final @Any @FlowActionsToolbox ManagedInstance<ActionsToolboxFactory> flowActionsToolboxFactories,
final @Any @MorphActionsToolbox ManagedInstance<ActionsToolboxFactory> morphActionsToolboxFactories,
final @Any @CommonActionsToolbox ManagedInstance<ActionsToolboxFactory> commonActionsToolboxFactories); DefaultToolboxControl(final @Any @FlowActionsToolbox ManagedInstance<ActionsToolboxFactory> flowActionsToolboxFactories,
final @Any @MorphActionsToolbox ManagedInstance<ActionsToolboxFactory> morphActionsToolboxFactories,
final @Any @CommonActionsToolbox ManagedInstance<ActionsToolboxFactory> commonActionsToolboxFactories,
final ToolboxControlImpl<ActionsToolboxFactory> toolboxControl); @PreDestroy @Override void destroy(); }
|
DefaultToolboxControl extends AbstractToolboxControl { @Override protected List<ActionsToolboxFactory> getFactories() { return Arrays.asList(flowActionsToolboxFactories.get(), morphActionsToolboxFactories.get(), commonActionsToolboxFactories.get()); } @Inject DefaultToolboxControl(final @Any @FlowActionsToolbox ManagedInstance<ActionsToolboxFactory> flowActionsToolboxFactories,
final @Any @MorphActionsToolbox ManagedInstance<ActionsToolboxFactory> morphActionsToolboxFactories,
final @Any @CommonActionsToolbox ManagedInstance<ActionsToolboxFactory> commonActionsToolboxFactories); DefaultToolboxControl(final @Any @FlowActionsToolbox ManagedInstance<ActionsToolboxFactory> flowActionsToolboxFactories,
final @Any @MorphActionsToolbox ManagedInstance<ActionsToolboxFactory> morphActionsToolboxFactories,
final @Any @CommonActionsToolbox ManagedInstance<ActionsToolboxFactory> commonActionsToolboxFactories,
final ToolboxControlImpl<ActionsToolboxFactory> toolboxControl); @PreDestroy @Override void destroy(); }
|
@Test public void testDestroy() { tested.destroy(); verify(flowActionsToolboxFactory, times(1)).destroyAll(); verify(morphActionsToolboxFactory, times(1)).destroyAll(); verify(commonActionsToolboxFactory, times(1)).destroyAll(); }
|
@PreDestroy @Override public void destroy() { super.destroy(); flowActionsToolboxFactories.destroyAll(); morphActionsToolboxFactories.destroyAll(); commonActionsToolboxFactories.destroyAll(); }
|
DefaultToolboxControl extends AbstractToolboxControl { @PreDestroy @Override public void destroy() { super.destroy(); flowActionsToolboxFactories.destroyAll(); morphActionsToolboxFactories.destroyAll(); commonActionsToolboxFactories.destroyAll(); } }
|
DefaultToolboxControl extends AbstractToolboxControl { @PreDestroy @Override public void destroy() { super.destroy(); flowActionsToolboxFactories.destroyAll(); morphActionsToolboxFactories.destroyAll(); commonActionsToolboxFactories.destroyAll(); } @Inject DefaultToolboxControl(final @Any @FlowActionsToolbox ManagedInstance<ActionsToolboxFactory> flowActionsToolboxFactories,
final @Any @MorphActionsToolbox ManagedInstance<ActionsToolboxFactory> morphActionsToolboxFactories,
final @Any @CommonActionsToolbox ManagedInstance<ActionsToolboxFactory> commonActionsToolboxFactories); DefaultToolboxControl(final @Any @FlowActionsToolbox ManagedInstance<ActionsToolboxFactory> flowActionsToolboxFactories,
final @Any @MorphActionsToolbox ManagedInstance<ActionsToolboxFactory> morphActionsToolboxFactories,
final @Any @CommonActionsToolbox ManagedInstance<ActionsToolboxFactory> commonActionsToolboxFactories,
final ToolboxControlImpl<ActionsToolboxFactory> toolboxControl); }
|
DefaultToolboxControl extends AbstractToolboxControl { @PreDestroy @Override public void destroy() { super.destroy(); flowActionsToolboxFactories.destroyAll(); morphActionsToolboxFactories.destroyAll(); commonActionsToolboxFactories.destroyAll(); } @Inject DefaultToolboxControl(final @Any @FlowActionsToolbox ManagedInstance<ActionsToolboxFactory> flowActionsToolboxFactories,
final @Any @MorphActionsToolbox ManagedInstance<ActionsToolboxFactory> morphActionsToolboxFactories,
final @Any @CommonActionsToolbox ManagedInstance<ActionsToolboxFactory> commonActionsToolboxFactories); DefaultToolboxControl(final @Any @FlowActionsToolbox ManagedInstance<ActionsToolboxFactory> flowActionsToolboxFactories,
final @Any @MorphActionsToolbox ManagedInstance<ActionsToolboxFactory> morphActionsToolboxFactories,
final @Any @CommonActionsToolbox ManagedInstance<ActionsToolboxFactory> commonActionsToolboxFactories,
final ToolboxControlImpl<ActionsToolboxFactory> toolboxControl); @PreDestroy @Override void destroy(); }
|
DefaultToolboxControl extends AbstractToolboxControl { @PreDestroy @Override public void destroy() { super.destroy(); flowActionsToolboxFactories.destroyAll(); morphActionsToolboxFactories.destroyAll(); commonActionsToolboxFactories.destroyAll(); } @Inject DefaultToolboxControl(final @Any @FlowActionsToolbox ManagedInstance<ActionsToolboxFactory> flowActionsToolboxFactories,
final @Any @MorphActionsToolbox ManagedInstance<ActionsToolboxFactory> morphActionsToolboxFactories,
final @Any @CommonActionsToolbox ManagedInstance<ActionsToolboxFactory> commonActionsToolboxFactories); DefaultToolboxControl(final @Any @FlowActionsToolbox ManagedInstance<ActionsToolboxFactory> flowActionsToolboxFactories,
final @Any @MorphActionsToolbox ManagedInstance<ActionsToolboxFactory> morphActionsToolboxFactories,
final @Any @CommonActionsToolbox ManagedInstance<ActionsToolboxFactory> commonActionsToolboxFactories,
final ToolboxControlImpl<ActionsToolboxFactory> toolboxControl); @PreDestroy @Override void destroy(); }
|
@Test public void testInitnable() { tested.init(canvasHandler); assertEquals(canvasHandler, tested.getCanvasHandler()); }
|
public AbstractCanvasHandler getCanvasHandler() { return canvasHandler; }
|
ToolboxControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements ToolboxControl<AbstractCanvasHandler, Element> { public AbstractCanvasHandler getCanvasHandler() { return canvasHandler; } }
|
ToolboxControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements ToolboxControl<AbstractCanvasHandler, Element> { public AbstractCanvasHandler getCanvasHandler() { return canvasHandler; } ToolboxControlImpl(final Supplier<List<F>> toolboxFactories); ToolboxControlImpl(final Supplier<List<F>> toolboxFactories,
final Predicate<String> showToolboxPredicate); }
|
ToolboxControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements ToolboxControl<AbstractCanvasHandler, Element> { public AbstractCanvasHandler getCanvasHandler() { return canvasHandler; } ToolboxControlImpl(final Supplier<List<F>> toolboxFactories); ToolboxControlImpl(final Supplier<List<F>> toolboxFactories,
final Predicate<String> showToolboxPredicate); @Override @SuppressWarnings("unchecked") void register(final Element element); @Override Iterator<Toolbox<?>> getToolboxes(final Element element); void destroyToolboxes(); void hideAndDestroyToolboxes(); @SuppressWarnings("unchecked") ToolboxControl<AbstractCanvasHandler, Element> show(final String uuid); ToolboxControl<AbstractCanvasHandler, Element> show(final Element element); AbstractCanvasHandler getCanvasHandler(); boolean isActive(final String uuid); }
|
ToolboxControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements ToolboxControl<AbstractCanvasHandler, Element> { public AbstractCanvasHandler getCanvasHandler() { return canvasHandler; } ToolboxControlImpl(final Supplier<List<F>> toolboxFactories); ToolboxControlImpl(final Supplier<List<F>> toolboxFactories,
final Predicate<String> showToolboxPredicate); @Override @SuppressWarnings("unchecked") void register(final Element element); @Override Iterator<Toolbox<?>> getToolboxes(final Element element); void destroyToolboxes(); void hideAndDestroyToolboxes(); @SuppressWarnings("unchecked") ToolboxControl<AbstractCanvasHandler, Element> show(final String uuid); ToolboxControl<AbstractCanvasHandler, Element> show(final Element element); AbstractCanvasHandler getCanvasHandler(); boolean isActive(final String uuid); static final Predicate<String> ALWAYS_SHOW_PREDICATE; }
|
@Test public void testRegisterElement() { tested.init(canvasHandler); assertFalse(tested.isRegistered(element)); tested.register(element); verify(shapeEventHandler, times(1)).supports(eq(ViewEventType.MOUSE_CLICK)); verify(shapeEventHandler, times(1)).addHandler(eq(ViewEventType.MOUSE_CLICK), any(MouseClickHandler.class)); assertTrue(tested.isRegistered(element)); }
|
@Override @SuppressWarnings("unchecked") public void register(final Element element) { if (checkNotRegistered(element) && supportsToolbox(element)) { final Shape shape = canvasHandler.getCanvas().getShape(element.getUUID()); final HasEventHandlers hasEventHandlers = (HasEventHandlers) shape.getShapeView(); if (hasEventHandlers.supports(ViewEventType.MOUSE_CLICK)) { final MouseClickHandler clickHandler = new MouseClickHandler() { @Override public void handle(final MouseClickEvent event) { if (event.isButtonLeft()) { show(element); } } }; hasEventHandlers.addHandler(ViewEventType.MOUSE_CLICK, clickHandler); registerHandler(element.getUUID(), clickHandler); } } }
|
ToolboxControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements ToolboxControl<AbstractCanvasHandler, Element> { @Override @SuppressWarnings("unchecked") public void register(final Element element) { if (checkNotRegistered(element) && supportsToolbox(element)) { final Shape shape = canvasHandler.getCanvas().getShape(element.getUUID()); final HasEventHandlers hasEventHandlers = (HasEventHandlers) shape.getShapeView(); if (hasEventHandlers.supports(ViewEventType.MOUSE_CLICK)) { final MouseClickHandler clickHandler = new MouseClickHandler() { @Override public void handle(final MouseClickEvent event) { if (event.isButtonLeft()) { show(element); } } }; hasEventHandlers.addHandler(ViewEventType.MOUSE_CLICK, clickHandler); registerHandler(element.getUUID(), clickHandler); } } } }
|
ToolboxControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements ToolboxControl<AbstractCanvasHandler, Element> { @Override @SuppressWarnings("unchecked") public void register(final Element element) { if (checkNotRegistered(element) && supportsToolbox(element)) { final Shape shape = canvasHandler.getCanvas().getShape(element.getUUID()); final HasEventHandlers hasEventHandlers = (HasEventHandlers) shape.getShapeView(); if (hasEventHandlers.supports(ViewEventType.MOUSE_CLICK)) { final MouseClickHandler clickHandler = new MouseClickHandler() { @Override public void handle(final MouseClickEvent event) { if (event.isButtonLeft()) { show(element); } } }; hasEventHandlers.addHandler(ViewEventType.MOUSE_CLICK, clickHandler); registerHandler(element.getUUID(), clickHandler); } } } ToolboxControlImpl(final Supplier<List<F>> toolboxFactories); ToolboxControlImpl(final Supplier<List<F>> toolboxFactories,
final Predicate<String> showToolboxPredicate); }
|
ToolboxControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements ToolboxControl<AbstractCanvasHandler, Element> { @Override @SuppressWarnings("unchecked") public void register(final Element element) { if (checkNotRegistered(element) && supportsToolbox(element)) { final Shape shape = canvasHandler.getCanvas().getShape(element.getUUID()); final HasEventHandlers hasEventHandlers = (HasEventHandlers) shape.getShapeView(); if (hasEventHandlers.supports(ViewEventType.MOUSE_CLICK)) { final MouseClickHandler clickHandler = new MouseClickHandler() { @Override public void handle(final MouseClickEvent event) { if (event.isButtonLeft()) { show(element); } } }; hasEventHandlers.addHandler(ViewEventType.MOUSE_CLICK, clickHandler); registerHandler(element.getUUID(), clickHandler); } } } ToolboxControlImpl(final Supplier<List<F>> toolboxFactories); ToolboxControlImpl(final Supplier<List<F>> toolboxFactories,
final Predicate<String> showToolboxPredicate); @Override @SuppressWarnings("unchecked") void register(final Element element); @Override Iterator<Toolbox<?>> getToolboxes(final Element element); void destroyToolboxes(); void hideAndDestroyToolboxes(); @SuppressWarnings("unchecked") ToolboxControl<AbstractCanvasHandler, Element> show(final String uuid); ToolboxControl<AbstractCanvasHandler, Element> show(final Element element); AbstractCanvasHandler getCanvasHandler(); boolean isActive(final String uuid); }
|
ToolboxControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements ToolboxControl<AbstractCanvasHandler, Element> { @Override @SuppressWarnings("unchecked") public void register(final Element element) { if (checkNotRegistered(element) && supportsToolbox(element)) { final Shape shape = canvasHandler.getCanvas().getShape(element.getUUID()); final HasEventHandlers hasEventHandlers = (HasEventHandlers) shape.getShapeView(); if (hasEventHandlers.supports(ViewEventType.MOUSE_CLICK)) { final MouseClickHandler clickHandler = new MouseClickHandler() { @Override public void handle(final MouseClickEvent event) { if (event.isButtonLeft()) { show(element); } } }; hasEventHandlers.addHandler(ViewEventType.MOUSE_CLICK, clickHandler); registerHandler(element.getUUID(), clickHandler); } } } ToolboxControlImpl(final Supplier<List<F>> toolboxFactories); ToolboxControlImpl(final Supplier<List<F>> toolboxFactories,
final Predicate<String> showToolboxPredicate); @Override @SuppressWarnings("unchecked") void register(final Element element); @Override Iterator<Toolbox<?>> getToolboxes(final Element element); void destroyToolboxes(); void hideAndDestroyToolboxes(); @SuppressWarnings("unchecked") ToolboxControl<AbstractCanvasHandler, Element> show(final String uuid); ToolboxControl<AbstractCanvasHandler, Element> show(final Element element); AbstractCanvasHandler getCanvasHandler(); boolean isActive(final String uuid); static final Predicate<String> ALWAYS_SHOW_PREDICATE; }
|
@Test public void testNotSupportedElement() { tested.init(canvasHandler); final Edge edge = mock(Edge.class); tested.register(edge); assertFalse(tested.isRegistered(edge)); verify(shapeEventHandler, never()).supports(any(ViewEventType.class)); verify(shapeEventHandler, never()).addHandler(any(ViewEventType.class), any(MouseClickHandler.class)); }
|
@Override @SuppressWarnings("unchecked") public void register(final Element element) { if (checkNotRegistered(element) && supportsToolbox(element)) { final Shape shape = canvasHandler.getCanvas().getShape(element.getUUID()); final HasEventHandlers hasEventHandlers = (HasEventHandlers) shape.getShapeView(); if (hasEventHandlers.supports(ViewEventType.MOUSE_CLICK)) { final MouseClickHandler clickHandler = new MouseClickHandler() { @Override public void handle(final MouseClickEvent event) { if (event.isButtonLeft()) { show(element); } } }; hasEventHandlers.addHandler(ViewEventType.MOUSE_CLICK, clickHandler); registerHandler(element.getUUID(), clickHandler); } } }
|
ToolboxControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements ToolboxControl<AbstractCanvasHandler, Element> { @Override @SuppressWarnings("unchecked") public void register(final Element element) { if (checkNotRegistered(element) && supportsToolbox(element)) { final Shape shape = canvasHandler.getCanvas().getShape(element.getUUID()); final HasEventHandlers hasEventHandlers = (HasEventHandlers) shape.getShapeView(); if (hasEventHandlers.supports(ViewEventType.MOUSE_CLICK)) { final MouseClickHandler clickHandler = new MouseClickHandler() { @Override public void handle(final MouseClickEvent event) { if (event.isButtonLeft()) { show(element); } } }; hasEventHandlers.addHandler(ViewEventType.MOUSE_CLICK, clickHandler); registerHandler(element.getUUID(), clickHandler); } } } }
|
ToolboxControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements ToolboxControl<AbstractCanvasHandler, Element> { @Override @SuppressWarnings("unchecked") public void register(final Element element) { if (checkNotRegistered(element) && supportsToolbox(element)) { final Shape shape = canvasHandler.getCanvas().getShape(element.getUUID()); final HasEventHandlers hasEventHandlers = (HasEventHandlers) shape.getShapeView(); if (hasEventHandlers.supports(ViewEventType.MOUSE_CLICK)) { final MouseClickHandler clickHandler = new MouseClickHandler() { @Override public void handle(final MouseClickEvent event) { if (event.isButtonLeft()) { show(element); } } }; hasEventHandlers.addHandler(ViewEventType.MOUSE_CLICK, clickHandler); registerHandler(element.getUUID(), clickHandler); } } } ToolboxControlImpl(final Supplier<List<F>> toolboxFactories); ToolboxControlImpl(final Supplier<List<F>> toolboxFactories,
final Predicate<String> showToolboxPredicate); }
|
ToolboxControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements ToolboxControl<AbstractCanvasHandler, Element> { @Override @SuppressWarnings("unchecked") public void register(final Element element) { if (checkNotRegistered(element) && supportsToolbox(element)) { final Shape shape = canvasHandler.getCanvas().getShape(element.getUUID()); final HasEventHandlers hasEventHandlers = (HasEventHandlers) shape.getShapeView(); if (hasEventHandlers.supports(ViewEventType.MOUSE_CLICK)) { final MouseClickHandler clickHandler = new MouseClickHandler() { @Override public void handle(final MouseClickEvent event) { if (event.isButtonLeft()) { show(element); } } }; hasEventHandlers.addHandler(ViewEventType.MOUSE_CLICK, clickHandler); registerHandler(element.getUUID(), clickHandler); } } } ToolboxControlImpl(final Supplier<List<F>> toolboxFactories); ToolboxControlImpl(final Supplier<List<F>> toolboxFactories,
final Predicate<String> showToolboxPredicate); @Override @SuppressWarnings("unchecked") void register(final Element element); @Override Iterator<Toolbox<?>> getToolboxes(final Element element); void destroyToolboxes(); void hideAndDestroyToolboxes(); @SuppressWarnings("unchecked") ToolboxControl<AbstractCanvasHandler, Element> show(final String uuid); ToolboxControl<AbstractCanvasHandler, Element> show(final Element element); AbstractCanvasHandler getCanvasHandler(); boolean isActive(final String uuid); }
|
ToolboxControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements ToolboxControl<AbstractCanvasHandler, Element> { @Override @SuppressWarnings("unchecked") public void register(final Element element) { if (checkNotRegistered(element) && supportsToolbox(element)) { final Shape shape = canvasHandler.getCanvas().getShape(element.getUUID()); final HasEventHandlers hasEventHandlers = (HasEventHandlers) shape.getShapeView(); if (hasEventHandlers.supports(ViewEventType.MOUSE_CLICK)) { final MouseClickHandler clickHandler = new MouseClickHandler() { @Override public void handle(final MouseClickEvent event) { if (event.isButtonLeft()) { show(element); } } }; hasEventHandlers.addHandler(ViewEventType.MOUSE_CLICK, clickHandler); registerHandler(element.getUUID(), clickHandler); } } } ToolboxControlImpl(final Supplier<List<F>> toolboxFactories); ToolboxControlImpl(final Supplier<List<F>> toolboxFactories,
final Predicate<String> showToolboxPredicate); @Override @SuppressWarnings("unchecked") void register(final Element element); @Override Iterator<Toolbox<?>> getToolboxes(final Element element); void destroyToolboxes(); void hideAndDestroyToolboxes(); @SuppressWarnings("unchecked") ToolboxControl<AbstractCanvasHandler, Element> show(final String uuid); ToolboxControl<AbstractCanvasHandler, Element> show(final Element element); AbstractCanvasHandler getCanvasHandler(); boolean isActive(final String uuid); static final Predicate<String> ALWAYS_SHOW_PREDICATE; }
|
@Test public void testShow() { tested.init(canvasHandler); tested.register(element); assertTrue(tested.isRegistered(element)); tested.show(element); verify(toolbox, times(1)).show(); verify(toolbox, never()).hide(); verify(toolbox, never()).destroy(); }
|
@SuppressWarnings("unchecked") public ToolboxControl<AbstractCanvasHandler, Element> show(final String uuid) { if (showToolboxPredicate.test(uuid)) { final Node node = canvasHandler.getGraphIndex().getNode(uuid); if (null != node) { return show(node); } } return this; }
|
ToolboxControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements ToolboxControl<AbstractCanvasHandler, Element> { @SuppressWarnings("unchecked") public ToolboxControl<AbstractCanvasHandler, Element> show(final String uuid) { if (showToolboxPredicate.test(uuid)) { final Node node = canvasHandler.getGraphIndex().getNode(uuid); if (null != node) { return show(node); } } return this; } }
|
ToolboxControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements ToolboxControl<AbstractCanvasHandler, Element> { @SuppressWarnings("unchecked") public ToolboxControl<AbstractCanvasHandler, Element> show(final String uuid) { if (showToolboxPredicate.test(uuid)) { final Node node = canvasHandler.getGraphIndex().getNode(uuid); if (null != node) { return show(node); } } return this; } ToolboxControlImpl(final Supplier<List<F>> toolboxFactories); ToolboxControlImpl(final Supplier<List<F>> toolboxFactories,
final Predicate<String> showToolboxPredicate); }
|
ToolboxControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements ToolboxControl<AbstractCanvasHandler, Element> { @SuppressWarnings("unchecked") public ToolboxControl<AbstractCanvasHandler, Element> show(final String uuid) { if (showToolboxPredicate.test(uuid)) { final Node node = canvasHandler.getGraphIndex().getNode(uuid); if (null != node) { return show(node); } } return this; } ToolboxControlImpl(final Supplier<List<F>> toolboxFactories); ToolboxControlImpl(final Supplier<List<F>> toolboxFactories,
final Predicate<String> showToolboxPredicate); @Override @SuppressWarnings("unchecked") void register(final Element element); @Override Iterator<Toolbox<?>> getToolboxes(final Element element); void destroyToolboxes(); void hideAndDestroyToolboxes(); @SuppressWarnings("unchecked") ToolboxControl<AbstractCanvasHandler, Element> show(final String uuid); ToolboxControl<AbstractCanvasHandler, Element> show(final Element element); AbstractCanvasHandler getCanvasHandler(); boolean isActive(final String uuid); }
|
ToolboxControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements ToolboxControl<AbstractCanvasHandler, Element> { @SuppressWarnings("unchecked") public ToolboxControl<AbstractCanvasHandler, Element> show(final String uuid) { if (showToolboxPredicate.test(uuid)) { final Node node = canvasHandler.getGraphIndex().getNode(uuid); if (null != node) { return show(node); } } return this; } ToolboxControlImpl(final Supplier<List<F>> toolboxFactories); ToolboxControlImpl(final Supplier<List<F>> toolboxFactories,
final Predicate<String> showToolboxPredicate); @Override @SuppressWarnings("unchecked") void register(final Element element); @Override Iterator<Toolbox<?>> getToolboxes(final Element element); void destroyToolboxes(); void hideAndDestroyToolboxes(); @SuppressWarnings("unchecked") ToolboxControl<AbstractCanvasHandler, Element> show(final String uuid); ToolboxControl<AbstractCanvasHandler, Element> show(final Element element); AbstractCanvasHandler getCanvasHandler(); boolean isActive(final String uuid); static final Predicate<String> ALWAYS_SHOW_PREDICATE; }
|
@Test @SuppressWarnings("unchecked") public void testDeregisterElement() { tested.init(canvasHandler); tested.register(element); tested.deregister(element); verify(shapeEventHandler, times(1)).removeHandler(any(ViewHandler.class)); assertFalse(tested.isRegistered(element)); }
|
@Override @SuppressWarnings("unchecked") public void register(final Element element) { if (checkNotRegistered(element) && supportsToolbox(element)) { final Shape shape = canvasHandler.getCanvas().getShape(element.getUUID()); final HasEventHandlers hasEventHandlers = (HasEventHandlers) shape.getShapeView(); if (hasEventHandlers.supports(ViewEventType.MOUSE_CLICK)) { final MouseClickHandler clickHandler = new MouseClickHandler() { @Override public void handle(final MouseClickEvent event) { if (event.isButtonLeft()) { show(element); } } }; hasEventHandlers.addHandler(ViewEventType.MOUSE_CLICK, clickHandler); registerHandler(element.getUUID(), clickHandler); } } }
|
ToolboxControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements ToolboxControl<AbstractCanvasHandler, Element> { @Override @SuppressWarnings("unchecked") public void register(final Element element) { if (checkNotRegistered(element) && supportsToolbox(element)) { final Shape shape = canvasHandler.getCanvas().getShape(element.getUUID()); final HasEventHandlers hasEventHandlers = (HasEventHandlers) shape.getShapeView(); if (hasEventHandlers.supports(ViewEventType.MOUSE_CLICK)) { final MouseClickHandler clickHandler = new MouseClickHandler() { @Override public void handle(final MouseClickEvent event) { if (event.isButtonLeft()) { show(element); } } }; hasEventHandlers.addHandler(ViewEventType.MOUSE_CLICK, clickHandler); registerHandler(element.getUUID(), clickHandler); } } } }
|
ToolboxControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements ToolboxControl<AbstractCanvasHandler, Element> { @Override @SuppressWarnings("unchecked") public void register(final Element element) { if (checkNotRegistered(element) && supportsToolbox(element)) { final Shape shape = canvasHandler.getCanvas().getShape(element.getUUID()); final HasEventHandlers hasEventHandlers = (HasEventHandlers) shape.getShapeView(); if (hasEventHandlers.supports(ViewEventType.MOUSE_CLICK)) { final MouseClickHandler clickHandler = new MouseClickHandler() { @Override public void handle(final MouseClickEvent event) { if (event.isButtonLeft()) { show(element); } } }; hasEventHandlers.addHandler(ViewEventType.MOUSE_CLICK, clickHandler); registerHandler(element.getUUID(), clickHandler); } } } ToolboxControlImpl(final Supplier<List<F>> toolboxFactories); ToolboxControlImpl(final Supplier<List<F>> toolboxFactories,
final Predicate<String> showToolboxPredicate); }
|
ToolboxControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements ToolboxControl<AbstractCanvasHandler, Element> { @Override @SuppressWarnings("unchecked") public void register(final Element element) { if (checkNotRegistered(element) && supportsToolbox(element)) { final Shape shape = canvasHandler.getCanvas().getShape(element.getUUID()); final HasEventHandlers hasEventHandlers = (HasEventHandlers) shape.getShapeView(); if (hasEventHandlers.supports(ViewEventType.MOUSE_CLICK)) { final MouseClickHandler clickHandler = new MouseClickHandler() { @Override public void handle(final MouseClickEvent event) { if (event.isButtonLeft()) { show(element); } } }; hasEventHandlers.addHandler(ViewEventType.MOUSE_CLICK, clickHandler); registerHandler(element.getUUID(), clickHandler); } } } ToolboxControlImpl(final Supplier<List<F>> toolboxFactories); ToolboxControlImpl(final Supplier<List<F>> toolboxFactories,
final Predicate<String> showToolboxPredicate); @Override @SuppressWarnings("unchecked") void register(final Element element); @Override Iterator<Toolbox<?>> getToolboxes(final Element element); void destroyToolboxes(); void hideAndDestroyToolboxes(); @SuppressWarnings("unchecked") ToolboxControl<AbstractCanvasHandler, Element> show(final String uuid); ToolboxControl<AbstractCanvasHandler, Element> show(final Element element); AbstractCanvasHandler getCanvasHandler(); boolean isActive(final String uuid); }
|
ToolboxControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements ToolboxControl<AbstractCanvasHandler, Element> { @Override @SuppressWarnings("unchecked") public void register(final Element element) { if (checkNotRegistered(element) && supportsToolbox(element)) { final Shape shape = canvasHandler.getCanvas().getShape(element.getUUID()); final HasEventHandlers hasEventHandlers = (HasEventHandlers) shape.getShapeView(); if (hasEventHandlers.supports(ViewEventType.MOUSE_CLICK)) { final MouseClickHandler clickHandler = new MouseClickHandler() { @Override public void handle(final MouseClickEvent event) { if (event.isButtonLeft()) { show(element); } } }; hasEventHandlers.addHandler(ViewEventType.MOUSE_CLICK, clickHandler); registerHandler(element.getUUID(), clickHandler); } } } ToolboxControlImpl(final Supplier<List<F>> toolboxFactories); ToolboxControlImpl(final Supplier<List<F>> toolboxFactories,
final Predicate<String> showToolboxPredicate); @Override @SuppressWarnings("unchecked") void register(final Element element); @Override Iterator<Toolbox<?>> getToolboxes(final Element element); void destroyToolboxes(); void hideAndDestroyToolboxes(); @SuppressWarnings("unchecked") ToolboxControl<AbstractCanvasHandler, Element> show(final String uuid); ToolboxControl<AbstractCanvasHandler, Element> show(final Element element); AbstractCanvasHandler getCanvasHandler(); boolean isActive(final String uuid); static final Predicate<String> ALWAYS_SHOW_PREDICATE; }
|
@Test @SuppressWarnings("unchecked") public void testShowNullControl() { popover.show(); verify(view, never()).show(any(Optional.class)); }
|
@Override public void show() { binding.ifPresent(b -> view.show(Optional.ofNullable(getPopoverTitle()))); }
|
AbstractPopoverImpl implements HasCellEditorControls.Editor<B> { @Override public void show() { binding.ifPresent(b -> view.show(Optional.ofNullable(getPopoverTitle()))); } }
|
AbstractPopoverImpl implements HasCellEditorControls.Editor<B> { @Override public void show() { binding.ifPresent(b -> view.show(Optional.ofNullable(getPopoverTitle()))); } protected AbstractPopoverImpl(); protected AbstractPopoverImpl(final V view); }
|
AbstractPopoverImpl implements HasCellEditorControls.Editor<B> { @Override public void show() { binding.ifPresent(b -> view.show(Optional.ofNullable(getPopoverTitle()))); } protected AbstractPopoverImpl(); protected AbstractPopoverImpl(final V view); @Override HTMLElement getElement(); @Override void bind(final B bound,
final int uiRowIndex,
final int uiColumnIndex); @Override void setOnClosedByKeyboardCallback(final Consumer<CanBeClosedByKeyboard> callback); @Override void show(); @Override void hide(); }
|
AbstractPopoverImpl implements HasCellEditorControls.Editor<B> { @Override public void show() { binding.ifPresent(b -> view.show(Optional.ofNullable(getPopoverTitle()))); } protected AbstractPopoverImpl(); protected AbstractPopoverImpl(final V view); @Override HTMLElement getElement(); @Override void bind(final B bound,
final int uiRowIndex,
final int uiColumnIndex); @Override void setOnClosedByKeyboardCallback(final Consumer<CanBeClosedByKeyboard> callback); @Override void show(); @Override void hide(); }
|
@Test public void checkPriorityEnsuresCatchAllOperation() { assertEquals(TextPropertyProviderFactory.CATCH_ALL_PRIORITY, provider.getPriority()); }
|
@Override public int getPriority() { return TextPropertyProviderFactory.CATCH_ALL_PRIORITY; }
|
DefaultTextPropertyProviderImpl implements TextPropertyProvider { @Override public int getPriority() { return TextPropertyProviderFactory.CATCH_ALL_PRIORITY; } }
|
DefaultTextPropertyProviderImpl implements TextPropertyProvider { @Override public int getPriority() { return TextPropertyProviderFactory.CATCH_ALL_PRIORITY; } DefaultTextPropertyProviderImpl(); @Inject DefaultTextPropertyProviderImpl(final DefinitionUtils definitionUtils,
final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory); }
|
DefaultTextPropertyProviderImpl implements TextPropertyProvider { @Override public int getPriority() { return TextPropertyProviderFactory.CATCH_ALL_PRIORITY; } DefaultTextPropertyProviderImpl(); @Inject DefaultTextPropertyProviderImpl(final DefinitionUtils definitionUtils,
final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory); @Override int getPriority(); @Override boolean supports(final Element<? extends Definition> element); @Override String getText(final Element<? extends Definition> element); @Override void setText(final AbstractCanvasHandler canvasHandler,
final CanvasCommandManager<AbstractCanvasHandler> commandManager,
final Element<? extends Definition> element,
final String text); }
|
DefaultTextPropertyProviderImpl implements TextPropertyProvider { @Override public int getPriority() { return TextPropertyProviderFactory.CATCH_ALL_PRIORITY; } DefaultTextPropertyProviderImpl(); @Inject DefaultTextPropertyProviderImpl(final DefinitionUtils definitionUtils,
final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory); @Override int getPriority(); @Override boolean supports(final Element<? extends Definition> element); @Override String getText(final Element<? extends Definition> element); @Override void setText(final AbstractCanvasHandler canvasHandler,
final CanvasCommandManager<AbstractCanvasHandler> commandManager,
final Element<? extends Definition> element,
final String text); }
|
@Test @SuppressWarnings("unchecked") public void checkSupportsAllElements() { assertTrue(provider.supports(element)); }
|
@Override public boolean supports(final Element<? extends Definition> element) { return true; }
|
DefaultTextPropertyProviderImpl implements TextPropertyProvider { @Override public boolean supports(final Element<? extends Definition> element) { return true; } }
|
DefaultTextPropertyProviderImpl implements TextPropertyProvider { @Override public boolean supports(final Element<? extends Definition> element) { return true; } DefaultTextPropertyProviderImpl(); @Inject DefaultTextPropertyProviderImpl(final DefinitionUtils definitionUtils,
final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory); }
|
DefaultTextPropertyProviderImpl implements TextPropertyProvider { @Override public boolean supports(final Element<? extends Definition> element) { return true; } DefaultTextPropertyProviderImpl(); @Inject DefaultTextPropertyProviderImpl(final DefinitionUtils definitionUtils,
final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory); @Override int getPriority(); @Override boolean supports(final Element<? extends Definition> element); @Override String getText(final Element<? extends Definition> element); @Override void setText(final AbstractCanvasHandler canvasHandler,
final CanvasCommandManager<AbstractCanvasHandler> commandManager,
final Element<? extends Definition> element,
final String text); }
|
DefaultTextPropertyProviderImpl implements TextPropertyProvider { @Override public boolean supports(final Element<? extends Definition> element) { return true; } DefaultTextPropertyProviderImpl(); @Inject DefaultTextPropertyProviderImpl(final DefinitionUtils definitionUtils,
final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory); @Override int getPriority(); @Override boolean supports(final Element<? extends Definition> element); @Override String getText(final Element<? extends Definition> element); @Override void setText(final AbstractCanvasHandler canvasHandler,
final CanvasCommandManager<AbstractCanvasHandler> commandManager,
final Element<? extends Definition> element,
final String text); }
|
@Test public void checkReadGetsNameFromPropertyMetaData() { provider.getText(element); verify(definitionUtils).getName(eq(definition)); }
|
@Override public String getText(final Element<? extends Definition> element) { return definitionUtils.getName(element.getContent().getDefinition()); }
|
DefaultTextPropertyProviderImpl implements TextPropertyProvider { @Override public String getText(final Element<? extends Definition> element) { return definitionUtils.getName(element.getContent().getDefinition()); } }
|
DefaultTextPropertyProviderImpl implements TextPropertyProvider { @Override public String getText(final Element<? extends Definition> element) { return definitionUtils.getName(element.getContent().getDefinition()); } DefaultTextPropertyProviderImpl(); @Inject DefaultTextPropertyProviderImpl(final DefinitionUtils definitionUtils,
final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory); }
|
DefaultTextPropertyProviderImpl implements TextPropertyProvider { @Override public String getText(final Element<? extends Definition> element) { return definitionUtils.getName(element.getContent().getDefinition()); } DefaultTextPropertyProviderImpl(); @Inject DefaultTextPropertyProviderImpl(final DefinitionUtils definitionUtils,
final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory); @Override int getPriority(); @Override boolean supports(final Element<? extends Definition> element); @Override String getText(final Element<? extends Definition> element); @Override void setText(final AbstractCanvasHandler canvasHandler,
final CanvasCommandManager<AbstractCanvasHandler> commandManager,
final Element<? extends Definition> element,
final String text); }
|
DefaultTextPropertyProviderImpl implements TextPropertyProvider { @Override public String getText(final Element<? extends Definition> element) { return definitionUtils.getName(element.getContent().getDefinition()); } DefaultTextPropertyProviderImpl(); @Inject DefaultTextPropertyProviderImpl(final DefinitionUtils definitionUtils,
final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory); @Override int getPriority(); @Override boolean supports(final Element<? extends Definition> element); @Override String getText(final Element<? extends Definition> element); @Override void setText(final AbstractCanvasHandler canvasHandler,
final CanvasCommandManager<AbstractCanvasHandler> commandManager,
final Element<? extends Definition> element,
final String text); }
|
@Test public void checkWriteUsesCommandToUpdateNamePropertyMetaData() { provider.setText(canvasHandler, commandManager, element, "text"); verify(canvasCommandFactory).updatePropertyValue(eq(element), eq("name"), eq("text")); verify(commandManager).execute(eq(canvasHandler), eq(command)); }
|
@Override public void setText(final AbstractCanvasHandler canvasHandler, final CanvasCommandManager<AbstractCanvasHandler> commandManager, final Element<? extends Definition> element, final String text) { final Object def = element.getContent().getDefinition(); final String nameField = definitionUtils.getNameIdentifier(def); if (null != nameField) { final CanvasCommand<AbstractCanvasHandler> command = canvasCommandFactory.updatePropertyValue(element, nameField, text); commandManager.execute(canvasHandler, command); } }
|
DefaultTextPropertyProviderImpl implements TextPropertyProvider { @Override public void setText(final AbstractCanvasHandler canvasHandler, final CanvasCommandManager<AbstractCanvasHandler> commandManager, final Element<? extends Definition> element, final String text) { final Object def = element.getContent().getDefinition(); final String nameField = definitionUtils.getNameIdentifier(def); if (null != nameField) { final CanvasCommand<AbstractCanvasHandler> command = canvasCommandFactory.updatePropertyValue(element, nameField, text); commandManager.execute(canvasHandler, command); } } }
|
DefaultTextPropertyProviderImpl implements TextPropertyProvider { @Override public void setText(final AbstractCanvasHandler canvasHandler, final CanvasCommandManager<AbstractCanvasHandler> commandManager, final Element<? extends Definition> element, final String text) { final Object def = element.getContent().getDefinition(); final String nameField = definitionUtils.getNameIdentifier(def); if (null != nameField) { final CanvasCommand<AbstractCanvasHandler> command = canvasCommandFactory.updatePropertyValue(element, nameField, text); commandManager.execute(canvasHandler, command); } } DefaultTextPropertyProviderImpl(); @Inject DefaultTextPropertyProviderImpl(final DefinitionUtils definitionUtils,
final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory); }
|
DefaultTextPropertyProviderImpl implements TextPropertyProvider { @Override public void setText(final AbstractCanvasHandler canvasHandler, final CanvasCommandManager<AbstractCanvasHandler> commandManager, final Element<? extends Definition> element, final String text) { final Object def = element.getContent().getDefinition(); final String nameField = definitionUtils.getNameIdentifier(def); if (null != nameField) { final CanvasCommand<AbstractCanvasHandler> command = canvasCommandFactory.updatePropertyValue(element, nameField, text); commandManager.execute(canvasHandler, command); } } DefaultTextPropertyProviderImpl(); @Inject DefaultTextPropertyProviderImpl(final DefinitionUtils definitionUtils,
final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory); @Override int getPriority(); @Override boolean supports(final Element<? extends Definition> element); @Override String getText(final Element<? extends Definition> element); @Override void setText(final AbstractCanvasHandler canvasHandler,
final CanvasCommandManager<AbstractCanvasHandler> commandManager,
final Element<? extends Definition> element,
final String text); }
|
DefaultTextPropertyProviderImpl implements TextPropertyProvider { @Override public void setText(final AbstractCanvasHandler canvasHandler, final CanvasCommandManager<AbstractCanvasHandler> commandManager, final Element<? extends Definition> element, final String text) { final Object def = element.getContent().getDefinition(); final String nameField = definitionUtils.getNameIdentifier(def); if (null != nameField) { final CanvasCommand<AbstractCanvasHandler> command = canvasCommandFactory.updatePropertyValue(element, nameField, text); commandManager.execute(canvasHandler, command); } } DefaultTextPropertyProviderImpl(); @Inject DefaultTextPropertyProviderImpl(final DefinitionUtils definitionUtils,
final CanvasCommandFactory<AbstractCanvasHandler> canvasCommandFactory); @Override int getPriority(); @Override boolean supports(final Element<? extends Definition> element); @Override String getText(final Element<? extends Definition> element); @Override void setText(final AbstractCanvasHandler canvasHandler,
final CanvasCommandManager<AbstractCanvasHandler> commandManager,
final Element<? extends Definition> element,
final String text); }
|
@Test public void checkMatch() { final boolean match = KeysMatcher.doKeysMatch(keysActual.keys, keysExpected.keys); assertEquals(matches, match); }
|
public static boolean doKeysMatch(final KeyboardEvent.Key[] actualKeys, final KeyboardEvent.Key... expectedKeys) { if (actualKeys == null) { return expectedKeys == null; } else if (expectedKeys == null) { return false; } if (actualKeys.length != expectedKeys.length) { return false; } final Set<KeyboardEvent.Key> matches = new HashSet<>(); matches.addAll(Arrays.asList(actualKeys)); matches.retainAll(Arrays.asList(expectedKeys)); return matches.size() == expectedKeys.length; }
|
KeysMatcher { public static boolean doKeysMatch(final KeyboardEvent.Key[] actualKeys, final KeyboardEvent.Key... expectedKeys) { if (actualKeys == null) { return expectedKeys == null; } else if (expectedKeys == null) { return false; } if (actualKeys.length != expectedKeys.length) { return false; } final Set<KeyboardEvent.Key> matches = new HashSet<>(); matches.addAll(Arrays.asList(actualKeys)); matches.retainAll(Arrays.asList(expectedKeys)); return matches.size() == expectedKeys.length; } }
|
KeysMatcher { public static boolean doKeysMatch(final KeyboardEvent.Key[] actualKeys, final KeyboardEvent.Key... expectedKeys) { if (actualKeys == null) { return expectedKeys == null; } else if (expectedKeys == null) { return false; } if (actualKeys.length != expectedKeys.length) { return false; } final Set<KeyboardEvent.Key> matches = new HashSet<>(); matches.addAll(Arrays.asList(actualKeys)); matches.retainAll(Arrays.asList(expectedKeys)); return matches.size() == expectedKeys.length; } }
|
KeysMatcher { public static boolean doKeysMatch(final KeyboardEvent.Key[] actualKeys, final KeyboardEvent.Key... expectedKeys) { if (actualKeys == null) { return expectedKeys == null; } else if (expectedKeys == null) { return false; } if (actualKeys.length != expectedKeys.length) { return false; } final Set<KeyboardEvent.Key> matches = new HashSet<>(); matches.addAll(Arrays.asList(actualKeys)); matches.retainAll(Arrays.asList(expectedKeys)); return matches.size() == expectedKeys.length; } static boolean doKeysMatch(final KeyboardEvent.Key[] actualKeys,
final KeyboardEvent.Key... expectedKeys); static boolean isKeyMatch(final KeyboardEvent.Key[] actualKeys,
final KeyboardEvent.Key... expectedKey); }
|
KeysMatcher { public static boolean doKeysMatch(final KeyboardEvent.Key[] actualKeys, final KeyboardEvent.Key... expectedKeys) { if (actualKeys == null) { return expectedKeys == null; } else if (expectedKeys == null) { return false; } if (actualKeys.length != expectedKeys.length) { return false; } final Set<KeyboardEvent.Key> matches = new HashSet<>(); matches.addAll(Arrays.asList(actualKeys)); matches.retainAll(Arrays.asList(expectedKeys)); return matches.size() == expectedKeys.length; } static boolean doKeysMatch(final KeyboardEvent.Key[] actualKeys,
final KeyboardEvent.Key... expectedKeys); static boolean isKeyMatch(final KeyboardEvent.Key[] actualKeys,
final KeyboardEvent.Key... expectedKey); }
|
@Test public void testBind() { assertThat(canvasShortcutsControl.editorSession).isNull(); final EditorSession session = mock(EditorSession.class); final KeyboardControl keyboardControl = mock(KeyboardControl.class); doReturn(keyboardControl).when(session).getKeyboardControl(); canvasShortcutsControl.bind(session); assertThat(canvasShortcutsControl.editorSession).isEqualTo(session); verify(keyboardControl).addKeyShortcutCallback(eq(canvasShortcutsControl)); }
|
@Override public void bind(final EditorSession session) { this.editorSession = session; session.getKeyboardControl().addKeyShortcutCallback(this); }
|
AbstractCanvasShortcutsControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements CanvasControl.SessionAware<EditorSession>,
KeyboardControl.KeyShortcutCallback { @Override public void bind(final EditorSession session) { this.editorSession = session; session.getKeyboardControl().addKeyShortcutCallback(this); } }
|
AbstractCanvasShortcutsControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements CanvasControl.SessionAware<EditorSession>,
KeyboardControl.KeyShortcutCallback { @Override public void bind(final EditorSession session) { this.editorSession = session; session.getKeyboardControl().addKeyShortcutCallback(this); } @Inject AbstractCanvasShortcutsControlImpl(final Instance<KeyboardShortcut> keyboardShortcutActions); }
|
AbstractCanvasShortcutsControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements CanvasControl.SessionAware<EditorSession>,
KeyboardControl.KeyShortcutCallback { @Override public void bind(final EditorSession session) { this.editorSession = session; session.getKeyboardControl().addKeyShortcutCallback(this); } @Inject AbstractCanvasShortcutsControlImpl(final Instance<KeyboardShortcut> keyboardShortcutActions); @Override void register(Element element); @Override void bind(final EditorSession session); @Override void onKeyShortcut(final KeyboardEvent.Key... keys); String selectedNodeId(); Element selectedNodeElement(); }
|
AbstractCanvasShortcutsControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements CanvasControl.SessionAware<EditorSession>,
KeyboardControl.KeyShortcutCallback { @Override public void bind(final EditorSession session) { this.editorSession = session; session.getKeyboardControl().addKeyShortcutCallback(this); } @Inject AbstractCanvasShortcutsControlImpl(final Instance<KeyboardShortcut> keyboardShortcutActions); @Override void register(Element element); @Override void bind(final EditorSession session); @Override void onKeyShortcut(final KeyboardEvent.Key... keys); String selectedNodeId(); Element selectedNodeElement(); }
|
@Test public void testOnKeyShortcutNothingSelected() { mockSelectedElements(); mockActionReactingOnKeyAndSelectedElement(KeyboardEvent.Key.E, mock(Element.class)); canvasShortcutsControl.onKeyShortcut(KeyboardEvent.Key.E); verify(keyboardShortcutAction, never()).executeAction(any(), any()); }
|
@Override public void onKeyShortcut(final KeyboardEvent.Key... keys) { if (selectedNodeId() != null) { final Iterator<KeyboardShortcut> keyboardShortcutActionsIterator = keyboardShortcutActions.iterator(); while (keyboardShortcutActionsIterator.hasNext()) { final KeyboardShortcut action = keyboardShortcutActionsIterator.next(); if (action.matchesPressedKeys(keys) && action.matchesSelectedElement(selectedNodeElement())) { action.executeAction(canvasHandler, selectedNodeId()); } } } }
|
AbstractCanvasShortcutsControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements CanvasControl.SessionAware<EditorSession>,
KeyboardControl.KeyShortcutCallback { @Override public void onKeyShortcut(final KeyboardEvent.Key... keys) { if (selectedNodeId() != null) { final Iterator<KeyboardShortcut> keyboardShortcutActionsIterator = keyboardShortcutActions.iterator(); while (keyboardShortcutActionsIterator.hasNext()) { final KeyboardShortcut action = keyboardShortcutActionsIterator.next(); if (action.matchesPressedKeys(keys) && action.matchesSelectedElement(selectedNodeElement())) { action.executeAction(canvasHandler, selectedNodeId()); } } } } }
|
AbstractCanvasShortcutsControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements CanvasControl.SessionAware<EditorSession>,
KeyboardControl.KeyShortcutCallback { @Override public void onKeyShortcut(final KeyboardEvent.Key... keys) { if (selectedNodeId() != null) { final Iterator<KeyboardShortcut> keyboardShortcutActionsIterator = keyboardShortcutActions.iterator(); while (keyboardShortcutActionsIterator.hasNext()) { final KeyboardShortcut action = keyboardShortcutActionsIterator.next(); if (action.matchesPressedKeys(keys) && action.matchesSelectedElement(selectedNodeElement())) { action.executeAction(canvasHandler, selectedNodeId()); } } } } @Inject AbstractCanvasShortcutsControlImpl(final Instance<KeyboardShortcut> keyboardShortcutActions); }
|
AbstractCanvasShortcutsControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements CanvasControl.SessionAware<EditorSession>,
KeyboardControl.KeyShortcutCallback { @Override public void onKeyShortcut(final KeyboardEvent.Key... keys) { if (selectedNodeId() != null) { final Iterator<KeyboardShortcut> keyboardShortcutActionsIterator = keyboardShortcutActions.iterator(); while (keyboardShortcutActionsIterator.hasNext()) { final KeyboardShortcut action = keyboardShortcutActionsIterator.next(); if (action.matchesPressedKeys(keys) && action.matchesSelectedElement(selectedNodeElement())) { action.executeAction(canvasHandler, selectedNodeId()); } } } } @Inject AbstractCanvasShortcutsControlImpl(final Instance<KeyboardShortcut> keyboardShortcutActions); @Override void register(Element element); @Override void bind(final EditorSession session); @Override void onKeyShortcut(final KeyboardEvent.Key... keys); String selectedNodeId(); Element selectedNodeElement(); }
|
AbstractCanvasShortcutsControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements CanvasControl.SessionAware<EditorSession>,
KeyboardControl.KeyShortcutCallback { @Override public void onKeyShortcut(final KeyboardEvent.Key... keys) { if (selectedNodeId() != null) { final Iterator<KeyboardShortcut> keyboardShortcutActionsIterator = keyboardShortcutActions.iterator(); while (keyboardShortcutActionsIterator.hasNext()) { final KeyboardShortcut action = keyboardShortcutActionsIterator.next(); if (action.matchesPressedKeys(keys) && action.matchesSelectedElement(selectedNodeElement())) { action.executeAction(canvasHandler, selectedNodeId()); } } } } @Inject AbstractCanvasShortcutsControlImpl(final Instance<KeyboardShortcut> keyboardShortcutActions); @Override void register(Element element); @Override void bind(final EditorSession session); @Override void onKeyShortcut(final KeyboardEvent.Key... keys); String selectedNodeId(); Element selectedNodeElement(); }
|
@Test public void testOnKeyShortcutWrongPressedKey() { final Element selectedElement = mockSelectedElements("element").get(0); mockActionReactingOnKeyAndSelectedElement(KeyboardEvent.Key.T, selectedElement); canvasShortcutsControl.onKeyShortcut(KeyboardEvent.Key.E); verify(keyboardShortcutAction, never()).executeAction(any(), any()); }
|
@Override public void onKeyShortcut(final KeyboardEvent.Key... keys) { if (selectedNodeId() != null) { final Iterator<KeyboardShortcut> keyboardShortcutActionsIterator = keyboardShortcutActions.iterator(); while (keyboardShortcutActionsIterator.hasNext()) { final KeyboardShortcut action = keyboardShortcutActionsIterator.next(); if (action.matchesPressedKeys(keys) && action.matchesSelectedElement(selectedNodeElement())) { action.executeAction(canvasHandler, selectedNodeId()); } } } }
|
AbstractCanvasShortcutsControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements CanvasControl.SessionAware<EditorSession>,
KeyboardControl.KeyShortcutCallback { @Override public void onKeyShortcut(final KeyboardEvent.Key... keys) { if (selectedNodeId() != null) { final Iterator<KeyboardShortcut> keyboardShortcutActionsIterator = keyboardShortcutActions.iterator(); while (keyboardShortcutActionsIterator.hasNext()) { final KeyboardShortcut action = keyboardShortcutActionsIterator.next(); if (action.matchesPressedKeys(keys) && action.matchesSelectedElement(selectedNodeElement())) { action.executeAction(canvasHandler, selectedNodeId()); } } } } }
|
AbstractCanvasShortcutsControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements CanvasControl.SessionAware<EditorSession>,
KeyboardControl.KeyShortcutCallback { @Override public void onKeyShortcut(final KeyboardEvent.Key... keys) { if (selectedNodeId() != null) { final Iterator<KeyboardShortcut> keyboardShortcutActionsIterator = keyboardShortcutActions.iterator(); while (keyboardShortcutActionsIterator.hasNext()) { final KeyboardShortcut action = keyboardShortcutActionsIterator.next(); if (action.matchesPressedKeys(keys) && action.matchesSelectedElement(selectedNodeElement())) { action.executeAction(canvasHandler, selectedNodeId()); } } } } @Inject AbstractCanvasShortcutsControlImpl(final Instance<KeyboardShortcut> keyboardShortcutActions); }
|
AbstractCanvasShortcutsControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements CanvasControl.SessionAware<EditorSession>,
KeyboardControl.KeyShortcutCallback { @Override public void onKeyShortcut(final KeyboardEvent.Key... keys) { if (selectedNodeId() != null) { final Iterator<KeyboardShortcut> keyboardShortcutActionsIterator = keyboardShortcutActions.iterator(); while (keyboardShortcutActionsIterator.hasNext()) { final KeyboardShortcut action = keyboardShortcutActionsIterator.next(); if (action.matchesPressedKeys(keys) && action.matchesSelectedElement(selectedNodeElement())) { action.executeAction(canvasHandler, selectedNodeId()); } } } } @Inject AbstractCanvasShortcutsControlImpl(final Instance<KeyboardShortcut> keyboardShortcutActions); @Override void register(Element element); @Override void bind(final EditorSession session); @Override void onKeyShortcut(final KeyboardEvent.Key... keys); String selectedNodeId(); Element selectedNodeElement(); }
|
AbstractCanvasShortcutsControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements CanvasControl.SessionAware<EditorSession>,
KeyboardControl.KeyShortcutCallback { @Override public void onKeyShortcut(final KeyboardEvent.Key... keys) { if (selectedNodeId() != null) { final Iterator<KeyboardShortcut> keyboardShortcutActionsIterator = keyboardShortcutActions.iterator(); while (keyboardShortcutActionsIterator.hasNext()) { final KeyboardShortcut action = keyboardShortcutActionsIterator.next(); if (action.matchesPressedKeys(keys) && action.matchesSelectedElement(selectedNodeElement())) { action.executeAction(canvasHandler, selectedNodeId()); } } } } @Inject AbstractCanvasShortcutsControlImpl(final Instance<KeyboardShortcut> keyboardShortcutActions); @Override void register(Element element); @Override void bind(final EditorSession session); @Override void onKeyShortcut(final KeyboardEvent.Key... keys); String selectedNodeId(); Element selectedNodeElement(); }
|
@Test public void testOnKeyShortcutWrongElement() { mockSelectedElements("element"); mockActionReactingOnKeyAndSelectedElement(KeyboardEvent.Key.E, mock(Element.class)); canvasShortcutsControl.onKeyShortcut(KeyboardEvent.Key.E); verify(keyboardShortcutAction, never()).executeAction(any(), any()); }
|
@Override public void onKeyShortcut(final KeyboardEvent.Key... keys) { if (selectedNodeId() != null) { final Iterator<KeyboardShortcut> keyboardShortcutActionsIterator = keyboardShortcutActions.iterator(); while (keyboardShortcutActionsIterator.hasNext()) { final KeyboardShortcut action = keyboardShortcutActionsIterator.next(); if (action.matchesPressedKeys(keys) && action.matchesSelectedElement(selectedNodeElement())) { action.executeAction(canvasHandler, selectedNodeId()); } } } }
|
AbstractCanvasShortcutsControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements CanvasControl.SessionAware<EditorSession>,
KeyboardControl.KeyShortcutCallback { @Override public void onKeyShortcut(final KeyboardEvent.Key... keys) { if (selectedNodeId() != null) { final Iterator<KeyboardShortcut> keyboardShortcutActionsIterator = keyboardShortcutActions.iterator(); while (keyboardShortcutActionsIterator.hasNext()) { final KeyboardShortcut action = keyboardShortcutActionsIterator.next(); if (action.matchesPressedKeys(keys) && action.matchesSelectedElement(selectedNodeElement())) { action.executeAction(canvasHandler, selectedNodeId()); } } } } }
|
AbstractCanvasShortcutsControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements CanvasControl.SessionAware<EditorSession>,
KeyboardControl.KeyShortcutCallback { @Override public void onKeyShortcut(final KeyboardEvent.Key... keys) { if (selectedNodeId() != null) { final Iterator<KeyboardShortcut> keyboardShortcutActionsIterator = keyboardShortcutActions.iterator(); while (keyboardShortcutActionsIterator.hasNext()) { final KeyboardShortcut action = keyboardShortcutActionsIterator.next(); if (action.matchesPressedKeys(keys) && action.matchesSelectedElement(selectedNodeElement())) { action.executeAction(canvasHandler, selectedNodeId()); } } } } @Inject AbstractCanvasShortcutsControlImpl(final Instance<KeyboardShortcut> keyboardShortcutActions); }
|
AbstractCanvasShortcutsControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements CanvasControl.SessionAware<EditorSession>,
KeyboardControl.KeyShortcutCallback { @Override public void onKeyShortcut(final KeyboardEvent.Key... keys) { if (selectedNodeId() != null) { final Iterator<KeyboardShortcut> keyboardShortcutActionsIterator = keyboardShortcutActions.iterator(); while (keyboardShortcutActionsIterator.hasNext()) { final KeyboardShortcut action = keyboardShortcutActionsIterator.next(); if (action.matchesPressedKeys(keys) && action.matchesSelectedElement(selectedNodeElement())) { action.executeAction(canvasHandler, selectedNodeId()); } } } } @Inject AbstractCanvasShortcutsControlImpl(final Instance<KeyboardShortcut> keyboardShortcutActions); @Override void register(Element element); @Override void bind(final EditorSession session); @Override void onKeyShortcut(final KeyboardEvent.Key... keys); String selectedNodeId(); Element selectedNodeElement(); }
|
AbstractCanvasShortcutsControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements CanvasControl.SessionAware<EditorSession>,
KeyboardControl.KeyShortcutCallback { @Override public void onKeyShortcut(final KeyboardEvent.Key... keys) { if (selectedNodeId() != null) { final Iterator<KeyboardShortcut> keyboardShortcutActionsIterator = keyboardShortcutActions.iterator(); while (keyboardShortcutActionsIterator.hasNext()) { final KeyboardShortcut action = keyboardShortcutActionsIterator.next(); if (action.matchesPressedKeys(keys) && action.matchesSelectedElement(selectedNodeElement())) { action.executeAction(canvasHandler, selectedNodeId()); } } } } @Inject AbstractCanvasShortcutsControlImpl(final Instance<KeyboardShortcut> keyboardShortcutActions); @Override void register(Element element); @Override void bind(final EditorSession session); @Override void onKeyShortcut(final KeyboardEvent.Key... keys); String selectedNodeId(); Element selectedNodeElement(); }
|
@Test public void testOnKeyShortcutSelectedElements() { mockSelectedElements("element-1", "element-2"); mockActionReactingOnKeyAndSelectedElement(KeyboardEvent.Key.E, mock(Element.class)); canvasShortcutsControl.onKeyShortcut(KeyboardEvent.Key.E); verify(keyboardShortcutAction, never()).executeAction(any(), any()); }
|
@Override public void onKeyShortcut(final KeyboardEvent.Key... keys) { if (selectedNodeId() != null) { final Iterator<KeyboardShortcut> keyboardShortcutActionsIterator = keyboardShortcutActions.iterator(); while (keyboardShortcutActionsIterator.hasNext()) { final KeyboardShortcut action = keyboardShortcutActionsIterator.next(); if (action.matchesPressedKeys(keys) && action.matchesSelectedElement(selectedNodeElement())) { action.executeAction(canvasHandler, selectedNodeId()); } } } }
|
AbstractCanvasShortcutsControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements CanvasControl.SessionAware<EditorSession>,
KeyboardControl.KeyShortcutCallback { @Override public void onKeyShortcut(final KeyboardEvent.Key... keys) { if (selectedNodeId() != null) { final Iterator<KeyboardShortcut> keyboardShortcutActionsIterator = keyboardShortcutActions.iterator(); while (keyboardShortcutActionsIterator.hasNext()) { final KeyboardShortcut action = keyboardShortcutActionsIterator.next(); if (action.matchesPressedKeys(keys) && action.matchesSelectedElement(selectedNodeElement())) { action.executeAction(canvasHandler, selectedNodeId()); } } } } }
|
AbstractCanvasShortcutsControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements CanvasControl.SessionAware<EditorSession>,
KeyboardControl.KeyShortcutCallback { @Override public void onKeyShortcut(final KeyboardEvent.Key... keys) { if (selectedNodeId() != null) { final Iterator<KeyboardShortcut> keyboardShortcutActionsIterator = keyboardShortcutActions.iterator(); while (keyboardShortcutActionsIterator.hasNext()) { final KeyboardShortcut action = keyboardShortcutActionsIterator.next(); if (action.matchesPressedKeys(keys) && action.matchesSelectedElement(selectedNodeElement())) { action.executeAction(canvasHandler, selectedNodeId()); } } } } @Inject AbstractCanvasShortcutsControlImpl(final Instance<KeyboardShortcut> keyboardShortcutActions); }
|
AbstractCanvasShortcutsControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements CanvasControl.SessionAware<EditorSession>,
KeyboardControl.KeyShortcutCallback { @Override public void onKeyShortcut(final KeyboardEvent.Key... keys) { if (selectedNodeId() != null) { final Iterator<KeyboardShortcut> keyboardShortcutActionsIterator = keyboardShortcutActions.iterator(); while (keyboardShortcutActionsIterator.hasNext()) { final KeyboardShortcut action = keyboardShortcutActionsIterator.next(); if (action.matchesPressedKeys(keys) && action.matchesSelectedElement(selectedNodeElement())) { action.executeAction(canvasHandler, selectedNodeId()); } } } } @Inject AbstractCanvasShortcutsControlImpl(final Instance<KeyboardShortcut> keyboardShortcutActions); @Override void register(Element element); @Override void bind(final EditorSession session); @Override void onKeyShortcut(final KeyboardEvent.Key... keys); String selectedNodeId(); Element selectedNodeElement(); }
|
AbstractCanvasShortcutsControlImpl extends AbstractCanvasHandlerRegistrationControl<AbstractCanvasHandler> implements CanvasControl.SessionAware<EditorSession>,
KeyboardControl.KeyShortcutCallback { @Override public void onKeyShortcut(final KeyboardEvent.Key... keys) { if (selectedNodeId() != null) { final Iterator<KeyboardShortcut> keyboardShortcutActionsIterator = keyboardShortcutActions.iterator(); while (keyboardShortcutActionsIterator.hasNext()) { final KeyboardShortcut action = keyboardShortcutActionsIterator.next(); if (action.matchesPressedKeys(keys) && action.matchesSelectedElement(selectedNodeElement())) { action.executeAction(canvasHandler, selectedNodeId()); } } } } @Inject AbstractCanvasShortcutsControlImpl(final Instance<KeyboardShortcut> keyboardShortcutActions); @Override void register(Element element); @Override void bind(final EditorSession session); @Override void onKeyShortcut(final KeyboardEvent.Key... keys); String selectedNodeId(); Element selectedNodeElement(); }
|
@Test public void testHideNullControl() { popover.hide(); verify(view, never()).hide(); }
|
@Override public void hide() { binding.ifPresent(b -> view.hide()); }
|
AbstractPopoverImpl implements HasCellEditorControls.Editor<B> { @Override public void hide() { binding.ifPresent(b -> view.hide()); } }
|
AbstractPopoverImpl implements HasCellEditorControls.Editor<B> { @Override public void hide() { binding.ifPresent(b -> view.hide()); } protected AbstractPopoverImpl(); protected AbstractPopoverImpl(final V view); }
|
AbstractPopoverImpl implements HasCellEditorControls.Editor<B> { @Override public void hide() { binding.ifPresent(b -> view.hide()); } protected AbstractPopoverImpl(); protected AbstractPopoverImpl(final V view); @Override HTMLElement getElement(); @Override void bind(final B bound,
final int uiRowIndex,
final int uiColumnIndex); @Override void setOnClosedByKeyboardCallback(final Consumer<CanBeClosedByKeyboard> callback); @Override void show(); @Override void hide(); }
|
AbstractPopoverImpl implements HasCellEditorControls.Editor<B> { @Override public void hide() { binding.ifPresent(b -> view.hide()); } protected AbstractPopoverImpl(); protected AbstractPopoverImpl(final V view); @Override HTMLElement getElement(); @Override void bind(final B bound,
final int uiRowIndex,
final int uiColumnIndex); @Override void setOnClosedByKeyboardCallback(final Consumer<CanBeClosedByKeyboard> callback); @Override void show(); @Override void hide(); }
|
@Test public void testAppend() { final Object targetNodeDefinition = mock(Object.class); testedShortcut = new AbstractAppendNodeShortcutMock(targetNodeDefinition); selectedNodeId = "selected"; targetDefinitionNodeId = "target"; connectorDefinitionId = "connector"; definitionSetId = "definition"; when(canvasHandler.getGraphIndex()).thenReturn(graphIndex); when(canvasHandler.getDiagram()).thenReturn(diagram); when(diagram.getGraph()).thenReturn(graph); when(diagram.getMetadata()).thenReturn(metadata); when(metadata.getDefinitionSetId()).thenReturn(definitionSetId); final Element selectedElement = mock(Element.class); when(graphIndex.get(selectedNodeId)).thenReturn(selectedElement); final Node selectedNode = mock(Node.class); when(selectedElement.asNode()).thenReturn(selectedNode); when(toolboxDomainLookups.get(definitionSetId)).thenReturn(commonDomainLookups); final Set<String> connectorDefinitionIds = Collections.singleton(connectorDefinitionId); when(commonDomainLookups.lookupTargetConnectors(selectedNode)).thenReturn(connectorDefinitionIds); final Set<String> targetNodesDefinitionIds = Collections.singleton(targetDefinitionNodeId); when(commonDomainLookups.lookupTargetNodes(graph, selectedNode, connectorDefinitionId)).thenReturn(targetNodesDefinitionIds); when(definitionsCacheRegistry.getDefinitionById(targetDefinitionNodeId)).thenReturn(targetNodeDefinition); testedShortcut.executeAction(canvasHandler, selectedNodeId); verify(generalCreateNodeAction).executeAction(canvasHandler, selectedNodeId, targetDefinitionNodeId, connectorDefinitionId); reset(definitionsCacheRegistry); reset(generalCreateNodeAction); when(definitionsCacheRegistry.getDefinitionById(targetDefinitionNodeId)).thenReturn(new Object()); testedShortcut.executeAction(canvasHandler, selectedNodeId); verify(generalCreateNodeAction, never()).executeAction(any(), any(), any(), any()); }
|
@Override public void executeAction(final AbstractCanvasHandler canvasHandler, final String selectedNodeId) { final Node sourceNode = CanvasLayoutUtils.getElement(canvasHandler, selectedNodeId).asNode(); final String definitionSetId = canvasHandler.getDiagram().getMetadata().getDefinitionSetId(); final CommonDomainLookups commonDomainLookups = toolboxDomainLookups.get(definitionSetId); final Set<String> connectorDefinitionIds = commonDomainLookups.lookupTargetConnectors(sourceNode); for (final String connectorDefinitionId : connectorDefinitionIds) { final Set<String> targetNodesDefinitionIds = commonDomainLookups.lookupTargetNodes(canvasHandler.getDiagram().getGraph(), sourceNode, connectorDefinitionId); for (final String targetNodeDefinitionId : targetNodesDefinitionIds) { final Object definition = definitionsCacheRegistry.getDefinitionById(targetNodeDefinitionId); if (canAppendNodeOfDefinition(definition)) { generalCreateNodeAction.executeAction(canvasHandler, selectedNodeId, targetNodeDefinitionId, connectorDefinitionId); break; } } } }
|
AbstractAppendNodeShortcut implements KeyboardShortcut<AbstractCanvasHandler> { @Override public void executeAction(final AbstractCanvasHandler canvasHandler, final String selectedNodeId) { final Node sourceNode = CanvasLayoutUtils.getElement(canvasHandler, selectedNodeId).asNode(); final String definitionSetId = canvasHandler.getDiagram().getMetadata().getDefinitionSetId(); final CommonDomainLookups commonDomainLookups = toolboxDomainLookups.get(definitionSetId); final Set<String> connectorDefinitionIds = commonDomainLookups.lookupTargetConnectors(sourceNode); for (final String connectorDefinitionId : connectorDefinitionIds) { final Set<String> targetNodesDefinitionIds = commonDomainLookups.lookupTargetNodes(canvasHandler.getDiagram().getGraph(), sourceNode, connectorDefinitionId); for (final String targetNodeDefinitionId : targetNodesDefinitionIds) { final Object definition = definitionsCacheRegistry.getDefinitionById(targetNodeDefinitionId); if (canAppendNodeOfDefinition(definition)) { generalCreateNodeAction.executeAction(canvasHandler, selectedNodeId, targetNodeDefinitionId, connectorDefinitionId); break; } } } } }
|
AbstractAppendNodeShortcut implements KeyboardShortcut<AbstractCanvasHandler> { @Override public void executeAction(final AbstractCanvasHandler canvasHandler, final String selectedNodeId) { final Node sourceNode = CanvasLayoutUtils.getElement(canvasHandler, selectedNodeId).asNode(); final String definitionSetId = canvasHandler.getDiagram().getMetadata().getDefinitionSetId(); final CommonDomainLookups commonDomainLookups = toolboxDomainLookups.get(definitionSetId); final Set<String> connectorDefinitionIds = commonDomainLookups.lookupTargetConnectors(sourceNode); for (final String connectorDefinitionId : connectorDefinitionIds) { final Set<String> targetNodesDefinitionIds = commonDomainLookups.lookupTargetNodes(canvasHandler.getDiagram().getGraph(), sourceNode, connectorDefinitionId); for (final String targetNodeDefinitionId : targetNodesDefinitionIds) { final Object definition = definitionsCacheRegistry.getDefinitionById(targetNodeDefinitionId); if (canAppendNodeOfDefinition(definition)) { generalCreateNodeAction.executeAction(canvasHandler, selectedNodeId, targetNodeDefinitionId, connectorDefinitionId); break; } } } } AbstractAppendNodeShortcut(final ToolboxDomainLookups toolboxDomainLookups,
final DefinitionsCacheRegistry definitionsCacheRegistry,
final GeneralCreateNodeAction generalCreateNodeAction); }
|
AbstractAppendNodeShortcut implements KeyboardShortcut<AbstractCanvasHandler> { @Override public void executeAction(final AbstractCanvasHandler canvasHandler, final String selectedNodeId) { final Node sourceNode = CanvasLayoutUtils.getElement(canvasHandler, selectedNodeId).asNode(); final String definitionSetId = canvasHandler.getDiagram().getMetadata().getDefinitionSetId(); final CommonDomainLookups commonDomainLookups = toolboxDomainLookups.get(definitionSetId); final Set<String> connectorDefinitionIds = commonDomainLookups.lookupTargetConnectors(sourceNode); for (final String connectorDefinitionId : connectorDefinitionIds) { final Set<String> targetNodesDefinitionIds = commonDomainLookups.lookupTargetNodes(canvasHandler.getDiagram().getGraph(), sourceNode, connectorDefinitionId); for (final String targetNodeDefinitionId : targetNodesDefinitionIds) { final Object definition = definitionsCacheRegistry.getDefinitionById(targetNodeDefinitionId); if (canAppendNodeOfDefinition(definition)) { generalCreateNodeAction.executeAction(canvasHandler, selectedNodeId, targetNodeDefinitionId, connectorDefinitionId); break; } } } } AbstractAppendNodeShortcut(final ToolboxDomainLookups toolboxDomainLookups,
final DefinitionsCacheRegistry definitionsCacheRegistry,
final GeneralCreateNodeAction generalCreateNodeAction); @Override void executeAction(final AbstractCanvasHandler canvasHandler,
final String selectedNodeId); abstract boolean canAppendNodeOfDefinition(final Object definition); }
|
AbstractAppendNodeShortcut implements KeyboardShortcut<AbstractCanvasHandler> { @Override public void executeAction(final AbstractCanvasHandler canvasHandler, final String selectedNodeId) { final Node sourceNode = CanvasLayoutUtils.getElement(canvasHandler, selectedNodeId).asNode(); final String definitionSetId = canvasHandler.getDiagram().getMetadata().getDefinitionSetId(); final CommonDomainLookups commonDomainLookups = toolboxDomainLookups.get(definitionSetId); final Set<String> connectorDefinitionIds = commonDomainLookups.lookupTargetConnectors(sourceNode); for (final String connectorDefinitionId : connectorDefinitionIds) { final Set<String> targetNodesDefinitionIds = commonDomainLookups.lookupTargetNodes(canvasHandler.getDiagram().getGraph(), sourceNode, connectorDefinitionId); for (final String targetNodeDefinitionId : targetNodesDefinitionIds) { final Object definition = definitionsCacheRegistry.getDefinitionById(targetNodeDefinitionId); if (canAppendNodeOfDefinition(definition)) { generalCreateNodeAction.executeAction(canvasHandler, selectedNodeId, targetNodeDefinitionId, connectorDefinitionId); break; } } } } AbstractAppendNodeShortcut(final ToolboxDomainLookups toolboxDomainLookups,
final DefinitionsCacheRegistry definitionsCacheRegistry,
final GeneralCreateNodeAction generalCreateNodeAction); @Override void executeAction(final AbstractCanvasHandler canvasHandler,
final String selectedNodeId); abstract boolean canAppendNodeOfDefinition(final Object definition); }
|
@Test public void testSetKeyEventHandlerEnabled() { tested.setKeyEventHandlerEnabled(true); verify(keyEventHandler, times(1)).setEnabled(eq(true)); }
|
public void setKeyEventHandlerEnabled(final boolean enabled) { this.keyEventHandler.setEnabled(enabled); }
|
KeyboardControlImpl extends AbstractCanvasControl<AbstractCanvas> implements KeyboardControl<AbstractCanvas, ClientSession> { public void setKeyEventHandlerEnabled(final boolean enabled) { this.keyEventHandler.setEnabled(enabled); } }
|
KeyboardControlImpl extends AbstractCanvasControl<AbstractCanvas> implements KeyboardControl<AbstractCanvas, ClientSession> { public void setKeyEventHandlerEnabled(final boolean enabled) { this.keyEventHandler.setEnabled(enabled); } @Inject KeyboardControlImpl(final SessionManager clientSessionManager,
final KeyEventHandler keyEventHandler); }
|
KeyboardControlImpl extends AbstractCanvasControl<AbstractCanvas> implements KeyboardControl<AbstractCanvas, ClientSession> { public void setKeyEventHandlerEnabled(final boolean enabled) { this.keyEventHandler.setEnabled(enabled); } @Inject KeyboardControlImpl(final SessionManager clientSessionManager,
final KeyEventHandler keyEventHandler); @Override KeyboardControl<AbstractCanvas, ClientSession> addKeyShortcutCallback(final KeyShortcutCallback shortcutCallback); void setKeyEventHandlerEnabled(final boolean enabled); @Override void bind(final ClientSession session); }
|
KeyboardControlImpl extends AbstractCanvasControl<AbstractCanvas> implements KeyboardControl<AbstractCanvas, ClientSession> { public void setKeyEventHandlerEnabled(final boolean enabled) { this.keyEventHandler.setEnabled(enabled); } @Inject KeyboardControlImpl(final SessionManager clientSessionManager,
final KeyEventHandler keyEventHandler); @Override KeyboardControl<AbstractCanvas, ClientSession> addKeyShortcutCallback(final KeyShortcutCallback shortcutCallback); void setKeyEventHandlerEnabled(final boolean enabled); @Override void bind(final ClientSession session); }
|
@Test public void testOnKeyUp() { tested.onKeyUpEvent(new KeyUpEvent(KeyboardEvent.Key.ALT)); verify(shortcutCallback, times(1)).onKeyUp(eq(KeyboardEvent.Key.ALT)); }
|
private void onKeyUp(final KeyboardEvent.Key key) { if (!enabled) { return; } keys.remove(key); shortcutCallbacks.stream().forEach(s -> s.onKeyUp(key)); }
|
KeyEventHandlerImpl implements KeyEventHandler { private void onKeyUp(final KeyboardEvent.Key key) { if (!enabled) { return; } keys.remove(key); shortcutCallbacks.stream().forEach(s -> s.onKeyUp(key)); } }
|
KeyEventHandlerImpl implements KeyEventHandler { private void onKeyUp(final KeyboardEvent.Key key) { if (!enabled) { return; } keys.remove(key); shortcutCallbacks.stream().forEach(s -> s.onKeyUp(key)); } }
|
KeyEventHandlerImpl implements KeyEventHandler { private void onKeyUp(final KeyboardEvent.Key key) { if (!enabled) { return; } keys.remove(key); shortcutCallbacks.stream().forEach(s -> s.onKeyUp(key)); } @Override KeyEventHandler addKeyShortcutCallback(final KeyboardControl.KeyShortcutCallback shortcutCallback); @Override KeyEventHandler setTimerDelay(final int millis); @Override @PreDestroy void clear(); @Override void setEnabled(final boolean enabled); void onKeyUpEvent(final @Observes KeyUpEvent event); }
|
KeyEventHandlerImpl implements KeyEventHandler { private void onKeyUp(final KeyboardEvent.Key key) { if (!enabled) { return; } keys.remove(key); shortcutCallbacks.stream().forEach(s -> s.onKeyUp(key)); } @Override KeyEventHandler addKeyShortcutCallback(final KeyboardControl.KeyShortcutCallback shortcutCallback); @Override KeyEventHandler setTimerDelay(final int millis); @Override @PreDestroy void clear(); @Override void setEnabled(final boolean enabled); void onKeyUpEvent(final @Observes KeyUpEvent event); }
|
@Test public void testAllow() { tested = new AddCanvasControlPointCommand(edge, newControlPoint, 0); CommandResult<CanvasViolation> result = tested.allow(canvasHandler); assertFalse(CommandUtils.isError(result)); tested = new AddCanvasControlPointCommand(edge, newControlPoint, 1); result = tested.allow(canvasHandler); assertFalse(CommandUtils.isError(result)); tested = new AddCanvasControlPointCommand(edge, newControlPoint, 2); result = tested.allow(canvasHandler); assertFalse(CommandUtils.isError(result)); assertFalse(CommandUtils.isError(result)); tested = new AddCanvasControlPointCommand(edge, newControlPoint, 3); result = tested.allow(canvasHandler); assertFalse(CommandUtils.isError(result)); }
|
@Override public CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context) { checkAddControlPoint(getViewControlPoints(context, candidate), controlPoint, index); return CanvasCommandResultBuilder.SUCCESS; }
|
AddCanvasControlPointCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context) { checkAddControlPoint(getViewControlPoints(context, candidate), controlPoint, index); return CanvasCommandResultBuilder.SUCCESS; } }
|
AddCanvasControlPointCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context) { checkAddControlPoint(getViewControlPoints(context, candidate), controlPoint, index); return CanvasCommandResultBuilder.SUCCESS; } AddCanvasControlPointCommand(final Edge candidate,
final ControlPoint controlPoint,
final int index); }
|
AddCanvasControlPointCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context) { checkAddControlPoint(getViewControlPoints(context, candidate), controlPoint, index); return CanvasCommandResultBuilder.SUCCESS; } AddCanvasControlPointCommand(final Edge candidate,
final ControlPoint controlPoint,
final int index); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(AbstractCanvasHandler context); ControlPoint getControlPoint(); int getIndex(); static ControlPoint[] getControlPoints(final Edge edge); static void consumeControlPoints(final AbstractCanvasHandler context,
final Edge edge,
final Consumer<HasManageableControlPoints> consumer); static HasManageableControlPoints<?> getManageableControlPoints(final AbstractCanvasHandler context,
final Edge candidate); static ControlPoint[] getViewControlPoints(final AbstractCanvasHandler context,
final Edge candidate); @Override String toString(); }
|
AddCanvasControlPointCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context) { checkAddControlPoint(getViewControlPoints(context, candidate), controlPoint, index); return CanvasCommandResultBuilder.SUCCESS; } AddCanvasControlPointCommand(final Edge candidate,
final ControlPoint controlPoint,
final int index); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(AbstractCanvasHandler context); ControlPoint getControlPoint(); int getIndex(); static ControlPoint[] getControlPoints(final Edge edge); static void consumeControlPoints(final AbstractCanvasHandler context,
final Edge edge,
final Consumer<HasManageableControlPoints> consumer); static HasManageableControlPoints<?> getManageableControlPoints(final AbstractCanvasHandler context,
final Edge candidate); static ControlPoint[] getViewControlPoints(final AbstractCanvasHandler context,
final Edge candidate); @Override String toString(); }
|
@Test(expected = IllegalArgumentException.class) public void testInvalidCPIndex() { tested = new AddCanvasControlPointCommand(edge, newControlPoint, 4); tested.allow(canvasHandler); }
|
@Override public CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context) { checkAddControlPoint(getViewControlPoints(context, candidate), controlPoint, index); return CanvasCommandResultBuilder.SUCCESS; }
|
AddCanvasControlPointCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context) { checkAddControlPoint(getViewControlPoints(context, candidate), controlPoint, index); return CanvasCommandResultBuilder.SUCCESS; } }
|
AddCanvasControlPointCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context) { checkAddControlPoint(getViewControlPoints(context, candidate), controlPoint, index); return CanvasCommandResultBuilder.SUCCESS; } AddCanvasControlPointCommand(final Edge candidate,
final ControlPoint controlPoint,
final int index); }
|
AddCanvasControlPointCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context) { checkAddControlPoint(getViewControlPoints(context, candidate), controlPoint, index); return CanvasCommandResultBuilder.SUCCESS; } AddCanvasControlPointCommand(final Edge candidate,
final ControlPoint controlPoint,
final int index); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(AbstractCanvasHandler context); ControlPoint getControlPoint(); int getIndex(); static ControlPoint[] getControlPoints(final Edge edge); static void consumeControlPoints(final AbstractCanvasHandler context,
final Edge edge,
final Consumer<HasManageableControlPoints> consumer); static HasManageableControlPoints<?> getManageableControlPoints(final AbstractCanvasHandler context,
final Edge candidate); static ControlPoint[] getViewControlPoints(final AbstractCanvasHandler context,
final Edge candidate); @Override String toString(); }
|
AddCanvasControlPointCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context) { checkAddControlPoint(getViewControlPoints(context, candidate), controlPoint, index); return CanvasCommandResultBuilder.SUCCESS; } AddCanvasControlPointCommand(final Edge candidate,
final ControlPoint controlPoint,
final int index); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(AbstractCanvasHandler context); ControlPoint getControlPoint(); int getIndex(); static ControlPoint[] getControlPoints(final Edge edge); static void consumeControlPoints(final AbstractCanvasHandler context,
final Edge edge,
final Consumer<HasManageableControlPoints> consumer); static HasManageableControlPoints<?> getManageableControlPoints(final AbstractCanvasHandler context,
final Edge candidate); static ControlPoint[] getViewControlPoints(final AbstractCanvasHandler context,
final Edge candidate); @Override String toString(); }
|
@Test(expected = IllegalArgumentException.class) public void testInvalidCPIndexDuringExecute() { tested = new AddCanvasControlPointCommand(edge, newControlPoint, 4); tested.execute(canvasHandler); }
|
@Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { allow(context); consumeControlPoints(context, candidate, view -> view.addControlPoint(controlPoint, index)); return buildResult(); }
|
AddCanvasControlPointCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { allow(context); consumeControlPoints(context, candidate, view -> view.addControlPoint(controlPoint, index)); return buildResult(); } }
|
AddCanvasControlPointCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { allow(context); consumeControlPoints(context, candidate, view -> view.addControlPoint(controlPoint, index)); return buildResult(); } AddCanvasControlPointCommand(final Edge candidate,
final ControlPoint controlPoint,
final int index); }
|
AddCanvasControlPointCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { allow(context); consumeControlPoints(context, candidate, view -> view.addControlPoint(controlPoint, index)); return buildResult(); } AddCanvasControlPointCommand(final Edge candidate,
final ControlPoint controlPoint,
final int index); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(AbstractCanvasHandler context); ControlPoint getControlPoint(); int getIndex(); static ControlPoint[] getControlPoints(final Edge edge); static void consumeControlPoints(final AbstractCanvasHandler context,
final Edge edge,
final Consumer<HasManageableControlPoints> consumer); static HasManageableControlPoints<?> getManageableControlPoints(final AbstractCanvasHandler context,
final Edge candidate); static ControlPoint[] getViewControlPoints(final AbstractCanvasHandler context,
final Edge candidate); @Override String toString(); }
|
AddCanvasControlPointCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { allow(context); consumeControlPoints(context, candidate, view -> view.addControlPoint(controlPoint, index)); return buildResult(); } AddCanvasControlPointCommand(final Edge candidate,
final ControlPoint controlPoint,
final int index); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(AbstractCanvasHandler context); ControlPoint getControlPoint(); int getIndex(); static ControlPoint[] getControlPoints(final Edge edge); static void consumeControlPoints(final AbstractCanvasHandler context,
final Edge edge,
final Consumer<HasManageableControlPoints> consumer); static HasManageableControlPoints<?> getManageableControlPoints(final AbstractCanvasHandler context,
final Edge candidate); static ControlPoint[] getViewControlPoints(final AbstractCanvasHandler context,
final Edge candidate); @Override String toString(); }
|
@Test(expected = IllegalArgumentException.class) public void testInvalidCP() { tested = new AddCanvasControlPointCommand(edge, newControlPoint, 2); newControlPoint.setLocation(null); tested.allow(canvasHandler); }
|
@Override public CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context) { checkAddControlPoint(getViewControlPoints(context, candidate), controlPoint, index); return CanvasCommandResultBuilder.SUCCESS; }
|
AddCanvasControlPointCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context) { checkAddControlPoint(getViewControlPoints(context, candidate), controlPoint, index); return CanvasCommandResultBuilder.SUCCESS; } }
|
AddCanvasControlPointCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context) { checkAddControlPoint(getViewControlPoints(context, candidate), controlPoint, index); return CanvasCommandResultBuilder.SUCCESS; } AddCanvasControlPointCommand(final Edge candidate,
final ControlPoint controlPoint,
final int index); }
|
AddCanvasControlPointCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context) { checkAddControlPoint(getViewControlPoints(context, candidate), controlPoint, index); return CanvasCommandResultBuilder.SUCCESS; } AddCanvasControlPointCommand(final Edge candidate,
final ControlPoint controlPoint,
final int index); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(AbstractCanvasHandler context); ControlPoint getControlPoint(); int getIndex(); static ControlPoint[] getControlPoints(final Edge edge); static void consumeControlPoints(final AbstractCanvasHandler context,
final Edge edge,
final Consumer<HasManageableControlPoints> consumer); static HasManageableControlPoints<?> getManageableControlPoints(final AbstractCanvasHandler context,
final Edge candidate); static ControlPoint[] getViewControlPoints(final AbstractCanvasHandler context,
final Edge candidate); @Override String toString(); }
|
AddCanvasControlPointCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context) { checkAddControlPoint(getViewControlPoints(context, candidate), controlPoint, index); return CanvasCommandResultBuilder.SUCCESS; } AddCanvasControlPointCommand(final Edge candidate,
final ControlPoint controlPoint,
final int index); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(AbstractCanvasHandler context); ControlPoint getControlPoint(); int getIndex(); static ControlPoint[] getControlPoints(final Edge edge); static void consumeControlPoints(final AbstractCanvasHandler context,
final Edge edge,
final Consumer<HasManageableControlPoints> consumer); static HasManageableControlPoints<?> getManageableControlPoints(final AbstractCanvasHandler context,
final Edge candidate); static ControlPoint[] getViewControlPoints(final AbstractCanvasHandler context,
final Edge candidate); @Override String toString(); }
|
@Test(expected = IllegalArgumentException.class) public void testInvalidCPDuringExecute() { tested = new AddCanvasControlPointCommand(edge, newControlPoint, 2); newControlPoint.setLocation(null); tested.execute(canvasHandler); }
|
@Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { allow(context); consumeControlPoints(context, candidate, view -> view.addControlPoint(controlPoint, index)); return buildResult(); }
|
AddCanvasControlPointCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { allow(context); consumeControlPoints(context, candidate, view -> view.addControlPoint(controlPoint, index)); return buildResult(); } }
|
AddCanvasControlPointCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { allow(context); consumeControlPoints(context, candidate, view -> view.addControlPoint(controlPoint, index)); return buildResult(); } AddCanvasControlPointCommand(final Edge candidate,
final ControlPoint controlPoint,
final int index); }
|
AddCanvasControlPointCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { allow(context); consumeControlPoints(context, candidate, view -> view.addControlPoint(controlPoint, index)); return buildResult(); } AddCanvasControlPointCommand(final Edge candidate,
final ControlPoint controlPoint,
final int index); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(AbstractCanvasHandler context); ControlPoint getControlPoint(); int getIndex(); static ControlPoint[] getControlPoints(final Edge edge); static void consumeControlPoints(final AbstractCanvasHandler context,
final Edge edge,
final Consumer<HasManageableControlPoints> consumer); static HasManageableControlPoints<?> getManageableControlPoints(final AbstractCanvasHandler context,
final Edge candidate); static ControlPoint[] getViewControlPoints(final AbstractCanvasHandler context,
final Edge candidate); @Override String toString(); }
|
AddCanvasControlPointCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { allow(context); consumeControlPoints(context, candidate, view -> view.addControlPoint(controlPoint, index)); return buildResult(); } AddCanvasControlPointCommand(final Edge candidate,
final ControlPoint controlPoint,
final int index); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(AbstractCanvasHandler context); ControlPoint getControlPoint(); int getIndex(); static ControlPoint[] getControlPoints(final Edge edge); static void consumeControlPoints(final AbstractCanvasHandler context,
final Edge edge,
final Consumer<HasManageableControlPoints> consumer); static HasManageableControlPoints<?> getManageableControlPoints(final AbstractCanvasHandler context,
final Edge candidate); static ControlPoint[] getViewControlPoints(final AbstractCanvasHandler context,
final Edge candidate); @Override String toString(); }
|
@Test public void execute() { checkExecution(true); }
|
@Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { allow(context); consumeControlPoints(context, candidate, view -> view.addControlPoint(controlPoint, index)); return buildResult(); }
|
AddCanvasControlPointCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { allow(context); consumeControlPoints(context, candidate, view -> view.addControlPoint(controlPoint, index)); return buildResult(); } }
|
AddCanvasControlPointCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { allow(context); consumeControlPoints(context, candidate, view -> view.addControlPoint(controlPoint, index)); return buildResult(); } AddCanvasControlPointCommand(final Edge candidate,
final ControlPoint controlPoint,
final int index); }
|
AddCanvasControlPointCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { allow(context); consumeControlPoints(context, candidate, view -> view.addControlPoint(controlPoint, index)); return buildResult(); } AddCanvasControlPointCommand(final Edge candidate,
final ControlPoint controlPoint,
final int index); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(AbstractCanvasHandler context); ControlPoint getControlPoint(); int getIndex(); static ControlPoint[] getControlPoints(final Edge edge); static void consumeControlPoints(final AbstractCanvasHandler context,
final Edge edge,
final Consumer<HasManageableControlPoints> consumer); static HasManageableControlPoints<?> getManageableControlPoints(final AbstractCanvasHandler context,
final Edge candidate); static ControlPoint[] getViewControlPoints(final AbstractCanvasHandler context,
final Edge candidate); @Override String toString(); }
|
AddCanvasControlPointCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { allow(context); consumeControlPoints(context, candidate, view -> view.addControlPoint(controlPoint, index)); return buildResult(); } AddCanvasControlPointCommand(final Edge candidate,
final ControlPoint controlPoint,
final int index); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(AbstractCanvasHandler context); ControlPoint getControlPoint(); int getIndex(); static ControlPoint[] getControlPoints(final Edge edge); static void consumeControlPoints(final AbstractCanvasHandler context,
final Edge edge,
final Consumer<HasManageableControlPoints> consumer); static HasManageableControlPoints<?> getManageableControlPoints(final AbstractCanvasHandler context,
final Edge candidate); static ControlPoint[] getViewControlPoints(final AbstractCanvasHandler context,
final Edge candidate); @Override String toString(); }
|
@Test @SuppressWarnings("unchecked") public void testExecute() { final CommandResult<CanvasViolation> result = tested.execute(canvasHandler); assertNotEquals(CommandResult.Type.ERROR, result.getType()); verify(edgeShape, times(1)).applyConnections(eq(edge), eq(sourceShapeView), eq(targetShapeView), any(MutationContext.class)); verify(canvasHandler, times(1)).notifyCanvasElementUpdated(eq(source)); verify(canvasHandler, times(1)).notifyCanvasElementUpdated(eq(target)); }
|
@Override @SuppressWarnings("unchecked") public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { final Node source = edge.getSourceNode(); final Node target = edge.getTargetNode(); ShapeUtils.applyConnections(edge, context, MutationContext.STATIC); if (null != source) { context.notifyCanvasElementUpdated(source); } if (null != target) { context.notifyCanvasElementUpdated(target); } return buildResult(); }
|
SetCanvasConnectionCommand extends AbstractCanvasCommand { @Override @SuppressWarnings("unchecked") public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { final Node source = edge.getSourceNode(); final Node target = edge.getTargetNode(); ShapeUtils.applyConnections(edge, context, MutationContext.STATIC); if (null != source) { context.notifyCanvasElementUpdated(source); } if (null != target) { context.notifyCanvasElementUpdated(target); } return buildResult(); } }
|
SetCanvasConnectionCommand extends AbstractCanvasCommand { @Override @SuppressWarnings("unchecked") public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { final Node source = edge.getSourceNode(); final Node target = edge.getTargetNode(); ShapeUtils.applyConnections(edge, context, MutationContext.STATIC); if (null != source) { context.notifyCanvasElementUpdated(source); } if (null != target) { context.notifyCanvasElementUpdated(target); } return buildResult(); } SetCanvasConnectionCommand(final Edge<? extends ViewConnector<?>, Node> edge); }
|
SetCanvasConnectionCommand extends AbstractCanvasCommand { @Override @SuppressWarnings("unchecked") public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { final Node source = edge.getSourceNode(); final Node target = edge.getTargetNode(); ShapeUtils.applyConnections(edge, context, MutationContext.STATIC); if (null != source) { context.notifyCanvasElementUpdated(source); } if (null != target) { context.notifyCanvasElementUpdated(target); } return buildResult(); } SetCanvasConnectionCommand(final Edge<? extends ViewConnector<?>, Node> edge); @Override @SuppressWarnings("unchecked") CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); Edge<? extends View<?>, Node> getEdge(); @Override String toString(); }
|
SetCanvasConnectionCommand extends AbstractCanvasCommand { @Override @SuppressWarnings("unchecked") public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { final Node source = edge.getSourceNode(); final Node target = edge.getTargetNode(); ShapeUtils.applyConnections(edge, context, MutationContext.STATIC); if (null != source) { context.notifyCanvasElementUpdated(source); } if (null != target) { context.notifyCanvasElementUpdated(target); } return buildResult(); } SetCanvasConnectionCommand(final Edge<? extends ViewConnector<?>, Node> edge); @Override @SuppressWarnings("unchecked") CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); Edge<? extends View<?>, Node> getEdge(); @Override String toString(); }
|
@Test public void testCreateOptions() { final PopoverOptions options = mock(PopoverOptions.class); doReturn(options).when(view).createPopoverOptionsInstance(); view.createOptions(); verify(options).setAnimation(false); verify(options).setHtml(true); verify(options).setPlacement(AbstractPopoverViewImpl.PLACEMENT); }
|
PopoverOptions createOptions() { final PopoverOptions options = createPopoverOptionsInstance(); options.setContent((element) -> popoverContentElement); options.setAnimation(false); options.setHtml(true); options.setPlacement(PLACEMENT); return options; }
|
AbstractPopoverViewImpl implements PopoverView { PopoverOptions createOptions() { final PopoverOptions options = createPopoverOptionsInstance(); options.setContent((element) -> popoverContentElement); options.setAnimation(false); options.setHtml(true); options.setPlacement(PLACEMENT); return options; } }
|
AbstractPopoverViewImpl implements PopoverView { PopoverOptions createOptions() { final PopoverOptions options = createPopoverOptionsInstance(); options.setContent((element) -> popoverContentElement); options.setAnimation(false); options.setHtml(true); options.setPlacement(PLACEMENT); return options; } protected AbstractPopoverViewImpl(); AbstractPopoverViewImpl(final Div popoverElement,
final Div popoverContentElement,
final JQueryProducer.JQuery<Popover> jQueryPopover); }
|
AbstractPopoverViewImpl implements PopoverView { PopoverOptions createOptions() { final PopoverOptions options = createPopoverOptionsInstance(); options.setContent((element) -> popoverContentElement); options.setAnimation(false); options.setHtml(true); options.setPlacement(PLACEMENT); return options; } protected AbstractPopoverViewImpl(); AbstractPopoverViewImpl(final Div popoverElement,
final Div popoverContentElement,
final JQueryProducer.JQuery<Popover> jQueryPopover); @Override void setOnClosedByKeyboardCallback(final Consumer<CanBeClosedByKeyboard> callback); @Override void show(final Optional<String> popoverTitle); @Override void hide(); boolean isVisible(); void keyDownEventListener(final Object event); boolean isEscapeKeyPressed(final KeyboardEvent event); boolean isEnterKeyPressed(final KeyboardEvent event); void onClosedByKeyboard(); Optional<Consumer<CanBeClosedByKeyboard>> getClosedByKeyboardCallback(); }
|
AbstractPopoverViewImpl implements PopoverView { PopoverOptions createOptions() { final PopoverOptions options = createPopoverOptionsInstance(); options.setContent((element) -> popoverContentElement); options.setAnimation(false); options.setHtml(true); options.setPlacement(PLACEMENT); return options; } protected AbstractPopoverViewImpl(); AbstractPopoverViewImpl(final Div popoverElement,
final Div popoverContentElement,
final JQueryProducer.JQuery<Popover> jQueryPopover); @Override void setOnClosedByKeyboardCallback(final Consumer<CanBeClosedByKeyboard> callback); @Override void show(final Optional<String> popoverTitle); @Override void hide(); boolean isVisible(); void keyDownEventListener(final Object event); boolean isEscapeKeyPressed(final KeyboardEvent event); boolean isEnterKeyPressed(final KeyboardEvent event); void onClosedByKeyboard(); Optional<Consumer<CanBeClosedByKeyboard>> getClosedByKeyboardCallback(); }
|
@Test @SuppressWarnings("unchecked") public void testExecuteAndUpdateMagnetLocations() { final MagnetConnection sourceConnection = new MagnetConnection.Builder() .magnet(0) .build(); final MagnetConnection targetConnection = new MagnetConnection.Builder() .magnet(0) .build(); when(edgeContent.getSourceConnection()).thenReturn(Optional.of(sourceConnection)); when(edgeContent.getTargetConnection()).thenReturn(Optional.of(targetConnection)); final CommandResult<CanvasViolation> result = tested.execute(canvasHandler); assertNotEquals(CommandResult.Type.ERROR, result.getType()); verify(edgeShape, times(1)).applyConnections(eq(edge), eq(sourceShapeView), eq(targetShapeView), any(MutationContext.class)); verify(canvasHandler, times(1)).notifyCanvasElementUpdated(eq(source)); verify(canvasHandler, times(1)).notifyCanvasElementUpdated(eq(target)); assertEquals(5d, sourceConnection.getLocation().getX(), 0d); assertEquals(5d, sourceConnection.getLocation().getY(), 0d); assertEquals(10d, targetConnection.getLocation().getX(), 0d); assertEquals(10d, targetConnection.getLocation().getY(), 0d); }
|
@Override @SuppressWarnings("unchecked") public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { final Node source = edge.getSourceNode(); final Node target = edge.getTargetNode(); ShapeUtils.applyConnections(edge, context, MutationContext.STATIC); if (null != source) { context.notifyCanvasElementUpdated(source); } if (null != target) { context.notifyCanvasElementUpdated(target); } return buildResult(); }
|
SetCanvasConnectionCommand extends AbstractCanvasCommand { @Override @SuppressWarnings("unchecked") public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { final Node source = edge.getSourceNode(); final Node target = edge.getTargetNode(); ShapeUtils.applyConnections(edge, context, MutationContext.STATIC); if (null != source) { context.notifyCanvasElementUpdated(source); } if (null != target) { context.notifyCanvasElementUpdated(target); } return buildResult(); } }
|
SetCanvasConnectionCommand extends AbstractCanvasCommand { @Override @SuppressWarnings("unchecked") public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { final Node source = edge.getSourceNode(); final Node target = edge.getTargetNode(); ShapeUtils.applyConnections(edge, context, MutationContext.STATIC); if (null != source) { context.notifyCanvasElementUpdated(source); } if (null != target) { context.notifyCanvasElementUpdated(target); } return buildResult(); } SetCanvasConnectionCommand(final Edge<? extends ViewConnector<?>, Node> edge); }
|
SetCanvasConnectionCommand extends AbstractCanvasCommand { @Override @SuppressWarnings("unchecked") public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { final Node source = edge.getSourceNode(); final Node target = edge.getTargetNode(); ShapeUtils.applyConnections(edge, context, MutationContext.STATIC); if (null != source) { context.notifyCanvasElementUpdated(source); } if (null != target) { context.notifyCanvasElementUpdated(target); } return buildResult(); } SetCanvasConnectionCommand(final Edge<? extends ViewConnector<?>, Node> edge); @Override @SuppressWarnings("unchecked") CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); Edge<? extends View<?>, Node> getEdge(); @Override String toString(); }
|
SetCanvasConnectionCommand extends AbstractCanvasCommand { @Override @SuppressWarnings("unchecked") public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { final Node source = edge.getSourceNode(); final Node target = edge.getTargetNode(); ShapeUtils.applyConnections(edge, context, MutationContext.STATIC); if (null != source) { context.notifyCanvasElementUpdated(source); } if (null != target) { context.notifyCanvasElementUpdated(target); } return buildResult(); } SetCanvasConnectionCommand(final Edge<? extends ViewConnector<?>, Node> edge); @Override @SuppressWarnings("unchecked") CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); Edge<? extends View<?>, Node> getEdge(); @Override String toString(); }
|
@Test public void testNewGraphCommand() { final Command<GraphCommandExecutionContext, RuleViolation> command = new UpdateDomainObjectPropertyCommand(domainObject, PROPERTY_ID, VALUE).newGraphCommand(canvasHandler); assertThat(command).isInstanceOf(UpdateDomainObjectPropertyValueCommand.class); }
|
@Override @SuppressWarnings("unchecked") protected Command<GraphCommandExecutionContext, RuleViolation> newGraphCommand(final AbstractCanvasHandler context) { return new UpdateDomainObjectPropertyValueCommand(domainObject, propertyId, value); }
|
UpdateDomainObjectPropertyCommand extends AbstractCanvasGraphCommand { @Override @SuppressWarnings("unchecked") protected Command<GraphCommandExecutionContext, RuleViolation> newGraphCommand(final AbstractCanvasHandler context) { return new UpdateDomainObjectPropertyValueCommand(domainObject, propertyId, value); } }
|
UpdateDomainObjectPropertyCommand extends AbstractCanvasGraphCommand { @Override @SuppressWarnings("unchecked") protected Command<GraphCommandExecutionContext, RuleViolation> newGraphCommand(final AbstractCanvasHandler context) { return new UpdateDomainObjectPropertyValueCommand(domainObject, propertyId, value); } UpdateDomainObjectPropertyCommand(final DomainObject domainObject,
final String propertyId,
final Object value); }
|
UpdateDomainObjectPropertyCommand extends AbstractCanvasGraphCommand { @Override @SuppressWarnings("unchecked") protected Command<GraphCommandExecutionContext, RuleViolation> newGraphCommand(final AbstractCanvasHandler context) { return new UpdateDomainObjectPropertyValueCommand(domainObject, propertyId, value); } UpdateDomainObjectPropertyCommand(final DomainObject domainObject,
final String propertyId,
final Object value); @Override String toString(); }
|
UpdateDomainObjectPropertyCommand extends AbstractCanvasGraphCommand { @Override @SuppressWarnings("unchecked") protected Command<GraphCommandExecutionContext, RuleViolation> newGraphCommand(final AbstractCanvasHandler context) { return new UpdateDomainObjectPropertyValueCommand(domainObject, propertyId, value); } UpdateDomainObjectPropertyCommand(final DomainObject domainObject,
final String propertyId,
final Object value); @Override String toString(); }
|
@Test public void testNewCanvasCommandExecute() { final CanvasCommand<AbstractCanvasHandler> command = new UpdateDomainObjectPropertyCommand(domainObject, PROPERTY_ID, VALUE).newCanvasCommand(canvasHandler); assertThat(command).isInstanceOf(UpdateDomainObjectPropertyCommand.RefreshPropertiesPanelCommand.class); assertThat(command.execute(canvasHandler)).isEqualTo(CanvasCommandResultBuilder.SUCCESS); verify(canvasHandler).notifyCanvasDomainObjectUpdated(eq(domainObject)); }
|
@Override protected AbstractCanvasCommand newCanvasCommand(final AbstractCanvasHandler context) { return new RefreshPropertiesPanelCommand(); }
|
UpdateDomainObjectPropertyCommand extends AbstractCanvasGraphCommand { @Override protected AbstractCanvasCommand newCanvasCommand(final AbstractCanvasHandler context) { return new RefreshPropertiesPanelCommand(); } }
|
UpdateDomainObjectPropertyCommand extends AbstractCanvasGraphCommand { @Override protected AbstractCanvasCommand newCanvasCommand(final AbstractCanvasHandler context) { return new RefreshPropertiesPanelCommand(); } UpdateDomainObjectPropertyCommand(final DomainObject domainObject,
final String propertyId,
final Object value); }
|
UpdateDomainObjectPropertyCommand extends AbstractCanvasGraphCommand { @Override protected AbstractCanvasCommand newCanvasCommand(final AbstractCanvasHandler context) { return new RefreshPropertiesPanelCommand(); } UpdateDomainObjectPropertyCommand(final DomainObject domainObject,
final String propertyId,
final Object value); @Override String toString(); }
|
UpdateDomainObjectPropertyCommand extends AbstractCanvasGraphCommand { @Override protected AbstractCanvasCommand newCanvasCommand(final AbstractCanvasHandler context) { return new RefreshPropertiesPanelCommand(); } UpdateDomainObjectPropertyCommand(final DomainObject domainObject,
final String propertyId,
final Object value); @Override String toString(); }
|
@Test public void testNewCanvasCommandUndo() { final CanvasCommand<AbstractCanvasHandler> command = new UpdateDomainObjectPropertyCommand(domainObject, PROPERTY_ID, VALUE).newCanvasCommand(canvasHandler); assertThat(command).isInstanceOf(UpdateDomainObjectPropertyCommand.RefreshPropertiesPanelCommand.class); assertThat(command.undo(canvasHandler)).isEqualTo(CanvasCommandResultBuilder.SUCCESS); verify(canvasHandler).notifyCanvasDomainObjectUpdated(eq(domainObject)); }
|
@Override protected AbstractCanvasCommand newCanvasCommand(final AbstractCanvasHandler context) { return new RefreshPropertiesPanelCommand(); }
|
UpdateDomainObjectPropertyCommand extends AbstractCanvasGraphCommand { @Override protected AbstractCanvasCommand newCanvasCommand(final AbstractCanvasHandler context) { return new RefreshPropertiesPanelCommand(); } }
|
UpdateDomainObjectPropertyCommand extends AbstractCanvasGraphCommand { @Override protected AbstractCanvasCommand newCanvasCommand(final AbstractCanvasHandler context) { return new RefreshPropertiesPanelCommand(); } UpdateDomainObjectPropertyCommand(final DomainObject domainObject,
final String propertyId,
final Object value); }
|
UpdateDomainObjectPropertyCommand extends AbstractCanvasGraphCommand { @Override protected AbstractCanvasCommand newCanvasCommand(final AbstractCanvasHandler context) { return new RefreshPropertiesPanelCommand(); } UpdateDomainObjectPropertyCommand(final DomainObject domainObject,
final String propertyId,
final Object value); @Override String toString(); }
|
UpdateDomainObjectPropertyCommand extends AbstractCanvasGraphCommand { @Override protected AbstractCanvasCommand newCanvasCommand(final AbstractCanvasHandler context) { return new RefreshPropertiesPanelCommand(); } UpdateDomainObjectPropertyCommand(final DomainObject domainObject,
final String propertyId,
final Object value); @Override String toString(); }
|
@Test @SuppressWarnings("unchecked") public void testExecute() { final CommandResult<CanvasViolation> result = tested.execute(canvasHandler); assertNotEquals(CommandResult.Type.ERROR, result.getType()); verify(canvasHandler, times(1)).register(eq(SHAPE_SET_ID), eq(candidate)); verify(canvasHandler, times(1)).applyElementMutation(eq(candidate), any(MutationContext.class)); verify(canvasHandler, times(1)).notifyCanvasElementUpdated(eq(source)); verify(candidateShape, times(1)).applyConnections(eq(candidate), eq(sourceShapeView), any(ShapeView.class), any(MutationContext.class)); }
|
@Override @SuppressWarnings("unchecked") public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { context.register(shapeSetId, candidate); if (candidate.getContent() instanceof ViewConnector) { final HasManageableControlPoints<?> view = (HasManageableControlPoints<?>) ShapeUtils.getConnectorShape(candidate, context).getShapeView(); final ControlPoint[] controlPoints = ((ViewConnector) candidate.getContent()).getControlPoints(); if (null != controlPoints) { for (int i = 0; i < controlPoints.length; i++) { view.addControlPoint(controlPoints[i], i); } } } applyConnections(candidate, context, MutationContext.STATIC); context.applyElementMutation(candidate, MutationContext.STATIC); final Node source = candidate.getSourceNode(); if (null != source) { context.notifyCanvasElementUpdated(source); } return buildResult(); }
|
AddCanvasConnectorCommand extends AbstractCanvasCommand { @Override @SuppressWarnings("unchecked") public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { context.register(shapeSetId, candidate); if (candidate.getContent() instanceof ViewConnector) { final HasManageableControlPoints<?> view = (HasManageableControlPoints<?>) ShapeUtils.getConnectorShape(candidate, context).getShapeView(); final ControlPoint[] controlPoints = ((ViewConnector) candidate.getContent()).getControlPoints(); if (null != controlPoints) { for (int i = 0; i < controlPoints.length; i++) { view.addControlPoint(controlPoints[i], i); } } } applyConnections(candidate, context, MutationContext.STATIC); context.applyElementMutation(candidate, MutationContext.STATIC); final Node source = candidate.getSourceNode(); if (null != source) { context.notifyCanvasElementUpdated(source); } return buildResult(); } }
|
AddCanvasConnectorCommand extends AbstractCanvasCommand { @Override @SuppressWarnings("unchecked") public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { context.register(shapeSetId, candidate); if (candidate.getContent() instanceof ViewConnector) { final HasManageableControlPoints<?> view = (HasManageableControlPoints<?>) ShapeUtils.getConnectorShape(candidate, context).getShapeView(); final ControlPoint[] controlPoints = ((ViewConnector) candidate.getContent()).getControlPoints(); if (null != controlPoints) { for (int i = 0; i < controlPoints.length; i++) { view.addControlPoint(controlPoints[i], i); } } } applyConnections(candidate, context, MutationContext.STATIC); context.applyElementMutation(candidate, MutationContext.STATIC); final Node source = candidate.getSourceNode(); if (null != source) { context.notifyCanvasElementUpdated(source); } return buildResult(); } AddCanvasConnectorCommand(final Edge candidate,
final String shapeSetId); }
|
AddCanvasConnectorCommand extends AbstractCanvasCommand { @Override @SuppressWarnings("unchecked") public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { context.register(shapeSetId, candidate); if (candidate.getContent() instanceof ViewConnector) { final HasManageableControlPoints<?> view = (HasManageableControlPoints<?>) ShapeUtils.getConnectorShape(candidate, context).getShapeView(); final ControlPoint[] controlPoints = ((ViewConnector) candidate.getContent()).getControlPoints(); if (null != controlPoints) { for (int i = 0; i < controlPoints.length; i++) { view.addControlPoint(controlPoints[i], i); } } } applyConnections(candidate, context, MutationContext.STATIC); context.applyElementMutation(candidate, MutationContext.STATIC); final Node source = candidate.getSourceNode(); if (null != source) { context.notifyCanvasElementUpdated(source); } return buildResult(); } AddCanvasConnectorCommand(final Edge candidate,
final String shapeSetId); @Override @SuppressWarnings("unchecked") CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); Edge getCandidate(); String getShapeSetId(); @Override String toString(); }
|
AddCanvasConnectorCommand extends AbstractCanvasCommand { @Override @SuppressWarnings("unchecked") public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { context.register(shapeSetId, candidate); if (candidate.getContent() instanceof ViewConnector) { final HasManageableControlPoints<?> view = (HasManageableControlPoints<?>) ShapeUtils.getConnectorShape(candidate, context).getShapeView(); final ControlPoint[] controlPoints = ((ViewConnector) candidate.getContent()).getControlPoints(); if (null != controlPoints) { for (int i = 0; i < controlPoints.length; i++) { view.addControlPoint(controlPoints[i], i); } } } applyConnections(candidate, context, MutationContext.STATIC); context.applyElementMutation(candidate, MutationContext.STATIC); final Node source = candidate.getSourceNode(); if (null != source) { context.notifyCanvasElementUpdated(source); } return buildResult(); } AddCanvasConnectorCommand(final Edge candidate,
final String shapeSetId); @Override @SuppressWarnings("unchecked") CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); Edge getCandidate(); String getShapeSetId(); @Override String toString(); }
|
@Test @SuppressWarnings("unchecked") public void testExecute() { final CommandResult<CanvasViolation> result = tested.execute(canvasHandler); assertNotEquals(CommandResult.Type.ERROR, result.getType()); verify(canvasHandler, times(1)).addChild(eq(graph1Instance.startNode), eq(graph1Instance.intermNode)); verify(canvasHandler, never()).applyElementMutation(eq(graph1Instance.intermNode), any(MutationContext.class)); verify(canvasHandler, never()).applyElementMutation(eq(graph1Instance.startNode), any(MutationContext.class)); verify(canvasHandler, times(0)).dock(any(Node.class), any(Node.class)); verify(connectorShapeView1, times(1)).moveToTop(); verify(connectorShapeView1, never()).moveToBottom(); verify(connectorShapeView1, never()).moveUp(); verify(connectorShapeView1, never()).moveDown(); verify(connectorShapeView2, times(1)).moveToTop(); verify(connectorShapeView2, never()).moveToBottom(); verify(connectorShapeView2, never()).moveUp(); verify(connectorShapeView2, never()).moveDown(); }
|
@Override @SuppressWarnings("unchecked") public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { candidates.forEach(candidate -> setCanvasChild(context, candidate)); return buildResult(); }
|
SetCanvasChildrenCommand extends AbstractCanvasCommand { @Override @SuppressWarnings("unchecked") public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { candidates.forEach(candidate -> setCanvasChild(context, candidate)); return buildResult(); } }
|
SetCanvasChildrenCommand extends AbstractCanvasCommand { @Override @SuppressWarnings("unchecked") public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { candidates.forEach(candidate -> setCanvasChild(context, candidate)); return buildResult(); } SetCanvasChildrenCommand(final Node parent,
final Collection<Node<?, Edge>> candidates); }
|
SetCanvasChildrenCommand extends AbstractCanvasCommand { @Override @SuppressWarnings("unchecked") public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { candidates.forEach(candidate -> setCanvasChild(context, candidate)); return buildResult(); } SetCanvasChildrenCommand(final Node parent,
final Collection<Node<?, Edge>> candidates); @Override @SuppressWarnings("unchecked") CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); Node getParent(); Collection<Node<?, Edge>> getCandidates(); @Override String toString(); }
|
SetCanvasChildrenCommand extends AbstractCanvasCommand { @Override @SuppressWarnings("unchecked") public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { candidates.forEach(candidate -> setCanvasChild(context, candidate)); return buildResult(); } SetCanvasChildrenCommand(final Node parent,
final Collection<Node<?, Edge>> candidates); @Override @SuppressWarnings("unchecked") CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); Node getParent(); Collection<Node<?, Edge>> getCandidates(); @Override String toString(); }
|
@Test @SuppressWarnings("unchecked") public void testSkipExecutionAsDockIsPresent() { final Edge dockEdge = mock(Edge.class); when(dockEdge.getContent()).thenReturn(new Dock()); graph1Instance.intermNode.getInEdges().add(dockEdge); final CommandResult<CanvasViolation> result = tested.execute(canvasHandler); assertNotEquals(CommandResult.Type.ERROR, result.getType()); verify(canvasHandler, never()).addChild(eq(graph1Instance.startNode), eq(graph1Instance.intermNode)); verify(canvasHandler, never()).applyElementMutation(eq(graph1Instance.intermNode), any(MutationContext.class)); verify(canvasHandler, never()).applyElementMutation(eq(graph1Instance.startNode), any(MutationContext.class)); verify(canvasHandler, never()).dock(any(Node.class), any(Node.class)); verify(connectorShapeView1, never()).moveToTop(); verify(connectorShapeView1, never()).moveToBottom(); verify(connectorShapeView1, never()).moveUp(); verify(connectorShapeView1, never()).moveDown(); verify(connectorShapeView2, never()).moveToTop(); verify(connectorShapeView2, never()).moveToBottom(); verify(connectorShapeView2, never()).moveUp(); verify(connectorShapeView2, never()).moveDown(); }
|
@Override @SuppressWarnings("unchecked") public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { candidates.forEach(candidate -> setCanvasChild(context, candidate)); return buildResult(); }
|
SetCanvasChildrenCommand extends AbstractCanvasCommand { @Override @SuppressWarnings("unchecked") public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { candidates.forEach(candidate -> setCanvasChild(context, candidate)); return buildResult(); } }
|
SetCanvasChildrenCommand extends AbstractCanvasCommand { @Override @SuppressWarnings("unchecked") public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { candidates.forEach(candidate -> setCanvasChild(context, candidate)); return buildResult(); } SetCanvasChildrenCommand(final Node parent,
final Collection<Node<?, Edge>> candidates); }
|
SetCanvasChildrenCommand extends AbstractCanvasCommand { @Override @SuppressWarnings("unchecked") public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { candidates.forEach(candidate -> setCanvasChild(context, candidate)); return buildResult(); } SetCanvasChildrenCommand(final Node parent,
final Collection<Node<?, Edge>> candidates); @Override @SuppressWarnings("unchecked") CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); Node getParent(); Collection<Node<?, Edge>> getCandidates(); @Override String toString(); }
|
SetCanvasChildrenCommand extends AbstractCanvasCommand { @Override @SuppressWarnings("unchecked") public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { candidates.forEach(candidate -> setCanvasChild(context, candidate)); return buildResult(); } SetCanvasChildrenCommand(final Node parent,
final Collection<Node<?, Edge>> candidates); @Override @SuppressWarnings("unchecked") CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); Node getParent(); Collection<Node<?, Edge>> getCandidates(); @Override String toString(); }
|
@Test public void testGetGraphCommand() { final org.kie.workbench.common.stunner.core.graph.command.impl.DeleteConnectorCommand graphCommand = (org.kie.workbench.common.stunner.core.graph.command.impl.DeleteConnectorCommand) tested.newGraphCommand(canvasHandler); assertNotNull(graphCommand); assertEquals(candidate, graphCommand.getEdge()); }
|
@Override @SuppressWarnings("unchecked") protected Command<GraphCommandExecutionContext, RuleViolation> newGraphCommand(final AbstractCanvasHandler context) { return new org.kie.workbench.common.stunner.core.graph.command.impl.DeleteConnectorCommand(candidate); }
|
DeleteConnectorCommand extends AbstractCanvasGraphCommand { @Override @SuppressWarnings("unchecked") protected Command<GraphCommandExecutionContext, RuleViolation> newGraphCommand(final AbstractCanvasHandler context) { return new org.kie.workbench.common.stunner.core.graph.command.impl.DeleteConnectorCommand(candidate); } }
|
DeleteConnectorCommand extends AbstractCanvasGraphCommand { @Override @SuppressWarnings("unchecked") protected Command<GraphCommandExecutionContext, RuleViolation> newGraphCommand(final AbstractCanvasHandler context) { return new org.kie.workbench.common.stunner.core.graph.command.impl.DeleteConnectorCommand(candidate); } DeleteConnectorCommand(final Edge candidate); }
|
DeleteConnectorCommand extends AbstractCanvasGraphCommand { @Override @SuppressWarnings("unchecked") protected Command<GraphCommandExecutionContext, RuleViolation> newGraphCommand(final AbstractCanvasHandler context) { return new org.kie.workbench.common.stunner.core.graph.command.impl.DeleteConnectorCommand(candidate); } DeleteConnectorCommand(final Edge candidate); @Override String toString(); }
|
DeleteConnectorCommand extends AbstractCanvasGraphCommand { @Override @SuppressWarnings("unchecked") protected Command<GraphCommandExecutionContext, RuleViolation> newGraphCommand(final AbstractCanvasHandler context) { return new org.kie.workbench.common.stunner.core.graph.command.impl.DeleteConnectorCommand(candidate); } DeleteConnectorCommand(final Edge candidate); @Override String toString(); }
|
@Test public void testGetCanvasCommand() { final DeleteCanvasConnectorCommand canvasCommand = (DeleteCanvasConnectorCommand) tested.newCanvasCommand(canvasHandler); assertNotNull(canvasCommand); assertEquals(candidate, canvasCommand.getCandidate()); }
|
@Override protected AbstractCanvasCommand newCanvasCommand(final AbstractCanvasHandler context) { return new DeleteCanvasConnectorCommand(candidate); }
|
DeleteConnectorCommand extends AbstractCanvasGraphCommand { @Override protected AbstractCanvasCommand newCanvasCommand(final AbstractCanvasHandler context) { return new DeleteCanvasConnectorCommand(candidate); } }
|
DeleteConnectorCommand extends AbstractCanvasGraphCommand { @Override protected AbstractCanvasCommand newCanvasCommand(final AbstractCanvasHandler context) { return new DeleteCanvasConnectorCommand(candidate); } DeleteConnectorCommand(final Edge candidate); }
|
DeleteConnectorCommand extends AbstractCanvasGraphCommand { @Override protected AbstractCanvasCommand newCanvasCommand(final AbstractCanvasHandler context) { return new DeleteCanvasConnectorCommand(candidate); } DeleteConnectorCommand(final Edge candidate); @Override String toString(); }
|
DeleteConnectorCommand extends AbstractCanvasGraphCommand { @Override protected AbstractCanvasCommand newCanvasCommand(final AbstractCanvasHandler context) { return new DeleteCanvasConnectorCommand(candidate); } DeleteConnectorCommand(final Edge candidate); @Override String toString(); }
|
@Test @SuppressWarnings("unchecked") public void testExecute() { final CommandResult<CanvasViolation> result = tested.execute(canvasHandler); assertNotEquals(CommandResult.Type.ERROR, result.getType()); verify(canvasHandler, times(1)).updateElementProperties(eq(candidate), any(MutationContext.class)); }
|
@Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { context.updateElementProperties(element, MutationContext.STATIC); return buildResult(); }
|
UpdateCanvasElementPropertyCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { context.updateElementProperties(element, MutationContext.STATIC); return buildResult(); } }
|
UpdateCanvasElementPropertyCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { context.updateElementProperties(element, MutationContext.STATIC); return buildResult(); } UpdateCanvasElementPropertyCommand(final Element element); }
|
UpdateCanvasElementPropertyCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { context.updateElementProperties(element, MutationContext.STATIC); return buildResult(); } UpdateCanvasElementPropertyCommand(final Element element); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); @Override String toString(); }
|
UpdateCanvasElementPropertyCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { context.updateElementProperties(element, MutationContext.STATIC); return buildResult(); } UpdateCanvasElementPropertyCommand(final Element element); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); @Override String toString(); }
|
@Test public void testOnClosedByKeyboard() { final Consumer consumer = mock(Consumer.class); final Optional opt = Optional.of(consumer); doReturn(opt).when(view).getClosedByKeyboardCallback(); view.onClosedByKeyboard(); verify(consumer).accept(view); }
|
public void onClosedByKeyboard() { getClosedByKeyboardCallback().ifPresent(c -> c.accept(this)); }
|
AbstractPopoverViewImpl implements PopoverView { public void onClosedByKeyboard() { getClosedByKeyboardCallback().ifPresent(c -> c.accept(this)); } }
|
AbstractPopoverViewImpl implements PopoverView { public void onClosedByKeyboard() { getClosedByKeyboardCallback().ifPresent(c -> c.accept(this)); } protected AbstractPopoverViewImpl(); AbstractPopoverViewImpl(final Div popoverElement,
final Div popoverContentElement,
final JQueryProducer.JQuery<Popover> jQueryPopover); }
|
AbstractPopoverViewImpl implements PopoverView { public void onClosedByKeyboard() { getClosedByKeyboardCallback().ifPresent(c -> c.accept(this)); } protected AbstractPopoverViewImpl(); AbstractPopoverViewImpl(final Div popoverElement,
final Div popoverContentElement,
final JQueryProducer.JQuery<Popover> jQueryPopover); @Override void setOnClosedByKeyboardCallback(final Consumer<CanBeClosedByKeyboard> callback); @Override void show(final Optional<String> popoverTitle); @Override void hide(); boolean isVisible(); void keyDownEventListener(final Object event); boolean isEscapeKeyPressed(final KeyboardEvent event); boolean isEnterKeyPressed(final KeyboardEvent event); void onClosedByKeyboard(); Optional<Consumer<CanBeClosedByKeyboard>> getClosedByKeyboardCallback(); }
|
AbstractPopoverViewImpl implements PopoverView { public void onClosedByKeyboard() { getClosedByKeyboardCallback().ifPresent(c -> c.accept(this)); } protected AbstractPopoverViewImpl(); AbstractPopoverViewImpl(final Div popoverElement,
final Div popoverContentElement,
final JQueryProducer.JQuery<Popover> jQueryPopover); @Override void setOnClosedByKeyboardCallback(final Consumer<CanBeClosedByKeyboard> callback); @Override void show(final Optional<String> popoverTitle); @Override void hide(); boolean isVisible(); void keyDownEventListener(final Object event); boolean isEscapeKeyPressed(final KeyboardEvent event); boolean isEnterKeyPressed(final KeyboardEvent event); void onClosedByKeyboard(); Optional<Consumer<CanBeClosedByKeyboard>> getClosedByKeyboardCallback(); }
|
@Test @SuppressWarnings("unchecked") public void testExecute() { final CommandResult<CanvasViolation> result = tested.execute(canvasHandler); assertNotEquals(CommandResult.Type.ERROR, result.getType()); verify(canvasHandler, times(1)).register(eq(SHAPE_SET_ID), eq(candidate)); verify(canvasHandler, times(1)).addChild(eq(parent), eq(candidate)); verify(canvasHandler, times(1)).applyElementMutation(eq(candidate), any(MutationContext.class)); verify(canvasHandler, times(1)).applyElementMutation(eq(parent), any(MutationContext.class)); }
|
@Override @SuppressWarnings("unchecked") public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { final CommandResult<CanvasViolation> result = super.execute(context); context.applyElementMutation(parent, MutationContext.STATIC); return result; }
|
AddCanvasChildNodeCommand extends AbstractRegistrationCanvasNodeCommand { @Override @SuppressWarnings("unchecked") public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { final CommandResult<CanvasViolation> result = super.execute(context); context.applyElementMutation(parent, MutationContext.STATIC); return result; } }
|
AddCanvasChildNodeCommand extends AbstractRegistrationCanvasNodeCommand { @Override @SuppressWarnings("unchecked") public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { final CommandResult<CanvasViolation> result = super.execute(context); context.applyElementMutation(parent, MutationContext.STATIC); return result; } AddCanvasChildNodeCommand(final Node parent,
final Node candidate,
final String shapeSetId); }
|
AddCanvasChildNodeCommand extends AbstractRegistrationCanvasNodeCommand { @Override @SuppressWarnings("unchecked") public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { final CommandResult<CanvasViolation> result = super.execute(context); context.applyElementMutation(parent, MutationContext.STATIC); return result; } AddCanvasChildNodeCommand(final Node parent,
final Node candidate,
final String shapeSetId); @Override @SuppressWarnings("unchecked") CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override @SuppressWarnings("unchecked") CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); Node getParent(); @Override String toString(); }
|
AddCanvasChildNodeCommand extends AbstractRegistrationCanvasNodeCommand { @Override @SuppressWarnings("unchecked") public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { final CommandResult<CanvasViolation> result = super.execute(context); context.applyElementMutation(parent, MutationContext.STATIC); return result; } AddCanvasChildNodeCommand(final Node parent,
final Node candidate,
final String shapeSetId); @Override @SuppressWarnings("unchecked") CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override @SuppressWarnings("unchecked") CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); Node getParent(); @Override String toString(); }
|
@Test public void testExecute() { final CommandResult<CanvasViolation> result = tested.execute(canvasHandler); assertNotEquals(CommandResult.Type.ERROR, result.getType()); verify(canvasHandler, times(1)).clearCanvas(); }
|
@Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { context.clearCanvas(); return buildResult(); }
|
ClearCanvasCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { context.clearCanvas(); return buildResult(); } }
|
ClearCanvasCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { context.clearCanvas(); return buildResult(); } }
|
ClearCanvasCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { context.clearCanvas(); return buildResult(); } @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); @Override String toString(); }
|
ClearCanvasCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { context.clearCanvas(); return buildResult(); } @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); @Override String toString(); }
|
@Test(expected = UnsupportedOperationException.class) public void testUndo() { tested.undo(canvasHandler); }
|
@Override public CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context) { throw new UnsupportedOperationException("Undo operation for Clear Canvas Command is still not supported."); }
|
ClearCanvasCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context) { throw new UnsupportedOperationException("Undo operation for Clear Canvas Command is still not supported."); } }
|
ClearCanvasCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context) { throw new UnsupportedOperationException("Undo operation for Clear Canvas Command is still not supported."); } }
|
ClearCanvasCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context) { throw new UnsupportedOperationException("Undo operation for Clear Canvas Command is still not supported."); } @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); @Override String toString(); }
|
ClearCanvasCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context) { throw new UnsupportedOperationException("Undo operation for Clear Canvas Command is still not supported."); } @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); @Override String toString(); }
|
@Test public void startNodeTestGraphCommand() { this.tested = new DeleteNodeCommand(graphHolder.startNode); final org.kie.workbench.common.stunner.core.graph.command.impl.SafeDeleteNodeCommand graphCommand = (org.kie.workbench.common.stunner.core.graph.command.impl.SafeDeleteNodeCommand) tested.newGraphCommand(canvasHandler); assertNotNull(graphCommand); assertEquals(graphHolder.startNode, graphCommand.getNode()); }
|
@Override @SuppressWarnings("unchecked") protected Command<GraphCommandExecutionContext, RuleViolation> newGraphCommand(final AbstractCanvasHandler context) { return new SafeDeleteNodeCommand(candidate, deleteProcessor, options); }
|
DeleteNodeCommand extends AbstractCanvasGraphCommand { @Override @SuppressWarnings("unchecked") protected Command<GraphCommandExecutionContext, RuleViolation> newGraphCommand(final AbstractCanvasHandler context) { return new SafeDeleteNodeCommand(candidate, deleteProcessor, options); } }
|
DeleteNodeCommand extends AbstractCanvasGraphCommand { @Override @SuppressWarnings("unchecked") protected Command<GraphCommandExecutionContext, RuleViolation> newGraphCommand(final AbstractCanvasHandler context) { return new SafeDeleteNodeCommand(candidate, deleteProcessor, options); } DeleteNodeCommand(final Node candidate); DeleteNodeCommand(final Node candidate,
final SafeDeleteNodeCommand.Options options); @SuppressWarnings("unchecked") DeleteNodeCommand(final Node candidate,
final SafeDeleteNodeCommand.Options options,
final CanvasDeleteProcessor deleteProcessor); }
|
DeleteNodeCommand extends AbstractCanvasGraphCommand { @Override @SuppressWarnings("unchecked") protected Command<GraphCommandExecutionContext, RuleViolation> newGraphCommand(final AbstractCanvasHandler context) { return new SafeDeleteNodeCommand(candidate, deleteProcessor, options); } DeleteNodeCommand(final Node candidate); DeleteNodeCommand(final Node candidate,
final SafeDeleteNodeCommand.Options options); @SuppressWarnings("unchecked") DeleteNodeCommand(final Node candidate,
final SafeDeleteNodeCommand.Options options,
final CanvasDeleteProcessor deleteProcessor); Node getCandidate(); SafeDeleteNodeCommand.Options getOptions(); @Override String toString(); CanvasDeleteProcessor getDeleteProcessor(); }
|
DeleteNodeCommand extends AbstractCanvasGraphCommand { @Override @SuppressWarnings("unchecked") protected Command<GraphCommandExecutionContext, RuleViolation> newGraphCommand(final AbstractCanvasHandler context) { return new SafeDeleteNodeCommand(candidate, deleteProcessor, options); } DeleteNodeCommand(final Node candidate); DeleteNodeCommand(final Node candidate,
final SafeDeleteNodeCommand.Options options); @SuppressWarnings("unchecked") DeleteNodeCommand(final Node candidate,
final SafeDeleteNodeCommand.Options options,
final CanvasDeleteProcessor deleteProcessor); Node getCandidate(); SafeDeleteNodeCommand.Options getOptions(); @Override String toString(); CanvasDeleteProcessor getDeleteProcessor(); }
|
@Test public void intermediateNodeTestGraphCommand() { this.tested = new DeleteNodeCommand(graphHolder.intermNode); final org.kie.workbench.common.stunner.core.graph.command.impl.SafeDeleteNodeCommand graphCommand = (org.kie.workbench.common.stunner.core.graph.command.impl.SafeDeleteNodeCommand) tested.newGraphCommand(canvasHandler); assertNotNull(graphCommand); assertEquals(graphHolder.intermNode, graphCommand.getNode()); }
|
@Override @SuppressWarnings("unchecked") protected Command<GraphCommandExecutionContext, RuleViolation> newGraphCommand(final AbstractCanvasHandler context) { return new SafeDeleteNodeCommand(candidate, deleteProcessor, options); }
|
DeleteNodeCommand extends AbstractCanvasGraphCommand { @Override @SuppressWarnings("unchecked") protected Command<GraphCommandExecutionContext, RuleViolation> newGraphCommand(final AbstractCanvasHandler context) { return new SafeDeleteNodeCommand(candidate, deleteProcessor, options); } }
|
DeleteNodeCommand extends AbstractCanvasGraphCommand { @Override @SuppressWarnings("unchecked") protected Command<GraphCommandExecutionContext, RuleViolation> newGraphCommand(final AbstractCanvasHandler context) { return new SafeDeleteNodeCommand(candidate, deleteProcessor, options); } DeleteNodeCommand(final Node candidate); DeleteNodeCommand(final Node candidate,
final SafeDeleteNodeCommand.Options options); @SuppressWarnings("unchecked") DeleteNodeCommand(final Node candidate,
final SafeDeleteNodeCommand.Options options,
final CanvasDeleteProcessor deleteProcessor); }
|
DeleteNodeCommand extends AbstractCanvasGraphCommand { @Override @SuppressWarnings("unchecked") protected Command<GraphCommandExecutionContext, RuleViolation> newGraphCommand(final AbstractCanvasHandler context) { return new SafeDeleteNodeCommand(candidate, deleteProcessor, options); } DeleteNodeCommand(final Node candidate); DeleteNodeCommand(final Node candidate,
final SafeDeleteNodeCommand.Options options); @SuppressWarnings("unchecked") DeleteNodeCommand(final Node candidate,
final SafeDeleteNodeCommand.Options options,
final CanvasDeleteProcessor deleteProcessor); Node getCandidate(); SafeDeleteNodeCommand.Options getOptions(); @Override String toString(); CanvasDeleteProcessor getDeleteProcessor(); }
|
DeleteNodeCommand extends AbstractCanvasGraphCommand { @Override @SuppressWarnings("unchecked") protected Command<GraphCommandExecutionContext, RuleViolation> newGraphCommand(final AbstractCanvasHandler context) { return new SafeDeleteNodeCommand(candidate, deleteProcessor, options); } DeleteNodeCommand(final Node candidate); DeleteNodeCommand(final Node candidate,
final SafeDeleteNodeCommand.Options options); @SuppressWarnings("unchecked") DeleteNodeCommand(final Node candidate,
final SafeDeleteNodeCommand.Options options,
final CanvasDeleteProcessor deleteProcessor); Node getCandidate(); SafeDeleteNodeCommand.Options getOptions(); @Override String toString(); CanvasDeleteProcessor getDeleteProcessor(); }
|
@Test public void testMoveChildToCanvasRoot() { final DeleteNodeCommand.CanvasDeleteProcessor processor = mock(DeleteNodeCommand.CanvasDeleteProcessor.class); final Node node = mock(Node.class); final Element elementCanvas = mock(Element.class); final Node canvasNode = mock(Node.class); final Element parentElement = mock(Element.class); final Node nodeParent = mock(Node.class); final Point2D newPosition = new Point2D(1, 2); final CompositeCommand command = mock(CompositeCommand.class); when(elementCanvas.asNode()).thenReturn(canvasNode); doCallRealMethod().when(processor).moveChildToCanvasRoot(elementCanvas, node); when(parentElement.asNode()).thenReturn(nodeParent); when(processor.getParent(node)).thenReturn(parentElement); when(processor.getCommand()).thenReturn(command); when(processor.getChildPosition(node, parentElement)).thenReturn(newPosition); processor.moveChildToCanvasRoot(elementCanvas, node); verify(command, times(3)).addCommand(commandsCaptor.capture()); final List<AbstractCanvasGraphCommand> values = commandsCaptor.getAllValues(); final AbstractCanvasGraphCommand removeChildrenCmd = values.get(0); final AbstractCanvasGraphCommand setChildrenCmd = values.get(1); final AbstractCanvasGraphCommand updatePosition = values.get(2); assertTrue(removeChildrenCmd instanceof RemoveChildrenCommand); assertTrue(setChildrenCmd instanceof SetChildrenCommand); assertTrue(updatePosition instanceof UpdateElementPositionCommand); assertEquals(nodeParent, ((RemoveChildrenCommand) removeChildrenCmd).getParent()); assertEquals(canvasNode, ((SetChildrenCommand) setChildrenCmd).getParent()); assertEquals(node, ((UpdateElementPositionCommand) updatePosition).getElement()); assertEquals(node, getNode(((RemoveChildrenCommand) removeChildrenCmd).getChildren())); assertEquals(node, getNode(((SetChildrenCommand) setChildrenCmd).getCandidates())); assertEquals(newPosition, ((UpdateElementPositionCommand) updatePosition).getLocation()); }
|
CompositeCommand<AbstractCanvasHandler, CanvasViolation> getCommand() { return deleteProcessor.getCommand(); }
|
DeleteNodeCommand extends AbstractCanvasGraphCommand { CompositeCommand<AbstractCanvasHandler, CanvasViolation> getCommand() { return deleteProcessor.getCommand(); } }
|
DeleteNodeCommand extends AbstractCanvasGraphCommand { CompositeCommand<AbstractCanvasHandler, CanvasViolation> getCommand() { return deleteProcessor.getCommand(); } DeleteNodeCommand(final Node candidate); DeleteNodeCommand(final Node candidate,
final SafeDeleteNodeCommand.Options options); @SuppressWarnings("unchecked") DeleteNodeCommand(final Node candidate,
final SafeDeleteNodeCommand.Options options,
final CanvasDeleteProcessor deleteProcessor); }
|
DeleteNodeCommand extends AbstractCanvasGraphCommand { CompositeCommand<AbstractCanvasHandler, CanvasViolation> getCommand() { return deleteProcessor.getCommand(); } DeleteNodeCommand(final Node candidate); DeleteNodeCommand(final Node candidate,
final SafeDeleteNodeCommand.Options options); @SuppressWarnings("unchecked") DeleteNodeCommand(final Node candidate,
final SafeDeleteNodeCommand.Options options,
final CanvasDeleteProcessor deleteProcessor); Node getCandidate(); SafeDeleteNodeCommand.Options getOptions(); @Override String toString(); CanvasDeleteProcessor getDeleteProcessor(); }
|
DeleteNodeCommand extends AbstractCanvasGraphCommand { CompositeCommand<AbstractCanvasHandler, CanvasViolation> getCommand() { return deleteProcessor.getCommand(); } DeleteNodeCommand(final Node candidate); DeleteNodeCommand(final Node candidate,
final SafeDeleteNodeCommand.Options options); @SuppressWarnings("unchecked") DeleteNodeCommand(final Node candidate,
final SafeDeleteNodeCommand.Options options,
final CanvasDeleteProcessor deleteProcessor); Node getCandidate(); SafeDeleteNodeCommand.Options getOptions(); @Override String toString(); CanvasDeleteProcessor getDeleteProcessor(); }
|
@Test public void newGraphCommand() { Command<GraphCommandExecutionContext, RuleViolation> command = cloneConnectorCommand.newGraphCommand(context); assertTrue(command instanceof org.kie.workbench.common.stunner.core.graph.command.impl.CloneConnectorCommand); }
|
@Override protected Command<GraphCommandExecutionContext, RuleViolation> newGraphCommand(final AbstractCanvasHandler context) { return new org.kie.workbench.common.stunner.core.graph.command.impl.CloneConnectorCommand(candidate, sourceUUID, targetUUID, getCloneCallback()); }
|
CloneConnectorCommand extends AbstractCanvasGraphCommand { @Override protected Command<GraphCommandExecutionContext, RuleViolation> newGraphCommand(final AbstractCanvasHandler context) { return new org.kie.workbench.common.stunner.core.graph.command.impl.CloneConnectorCommand(candidate, sourceUUID, targetUUID, getCloneCallback()); } }
|
CloneConnectorCommand extends AbstractCanvasGraphCommand { @Override protected Command<GraphCommandExecutionContext, RuleViolation> newGraphCommand(final AbstractCanvasHandler context) { return new org.kie.workbench.common.stunner.core.graph.command.impl.CloneConnectorCommand(candidate, sourceUUID, targetUUID, getCloneCallback()); } CloneConnectorCommand(final Edge candidate,
final String sourceUUID,
final String targetUUID,
final String shapeSetId,
final Consumer<Edge> callback); }
|
CloneConnectorCommand extends AbstractCanvasGraphCommand { @Override protected Command<GraphCommandExecutionContext, RuleViolation> newGraphCommand(final AbstractCanvasHandler context) { return new org.kie.workbench.common.stunner.core.graph.command.impl.CloneConnectorCommand(candidate, sourceUUID, targetUUID, getCloneCallback()); } CloneConnectorCommand(final Edge candidate,
final String sourceUUID,
final String targetUUID,
final String shapeSetId,
final Consumer<Edge> callback); @Override String toString(); }
|
CloneConnectorCommand extends AbstractCanvasGraphCommand { @Override protected Command<GraphCommandExecutionContext, RuleViolation> newGraphCommand(final AbstractCanvasHandler context) { return new org.kie.workbench.common.stunner.core.graph.command.impl.CloneConnectorCommand(candidate, sourceUUID, targetUUID, getCloneCallback()); } CloneConnectorCommand(final Edge candidate,
final String sourceUUID,
final String targetUUID,
final String shapeSetId,
final Consumer<Edge> callback); @Override String toString(); }
|
@Test @SuppressWarnings("unchecked") public void newCanvasCommand() { Command<AbstractCanvasHandler, CanvasViolation> command = cloneConnectorCommand.newCanvasCommand(context); assertTrue(command instanceof CompositeCommand); Consumer<Edge> cloneCallback = cloneConnectorCommand.getCloneCallback(); cloneCallback.accept(clone); CompositeCommand compositeCommand = (CompositeCommand) command; assertTrue(compositeCommand.getCommands().stream().anyMatch(c -> c instanceof AddCanvasConnectorCommand)); assertEquals(((AddCanvasConnectorCommand) compositeCommand.getCommands().stream() .filter(c -> c instanceof AddCanvasConnectorCommand) .findFirst() .get()).getCandidate(), clone); assertTrue(compositeCommand.getCommands().stream().anyMatch(c -> c instanceof SetCanvasConnectionCommand)); assertEquals(((SetCanvasConnectionCommand) compositeCommand.getCommands().stream() .filter(c -> c instanceof SetCanvasConnectionCommand) .findFirst() .get()).getEdge(), clone); }
|
@Override protected Command<AbstractCanvasHandler, CanvasViolation> newCanvasCommand(final AbstractCanvasHandler context) { return command; }
|
CloneConnectorCommand extends AbstractCanvasGraphCommand { @Override protected Command<AbstractCanvasHandler, CanvasViolation> newCanvasCommand(final AbstractCanvasHandler context) { return command; } }
|
CloneConnectorCommand extends AbstractCanvasGraphCommand { @Override protected Command<AbstractCanvasHandler, CanvasViolation> newCanvasCommand(final AbstractCanvasHandler context) { return command; } CloneConnectorCommand(final Edge candidate,
final String sourceUUID,
final String targetUUID,
final String shapeSetId,
final Consumer<Edge> callback); }
|
CloneConnectorCommand extends AbstractCanvasGraphCommand { @Override protected Command<AbstractCanvasHandler, CanvasViolation> newCanvasCommand(final AbstractCanvasHandler context) { return command; } CloneConnectorCommand(final Edge candidate,
final String sourceUUID,
final String targetUUID,
final String shapeSetId,
final Consumer<Edge> callback); @Override String toString(); }
|
CloneConnectorCommand extends AbstractCanvasGraphCommand { @Override protected Command<AbstractCanvasHandler, CanvasViolation> newCanvasCommand(final AbstractCanvasHandler context) { return command; } CloneConnectorCommand(final Edge candidate,
final String sourceUUID,
final String targetUUID,
final String shapeSetId,
final Consumer<Edge> callback); @Override String toString(); }
|
@Test @SuppressWarnings("unchecked") public void testExecute() { final CommandResult<CanvasViolation> result = tested.execute(canvasHandler); assertNotEquals(CommandResult.Type.ERROR, result.getType()); verify(canvasHandler, times(0)).register(anyString(), eq(candidate)); verify(canvasHandler, times(0)).addChild(any(Node.class), any(Node.class)); verify(canvasHandler, times(1)).dock(eq(parent), eq(candidate)); verify(canvasHandler, times(1)).applyElementMutation(eq(candidate), any(MutationContext.class)); verify(canvasHandler, times(1)).applyElementMutation(eq(parent), any(MutationContext.class)); }
|
@Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { getCandidate().getInEdges().stream() .filter(e -> e.getContent() instanceof Child) .findAny() .ifPresent(e -> context.removeChild(e.getSourceNode(), candidate)); ShapeView shapeView = context.getCanvas().getShape(candidate.getUUID()).getShapeView(); Point2D currentPosition = new Point2D(shapeView.getShapeX(), shapeView.getShapeY()); context.applyElementMutation(parent, MutationContext.STATIC); context.applyElementMutation(candidate, MutationContext.STATIC); if (!context.dock(parent, candidate)) { return new CanvasCommandResultBuilder() .addViolation(CanvasViolationImpl.Builder .build(new DockingRuleViolation(parent.getUUID(), candidate.getUUID()))) .build(); } Point2D dockLocation = new Point2D(shapeView.getShapeX(), shapeView.getShapeY()); if (!Objects.equals(currentPosition, dockLocation)) { dockedPositionCallback.ifPresent(callback -> callback.accept(dockLocation)); } return buildResult(); }
|
CanvasDockNodeCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { getCandidate().getInEdges().stream() .filter(e -> e.getContent() instanceof Child) .findAny() .ifPresent(e -> context.removeChild(e.getSourceNode(), candidate)); ShapeView shapeView = context.getCanvas().getShape(candidate.getUUID()).getShapeView(); Point2D currentPosition = new Point2D(shapeView.getShapeX(), shapeView.getShapeY()); context.applyElementMutation(parent, MutationContext.STATIC); context.applyElementMutation(candidate, MutationContext.STATIC); if (!context.dock(parent, candidate)) { return new CanvasCommandResultBuilder() .addViolation(CanvasViolationImpl.Builder .build(new DockingRuleViolation(parent.getUUID(), candidate.getUUID()))) .build(); } Point2D dockLocation = new Point2D(shapeView.getShapeX(), shapeView.getShapeY()); if (!Objects.equals(currentPosition, dockLocation)) { dockedPositionCallback.ifPresent(callback -> callback.accept(dockLocation)); } return buildResult(); } }
|
CanvasDockNodeCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { getCandidate().getInEdges().stream() .filter(e -> e.getContent() instanceof Child) .findAny() .ifPresent(e -> context.removeChild(e.getSourceNode(), candidate)); ShapeView shapeView = context.getCanvas().getShape(candidate.getUUID()).getShapeView(); Point2D currentPosition = new Point2D(shapeView.getShapeX(), shapeView.getShapeY()); context.applyElementMutation(parent, MutationContext.STATIC); context.applyElementMutation(candidate, MutationContext.STATIC); if (!context.dock(parent, candidate)) { return new CanvasCommandResultBuilder() .addViolation(CanvasViolationImpl.Builder .build(new DockingRuleViolation(parent.getUUID(), candidate.getUUID()))) .build(); } Point2D dockLocation = new Point2D(shapeView.getShapeX(), shapeView.getShapeY()); if (!Objects.equals(currentPosition, dockLocation)) { dockedPositionCallback.ifPresent(callback -> callback.accept(dockLocation)); } return buildResult(); } CanvasDockNodeCommand(final Node parent,
final Node candidate); CanvasDockNodeCommand(final Node parent,
final Node candidate,
final Consumer<Point2D> dockedPositionCallback); }
|
CanvasDockNodeCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { getCandidate().getInEdges().stream() .filter(e -> e.getContent() instanceof Child) .findAny() .ifPresent(e -> context.removeChild(e.getSourceNode(), candidate)); ShapeView shapeView = context.getCanvas().getShape(candidate.getUUID()).getShapeView(); Point2D currentPosition = new Point2D(shapeView.getShapeX(), shapeView.getShapeY()); context.applyElementMutation(parent, MutationContext.STATIC); context.applyElementMutation(candidate, MutationContext.STATIC); if (!context.dock(parent, candidate)) { return new CanvasCommandResultBuilder() .addViolation(CanvasViolationImpl.Builder .build(new DockingRuleViolation(parent.getUUID(), candidate.getUUID()))) .build(); } Point2D dockLocation = new Point2D(shapeView.getShapeX(), shapeView.getShapeY()); if (!Objects.equals(currentPosition, dockLocation)) { dockedPositionCallback.ifPresent(callback -> callback.accept(dockLocation)); } return buildResult(); } CanvasDockNodeCommand(final Node parent,
final Node candidate); CanvasDockNodeCommand(final Node parent,
final Node candidate,
final Consumer<Point2D> dockedPositionCallback); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); Node getParent(); Node<?, Edge> getCandidate(); @Override String toString(); }
|
CanvasDockNodeCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { getCandidate().getInEdges().stream() .filter(e -> e.getContent() instanceof Child) .findAny() .ifPresent(e -> context.removeChild(e.getSourceNode(), candidate)); ShapeView shapeView = context.getCanvas().getShape(candidate.getUUID()).getShapeView(); Point2D currentPosition = new Point2D(shapeView.getShapeX(), shapeView.getShapeY()); context.applyElementMutation(parent, MutationContext.STATIC); context.applyElementMutation(candidate, MutationContext.STATIC); if (!context.dock(parent, candidate)) { return new CanvasCommandResultBuilder() .addViolation(CanvasViolationImpl.Builder .build(new DockingRuleViolation(parent.getUUID(), candidate.getUUID()))) .build(); } Point2D dockLocation = new Point2D(shapeView.getShapeX(), shapeView.getShapeY()); if (!Objects.equals(currentPosition, dockLocation)) { dockedPositionCallback.ifPresent(callback -> callback.accept(dockLocation)); } return buildResult(); } CanvasDockNodeCommand(final Node parent,
final Node candidate); CanvasDockNodeCommand(final Node parent,
final Node candidate,
final Consumer<Point2D> dockedPositionCallback); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); Node getParent(); Node<?, Edge> getCandidate(); @Override String toString(); }
|
@Test @SuppressWarnings("unchecked") public void testExecute() { final CommandResult<CanvasViolation> result = tested.execute(canvasHandler); assertNotEquals(CommandResult.Type.ERROR, result.getType()); verify(canvasHandler, times(1)).deregister(eq(candidate)); verify(canvasHandler, times(1)).notifyCanvasElementUpdated(eq(source)); verify(canvasHandler, times(1)).notifyCanvasElementUpdated(eq(target)); }
|
@Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { if (!checkShapeNotNull(context, candidate.getUUID())) { return buildResult(); } context.deregister(candidate); final Node source = candidate.getSourceNode(); if (null != source) { context.notifyCanvasElementUpdated(source); } final Node target = candidate.getTargetNode(); if (null != target) { context.notifyCanvasElementUpdated(target); } return buildResult(); }
|
DeleteCanvasConnectorCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { if (!checkShapeNotNull(context, candidate.getUUID())) { return buildResult(); } context.deregister(candidate); final Node source = candidate.getSourceNode(); if (null != source) { context.notifyCanvasElementUpdated(source); } final Node target = candidate.getTargetNode(); if (null != target) { context.notifyCanvasElementUpdated(target); } return buildResult(); } }
|
DeleteCanvasConnectorCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { if (!checkShapeNotNull(context, candidate.getUUID())) { return buildResult(); } context.deregister(candidate); final Node source = candidate.getSourceNode(); if (null != source) { context.notifyCanvasElementUpdated(source); } final Node target = candidate.getTargetNode(); if (null != target) { context.notifyCanvasElementUpdated(target); } return buildResult(); } DeleteCanvasConnectorCommand(final Edge candidate); }
|
DeleteCanvasConnectorCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { if (!checkShapeNotNull(context, candidate.getUUID())) { return buildResult(); } context.deregister(candidate); final Node source = candidate.getSourceNode(); if (null != source) { context.notifyCanvasElementUpdated(source); } final Node target = candidate.getTargetNode(); if (null != target) { context.notifyCanvasElementUpdated(target); } return buildResult(); } DeleteCanvasConnectorCommand(final Edge candidate); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); Edge getCandidate(); @Override String toString(); }
|
DeleteCanvasConnectorCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { if (!checkShapeNotNull(context, candidate.getUUID())) { return buildResult(); } context.deregister(candidate); final Node source = candidate.getSourceNode(); if (null != source) { context.notifyCanvasElementUpdated(source); } final Node target = candidate.getTargetNode(); if (null != target) { context.notifyCanvasElementUpdated(target); } return buildResult(); } DeleteCanvasConnectorCommand(final Edge candidate); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); Edge getCandidate(); @Override String toString(); }
|
@Test public void testSetOnClosedByKeyboardCallback() { final Consumer consumer = mock(Consumer.class); view.setOnClosedByKeyboardCallback(consumer); final Optional<Consumer<CanBeClosedByKeyboard>> actual = view.getClosedByKeyboardCallback(); assertTrue(actual.isPresent()); assertEquals(consumer, actual.get()); }
|
@Override public void setOnClosedByKeyboardCallback(final Consumer<CanBeClosedByKeyboard> callback) { closedByKeyboardCallback = Optional.ofNullable(callback); }
|
AbstractPopoverViewImpl implements PopoverView { @Override public void setOnClosedByKeyboardCallback(final Consumer<CanBeClosedByKeyboard> callback) { closedByKeyboardCallback = Optional.ofNullable(callback); } }
|
AbstractPopoverViewImpl implements PopoverView { @Override public void setOnClosedByKeyboardCallback(final Consumer<CanBeClosedByKeyboard> callback) { closedByKeyboardCallback = Optional.ofNullable(callback); } protected AbstractPopoverViewImpl(); AbstractPopoverViewImpl(final Div popoverElement,
final Div popoverContentElement,
final JQueryProducer.JQuery<Popover> jQueryPopover); }
|
AbstractPopoverViewImpl implements PopoverView { @Override public void setOnClosedByKeyboardCallback(final Consumer<CanBeClosedByKeyboard> callback) { closedByKeyboardCallback = Optional.ofNullable(callback); } protected AbstractPopoverViewImpl(); AbstractPopoverViewImpl(final Div popoverElement,
final Div popoverContentElement,
final JQueryProducer.JQuery<Popover> jQueryPopover); @Override void setOnClosedByKeyboardCallback(final Consumer<CanBeClosedByKeyboard> callback); @Override void show(final Optional<String> popoverTitle); @Override void hide(); boolean isVisible(); void keyDownEventListener(final Object event); boolean isEscapeKeyPressed(final KeyboardEvent event); boolean isEnterKeyPressed(final KeyboardEvent event); void onClosedByKeyboard(); Optional<Consumer<CanBeClosedByKeyboard>> getClosedByKeyboardCallback(); }
|
AbstractPopoverViewImpl implements PopoverView { @Override public void setOnClosedByKeyboardCallback(final Consumer<CanBeClosedByKeyboard> callback) { closedByKeyboardCallback = Optional.ofNullable(callback); } protected AbstractPopoverViewImpl(); AbstractPopoverViewImpl(final Div popoverElement,
final Div popoverContentElement,
final JQueryProducer.JQuery<Popover> jQueryPopover); @Override void setOnClosedByKeyboardCallback(final Consumer<CanBeClosedByKeyboard> callback); @Override void show(final Optional<String> popoverTitle); @Override void hide(); boolean isVisible(); void keyDownEventListener(final Object event); boolean isEscapeKeyPressed(final KeyboardEvent event); boolean isEnterKeyPressed(final KeyboardEvent event); void onClosedByKeyboard(); Optional<Consumer<CanBeClosedByKeyboard>> getClosedByKeyboardCallback(); }
|
@Test @SuppressWarnings("unchecked") public void testExecuteNullSourceNode() { when(candidate.getSourceNode()).thenReturn(null); final CommandResult<CanvasViolation> result = tested.execute(canvasHandler); assertNotEquals(CommandResult.Type.ERROR, result.getType()); verify(canvasHandler, times(1)).deregister(eq(candidate)); verify(canvasHandler, never()).notifyCanvasElementUpdated(eq(source)); verify(canvasHandler, times(1)).notifyCanvasElementUpdated(eq(target)); }
|
@Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { if (!checkShapeNotNull(context, candidate.getUUID())) { return buildResult(); } context.deregister(candidate); final Node source = candidate.getSourceNode(); if (null != source) { context.notifyCanvasElementUpdated(source); } final Node target = candidate.getTargetNode(); if (null != target) { context.notifyCanvasElementUpdated(target); } return buildResult(); }
|
DeleteCanvasConnectorCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { if (!checkShapeNotNull(context, candidate.getUUID())) { return buildResult(); } context.deregister(candidate); final Node source = candidate.getSourceNode(); if (null != source) { context.notifyCanvasElementUpdated(source); } final Node target = candidate.getTargetNode(); if (null != target) { context.notifyCanvasElementUpdated(target); } return buildResult(); } }
|
DeleteCanvasConnectorCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { if (!checkShapeNotNull(context, candidate.getUUID())) { return buildResult(); } context.deregister(candidate); final Node source = candidate.getSourceNode(); if (null != source) { context.notifyCanvasElementUpdated(source); } final Node target = candidate.getTargetNode(); if (null != target) { context.notifyCanvasElementUpdated(target); } return buildResult(); } DeleteCanvasConnectorCommand(final Edge candidate); }
|
DeleteCanvasConnectorCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { if (!checkShapeNotNull(context, candidate.getUUID())) { return buildResult(); } context.deregister(candidate); final Node source = candidate.getSourceNode(); if (null != source) { context.notifyCanvasElementUpdated(source); } final Node target = candidate.getTargetNode(); if (null != target) { context.notifyCanvasElementUpdated(target); } return buildResult(); } DeleteCanvasConnectorCommand(final Edge candidate); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); Edge getCandidate(); @Override String toString(); }
|
DeleteCanvasConnectorCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { if (!checkShapeNotNull(context, candidate.getUUID())) { return buildResult(); } context.deregister(candidate); final Node source = candidate.getSourceNode(); if (null != source) { context.notifyCanvasElementUpdated(source); } final Node target = candidate.getTargetNode(); if (null != target) { context.notifyCanvasElementUpdated(target); } return buildResult(); } DeleteCanvasConnectorCommand(final Edge candidate); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); Edge getCandidate(); @Override String toString(); }
|
@Test @SuppressWarnings("unchecked") public void testExecuteNullTargetNode() { when(candidate.getTargetNode()).thenReturn(null); final CommandResult<CanvasViolation> result = tested.execute(canvasHandler); assertNotEquals(CommandResult.Type.ERROR, result.getType()); verify(canvasHandler, times(1)).deregister(eq(candidate)); verify(canvasHandler, times(1)).notifyCanvasElementUpdated(eq(source)); verify(canvasHandler, never()).notifyCanvasElementUpdated(eq(target)); }
|
@Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { if (!checkShapeNotNull(context, candidate.getUUID())) { return buildResult(); } context.deregister(candidate); final Node source = candidate.getSourceNode(); if (null != source) { context.notifyCanvasElementUpdated(source); } final Node target = candidate.getTargetNode(); if (null != target) { context.notifyCanvasElementUpdated(target); } return buildResult(); }
|
DeleteCanvasConnectorCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { if (!checkShapeNotNull(context, candidate.getUUID())) { return buildResult(); } context.deregister(candidate); final Node source = candidate.getSourceNode(); if (null != source) { context.notifyCanvasElementUpdated(source); } final Node target = candidate.getTargetNode(); if (null != target) { context.notifyCanvasElementUpdated(target); } return buildResult(); } }
|
DeleteCanvasConnectorCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { if (!checkShapeNotNull(context, candidate.getUUID())) { return buildResult(); } context.deregister(candidate); final Node source = candidate.getSourceNode(); if (null != source) { context.notifyCanvasElementUpdated(source); } final Node target = candidate.getTargetNode(); if (null != target) { context.notifyCanvasElementUpdated(target); } return buildResult(); } DeleteCanvasConnectorCommand(final Edge candidate); }
|
DeleteCanvasConnectorCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { if (!checkShapeNotNull(context, candidate.getUUID())) { return buildResult(); } context.deregister(candidate); final Node source = candidate.getSourceNode(); if (null != source) { context.notifyCanvasElementUpdated(source); } final Node target = candidate.getTargetNode(); if (null != target) { context.notifyCanvasElementUpdated(target); } return buildResult(); } DeleteCanvasConnectorCommand(final Edge candidate); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); Edge getCandidate(); @Override String toString(); }
|
DeleteCanvasConnectorCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { if (!checkShapeNotNull(context, candidate.getUUID())) { return buildResult(); } context.deregister(candidate); final Node source = candidate.getSourceNode(); if (null != source) { context.notifyCanvasElementUpdated(source); } final Node target = candidate.getTargetNode(); if (null != target) { context.notifyCanvasElementUpdated(target); } return buildResult(); } DeleteCanvasConnectorCommand(final Edge candidate); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); Edge getCandidate(); @Override String toString(); }
|
@Test public void testExecuteNullShape() { when(canvas.getShape(EDGE_ID)).thenReturn(null); assertFalse(CommandUtils.isError(tested.execute(canvasHandler))); verify(canvasHandler, never()).deregister(eq(candidate)); }
|
@Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { if (!checkShapeNotNull(context, candidate.getUUID())) { return buildResult(); } context.deregister(candidate); final Node source = candidate.getSourceNode(); if (null != source) { context.notifyCanvasElementUpdated(source); } final Node target = candidate.getTargetNode(); if (null != target) { context.notifyCanvasElementUpdated(target); } return buildResult(); }
|
DeleteCanvasConnectorCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { if (!checkShapeNotNull(context, candidate.getUUID())) { return buildResult(); } context.deregister(candidate); final Node source = candidate.getSourceNode(); if (null != source) { context.notifyCanvasElementUpdated(source); } final Node target = candidate.getTargetNode(); if (null != target) { context.notifyCanvasElementUpdated(target); } return buildResult(); } }
|
DeleteCanvasConnectorCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { if (!checkShapeNotNull(context, candidate.getUUID())) { return buildResult(); } context.deregister(candidate); final Node source = candidate.getSourceNode(); if (null != source) { context.notifyCanvasElementUpdated(source); } final Node target = candidate.getTargetNode(); if (null != target) { context.notifyCanvasElementUpdated(target); } return buildResult(); } DeleteCanvasConnectorCommand(final Edge candidate); }
|
DeleteCanvasConnectorCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { if (!checkShapeNotNull(context, candidate.getUUID())) { return buildResult(); } context.deregister(candidate); final Node source = candidate.getSourceNode(); if (null != source) { context.notifyCanvasElementUpdated(source); } final Node target = candidate.getTargetNode(); if (null != target) { context.notifyCanvasElementUpdated(target); } return buildResult(); } DeleteCanvasConnectorCommand(final Edge candidate); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); Edge getCandidate(); @Override String toString(); }
|
DeleteCanvasConnectorCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { if (!checkShapeNotNull(context, candidate.getUUID())) { return buildResult(); } context.deregister(candidate); final Node source = candidate.getSourceNode(); if (null != source) { context.notifyCanvasElementUpdated(source); } final Node target = candidate.getTargetNode(); if (null != target) { context.notifyCanvasElementUpdated(target); } return buildResult(); } DeleteCanvasConnectorCommand(final Edge candidate); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); Edge getCandidate(); @Override String toString(); }
|
@Test @SuppressWarnings("unchecked") public void testExecuteSuccess() { tested = new UpdateCanvasElementPositionCommand(candidate, Point2D.create(0d, 0d)); CommandResult<CanvasViolation> result = tested.execute(canvasHandler); assertNotEquals(CommandResult.Type.ERROR, result.getType()); verify(canvasHandler, times(1)).updateElementPosition(eq(candidate), any(MutationContext.class)); }
|
@Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { final CommandResult<CanvasViolation> allowResult = allow(context); if (isError(allowResult)) { return allowResult; } context.updateElementPosition(element, MutationContext.STATIC); moveConnectorsToTop(context); return allowResult; }
|
UpdateCanvasElementPositionCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { final CommandResult<CanvasViolation> allowResult = allow(context); if (isError(allowResult)) { return allowResult; } context.updateElementPosition(element, MutationContext.STATIC); moveConnectorsToTop(context); return allowResult; } }
|
UpdateCanvasElementPositionCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { final CommandResult<CanvasViolation> allowResult = allow(context); if (isError(allowResult)) { return allowResult; } context.updateElementPosition(element, MutationContext.STATIC); moveConnectorsToTop(context); return allowResult; } UpdateCanvasElementPositionCommand(final Element<? extends View<?>> element,
final Point2D location); }
|
UpdateCanvasElementPositionCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { final CommandResult<CanvasViolation> allowResult = allow(context); if (isError(allowResult)) { return allowResult; } context.updateElementPosition(element, MutationContext.STATIC); moveConnectorsToTop(context); return allowResult; } UpdateCanvasElementPositionCommand(final Element<? extends View<?>> element,
final Point2D location); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); Element<? extends View<?>> getElement(); Point2D getLocation(); @Override String toString(); }
|
UpdateCanvasElementPositionCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { final CommandResult<CanvasViolation> allowResult = allow(context); if (isError(allowResult)) { return allowResult; } context.updateElementPosition(element, MutationContext.STATIC); moveConnectorsToTop(context); return allowResult; } UpdateCanvasElementPositionCommand(final Element<? extends View<?>> element,
final Point2D location); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); Element<? extends View<?>> getElement(); Point2D getLocation(); @Override String toString(); }
|
@Test @SuppressWarnings("unchecked") public void testExecute() { final CommandResult<CanvasViolation> result = tested.execute(canvasHandler); assertNotEquals(CommandResult.Type.ERROR, result.getType()); verify(canvasHandler, times(1)).register(eq(SHAPE_SET_ID), eq(candidate)); verify(canvasHandler, times(1)).dock(eq(parent), eq(candidate)); verify(canvasHandler, times(1)).applyElementMutation(eq(candidate), any(MutationContext.class)); verify(canvasHandler, times(1)).applyElementMutation(eq(parent), any(MutationContext.class)); verify(canvasHandler, never()).addChild(eq(parent), eq(candidate)); }
|
@Override @SuppressWarnings("unchecked") public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { context.register(ssid, candidate); context.applyElementMutation(candidate, MutationContext.STATIC); context.applyElementMutation(parent, MutationContext.STATIC); if (!context.dock(parent, candidate)) { return new CanvasCommandResultBuilder() .addViolation(CanvasViolationImpl.Builder .build(new DockingRuleViolation(parent.getUUID(), candidate.getUUID()))) .build(); } return buildResult(); }
|
AddCanvasDockedNodeCommand extends AbstractCanvasCommand { @Override @SuppressWarnings("unchecked") public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { context.register(ssid, candidate); context.applyElementMutation(candidate, MutationContext.STATIC); context.applyElementMutation(parent, MutationContext.STATIC); if (!context.dock(parent, candidate)) { return new CanvasCommandResultBuilder() .addViolation(CanvasViolationImpl.Builder .build(new DockingRuleViolation(parent.getUUID(), candidate.getUUID()))) .build(); } return buildResult(); } }
|
AddCanvasDockedNodeCommand extends AbstractCanvasCommand { @Override @SuppressWarnings("unchecked") public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { context.register(ssid, candidate); context.applyElementMutation(candidate, MutationContext.STATIC); context.applyElementMutation(parent, MutationContext.STATIC); if (!context.dock(parent, candidate)) { return new CanvasCommandResultBuilder() .addViolation(CanvasViolationImpl.Builder .build(new DockingRuleViolation(parent.getUUID(), candidate.getUUID()))) .build(); } return buildResult(); } AddCanvasDockedNodeCommand(final Node parent,
final Node candidate,
final String ssid); }
|
AddCanvasDockedNodeCommand extends AbstractCanvasCommand { @Override @SuppressWarnings("unchecked") public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { context.register(ssid, candidate); context.applyElementMutation(candidate, MutationContext.STATIC); context.applyElementMutation(parent, MutationContext.STATIC); if (!context.dock(parent, candidate)) { return new CanvasCommandResultBuilder() .addViolation(CanvasViolationImpl.Builder .build(new DockingRuleViolation(parent.getUUID(), candidate.getUUID()))) .build(); } return buildResult(); } AddCanvasDockedNodeCommand(final Node parent,
final Node candidate,
final String ssid); @Override @SuppressWarnings("unchecked") CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); @Override String toString(); }
|
AddCanvasDockedNodeCommand extends AbstractCanvasCommand { @Override @SuppressWarnings("unchecked") public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { context.register(ssid, candidate); context.applyElementMutation(candidate, MutationContext.STATIC); context.applyElementMutation(parent, MutationContext.STATIC); if (!context.dock(parent, candidate)) { return new CanvasCommandResultBuilder() .addViolation(CanvasViolationImpl.Builder .build(new DockingRuleViolation(parent.getUUID(), candidate.getUUID()))) .build(); } return buildResult(); } AddCanvasDockedNodeCommand(final Node parent,
final Node candidate,
final String ssid); @Override @SuppressWarnings("unchecked") CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); @Override String toString(); }
|
@Test public void testExecute() { cloneCanvasNodeCommand.execute(canvasHandler); AbstractCompositeCommand<AbstractCanvasHandler, CanvasViolation> commands = cloneCanvasNodeCommand.getCommands(); assertEquals(commands.size(), 6); assertTrue(commands.getCommands().stream() .filter(command -> command instanceof CloneCanvasNodeCommand) .map(command -> (CloneCanvasNodeCommand) command) .allMatch(command -> Objects.equals(command.getCandidate(), graphInstance.startNode) || Objects.equals(command.getCandidate(), graphInstance.intermNode) || Objects.equals(command.getCandidate(), graphInstance.endNode))); assertTrue(commands.getCommands().stream() .filter(command -> command instanceof AddCanvasConnectorCommand) .map(command -> (AddCanvasConnectorCommand) command) .allMatch(command -> Objects.equals(command.getCandidate(), graphInstance.edge1) || Objects.equals(command.getCandidate(), graphInstance.edge2))); }
|
@Override public CommandResult<CanvasViolation> execute(AbstractCanvasHandler context) { commands = new CompositeCommand.Builder<AbstractCanvasHandler, CanvasViolation>() .reverse() .build(); commands.addCommand(createAddCanvasChildNodeCommand(getParent(), getCandidate(), getShapeSetId())); if (GraphUtils.hasChildren(getCandidate())) { Graph graph = context.getGraphIndex().getGraph(); List<Edge> clonedEdges = new ArrayList<>(); childrenTraverseProcessor.get() .setRootUUID(getCandidate().getUUID()) .traverse(graph, new AbstractChildrenTraverseCallback<Node<View, Edge>, Edge<Child, Node>>() { @Override public boolean startNodeTraversal(List<Node<View, Edge>> parents, Node<View, Edge> node) { commands.addCommand(createCloneCanvasNodeCommand(getCandidate(), node, getShapeSetId())); clonedEdges.addAll(node.getOutEdges()); return false; } }); clonedEdges.stream() .filter(edge -> edge.getContent() instanceof Dock) .forEach(edge -> commands.addCommand(new CanvasDockNodeCommand(edge.getSourceNode(), edge.getTargetNode()))); clonedEdges .stream() .filter(edge -> edge.getContent() instanceof ViewConnector) .forEach(edge -> commands.addCommand(new AddCanvasConnectorCommand((Edge) edge, getShapeSetId()))); } if (GraphUtils.hasDockedNodes(getCandidate())) { List<Edge> edges = getCandidate().getOutEdges(); edges.stream() .filter(edge -> edge.getContent() instanceof Dock) .map(edge -> edge.getTargetNode()) .forEach(targetNode -> { commands.addCommand(new AddCanvasChildNodeCommand(getParent(), targetNode, getShapeSetId())); commands.addCommand(new CanvasDockNodeCommand(getCandidate(), targetNode)); }); } return commands.execute(context); }
|
CloneCanvasNodeCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> execute(AbstractCanvasHandler context) { commands = new CompositeCommand.Builder<AbstractCanvasHandler, CanvasViolation>() .reverse() .build(); commands.addCommand(createAddCanvasChildNodeCommand(getParent(), getCandidate(), getShapeSetId())); if (GraphUtils.hasChildren(getCandidate())) { Graph graph = context.getGraphIndex().getGraph(); List<Edge> clonedEdges = new ArrayList<>(); childrenTraverseProcessor.get() .setRootUUID(getCandidate().getUUID()) .traverse(graph, new AbstractChildrenTraverseCallback<Node<View, Edge>, Edge<Child, Node>>() { @Override public boolean startNodeTraversal(List<Node<View, Edge>> parents, Node<View, Edge> node) { commands.addCommand(createCloneCanvasNodeCommand(getCandidate(), node, getShapeSetId())); clonedEdges.addAll(node.getOutEdges()); return false; } }); clonedEdges.stream() .filter(edge -> edge.getContent() instanceof Dock) .forEach(edge -> commands.addCommand(new CanvasDockNodeCommand(edge.getSourceNode(), edge.getTargetNode()))); clonedEdges .stream() .filter(edge -> edge.getContent() instanceof ViewConnector) .forEach(edge -> commands.addCommand(new AddCanvasConnectorCommand((Edge) edge, getShapeSetId()))); } if (GraphUtils.hasDockedNodes(getCandidate())) { List<Edge> edges = getCandidate().getOutEdges(); edges.stream() .filter(edge -> edge.getContent() instanceof Dock) .map(edge -> edge.getTargetNode()) .forEach(targetNode -> { commands.addCommand(new AddCanvasChildNodeCommand(getParent(), targetNode, getShapeSetId())); commands.addCommand(new CanvasDockNodeCommand(getCandidate(), targetNode)); }); } return commands.execute(context); } }
|
CloneCanvasNodeCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> execute(AbstractCanvasHandler context) { commands = new CompositeCommand.Builder<AbstractCanvasHandler, CanvasViolation>() .reverse() .build(); commands.addCommand(createAddCanvasChildNodeCommand(getParent(), getCandidate(), getShapeSetId())); if (GraphUtils.hasChildren(getCandidate())) { Graph graph = context.getGraphIndex().getGraph(); List<Edge> clonedEdges = new ArrayList<>(); childrenTraverseProcessor.get() .setRootUUID(getCandidate().getUUID()) .traverse(graph, new AbstractChildrenTraverseCallback<Node<View, Edge>, Edge<Child, Node>>() { @Override public boolean startNodeTraversal(List<Node<View, Edge>> parents, Node<View, Edge> node) { commands.addCommand(createCloneCanvasNodeCommand(getCandidate(), node, getShapeSetId())); clonedEdges.addAll(node.getOutEdges()); return false; } }); clonedEdges.stream() .filter(edge -> edge.getContent() instanceof Dock) .forEach(edge -> commands.addCommand(new CanvasDockNodeCommand(edge.getSourceNode(), edge.getTargetNode()))); clonedEdges .stream() .filter(edge -> edge.getContent() instanceof ViewConnector) .forEach(edge -> commands.addCommand(new AddCanvasConnectorCommand((Edge) edge, getShapeSetId()))); } if (GraphUtils.hasDockedNodes(getCandidate())) { List<Edge> edges = getCandidate().getOutEdges(); edges.stream() .filter(edge -> edge.getContent() instanceof Dock) .map(edge -> edge.getTargetNode()) .forEach(targetNode -> { commands.addCommand(new AddCanvasChildNodeCommand(getParent(), targetNode, getShapeSetId())); commands.addCommand(new CanvasDockNodeCommand(getCandidate(), targetNode)); }); } return commands.execute(context); } CloneCanvasNodeCommand(Node parent, Node candidate, String shapeSetId, final ManagedInstance<ChildrenTraverseProcessor> childrenTraverseProcessor); }
|
CloneCanvasNodeCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> execute(AbstractCanvasHandler context) { commands = new CompositeCommand.Builder<AbstractCanvasHandler, CanvasViolation>() .reverse() .build(); commands.addCommand(createAddCanvasChildNodeCommand(getParent(), getCandidate(), getShapeSetId())); if (GraphUtils.hasChildren(getCandidate())) { Graph graph = context.getGraphIndex().getGraph(); List<Edge> clonedEdges = new ArrayList<>(); childrenTraverseProcessor.get() .setRootUUID(getCandidate().getUUID()) .traverse(graph, new AbstractChildrenTraverseCallback<Node<View, Edge>, Edge<Child, Node>>() { @Override public boolean startNodeTraversal(List<Node<View, Edge>> parents, Node<View, Edge> node) { commands.addCommand(createCloneCanvasNodeCommand(getCandidate(), node, getShapeSetId())); clonedEdges.addAll(node.getOutEdges()); return false; } }); clonedEdges.stream() .filter(edge -> edge.getContent() instanceof Dock) .forEach(edge -> commands.addCommand(new CanvasDockNodeCommand(edge.getSourceNode(), edge.getTargetNode()))); clonedEdges .stream() .filter(edge -> edge.getContent() instanceof ViewConnector) .forEach(edge -> commands.addCommand(new AddCanvasConnectorCommand((Edge) edge, getShapeSetId()))); } if (GraphUtils.hasDockedNodes(getCandidate())) { List<Edge> edges = getCandidate().getOutEdges(); edges.stream() .filter(edge -> edge.getContent() instanceof Dock) .map(edge -> edge.getTargetNode()) .forEach(targetNode -> { commands.addCommand(new AddCanvasChildNodeCommand(getParent(), targetNode, getShapeSetId())); commands.addCommand(new CanvasDockNodeCommand(getCandidate(), targetNode)); }); } return commands.execute(context); } CloneCanvasNodeCommand(Node parent, Node candidate, String shapeSetId, final ManagedInstance<ChildrenTraverseProcessor> childrenTraverseProcessor); AbstractCanvasCommand createAddCanvasChildNodeCommand(Node parent, Node candidate, String shapeSetId); CloneCanvasNodeCommand createCloneCanvasNodeCommand(Node parent, Node candidate, String shapeSetId); @Override CommandResult<CanvasViolation> execute(AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(AbstractCanvasHandler context); ManagedInstance<ChildrenTraverseProcessor> getChildrenTraverseProcessor(); Node getParent(); Node getCandidate(); String getShapeSetId(); @Override String toString(); }
|
CloneCanvasNodeCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> execute(AbstractCanvasHandler context) { commands = new CompositeCommand.Builder<AbstractCanvasHandler, CanvasViolation>() .reverse() .build(); commands.addCommand(createAddCanvasChildNodeCommand(getParent(), getCandidate(), getShapeSetId())); if (GraphUtils.hasChildren(getCandidate())) { Graph graph = context.getGraphIndex().getGraph(); List<Edge> clonedEdges = new ArrayList<>(); childrenTraverseProcessor.get() .setRootUUID(getCandidate().getUUID()) .traverse(graph, new AbstractChildrenTraverseCallback<Node<View, Edge>, Edge<Child, Node>>() { @Override public boolean startNodeTraversal(List<Node<View, Edge>> parents, Node<View, Edge> node) { commands.addCommand(createCloneCanvasNodeCommand(getCandidate(), node, getShapeSetId())); clonedEdges.addAll(node.getOutEdges()); return false; } }); clonedEdges.stream() .filter(edge -> edge.getContent() instanceof Dock) .forEach(edge -> commands.addCommand(new CanvasDockNodeCommand(edge.getSourceNode(), edge.getTargetNode()))); clonedEdges .stream() .filter(edge -> edge.getContent() instanceof ViewConnector) .forEach(edge -> commands.addCommand(new AddCanvasConnectorCommand((Edge) edge, getShapeSetId()))); } if (GraphUtils.hasDockedNodes(getCandidate())) { List<Edge> edges = getCandidate().getOutEdges(); edges.stream() .filter(edge -> edge.getContent() instanceof Dock) .map(edge -> edge.getTargetNode()) .forEach(targetNode -> { commands.addCommand(new AddCanvasChildNodeCommand(getParent(), targetNode, getShapeSetId())); commands.addCommand(new CanvasDockNodeCommand(getCandidate(), targetNode)); }); } return commands.execute(context); } CloneCanvasNodeCommand(Node parent, Node candidate, String shapeSetId, final ManagedInstance<ChildrenTraverseProcessor> childrenTraverseProcessor); AbstractCanvasCommand createAddCanvasChildNodeCommand(Node parent, Node candidate, String shapeSetId); CloneCanvasNodeCommand createCloneCanvasNodeCommand(Node parent, Node candidate, String shapeSetId); @Override CommandResult<CanvasViolation> execute(AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(AbstractCanvasHandler context); ManagedInstance<ChildrenTraverseProcessor> getChildrenTraverseProcessor(); Node getParent(); Node getCandidate(); String getShapeSetId(); @Override String toString(); }
|
@Test public void testUndo() { testExecute(); cloneCanvasNodeCommand.undo(canvasHandler); verify(canvasHandler, atLeastOnce()).removeChild(parent, candidate); verify(canvasHandler, atLeastOnce()).deregister(candidate); verify(canvasHandler, atLeastOnce()).removeChild(graphInstance.parentNode, graphInstance.startNode); verify(canvasHandler, atLeastOnce()).deregister(graphInstance.startNode); verify(canvasHandler, atLeastOnce()).removeChild(graphInstance.parentNode, graphInstance.intermNode); verify(canvasHandler, atLeastOnce()).deregister(graphInstance.intermNode); verify(canvasHandler, atLeastOnce()).removeChild(graphInstance.parentNode, graphInstance.endNode); verify(canvasHandler, atLeastOnce()).deregister(graphInstance.endNode); verify(canvasHandler, atLeastOnce()).deregister(graphInstance.edge1); verify(canvasHandler, atLeastOnce()).deregister(graphInstance.edge2); }
|
@Override public CommandResult<CanvasViolation> undo(AbstractCanvasHandler context) { return commands.undo(context); }
|
CloneCanvasNodeCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> undo(AbstractCanvasHandler context) { return commands.undo(context); } }
|
CloneCanvasNodeCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> undo(AbstractCanvasHandler context) { return commands.undo(context); } CloneCanvasNodeCommand(Node parent, Node candidate, String shapeSetId, final ManagedInstance<ChildrenTraverseProcessor> childrenTraverseProcessor); }
|
CloneCanvasNodeCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> undo(AbstractCanvasHandler context) { return commands.undo(context); } CloneCanvasNodeCommand(Node parent, Node candidate, String shapeSetId, final ManagedInstance<ChildrenTraverseProcessor> childrenTraverseProcessor); AbstractCanvasCommand createAddCanvasChildNodeCommand(Node parent, Node candidate, String shapeSetId); CloneCanvasNodeCommand createCloneCanvasNodeCommand(Node parent, Node candidate, String shapeSetId); @Override CommandResult<CanvasViolation> execute(AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(AbstractCanvasHandler context); ManagedInstance<ChildrenTraverseProcessor> getChildrenTraverseProcessor(); Node getParent(); Node getCandidate(); String getShapeSetId(); @Override String toString(); }
|
CloneCanvasNodeCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> undo(AbstractCanvasHandler context) { return commands.undo(context); } CloneCanvasNodeCommand(Node parent, Node candidate, String shapeSetId, final ManagedInstance<ChildrenTraverseProcessor> childrenTraverseProcessor); AbstractCanvasCommand createAddCanvasChildNodeCommand(Node parent, Node candidate, String shapeSetId); CloneCanvasNodeCommand createCloneCanvasNodeCommand(Node parent, Node candidate, String shapeSetId); @Override CommandResult<CanvasViolation> execute(AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(AbstractCanvasHandler context); ManagedInstance<ChildrenTraverseProcessor> getChildrenTraverseProcessor(); Node getParent(); Node getCandidate(); String getShapeSetId(); @Override String toString(); }
|
@Test @SuppressWarnings("unchecked") public void testExecute() { final CommandResult<CanvasViolation> result = tested.execute(canvasHandler); assertNotEquals(CommandResult.Type.ERROR, result.getType()); verify(canvasHandler, times(1)).removeChild(eq(parent), eq(candidate)); verify(canvasHandler, times(1)).deregister(eq(candidate)); verify(canvasHandler, times(1)).applyElementMutation(eq(parent), any(MutationContext.class)); }
|
@Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { if (null != parent) { context.removeChild(parent, candidate); } context.deregister(candidate); if (null != parent) { context.applyElementMutation(parent, MutationContext.STATIC); } return buildResult(); }
|
DeleteCanvasNodeCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { if (null != parent) { context.removeChild(parent, candidate); } context.deregister(candidate); if (null != parent) { context.applyElementMutation(parent, MutationContext.STATIC); } return buildResult(); } }
|
DeleteCanvasNodeCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { if (null != parent) { context.removeChild(parent, candidate); } context.deregister(candidate); if (null != parent) { context.applyElementMutation(parent, MutationContext.STATIC); } return buildResult(); } DeleteCanvasNodeCommand(final Node candidate); DeleteCanvasNodeCommand(final Node candidate,
final Node parent); }
|
DeleteCanvasNodeCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { if (null != parent) { context.removeChild(parent, candidate); } context.deregister(candidate); if (null != parent) { context.applyElementMutation(parent, MutationContext.STATIC); } return buildResult(); } DeleteCanvasNodeCommand(final Node candidate); DeleteCanvasNodeCommand(final Node candidate,
final Node parent); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); @SuppressWarnings("unchecked") static Node getParent(final Node node); static boolean isChildEdge(final Edge edge); static boolean isDockEdge(final Edge edge); Node getCandidate(); @Override String toString(); }
|
DeleteCanvasNodeCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { if (null != parent) { context.removeChild(parent, candidate); } context.deregister(candidate); if (null != parent) { context.applyElementMutation(parent, MutationContext.STATIC); } return buildResult(); } DeleteCanvasNodeCommand(final Node candidate); DeleteCanvasNodeCommand(final Node candidate,
final Node parent); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); @SuppressWarnings("unchecked") static Node getParent(final Node node); static boolean isChildEdge(final Edge edge); static boolean isDockEdge(final Edge edge); Node getCandidate(); @Override String toString(); }
|
@Test public void testUndo() { tested.undo(canvasHandler); verify(canvasHandler).register(SHAPE_SET_ID, candidate); verify(canvasHandler).addChild(parent, candidate); }
|
@Override public CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context) { final String ssid = context.getDiagram().getMetadata().getShapeSetId(); final AbstractCanvasCommand command = createUndoCommand(parent, candidate, ssid); return command.execute(context); }
|
DeleteCanvasNodeCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context) { final String ssid = context.getDiagram().getMetadata().getShapeSetId(); final AbstractCanvasCommand command = createUndoCommand(parent, candidate, ssid); return command.execute(context); } }
|
DeleteCanvasNodeCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context) { final String ssid = context.getDiagram().getMetadata().getShapeSetId(); final AbstractCanvasCommand command = createUndoCommand(parent, candidate, ssid); return command.execute(context); } DeleteCanvasNodeCommand(final Node candidate); DeleteCanvasNodeCommand(final Node candidate,
final Node parent); }
|
DeleteCanvasNodeCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context) { final String ssid = context.getDiagram().getMetadata().getShapeSetId(); final AbstractCanvasCommand command = createUndoCommand(parent, candidate, ssid); return command.execute(context); } DeleteCanvasNodeCommand(final Node candidate); DeleteCanvasNodeCommand(final Node candidate,
final Node parent); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); @SuppressWarnings("unchecked") static Node getParent(final Node node); static boolean isChildEdge(final Edge edge); static boolean isDockEdge(final Edge edge); Node getCandidate(); @Override String toString(); }
|
DeleteCanvasNodeCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context) { final String ssid = context.getDiagram().getMetadata().getShapeSetId(); final AbstractCanvasCommand command = createUndoCommand(parent, candidate, ssid); return command.execute(context); } DeleteCanvasNodeCommand(final Node candidate); DeleteCanvasNodeCommand(final Node candidate,
final Node parent); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); @SuppressWarnings("unchecked") static Node getParent(final Node node); static boolean isChildEdge(final Edge edge); static boolean isDockEdge(final Edge edge); Node getCandidate(); @Override String toString(); }
|
@Test @SuppressWarnings("unchecked") public void testInitialize() { AbstractCompositeCommand<AbstractCanvasHandler, CanvasViolation> command = tested.initialize(canvasHandler); assertNotNull(command); final List commands = command.getCommands(); assertNotNull(commands); assertEquals(6, commands.size()); assertTrue(commands.get(0) instanceof UpdateElementPropertyCommand); final UpdateElementPropertyCommand wPropertyCommand = (UpdateElementPropertyCommand) commands.get(0); assertEquals(element, wPropertyCommand.getElement()); assertEquals(W_PROPERTY_ID, wPropertyCommand.getField()); assertEquals(boundingBox.getWidth(), wPropertyCommand.getValue()); assertTrue(commands.get(1) instanceof UpdateElementPropertyCommand); final UpdateElementPropertyCommand hPropertyCommand = (UpdateElementPropertyCommand) commands.get(1); assertEquals(element, hPropertyCommand.getElement()); assertEquals(H_PROPERTY_ID, hPropertyCommand.getField()); assertEquals(boundingBox.getHeight(), hPropertyCommand.getValue()); assertTrue(commands.get(2) instanceof UpdateElementPropertyCommand); final UpdateElementPropertyCommand rPropertyCommand = (UpdateElementPropertyCommand) commands.get(2); assertEquals(element, rPropertyCommand.getElement()); assertEquals(R_PROPERTY_ID, rPropertyCommand.getField()); assertEquals(50d, rPropertyCommand.getValue()); verify(magnetLocationProvider, times(1)).apply(eq(shape), eq(0)); verify(magnetLocationProvider, times(1)).apply(eq(shape), eq(1)); }
|
@Override @SuppressWarnings("unchecked") protected AbstractCompositeCommand<AbstractCanvasHandler, CanvasViolation> initialize(final AbstractCanvasHandler context) { super.initialize(context); widthBefore = candidate.getContent().getBounds().getWidth(); heightBefore = candidate.getContent().getBounds().getHeight(); final double w = boundingBox.getMaxX(); final double h = boundingBox.getMaxY(); final List<Command<AbstractCanvasHandler, CanvasViolation>> commands = getResizeCommands(context, w, h); if (null != commands) { final Node<View<?>, Edge> node = (Node<View<?>, Edge>) candidate; commands.forEach(this::addCommand); if (GraphUtils.hasDockedNodes(node)) { updateDockedNodesPosition(context, node); } if (GraphUtils.hasConnections(node)) { updateConnectionsPositions(context, node); } } return this; }
|
ResizeNodeCommand extends AbstractCanvasCompositeCommand { @Override @SuppressWarnings("unchecked") protected AbstractCompositeCommand<AbstractCanvasHandler, CanvasViolation> initialize(final AbstractCanvasHandler context) { super.initialize(context); widthBefore = candidate.getContent().getBounds().getWidth(); heightBefore = candidate.getContent().getBounds().getHeight(); final double w = boundingBox.getMaxX(); final double h = boundingBox.getMaxY(); final List<Command<AbstractCanvasHandler, CanvasViolation>> commands = getResizeCommands(context, w, h); if (null != commands) { final Node<View<?>, Edge> node = (Node<View<?>, Edge>) candidate; commands.forEach(this::addCommand); if (GraphUtils.hasDockedNodes(node)) { updateDockedNodesPosition(context, node); } if (GraphUtils.hasConnections(node)) { updateConnectionsPositions(context, node); } } return this; } }
|
ResizeNodeCommand extends AbstractCanvasCompositeCommand { @Override @SuppressWarnings("unchecked") protected AbstractCompositeCommand<AbstractCanvasHandler, CanvasViolation> initialize(final AbstractCanvasHandler context) { super.initialize(context); widthBefore = candidate.getContent().getBounds().getWidth(); heightBefore = candidate.getContent().getBounds().getHeight(); final double w = boundingBox.getMaxX(); final double h = boundingBox.getMaxY(); final List<Command<AbstractCanvasHandler, CanvasViolation>> commands = getResizeCommands(context, w, h); if (null != commands) { final Node<View<?>, Edge> node = (Node<View<?>, Edge>) candidate; commands.forEach(this::addCommand); if (GraphUtils.hasDockedNodes(node)) { updateDockedNodesPosition(context, node); } if (GraphUtils.hasConnections(node)) { updateConnectionsPositions(context, node); } } return this; } ResizeNodeCommand(final Element<? extends View> candidate,
final BoundingBox boundingBox,
final BiFunction<Shape, Integer, Point2D> magnetLocationProvider); ResizeNodeCommand(final Element<? extends View> candidate,
final BoundingBox boundingBox,
final BiFunction<Shape, Integer, Point2D> magnetLocationProvider,
final Consumer<Shape> onResize); }
|
ResizeNodeCommand extends AbstractCanvasCompositeCommand { @Override @SuppressWarnings("unchecked") protected AbstractCompositeCommand<AbstractCanvasHandler, CanvasViolation> initialize(final AbstractCanvasHandler context) { super.initialize(context); widthBefore = candidate.getContent().getBounds().getWidth(); heightBefore = candidate.getContent().getBounds().getHeight(); final double w = boundingBox.getMaxX(); final double h = boundingBox.getMaxY(); final List<Command<AbstractCanvasHandler, CanvasViolation>> commands = getResizeCommands(context, w, h); if (null != commands) { final Node<View<?>, Edge> node = (Node<View<?>, Edge>) candidate; commands.forEach(this::addCommand); if (GraphUtils.hasDockedNodes(node)) { updateDockedNodesPosition(context, node); } if (GraphUtils.hasConnections(node)) { updateConnectionsPositions(context, node); } } return this; } ResizeNodeCommand(final Element<? extends View> candidate,
final BoundingBox boundingBox,
final BiFunction<Shape, Integer, Point2D> magnetLocationProvider); ResizeNodeCommand(final Element<? extends View> candidate,
final BoundingBox boundingBox,
final BiFunction<Shape, Integer, Point2D> magnetLocationProvider,
final Consumer<Shape> onResize); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(AbstractCanvasHandler context); Element<? extends View> getCandidate(); BoundingBox getBoundingBox(); BiFunction<Shape, Integer, Point2D> getMagnetLocationProvider(); Consumer<Shape> getOnResize(); @Override String toString(); }
|
ResizeNodeCommand extends AbstractCanvasCompositeCommand { @Override @SuppressWarnings("unchecked") protected AbstractCompositeCommand<AbstractCanvasHandler, CanvasViolation> initialize(final AbstractCanvasHandler context) { super.initialize(context); widthBefore = candidate.getContent().getBounds().getWidth(); heightBefore = candidate.getContent().getBounds().getHeight(); final double w = boundingBox.getMaxX(); final double h = boundingBox.getMaxY(); final List<Command<AbstractCanvasHandler, CanvasViolation>> commands = getResizeCommands(context, w, h); if (null != commands) { final Node<View<?>, Edge> node = (Node<View<?>, Edge>) candidate; commands.forEach(this::addCommand); if (GraphUtils.hasDockedNodes(node)) { updateDockedNodesPosition(context, node); } if (GraphUtils.hasConnections(node)) { updateConnectionsPositions(context, node); } } return this; } ResizeNodeCommand(final Element<? extends View> candidate,
final BoundingBox boundingBox,
final BiFunction<Shape, Integer, Point2D> magnetLocationProvider); ResizeNodeCommand(final Element<? extends View> candidate,
final BoundingBox boundingBox,
final BiFunction<Shape, Integer, Point2D> magnetLocationProvider,
final Consumer<Shape> onResize); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(AbstractCanvasHandler context); Element<? extends View> getCandidate(); BoundingBox getBoundingBox(); BiFunction<Shape, Integer, Point2D> getMagnetLocationProvider(); Consumer<Shape> getOnResize(); @Override String toString(); }
|
@Test public void testShow() { final PopupEditorControls editor = mock(PopupEditorControls.class); final int x = 10; final int y = 20; final HTMLElement element = mock(HTMLElement.class); doReturn(element).when(view).getElement(); final CSSStyleDeclaration style = mock(CSSStyleDeclaration.class); when(element.getStyle()).thenReturn(style); view.show(editor, x, y); verify(style).setProperty(LEFT, x + PX); verify(style).setProperty(TOP, y + PX); verify(view).setOnClosedByKeyboardCallback(editor); verify(editor).show(); }
|
@Override public void show(final PopupEditorControls editor, final int x, final int y) { DOMUtil.removeAllChildren(cellEditorControlsContainer); cellEditorControlsContainer.appendChild(editor.getElement()); final CSSStyleDeclaration style = getElement().getStyle(); style.setProperty(LEFT, x + PX); style.setProperty(TOP, y + PX); setActiveEditor(Optional.of(editor)); setOnClosedByKeyboardCallback(editor); editor.show(); }
|
CellEditorControlsViewImpl implements CellEditorControlsView { @Override public void show(final PopupEditorControls editor, final int x, final int y) { DOMUtil.removeAllChildren(cellEditorControlsContainer); cellEditorControlsContainer.appendChild(editor.getElement()); final CSSStyleDeclaration style = getElement().getStyle(); style.setProperty(LEFT, x + PX); style.setProperty(TOP, y + PX); setActiveEditor(Optional.of(editor)); setOnClosedByKeyboardCallback(editor); editor.show(); } }
|
CellEditorControlsViewImpl implements CellEditorControlsView { @Override public void show(final PopupEditorControls editor, final int x, final int y) { DOMUtil.removeAllChildren(cellEditorControlsContainer); cellEditorControlsContainer.appendChild(editor.getElement()); final CSSStyleDeclaration style = getElement().getStyle(); style.setProperty(LEFT, x + PX); style.setProperty(TOP, y + PX); setActiveEditor(Optional.of(editor)); setOnClosedByKeyboardCallback(editor); editor.show(); } CellEditorControlsViewImpl(); @Inject CellEditorControlsViewImpl(final Document document,
final Div cellEditorControls,
final Div cellEditorControlsContainer); }
|
CellEditorControlsViewImpl implements CellEditorControlsView { @Override public void show(final PopupEditorControls editor, final int x, final int y) { DOMUtil.removeAllChildren(cellEditorControlsContainer); cellEditorControlsContainer.appendChild(editor.getElement()); final CSSStyleDeclaration style = getElement().getStyle(); style.setProperty(LEFT, x + PX); style.setProperty(TOP, y + PX); setActiveEditor(Optional.of(editor)); setOnClosedByKeyboardCallback(editor); editor.show(); } CellEditorControlsViewImpl(); @Inject CellEditorControlsViewImpl(final Document document,
final Div cellEditorControls,
final Div cellEditorControlsContainer); Optional<PopupEditorControls> getActiveEditor(); void setActiveEditor(final Optional<PopupEditorControls> activeEditor); @PostConstruct void setup(); @PreDestroy void destroy(); @Override void show(final PopupEditorControls editor,
final int x,
final int y); @Override void hide(); }
|
CellEditorControlsViewImpl implements CellEditorControlsView { @Override public void show(final PopupEditorControls editor, final int x, final int y) { DOMUtil.removeAllChildren(cellEditorControlsContainer); cellEditorControlsContainer.appendChild(editor.getElement()); final CSSStyleDeclaration style = getElement().getStyle(); style.setProperty(LEFT, x + PX); style.setProperty(TOP, y + PX); setActiveEditor(Optional.of(editor)); setOnClosedByKeyboardCallback(editor); editor.show(); } CellEditorControlsViewImpl(); @Inject CellEditorControlsViewImpl(final Document document,
final Div cellEditorControls,
final Div cellEditorControlsContainer); Optional<PopupEditorControls> getActiveEditor(); void setActiveEditor(final Optional<PopupEditorControls> activeEditor); @PostConstruct void setup(); @PreDestroy void destroy(); @Override void show(final PopupEditorControls editor,
final int x,
final int y); @Override void hide(); static final String LEFT; static final String TOP; }
|
@Test @SuppressWarnings("unchecked") public void testPostOperation() { CommandResult<CanvasViolation> result = CanvasCommandResultBuilder.SUCCESS; CommandResult<CanvasViolation> cascasded = tested.postOperation(canvasHandler, result, 100, 200); assertEquals(result, cascasded); verify(onResize, times(1)).accept(eq(shape)); ArgumentCaptor<Bounds> boundsArgumentCaptor = ArgumentCaptor.forClass(Bounds.class); verify(elementContent, times(1)).setBounds(boundsArgumentCaptor.capture()); assertEquals(Bounds.create(10, 20, 110, 220), boundsArgumentCaptor.getValue()); }
|
CommandResult<CanvasViolation> postOperation(final AbstractCanvasHandler context, final CommandResult<CanvasViolation> result, final double width, final double height) { if (!CommandUtils.isError(result)) { final Point2D current = GraphUtils.getPosition(candidate.getContent()); final Bounds newBounds = Bounds.create(current.getX(), current.getY(), current.getX() + width, current.getY() + height); candidate.getContent().setBounds(newBounds); final ShapeView shapeView = getShape(context, candidate.getUUID()).getShapeView(); ShapeUtils.setSizeFromBoundingBox(shapeView, width, height); onResize.accept(getShape(context, candidate.getUUID())); } return result; }
|
ResizeNodeCommand extends AbstractCanvasCompositeCommand { CommandResult<CanvasViolation> postOperation(final AbstractCanvasHandler context, final CommandResult<CanvasViolation> result, final double width, final double height) { if (!CommandUtils.isError(result)) { final Point2D current = GraphUtils.getPosition(candidate.getContent()); final Bounds newBounds = Bounds.create(current.getX(), current.getY(), current.getX() + width, current.getY() + height); candidate.getContent().setBounds(newBounds); final ShapeView shapeView = getShape(context, candidate.getUUID()).getShapeView(); ShapeUtils.setSizeFromBoundingBox(shapeView, width, height); onResize.accept(getShape(context, candidate.getUUID())); } return result; } }
|
ResizeNodeCommand extends AbstractCanvasCompositeCommand { CommandResult<CanvasViolation> postOperation(final AbstractCanvasHandler context, final CommandResult<CanvasViolation> result, final double width, final double height) { if (!CommandUtils.isError(result)) { final Point2D current = GraphUtils.getPosition(candidate.getContent()); final Bounds newBounds = Bounds.create(current.getX(), current.getY(), current.getX() + width, current.getY() + height); candidate.getContent().setBounds(newBounds); final ShapeView shapeView = getShape(context, candidate.getUUID()).getShapeView(); ShapeUtils.setSizeFromBoundingBox(shapeView, width, height); onResize.accept(getShape(context, candidate.getUUID())); } return result; } ResizeNodeCommand(final Element<? extends View> candidate,
final BoundingBox boundingBox,
final BiFunction<Shape, Integer, Point2D> magnetLocationProvider); ResizeNodeCommand(final Element<? extends View> candidate,
final BoundingBox boundingBox,
final BiFunction<Shape, Integer, Point2D> magnetLocationProvider,
final Consumer<Shape> onResize); }
|
ResizeNodeCommand extends AbstractCanvasCompositeCommand { CommandResult<CanvasViolation> postOperation(final AbstractCanvasHandler context, final CommandResult<CanvasViolation> result, final double width, final double height) { if (!CommandUtils.isError(result)) { final Point2D current = GraphUtils.getPosition(candidate.getContent()); final Bounds newBounds = Bounds.create(current.getX(), current.getY(), current.getX() + width, current.getY() + height); candidate.getContent().setBounds(newBounds); final ShapeView shapeView = getShape(context, candidate.getUUID()).getShapeView(); ShapeUtils.setSizeFromBoundingBox(shapeView, width, height); onResize.accept(getShape(context, candidate.getUUID())); } return result; } ResizeNodeCommand(final Element<? extends View> candidate,
final BoundingBox boundingBox,
final BiFunction<Shape, Integer, Point2D> magnetLocationProvider); ResizeNodeCommand(final Element<? extends View> candidate,
final BoundingBox boundingBox,
final BiFunction<Shape, Integer, Point2D> magnetLocationProvider,
final Consumer<Shape> onResize); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(AbstractCanvasHandler context); Element<? extends View> getCandidate(); BoundingBox getBoundingBox(); BiFunction<Shape, Integer, Point2D> getMagnetLocationProvider(); Consumer<Shape> getOnResize(); @Override String toString(); }
|
ResizeNodeCommand extends AbstractCanvasCompositeCommand { CommandResult<CanvasViolation> postOperation(final AbstractCanvasHandler context, final CommandResult<CanvasViolation> result, final double width, final double height) { if (!CommandUtils.isError(result)) { final Point2D current = GraphUtils.getPosition(candidate.getContent()); final Bounds newBounds = Bounds.create(current.getX(), current.getY(), current.getX() + width, current.getY() + height); candidate.getContent().setBounds(newBounds); final ShapeView shapeView = getShape(context, candidate.getUUID()).getShapeView(); ShapeUtils.setSizeFromBoundingBox(shapeView, width, height); onResize.accept(getShape(context, candidate.getUUID())); } return result; } ResizeNodeCommand(final Element<? extends View> candidate,
final BoundingBox boundingBox,
final BiFunction<Shape, Integer, Point2D> magnetLocationProvider); ResizeNodeCommand(final Element<? extends View> candidate,
final BoundingBox boundingBox,
final BiFunction<Shape, Integer, Point2D> magnetLocationProvider,
final Consumer<Shape> onResize); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(AbstractCanvasHandler context); Element<? extends View> getCandidate(); BoundingBox getBoundingBox(); BiFunction<Shape, Integer, Point2D> getMagnetLocationProvider(); Consumer<Shape> getOnResize(); @Override String toString(); }
|
@Test public void testGetGraphCommand() { final ClearGraphCommand graphCommand = (ClearGraphCommand) tested.newGraphCommand(canvasHandler); assertNotNull(graphCommand); assertEquals(CANVAS_ROOT_UUID, graphCommand.getRootUUID()); }
|
@Override protected Command<GraphCommandExecutionContext, RuleViolation> newGraphCommand(final AbstractCanvasHandler context) { final String rootUUID = context.getDiagram().getMetadata().getCanvasRootUUID(); return new ClearGraphCommand(rootUUID); }
|
ClearCommand extends AbstractCanvasGraphCommand { @Override protected Command<GraphCommandExecutionContext, RuleViolation> newGraphCommand(final AbstractCanvasHandler context) { final String rootUUID = context.getDiagram().getMetadata().getCanvasRootUUID(); return new ClearGraphCommand(rootUUID); } }
|
ClearCommand extends AbstractCanvasGraphCommand { @Override protected Command<GraphCommandExecutionContext, RuleViolation> newGraphCommand(final AbstractCanvasHandler context) { final String rootUUID = context.getDiagram().getMetadata().getCanvasRootUUID(); return new ClearGraphCommand(rootUUID); } }
|
ClearCommand extends AbstractCanvasGraphCommand { @Override protected Command<GraphCommandExecutionContext, RuleViolation> newGraphCommand(final AbstractCanvasHandler context) { final String rootUUID = context.getDiagram().getMetadata().getCanvasRootUUID(); return new ClearGraphCommand(rootUUID); } @Override String toString(); }
|
ClearCommand extends AbstractCanvasGraphCommand { @Override protected Command<GraphCommandExecutionContext, RuleViolation> newGraphCommand(final AbstractCanvasHandler context) { final String rootUUID = context.getDiagram().getMetadata().getCanvasRootUUID(); return new ClearGraphCommand(rootUUID); } @Override String toString(); }
|
@Test public void testGetCanvasCommand() { final ClearCanvasCommand canvasCommand = (ClearCanvasCommand) tested.newCanvasCommand(canvasHandler); assertNotNull(canvasCommand); }
|
@Override protected AbstractCanvasCommand newCanvasCommand(final AbstractCanvasHandler context) { return new ClearCanvasCommand(); }
|
ClearCommand extends AbstractCanvasGraphCommand { @Override protected AbstractCanvasCommand newCanvasCommand(final AbstractCanvasHandler context) { return new ClearCanvasCommand(); } }
|
ClearCommand extends AbstractCanvasGraphCommand { @Override protected AbstractCanvasCommand newCanvasCommand(final AbstractCanvasHandler context) { return new ClearCanvasCommand(); } }
|
ClearCommand extends AbstractCanvasGraphCommand { @Override protected AbstractCanvasCommand newCanvasCommand(final AbstractCanvasHandler context) { return new ClearCanvasCommand(); } @Override String toString(); }
|
ClearCommand extends AbstractCanvasGraphCommand { @Override protected AbstractCanvasCommand newCanvasCommand(final AbstractCanvasHandler context) { return new ClearCanvasCommand(); } @Override String toString(); }
|
@Test public void testNewGraphCommand() { Command<GraphCommandExecutionContext, RuleViolation> command; String propertyId = "name"; String value = "updated value"; command = new UpdateElementPropertyCommand(element, propertyId, value).newGraphCommand(abstractCanvasHandler); assertEquals(command.getClass(), UpdateElementPropertyValueCommand.class); command = new UpdateElementPropertyCommand(node, propertyId, value).newGraphCommand(abstractCanvasHandler); assertEquals(command.getClass(), UpdateElementPropertyValueCommand.class); }
|
@Override @SuppressWarnings("unchecked") protected Command<GraphCommandExecutionContext, RuleViolation> newGraphCommand(final AbstractCanvasHandler context) { return (element instanceof Node ? new UpdateElementPropertyValueCommand(element, field, value) : new UpdateElementPropertyValueCommand(element.getUUID(), field, value)); }
|
UpdateElementPropertyCommand extends AbstractCanvasGraphCommand { @Override @SuppressWarnings("unchecked") protected Command<GraphCommandExecutionContext, RuleViolation> newGraphCommand(final AbstractCanvasHandler context) { return (element instanceof Node ? new UpdateElementPropertyValueCommand(element, field, value) : new UpdateElementPropertyValueCommand(element.getUUID(), field, value)); } }
|
UpdateElementPropertyCommand extends AbstractCanvasGraphCommand { @Override @SuppressWarnings("unchecked") protected Command<GraphCommandExecutionContext, RuleViolation> newGraphCommand(final AbstractCanvasHandler context) { return (element instanceof Node ? new UpdateElementPropertyValueCommand(element, field, value) : new UpdateElementPropertyValueCommand(element.getUUID(), field, value)); } UpdateElementPropertyCommand(final Element element,
final String field,
final Object value); }
|
UpdateElementPropertyCommand extends AbstractCanvasGraphCommand { @Override @SuppressWarnings("unchecked") protected Command<GraphCommandExecutionContext, RuleViolation> newGraphCommand(final AbstractCanvasHandler context) { return (element instanceof Node ? new UpdateElementPropertyValueCommand(element, field, value) : new UpdateElementPropertyValueCommand(element.getUUID(), field, value)); } UpdateElementPropertyCommand(final Element element,
final String field,
final Object value); Element getElement(); String getField(); Object getValue(); @Override String toString(); }
|
UpdateElementPropertyCommand extends AbstractCanvasGraphCommand { @Override @SuppressWarnings("unchecked") protected Command<GraphCommandExecutionContext, RuleViolation> newGraphCommand(final AbstractCanvasHandler context) { return (element instanceof Node ? new UpdateElementPropertyValueCommand(element, field, value) : new UpdateElementPropertyValueCommand(element.getUUID(), field, value)); } UpdateElementPropertyCommand(final Element element,
final String field,
final Object value); Element getElement(); String getField(); Object getValue(); @Override String toString(); }
|
@Test @SuppressWarnings("unchecked") public void testMorphDockedNode() { TestingGraphInstanceBuilder.TestGraph4 graphInstance = mockGraph4(); this.tested = new MorphCanvasNodeCommand(graphInstance.dockedNode, NEW_SHAPE_SET_ID); CommandResult<CanvasViolation> result = tested.execute(canvasHandler); assertFalse(CommandUtils.isError(result)); verify(canvasHandler, times(1)).deregister(graphInstance.dockedNode); verify(canvasHandler, times(1)).register(NEW_SHAPE_SET_ID, graphInstance.dockedNode); verify(canvasHandler, times(1)).undock(graphInstance.intermNode, graphInstance.dockedNode); verify(canvasHandler, times(1)).dock(graphInstance.intermNode, graphInstance.dockedNode); verify(canvasHandler, times(1)).applyElementMutation(graphInstance.dockedNode, MutationContext.STATIC); verify(canvasHandler, never()).removeChild(anyObject(), anyObject()); verify(canvasHandler, never()).addChild(anyObject(), anyObject()); verify(edge1ShapeView, never()).moveToTop(); verify(edge2ShapeView, never()).moveToTop(); }
|
@Override @SuppressWarnings("unchecked") public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { final Optional<Node> parentOptional = getParent(); final Optional<Node> dockParentOptional = getDockParent(candidate); final List<Node> dockedNodes = getDockedNodes(candidate); final List<Node> childNodes = getChildNodes(candidate); if (dockParentOptional.isPresent()) { context.undock(dockParentOptional.get(), candidate); } else { parentOptional.ifPresent(parent -> context.removeChild(parent, candidate)); } dockedNodes.stream().forEach(node -> context.undock(candidate, node)); childNodes.stream().forEach(node -> context.removeChild(candidate, node)); context.deregister(candidate); context.register(shapeSetId, candidate); dockedNodes.stream().forEach(node -> context.dock(candidate, node)); childNodes.stream().forEach(node -> context.addChild(candidate, node)); if (dockParentOptional.isPresent()) { context.dock(dockParentOptional.get(), candidate); } else { parentOptional.ifPresent(parent -> context.addChild(parent, candidate)); } updateConnectionEdges(context, candidate); context.applyElementMutation(candidate, MutationContext.STATIC); return buildResult(); }
|
MorphCanvasNodeCommand extends AbstractCanvasCommand { @Override @SuppressWarnings("unchecked") public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { final Optional<Node> parentOptional = getParent(); final Optional<Node> dockParentOptional = getDockParent(candidate); final List<Node> dockedNodes = getDockedNodes(candidate); final List<Node> childNodes = getChildNodes(candidate); if (dockParentOptional.isPresent()) { context.undock(dockParentOptional.get(), candidate); } else { parentOptional.ifPresent(parent -> context.removeChild(parent, candidate)); } dockedNodes.stream().forEach(node -> context.undock(candidate, node)); childNodes.stream().forEach(node -> context.removeChild(candidate, node)); context.deregister(candidate); context.register(shapeSetId, candidate); dockedNodes.stream().forEach(node -> context.dock(candidate, node)); childNodes.stream().forEach(node -> context.addChild(candidate, node)); if (dockParentOptional.isPresent()) { context.dock(dockParentOptional.get(), candidate); } else { parentOptional.ifPresent(parent -> context.addChild(parent, candidate)); } updateConnectionEdges(context, candidate); context.applyElementMutation(candidate, MutationContext.STATIC); return buildResult(); } }
|
MorphCanvasNodeCommand extends AbstractCanvasCommand { @Override @SuppressWarnings("unchecked") public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { final Optional<Node> parentOptional = getParent(); final Optional<Node> dockParentOptional = getDockParent(candidate); final List<Node> dockedNodes = getDockedNodes(candidate); final List<Node> childNodes = getChildNodes(candidate); if (dockParentOptional.isPresent()) { context.undock(dockParentOptional.get(), candidate); } else { parentOptional.ifPresent(parent -> context.removeChild(parent, candidate)); } dockedNodes.stream().forEach(node -> context.undock(candidate, node)); childNodes.stream().forEach(node -> context.removeChild(candidate, node)); context.deregister(candidate); context.register(shapeSetId, candidate); dockedNodes.stream().forEach(node -> context.dock(candidate, node)); childNodes.stream().forEach(node -> context.addChild(candidate, node)); if (dockParentOptional.isPresent()) { context.dock(dockParentOptional.get(), candidate); } else { parentOptional.ifPresent(parent -> context.addChild(parent, candidate)); } updateConnectionEdges(context, candidate); context.applyElementMutation(candidate, MutationContext.STATIC); return buildResult(); } MorphCanvasNodeCommand(final Node<? extends Definition<?>, Edge> candidate,
final String shapeSetId); }
|
MorphCanvasNodeCommand extends AbstractCanvasCommand { @Override @SuppressWarnings("unchecked") public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { final Optional<Node> parentOptional = getParent(); final Optional<Node> dockParentOptional = getDockParent(candidate); final List<Node> dockedNodes = getDockedNodes(candidate); final List<Node> childNodes = getChildNodes(candidate); if (dockParentOptional.isPresent()) { context.undock(dockParentOptional.get(), candidate); } else { parentOptional.ifPresent(parent -> context.removeChild(parent, candidate)); } dockedNodes.stream().forEach(node -> context.undock(candidate, node)); childNodes.stream().forEach(node -> context.removeChild(candidate, node)); context.deregister(candidate); context.register(shapeSetId, candidate); dockedNodes.stream().forEach(node -> context.dock(candidate, node)); childNodes.stream().forEach(node -> context.addChild(candidate, node)); if (dockParentOptional.isPresent()) { context.dock(dockParentOptional.get(), candidate); } else { parentOptional.ifPresent(parent -> context.addChild(parent, candidate)); } updateConnectionEdges(context, candidate); context.applyElementMutation(candidate, MutationContext.STATIC); return buildResult(); } MorphCanvasNodeCommand(final Node<? extends Definition<?>, Edge> candidate,
final String shapeSetId); @Override @SuppressWarnings("unchecked") CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); @Override String toString(); }
|
MorphCanvasNodeCommand extends AbstractCanvasCommand { @Override @SuppressWarnings("unchecked") public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { final Optional<Node> parentOptional = getParent(); final Optional<Node> dockParentOptional = getDockParent(candidate); final List<Node> dockedNodes = getDockedNodes(candidate); final List<Node> childNodes = getChildNodes(candidate); if (dockParentOptional.isPresent()) { context.undock(dockParentOptional.get(), candidate); } else { parentOptional.ifPresent(parent -> context.removeChild(parent, candidate)); } dockedNodes.stream().forEach(node -> context.undock(candidate, node)); childNodes.stream().forEach(node -> context.removeChild(candidate, node)); context.deregister(candidate); context.register(shapeSetId, candidate); dockedNodes.stream().forEach(node -> context.dock(candidate, node)); childNodes.stream().forEach(node -> context.addChild(candidate, node)); if (dockParentOptional.isPresent()) { context.dock(dockParentOptional.get(), candidate); } else { parentOptional.ifPresent(parent -> context.addChild(parent, candidate)); } updateConnectionEdges(context, candidate); context.applyElementMutation(candidate, MutationContext.STATIC); return buildResult(); } MorphCanvasNodeCommand(final Node<? extends Definition<?>, Edge> candidate,
final String shapeSetId); @Override @SuppressWarnings("unchecked") CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); @Override String toString(); }
|
@Test @SuppressWarnings("unchecked") public void testMorphSomeIntermediateNode() { TestingGraphInstanceBuilder.TestGraph4 graphInstance = mockGraph4(); this.tested = new MorphCanvasNodeCommand(graphInstance.intermNode, NEW_SHAPE_SET_ID); CommandResult<CanvasViolation> result = tested.execute(canvasHandler); assertFalse(CommandUtils.isError(result)); verify(canvasHandler, times(1)).undock(eq(graphInstance.intermNode), eq(graphInstance.dockedNode)); verify(canvasHandler, times(1)).removeChild(graphInstance.parentNode, graphInstance.intermNode); verify(canvasHandler, times(1)).deregister(graphInstance.intermNode); verify(canvasHandler, times(1)).register(NEW_SHAPE_SET_ID, graphInstance.intermNode); verify(canvasHandler, times(1)).addChild(graphInstance.parentNode, graphInstance.intermNode); verify(canvasHandler, times(1)).dock(eq(graphInstance.intermNode), eq(graphInstance.dockedNode)); verify(canvasHandler, times(1)).applyElementMutation(graphInstance.intermNode, MutationContext.STATIC); verify(edge1ShapeView, times(1)).moveToTop(); verify(edge2ShapeView, times(1)).moveToTop(); }
|
@Override @SuppressWarnings("unchecked") public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { final Optional<Node> parentOptional = getParent(); final Optional<Node> dockParentOptional = getDockParent(candidate); final List<Node> dockedNodes = getDockedNodes(candidate); final List<Node> childNodes = getChildNodes(candidate); if (dockParentOptional.isPresent()) { context.undock(dockParentOptional.get(), candidate); } else { parentOptional.ifPresent(parent -> context.removeChild(parent, candidate)); } dockedNodes.stream().forEach(node -> context.undock(candidate, node)); childNodes.stream().forEach(node -> context.removeChild(candidate, node)); context.deregister(candidate); context.register(shapeSetId, candidate); dockedNodes.stream().forEach(node -> context.dock(candidate, node)); childNodes.stream().forEach(node -> context.addChild(candidate, node)); if (dockParentOptional.isPresent()) { context.dock(dockParentOptional.get(), candidate); } else { parentOptional.ifPresent(parent -> context.addChild(parent, candidate)); } updateConnectionEdges(context, candidate); context.applyElementMutation(candidate, MutationContext.STATIC); return buildResult(); }
|
MorphCanvasNodeCommand extends AbstractCanvasCommand { @Override @SuppressWarnings("unchecked") public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { final Optional<Node> parentOptional = getParent(); final Optional<Node> dockParentOptional = getDockParent(candidate); final List<Node> dockedNodes = getDockedNodes(candidate); final List<Node> childNodes = getChildNodes(candidate); if (dockParentOptional.isPresent()) { context.undock(dockParentOptional.get(), candidate); } else { parentOptional.ifPresent(parent -> context.removeChild(parent, candidate)); } dockedNodes.stream().forEach(node -> context.undock(candidate, node)); childNodes.stream().forEach(node -> context.removeChild(candidate, node)); context.deregister(candidate); context.register(shapeSetId, candidate); dockedNodes.stream().forEach(node -> context.dock(candidate, node)); childNodes.stream().forEach(node -> context.addChild(candidate, node)); if (dockParentOptional.isPresent()) { context.dock(dockParentOptional.get(), candidate); } else { parentOptional.ifPresent(parent -> context.addChild(parent, candidate)); } updateConnectionEdges(context, candidate); context.applyElementMutation(candidate, MutationContext.STATIC); return buildResult(); } }
|
MorphCanvasNodeCommand extends AbstractCanvasCommand { @Override @SuppressWarnings("unchecked") public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { final Optional<Node> parentOptional = getParent(); final Optional<Node> dockParentOptional = getDockParent(candidate); final List<Node> dockedNodes = getDockedNodes(candidate); final List<Node> childNodes = getChildNodes(candidate); if (dockParentOptional.isPresent()) { context.undock(dockParentOptional.get(), candidate); } else { parentOptional.ifPresent(parent -> context.removeChild(parent, candidate)); } dockedNodes.stream().forEach(node -> context.undock(candidate, node)); childNodes.stream().forEach(node -> context.removeChild(candidate, node)); context.deregister(candidate); context.register(shapeSetId, candidate); dockedNodes.stream().forEach(node -> context.dock(candidate, node)); childNodes.stream().forEach(node -> context.addChild(candidate, node)); if (dockParentOptional.isPresent()) { context.dock(dockParentOptional.get(), candidate); } else { parentOptional.ifPresent(parent -> context.addChild(parent, candidate)); } updateConnectionEdges(context, candidate); context.applyElementMutation(candidate, MutationContext.STATIC); return buildResult(); } MorphCanvasNodeCommand(final Node<? extends Definition<?>, Edge> candidate,
final String shapeSetId); }
|
MorphCanvasNodeCommand extends AbstractCanvasCommand { @Override @SuppressWarnings("unchecked") public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { final Optional<Node> parentOptional = getParent(); final Optional<Node> dockParentOptional = getDockParent(candidate); final List<Node> dockedNodes = getDockedNodes(candidate); final List<Node> childNodes = getChildNodes(candidate); if (dockParentOptional.isPresent()) { context.undock(dockParentOptional.get(), candidate); } else { parentOptional.ifPresent(parent -> context.removeChild(parent, candidate)); } dockedNodes.stream().forEach(node -> context.undock(candidate, node)); childNodes.stream().forEach(node -> context.removeChild(candidate, node)); context.deregister(candidate); context.register(shapeSetId, candidate); dockedNodes.stream().forEach(node -> context.dock(candidate, node)); childNodes.stream().forEach(node -> context.addChild(candidate, node)); if (dockParentOptional.isPresent()) { context.dock(dockParentOptional.get(), candidate); } else { parentOptional.ifPresent(parent -> context.addChild(parent, candidate)); } updateConnectionEdges(context, candidate); context.applyElementMutation(candidate, MutationContext.STATIC); return buildResult(); } MorphCanvasNodeCommand(final Node<? extends Definition<?>, Edge> candidate,
final String shapeSetId); @Override @SuppressWarnings("unchecked") CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); @Override String toString(); }
|
MorphCanvasNodeCommand extends AbstractCanvasCommand { @Override @SuppressWarnings("unchecked") public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { final Optional<Node> parentOptional = getParent(); final Optional<Node> dockParentOptional = getDockParent(candidate); final List<Node> dockedNodes = getDockedNodes(candidate); final List<Node> childNodes = getChildNodes(candidate); if (dockParentOptional.isPresent()) { context.undock(dockParentOptional.get(), candidate); } else { parentOptional.ifPresent(parent -> context.removeChild(parent, candidate)); } dockedNodes.stream().forEach(node -> context.undock(candidate, node)); childNodes.stream().forEach(node -> context.removeChild(candidate, node)); context.deregister(candidate); context.register(shapeSetId, candidate); dockedNodes.stream().forEach(node -> context.dock(candidate, node)); childNodes.stream().forEach(node -> context.addChild(candidate, node)); if (dockParentOptional.isPresent()) { context.dock(dockParentOptional.get(), candidate); } else { parentOptional.ifPresent(parent -> context.addChild(parent, candidate)); } updateConnectionEdges(context, candidate); context.applyElementMutation(candidate, MutationContext.STATIC); return buildResult(); } MorphCanvasNodeCommand(final Node<? extends Definition<?>, Edge> candidate,
final String shapeSetId); @Override @SuppressWarnings("unchecked") CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); @Override String toString(); }
|
@Test @SuppressWarnings("unchecked") public void testMorphSomeContainerNode() { TestingGraphInstanceBuilder.TestGraph3 graphInstance = mockGraph3(); this.tested = new MorphCanvasNodeCommand(graphInstance.containerNode, NEW_SHAPE_SET_ID); CommandResult<CanvasViolation> result = tested.execute(canvasHandler); assertFalse(CommandUtils.isError(result)); verify(canvasHandler, times(1)).deregister(graphInstance.containerNode); verify(canvasHandler, times(1)).removeChild(graphInstance.parentNode, graphInstance.containerNode); verify(canvasHandler, times(1)).removeChild(graphInstance.containerNode, graphInstance.startNode); verify(canvasHandler, times(1)).removeChild(graphInstance.containerNode, graphInstance.intermNode); verify(canvasHandler, times(1)).removeChild(graphInstance.containerNode, graphInstance.endNode); verify(canvasHandler, times(1)).register(NEW_SHAPE_SET_ID, graphInstance.containerNode); verify(canvasHandler, times(1)).addChild(graphInstance.parentNode, graphInstance.containerNode); verify(canvasHandler, times(1)).addChild(graphInstance.containerNode, graphInstance.startNode); verify(canvasHandler, times(1)).addChild(graphInstance.containerNode, graphInstance.intermNode); verify(canvasHandler, times(1)).addChild(graphInstance.containerNode, graphInstance.endNode); verify(canvasHandler, times(1)).applyElementMutation(graphInstance.containerNode, MutationContext.STATIC); verify(edge1ShapeView, times(1)).moveToTop(); verify(edge2ShapeView, times(1)).moveToTop(); }
|
@Override @SuppressWarnings("unchecked") public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { final Optional<Node> parentOptional = getParent(); final Optional<Node> dockParentOptional = getDockParent(candidate); final List<Node> dockedNodes = getDockedNodes(candidate); final List<Node> childNodes = getChildNodes(candidate); if (dockParentOptional.isPresent()) { context.undock(dockParentOptional.get(), candidate); } else { parentOptional.ifPresent(parent -> context.removeChild(parent, candidate)); } dockedNodes.stream().forEach(node -> context.undock(candidate, node)); childNodes.stream().forEach(node -> context.removeChild(candidate, node)); context.deregister(candidate); context.register(shapeSetId, candidate); dockedNodes.stream().forEach(node -> context.dock(candidate, node)); childNodes.stream().forEach(node -> context.addChild(candidate, node)); if (dockParentOptional.isPresent()) { context.dock(dockParentOptional.get(), candidate); } else { parentOptional.ifPresent(parent -> context.addChild(parent, candidate)); } updateConnectionEdges(context, candidate); context.applyElementMutation(candidate, MutationContext.STATIC); return buildResult(); }
|
MorphCanvasNodeCommand extends AbstractCanvasCommand { @Override @SuppressWarnings("unchecked") public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { final Optional<Node> parentOptional = getParent(); final Optional<Node> dockParentOptional = getDockParent(candidate); final List<Node> dockedNodes = getDockedNodes(candidate); final List<Node> childNodes = getChildNodes(candidate); if (dockParentOptional.isPresent()) { context.undock(dockParentOptional.get(), candidate); } else { parentOptional.ifPresent(parent -> context.removeChild(parent, candidate)); } dockedNodes.stream().forEach(node -> context.undock(candidate, node)); childNodes.stream().forEach(node -> context.removeChild(candidate, node)); context.deregister(candidate); context.register(shapeSetId, candidate); dockedNodes.stream().forEach(node -> context.dock(candidate, node)); childNodes.stream().forEach(node -> context.addChild(candidate, node)); if (dockParentOptional.isPresent()) { context.dock(dockParentOptional.get(), candidate); } else { parentOptional.ifPresent(parent -> context.addChild(parent, candidate)); } updateConnectionEdges(context, candidate); context.applyElementMutation(candidate, MutationContext.STATIC); return buildResult(); } }
|
MorphCanvasNodeCommand extends AbstractCanvasCommand { @Override @SuppressWarnings("unchecked") public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { final Optional<Node> parentOptional = getParent(); final Optional<Node> dockParentOptional = getDockParent(candidate); final List<Node> dockedNodes = getDockedNodes(candidate); final List<Node> childNodes = getChildNodes(candidate); if (dockParentOptional.isPresent()) { context.undock(dockParentOptional.get(), candidate); } else { parentOptional.ifPresent(parent -> context.removeChild(parent, candidate)); } dockedNodes.stream().forEach(node -> context.undock(candidate, node)); childNodes.stream().forEach(node -> context.removeChild(candidate, node)); context.deregister(candidate); context.register(shapeSetId, candidate); dockedNodes.stream().forEach(node -> context.dock(candidate, node)); childNodes.stream().forEach(node -> context.addChild(candidate, node)); if (dockParentOptional.isPresent()) { context.dock(dockParentOptional.get(), candidate); } else { parentOptional.ifPresent(parent -> context.addChild(parent, candidate)); } updateConnectionEdges(context, candidate); context.applyElementMutation(candidate, MutationContext.STATIC); return buildResult(); } MorphCanvasNodeCommand(final Node<? extends Definition<?>, Edge> candidate,
final String shapeSetId); }
|
MorphCanvasNodeCommand extends AbstractCanvasCommand { @Override @SuppressWarnings("unchecked") public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { final Optional<Node> parentOptional = getParent(); final Optional<Node> dockParentOptional = getDockParent(candidate); final List<Node> dockedNodes = getDockedNodes(candidate); final List<Node> childNodes = getChildNodes(candidate); if (dockParentOptional.isPresent()) { context.undock(dockParentOptional.get(), candidate); } else { parentOptional.ifPresent(parent -> context.removeChild(parent, candidate)); } dockedNodes.stream().forEach(node -> context.undock(candidate, node)); childNodes.stream().forEach(node -> context.removeChild(candidate, node)); context.deregister(candidate); context.register(shapeSetId, candidate); dockedNodes.stream().forEach(node -> context.dock(candidate, node)); childNodes.stream().forEach(node -> context.addChild(candidate, node)); if (dockParentOptional.isPresent()) { context.dock(dockParentOptional.get(), candidate); } else { parentOptional.ifPresent(parent -> context.addChild(parent, candidate)); } updateConnectionEdges(context, candidate); context.applyElementMutation(candidate, MutationContext.STATIC); return buildResult(); } MorphCanvasNodeCommand(final Node<? extends Definition<?>, Edge> candidate,
final String shapeSetId); @Override @SuppressWarnings("unchecked") CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); @Override String toString(); }
|
MorphCanvasNodeCommand extends AbstractCanvasCommand { @Override @SuppressWarnings("unchecked") public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { final Optional<Node> parentOptional = getParent(); final Optional<Node> dockParentOptional = getDockParent(candidate); final List<Node> dockedNodes = getDockedNodes(candidate); final List<Node> childNodes = getChildNodes(candidate); if (dockParentOptional.isPresent()) { context.undock(dockParentOptional.get(), candidate); } else { parentOptional.ifPresent(parent -> context.removeChild(parent, candidate)); } dockedNodes.stream().forEach(node -> context.undock(candidate, node)); childNodes.stream().forEach(node -> context.removeChild(candidate, node)); context.deregister(candidate); context.register(shapeSetId, candidate); dockedNodes.stream().forEach(node -> context.dock(candidate, node)); childNodes.stream().forEach(node -> context.addChild(candidate, node)); if (dockParentOptional.isPresent()) { context.dock(dockParentOptional.get(), candidate); } else { parentOptional.ifPresent(parent -> context.addChild(parent, candidate)); } updateConnectionEdges(context, candidate); context.applyElementMutation(candidate, MutationContext.STATIC); return buildResult(); } MorphCanvasNodeCommand(final Node<? extends Definition<?>, Edge> candidate,
final String shapeSetId); @Override @SuppressWarnings("unchecked") CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); @Override String toString(); }
|
@Test @SuppressWarnings("unchecked") public void testAllow() { CommandResult<CanvasViolation> result = tested.allow(canvasHandler); verify(graphCommand, times(1)).allow(eq(graphContext)); verify(canvasCommand, times(1)).allow(eq(canvasHandler)); assertEquals(CommandResult.Type.INFO, result.getType()); assertFalse(result.getViolations().iterator().hasNext()); }
|
@Override public CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context) { final CommandResult<CanvasViolation> result = performOperationOnGraph(context, CommandOperation.ALLOW); if (canDoNexOperation(result)) { return performOperationOnCanvas(context, CommandOperation.ALLOW); } return result; }
|
AbstractCanvasGraphCommand extends AbstractCanvasCommand implements HasGraphCommand<AbstractCanvasHandler> { @Override public CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context) { final CommandResult<CanvasViolation> result = performOperationOnGraph(context, CommandOperation.ALLOW); if (canDoNexOperation(result)) { return performOperationOnCanvas(context, CommandOperation.ALLOW); } return result; } }
|
AbstractCanvasGraphCommand extends AbstractCanvasCommand implements HasGraphCommand<AbstractCanvasHandler> { @Override public CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context) { final CommandResult<CanvasViolation> result = performOperationOnGraph(context, CommandOperation.ALLOW); if (canDoNexOperation(result)) { return performOperationOnCanvas(context, CommandOperation.ALLOW); } return result; } }
|
AbstractCanvasGraphCommand extends AbstractCanvasCommand implements HasGraphCommand<AbstractCanvasHandler> { @Override public CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context) { final CommandResult<CanvasViolation> result = performOperationOnGraph(context, CommandOperation.ALLOW); if (canDoNexOperation(result)) { return performOperationOnCanvas(context, CommandOperation.ALLOW); } return result; } @Override Command<GraphCommandExecutionContext, RuleViolation> getGraphCommand(final AbstractCanvasHandler context); Command<AbstractCanvasHandler, CanvasViolation> getCanvasCommand(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); }
|
AbstractCanvasGraphCommand extends AbstractCanvasCommand implements HasGraphCommand<AbstractCanvasHandler> { @Override public CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context) { final CommandResult<CanvasViolation> result = performOperationOnGraph(context, CommandOperation.ALLOW); if (canDoNexOperation(result)) { return performOperationOnCanvas(context, CommandOperation.ALLOW); } return result; } @Override Command<GraphCommandExecutionContext, RuleViolation> getGraphCommand(final AbstractCanvasHandler context); Command<AbstractCanvasHandler, CanvasViolation> getCanvasCommand(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); }
|
@Test @SuppressWarnings("unchecked") public void testCanvasCommandNotAllowed() { when(canvasCommand.allow(eq(canvasHandler))).thenReturn(CANVAS_COMMAND_FAILED); CommandResult<CanvasViolation> result = tested.allow(canvasHandler); verify(graphCommand, times(1)).allow(eq(graphContext)); verify(canvasCommand, times(1)).allow(eq(canvasHandler)); assertEquals(CommandResult.Type.ERROR, result.getType()); }
|
@Override public CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context) { final CommandResult<CanvasViolation> result = performOperationOnGraph(context, CommandOperation.ALLOW); if (canDoNexOperation(result)) { return performOperationOnCanvas(context, CommandOperation.ALLOW); } return result; }
|
AbstractCanvasGraphCommand extends AbstractCanvasCommand implements HasGraphCommand<AbstractCanvasHandler> { @Override public CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context) { final CommandResult<CanvasViolation> result = performOperationOnGraph(context, CommandOperation.ALLOW); if (canDoNexOperation(result)) { return performOperationOnCanvas(context, CommandOperation.ALLOW); } return result; } }
|
AbstractCanvasGraphCommand extends AbstractCanvasCommand implements HasGraphCommand<AbstractCanvasHandler> { @Override public CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context) { final CommandResult<CanvasViolation> result = performOperationOnGraph(context, CommandOperation.ALLOW); if (canDoNexOperation(result)) { return performOperationOnCanvas(context, CommandOperation.ALLOW); } return result; } }
|
AbstractCanvasGraphCommand extends AbstractCanvasCommand implements HasGraphCommand<AbstractCanvasHandler> { @Override public CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context) { final CommandResult<CanvasViolation> result = performOperationOnGraph(context, CommandOperation.ALLOW); if (canDoNexOperation(result)) { return performOperationOnCanvas(context, CommandOperation.ALLOW); } return result; } @Override Command<GraphCommandExecutionContext, RuleViolation> getGraphCommand(final AbstractCanvasHandler context); Command<AbstractCanvasHandler, CanvasViolation> getCanvasCommand(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); }
|
AbstractCanvasGraphCommand extends AbstractCanvasCommand implements HasGraphCommand<AbstractCanvasHandler> { @Override public CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context) { final CommandResult<CanvasViolation> result = performOperationOnGraph(context, CommandOperation.ALLOW); if (canDoNexOperation(result)) { return performOperationOnCanvas(context, CommandOperation.ALLOW); } return result; } @Override Command<GraphCommandExecutionContext, RuleViolation> getGraphCommand(final AbstractCanvasHandler context); Command<AbstractCanvasHandler, CanvasViolation> getCanvasCommand(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); }
|
@Test @SuppressWarnings("unchecked") public void testGraphCommandNotAllowed() { when(graphCommand.allow(eq(graphContext))).thenReturn(GRAPH_COMMAND_FAILED); CommandResult<CanvasViolation> result = tested.allow(canvasHandler); verify(graphCommand, times(1)).allow(eq(graphContext)); verify(canvasCommand, never()).allow(eq(canvasHandler)); assertEquals(CommandResult.Type.ERROR, result.getType()); }
|
@Override public CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context) { final CommandResult<CanvasViolation> result = performOperationOnGraph(context, CommandOperation.ALLOW); if (canDoNexOperation(result)) { return performOperationOnCanvas(context, CommandOperation.ALLOW); } return result; }
|
AbstractCanvasGraphCommand extends AbstractCanvasCommand implements HasGraphCommand<AbstractCanvasHandler> { @Override public CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context) { final CommandResult<CanvasViolation> result = performOperationOnGraph(context, CommandOperation.ALLOW); if (canDoNexOperation(result)) { return performOperationOnCanvas(context, CommandOperation.ALLOW); } return result; } }
|
AbstractCanvasGraphCommand extends AbstractCanvasCommand implements HasGraphCommand<AbstractCanvasHandler> { @Override public CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context) { final CommandResult<CanvasViolation> result = performOperationOnGraph(context, CommandOperation.ALLOW); if (canDoNexOperation(result)) { return performOperationOnCanvas(context, CommandOperation.ALLOW); } return result; } }
|
AbstractCanvasGraphCommand extends AbstractCanvasCommand implements HasGraphCommand<AbstractCanvasHandler> { @Override public CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context) { final CommandResult<CanvasViolation> result = performOperationOnGraph(context, CommandOperation.ALLOW); if (canDoNexOperation(result)) { return performOperationOnCanvas(context, CommandOperation.ALLOW); } return result; } @Override Command<GraphCommandExecutionContext, RuleViolation> getGraphCommand(final AbstractCanvasHandler context); Command<AbstractCanvasHandler, CanvasViolation> getCanvasCommand(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); }
|
AbstractCanvasGraphCommand extends AbstractCanvasCommand implements HasGraphCommand<AbstractCanvasHandler> { @Override public CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context) { final CommandResult<CanvasViolation> result = performOperationOnGraph(context, CommandOperation.ALLOW); if (canDoNexOperation(result)) { return performOperationOnCanvas(context, CommandOperation.ALLOW); } return result; } @Override Command<GraphCommandExecutionContext, RuleViolation> getGraphCommand(final AbstractCanvasHandler context); Command<AbstractCanvasHandler, CanvasViolation> getCanvasCommand(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); }
|
@Test public void testSetOnClosedByKeyboardCallback() { final PopupEditorControls editor = mock(PopupEditorControls.class, withSettings().extraInterfaces(CanBeClosedByKeyboard.class)); view.setOnClosedByKeyboardCallback(editor); verify((CanBeClosedByKeyboard) editor).setOnClosedByKeyboardCallback(any()); }
|
void setOnClosedByKeyboardCallback(final PopupEditorControls editor) { if (editor instanceof CanBeClosedByKeyboard) { ((CanBeClosedByKeyboard) editor).setOnClosedByKeyboardCallback(this::focusOnDMNContainer); } }
|
CellEditorControlsViewImpl implements CellEditorControlsView { void setOnClosedByKeyboardCallback(final PopupEditorControls editor) { if (editor instanceof CanBeClosedByKeyboard) { ((CanBeClosedByKeyboard) editor).setOnClosedByKeyboardCallback(this::focusOnDMNContainer); } } }
|
CellEditorControlsViewImpl implements CellEditorControlsView { void setOnClosedByKeyboardCallback(final PopupEditorControls editor) { if (editor instanceof CanBeClosedByKeyboard) { ((CanBeClosedByKeyboard) editor).setOnClosedByKeyboardCallback(this::focusOnDMNContainer); } } CellEditorControlsViewImpl(); @Inject CellEditorControlsViewImpl(final Document document,
final Div cellEditorControls,
final Div cellEditorControlsContainer); }
|
CellEditorControlsViewImpl implements CellEditorControlsView { void setOnClosedByKeyboardCallback(final PopupEditorControls editor) { if (editor instanceof CanBeClosedByKeyboard) { ((CanBeClosedByKeyboard) editor).setOnClosedByKeyboardCallback(this::focusOnDMNContainer); } } CellEditorControlsViewImpl(); @Inject CellEditorControlsViewImpl(final Document document,
final Div cellEditorControls,
final Div cellEditorControlsContainer); Optional<PopupEditorControls> getActiveEditor(); void setActiveEditor(final Optional<PopupEditorControls> activeEditor); @PostConstruct void setup(); @PreDestroy void destroy(); @Override void show(final PopupEditorControls editor,
final int x,
final int y); @Override void hide(); }
|
CellEditorControlsViewImpl implements CellEditorControlsView { void setOnClosedByKeyboardCallback(final PopupEditorControls editor) { if (editor instanceof CanBeClosedByKeyboard) { ((CanBeClosedByKeyboard) editor).setOnClosedByKeyboardCallback(this::focusOnDMNContainer); } } CellEditorControlsViewImpl(); @Inject CellEditorControlsViewImpl(final Document document,
final Div cellEditorControls,
final Div cellEditorControlsContainer); Optional<PopupEditorControls> getActiveEditor(); void setActiveEditor(final Optional<PopupEditorControls> activeEditor); @PostConstruct void setup(); @PreDestroy void destroy(); @Override void show(final PopupEditorControls editor,
final int x,
final int y); @Override void hide(); static final String LEFT; static final String TOP; }
|
@Test public void testGetModelPathWhenDMNModelCouldNotBeFound() { final Metadata metadata = mock(Metadata.class); final String modelNamespace = "0000-1111-2222-3333"; final String modelName = "model name"; assertThatThrownBy(() -> helper.getDMNModelPath(metadata, modelNamespace, modelName)) .isInstanceOf(IllegalStateException.class) .hasMessageContaining("A path for the DMN model with namespace [0000-1111-2222-3333] could not be found."); }
|
@Override public Path getDMNModelPath(final Metadata metadata, final String modelNamespace, final String modelName) { final WorkspaceProject workspaceProject = getProject(metadata); for (final Path dmnModelPath : pathsHelper.getDMNModelsPaths(workspaceProject)) { final Optional<Definitions> definitions = getDefinitionsByPath(dmnModelPath); if (definitions.map(d -> Objects.equals(d.getNamespace(), modelNamespace) && Objects.equals(d.getName(), modelName)).orElse(false)) { return dmnModelPath; } } throw new IllegalStateException("A path for the DMN model with namespace [" + modelNamespace + "] could not be found."); }
|
DMNMarshallerImportsHelperStandaloneImpl implements DMNMarshallerImportsHelperStandalone { @Override public Path getDMNModelPath(final Metadata metadata, final String modelNamespace, final String modelName) { final WorkspaceProject workspaceProject = getProject(metadata); for (final Path dmnModelPath : pathsHelper.getDMNModelsPaths(workspaceProject)) { final Optional<Definitions> definitions = getDefinitionsByPath(dmnModelPath); if (definitions.map(d -> Objects.equals(d.getNamespace(), modelNamespace) && Objects.equals(d.getName(), modelName)).orElse(false)) { return dmnModelPath; } } throw new IllegalStateException("A path for the DMN model with namespace [" + modelNamespace + "] could not be found."); } }
|
DMNMarshallerImportsHelperStandaloneImpl implements DMNMarshallerImportsHelperStandalone { @Override public Path getDMNModelPath(final Metadata metadata, final String modelNamespace, final String modelName) { final WorkspaceProject workspaceProject = getProject(metadata); for (final Path dmnModelPath : pathsHelper.getDMNModelsPaths(workspaceProject)) { final Optional<Definitions> definitions = getDefinitionsByPath(dmnModelPath); if (definitions.map(d -> Objects.equals(d.getNamespace(), modelNamespace) && Objects.equals(d.getName(), modelName)).orElse(false)) { return dmnModelPath; } } throw new IllegalStateException("A path for the DMN model with namespace [" + modelNamespace + "] could not be found."); } DMNMarshallerImportsHelperStandaloneImpl(); @Inject DMNMarshallerImportsHelperStandaloneImpl(final DMNPathsHelper pathsHelper,
final WorkspaceProjectService projectService,
final DMNMarshaller marshaller,
final DMNIOHelper dmnIOHelper,
final PMMLIncludedDocumentFactory pmmlDocumentFactory,
final @Named("ioStrategy") IOService ioService); }
|
DMNMarshallerImportsHelperStandaloneImpl implements DMNMarshallerImportsHelperStandalone { @Override public Path getDMNModelPath(final Metadata metadata, final String modelNamespace, final String modelName) { final WorkspaceProject workspaceProject = getProject(metadata); for (final Path dmnModelPath : pathsHelper.getDMNModelsPaths(workspaceProject)) { final Optional<Definitions> definitions = getDefinitionsByPath(dmnModelPath); if (definitions.map(d -> Objects.equals(d.getNamespace(), modelNamespace) && Objects.equals(d.getName(), modelName)).orElse(false)) { return dmnModelPath; } } throw new IllegalStateException("A path for the DMN model with namespace [" + modelNamespace + "] could not be found."); } DMNMarshallerImportsHelperStandaloneImpl(); @Inject DMNMarshallerImportsHelperStandaloneImpl(final DMNPathsHelper pathsHelper,
final WorkspaceProjectService projectService,
final DMNMarshaller marshaller,
final DMNIOHelper dmnIOHelper,
final PMMLIncludedDocumentFactory pmmlDocumentFactory,
final @Named("ioStrategy") IOService ioService); @Override Map<Import, Definitions> getImportDefinitions(final Metadata metadata,
final List<Import> imports); @Override Map<Import, PMMLDocumentMetadata> getPMMLDocuments(final Metadata metadata,
final List<Import> imports); @Override Map<Import, String> getImportXML(final Metadata metadata,
final List<Import> imports); @Override Path getDMNModelPath(final Metadata metadata,
final String modelNamespace,
final String modelName); @Override List<DRGElement> getImportedDRGElements(final Map<Import, Definitions> importDefinitions); @Override List<ItemDefinition> getImportedItemDefinitions(final Map<Import, Definitions> importDefinitions); @Override List<ItemDefinition> getImportedItemDefinitionsByNamespace(final WorkspaceProject workspaceProject,
final String modelName,
final String namespace); @Override Optional<InputStream> loadPath(final Path path); }
|
DMNMarshallerImportsHelperStandaloneImpl implements DMNMarshallerImportsHelperStandalone { @Override public Path getDMNModelPath(final Metadata metadata, final String modelNamespace, final String modelName) { final WorkspaceProject workspaceProject = getProject(metadata); for (final Path dmnModelPath : pathsHelper.getDMNModelsPaths(workspaceProject)) { final Optional<Definitions> definitions = getDefinitionsByPath(dmnModelPath); if (definitions.map(d -> Objects.equals(d.getNamespace(), modelNamespace) && Objects.equals(d.getName(), modelName)).orElse(false)) { return dmnModelPath; } } throw new IllegalStateException("A path for the DMN model with namespace [" + modelNamespace + "] could not be found."); } DMNMarshallerImportsHelperStandaloneImpl(); @Inject DMNMarshallerImportsHelperStandaloneImpl(final DMNPathsHelper pathsHelper,
final WorkspaceProjectService projectService,
final DMNMarshaller marshaller,
final DMNIOHelper dmnIOHelper,
final PMMLIncludedDocumentFactory pmmlDocumentFactory,
final @Named("ioStrategy") IOService ioService); @Override Map<Import, Definitions> getImportDefinitions(final Metadata metadata,
final List<Import> imports); @Override Map<Import, PMMLDocumentMetadata> getPMMLDocuments(final Metadata metadata,
final List<Import> imports); @Override Map<Import, String> getImportXML(final Metadata metadata,
final List<Import> imports); @Override Path getDMNModelPath(final Metadata metadata,
final String modelNamespace,
final String modelName); @Override List<DRGElement> getImportedDRGElements(final Map<Import, Definitions> importDefinitions); @Override List<ItemDefinition> getImportedItemDefinitions(final Map<Import, Definitions> importDefinitions); @Override List<ItemDefinition> getImportedItemDefinitionsByNamespace(final WorkspaceProject workspaceProject,
final String modelName,
final String namespace); @Override Optional<InputStream> loadPath(final Path path); static final QName NAMESPACE; }
|
@Test public void testGetContent() { final String actual = "<xml/>"; doReturn(actual).when(service).getSource(path); final String expected = service.getContent(path); assertEquals(expected, actual); }
|
@Override public String getContent(final Path path) { return getSource(path); }
|
DMNContentServiceImpl extends KieService<String> implements DMNContentService { @Override public String getContent(final Path path) { return getSource(path); } }
|
DMNContentServiceImpl extends KieService<String> implements DMNContentService { @Override public String getContent(final Path path) { return getSource(path); } @Inject DMNContentServiceImpl(final CommentedOptionFactory commentedOptionFactory,
final DMNIOHelper dmnIOHelper,
final DMNPathsHelper pathsHelper,
final PMMLIncludedDocumentFactory pmmlIncludedDocumentFactory); }
|
DMNContentServiceImpl extends KieService<String> implements DMNContentService { @Override public String getContent(final Path path) { return getSource(path); } @Inject DMNContentServiceImpl(final CommentedOptionFactory commentedOptionFactory,
final DMNIOHelper dmnIOHelper,
final DMNPathsHelper pathsHelper,
final PMMLIncludedDocumentFactory pmmlIncludedDocumentFactory); @Override String getContent(final Path path); @Override DMNContentResource getProjectContent(final Path path,
final String defSetId); @Override void saveContent(final Path path,
final String content,
final Metadata metadata,
final String comment); @Override List<Path> getModelsPaths(final WorkspaceProject workspaceProject); @Override List<Path> getDMNModelsPaths(final WorkspaceProject workspaceProject); @Override List<Path> getPMMLModelsPaths(final WorkspaceProject workspaceProject); @Override PMMLDocumentMetadata loadPMMLDocumentMetadata(final Path path); @Override String getSource(final Path path); }
|
DMNContentServiceImpl extends KieService<String> implements DMNContentService { @Override public String getContent(final Path path) { return getSource(path); } @Inject DMNContentServiceImpl(final CommentedOptionFactory commentedOptionFactory,
final DMNIOHelper dmnIOHelper,
final DMNPathsHelper pathsHelper,
final PMMLIncludedDocumentFactory pmmlIncludedDocumentFactory); @Override String getContent(final Path path); @Override DMNContentResource getProjectContent(final Path path,
final String defSetId); @Override void saveContent(final Path path,
final String content,
final Metadata metadata,
final String comment); @Override List<Path> getModelsPaths(final WorkspaceProject workspaceProject); @Override List<Path> getDMNModelsPaths(final WorkspaceProject workspaceProject); @Override List<Path> getPMMLModelsPaths(final WorkspaceProject workspaceProject); @Override PMMLDocumentMetadata loadPMMLDocumentMetadata(final Path path); @Override String getSource(final Path path); }
|
@Test @SuppressWarnings("unchecked") public void testExecute() { CommandResult<CanvasViolation> result = tested.execute(canvasHandler); verify(graphCommand, times(1)).execute(eq(graphContext)); verify(canvasCommand, times(1)).execute(eq(canvasHandler)); assertEquals(CommandResult.Type.INFO, result.getType()); assertFalse(result.getViolations().iterator().hasNext()); }
|
@Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { CommandResult<CanvasViolation> result = performOperationOnGraph(context, CommandOperation.EXECUTE); if (canDoNexOperation(result)) { final CommandResult<CanvasViolation> canvasResult = performOperationOnCanvas(context, CommandOperation.EXECUTE); if (!canDoNexOperation(canvasResult)) { performOperationOnGraph(context, CommandOperation.UNDO); return canvasResult; } } return result; }
|
AbstractCanvasGraphCommand extends AbstractCanvasCommand implements HasGraphCommand<AbstractCanvasHandler> { @Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { CommandResult<CanvasViolation> result = performOperationOnGraph(context, CommandOperation.EXECUTE); if (canDoNexOperation(result)) { final CommandResult<CanvasViolation> canvasResult = performOperationOnCanvas(context, CommandOperation.EXECUTE); if (!canDoNexOperation(canvasResult)) { performOperationOnGraph(context, CommandOperation.UNDO); return canvasResult; } } return result; } }
|
AbstractCanvasGraphCommand extends AbstractCanvasCommand implements HasGraphCommand<AbstractCanvasHandler> { @Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { CommandResult<CanvasViolation> result = performOperationOnGraph(context, CommandOperation.EXECUTE); if (canDoNexOperation(result)) { final CommandResult<CanvasViolation> canvasResult = performOperationOnCanvas(context, CommandOperation.EXECUTE); if (!canDoNexOperation(canvasResult)) { performOperationOnGraph(context, CommandOperation.UNDO); return canvasResult; } } return result; } }
|
AbstractCanvasGraphCommand extends AbstractCanvasCommand implements HasGraphCommand<AbstractCanvasHandler> { @Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { CommandResult<CanvasViolation> result = performOperationOnGraph(context, CommandOperation.EXECUTE); if (canDoNexOperation(result)) { final CommandResult<CanvasViolation> canvasResult = performOperationOnCanvas(context, CommandOperation.EXECUTE); if (!canDoNexOperation(canvasResult)) { performOperationOnGraph(context, CommandOperation.UNDO); return canvasResult; } } return result; } @Override Command<GraphCommandExecutionContext, RuleViolation> getGraphCommand(final AbstractCanvasHandler context); Command<AbstractCanvasHandler, CanvasViolation> getCanvasCommand(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); }
|
AbstractCanvasGraphCommand extends AbstractCanvasCommand implements HasGraphCommand<AbstractCanvasHandler> { @Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { CommandResult<CanvasViolation> result = performOperationOnGraph(context, CommandOperation.EXECUTE); if (canDoNexOperation(result)) { final CommandResult<CanvasViolation> canvasResult = performOperationOnCanvas(context, CommandOperation.EXECUTE); if (!canDoNexOperation(canvasResult)) { performOperationOnGraph(context, CommandOperation.UNDO); return canvasResult; } } return result; } @Override Command<GraphCommandExecutionContext, RuleViolation> getGraphCommand(final AbstractCanvasHandler context); Command<AbstractCanvasHandler, CanvasViolation> getCanvasCommand(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); }
|
@Test public void execute() { tested.execute(context); verify(tested).executeCommands(eq(context), commandsCapture.capture()); final CompositeCommand.Builder<AbstractCanvasHandler, CanvasViolation> commands = commandsCapture.getValue(); assertEquals(commands.size(), 7); final List<Command<AbstractCanvasHandler, CanvasViolation>> commandList = new ArrayList<>(); for (int i = 0; i < commands.size(); i++) { Command<AbstractCanvasHandler, CanvasViolation> cmd = commands.get(i); commandList.add(cmd); } assertEquals(commandList.stream().filter(cmd -> cmd instanceof AddCanvasNodeCommand).count(), 1); assertEquals(commandList.stream().filter(cmd -> cmd instanceof AddCanvasChildNodeCommand).count(), 3); assertEquals(commandList.stream().filter(cmd -> cmd instanceof AddCanvasDockedNodeCommand).count(), 1); assertEquals(commandList.stream().filter(cmd -> cmd instanceof AddCanvasConnectorCommand).count(), 2); }
|
@Override @SuppressWarnings("unchecked") public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { final Graph graph = context.getGraphIndex().getGraph(); final String shapeSetId = getShapeSetId(context); final CompositeCommand.Builder<AbstractCanvasHandler, CanvasViolation> commandBuilder = new CompositeCommand.Builder<AbstractCanvasHandler, CanvasViolation>().forward(); childrenTraverseProcessor .traverse(graph, new AbstractChildrenTraverseCallback<Node<View, Edge>, Edge<Child, Node>>() { private Map<String, Boolean> processedNodes = new HashMap<>(); @Override public void startNodeTraversal(final Node<View, Edge> node) { super.startNodeTraversal(node); if (!isCanvasRoot().test(context, node.getUUID())) { addNode(node); } } @Override public boolean startNodeTraversal(final List<Node<View, Edge>> parents, final Node<View, Edge> node) { super.startNodeTraversal(parents, node); final Optional<Edge> dockEdge = node.getInEdges().stream() .filter(e -> e.getContent() instanceof Dock) .findAny(); final Node parent = dockEdge.map(Edge::getSourceNode) .orElseGet(() -> parents.get(parents.size() - 1)); if (dockEdge.isPresent()) { addDockedNode(parent, node); } else if (isCanvasRoot(). test(context, parent.getUUID())) { addNode(node); } else { addChildNode(parent, node); } return true; } private void addNode(final Node node) { if (processedNodes.containsKey(node.getUUID())) { return; } commandBuilder.addCommand(new AddCanvasNodeCommand(node, shapeSetId)); addProcessedNode(node); } private void addChildNode(final Node<View, Edge> parent, final Node<View, Edge> node) { if (processedNodes.containsKey(node.getUUID())) { return; } if (!processedNodes.containsKey(parent.getUUID())) { addNode(parent); } commandBuilder.addCommand(new AddCanvasChildNodeCommand(parent, node, shapeSetId)); addProcessedNode(node); } private void addDockedNode(final Node<View, Edge> parent, final Node<View, Edge> node) { if (!processedNodes.containsKey(parent.getUUID())) { addNode(parent); } commandBuilder.addCommand(new AddCanvasDockedNodeCommand(parent, node, shapeSetId)); addProcessedNode(node); } private void addProcessedNode(Node<View, Edge> node) { processedNodes.put(node.getUUID(), true); } @Override public void endGraphTraversal() { super.endGraphTraversal(); processedNodes.clear(); processedNodes = null; } }); viewTraverseProcessor .traverse(graph, new AbstractContentTraverseCallback<View<?>, Node<View, Edge>, Edge<View<?>, Node>>() { @Override public void startEdgeTraversal(final Edge<View<?>, Node> edge) { super.startEdgeTraversal(edge); commandBuilder.addCommand(new AddCanvasConnectorCommand(edge, shapeSetId)); } }); return executeCommands(context, commandBuilder); }
|
DrawCanvasCommand extends AbstractCanvasCommand { @Override @SuppressWarnings("unchecked") public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { final Graph graph = context.getGraphIndex().getGraph(); final String shapeSetId = getShapeSetId(context); final CompositeCommand.Builder<AbstractCanvasHandler, CanvasViolation> commandBuilder = new CompositeCommand.Builder<AbstractCanvasHandler, CanvasViolation>().forward(); childrenTraverseProcessor .traverse(graph, new AbstractChildrenTraverseCallback<Node<View, Edge>, Edge<Child, Node>>() { private Map<String, Boolean> processedNodes = new HashMap<>(); @Override public void startNodeTraversal(final Node<View, Edge> node) { super.startNodeTraversal(node); if (!isCanvasRoot().test(context, node.getUUID())) { addNode(node); } } @Override public boolean startNodeTraversal(final List<Node<View, Edge>> parents, final Node<View, Edge> node) { super.startNodeTraversal(parents, node); final Optional<Edge> dockEdge = node.getInEdges().stream() .filter(e -> e.getContent() instanceof Dock) .findAny(); final Node parent = dockEdge.map(Edge::getSourceNode) .orElseGet(() -> parents.get(parents.size() - 1)); if (dockEdge.isPresent()) { addDockedNode(parent, node); } else if (isCanvasRoot(). test(context, parent.getUUID())) { addNode(node); } else { addChildNode(parent, node); } return true; } private void addNode(final Node node) { if (processedNodes.containsKey(node.getUUID())) { return; } commandBuilder.addCommand(new AddCanvasNodeCommand(node, shapeSetId)); addProcessedNode(node); } private void addChildNode(final Node<View, Edge> parent, final Node<View, Edge> node) { if (processedNodes.containsKey(node.getUUID())) { return; } if (!processedNodes.containsKey(parent.getUUID())) { addNode(parent); } commandBuilder.addCommand(new AddCanvasChildNodeCommand(parent, node, shapeSetId)); addProcessedNode(node); } private void addDockedNode(final Node<View, Edge> parent, final Node<View, Edge> node) { if (!processedNodes.containsKey(parent.getUUID())) { addNode(parent); } commandBuilder.addCommand(new AddCanvasDockedNodeCommand(parent, node, shapeSetId)); addProcessedNode(node); } private void addProcessedNode(Node<View, Edge> node) { processedNodes.put(node.getUUID(), true); } @Override public void endGraphTraversal() { super.endGraphTraversal(); processedNodes.clear(); processedNodes = null; } }); viewTraverseProcessor .traverse(graph, new AbstractContentTraverseCallback<View<?>, Node<View, Edge>, Edge<View<?>, Node>>() { @Override public void startEdgeTraversal(final Edge<View<?>, Node> edge) { super.startEdgeTraversal(edge); commandBuilder.addCommand(new AddCanvasConnectorCommand(edge, shapeSetId)); } }); return executeCommands(context, commandBuilder); } }
|
DrawCanvasCommand extends AbstractCanvasCommand { @Override @SuppressWarnings("unchecked") public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { final Graph graph = context.getGraphIndex().getGraph(); final String shapeSetId = getShapeSetId(context); final CompositeCommand.Builder<AbstractCanvasHandler, CanvasViolation> commandBuilder = new CompositeCommand.Builder<AbstractCanvasHandler, CanvasViolation>().forward(); childrenTraverseProcessor .traverse(graph, new AbstractChildrenTraverseCallback<Node<View, Edge>, Edge<Child, Node>>() { private Map<String, Boolean> processedNodes = new HashMap<>(); @Override public void startNodeTraversal(final Node<View, Edge> node) { super.startNodeTraversal(node); if (!isCanvasRoot().test(context, node.getUUID())) { addNode(node); } } @Override public boolean startNodeTraversal(final List<Node<View, Edge>> parents, final Node<View, Edge> node) { super.startNodeTraversal(parents, node); final Optional<Edge> dockEdge = node.getInEdges().stream() .filter(e -> e.getContent() instanceof Dock) .findAny(); final Node parent = dockEdge.map(Edge::getSourceNode) .orElseGet(() -> parents.get(parents.size() - 1)); if (dockEdge.isPresent()) { addDockedNode(parent, node); } else if (isCanvasRoot(). test(context, parent.getUUID())) { addNode(node); } else { addChildNode(parent, node); } return true; } private void addNode(final Node node) { if (processedNodes.containsKey(node.getUUID())) { return; } commandBuilder.addCommand(new AddCanvasNodeCommand(node, shapeSetId)); addProcessedNode(node); } private void addChildNode(final Node<View, Edge> parent, final Node<View, Edge> node) { if (processedNodes.containsKey(node.getUUID())) { return; } if (!processedNodes.containsKey(parent.getUUID())) { addNode(parent); } commandBuilder.addCommand(new AddCanvasChildNodeCommand(parent, node, shapeSetId)); addProcessedNode(node); } private void addDockedNode(final Node<View, Edge> parent, final Node<View, Edge> node) { if (!processedNodes.containsKey(parent.getUUID())) { addNode(parent); } commandBuilder.addCommand(new AddCanvasDockedNodeCommand(parent, node, shapeSetId)); addProcessedNode(node); } private void addProcessedNode(Node<View, Edge> node) { processedNodes.put(node.getUUID(), true); } @Override public void endGraphTraversal() { super.endGraphTraversal(); processedNodes.clear(); processedNodes = null; } }); viewTraverseProcessor .traverse(graph, new AbstractContentTraverseCallback<View<?>, Node<View, Edge>, Edge<View<?>, Node>>() { @Override public void startEdgeTraversal(final Edge<View<?>, Node> edge) { super.startEdgeTraversal(edge); commandBuilder.addCommand(new AddCanvasConnectorCommand(edge, shapeSetId)); } }); return executeCommands(context, commandBuilder); } DrawCanvasCommand(final ChildrenTraverseProcessor childrenTraverseProcessor,
final ViewTraverseProcessor viewTraverseProcessor); }
|
DrawCanvasCommand extends AbstractCanvasCommand { @Override @SuppressWarnings("unchecked") public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { final Graph graph = context.getGraphIndex().getGraph(); final String shapeSetId = getShapeSetId(context); final CompositeCommand.Builder<AbstractCanvasHandler, CanvasViolation> commandBuilder = new CompositeCommand.Builder<AbstractCanvasHandler, CanvasViolation>().forward(); childrenTraverseProcessor .traverse(graph, new AbstractChildrenTraverseCallback<Node<View, Edge>, Edge<Child, Node>>() { private Map<String, Boolean> processedNodes = new HashMap<>(); @Override public void startNodeTraversal(final Node<View, Edge> node) { super.startNodeTraversal(node); if (!isCanvasRoot().test(context, node.getUUID())) { addNode(node); } } @Override public boolean startNodeTraversal(final List<Node<View, Edge>> parents, final Node<View, Edge> node) { super.startNodeTraversal(parents, node); final Optional<Edge> dockEdge = node.getInEdges().stream() .filter(e -> e.getContent() instanceof Dock) .findAny(); final Node parent = dockEdge.map(Edge::getSourceNode) .orElseGet(() -> parents.get(parents.size() - 1)); if (dockEdge.isPresent()) { addDockedNode(parent, node); } else if (isCanvasRoot(). test(context, parent.getUUID())) { addNode(node); } else { addChildNode(parent, node); } return true; } private void addNode(final Node node) { if (processedNodes.containsKey(node.getUUID())) { return; } commandBuilder.addCommand(new AddCanvasNodeCommand(node, shapeSetId)); addProcessedNode(node); } private void addChildNode(final Node<View, Edge> parent, final Node<View, Edge> node) { if (processedNodes.containsKey(node.getUUID())) { return; } if (!processedNodes.containsKey(parent.getUUID())) { addNode(parent); } commandBuilder.addCommand(new AddCanvasChildNodeCommand(parent, node, shapeSetId)); addProcessedNode(node); } private void addDockedNode(final Node<View, Edge> parent, final Node<View, Edge> node) { if (!processedNodes.containsKey(parent.getUUID())) { addNode(parent); } commandBuilder.addCommand(new AddCanvasDockedNodeCommand(parent, node, shapeSetId)); addProcessedNode(node); } private void addProcessedNode(Node<View, Edge> node) { processedNodes.put(node.getUUID(), true); } @Override public void endGraphTraversal() { super.endGraphTraversal(); processedNodes.clear(); processedNodes = null; } }); viewTraverseProcessor .traverse(graph, new AbstractContentTraverseCallback<View<?>, Node<View, Edge>, Edge<View<?>, Node>>() { @Override public void startEdgeTraversal(final Edge<View<?>, Node> edge) { super.startEdgeTraversal(edge); commandBuilder.addCommand(new AddCanvasConnectorCommand(edge, shapeSetId)); } }); return executeCommands(context, commandBuilder); } DrawCanvasCommand(final ChildrenTraverseProcessor childrenTraverseProcessor,
final ViewTraverseProcessor viewTraverseProcessor); @Override @SuppressWarnings("unchecked") CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); @Override String toString(); }
|
DrawCanvasCommand extends AbstractCanvasCommand { @Override @SuppressWarnings("unchecked") public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { final Graph graph = context.getGraphIndex().getGraph(); final String shapeSetId = getShapeSetId(context); final CompositeCommand.Builder<AbstractCanvasHandler, CanvasViolation> commandBuilder = new CompositeCommand.Builder<AbstractCanvasHandler, CanvasViolation>().forward(); childrenTraverseProcessor .traverse(graph, new AbstractChildrenTraverseCallback<Node<View, Edge>, Edge<Child, Node>>() { private Map<String, Boolean> processedNodes = new HashMap<>(); @Override public void startNodeTraversal(final Node<View, Edge> node) { super.startNodeTraversal(node); if (!isCanvasRoot().test(context, node.getUUID())) { addNode(node); } } @Override public boolean startNodeTraversal(final List<Node<View, Edge>> parents, final Node<View, Edge> node) { super.startNodeTraversal(parents, node); final Optional<Edge> dockEdge = node.getInEdges().stream() .filter(e -> e.getContent() instanceof Dock) .findAny(); final Node parent = dockEdge.map(Edge::getSourceNode) .orElseGet(() -> parents.get(parents.size() - 1)); if (dockEdge.isPresent()) { addDockedNode(parent, node); } else if (isCanvasRoot(). test(context, parent.getUUID())) { addNode(node); } else { addChildNode(parent, node); } return true; } private void addNode(final Node node) { if (processedNodes.containsKey(node.getUUID())) { return; } commandBuilder.addCommand(new AddCanvasNodeCommand(node, shapeSetId)); addProcessedNode(node); } private void addChildNode(final Node<View, Edge> parent, final Node<View, Edge> node) { if (processedNodes.containsKey(node.getUUID())) { return; } if (!processedNodes.containsKey(parent.getUUID())) { addNode(parent); } commandBuilder.addCommand(new AddCanvasChildNodeCommand(parent, node, shapeSetId)); addProcessedNode(node); } private void addDockedNode(final Node<View, Edge> parent, final Node<View, Edge> node) { if (!processedNodes.containsKey(parent.getUUID())) { addNode(parent); } commandBuilder.addCommand(new AddCanvasDockedNodeCommand(parent, node, shapeSetId)); addProcessedNode(node); } private void addProcessedNode(Node<View, Edge> node) { processedNodes.put(node.getUUID(), true); } @Override public void endGraphTraversal() { super.endGraphTraversal(); processedNodes.clear(); processedNodes = null; } }); viewTraverseProcessor .traverse(graph, new AbstractContentTraverseCallback<View<?>, Node<View, Edge>, Edge<View<?>, Node>>() { @Override public void startEdgeTraversal(final Edge<View<?>, Node> edge) { super.startEdgeTraversal(edge); commandBuilder.addCommand(new AddCanvasConnectorCommand(edge, shapeSetId)); } }); return executeCommands(context, commandBuilder); } DrawCanvasCommand(final ChildrenTraverseProcessor childrenTraverseProcessor,
final ViewTraverseProcessor viewTraverseProcessor); @Override @SuppressWarnings("unchecked") CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); @Override String toString(); }
|
@Test public void testNewGraphCommand() { Command<GraphCommandExecutionContext, RuleViolation> graphCommand = cloneNodeCommand.newGraphCommand(canvasHandler); assertTrue(graphCommand instanceof org.kie.workbench.common.stunner.core.graph.command.impl.CloneNodeCommand); }
|
@Override @SuppressWarnings("unchecked") protected Command<GraphCommandExecutionContext, RuleViolation> newGraphCommand(final AbstractCanvasHandler context) { return new org.kie.workbench.common.stunner.core.graph.command.impl.CloneNodeCommand(candidate, parentUuid, getClonePosition(), cloneNodeCallback(context), childrenTraverseProcessor); }
|
CloneNodeCommand extends AbstractCanvasGraphCommand { @Override @SuppressWarnings("unchecked") protected Command<GraphCommandExecutionContext, RuleViolation> newGraphCommand(final AbstractCanvasHandler context) { return new org.kie.workbench.common.stunner.core.graph.command.impl.CloneNodeCommand(candidate, parentUuid, getClonePosition(), cloneNodeCallback(context), childrenTraverseProcessor); } }
|
CloneNodeCommand extends AbstractCanvasGraphCommand { @Override @SuppressWarnings("unchecked") protected Command<GraphCommandExecutionContext, RuleViolation> newGraphCommand(final AbstractCanvasHandler context) { return new org.kie.workbench.common.stunner.core.graph.command.impl.CloneNodeCommand(candidate, parentUuid, getClonePosition(), cloneNodeCallback(context), childrenTraverseProcessor); } @SuppressWarnings("unchecked") CloneNodeCommand(final Node candidate, final String parentUuid, final Point2D cloneLocation, final Consumer<Node> cloneNodeCommandCallback, final ManagedInstance<ChildrenTraverseProcessor> childrenTraverseProcessor); }
|
CloneNodeCommand extends AbstractCanvasGraphCommand { @Override @SuppressWarnings("unchecked") protected Command<GraphCommandExecutionContext, RuleViolation> newGraphCommand(final AbstractCanvasHandler context) { return new org.kie.workbench.common.stunner.core.graph.command.impl.CloneNodeCommand(candidate, parentUuid, getClonePosition(), cloneNodeCallback(context), childrenTraverseProcessor); } @SuppressWarnings("unchecked") CloneNodeCommand(final Node candidate, final String parentUuid, final Point2D cloneLocation, final Consumer<Node> cloneNodeCommandCallback, final ManagedInstance<ChildrenTraverseProcessor> childrenTraverseProcessor); CloneCanvasNodeCommand getCloneCanvasNodeCommand(Node parent, Node clone, String shapeId); ManagedInstance<ChildrenTraverseProcessor> getChildrenTraverseProcessor(); Node getCandidate(); @Override String toString(); }
|
CloneNodeCommand extends AbstractCanvasGraphCommand { @Override @SuppressWarnings("unchecked") protected Command<GraphCommandExecutionContext, RuleViolation> newGraphCommand(final AbstractCanvasHandler context) { return new org.kie.workbench.common.stunner.core.graph.command.impl.CloneNodeCommand(candidate, parentUuid, getClonePosition(), cloneNodeCallback(context), childrenTraverseProcessor); } @SuppressWarnings("unchecked") CloneNodeCommand(final Node candidate, final String parentUuid, final Point2D cloneLocation, final Consumer<Node> cloneNodeCommandCallback, final ManagedInstance<ChildrenTraverseProcessor> childrenTraverseProcessor); CloneCanvasNodeCommand getCloneCanvasNodeCommand(Node parent, Node clone, String shapeId); ManagedInstance<ChildrenTraverseProcessor> getChildrenTraverseProcessor(); Node getCandidate(); @Override String toString(); }
|
@Test public void testNewCanvasCommand() { Command<AbstractCanvasHandler, CanvasViolation> canvasCommand = cloneNodeCommand.newCanvasCommand(canvasHandler); assertTrue(canvasCommand instanceof CompositeCommand); }
|
@Override protected Command<AbstractCanvasHandler, CanvasViolation> newCanvasCommand(final AbstractCanvasHandler context) { return this.command; }
|
CloneNodeCommand extends AbstractCanvasGraphCommand { @Override protected Command<AbstractCanvasHandler, CanvasViolation> newCanvasCommand(final AbstractCanvasHandler context) { return this.command; } }
|
CloneNodeCommand extends AbstractCanvasGraphCommand { @Override protected Command<AbstractCanvasHandler, CanvasViolation> newCanvasCommand(final AbstractCanvasHandler context) { return this.command; } @SuppressWarnings("unchecked") CloneNodeCommand(final Node candidate, final String parentUuid, final Point2D cloneLocation, final Consumer<Node> cloneNodeCommandCallback, final ManagedInstance<ChildrenTraverseProcessor> childrenTraverseProcessor); }
|
CloneNodeCommand extends AbstractCanvasGraphCommand { @Override protected Command<AbstractCanvasHandler, CanvasViolation> newCanvasCommand(final AbstractCanvasHandler context) { return this.command; } @SuppressWarnings("unchecked") CloneNodeCommand(final Node candidate, final String parentUuid, final Point2D cloneLocation, final Consumer<Node> cloneNodeCommandCallback, final ManagedInstance<ChildrenTraverseProcessor> childrenTraverseProcessor); CloneCanvasNodeCommand getCloneCanvasNodeCommand(Node parent, Node clone, String shapeId); ManagedInstance<ChildrenTraverseProcessor> getChildrenTraverseProcessor(); Node getCandidate(); @Override String toString(); }
|
CloneNodeCommand extends AbstractCanvasGraphCommand { @Override protected Command<AbstractCanvasHandler, CanvasViolation> newCanvasCommand(final AbstractCanvasHandler context) { return this.command; } @SuppressWarnings("unchecked") CloneNodeCommand(final Node candidate, final String parentUuid, final Point2D cloneLocation, final Consumer<Node> cloneNodeCommandCallback, final ManagedInstance<ChildrenTraverseProcessor> childrenTraverseProcessor); CloneCanvasNodeCommand getCloneCanvasNodeCommand(Node parent, Node clone, String shapeId); ManagedInstance<ChildrenTraverseProcessor> getChildrenTraverseProcessor(); Node getCandidate(); @Override String toString(); }
|
@Test @SuppressWarnings("unchecked") public void testExecute() { final CommandResult<CanvasViolation> result = tested.execute(canvasHandler); assertNotEquals(CommandResult.Type.ERROR, result.getType()); verify(canvasHandler, times(0)).register(anyString(), eq(candidate)); verify(canvasHandler, times(0)).addChild(any(Node.class), any(Node.class)); verify(canvasHandler, times(1)).undock(eq(parent), eq(candidate)); verify(canvasHandler, times(1)).applyElementMutation(eq(candidate), any(MutationContext.class)); verify(canvasHandler, times(1)).applyElementMutation(eq(parent), any(MutationContext.class)); }
|
@Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { if (Objects.isNull(parent) || Objects.isNull(child)) { throw new IllegalArgumentException("Parent and child should not be null"); } context.undock(parent, child); getChild().getInEdges().stream() .filter(e -> e.getContent() instanceof Child) .findAny() .ifPresent(e -> context.addChild(e.getSourceNode(), child)); if (existNode(parent, context)) { context.applyElementMutation(parent, MutationContext.STATIC); } if (existNode(child, context)) { context.applyElementMutation(child, MutationContext.STATIC); } return buildResult(); }
|
CanvasUndockNodeCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { if (Objects.isNull(parent) || Objects.isNull(child)) { throw new IllegalArgumentException("Parent and child should not be null"); } context.undock(parent, child); getChild().getInEdges().stream() .filter(e -> e.getContent() instanceof Child) .findAny() .ifPresent(e -> context.addChild(e.getSourceNode(), child)); if (existNode(parent, context)) { context.applyElementMutation(parent, MutationContext.STATIC); } if (existNode(child, context)) { context.applyElementMutation(child, MutationContext.STATIC); } return buildResult(); } }
|
CanvasUndockNodeCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { if (Objects.isNull(parent) || Objects.isNull(child)) { throw new IllegalArgumentException("Parent and child should not be null"); } context.undock(parent, child); getChild().getInEdges().stream() .filter(e -> e.getContent() instanceof Child) .findAny() .ifPresent(e -> context.addChild(e.getSourceNode(), child)); if (existNode(parent, context)) { context.applyElementMutation(parent, MutationContext.STATIC); } if (existNode(child, context)) { context.applyElementMutation(child, MutationContext.STATIC); } return buildResult(); } CanvasUndockNodeCommand(final Node parent,
final Node child); }
|
CanvasUndockNodeCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { if (Objects.isNull(parent) || Objects.isNull(child)) { throw new IllegalArgumentException("Parent and child should not be null"); } context.undock(parent, child); getChild().getInEdges().stream() .filter(e -> e.getContent() instanceof Child) .findAny() .ifPresent(e -> context.addChild(e.getSourceNode(), child)); if (existNode(parent, context)) { context.applyElementMutation(parent, MutationContext.STATIC); } if (existNode(child, context)) { context.applyElementMutation(child, MutationContext.STATIC); } return buildResult(); } CanvasUndockNodeCommand(final Node parent,
final Node child); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); Node getParent(); Node<?, Edge> getChild(); @Override String toString(); }
|
CanvasUndockNodeCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { if (Objects.isNull(parent) || Objects.isNull(child)) { throw new IllegalArgumentException("Parent and child should not be null"); } context.undock(parent, child); getChild().getInEdges().stream() .filter(e -> e.getContent() instanceof Child) .findAny() .ifPresent(e -> context.addChild(e.getSourceNode(), child)); if (existNode(parent, context)) { context.applyElementMutation(parent, MutationContext.STATIC); } if (existNode(child, context)) { context.applyElementMutation(child, MutationContext.STATIC); } return buildResult(); } CanvasUndockNodeCommand(final Node parent,
final Node child); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); Node getParent(); Node<?, Edge> getChild(); @Override String toString(); }
|
@Test @SuppressWarnings("unchecked") public void testExecuteButCandidateHasBeenRemoved() { when(graphIndex.getNode(eq(C_ID))).thenReturn(null); final CommandResult<CanvasViolation> result = tested.execute(canvasHandler); assertNotEquals(CommandResult.Type.ERROR, result.getType()); verify(canvasHandler, times(0)).register(anyString(), eq(candidate)); verify(canvasHandler, times(0)).addChild(any(Node.class), any(Node.class)); verify(canvasHandler, times(1)).undock(eq(parent), eq(candidate)); verify(canvasHandler, never()).applyElementMutation(eq(candidate), any(MutationContext.class)); verify(canvasHandler, times(1)).applyElementMutation(eq(parent), any(MutationContext.class)); }
|
@Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { if (Objects.isNull(parent) || Objects.isNull(child)) { throw new IllegalArgumentException("Parent and child should not be null"); } context.undock(parent, child); getChild().getInEdges().stream() .filter(e -> e.getContent() instanceof Child) .findAny() .ifPresent(e -> context.addChild(e.getSourceNode(), child)); if (existNode(parent, context)) { context.applyElementMutation(parent, MutationContext.STATIC); } if (existNode(child, context)) { context.applyElementMutation(child, MutationContext.STATIC); } return buildResult(); }
|
CanvasUndockNodeCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { if (Objects.isNull(parent) || Objects.isNull(child)) { throw new IllegalArgumentException("Parent and child should not be null"); } context.undock(parent, child); getChild().getInEdges().stream() .filter(e -> e.getContent() instanceof Child) .findAny() .ifPresent(e -> context.addChild(e.getSourceNode(), child)); if (existNode(parent, context)) { context.applyElementMutation(parent, MutationContext.STATIC); } if (existNode(child, context)) { context.applyElementMutation(child, MutationContext.STATIC); } return buildResult(); } }
|
CanvasUndockNodeCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { if (Objects.isNull(parent) || Objects.isNull(child)) { throw new IllegalArgumentException("Parent and child should not be null"); } context.undock(parent, child); getChild().getInEdges().stream() .filter(e -> e.getContent() instanceof Child) .findAny() .ifPresent(e -> context.addChild(e.getSourceNode(), child)); if (existNode(parent, context)) { context.applyElementMutation(parent, MutationContext.STATIC); } if (existNode(child, context)) { context.applyElementMutation(child, MutationContext.STATIC); } return buildResult(); } CanvasUndockNodeCommand(final Node parent,
final Node child); }
|
CanvasUndockNodeCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { if (Objects.isNull(parent) || Objects.isNull(child)) { throw new IllegalArgumentException("Parent and child should not be null"); } context.undock(parent, child); getChild().getInEdges().stream() .filter(e -> e.getContent() instanceof Child) .findAny() .ifPresent(e -> context.addChild(e.getSourceNode(), child)); if (existNode(parent, context)) { context.applyElementMutation(parent, MutationContext.STATIC); } if (existNode(child, context)) { context.applyElementMutation(child, MutationContext.STATIC); } return buildResult(); } CanvasUndockNodeCommand(final Node parent,
final Node child); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); Node getParent(); Node<?, Edge> getChild(); @Override String toString(); }
|
CanvasUndockNodeCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { if (Objects.isNull(parent) || Objects.isNull(child)) { throw new IllegalArgumentException("Parent and child should not be null"); } context.undock(parent, child); getChild().getInEdges().stream() .filter(e -> e.getContent() instanceof Child) .findAny() .ifPresent(e -> context.addChild(e.getSourceNode(), child)); if (existNode(parent, context)) { context.applyElementMutation(parent, MutationContext.STATIC); } if (existNode(child, context)) { context.applyElementMutation(child, MutationContext.STATIC); } return buildResult(); } CanvasUndockNodeCommand(final Node parent,
final Node child); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); Node getParent(); Node<?, Edge> getChild(); @Override String toString(); }
|
@Test public void testChecks() { tested = new DeleteCanvasControlPointCommand(edge, 0); CommandResult<CanvasViolation> result = tested.allow(canvasHandler); assertFalse(CommandUtils.isError(result)); tested = new DeleteCanvasControlPointCommand(edge, 1); result = tested.allow(canvasHandler); assertFalse(CommandUtils.isError(result)); tested = new DeleteCanvasControlPointCommand(edge, 2); result = tested.allow(canvasHandler); assertFalse(CommandUtils.isError(result)); }
|
@Override public CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context) { ControlPointValidations.checkDeleteControlPoint(getViewControlPoints(context, candidate), index); return CanvasCommandResultBuilder.SUCCESS; }
|
DeleteCanvasControlPointCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context) { ControlPointValidations.checkDeleteControlPoint(getViewControlPoints(context, candidate), index); return CanvasCommandResultBuilder.SUCCESS; } }
|
DeleteCanvasControlPointCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context) { ControlPointValidations.checkDeleteControlPoint(getViewControlPoints(context, candidate), index); return CanvasCommandResultBuilder.SUCCESS; } DeleteCanvasControlPointCommand(final Edge candidate,
final int index); }
|
DeleteCanvasControlPointCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context) { ControlPointValidations.checkDeleteControlPoint(getViewControlPoints(context, candidate), index); return CanvasCommandResultBuilder.SUCCESS; } DeleteCanvasControlPointCommand(final Edge candidate,
final int index); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); @Override String toString(); }
|
DeleteCanvasControlPointCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context) { ControlPointValidations.checkDeleteControlPoint(getViewControlPoints(context, candidate), index); return CanvasCommandResultBuilder.SUCCESS; } DeleteCanvasControlPointCommand(final Edge candidate,
final int index); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); @Override String toString(); }
|
@Test(expected = IllegalArgumentException.class) public void testInvalidIndex() { tested = new DeleteCanvasControlPointCommand(edge, -1); tested.allow(canvasHandler); }
|
@Override public CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context) { ControlPointValidations.checkDeleteControlPoint(getViewControlPoints(context, candidate), index); return CanvasCommandResultBuilder.SUCCESS; }
|
DeleteCanvasControlPointCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context) { ControlPointValidations.checkDeleteControlPoint(getViewControlPoints(context, candidate), index); return CanvasCommandResultBuilder.SUCCESS; } }
|
DeleteCanvasControlPointCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context) { ControlPointValidations.checkDeleteControlPoint(getViewControlPoints(context, candidate), index); return CanvasCommandResultBuilder.SUCCESS; } DeleteCanvasControlPointCommand(final Edge candidate,
final int index); }
|
DeleteCanvasControlPointCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context) { ControlPointValidations.checkDeleteControlPoint(getViewControlPoints(context, candidate), index); return CanvasCommandResultBuilder.SUCCESS; } DeleteCanvasControlPointCommand(final Edge candidate,
final int index); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); @Override String toString(); }
|
DeleteCanvasControlPointCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context) { ControlPointValidations.checkDeleteControlPoint(getViewControlPoints(context, candidate), index); return CanvasCommandResultBuilder.SUCCESS; } DeleteCanvasControlPointCommand(final Edge candidate,
final int index); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); @Override String toString(); }
|
@Test(expected = IllegalArgumentException.class) public void testIndexForbidden() { tested = new DeleteCanvasControlPointCommand(edge, 3); tested.allow(canvasHandler); }
|
@Override public CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context) { ControlPointValidations.checkDeleteControlPoint(getViewControlPoints(context, candidate), index); return CanvasCommandResultBuilder.SUCCESS; }
|
DeleteCanvasControlPointCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context) { ControlPointValidations.checkDeleteControlPoint(getViewControlPoints(context, candidate), index); return CanvasCommandResultBuilder.SUCCESS; } }
|
DeleteCanvasControlPointCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context) { ControlPointValidations.checkDeleteControlPoint(getViewControlPoints(context, candidate), index); return CanvasCommandResultBuilder.SUCCESS; } DeleteCanvasControlPointCommand(final Edge candidate,
final int index); }
|
DeleteCanvasControlPointCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context) { ControlPointValidations.checkDeleteControlPoint(getViewControlPoints(context, candidate), index); return CanvasCommandResultBuilder.SUCCESS; } DeleteCanvasControlPointCommand(final Edge candidate,
final int index); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); @Override String toString(); }
|
DeleteCanvasControlPointCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context) { ControlPointValidations.checkDeleteControlPoint(getViewControlPoints(context, candidate), index); return CanvasCommandResultBuilder.SUCCESS; } DeleteCanvasControlPointCommand(final Edge candidate,
final int index); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); @Override String toString(); }
|
@Test(expected = IllegalArgumentException.class) public void testInvalidIndexDuringExecute() { tested = new DeleteCanvasControlPointCommand(edge, -1); tested.execute(canvasHandler); }
|
@Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { allow(context); consumeControlPoints(context, candidate, view -> { this.deletedControlPoint = view.getManageableControlPoints()[index]; view.deleteControlPoint(index); }); return buildResult(); }
|
DeleteCanvasControlPointCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { allow(context); consumeControlPoints(context, candidate, view -> { this.deletedControlPoint = view.getManageableControlPoints()[index]; view.deleteControlPoint(index); }); return buildResult(); } }
|
DeleteCanvasControlPointCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { allow(context); consumeControlPoints(context, candidate, view -> { this.deletedControlPoint = view.getManageableControlPoints()[index]; view.deleteControlPoint(index); }); return buildResult(); } DeleteCanvasControlPointCommand(final Edge candidate,
final int index); }
|
DeleteCanvasControlPointCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { allow(context); consumeControlPoints(context, candidate, view -> { this.deletedControlPoint = view.getManageableControlPoints()[index]; view.deleteControlPoint(index); }); return buildResult(); } DeleteCanvasControlPointCommand(final Edge candidate,
final int index); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); @Override String toString(); }
|
DeleteCanvasControlPointCommand extends AbstractCanvasCommand { @Override public CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context) { allow(context); consumeControlPoints(context, candidate, view -> { this.deletedControlPoint = view.getManageableControlPoints()[index]; view.deleteControlPoint(index); }); return buildResult(); } DeleteCanvasControlPointCommand(final Edge candidate,
final int index); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); @Override String toString(); }
|
@Test public void testRemoveOnClosedByKeyboardCallback() { final PopupEditorControls editor = mock(PopupEditorControls.class, withSettings().extraInterfaces(CanBeClosedByKeyboard.class)); view.removeOnClosedByKeyboardCallback(editor); verify((CanBeClosedByKeyboard) editor).setOnClosedByKeyboardCallback(null); }
|
void removeOnClosedByKeyboardCallback(final PopupEditorControls editor) { if (editor instanceof CanBeClosedByKeyboard) { ((CanBeClosedByKeyboard) editor).setOnClosedByKeyboardCallback(null); } }
|
CellEditorControlsViewImpl implements CellEditorControlsView { void removeOnClosedByKeyboardCallback(final PopupEditorControls editor) { if (editor instanceof CanBeClosedByKeyboard) { ((CanBeClosedByKeyboard) editor).setOnClosedByKeyboardCallback(null); } } }
|
CellEditorControlsViewImpl implements CellEditorControlsView { void removeOnClosedByKeyboardCallback(final PopupEditorControls editor) { if (editor instanceof CanBeClosedByKeyboard) { ((CanBeClosedByKeyboard) editor).setOnClosedByKeyboardCallback(null); } } CellEditorControlsViewImpl(); @Inject CellEditorControlsViewImpl(final Document document,
final Div cellEditorControls,
final Div cellEditorControlsContainer); }
|
CellEditorControlsViewImpl implements CellEditorControlsView { void removeOnClosedByKeyboardCallback(final PopupEditorControls editor) { if (editor instanceof CanBeClosedByKeyboard) { ((CanBeClosedByKeyboard) editor).setOnClosedByKeyboardCallback(null); } } CellEditorControlsViewImpl(); @Inject CellEditorControlsViewImpl(final Document document,
final Div cellEditorControls,
final Div cellEditorControlsContainer); Optional<PopupEditorControls> getActiveEditor(); void setActiveEditor(final Optional<PopupEditorControls> activeEditor); @PostConstruct void setup(); @PreDestroy void destroy(); @Override void show(final PopupEditorControls editor,
final int x,
final int y); @Override void hide(); }
|
CellEditorControlsViewImpl implements CellEditorControlsView { void removeOnClosedByKeyboardCallback(final PopupEditorControls editor) { if (editor instanceof CanBeClosedByKeyboard) { ((CanBeClosedByKeyboard) editor).setOnClosedByKeyboardCallback(null); } } CellEditorControlsViewImpl(); @Inject CellEditorControlsViewImpl(final Document document,
final Div cellEditorControls,
final Div cellEditorControlsContainer); Optional<PopupEditorControls> getActiveEditor(); void setActiveEditor(final Optional<PopupEditorControls> activeEditor); @PostConstruct void setup(); @PreDestroy void destroy(); @Override void show(final PopupEditorControls editor,
final int x,
final int y); @Override void hide(); static final String LEFT; static final String TOP; }
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.