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 testUpdate() { Element element = mock(Element.class); defaultCanvasElementListener.update(element); updatableRegistrationControls.forEach(control -> verify(control).update(element)); }
|
@Override public void update(final Element item) { onElementRegistration(item, false, true); }
|
DefaultCanvasElementListener implements CanvasElementListener { @Override public void update(final Element item) { onElementRegistration(item, false, true); } }
|
DefaultCanvasElementListener implements CanvasElementListener { @Override public void update(final Element item) { onElementRegistration(item, false, true); } DefaultCanvasElementListener(final Iterable<CanvasControl<AbstractCanvasHandler>> canvasControls); }
|
DefaultCanvasElementListener implements CanvasElementListener { @Override public void update(final Element item) { onElementRegistration(item, false, true); } DefaultCanvasElementListener(final Iterable<CanvasControl<AbstractCanvasHandler>> canvasControls); @Override void update(final Element item); @Override void register(final Element item); @Override void deregister(final Element item); @Override void clear(); Iterable<CanvasControl<AbstractCanvasHandler>> getCanvasControls(); }
|
DefaultCanvasElementListener implements CanvasElementListener { @Override public void update(final Element item) { onElementRegistration(item, false, true); } DefaultCanvasElementListener(final Iterable<CanvasControl<AbstractCanvasHandler>> canvasControls); @Override void update(final Element item); @Override void register(final Element item); @Override void deregister(final Element item); @Override void clear(); Iterable<CanvasControl<AbstractCanvasHandler>> getCanvasControls(); }
|
@Test public void testInit() { Metadata metadata = mock(Metadata.class); Command command = mock(Command.class); tested.init(metadata, command); verify(managedSession, times(1)).registerCanvasControl(eq(MediatorsControl.class)); verify(managedSession, times(1)).registerCanvasHandlerControl(eq(SelectionControl.class), eq(MultipleSelection.class)); verify(managedSession, times(1)).registerCanvasHandlerControl(eq(ResizeControl.class)); verify(managedSession, times(1)).registerCanvasHandlerControl(eq(ConnectionAcceptorControl.class)); verify(managedSession, times(1)).registerCanvasHandlerControl(eq(ContainmentAcceptorControl.class)); verify(managedSession, times(1)).registerCanvasHandlerControl(eq(DockingAcceptorControl.class)); verify(managedSession, times(1)).registerCanvasHandlerControl(eq(CanvasInlineTextEditorControl.class)); verify(managedSession, times(1)).registerCanvasHandlerControl(eq(LocationControl.class)); verify(managedSession, times(1)).registerCanvasHandlerControl(eq(ToolboxControl.class)); verify(managedSession, times(1)).registerCanvasHandlerControl(eq(ElementBuilderControl.class), eq(Observer.class)); verify(managedSession, times(1)).registerCanvasHandlerControl(eq(NodeBuilderControl.class)); verify(managedSession, times(1)).registerCanvasHandlerControl(eq(EdgeBuilderControl.class)); verify(managedSession, times(1)).registerCanvasControl(eq(KeyboardControl.class)); verify(managedSession, times(1)).registerCanvasControl(eq(ClipboardControl.class)); verify(managedSession, times(1)).registerCanvasHandlerControl(eq(ControlPointControl.class)); verify(managedSession, times(1)).init(eq(metadata), eq(command)); }
|
@Override public void init(final Metadata metadata, final Command callback) { init(s -> s.registerCanvasControl(MediatorsControl.class) .registerCanvasHandlerControl(SelectionControl.class, MultipleSelection.class) .registerCanvasHandlerControl(ResizeControl.class) .registerCanvasHandlerControl(ConnectionAcceptorControl.class) .registerCanvasHandlerControl(ContainmentAcceptorControl.class) .registerCanvasHandlerControl(DockingAcceptorControl.class) .registerCanvasHandlerControl(CanvasInlineTextEditorControl.class) .registerCanvasHandlerControl(LocationControl.class) .registerCanvasHandlerControl(ToolboxControl.class) .registerCanvasHandlerControl(ElementBuilderControl.class, Observer.class) .registerCanvasHandlerControl(NodeBuilderControl.class) .registerCanvasHandlerControl(EdgeBuilderControl.class) .registerCanvasHandlerControl(AbstractCanvasShortcutsControlImpl.class) .registerCanvasControl(KeyboardControl.class) .registerCanvasControl(ClipboardControl.class) .registerCanvasHandlerControl(ControlPointControl.class), metadata, callback); }
|
DefaultEditorSession extends EditorSession { @Override public void init(final Metadata metadata, final Command callback) { init(s -> s.registerCanvasControl(MediatorsControl.class) .registerCanvasHandlerControl(SelectionControl.class, MultipleSelection.class) .registerCanvasHandlerControl(ResizeControl.class) .registerCanvasHandlerControl(ConnectionAcceptorControl.class) .registerCanvasHandlerControl(ContainmentAcceptorControl.class) .registerCanvasHandlerControl(DockingAcceptorControl.class) .registerCanvasHandlerControl(CanvasInlineTextEditorControl.class) .registerCanvasHandlerControl(LocationControl.class) .registerCanvasHandlerControl(ToolboxControl.class) .registerCanvasHandlerControl(ElementBuilderControl.class, Observer.class) .registerCanvasHandlerControl(NodeBuilderControl.class) .registerCanvasHandlerControl(EdgeBuilderControl.class) .registerCanvasHandlerControl(AbstractCanvasShortcutsControlImpl.class) .registerCanvasControl(KeyboardControl.class) .registerCanvasControl(ClipboardControl.class) .registerCanvasHandlerControl(ControlPointControl.class), metadata, callback); } }
|
DefaultEditorSession extends EditorSession { @Override public void init(final Metadata metadata, final Command callback) { init(s -> s.registerCanvasControl(MediatorsControl.class) .registerCanvasHandlerControl(SelectionControl.class, MultipleSelection.class) .registerCanvasHandlerControl(ResizeControl.class) .registerCanvasHandlerControl(ConnectionAcceptorControl.class) .registerCanvasHandlerControl(ContainmentAcceptorControl.class) .registerCanvasHandlerControl(DockingAcceptorControl.class) .registerCanvasHandlerControl(CanvasInlineTextEditorControl.class) .registerCanvasHandlerControl(LocationControl.class) .registerCanvasHandlerControl(ToolboxControl.class) .registerCanvasHandlerControl(ElementBuilderControl.class, Observer.class) .registerCanvasHandlerControl(NodeBuilderControl.class) .registerCanvasHandlerControl(EdgeBuilderControl.class) .registerCanvasHandlerControl(AbstractCanvasShortcutsControlImpl.class) .registerCanvasControl(KeyboardControl.class) .registerCanvasControl(ClipboardControl.class) .registerCanvasHandlerControl(ControlPointControl.class), metadata, callback); } @Inject DefaultEditorSession(final ManagedSession session,
final CanvasCommandManager<AbstractCanvasHandler> canvasCommandManager,
final SessionCommandManager<AbstractCanvasHandler> sessionCommandManager,
final Registry<org.kie.workbench.common.stunner.core.command.Command<AbstractCanvasHandler, CanvasViolation>> commandRegistry,
final Event<RegisterChangedEvent> registerChangedEvent); }
|
DefaultEditorSession extends EditorSession { @Override public void init(final Metadata metadata, final Command callback) { init(s -> s.registerCanvasControl(MediatorsControl.class) .registerCanvasHandlerControl(SelectionControl.class, MultipleSelection.class) .registerCanvasHandlerControl(ResizeControl.class) .registerCanvasHandlerControl(ConnectionAcceptorControl.class) .registerCanvasHandlerControl(ContainmentAcceptorControl.class) .registerCanvasHandlerControl(DockingAcceptorControl.class) .registerCanvasHandlerControl(CanvasInlineTextEditorControl.class) .registerCanvasHandlerControl(LocationControl.class) .registerCanvasHandlerControl(ToolboxControl.class) .registerCanvasHandlerControl(ElementBuilderControl.class, Observer.class) .registerCanvasHandlerControl(NodeBuilderControl.class) .registerCanvasHandlerControl(EdgeBuilderControl.class) .registerCanvasHandlerControl(AbstractCanvasShortcutsControlImpl.class) .registerCanvasControl(KeyboardControl.class) .registerCanvasControl(ClipboardControl.class) .registerCanvasHandlerControl(ControlPointControl.class), metadata, callback); } @Inject DefaultEditorSession(final ManagedSession session,
final CanvasCommandManager<AbstractCanvasHandler> canvasCommandManager,
final SessionCommandManager<AbstractCanvasHandler> sessionCommandManager,
final Registry<org.kie.workbench.common.stunner.core.command.Command<AbstractCanvasHandler, CanvasViolation>> commandRegistry,
final Event<RegisterChangedEvent> registerChangedEvent); @PostConstruct void constructInstance(); @Override void init(final Metadata metadata,
final Command callback); void init(final Consumer<ManagedSession> sessionControls,
final Metadata metadata,
final Command callback); @Override void open(); @Override void destroy(); @Override String getSessionUUID(); @Override AbstractCanvas getCanvas(); @Override AbstractCanvasHandler getCanvasHandler(); @Override CanvasCommandManager<AbstractCanvasHandler> getCommandManager(); @Override Registry<org.kie.workbench.common.stunner.core.command.Command<AbstractCanvasHandler, CanvasViolation>> getCommandRegistry(); @Override MediatorsControl<AbstractCanvas> getMediatorsControl(); @Override KeyboardControl<AbstractCanvas, ClientSession> getKeyboardControl(); @Override ClipboardControl<Element, AbstractCanvas, ClientSession> getClipboardControl(); @Override SelectionControl<AbstractCanvasHandler, Element> getSelectionControl(); @Override ConnectionAcceptorControl<AbstractCanvasHandler> getConnectionAcceptorControl(); @Override ContainmentAcceptorControl<AbstractCanvasHandler> getContainmentAcceptorControl(); @Override DockingAcceptorControl<AbstractCanvasHandler> getDockingAcceptorControl(); }
|
DefaultEditorSession extends EditorSession { @Override public void init(final Metadata metadata, final Command callback) { init(s -> s.registerCanvasControl(MediatorsControl.class) .registerCanvasHandlerControl(SelectionControl.class, MultipleSelection.class) .registerCanvasHandlerControl(ResizeControl.class) .registerCanvasHandlerControl(ConnectionAcceptorControl.class) .registerCanvasHandlerControl(ContainmentAcceptorControl.class) .registerCanvasHandlerControl(DockingAcceptorControl.class) .registerCanvasHandlerControl(CanvasInlineTextEditorControl.class) .registerCanvasHandlerControl(LocationControl.class) .registerCanvasHandlerControl(ToolboxControl.class) .registerCanvasHandlerControl(ElementBuilderControl.class, Observer.class) .registerCanvasHandlerControl(NodeBuilderControl.class) .registerCanvasHandlerControl(EdgeBuilderControl.class) .registerCanvasHandlerControl(AbstractCanvasShortcutsControlImpl.class) .registerCanvasControl(KeyboardControl.class) .registerCanvasControl(ClipboardControl.class) .registerCanvasHandlerControl(ControlPointControl.class), metadata, callback); } @Inject DefaultEditorSession(final ManagedSession session,
final CanvasCommandManager<AbstractCanvasHandler> canvasCommandManager,
final SessionCommandManager<AbstractCanvasHandler> sessionCommandManager,
final Registry<org.kie.workbench.common.stunner.core.command.Command<AbstractCanvasHandler, CanvasViolation>> commandRegistry,
final Event<RegisterChangedEvent> registerChangedEvent); @PostConstruct void constructInstance(); @Override void init(final Metadata metadata,
final Command callback); void init(final Consumer<ManagedSession> sessionControls,
final Metadata metadata,
final Command callback); @Override void open(); @Override void destroy(); @Override String getSessionUUID(); @Override AbstractCanvas getCanvas(); @Override AbstractCanvasHandler getCanvasHandler(); @Override CanvasCommandManager<AbstractCanvasHandler> getCommandManager(); @Override Registry<org.kie.workbench.common.stunner.core.command.Command<AbstractCanvasHandler, CanvasViolation>> getCommandRegistry(); @Override MediatorsControl<AbstractCanvas> getMediatorsControl(); @Override KeyboardControl<AbstractCanvas, ClientSession> getKeyboardControl(); @Override ClipboardControl<Element, AbstractCanvas, ClientSession> getClipboardControl(); @Override SelectionControl<AbstractCanvasHandler, Element> getSelectionControl(); @Override ConnectionAcceptorControl<AbstractCanvasHandler> getConnectionAcceptorControl(); @Override ContainmentAcceptorControl<AbstractCanvasHandler> getContainmentAcceptorControl(); @Override DockingAcceptorControl<AbstractCanvasHandler> getDockingAcceptorControl(); }
|
@Test public void testOpen() { tested.open(); verify(managedSession, times(1)).open(); }
|
@Override public void open() { session.open(); }
|
DefaultEditorSession extends EditorSession { @Override public void open() { session.open(); } }
|
DefaultEditorSession extends EditorSession { @Override public void open() { session.open(); } @Inject DefaultEditorSession(final ManagedSession session,
final CanvasCommandManager<AbstractCanvasHandler> canvasCommandManager,
final SessionCommandManager<AbstractCanvasHandler> sessionCommandManager,
final Registry<org.kie.workbench.common.stunner.core.command.Command<AbstractCanvasHandler, CanvasViolation>> commandRegistry,
final Event<RegisterChangedEvent> registerChangedEvent); }
|
DefaultEditorSession extends EditorSession { @Override public void open() { session.open(); } @Inject DefaultEditorSession(final ManagedSession session,
final CanvasCommandManager<AbstractCanvasHandler> canvasCommandManager,
final SessionCommandManager<AbstractCanvasHandler> sessionCommandManager,
final Registry<org.kie.workbench.common.stunner.core.command.Command<AbstractCanvasHandler, CanvasViolation>> commandRegistry,
final Event<RegisterChangedEvent> registerChangedEvent); @PostConstruct void constructInstance(); @Override void init(final Metadata metadata,
final Command callback); void init(final Consumer<ManagedSession> sessionControls,
final Metadata metadata,
final Command callback); @Override void open(); @Override void destroy(); @Override String getSessionUUID(); @Override AbstractCanvas getCanvas(); @Override AbstractCanvasHandler getCanvasHandler(); @Override CanvasCommandManager<AbstractCanvasHandler> getCommandManager(); @Override Registry<org.kie.workbench.common.stunner.core.command.Command<AbstractCanvasHandler, CanvasViolation>> getCommandRegistry(); @Override MediatorsControl<AbstractCanvas> getMediatorsControl(); @Override KeyboardControl<AbstractCanvas, ClientSession> getKeyboardControl(); @Override ClipboardControl<Element, AbstractCanvas, ClientSession> getClipboardControl(); @Override SelectionControl<AbstractCanvasHandler, Element> getSelectionControl(); @Override ConnectionAcceptorControl<AbstractCanvasHandler> getConnectionAcceptorControl(); @Override ContainmentAcceptorControl<AbstractCanvasHandler> getContainmentAcceptorControl(); @Override DockingAcceptorControl<AbstractCanvasHandler> getDockingAcceptorControl(); }
|
DefaultEditorSession extends EditorSession { @Override public void open() { session.open(); } @Inject DefaultEditorSession(final ManagedSession session,
final CanvasCommandManager<AbstractCanvasHandler> canvasCommandManager,
final SessionCommandManager<AbstractCanvasHandler> sessionCommandManager,
final Registry<org.kie.workbench.common.stunner.core.command.Command<AbstractCanvasHandler, CanvasViolation>> commandRegistry,
final Event<RegisterChangedEvent> registerChangedEvent); @PostConstruct void constructInstance(); @Override void init(final Metadata metadata,
final Command callback); void init(final Consumer<ManagedSession> sessionControls,
final Metadata metadata,
final Command callback); @Override void open(); @Override void destroy(); @Override String getSessionUUID(); @Override AbstractCanvas getCanvas(); @Override AbstractCanvasHandler getCanvasHandler(); @Override CanvasCommandManager<AbstractCanvasHandler> getCommandManager(); @Override Registry<org.kie.workbench.common.stunner.core.command.Command<AbstractCanvasHandler, CanvasViolation>> getCommandRegistry(); @Override MediatorsControl<AbstractCanvas> getMediatorsControl(); @Override KeyboardControl<AbstractCanvas, ClientSession> getKeyboardControl(); @Override ClipboardControl<Element, AbstractCanvas, ClientSession> getClipboardControl(); @Override SelectionControl<AbstractCanvasHandler, Element> getSelectionControl(); @Override ConnectionAcceptorControl<AbstractCanvasHandler> getConnectionAcceptorControl(); @Override ContainmentAcceptorControl<AbstractCanvasHandler> getContainmentAcceptorControl(); @Override DockingAcceptorControl<AbstractCanvasHandler> getDockingAcceptorControl(); }
|
@Test public void testDestroy() { tested.destroy(); verify(commandRegistry, times(1)).clear(); verify(managedSession, times(1)).destroy(); }
|
@Override public void destroy() { commandRegistry.clear(); session.destroy(); }
|
DefaultEditorSession extends EditorSession { @Override public void destroy() { commandRegistry.clear(); session.destroy(); } }
|
DefaultEditorSession extends EditorSession { @Override public void destroy() { commandRegistry.clear(); session.destroy(); } @Inject DefaultEditorSession(final ManagedSession session,
final CanvasCommandManager<AbstractCanvasHandler> canvasCommandManager,
final SessionCommandManager<AbstractCanvasHandler> sessionCommandManager,
final Registry<org.kie.workbench.common.stunner.core.command.Command<AbstractCanvasHandler, CanvasViolation>> commandRegistry,
final Event<RegisterChangedEvent> registerChangedEvent); }
|
DefaultEditorSession extends EditorSession { @Override public void destroy() { commandRegistry.clear(); session.destroy(); } @Inject DefaultEditorSession(final ManagedSession session,
final CanvasCommandManager<AbstractCanvasHandler> canvasCommandManager,
final SessionCommandManager<AbstractCanvasHandler> sessionCommandManager,
final Registry<org.kie.workbench.common.stunner.core.command.Command<AbstractCanvasHandler, CanvasViolation>> commandRegistry,
final Event<RegisterChangedEvent> registerChangedEvent); @PostConstruct void constructInstance(); @Override void init(final Metadata metadata,
final Command callback); void init(final Consumer<ManagedSession> sessionControls,
final Metadata metadata,
final Command callback); @Override void open(); @Override void destroy(); @Override String getSessionUUID(); @Override AbstractCanvas getCanvas(); @Override AbstractCanvasHandler getCanvasHandler(); @Override CanvasCommandManager<AbstractCanvasHandler> getCommandManager(); @Override Registry<org.kie.workbench.common.stunner.core.command.Command<AbstractCanvasHandler, CanvasViolation>> getCommandRegistry(); @Override MediatorsControl<AbstractCanvas> getMediatorsControl(); @Override KeyboardControl<AbstractCanvas, ClientSession> getKeyboardControl(); @Override ClipboardControl<Element, AbstractCanvas, ClientSession> getClipboardControl(); @Override SelectionControl<AbstractCanvasHandler, Element> getSelectionControl(); @Override ConnectionAcceptorControl<AbstractCanvasHandler> getConnectionAcceptorControl(); @Override ContainmentAcceptorControl<AbstractCanvasHandler> getContainmentAcceptorControl(); @Override DockingAcceptorControl<AbstractCanvasHandler> getDockingAcceptorControl(); }
|
DefaultEditorSession extends EditorSession { @Override public void destroy() { commandRegistry.clear(); session.destroy(); } @Inject DefaultEditorSession(final ManagedSession session,
final CanvasCommandManager<AbstractCanvasHandler> canvasCommandManager,
final SessionCommandManager<AbstractCanvasHandler> sessionCommandManager,
final Registry<org.kie.workbench.common.stunner.core.command.Command<AbstractCanvasHandler, CanvasViolation>> commandRegistry,
final Event<RegisterChangedEvent> registerChangedEvent); @PostConstruct void constructInstance(); @Override void init(final Metadata metadata,
final Command callback); void init(final Consumer<ManagedSession> sessionControls,
final Metadata metadata,
final Command callback); @Override void open(); @Override void destroy(); @Override String getSessionUUID(); @Override AbstractCanvas getCanvas(); @Override AbstractCanvasHandler getCanvasHandler(); @Override CanvasCommandManager<AbstractCanvasHandler> getCommandManager(); @Override Registry<org.kie.workbench.common.stunner.core.command.Command<AbstractCanvasHandler, CanvasViolation>> getCommandRegistry(); @Override MediatorsControl<AbstractCanvas> getMediatorsControl(); @Override KeyboardControl<AbstractCanvas, ClientSession> getKeyboardControl(); @Override ClipboardControl<Element, AbstractCanvas, ClientSession> getClipboardControl(); @Override SelectionControl<AbstractCanvasHandler, Element> getSelectionControl(); @Override ConnectionAcceptorControl<AbstractCanvasHandler> getConnectionAcceptorControl(); @Override ContainmentAcceptorControl<AbstractCanvasHandler> getContainmentAcceptorControl(); @Override DockingAcceptorControl<AbstractCanvasHandler> getDockingAcceptorControl(); }
|
@Test public void testDestroy() { final ManagedInstance managedInstance = mock(ManagedInstance.class); final Object control = mock(Object.class); final Consumer<Object> consumer = mock(Consumer.class); InstanceUtils.destroy(managedInstance, control, consumer); verify(consumer, times(1)).accept(eq(control)); verify(managedInstance, times(1)).destroy(eq(control)); }
|
public static <T> void destroy(final ManagedInstance<T> controlInstance, final T control, final Consumer<T> destroyer) { destroyer.accept(control); controlInstance.destroy(control); }
|
InstanceUtils { public static <T> void destroy(final ManagedInstance<T> controlInstance, final T control, final Consumer<T> destroyer) { destroyer.accept(control); controlInstance.destroy(control); } }
|
InstanceUtils { public static <T> void destroy(final ManagedInstance<T> controlInstance, final T control, final Consumer<T> destroyer) { destroyer.accept(control); controlInstance.destroy(control); } }
|
InstanceUtils { public static <T> void destroy(final ManagedInstance<T> controlInstance, final T control, final Consumer<T> destroyer) { destroyer.accept(control); controlInstance.destroy(control); } @SuppressWarnings("unchecked") static T lookup(final ManagedInstance instance,
final Class<T> type,
final Annotation... qualifier); static T lookup(final ManagedInstance<T> instance,
final Annotation qualifier); static void destroyAll(final List<ManagedInstance<T>> controlInstances,
final List<T> controls,
final Consumer<T> destroyer); static void destroy(final ManagedInstance<T> controlInstance,
final T control,
final Consumer<T> destroyer); }
|
InstanceUtils { public static <T> void destroy(final ManagedInstance<T> controlInstance, final T control, final Consumer<T> destroyer) { destroyer.accept(control); controlInstance.destroy(control); } @SuppressWarnings("unchecked") static T lookup(final ManagedInstance instance,
final Class<T> type,
final Annotation... qualifier); static T lookup(final ManagedInstance<T> instance,
final Annotation qualifier); static void destroyAll(final List<ManagedInstance<T>> controlInstances,
final List<T> controls,
final Consumer<T> destroyer); static void destroy(final ManagedInstance<T> controlInstance,
final T control,
final Consumer<T> destroyer); }
|
@Test public void testOnSessionDiagramOpenedEvent() { observer.onSessionDiagramOpenedEvent(new SessionDiagramOpenedEvent(session)); allSessionDiagramOpenedHandlers.forEach(handler -> verify(handler).accepts(diagram)); acceptsDiagramSessionDiagramOpenedHandlers.forEach(handler -> verify(handler).onSessionDiagramOpened(session)); dontAcceptsDiagramSessionDiagramOpenedHandlers.forEach(handler -> verify(handler, never()).onSessionDiagramOpened(session)); }
|
void onSessionDiagramOpenedEvent(@Observes final SessionDiagramOpenedEvent event) { final Diagram currentDiagram = event.getSession().getCanvasHandler().getDiagram(); sessionDiagramOpenedHandlers.stream() .filter(handler -> handler.accepts(currentDiagram)) .forEach(handler -> handler.onSessionDiagramOpened(event.getSession())); }
|
SessionEventObserver { void onSessionDiagramOpenedEvent(@Observes final SessionDiagramOpenedEvent event) { final Diagram currentDiagram = event.getSession().getCanvasHandler().getDiagram(); sessionDiagramOpenedHandlers.stream() .filter(handler -> handler.accepts(currentDiagram)) .forEach(handler -> handler.onSessionDiagramOpened(event.getSession())); } }
|
SessionEventObserver { void onSessionDiagramOpenedEvent(@Observes final SessionDiagramOpenedEvent event) { final Diagram currentDiagram = event.getSession().getCanvasHandler().getDiagram(); sessionDiagramOpenedHandlers.stream() .filter(handler -> handler.accepts(currentDiagram)) .forEach(handler -> handler.onSessionDiagramOpened(event.getSession())); } SessionEventObserver(); @Inject SessionEventObserver(@Any final Instance<SessionDiagramOpenedHandler> sessionDiagramOpenedHandlersInstance,
@Any final Instance<SessionDiagramSavedHandler> sessionDiagramSavedHandlersInstance); }
|
SessionEventObserver { void onSessionDiagramOpenedEvent(@Observes final SessionDiagramOpenedEvent event) { final Diagram currentDiagram = event.getSession().getCanvasHandler().getDiagram(); sessionDiagramOpenedHandlers.stream() .filter(handler -> handler.accepts(currentDiagram)) .forEach(handler -> handler.onSessionDiagramOpened(event.getSession())); } SessionEventObserver(); @Inject SessionEventObserver(@Any final Instance<SessionDiagramOpenedHandler> sessionDiagramOpenedHandlersInstance,
@Any final Instance<SessionDiagramSavedHandler> sessionDiagramSavedHandlersInstance); }
|
SessionEventObserver { void onSessionDiagramOpenedEvent(@Observes final SessionDiagramOpenedEvent event) { final Diagram currentDiagram = event.getSession().getCanvasHandler().getDiagram(); sessionDiagramOpenedHandlers.stream() .filter(handler -> handler.accepts(currentDiagram)) .forEach(handler -> handler.onSessionDiagramOpened(event.getSession())); } SessionEventObserver(); @Inject SessionEventObserver(@Any final Instance<SessionDiagramOpenedHandler> sessionDiagramOpenedHandlersInstance,
@Any final Instance<SessionDiagramSavedHandler> sessionDiagramSavedHandlersInstance); }
|
@Test public void testOnSessionDiagramSavedEvent() { observer.onSessionDiagramSavedEvent(new SessionDiagramSavedEvent(session)); allSessionDiagramSavedHandlers.forEach(handler -> verify(handler).accepts(diagram)); acceptsDiagramSessionDiagramSavedHandlers.forEach(handler -> verify(handler).onSessionDiagramSaved(session)); dontAcceptsDiagramSessionDiagramSavedHandlers.forEach(handler -> verify(handler, never()).onSessionDiagramSaved(session)); }
|
void onSessionDiagramSavedEvent(@Observes final SessionDiagramSavedEvent event) { final Diagram currentDiagram = event.getSession().getCanvasHandler().getDiagram(); sessionDiagramSavedHandlers.stream() .filter(handler -> handler.accepts(currentDiagram)) .forEach(handler -> handler.onSessionDiagramSaved(event.getSession())); }
|
SessionEventObserver { void onSessionDiagramSavedEvent(@Observes final SessionDiagramSavedEvent event) { final Diagram currentDiagram = event.getSession().getCanvasHandler().getDiagram(); sessionDiagramSavedHandlers.stream() .filter(handler -> handler.accepts(currentDiagram)) .forEach(handler -> handler.onSessionDiagramSaved(event.getSession())); } }
|
SessionEventObserver { void onSessionDiagramSavedEvent(@Observes final SessionDiagramSavedEvent event) { final Diagram currentDiagram = event.getSession().getCanvasHandler().getDiagram(); sessionDiagramSavedHandlers.stream() .filter(handler -> handler.accepts(currentDiagram)) .forEach(handler -> handler.onSessionDiagramSaved(event.getSession())); } SessionEventObserver(); @Inject SessionEventObserver(@Any final Instance<SessionDiagramOpenedHandler> sessionDiagramOpenedHandlersInstance,
@Any final Instance<SessionDiagramSavedHandler> sessionDiagramSavedHandlersInstance); }
|
SessionEventObserver { void onSessionDiagramSavedEvent(@Observes final SessionDiagramSavedEvent event) { final Diagram currentDiagram = event.getSession().getCanvasHandler().getDiagram(); sessionDiagramSavedHandlers.stream() .filter(handler -> handler.accepts(currentDiagram)) .forEach(handler -> handler.onSessionDiagramSaved(event.getSession())); } SessionEventObserver(); @Inject SessionEventObserver(@Any final Instance<SessionDiagramOpenedHandler> sessionDiagramOpenedHandlersInstance,
@Any final Instance<SessionDiagramSavedHandler> sessionDiagramSavedHandlersInstance); }
|
SessionEventObserver { void onSessionDiagramSavedEvent(@Observes final SessionDiagramSavedEvent event) { final Diagram currentDiagram = event.getSession().getCanvasHandler().getDiagram(); sessionDiagramSavedHandlers.stream() .filter(handler -> handler.accepts(currentDiagram)) .forEach(handler -> handler.onSessionDiagramSaved(event.getSession())); } SessionEventObserver(); @Inject SessionEventObserver(@Any final Instance<SessionDiagramOpenedHandler> sessionDiagramOpenedHandlersInstance,
@Any final Instance<SessionDiagramSavedHandler> sessionDiagramSavedHandlersInstance); }
|
@Test @SuppressWarnings("unchecked") public void testCreate() { final String name = "d1"; final String defSetId = "id1"; final ServiceCallback<Path> callback = mock(ServiceCallback.class); tested.create(path, name, defSetId, callback); verify(diagramService, times(1)).create(eq(path), eq(name), eq(defSetId)); verify(callback, times(1)).onSuccess(any(Path.class)); verify(callback, times(0)).onError(any(ClientRuntimeError.class)); }
|
@Override public void create(final Path path, final String name, final String defSetId, final ServiceCallback<Path> callback) { diagramServiceCaller.call(p -> callback.onSuccess(path), (message, throwable) -> { callback.onError(new ClientRuntimeError(throwable)); return false; }).create(path, name, defSetId); }
|
AbstractClientDiagramService implements ClientDiagramService<M, D, S> { @Override public void create(final Path path, final String name, final String defSetId, final ServiceCallback<Path> callback) { diagramServiceCaller.call(p -> callback.onSuccess(path), (message, throwable) -> { callback.onError(new ClientRuntimeError(throwable)); return false; }).create(path, name, defSetId); } }
|
AbstractClientDiagramService implements ClientDiagramService<M, D, S> { @Override public void create(final Path path, final String name, final String defSetId, final ServiceCallback<Path> callback) { diagramServiceCaller.call(p -> callback.onSuccess(path), (message, throwable) -> { callback.onError(new ClientRuntimeError(throwable)); return false; }).create(path, name, defSetId); } AbstractClientDiagramService(final ShapeManager shapeManager,
final SessionManager sessionManager,
final Caller<S> diagramServiceCaller,
final Caller<DiagramLookupService> diagramLookupServiceCaller,
final Event<SessionDiagramSavedEvent> saveEvent); }
|
AbstractClientDiagramService implements ClientDiagramService<M, D, S> { @Override public void create(final Path path, final String name, final String defSetId, final ServiceCallback<Path> callback) { diagramServiceCaller.call(p -> callback.onSuccess(path), (message, throwable) -> { callback.onError(new ClientRuntimeError(throwable)); return false; }).create(path, name, defSetId); } AbstractClientDiagramService(final ShapeManager shapeManager,
final SessionManager sessionManager,
final Caller<S> diagramServiceCaller,
final Caller<DiagramLookupService> diagramLookupServiceCaller,
final Event<SessionDiagramSavedEvent> saveEvent); @Override void create(final Path path,
final String name,
final String defSetId,
final ServiceCallback<Path> callback); @Override @SuppressWarnings("unchecked") void saveOrUpdate(final D diagram,
final ServiceCallback<D> callback); @Override void saveOrUpdateSvg(Path diagramPath, String rawSvg, ServiceCallback<Path> callback); @Override void add(final D diagram,
final ServiceCallback<D> callback); @Override @SuppressWarnings("unchecked") void getByPath(final Path path,
final ServiceCallback<D> callback); @Override @SuppressWarnings("unchecked") void lookup(final DiagramLookupRequest request,
final ServiceCallback<LookupManager.LookupResponse<DiagramRepresentation>> callback); @Override void getRawContent(final D diagram,
final ServiceCallback<String> callback); }
|
AbstractClientDiagramService implements ClientDiagramService<M, D, S> { @Override public void create(final Path path, final String name, final String defSetId, final ServiceCallback<Path> callback) { diagramServiceCaller.call(p -> callback.onSuccess(path), (message, throwable) -> { callback.onError(new ClientRuntimeError(throwable)); return false; }).create(path, name, defSetId); } AbstractClientDiagramService(final ShapeManager shapeManager,
final SessionManager sessionManager,
final Caller<S> diagramServiceCaller,
final Caller<DiagramLookupService> diagramLookupServiceCaller,
final Event<SessionDiagramSavedEvent> saveEvent); @Override void create(final Path path,
final String name,
final String defSetId,
final ServiceCallback<Path> callback); @Override @SuppressWarnings("unchecked") void saveOrUpdate(final D diagram,
final ServiceCallback<D> callback); @Override void saveOrUpdateSvg(Path diagramPath, String rawSvg, ServiceCallback<Path> callback); @Override void add(final D diagram,
final ServiceCallback<D> callback); @Override @SuppressWarnings("unchecked") void getByPath(final Path path,
final ServiceCallback<D> callback); @Override @SuppressWarnings("unchecked") void lookup(final DiagramLookupRequest request,
final ServiceCallback<LookupManager.LookupResponse<DiagramRepresentation>> callback); @Override void getRawContent(final D diagram,
final ServiceCallback<String> callback); }
|
@Test @SuppressWarnings("unchecked") public void testAdd() { final ServiceCallback<D> callback = mock(ServiceCallback.class); tested.add(diagram, callback); verify(diagramService, times(1)).saveOrUpdate(eq(diagram)); verify(callback, times(1)).onSuccess(eq(diagram)); verify(callback, times(0)).onError(any(ClientRuntimeError.class)); }
|
@Override public void add(final D diagram, final ServiceCallback<D> callback) { diagramServiceCaller.call(v -> { updateClientMetadata(diagram); callback.onSuccess(diagram); }, (message, throwable) -> { callback.onError(new ClientRuntimeError(throwable)); return false; }).saveOrUpdate(diagram); }
|
AbstractClientDiagramService implements ClientDiagramService<M, D, S> { @Override public void add(final D diagram, final ServiceCallback<D> callback) { diagramServiceCaller.call(v -> { updateClientMetadata(diagram); callback.onSuccess(diagram); }, (message, throwable) -> { callback.onError(new ClientRuntimeError(throwable)); return false; }).saveOrUpdate(diagram); } }
|
AbstractClientDiagramService implements ClientDiagramService<M, D, S> { @Override public void add(final D diagram, final ServiceCallback<D> callback) { diagramServiceCaller.call(v -> { updateClientMetadata(diagram); callback.onSuccess(diagram); }, (message, throwable) -> { callback.onError(new ClientRuntimeError(throwable)); return false; }).saveOrUpdate(diagram); } AbstractClientDiagramService(final ShapeManager shapeManager,
final SessionManager sessionManager,
final Caller<S> diagramServiceCaller,
final Caller<DiagramLookupService> diagramLookupServiceCaller,
final Event<SessionDiagramSavedEvent> saveEvent); }
|
AbstractClientDiagramService implements ClientDiagramService<M, D, S> { @Override public void add(final D diagram, final ServiceCallback<D> callback) { diagramServiceCaller.call(v -> { updateClientMetadata(diagram); callback.onSuccess(diagram); }, (message, throwable) -> { callback.onError(new ClientRuntimeError(throwable)); return false; }).saveOrUpdate(diagram); } AbstractClientDiagramService(final ShapeManager shapeManager,
final SessionManager sessionManager,
final Caller<S> diagramServiceCaller,
final Caller<DiagramLookupService> diagramLookupServiceCaller,
final Event<SessionDiagramSavedEvent> saveEvent); @Override void create(final Path path,
final String name,
final String defSetId,
final ServiceCallback<Path> callback); @Override @SuppressWarnings("unchecked") void saveOrUpdate(final D diagram,
final ServiceCallback<D> callback); @Override void saveOrUpdateSvg(Path diagramPath, String rawSvg, ServiceCallback<Path> callback); @Override void add(final D diagram,
final ServiceCallback<D> callback); @Override @SuppressWarnings("unchecked") void getByPath(final Path path,
final ServiceCallback<D> callback); @Override @SuppressWarnings("unchecked") void lookup(final DiagramLookupRequest request,
final ServiceCallback<LookupManager.LookupResponse<DiagramRepresentation>> callback); @Override void getRawContent(final D diagram,
final ServiceCallback<String> callback); }
|
AbstractClientDiagramService implements ClientDiagramService<M, D, S> { @Override public void add(final D diagram, final ServiceCallback<D> callback) { diagramServiceCaller.call(v -> { updateClientMetadata(diagram); callback.onSuccess(diagram); }, (message, throwable) -> { callback.onError(new ClientRuntimeError(throwable)); return false; }).saveOrUpdate(diagram); } AbstractClientDiagramService(final ShapeManager shapeManager,
final SessionManager sessionManager,
final Caller<S> diagramServiceCaller,
final Caller<DiagramLookupService> diagramLookupServiceCaller,
final Event<SessionDiagramSavedEvent> saveEvent); @Override void create(final Path path,
final String name,
final String defSetId,
final ServiceCallback<Path> callback); @Override @SuppressWarnings("unchecked") void saveOrUpdate(final D diagram,
final ServiceCallback<D> callback); @Override void saveOrUpdateSvg(Path diagramPath, String rawSvg, ServiceCallback<Path> callback); @Override void add(final D diagram,
final ServiceCallback<D> callback); @Override @SuppressWarnings("unchecked") void getByPath(final Path path,
final ServiceCallback<D> callback); @Override @SuppressWarnings("unchecked") void lookup(final DiagramLookupRequest request,
final ServiceCallback<LookupManager.LookupResponse<DiagramRepresentation>> callback); @Override void getRawContent(final D diagram,
final ServiceCallback<String> callback); }
|
@Test @SuppressWarnings("unchecked") public void testBindWithNoItems() { when(bound.getItems(anyInt(), anyInt())).thenReturn(Collections.emptyList()); listSelector.bind(bound, 0, 0); verify(view, never()).setItems(anyList()); listSelector.show(); verify(view, never()).show(Optional.empty()); }
|
@Override public void bind(final HasListSelectorControl bound, final int uiRowIndex, final int uiColumnIndex) { super.bind(bound, uiRowIndex, uiColumnIndex); binding.ifPresent(b -> { final List<ListSelectorItem> items = b.getItems(uiRowIndex, uiColumnIndex); if (items.isEmpty()) { bind(null, uiRowIndex, uiColumnIndex); } else { view.setItems(b.getItems(uiRowIndex, uiColumnIndex)); } }); }
|
ListSelector extends AbstractPopoverImpl<ListSelectorView, HasListSelectorControl> implements ListSelectorView.Presenter { @Override public void bind(final HasListSelectorControl bound, final int uiRowIndex, final int uiColumnIndex) { super.bind(bound, uiRowIndex, uiColumnIndex); binding.ifPresent(b -> { final List<ListSelectorItem> items = b.getItems(uiRowIndex, uiColumnIndex); if (items.isEmpty()) { bind(null, uiRowIndex, uiColumnIndex); } else { view.setItems(b.getItems(uiRowIndex, uiColumnIndex)); } }); } }
|
ListSelector extends AbstractPopoverImpl<ListSelectorView, HasListSelectorControl> implements ListSelectorView.Presenter { @Override public void bind(final HasListSelectorControl bound, final int uiRowIndex, final int uiColumnIndex) { super.bind(bound, uiRowIndex, uiColumnIndex); binding.ifPresent(b -> { final List<ListSelectorItem> items = b.getItems(uiRowIndex, uiColumnIndex); if (items.isEmpty()) { bind(null, uiRowIndex, uiColumnIndex); } else { view.setItems(b.getItems(uiRowIndex, uiColumnIndex)); } }); } ListSelector(); @Inject ListSelector(final ListSelectorView view); }
|
ListSelector extends AbstractPopoverImpl<ListSelectorView, HasListSelectorControl> implements ListSelectorView.Presenter { @Override public void bind(final HasListSelectorControl bound, final int uiRowIndex, final int uiColumnIndex) { super.bind(bound, uiRowIndex, uiColumnIndex); binding.ifPresent(b -> { final List<ListSelectorItem> items = b.getItems(uiRowIndex, uiColumnIndex); if (items.isEmpty()) { bind(null, uiRowIndex, uiColumnIndex); } else { view.setItems(b.getItems(uiRowIndex, uiColumnIndex)); } }); } ListSelector(); @Inject ListSelector(final ListSelectorView view); @Override void onItemSelected(final ListSelectorItem item); @Override void bind(final HasListSelectorControl bound,
final int uiRowIndex,
final int uiColumnIndex); }
|
ListSelector extends AbstractPopoverImpl<ListSelectorView, HasListSelectorControl> implements ListSelectorView.Presenter { @Override public void bind(final HasListSelectorControl bound, final int uiRowIndex, final int uiColumnIndex) { super.bind(bound, uiRowIndex, uiColumnIndex); binding.ifPresent(b -> { final List<ListSelectorItem> items = b.getItems(uiRowIndex, uiColumnIndex); if (items.isEmpty()) { bind(null, uiRowIndex, uiColumnIndex); } else { view.setItems(b.getItems(uiRowIndex, uiColumnIndex)); } }); } ListSelector(); @Inject ListSelector(final ListSelectorView view); @Override void onItemSelected(final ListSelectorItem item); @Override void bind(final HasListSelectorControl bound,
final int uiRowIndex,
final int uiColumnIndex); }
|
@Test @SuppressWarnings("unchecked") public void testSaveOrUpdate() { final ServiceCallback<D> callback = mock(ServiceCallback.class); tested.saveOrUpdate(diagram, callback); verify(diagramService, times(1)).saveOrUpdate(eq(diagram)); verify(callback, times(1)).onSuccess(eq(diagram)); verify(callback, times(0)).onError(any(ClientRuntimeError.class)); }
|
@Override @SuppressWarnings("unchecked") public void saveOrUpdate(final D diagram, final ServiceCallback<D> callback) { diagramServiceCaller.call(serverMetadata -> { updateClientMetadata(diagram); diagram.getMetadata().setPath(((M) serverMetadata).getPath()); callback.onSuccess(diagram); fireSavedEvent(sessionManager.getCurrentSession()); }, (message, throwable) -> { callback.onError(new ClientRuntimeError(throwable)); return false; }).saveOrUpdate(diagram); }
|
AbstractClientDiagramService implements ClientDiagramService<M, D, S> { @Override @SuppressWarnings("unchecked") public void saveOrUpdate(final D diagram, final ServiceCallback<D> callback) { diagramServiceCaller.call(serverMetadata -> { updateClientMetadata(diagram); diagram.getMetadata().setPath(((M) serverMetadata).getPath()); callback.onSuccess(diagram); fireSavedEvent(sessionManager.getCurrentSession()); }, (message, throwable) -> { callback.onError(new ClientRuntimeError(throwable)); return false; }).saveOrUpdate(diagram); } }
|
AbstractClientDiagramService implements ClientDiagramService<M, D, S> { @Override @SuppressWarnings("unchecked") public void saveOrUpdate(final D diagram, final ServiceCallback<D> callback) { diagramServiceCaller.call(serverMetadata -> { updateClientMetadata(diagram); diagram.getMetadata().setPath(((M) serverMetadata).getPath()); callback.onSuccess(diagram); fireSavedEvent(sessionManager.getCurrentSession()); }, (message, throwable) -> { callback.onError(new ClientRuntimeError(throwable)); return false; }).saveOrUpdate(diagram); } AbstractClientDiagramService(final ShapeManager shapeManager,
final SessionManager sessionManager,
final Caller<S> diagramServiceCaller,
final Caller<DiagramLookupService> diagramLookupServiceCaller,
final Event<SessionDiagramSavedEvent> saveEvent); }
|
AbstractClientDiagramService implements ClientDiagramService<M, D, S> { @Override @SuppressWarnings("unchecked") public void saveOrUpdate(final D diagram, final ServiceCallback<D> callback) { diagramServiceCaller.call(serverMetadata -> { updateClientMetadata(diagram); diagram.getMetadata().setPath(((M) serverMetadata).getPath()); callback.onSuccess(diagram); fireSavedEvent(sessionManager.getCurrentSession()); }, (message, throwable) -> { callback.onError(new ClientRuntimeError(throwable)); return false; }).saveOrUpdate(diagram); } AbstractClientDiagramService(final ShapeManager shapeManager,
final SessionManager sessionManager,
final Caller<S> diagramServiceCaller,
final Caller<DiagramLookupService> diagramLookupServiceCaller,
final Event<SessionDiagramSavedEvent> saveEvent); @Override void create(final Path path,
final String name,
final String defSetId,
final ServiceCallback<Path> callback); @Override @SuppressWarnings("unchecked") void saveOrUpdate(final D diagram,
final ServiceCallback<D> callback); @Override void saveOrUpdateSvg(Path diagramPath, String rawSvg, ServiceCallback<Path> callback); @Override void add(final D diagram,
final ServiceCallback<D> callback); @Override @SuppressWarnings("unchecked") void getByPath(final Path path,
final ServiceCallback<D> callback); @Override @SuppressWarnings("unchecked") void lookup(final DiagramLookupRequest request,
final ServiceCallback<LookupManager.LookupResponse<DiagramRepresentation>> callback); @Override void getRawContent(final D diagram,
final ServiceCallback<String> callback); }
|
AbstractClientDiagramService implements ClientDiagramService<M, D, S> { @Override @SuppressWarnings("unchecked") public void saveOrUpdate(final D diagram, final ServiceCallback<D> callback) { diagramServiceCaller.call(serverMetadata -> { updateClientMetadata(diagram); diagram.getMetadata().setPath(((M) serverMetadata).getPath()); callback.onSuccess(diagram); fireSavedEvent(sessionManager.getCurrentSession()); }, (message, throwable) -> { callback.onError(new ClientRuntimeError(throwable)); return false; }).saveOrUpdate(diagram); } AbstractClientDiagramService(final ShapeManager shapeManager,
final SessionManager sessionManager,
final Caller<S> diagramServiceCaller,
final Caller<DiagramLookupService> diagramLookupServiceCaller,
final Event<SessionDiagramSavedEvent> saveEvent); @Override void create(final Path path,
final String name,
final String defSetId,
final ServiceCallback<Path> callback); @Override @SuppressWarnings("unchecked") void saveOrUpdate(final D diagram,
final ServiceCallback<D> callback); @Override void saveOrUpdateSvg(Path diagramPath, String rawSvg, ServiceCallback<Path> callback); @Override void add(final D diagram,
final ServiceCallback<D> callback); @Override @SuppressWarnings("unchecked") void getByPath(final Path path,
final ServiceCallback<D> callback); @Override @SuppressWarnings("unchecked") void lookup(final DiagramLookupRequest request,
final ServiceCallback<LookupManager.LookupResponse<DiagramRepresentation>> callback); @Override void getRawContent(final D diagram,
final ServiceCallback<String> callback); }
|
@Test public void testSaveOrUpdateSvg() { final ServiceCallback<Path> callback = mock(ServiceCallback.class); tested.saveOrUpdateSvg(path, RAW_DIAGRAM, callback); verify(diagramService).saveOrUpdateSvg(path, RAW_DIAGRAM); }
|
@Override public void saveOrUpdateSvg(Path diagramPath, String rawSvg, ServiceCallback<Path> callback) { diagramServiceCaller.call(res -> callback.onSuccess((Path) res)).saveOrUpdateSvg(diagramPath, rawSvg); }
|
AbstractClientDiagramService implements ClientDiagramService<M, D, S> { @Override public void saveOrUpdateSvg(Path diagramPath, String rawSvg, ServiceCallback<Path> callback) { diagramServiceCaller.call(res -> callback.onSuccess((Path) res)).saveOrUpdateSvg(diagramPath, rawSvg); } }
|
AbstractClientDiagramService implements ClientDiagramService<M, D, S> { @Override public void saveOrUpdateSvg(Path diagramPath, String rawSvg, ServiceCallback<Path> callback) { diagramServiceCaller.call(res -> callback.onSuccess((Path) res)).saveOrUpdateSvg(diagramPath, rawSvg); } AbstractClientDiagramService(final ShapeManager shapeManager,
final SessionManager sessionManager,
final Caller<S> diagramServiceCaller,
final Caller<DiagramLookupService> diagramLookupServiceCaller,
final Event<SessionDiagramSavedEvent> saveEvent); }
|
AbstractClientDiagramService implements ClientDiagramService<M, D, S> { @Override public void saveOrUpdateSvg(Path diagramPath, String rawSvg, ServiceCallback<Path> callback) { diagramServiceCaller.call(res -> callback.onSuccess((Path) res)).saveOrUpdateSvg(diagramPath, rawSvg); } AbstractClientDiagramService(final ShapeManager shapeManager,
final SessionManager sessionManager,
final Caller<S> diagramServiceCaller,
final Caller<DiagramLookupService> diagramLookupServiceCaller,
final Event<SessionDiagramSavedEvent> saveEvent); @Override void create(final Path path,
final String name,
final String defSetId,
final ServiceCallback<Path> callback); @Override @SuppressWarnings("unchecked") void saveOrUpdate(final D diagram,
final ServiceCallback<D> callback); @Override void saveOrUpdateSvg(Path diagramPath, String rawSvg, ServiceCallback<Path> callback); @Override void add(final D diagram,
final ServiceCallback<D> callback); @Override @SuppressWarnings("unchecked") void getByPath(final Path path,
final ServiceCallback<D> callback); @Override @SuppressWarnings("unchecked") void lookup(final DiagramLookupRequest request,
final ServiceCallback<LookupManager.LookupResponse<DiagramRepresentation>> callback); @Override void getRawContent(final D diagram,
final ServiceCallback<String> callback); }
|
AbstractClientDiagramService implements ClientDiagramService<M, D, S> { @Override public void saveOrUpdateSvg(Path diagramPath, String rawSvg, ServiceCallback<Path> callback) { diagramServiceCaller.call(res -> callback.onSuccess((Path) res)).saveOrUpdateSvg(diagramPath, rawSvg); } AbstractClientDiagramService(final ShapeManager shapeManager,
final SessionManager sessionManager,
final Caller<S> diagramServiceCaller,
final Caller<DiagramLookupService> diagramLookupServiceCaller,
final Event<SessionDiagramSavedEvent> saveEvent); @Override void create(final Path path,
final String name,
final String defSetId,
final ServiceCallback<Path> callback); @Override @SuppressWarnings("unchecked") void saveOrUpdate(final D diagram,
final ServiceCallback<D> callback); @Override void saveOrUpdateSvg(Path diagramPath, String rawSvg, ServiceCallback<Path> callback); @Override void add(final D diagram,
final ServiceCallback<D> callback); @Override @SuppressWarnings("unchecked") void getByPath(final Path path,
final ServiceCallback<D> callback); @Override @SuppressWarnings("unchecked") void lookup(final DiagramLookupRequest request,
final ServiceCallback<LookupManager.LookupResponse<DiagramRepresentation>> callback); @Override void getRawContent(final D diagram,
final ServiceCallback<String> callback); }
|
@Test @SuppressWarnings("unchecked") public void testGetByPath() { final ServiceCallback<D> callback = mock(ServiceCallback.class); tested.getByPath(path, callback); verify(diagramService, times(1)).getDiagramByPath(eq(path)); verify(callback, times(1)).onSuccess(eq(diagram)); verify(callback, times(0)).onError(any(ClientRuntimeError.class)); }
|
@Override @SuppressWarnings("unchecked") public void getByPath(final Path path, final ServiceCallback<D> callback) { diagramServiceCaller.call(diagram -> { updateClientMetadata((D) diagram); callback.onSuccess((D) diagram); }, (message, throwable) -> { callback.onError(new ClientRuntimeError(throwable)); return false; }).getDiagramByPath(path); }
|
AbstractClientDiagramService implements ClientDiagramService<M, D, S> { @Override @SuppressWarnings("unchecked") public void getByPath(final Path path, final ServiceCallback<D> callback) { diagramServiceCaller.call(diagram -> { updateClientMetadata((D) diagram); callback.onSuccess((D) diagram); }, (message, throwable) -> { callback.onError(new ClientRuntimeError(throwable)); return false; }).getDiagramByPath(path); } }
|
AbstractClientDiagramService implements ClientDiagramService<M, D, S> { @Override @SuppressWarnings("unchecked") public void getByPath(final Path path, final ServiceCallback<D> callback) { diagramServiceCaller.call(diagram -> { updateClientMetadata((D) diagram); callback.onSuccess((D) diagram); }, (message, throwable) -> { callback.onError(new ClientRuntimeError(throwable)); return false; }).getDiagramByPath(path); } AbstractClientDiagramService(final ShapeManager shapeManager,
final SessionManager sessionManager,
final Caller<S> diagramServiceCaller,
final Caller<DiagramLookupService> diagramLookupServiceCaller,
final Event<SessionDiagramSavedEvent> saveEvent); }
|
AbstractClientDiagramService implements ClientDiagramService<M, D, S> { @Override @SuppressWarnings("unchecked") public void getByPath(final Path path, final ServiceCallback<D> callback) { diagramServiceCaller.call(diagram -> { updateClientMetadata((D) diagram); callback.onSuccess((D) diagram); }, (message, throwable) -> { callback.onError(new ClientRuntimeError(throwable)); return false; }).getDiagramByPath(path); } AbstractClientDiagramService(final ShapeManager shapeManager,
final SessionManager sessionManager,
final Caller<S> diagramServiceCaller,
final Caller<DiagramLookupService> diagramLookupServiceCaller,
final Event<SessionDiagramSavedEvent> saveEvent); @Override void create(final Path path,
final String name,
final String defSetId,
final ServiceCallback<Path> callback); @Override @SuppressWarnings("unchecked") void saveOrUpdate(final D diagram,
final ServiceCallback<D> callback); @Override void saveOrUpdateSvg(Path diagramPath, String rawSvg, ServiceCallback<Path> callback); @Override void add(final D diagram,
final ServiceCallback<D> callback); @Override @SuppressWarnings("unchecked") void getByPath(final Path path,
final ServiceCallback<D> callback); @Override @SuppressWarnings("unchecked") void lookup(final DiagramLookupRequest request,
final ServiceCallback<LookupManager.LookupResponse<DiagramRepresentation>> callback); @Override void getRawContent(final D diagram,
final ServiceCallback<String> callback); }
|
AbstractClientDiagramService implements ClientDiagramService<M, D, S> { @Override @SuppressWarnings("unchecked") public void getByPath(final Path path, final ServiceCallback<D> callback) { diagramServiceCaller.call(diagram -> { updateClientMetadata((D) diagram); callback.onSuccess((D) diagram); }, (message, throwable) -> { callback.onError(new ClientRuntimeError(throwable)); return false; }).getDiagramByPath(path); } AbstractClientDiagramService(final ShapeManager shapeManager,
final SessionManager sessionManager,
final Caller<S> diagramServiceCaller,
final Caller<DiagramLookupService> diagramLookupServiceCaller,
final Event<SessionDiagramSavedEvent> saveEvent); @Override void create(final Path path,
final String name,
final String defSetId,
final ServiceCallback<Path> callback); @Override @SuppressWarnings("unchecked") void saveOrUpdate(final D diagram,
final ServiceCallback<D> callback); @Override void saveOrUpdateSvg(Path diagramPath, String rawSvg, ServiceCallback<Path> callback); @Override void add(final D diagram,
final ServiceCallback<D> callback); @Override @SuppressWarnings("unchecked") void getByPath(final Path path,
final ServiceCallback<D> callback); @Override @SuppressWarnings("unchecked") void lookup(final DiagramLookupRequest request,
final ServiceCallback<LookupManager.LookupResponse<DiagramRepresentation>> callback); @Override void getRawContent(final D diagram,
final ServiceCallback<String> callback); }
|
@Test @SuppressWarnings("unchecked") public void testLookup() { final DiagramLookupRequest request = mock(DiagramLookupRequest.class); final ServiceCallback<LookupManager.LookupResponse<DiagramRepresentation>> callback = mock(ServiceCallback.class); tested.lookup(request, callback); verify(diagramLookupService, times(1)).lookup(eq(request)); verify(callback, times(1)).onSuccess(any(LookupManager.LookupResponse.class)); verify(callback, times(0)).onError(any(ClientRuntimeError.class)); }
|
@Override @SuppressWarnings("unchecked") public void lookup(final DiagramLookupRequest request, final ServiceCallback<LookupManager.LookupResponse<DiagramRepresentation>> callback) { diagramLookupServiceCaller.call(response -> callback.onSuccess((LookupManager.LookupResponse<DiagramRepresentation>) response), (message, throwable) -> { callback.onError(new ClientRuntimeError(throwable)); return false; }).lookup(request); }
|
AbstractClientDiagramService implements ClientDiagramService<M, D, S> { @Override @SuppressWarnings("unchecked") public void lookup(final DiagramLookupRequest request, final ServiceCallback<LookupManager.LookupResponse<DiagramRepresentation>> callback) { diagramLookupServiceCaller.call(response -> callback.onSuccess((LookupManager.LookupResponse<DiagramRepresentation>) response), (message, throwable) -> { callback.onError(new ClientRuntimeError(throwable)); return false; }).lookup(request); } }
|
AbstractClientDiagramService implements ClientDiagramService<M, D, S> { @Override @SuppressWarnings("unchecked") public void lookup(final DiagramLookupRequest request, final ServiceCallback<LookupManager.LookupResponse<DiagramRepresentation>> callback) { diagramLookupServiceCaller.call(response -> callback.onSuccess((LookupManager.LookupResponse<DiagramRepresentation>) response), (message, throwable) -> { callback.onError(new ClientRuntimeError(throwable)); return false; }).lookup(request); } AbstractClientDiagramService(final ShapeManager shapeManager,
final SessionManager sessionManager,
final Caller<S> diagramServiceCaller,
final Caller<DiagramLookupService> diagramLookupServiceCaller,
final Event<SessionDiagramSavedEvent> saveEvent); }
|
AbstractClientDiagramService implements ClientDiagramService<M, D, S> { @Override @SuppressWarnings("unchecked") public void lookup(final DiagramLookupRequest request, final ServiceCallback<LookupManager.LookupResponse<DiagramRepresentation>> callback) { diagramLookupServiceCaller.call(response -> callback.onSuccess((LookupManager.LookupResponse<DiagramRepresentation>) response), (message, throwable) -> { callback.onError(new ClientRuntimeError(throwable)); return false; }).lookup(request); } AbstractClientDiagramService(final ShapeManager shapeManager,
final SessionManager sessionManager,
final Caller<S> diagramServiceCaller,
final Caller<DiagramLookupService> diagramLookupServiceCaller,
final Event<SessionDiagramSavedEvent> saveEvent); @Override void create(final Path path,
final String name,
final String defSetId,
final ServiceCallback<Path> callback); @Override @SuppressWarnings("unchecked") void saveOrUpdate(final D diagram,
final ServiceCallback<D> callback); @Override void saveOrUpdateSvg(Path diagramPath, String rawSvg, ServiceCallback<Path> callback); @Override void add(final D diagram,
final ServiceCallback<D> callback); @Override @SuppressWarnings("unchecked") void getByPath(final Path path,
final ServiceCallback<D> callback); @Override @SuppressWarnings("unchecked") void lookup(final DiagramLookupRequest request,
final ServiceCallback<LookupManager.LookupResponse<DiagramRepresentation>> callback); @Override void getRawContent(final D diagram,
final ServiceCallback<String> callback); }
|
AbstractClientDiagramService implements ClientDiagramService<M, D, S> { @Override @SuppressWarnings("unchecked") public void lookup(final DiagramLookupRequest request, final ServiceCallback<LookupManager.LookupResponse<DiagramRepresentation>> callback) { diagramLookupServiceCaller.call(response -> callback.onSuccess((LookupManager.LookupResponse<DiagramRepresentation>) response), (message, throwable) -> { callback.onError(new ClientRuntimeError(throwable)); return false; }).lookup(request); } AbstractClientDiagramService(final ShapeManager shapeManager,
final SessionManager sessionManager,
final Caller<S> diagramServiceCaller,
final Caller<DiagramLookupService> diagramLookupServiceCaller,
final Event<SessionDiagramSavedEvent> saveEvent); @Override void create(final Path path,
final String name,
final String defSetId,
final ServiceCallback<Path> callback); @Override @SuppressWarnings("unchecked") void saveOrUpdate(final D diagram,
final ServiceCallback<D> callback); @Override void saveOrUpdateSvg(Path diagramPath, String rawSvg, ServiceCallback<Path> callback); @Override void add(final D diagram,
final ServiceCallback<D> callback); @Override @SuppressWarnings("unchecked") void getByPath(final Path path,
final ServiceCallback<D> callback); @Override @SuppressWarnings("unchecked") void lookup(final DiagramLookupRequest request,
final ServiceCallback<LookupManager.LookupResponse<DiagramRepresentation>> callback); @Override void getRawContent(final D diagram,
final ServiceCallback<String> callback); }
|
@Test @SuppressWarnings("unchecked") public void testUpdateClientMetadata() { final String ssid = "shapeSet1"; final ShapeSet shapeSet = mock(ShapeSet.class); final ServiceCallback<D> callback = mock(ServiceCallback.class); when(shapeSet.getId()).thenReturn(ssid); when(shapeManager.getDefaultShapeSet(anyString())).thenReturn(shapeSet); when(metadata.getShapeSetId()).thenReturn(null); when(diagramService.getDiagramByPath(eq(path))).thenReturn(diagram); tested.add(diagram, callback); tested.saveOrUpdate(diagram, callback); tested.getByPath(path, callback); verify(metadata, times(3)).setShapeSetId(eq(ssid)); }
|
protected void updateClientMetadata(final D diagram) { if (null != diagram) { final Metadata metadata = diagram.getMetadata(); if (null != metadata && isEmpty(metadata.getShapeSetId())) { final String sId = shapeManager.getDefaultShapeSet(metadata.getDefinitionSetId()).getId(); metadata.setShapeSetId(sId); } } }
|
AbstractClientDiagramService implements ClientDiagramService<M, D, S> { protected void updateClientMetadata(final D diagram) { if (null != diagram) { final Metadata metadata = diagram.getMetadata(); if (null != metadata && isEmpty(metadata.getShapeSetId())) { final String sId = shapeManager.getDefaultShapeSet(metadata.getDefinitionSetId()).getId(); metadata.setShapeSetId(sId); } } } }
|
AbstractClientDiagramService implements ClientDiagramService<M, D, S> { protected void updateClientMetadata(final D diagram) { if (null != diagram) { final Metadata metadata = diagram.getMetadata(); if (null != metadata && isEmpty(metadata.getShapeSetId())) { final String sId = shapeManager.getDefaultShapeSet(metadata.getDefinitionSetId()).getId(); metadata.setShapeSetId(sId); } } } AbstractClientDiagramService(final ShapeManager shapeManager,
final SessionManager sessionManager,
final Caller<S> diagramServiceCaller,
final Caller<DiagramLookupService> diagramLookupServiceCaller,
final Event<SessionDiagramSavedEvent> saveEvent); }
|
AbstractClientDiagramService implements ClientDiagramService<M, D, S> { protected void updateClientMetadata(final D diagram) { if (null != diagram) { final Metadata metadata = diagram.getMetadata(); if (null != metadata && isEmpty(metadata.getShapeSetId())) { final String sId = shapeManager.getDefaultShapeSet(metadata.getDefinitionSetId()).getId(); metadata.setShapeSetId(sId); } } } AbstractClientDiagramService(final ShapeManager shapeManager,
final SessionManager sessionManager,
final Caller<S> diagramServiceCaller,
final Caller<DiagramLookupService> diagramLookupServiceCaller,
final Event<SessionDiagramSavedEvent> saveEvent); @Override void create(final Path path,
final String name,
final String defSetId,
final ServiceCallback<Path> callback); @Override @SuppressWarnings("unchecked") void saveOrUpdate(final D diagram,
final ServiceCallback<D> callback); @Override void saveOrUpdateSvg(Path diagramPath, String rawSvg, ServiceCallback<Path> callback); @Override void add(final D diagram,
final ServiceCallback<D> callback); @Override @SuppressWarnings("unchecked") void getByPath(final Path path,
final ServiceCallback<D> callback); @Override @SuppressWarnings("unchecked") void lookup(final DiagramLookupRequest request,
final ServiceCallback<LookupManager.LookupResponse<DiagramRepresentation>> callback); @Override void getRawContent(final D diagram,
final ServiceCallback<String> callback); }
|
AbstractClientDiagramService implements ClientDiagramService<M, D, S> { protected void updateClientMetadata(final D diagram) { if (null != diagram) { final Metadata metadata = diagram.getMetadata(); if (null != metadata && isEmpty(metadata.getShapeSetId())) { final String sId = shapeManager.getDefaultShapeSet(metadata.getDefinitionSetId()).getId(); metadata.setShapeSetId(sId); } } } AbstractClientDiagramService(final ShapeManager shapeManager,
final SessionManager sessionManager,
final Caller<S> diagramServiceCaller,
final Caller<DiagramLookupService> diagramLookupServiceCaller,
final Event<SessionDiagramSavedEvent> saveEvent); @Override void create(final Path path,
final String name,
final String defSetId,
final ServiceCallback<Path> callback); @Override @SuppressWarnings("unchecked") void saveOrUpdate(final D diagram,
final ServiceCallback<D> callback); @Override void saveOrUpdateSvg(Path diagramPath, String rawSvg, ServiceCallback<Path> callback); @Override void add(final D diagram,
final ServiceCallback<D> callback); @Override @SuppressWarnings("unchecked") void getByPath(final Path path,
final ServiceCallback<D> callback); @Override @SuppressWarnings("unchecked") void lookup(final DiagramLookupRequest request,
final ServiceCallback<LookupManager.LookupResponse<DiagramRepresentation>> callback); @Override void getRawContent(final D diagram,
final ServiceCallback<String> callback); }
|
@Test @SuppressWarnings("unchecked") public void testGetRawContent() { final ServiceCallback<String> callback = mock(ServiceCallback.class); tested.getRawContent(diagram, callback); verify(diagramService, times(1)).getRawContent(eq(diagram)); verify(callback, times(1)).onSuccess(any(String.class)); verify(callback, times(0)).onError(any(ClientRuntimeError.class)); }
|
@Override public void getRawContent(final D diagram, final ServiceCallback<String> callback) { diagramServiceCaller.call(rawContent -> { callback.onSuccess((String) rawContent); }, (message, throwable) -> { callback.onError(new ClientRuntimeError(throwable)); return false; } ).getRawContent(diagram); }
|
AbstractClientDiagramService implements ClientDiagramService<M, D, S> { @Override public void getRawContent(final D diagram, final ServiceCallback<String> callback) { diagramServiceCaller.call(rawContent -> { callback.onSuccess((String) rawContent); }, (message, throwable) -> { callback.onError(new ClientRuntimeError(throwable)); return false; } ).getRawContent(diagram); } }
|
AbstractClientDiagramService implements ClientDiagramService<M, D, S> { @Override public void getRawContent(final D diagram, final ServiceCallback<String> callback) { diagramServiceCaller.call(rawContent -> { callback.onSuccess((String) rawContent); }, (message, throwable) -> { callback.onError(new ClientRuntimeError(throwable)); return false; } ).getRawContent(diagram); } AbstractClientDiagramService(final ShapeManager shapeManager,
final SessionManager sessionManager,
final Caller<S> diagramServiceCaller,
final Caller<DiagramLookupService> diagramLookupServiceCaller,
final Event<SessionDiagramSavedEvent> saveEvent); }
|
AbstractClientDiagramService implements ClientDiagramService<M, D, S> { @Override public void getRawContent(final D diagram, final ServiceCallback<String> callback) { diagramServiceCaller.call(rawContent -> { callback.onSuccess((String) rawContent); }, (message, throwable) -> { callback.onError(new ClientRuntimeError(throwable)); return false; } ).getRawContent(diagram); } AbstractClientDiagramService(final ShapeManager shapeManager,
final SessionManager sessionManager,
final Caller<S> diagramServiceCaller,
final Caller<DiagramLookupService> diagramLookupServiceCaller,
final Event<SessionDiagramSavedEvent> saveEvent); @Override void create(final Path path,
final String name,
final String defSetId,
final ServiceCallback<Path> callback); @Override @SuppressWarnings("unchecked") void saveOrUpdate(final D diagram,
final ServiceCallback<D> callback); @Override void saveOrUpdateSvg(Path diagramPath, String rawSvg, ServiceCallback<Path> callback); @Override void add(final D diagram,
final ServiceCallback<D> callback); @Override @SuppressWarnings("unchecked") void getByPath(final Path path,
final ServiceCallback<D> callback); @Override @SuppressWarnings("unchecked") void lookup(final DiagramLookupRequest request,
final ServiceCallback<LookupManager.LookupResponse<DiagramRepresentation>> callback); @Override void getRawContent(final D diagram,
final ServiceCallback<String> callback); }
|
AbstractClientDiagramService implements ClientDiagramService<M, D, S> { @Override public void getRawContent(final D diagram, final ServiceCallback<String> callback) { diagramServiceCaller.call(rawContent -> { callback.onSuccess((String) rawContent); }, (message, throwable) -> { callback.onError(new ClientRuntimeError(throwable)); return false; } ).getRawContent(diagram); } AbstractClientDiagramService(final ShapeManager shapeManager,
final SessionManager sessionManager,
final Caller<S> diagramServiceCaller,
final Caller<DiagramLookupService> diagramLookupServiceCaller,
final Event<SessionDiagramSavedEvent> saveEvent); @Override void create(final Path path,
final String name,
final String defSetId,
final ServiceCallback<Path> callback); @Override @SuppressWarnings("unchecked") void saveOrUpdate(final D diagram,
final ServiceCallback<D> callback); @Override void saveOrUpdateSvg(Path diagramPath, String rawSvg, ServiceCallback<Path> callback); @Override void add(final D diagram,
final ServiceCallback<D> callback); @Override @SuppressWarnings("unchecked") void getByPath(final Path path,
final ServiceCallback<D> callback); @Override @SuppressWarnings("unchecked") void lookup(final DiagramLookupRequest request,
final ServiceCallback<LookupManager.LookupResponse<DiagramRepresentation>> callback); @Override void getRawContent(final D diagram,
final ServiceCallback<String> callback); }
|
@Test @SuppressWarnings("unchecked") public void testSaveSessionDiagramSavedEventFiredWhenSaveWasSuccessful() { when(sessionManager.getCurrentSession()).thenReturn(session); ServiceCallback serviceCallback = mock(ServiceCallback.class); when(diagramService.saveOrUpdate(any())).thenReturn(metadata); tested.saveOrUpdate(diagram, serviceCallback); verify(sessionDiagramSavedEvent).fire(new SessionDiagramSavedEvent(session)); }
|
@Override @SuppressWarnings("unchecked") public void saveOrUpdate(final D diagram, final ServiceCallback<D> callback) { diagramServiceCaller.call(serverMetadata -> { updateClientMetadata(diagram); diagram.getMetadata().setPath(((M) serverMetadata).getPath()); callback.onSuccess(diagram); fireSavedEvent(sessionManager.getCurrentSession()); }, (message, throwable) -> { callback.onError(new ClientRuntimeError(throwable)); return false; }).saveOrUpdate(diagram); }
|
AbstractClientDiagramService implements ClientDiagramService<M, D, S> { @Override @SuppressWarnings("unchecked") public void saveOrUpdate(final D diagram, final ServiceCallback<D> callback) { diagramServiceCaller.call(serverMetadata -> { updateClientMetadata(diagram); diagram.getMetadata().setPath(((M) serverMetadata).getPath()); callback.onSuccess(diagram); fireSavedEvent(sessionManager.getCurrentSession()); }, (message, throwable) -> { callback.onError(new ClientRuntimeError(throwable)); return false; }).saveOrUpdate(diagram); } }
|
AbstractClientDiagramService implements ClientDiagramService<M, D, S> { @Override @SuppressWarnings("unchecked") public void saveOrUpdate(final D diagram, final ServiceCallback<D> callback) { diagramServiceCaller.call(serverMetadata -> { updateClientMetadata(diagram); diagram.getMetadata().setPath(((M) serverMetadata).getPath()); callback.onSuccess(diagram); fireSavedEvent(sessionManager.getCurrentSession()); }, (message, throwable) -> { callback.onError(new ClientRuntimeError(throwable)); return false; }).saveOrUpdate(diagram); } AbstractClientDiagramService(final ShapeManager shapeManager,
final SessionManager sessionManager,
final Caller<S> diagramServiceCaller,
final Caller<DiagramLookupService> diagramLookupServiceCaller,
final Event<SessionDiagramSavedEvent> saveEvent); }
|
AbstractClientDiagramService implements ClientDiagramService<M, D, S> { @Override @SuppressWarnings("unchecked") public void saveOrUpdate(final D diagram, final ServiceCallback<D> callback) { diagramServiceCaller.call(serverMetadata -> { updateClientMetadata(diagram); diagram.getMetadata().setPath(((M) serverMetadata).getPath()); callback.onSuccess(diagram); fireSavedEvent(sessionManager.getCurrentSession()); }, (message, throwable) -> { callback.onError(new ClientRuntimeError(throwable)); return false; }).saveOrUpdate(diagram); } AbstractClientDiagramService(final ShapeManager shapeManager,
final SessionManager sessionManager,
final Caller<S> diagramServiceCaller,
final Caller<DiagramLookupService> diagramLookupServiceCaller,
final Event<SessionDiagramSavedEvent> saveEvent); @Override void create(final Path path,
final String name,
final String defSetId,
final ServiceCallback<Path> callback); @Override @SuppressWarnings("unchecked") void saveOrUpdate(final D diagram,
final ServiceCallback<D> callback); @Override void saveOrUpdateSvg(Path diagramPath, String rawSvg, ServiceCallback<Path> callback); @Override void add(final D diagram,
final ServiceCallback<D> callback); @Override @SuppressWarnings("unchecked") void getByPath(final Path path,
final ServiceCallback<D> callback); @Override @SuppressWarnings("unchecked") void lookup(final DiagramLookupRequest request,
final ServiceCallback<LookupManager.LookupResponse<DiagramRepresentation>> callback); @Override void getRawContent(final D diagram,
final ServiceCallback<String> callback); }
|
AbstractClientDiagramService implements ClientDiagramService<M, D, S> { @Override @SuppressWarnings("unchecked") public void saveOrUpdate(final D diagram, final ServiceCallback<D> callback) { diagramServiceCaller.call(serverMetadata -> { updateClientMetadata(diagram); diagram.getMetadata().setPath(((M) serverMetadata).getPath()); callback.onSuccess(diagram); fireSavedEvent(sessionManager.getCurrentSession()); }, (message, throwable) -> { callback.onError(new ClientRuntimeError(throwable)); return false; }).saveOrUpdate(diagram); } AbstractClientDiagramService(final ShapeManager shapeManager,
final SessionManager sessionManager,
final Caller<S> diagramServiceCaller,
final Caller<DiagramLookupService> diagramLookupServiceCaller,
final Event<SessionDiagramSavedEvent> saveEvent); @Override void create(final Path path,
final String name,
final String defSetId,
final ServiceCallback<Path> callback); @Override @SuppressWarnings("unchecked") void saveOrUpdate(final D diagram,
final ServiceCallback<D> callback); @Override void saveOrUpdateSvg(Path diagramPath, String rawSvg, ServiceCallback<Path> callback); @Override void add(final D diagram,
final ServiceCallback<D> callback); @Override @SuppressWarnings("unchecked") void getByPath(final Path path,
final ServiceCallback<D> callback); @Override @SuppressWarnings("unchecked") void lookup(final DiagramLookupRequest request,
final ServiceCallback<LookupManager.LookupResponse<DiagramRepresentation>> callback); @Override void getRawContent(final D diagram,
final ServiceCallback<String> callback); }
|
@Test @SuppressWarnings("unchecked") public void testSaveSessionDiagramSavedEventNotFiredWhenSaveWasUnSuccessful() { TestUtils.prepareServiceCallerError(diagramService, diagramServiceCaller, new Throwable("some error")); when(sessionManager.getCurrentSession()).thenReturn(session); ServiceCallback serviceCallback = mock(ServiceCallback.class); when(diagramService.saveOrUpdate(any())).thenReturn(metadata); tested.saveOrUpdate(diagram, serviceCallback); verify(sessionDiagramSavedEvent, never()).fire(any(SessionDiagramSavedEvent.class)); }
|
@Override @SuppressWarnings("unchecked") public void saveOrUpdate(final D diagram, final ServiceCallback<D> callback) { diagramServiceCaller.call(serverMetadata -> { updateClientMetadata(diagram); diagram.getMetadata().setPath(((M) serverMetadata).getPath()); callback.onSuccess(diagram); fireSavedEvent(sessionManager.getCurrentSession()); }, (message, throwable) -> { callback.onError(new ClientRuntimeError(throwable)); return false; }).saveOrUpdate(diagram); }
|
AbstractClientDiagramService implements ClientDiagramService<M, D, S> { @Override @SuppressWarnings("unchecked") public void saveOrUpdate(final D diagram, final ServiceCallback<D> callback) { diagramServiceCaller.call(serverMetadata -> { updateClientMetadata(diagram); diagram.getMetadata().setPath(((M) serverMetadata).getPath()); callback.onSuccess(diagram); fireSavedEvent(sessionManager.getCurrentSession()); }, (message, throwable) -> { callback.onError(new ClientRuntimeError(throwable)); return false; }).saveOrUpdate(diagram); } }
|
AbstractClientDiagramService implements ClientDiagramService<M, D, S> { @Override @SuppressWarnings("unchecked") public void saveOrUpdate(final D diagram, final ServiceCallback<D> callback) { diagramServiceCaller.call(serverMetadata -> { updateClientMetadata(diagram); diagram.getMetadata().setPath(((M) serverMetadata).getPath()); callback.onSuccess(diagram); fireSavedEvent(sessionManager.getCurrentSession()); }, (message, throwable) -> { callback.onError(new ClientRuntimeError(throwable)); return false; }).saveOrUpdate(diagram); } AbstractClientDiagramService(final ShapeManager shapeManager,
final SessionManager sessionManager,
final Caller<S> diagramServiceCaller,
final Caller<DiagramLookupService> diagramLookupServiceCaller,
final Event<SessionDiagramSavedEvent> saveEvent); }
|
AbstractClientDiagramService implements ClientDiagramService<M, D, S> { @Override @SuppressWarnings("unchecked") public void saveOrUpdate(final D diagram, final ServiceCallback<D> callback) { diagramServiceCaller.call(serverMetadata -> { updateClientMetadata(diagram); diagram.getMetadata().setPath(((M) serverMetadata).getPath()); callback.onSuccess(diagram); fireSavedEvent(sessionManager.getCurrentSession()); }, (message, throwable) -> { callback.onError(new ClientRuntimeError(throwable)); return false; }).saveOrUpdate(diagram); } AbstractClientDiagramService(final ShapeManager shapeManager,
final SessionManager sessionManager,
final Caller<S> diagramServiceCaller,
final Caller<DiagramLookupService> diagramLookupServiceCaller,
final Event<SessionDiagramSavedEvent> saveEvent); @Override void create(final Path path,
final String name,
final String defSetId,
final ServiceCallback<Path> callback); @Override @SuppressWarnings("unchecked") void saveOrUpdate(final D diagram,
final ServiceCallback<D> callback); @Override void saveOrUpdateSvg(Path diagramPath, String rawSvg, ServiceCallback<Path> callback); @Override void add(final D diagram,
final ServiceCallback<D> callback); @Override @SuppressWarnings("unchecked") void getByPath(final Path path,
final ServiceCallback<D> callback); @Override @SuppressWarnings("unchecked") void lookup(final DiagramLookupRequest request,
final ServiceCallback<LookupManager.LookupResponse<DiagramRepresentation>> callback); @Override void getRawContent(final D diagram,
final ServiceCallback<String> callback); }
|
AbstractClientDiagramService implements ClientDiagramService<M, D, S> { @Override @SuppressWarnings("unchecked") public void saveOrUpdate(final D diagram, final ServiceCallback<D> callback) { diagramServiceCaller.call(serverMetadata -> { updateClientMetadata(diagram); diagram.getMetadata().setPath(((M) serverMetadata).getPath()); callback.onSuccess(diagram); fireSavedEvent(sessionManager.getCurrentSession()); }, (message, throwable) -> { callback.onError(new ClientRuntimeError(throwable)); return false; }).saveOrUpdate(diagram); } AbstractClientDiagramService(final ShapeManager shapeManager,
final SessionManager sessionManager,
final Caller<S> diagramServiceCaller,
final Caller<DiagramLookupService> diagramLookupServiceCaller,
final Event<SessionDiagramSavedEvent> saveEvent); @Override void create(final Path path,
final String name,
final String defSetId,
final ServiceCallback<Path> callback); @Override @SuppressWarnings("unchecked") void saveOrUpdate(final D diagram,
final ServiceCallback<D> callback); @Override void saveOrUpdateSvg(Path diagramPath, String rawSvg, ServiceCallback<Path> callback); @Override void add(final D diagram,
final ServiceCallback<D> callback); @Override @SuppressWarnings("unchecked") void getByPath(final Path path,
final ServiceCallback<D> callback); @Override @SuppressWarnings("unchecked") void lookup(final DiagramLookupRequest request,
final ServiceCallback<LookupManager.LookupResponse<DiagramRepresentation>> callback); @Override void getRawContent(final D diagram,
final ServiceCallback<String> callback); }
|
@Test public void testRegisterHandlers() { tested.init(); verify(registry, times(1)).register(eq(handler)); }
|
@PostConstruct public void init() { ruleEvaluationHandlerInstances.forEach(registry()::register); }
|
ClientRuleManager implements RuleManager { @PostConstruct public void init() { ruleEvaluationHandlerInstances.forEach(registry()::register); } }
|
ClientRuleManager implements RuleManager { @PostConstruct public void init() { ruleEvaluationHandlerInstances.forEach(registry()::register); } protected ClientRuleManager(); @Inject ClientRuleManager(final CachedRuleManager ruleManager,
final @Any ManagedInstance<RuleEvaluationHandler> ruleEvaluationHandlerInstances); }
|
ClientRuleManager implements RuleManager { @PostConstruct public void init() { ruleEvaluationHandlerInstances.forEach(registry()::register); } protected ClientRuleManager(); @Inject ClientRuleManager(final CachedRuleManager ruleManager,
final @Any ManagedInstance<RuleEvaluationHandler> ruleEvaluationHandlerInstances); @PostConstruct void init(); @Override RuleHandlerRegistry registry(); @Override RuleViolations evaluate(final RuleSet ruleSet,
final RuleEvaluationContext context); }
|
ClientRuleManager implements RuleManager { @PostConstruct public void init() { ruleEvaluationHandlerInstances.forEach(registry()::register); } protected ClientRuleManager(); @Inject ClientRuleManager(final CachedRuleManager ruleManager,
final @Any ManagedInstance<RuleEvaluationHandler> ruleEvaluationHandlerInstances); @PostConstruct void init(); @Override RuleHandlerRegistry registry(); @Override RuleViolations evaluate(final RuleSet ruleSet,
final RuleEvaluationContext context); }
|
@Test public void testGetRegistry() { assertEquals(registry, tested.registry()); }
|
@Override public RuleHandlerRegistry registry() { return ruleManager.registry(); }
|
ClientRuleManager implements RuleManager { @Override public RuleHandlerRegistry registry() { return ruleManager.registry(); } }
|
ClientRuleManager implements RuleManager { @Override public RuleHandlerRegistry registry() { return ruleManager.registry(); } protected ClientRuleManager(); @Inject ClientRuleManager(final CachedRuleManager ruleManager,
final @Any ManagedInstance<RuleEvaluationHandler> ruleEvaluationHandlerInstances); }
|
ClientRuleManager implements RuleManager { @Override public RuleHandlerRegistry registry() { return ruleManager.registry(); } protected ClientRuleManager(); @Inject ClientRuleManager(final CachedRuleManager ruleManager,
final @Any ManagedInstance<RuleEvaluationHandler> ruleEvaluationHandlerInstances); @PostConstruct void init(); @Override RuleHandlerRegistry registry(); @Override RuleViolations evaluate(final RuleSet ruleSet,
final RuleEvaluationContext context); }
|
ClientRuleManager implements RuleManager { @Override public RuleHandlerRegistry registry() { return ruleManager.registry(); } protected ClientRuleManager(); @Inject ClientRuleManager(final CachedRuleManager ruleManager,
final @Any ManagedInstance<RuleEvaluationHandler> ruleEvaluationHandlerInstances); @PostConstruct void init(); @Override RuleHandlerRegistry registry(); @Override RuleViolations evaluate(final RuleSet ruleSet,
final RuleEvaluationContext context); }
|
@Test public void testOnItemSelected() { listSelector.bind(bound, 0, 0); listSelector.onItemSelected(listSelectorItem2); verify(bound).onItemSelected(eq(listSelectorItem2)); }
|
@Override public void onItemSelected(final ListSelectorItem item) { binding.ifPresent(b -> b.onItemSelected(item)); }
|
ListSelector extends AbstractPopoverImpl<ListSelectorView, HasListSelectorControl> implements ListSelectorView.Presenter { @Override public void onItemSelected(final ListSelectorItem item) { binding.ifPresent(b -> b.onItemSelected(item)); } }
|
ListSelector extends AbstractPopoverImpl<ListSelectorView, HasListSelectorControl> implements ListSelectorView.Presenter { @Override public void onItemSelected(final ListSelectorItem item) { binding.ifPresent(b -> b.onItemSelected(item)); } ListSelector(); @Inject ListSelector(final ListSelectorView view); }
|
ListSelector extends AbstractPopoverImpl<ListSelectorView, HasListSelectorControl> implements ListSelectorView.Presenter { @Override public void onItemSelected(final ListSelectorItem item) { binding.ifPresent(b -> b.onItemSelected(item)); } ListSelector(); @Inject ListSelector(final ListSelectorView view); @Override void onItemSelected(final ListSelectorItem item); @Override void bind(final HasListSelectorControl bound,
final int uiRowIndex,
final int uiColumnIndex); }
|
ListSelector extends AbstractPopoverImpl<ListSelectorView, HasListSelectorControl> implements ListSelectorView.Presenter { @Override public void onItemSelected(final ListSelectorItem item) { binding.ifPresent(b -> b.onItemSelected(item)); } ListSelector(); @Inject ListSelector(final ListSelectorView view); @Override void onItemSelected(final ListSelectorItem item); @Override void bind(final HasListSelectorControl bound,
final int uiRowIndex,
final int uiColumnIndex); }
|
@Test public void testEvaluate() { RuleSet ruleSet = mock(RuleSet.class); RuleEvaluationContext context = mock(RuleEvaluationContext.class); tested.evaluate(ruleSet, context); verify(ruleManager, times(1)).evaluate(eq(ruleSet), eq(context)); }
|
@Override public RuleViolations evaluate(final RuleSet ruleSet, final RuleEvaluationContext context) { return ruleManager.evaluate(ruleSet, context); }
|
ClientRuleManager implements RuleManager { @Override public RuleViolations evaluate(final RuleSet ruleSet, final RuleEvaluationContext context) { return ruleManager.evaluate(ruleSet, context); } }
|
ClientRuleManager implements RuleManager { @Override public RuleViolations evaluate(final RuleSet ruleSet, final RuleEvaluationContext context) { return ruleManager.evaluate(ruleSet, context); } protected ClientRuleManager(); @Inject ClientRuleManager(final CachedRuleManager ruleManager,
final @Any ManagedInstance<RuleEvaluationHandler> ruleEvaluationHandlerInstances); }
|
ClientRuleManager implements RuleManager { @Override public RuleViolations evaluate(final RuleSet ruleSet, final RuleEvaluationContext context) { return ruleManager.evaluate(ruleSet, context); } protected ClientRuleManager(); @Inject ClientRuleManager(final CachedRuleManager ruleManager,
final @Any ManagedInstance<RuleEvaluationHandler> ruleEvaluationHandlerInstances); @PostConstruct void init(); @Override RuleHandlerRegistry registry(); @Override RuleViolations evaluate(final RuleSet ruleSet,
final RuleEvaluationContext context); }
|
ClientRuleManager implements RuleManager { @Override public RuleViolations evaluate(final RuleSet ruleSet, final RuleEvaluationContext context) { return ruleManager.evaluate(ruleSet, context); } protected ClientRuleManager(); @Inject ClientRuleManager(final CachedRuleManager ruleManager,
final @Any ManagedInstance<RuleEvaluationHandler> ruleEvaluationHandlerInstances); @PostConstruct void init(); @Override RuleHandlerRegistry registry(); @Override RuleViolations evaluate(final RuleSet ruleSet,
final RuleEvaluationContext context); }
|
@Test public void testGetQualifier() { tested.getQualifier().apply("q1"); verify(definitionUtils, times(1)).getQualifier(eq("q1")); tested.getQualifier().apply("q2"); verify(definitionUtils, times(1)).getQualifier(eq("q2")); }
|
@Override protected Function<String, Annotation> getQualifier() { return definitionUtils::getQualifier; }
|
ClientProfileManager extends AbstractProfileManager { @Override protected Function<String, Annotation> getQualifier() { return definitionUtils::getQualifier; } }
|
ClientProfileManager extends AbstractProfileManager { @Override protected Function<String, Annotation> getQualifier() { return definitionUtils::getQualifier; } @Inject ClientProfileManager(final DefinitionUtils definitionUtils,
final @Any ManagedInstance<Profile> profileInstances); }
|
ClientProfileManager extends AbstractProfileManager { @Override protected Function<String, Annotation> getQualifier() { return definitionUtils::getQualifier; } @Inject ClientProfileManager(final DefinitionUtils definitionUtils,
final @Any ManagedInstance<Profile> profileInstances); @PreDestroy void destroy(); }
|
ClientProfileManager extends AbstractProfileManager { @Override protected Function<String, Annotation> getQualifier() { return definitionUtils::getQualifier; } @Inject ClientProfileManager(final DefinitionUtils definitionUtils,
final @Any ManagedInstance<Profile> profileInstances); @PreDestroy void destroy(); }
|
@Test public void testGetAllProfileInstances() { Iterable<Profile> profiles = tested.getAllProfileInstances(); Iterator<Profile> iterator = profiles.iterator(); assertEquals(profile1, iterator.next()); assertEquals(profile2, iterator.next()); assertFalse(iterator.hasNext()); }
|
@Override protected Iterable<Profile> getAllProfileInstances() { return profileInstances; }
|
ClientProfileManager extends AbstractProfileManager { @Override protected Iterable<Profile> getAllProfileInstances() { return profileInstances; } }
|
ClientProfileManager extends AbstractProfileManager { @Override protected Iterable<Profile> getAllProfileInstances() { return profileInstances; } @Inject ClientProfileManager(final DefinitionUtils definitionUtils,
final @Any ManagedInstance<Profile> profileInstances); }
|
ClientProfileManager extends AbstractProfileManager { @Override protected Iterable<Profile> getAllProfileInstances() { return profileInstances; } @Inject ClientProfileManager(final DefinitionUtils definitionUtils,
final @Any ManagedInstance<Profile> profileInstances); @PreDestroy void destroy(); }
|
ClientProfileManager extends AbstractProfileManager { @Override protected Iterable<Profile> getAllProfileInstances() { return profileInstances; } @Inject ClientProfileManager(final DefinitionUtils definitionUtils,
final @Any ManagedInstance<Profile> profileInstances); @PreDestroy void destroy(); }
|
@Test public void testSelectProfileInstances() { Annotation qualifier = mock(Annotation.class); tested.selectProfileInstances(qualifier); verify(profileInstances, times(1)).select(eq(qualifier)); }
|
@Override protected Iterable<Profile> selectProfileInstances(final Annotation... qualifiers) { return profileInstances.select(qualifiers); }
|
ClientProfileManager extends AbstractProfileManager { @Override protected Iterable<Profile> selectProfileInstances(final Annotation... qualifiers) { return profileInstances.select(qualifiers); } }
|
ClientProfileManager extends AbstractProfileManager { @Override protected Iterable<Profile> selectProfileInstances(final Annotation... qualifiers) { return profileInstances.select(qualifiers); } @Inject ClientProfileManager(final DefinitionUtils definitionUtils,
final @Any ManagedInstance<Profile> profileInstances); }
|
ClientProfileManager extends AbstractProfileManager { @Override protected Iterable<Profile> selectProfileInstances(final Annotation... qualifiers) { return profileInstances.select(qualifiers); } @Inject ClientProfileManager(final DefinitionUtils definitionUtils,
final @Any ManagedInstance<Profile> profileInstances); @PreDestroy void destroy(); }
|
ClientProfileManager extends AbstractProfileManager { @Override protected Iterable<Profile> selectProfileInstances(final Annotation... qualifiers) { return profileInstances.select(qualifiers); } @Inject ClientProfileManager(final DefinitionUtils definitionUtils,
final @Any ManagedInstance<Profile> profileInstances); @PreDestroy void destroy(); }
|
@Test public void testDestroy() { tested.destroy(); verify(profileInstances, times(1)).destroyAll(); }
|
@PreDestroy public void destroy() { profileInstances.destroyAll(); }
|
ClientProfileManager extends AbstractProfileManager { @PreDestroy public void destroy() { profileInstances.destroyAll(); } }
|
ClientProfileManager extends AbstractProfileManager { @PreDestroy public void destroy() { profileInstances.destroyAll(); } @Inject ClientProfileManager(final DefinitionUtils definitionUtils,
final @Any ManagedInstance<Profile> profileInstances); }
|
ClientProfileManager extends AbstractProfileManager { @PreDestroy public void destroy() { profileInstances.destroyAll(); } @Inject ClientProfileManager(final DefinitionUtils definitionUtils,
final @Any ManagedInstance<Profile> profileInstances); @PreDestroy void destroy(); }
|
ClientProfileManager extends AbstractProfileManager { @PreDestroy public void destroy() { profileInstances.destroyAll(); } @Inject ClientProfileManager(final DefinitionUtils definitionUtils,
final @Any ManagedInstance<Profile> profileInstances); @PreDestroy void destroy(); }
|
@Test public void testStart() { tested.start(); verify(lifecycle, times(1)).start(); verify(lifecycle, never()).complete(); verify(lifecycle, never()).rollback(); }
|
@Override public void start() { getTarget().start(); }
|
MouseRequestLifecycle implements CommandRequestLifecycle { @Override public void start() { getTarget().start(); } }
|
MouseRequestLifecycle implements CommandRequestLifecycle { @Override public void start() { getTarget().start(); } }
|
MouseRequestLifecycle implements CommandRequestLifecycle { @Override public void start() { getTarget().start(); } void listen(Supplier<CommandRequestLifecycle> target); @Override void start(); @Override void rollback(); @Override void complete(); @PreDestroy void destroy(); }
|
MouseRequestLifecycle implements CommandRequestLifecycle { @Override public void start() { getTarget().start(); } void listen(Supplier<CommandRequestLifecycle> target); @Override void start(); @Override void rollback(); @Override void complete(); @PreDestroy void destroy(); }
|
@Test public void testRollback() { tested.rollback(); verify(lifecycle, times(1)).rollback(); verify(lifecycle, never()).complete(); verify(lifecycle, never()).start(); }
|
@Override public void rollback() { getTarget().rollback(); }
|
MouseRequestLifecycle implements CommandRequestLifecycle { @Override public void rollback() { getTarget().rollback(); } }
|
MouseRequestLifecycle implements CommandRequestLifecycle { @Override public void rollback() { getTarget().rollback(); } }
|
MouseRequestLifecycle implements CommandRequestLifecycle { @Override public void rollback() { getTarget().rollback(); } void listen(Supplier<CommandRequestLifecycle> target); @Override void start(); @Override void rollback(); @Override void complete(); @PreDestroy void destroy(); }
|
MouseRequestLifecycle implements CommandRequestLifecycle { @Override public void rollback() { getTarget().rollback(); } void listen(Supplier<CommandRequestLifecycle> target); @Override void start(); @Override void rollback(); @Override void complete(); @PreDestroy void destroy(); }
|
@Test public void testComplete() { tested.complete(); verify(lifecycle, times(1)).complete(); verify(lifecycle, never()).rollback(); verify(lifecycle, never()).start(); }
|
@Override public void complete() { getTarget().complete(); }
|
MouseRequestLifecycle implements CommandRequestLifecycle { @Override public void complete() { getTarget().complete(); } }
|
MouseRequestLifecycle implements CommandRequestLifecycle { @Override public void complete() { getTarget().complete(); } }
|
MouseRequestLifecycle implements CommandRequestLifecycle { @Override public void complete() { getTarget().complete(); } void listen(Supplier<CommandRequestLifecycle> target); @Override void start(); @Override void rollback(); @Override void complete(); @PreDestroy void destroy(); }
|
MouseRequestLifecycle implements CommandRequestLifecycle { @Override public void complete() { getTarget().complete(); } void listen(Supplier<CommandRequestLifecycle> target); @Override void start(); @Override void rollback(); @Override void complete(); @PreDestroy void destroy(); }
|
@Test public void testOnMouseDown() { tested.onMouseDown(mock(CanvasMouseDownEvent.class)); verify(lifecycle, times(1)).start(); verify(lifecycle, never()).complete(); verify(lifecycle, never()).rollback(); }
|
void onMouseDown(final @Observes CanvasMouseDownEvent event) { start(); }
|
MouseRequestLifecycle implements CommandRequestLifecycle { void onMouseDown(final @Observes CanvasMouseDownEvent event) { start(); } }
|
MouseRequestLifecycle implements CommandRequestLifecycle { void onMouseDown(final @Observes CanvasMouseDownEvent event) { start(); } }
|
MouseRequestLifecycle implements CommandRequestLifecycle { void onMouseDown(final @Observes CanvasMouseDownEvent event) { start(); } void listen(Supplier<CommandRequestLifecycle> target); @Override void start(); @Override void rollback(); @Override void complete(); @PreDestroy void destroy(); }
|
MouseRequestLifecycle implements CommandRequestLifecycle { void onMouseDown(final @Observes CanvasMouseDownEvent event) { start(); } void listen(Supplier<CommandRequestLifecycle> target); @Override void start(); @Override void rollback(); @Override void complete(); @PreDestroy void destroy(); }
|
@Test public void testOnMouseUp() { tested.onMouseUp(mock(CanvasMouseUpEvent.class)); verify(lifecycle, times(1)).complete(); verify(lifecycle, never()).rollback(); verify(lifecycle, never()).start(); }
|
void onMouseUp(final @Observes CanvasMouseUpEvent event) { complete(); }
|
MouseRequestLifecycle implements CommandRequestLifecycle { void onMouseUp(final @Observes CanvasMouseUpEvent event) { complete(); } }
|
MouseRequestLifecycle implements CommandRequestLifecycle { void onMouseUp(final @Observes CanvasMouseUpEvent event) { complete(); } }
|
MouseRequestLifecycle implements CommandRequestLifecycle { void onMouseUp(final @Observes CanvasMouseUpEvent event) { complete(); } void listen(Supplier<CommandRequestLifecycle> target); @Override void start(); @Override void rollback(); @Override void complete(); @PreDestroy void destroy(); }
|
MouseRequestLifecycle implements CommandRequestLifecycle { void onMouseUp(final @Observes CanvasMouseUpEvent event) { complete(); } void listen(Supplier<CommandRequestLifecycle> target); @Override void start(); @Override void rollback(); @Override void complete(); @PreDestroy void destroy(); }
|
@Test public void testSetItems() { final boolean textItemEnabled = true; final String textItemText = "Insert rule above"; doReturn(textItemEnabled).when(textItem).isEnabled(); doReturn(textItemText).when(textItem).getText(); final String headerItemText = "Header"; doReturn(headerItemText).when(headerItem).getText(); view.setItems(Arrays.asList(textItem, dividerItem, headerItem)); verify(itemsContainer).appendChild(textElement); verify(itemsContainer).appendChild(dividerElement); verify(itemsContainer).appendChild(headerElement); verify(textItemView).setEnabled(eq(textItemEnabled)); verify(textItemView).setText(eq(textItemText)); verify(headerItemView).setText(eq(headerItemText)); final ArgumentCaptor<Command> commandCaptor = ArgumentCaptor.forClass(Command.class); verify(textItemView).addClickHandler(commandCaptor.capture()); commandCaptor.getValue().execute(); verify(presenter).onItemSelected(eq(textItem)); reset(presenter); doReturn(false).when(textItem).isEnabled(); commandCaptor.getValue().execute(); verify(presenter, never()).onItemSelected(any(HasListSelectorControl.ListSelectorTextItem.class)); }
|
@Override public void setItems(final List<ListSelectorItem> items) { DOMUtil.removeAllChildren(itemsContainer); items.forEach(item -> makeListSelectorItemView(item).ifPresent(child -> itemsContainer.appendChild(child.getElement()))); }
|
ListSelectorViewImpl implements ListSelectorView { @Override public void setItems(final List<ListSelectorItem> items) { DOMUtil.removeAllChildren(itemsContainer); items.forEach(item -> makeListSelectorItemView(item).ifPresent(child -> itemsContainer.appendChild(child.getElement()))); } }
|
ListSelectorViewImpl implements ListSelectorView { @Override public void setItems(final List<ListSelectorItem> items) { DOMUtil.removeAllChildren(itemsContainer); items.forEach(item -> makeListSelectorItemView(item).ifPresent(child -> itemsContainer.appendChild(child.getElement()))); } ListSelectorViewImpl(); @Inject ListSelectorViewImpl(final UnorderedList itemsContainer,
final ManagedInstance<ListSelectorTextItemView> listSelectorTextItemViews,
final ManagedInstance<ListSelectorDividerItemView> listSelectorDividerItemViews,
final ManagedInstance<ListSelectorHeaderItemView> listSelectorHeaderItemViews); }
|
ListSelectorViewImpl implements ListSelectorView { @Override public void setItems(final List<ListSelectorItem> items) { DOMUtil.removeAllChildren(itemsContainer); items.forEach(item -> makeListSelectorItemView(item).ifPresent(child -> itemsContainer.appendChild(child.getElement()))); } ListSelectorViewImpl(); @Inject ListSelectorViewImpl(final UnorderedList itemsContainer,
final ManagedInstance<ListSelectorTextItemView> listSelectorTextItemViews,
final ManagedInstance<ListSelectorDividerItemView> listSelectorDividerItemViews,
final ManagedInstance<ListSelectorHeaderItemView> listSelectorHeaderItemViews); @Override void init(final Presenter presenter); @Override void setItems(final List<ListSelectorItem> items); @Override void show(final Optional<String> title); @Override void hide(); @Override void setOnClosedByKeyboardCallback(final Consumer<CanBeClosedByKeyboard> callback); }
|
ListSelectorViewImpl implements ListSelectorView { @Override public void setItems(final List<ListSelectorItem> items) { DOMUtil.removeAllChildren(itemsContainer); items.forEach(item -> makeListSelectorItemView(item).ifPresent(child -> itemsContainer.appendChild(child.getElement()))); } ListSelectorViewImpl(); @Inject ListSelectorViewImpl(final UnorderedList itemsContainer,
final ManagedInstance<ListSelectorTextItemView> listSelectorTextItemViews,
final ManagedInstance<ListSelectorDividerItemView> listSelectorDividerItemViews,
final ManagedInstance<ListSelectorHeaderItemView> listSelectorHeaderItemViews); @Override void init(final Presenter presenter); @Override void setItems(final List<ListSelectorItem> items); @Override void show(final Optional<String> title); @Override void hide(); @Override void setOnClosedByKeyboardCallback(final Consumer<CanBeClosedByKeyboard> callback); }
|
@Test @SuppressWarnings("unchecked") public void testRollback() { Consumer<Command<AbstractCanvasHandler, CanvasViolation>> fireComplete = mock(Consumer.class); tested = new RequestCommands.Builder() .onComplete(fireComplete) .onRollback(c -> command = (CompositeCommand<AbstractCanvasHandler, CanvasViolation>) c) .build(); tested.start(); tested.push(c1); tested.push(c2); tested.rollback(); tested.push(c3); tested.complete(); assertNotNull(command); assertTrue(command.getCommands().contains(c1)); assertTrue(command.getCommands().contains(c2)); assertTrue(command.getCommands().contains(c3)); verify(fireComplete, never()).accept(any()); }
|
@Override public void rollback() { rollback = true; }
|
RequestCommands implements CommandRequestLifecycle { @Override public void rollback() { rollback = true; } }
|
RequestCommands implements CommandRequestLifecycle { @Override public void rollback() { rollback = true; } RequestCommands(final Consumer<Command<AbstractCanvasHandler, CanvasViolation>> completedCommand,
final Consumer<Command<AbstractCanvasHandler, CanvasViolation>> rollbackCommand); }
|
RequestCommands implements CommandRequestLifecycle { @Override public void rollback() { rollback = true; } RequestCommands(final Consumer<Command<AbstractCanvasHandler, CanvasViolation>> completedCommand,
final Consumer<Command<AbstractCanvasHandler, CanvasViolation>> rollbackCommand); @Override void start(); void push(Command<AbstractCanvasHandler, CanvasViolation> command); @Override void rollback(); @Override void complete(); }
|
RequestCommands implements CommandRequestLifecycle { @Override public void rollback() { rollback = true; } RequestCommands(final Consumer<Command<AbstractCanvasHandler, CanvasViolation>> completedCommand,
final Consumer<Command<AbstractCanvasHandler, CanvasViolation>> rollbackCommand); @Override void start(); void push(Command<AbstractCanvasHandler, CanvasViolation> command); @Override void rollback(); @Override void complete(); }
|
@Test public void testInit() { tested.init(); assertEquals(tested, lifecycle.getTarget()); verify(lifecycle, never()).start(); verify(lifecycle, never()).rollback(); verify(lifecycle, never()).complete(); }
|
@PostConstruct public void init() { lifecycle.listen(() -> this); }
|
ApplicationCommandManager implements SessionCommandManager<AbstractCanvasHandler> { @PostConstruct public void init() { lifecycle.listen(() -> this); } }
|
ApplicationCommandManager implements SessionCommandManager<AbstractCanvasHandler> { @PostConstruct public void init() { lifecycle.listen(() -> this); } @Inject ApplicationCommandManager(final SessionManager sessionManager,
final MouseRequestLifecycle lifecycle,
final @Any ManagedInstance<RegistryAwareCommandManager> commandManagerInstances); }
|
ApplicationCommandManager implements SessionCommandManager<AbstractCanvasHandler> { @PostConstruct public void init() { lifecycle.listen(() -> this); } @Inject ApplicationCommandManager(final SessionManager sessionManager,
final MouseRequestLifecycle lifecycle,
final @Any ManagedInstance<RegistryAwareCommandManager> commandManagerInstances); @PostConstruct void init(); @Override void start(); @Override void rollback(); @Override void complete(); CommandResult<CanvasViolation> allow(final Command<AbstractCanvasHandler, CanvasViolation> command); CommandResult<CanvasViolation> execute(final Command<AbstractCanvasHandler, CanvasViolation> command); CommandResult<CanvasViolation> undo(); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); @PreDestroy void destroy(); }
|
ApplicationCommandManager implements SessionCommandManager<AbstractCanvasHandler> { @PostConstruct public void init() { lifecycle.listen(() -> this); } @Inject ApplicationCommandManager(final SessionManager sessionManager,
final MouseRequestLifecycle lifecycle,
final @Any ManagedInstance<RegistryAwareCommandManager> commandManagerInstances); @PostConstruct void init(); @Override void start(); @Override void rollback(); @Override void complete(); CommandResult<CanvasViolation> allow(final Command<AbstractCanvasHandler, CanvasViolation> command); CommandResult<CanvasViolation> execute(final Command<AbstractCanvasHandler, CanvasViolation> command); CommandResult<CanvasViolation> undo(); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); @PreDestroy void destroy(); }
|
@Test public void testStart() { tested.start(); verify(commandManager, times(1)).init(eq(session)); verify(commandManager, times(1)).start(); verify(commandManager, never()).rollback(); verify(commandManager, never()).complete(); }
|
@Override public void start() { getDelegate().start(); }
|
ApplicationCommandManager implements SessionCommandManager<AbstractCanvasHandler> { @Override public void start() { getDelegate().start(); } }
|
ApplicationCommandManager implements SessionCommandManager<AbstractCanvasHandler> { @Override public void start() { getDelegate().start(); } @Inject ApplicationCommandManager(final SessionManager sessionManager,
final MouseRequestLifecycle lifecycle,
final @Any ManagedInstance<RegistryAwareCommandManager> commandManagerInstances); }
|
ApplicationCommandManager implements SessionCommandManager<AbstractCanvasHandler> { @Override public void start() { getDelegate().start(); } @Inject ApplicationCommandManager(final SessionManager sessionManager,
final MouseRequestLifecycle lifecycle,
final @Any ManagedInstance<RegistryAwareCommandManager> commandManagerInstances); @PostConstruct void init(); @Override void start(); @Override void rollback(); @Override void complete(); CommandResult<CanvasViolation> allow(final Command<AbstractCanvasHandler, CanvasViolation> command); CommandResult<CanvasViolation> execute(final Command<AbstractCanvasHandler, CanvasViolation> command); CommandResult<CanvasViolation> undo(); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); @PreDestroy void destroy(); }
|
ApplicationCommandManager implements SessionCommandManager<AbstractCanvasHandler> { @Override public void start() { getDelegate().start(); } @Inject ApplicationCommandManager(final SessionManager sessionManager,
final MouseRequestLifecycle lifecycle,
final @Any ManagedInstance<RegistryAwareCommandManager> commandManagerInstances); @PostConstruct void init(); @Override void start(); @Override void rollback(); @Override void complete(); CommandResult<CanvasViolation> allow(final Command<AbstractCanvasHandler, CanvasViolation> command); CommandResult<CanvasViolation> execute(final Command<AbstractCanvasHandler, CanvasViolation> command); CommandResult<CanvasViolation> undo(); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); @PreDestroy void destroy(); }
|
@Test public void testComplete() { tested.start(); tested.complete(); verify(commandManager, times(1)).start(); verify(commandManager, times(1)).complete(); verify(commandManager, never()).rollback(); }
|
@Override public void complete() { getDelegate().complete(); }
|
ApplicationCommandManager implements SessionCommandManager<AbstractCanvasHandler> { @Override public void complete() { getDelegate().complete(); } }
|
ApplicationCommandManager implements SessionCommandManager<AbstractCanvasHandler> { @Override public void complete() { getDelegate().complete(); } @Inject ApplicationCommandManager(final SessionManager sessionManager,
final MouseRequestLifecycle lifecycle,
final @Any ManagedInstance<RegistryAwareCommandManager> commandManagerInstances); }
|
ApplicationCommandManager implements SessionCommandManager<AbstractCanvasHandler> { @Override public void complete() { getDelegate().complete(); } @Inject ApplicationCommandManager(final SessionManager sessionManager,
final MouseRequestLifecycle lifecycle,
final @Any ManagedInstance<RegistryAwareCommandManager> commandManagerInstances); @PostConstruct void init(); @Override void start(); @Override void rollback(); @Override void complete(); CommandResult<CanvasViolation> allow(final Command<AbstractCanvasHandler, CanvasViolation> command); CommandResult<CanvasViolation> execute(final Command<AbstractCanvasHandler, CanvasViolation> command); CommandResult<CanvasViolation> undo(); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); @PreDestroy void destroy(); }
|
ApplicationCommandManager implements SessionCommandManager<AbstractCanvasHandler> { @Override public void complete() { getDelegate().complete(); } @Inject ApplicationCommandManager(final SessionManager sessionManager,
final MouseRequestLifecycle lifecycle,
final @Any ManagedInstance<RegistryAwareCommandManager> commandManagerInstances); @PostConstruct void init(); @Override void start(); @Override void rollback(); @Override void complete(); CommandResult<CanvasViolation> allow(final Command<AbstractCanvasHandler, CanvasViolation> command); CommandResult<CanvasViolation> execute(final Command<AbstractCanvasHandler, CanvasViolation> command); CommandResult<CanvasViolation> undo(); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); @PreDestroy void destroy(); }
|
@Test public void testRollback() { tested.start(); tested.rollback(); verify(commandManager, times(1)).start(); verify(commandManager, times(1)).rollback(); verify(commandManager, never()).complete(); }
|
@Override public void rollback() { getDelegate().rollback(); }
|
ApplicationCommandManager implements SessionCommandManager<AbstractCanvasHandler> { @Override public void rollback() { getDelegate().rollback(); } }
|
ApplicationCommandManager implements SessionCommandManager<AbstractCanvasHandler> { @Override public void rollback() { getDelegate().rollback(); } @Inject ApplicationCommandManager(final SessionManager sessionManager,
final MouseRequestLifecycle lifecycle,
final @Any ManagedInstance<RegistryAwareCommandManager> commandManagerInstances); }
|
ApplicationCommandManager implements SessionCommandManager<AbstractCanvasHandler> { @Override public void rollback() { getDelegate().rollback(); } @Inject ApplicationCommandManager(final SessionManager sessionManager,
final MouseRequestLifecycle lifecycle,
final @Any ManagedInstance<RegistryAwareCommandManager> commandManagerInstances); @PostConstruct void init(); @Override void start(); @Override void rollback(); @Override void complete(); CommandResult<CanvasViolation> allow(final Command<AbstractCanvasHandler, CanvasViolation> command); CommandResult<CanvasViolation> execute(final Command<AbstractCanvasHandler, CanvasViolation> command); CommandResult<CanvasViolation> undo(); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); @PreDestroy void destroy(); }
|
ApplicationCommandManager implements SessionCommandManager<AbstractCanvasHandler> { @Override public void rollback() { getDelegate().rollback(); } @Inject ApplicationCommandManager(final SessionManager sessionManager,
final MouseRequestLifecycle lifecycle,
final @Any ManagedInstance<RegistryAwareCommandManager> commandManagerInstances); @PostConstruct void init(); @Override void start(); @Override void rollback(); @Override void complete(); CommandResult<CanvasViolation> allow(final Command<AbstractCanvasHandler, CanvasViolation> command); CommandResult<CanvasViolation> execute(final Command<AbstractCanvasHandler, CanvasViolation> command); CommandResult<CanvasViolation> undo(); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); @PreDestroy void destroy(); }
|
@Test @SuppressWarnings("unchecked") public void testAllow() { Command<AbstractCanvasHandler, CanvasViolation> command = mock(Command.class); tested.allow(command); verify(commandManager, times(1)).allow(eq(command)); verify(commandManager, never()).execute(any()); verify(commandManager, never()).undo(); verify(commandManager, never()).undo(any(), any()); }
|
public CommandResult<CanvasViolation> allow(final Command<AbstractCanvasHandler, CanvasViolation> command) { return runExceptionSafeOperation(() -> getDelegate().allow(command)); }
|
ApplicationCommandManager implements SessionCommandManager<AbstractCanvasHandler> { public CommandResult<CanvasViolation> allow(final Command<AbstractCanvasHandler, CanvasViolation> command) { return runExceptionSafeOperation(() -> getDelegate().allow(command)); } }
|
ApplicationCommandManager implements SessionCommandManager<AbstractCanvasHandler> { public CommandResult<CanvasViolation> allow(final Command<AbstractCanvasHandler, CanvasViolation> command) { return runExceptionSafeOperation(() -> getDelegate().allow(command)); } @Inject ApplicationCommandManager(final SessionManager sessionManager,
final MouseRequestLifecycle lifecycle,
final @Any ManagedInstance<RegistryAwareCommandManager> commandManagerInstances); }
|
ApplicationCommandManager implements SessionCommandManager<AbstractCanvasHandler> { public CommandResult<CanvasViolation> allow(final Command<AbstractCanvasHandler, CanvasViolation> command) { return runExceptionSafeOperation(() -> getDelegate().allow(command)); } @Inject ApplicationCommandManager(final SessionManager sessionManager,
final MouseRequestLifecycle lifecycle,
final @Any ManagedInstance<RegistryAwareCommandManager> commandManagerInstances); @PostConstruct void init(); @Override void start(); @Override void rollback(); @Override void complete(); CommandResult<CanvasViolation> allow(final Command<AbstractCanvasHandler, CanvasViolation> command); CommandResult<CanvasViolation> execute(final Command<AbstractCanvasHandler, CanvasViolation> command); CommandResult<CanvasViolation> undo(); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); @PreDestroy void destroy(); }
|
ApplicationCommandManager implements SessionCommandManager<AbstractCanvasHandler> { public CommandResult<CanvasViolation> allow(final Command<AbstractCanvasHandler, CanvasViolation> command) { return runExceptionSafeOperation(() -> getDelegate().allow(command)); } @Inject ApplicationCommandManager(final SessionManager sessionManager,
final MouseRequestLifecycle lifecycle,
final @Any ManagedInstance<RegistryAwareCommandManager> commandManagerInstances); @PostConstruct void init(); @Override void start(); @Override void rollback(); @Override void complete(); CommandResult<CanvasViolation> allow(final Command<AbstractCanvasHandler, CanvasViolation> command); CommandResult<CanvasViolation> execute(final Command<AbstractCanvasHandler, CanvasViolation> command); CommandResult<CanvasViolation> undo(); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); @PreDestroy void destroy(); }
|
@Test @SuppressWarnings("unchecked") public void testExecute() { Command<AbstractCanvasHandler, CanvasViolation> command = mock(Command.class); tested.execute(command); verify(commandManager, times(1)).execute(eq(command)); verify(commandManager, never()).allow(any()); verify(commandManager, never()).undo(); verify(commandManager, never()).undo(any(), any()); }
|
public CommandResult<CanvasViolation> execute(final Command<AbstractCanvasHandler, CanvasViolation> command) { return runSafeOperation(() -> getDelegate().execute(command)); }
|
ApplicationCommandManager implements SessionCommandManager<AbstractCanvasHandler> { public CommandResult<CanvasViolation> execute(final Command<AbstractCanvasHandler, CanvasViolation> command) { return runSafeOperation(() -> getDelegate().execute(command)); } }
|
ApplicationCommandManager implements SessionCommandManager<AbstractCanvasHandler> { public CommandResult<CanvasViolation> execute(final Command<AbstractCanvasHandler, CanvasViolation> command) { return runSafeOperation(() -> getDelegate().execute(command)); } @Inject ApplicationCommandManager(final SessionManager sessionManager,
final MouseRequestLifecycle lifecycle,
final @Any ManagedInstance<RegistryAwareCommandManager> commandManagerInstances); }
|
ApplicationCommandManager implements SessionCommandManager<AbstractCanvasHandler> { public CommandResult<CanvasViolation> execute(final Command<AbstractCanvasHandler, CanvasViolation> command) { return runSafeOperation(() -> getDelegate().execute(command)); } @Inject ApplicationCommandManager(final SessionManager sessionManager,
final MouseRequestLifecycle lifecycle,
final @Any ManagedInstance<RegistryAwareCommandManager> commandManagerInstances); @PostConstruct void init(); @Override void start(); @Override void rollback(); @Override void complete(); CommandResult<CanvasViolation> allow(final Command<AbstractCanvasHandler, CanvasViolation> command); CommandResult<CanvasViolation> execute(final Command<AbstractCanvasHandler, CanvasViolation> command); CommandResult<CanvasViolation> undo(); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); @PreDestroy void destroy(); }
|
ApplicationCommandManager implements SessionCommandManager<AbstractCanvasHandler> { public CommandResult<CanvasViolation> execute(final Command<AbstractCanvasHandler, CanvasViolation> command) { return runSafeOperation(() -> getDelegate().execute(command)); } @Inject ApplicationCommandManager(final SessionManager sessionManager,
final MouseRequestLifecycle lifecycle,
final @Any ManagedInstance<RegistryAwareCommandManager> commandManagerInstances); @PostConstruct void init(); @Override void start(); @Override void rollback(); @Override void complete(); CommandResult<CanvasViolation> allow(final Command<AbstractCanvasHandler, CanvasViolation> command); CommandResult<CanvasViolation> execute(final Command<AbstractCanvasHandler, CanvasViolation> command); CommandResult<CanvasViolation> undo(); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); @PreDestroy void destroy(); }
|
@Test public void testUndo() { tested.undo(); verify(commandManager, times(1)).undo(); verify(commandManager, never()).execute(any()); verify(commandManager, never()).allow(any()); }
|
public CommandResult<CanvasViolation> undo() { return runSafeOperation(() -> getDelegate().undo()); }
|
ApplicationCommandManager implements SessionCommandManager<AbstractCanvasHandler> { public CommandResult<CanvasViolation> undo() { return runSafeOperation(() -> getDelegate().undo()); } }
|
ApplicationCommandManager implements SessionCommandManager<AbstractCanvasHandler> { public CommandResult<CanvasViolation> undo() { return runSafeOperation(() -> getDelegate().undo()); } @Inject ApplicationCommandManager(final SessionManager sessionManager,
final MouseRequestLifecycle lifecycle,
final @Any ManagedInstance<RegistryAwareCommandManager> commandManagerInstances); }
|
ApplicationCommandManager implements SessionCommandManager<AbstractCanvasHandler> { public CommandResult<CanvasViolation> undo() { return runSafeOperation(() -> getDelegate().undo()); } @Inject ApplicationCommandManager(final SessionManager sessionManager,
final MouseRequestLifecycle lifecycle,
final @Any ManagedInstance<RegistryAwareCommandManager> commandManagerInstances); @PostConstruct void init(); @Override void start(); @Override void rollback(); @Override void complete(); CommandResult<CanvasViolation> allow(final Command<AbstractCanvasHandler, CanvasViolation> command); CommandResult<CanvasViolation> execute(final Command<AbstractCanvasHandler, CanvasViolation> command); CommandResult<CanvasViolation> undo(); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); @PreDestroy void destroy(); }
|
ApplicationCommandManager implements SessionCommandManager<AbstractCanvasHandler> { public CommandResult<CanvasViolation> undo() { return runSafeOperation(() -> getDelegate().undo()); } @Inject ApplicationCommandManager(final SessionManager sessionManager,
final MouseRequestLifecycle lifecycle,
final @Any ManagedInstance<RegistryAwareCommandManager> commandManagerInstances); @PostConstruct void init(); @Override void start(); @Override void rollback(); @Override void complete(); CommandResult<CanvasViolation> allow(final Command<AbstractCanvasHandler, CanvasViolation> command); CommandResult<CanvasViolation> execute(final Command<AbstractCanvasHandler, CanvasViolation> command); CommandResult<CanvasViolation> undo(); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); @PreDestroy void destroy(); }
|
@Test public void testOnSessionDestroyed() { tested.start(); tested.onSessionDestroyed(new SessionDestroyedEvent(SESSION_ID, "diagram1", "graph1", mock(Metadata.class))); assertTrue(tested.getCommandManagers().isEmpty()); verify(commandManagerInstances, times(1)).destroy(eq(commandManager)); }
|
void onSessionDestroyed(@Observes SessionDestroyedEvent event) { final String sessionUUID = event.getSessionUUID(); final RegistryAwareCommandManager commandManager = getCommandManagers().get(sessionUUID); commandManagerInstances.destroy(commandManager); getCommandManagers().remove(sessionUUID); }
|
ApplicationCommandManager implements SessionCommandManager<AbstractCanvasHandler> { void onSessionDestroyed(@Observes SessionDestroyedEvent event) { final String sessionUUID = event.getSessionUUID(); final RegistryAwareCommandManager commandManager = getCommandManagers().get(sessionUUID); commandManagerInstances.destroy(commandManager); getCommandManagers().remove(sessionUUID); } }
|
ApplicationCommandManager implements SessionCommandManager<AbstractCanvasHandler> { void onSessionDestroyed(@Observes SessionDestroyedEvent event) { final String sessionUUID = event.getSessionUUID(); final RegistryAwareCommandManager commandManager = getCommandManagers().get(sessionUUID); commandManagerInstances.destroy(commandManager); getCommandManagers().remove(sessionUUID); } @Inject ApplicationCommandManager(final SessionManager sessionManager,
final MouseRequestLifecycle lifecycle,
final @Any ManagedInstance<RegistryAwareCommandManager> commandManagerInstances); }
|
ApplicationCommandManager implements SessionCommandManager<AbstractCanvasHandler> { void onSessionDestroyed(@Observes SessionDestroyedEvent event) { final String sessionUUID = event.getSessionUUID(); final RegistryAwareCommandManager commandManager = getCommandManagers().get(sessionUUID); commandManagerInstances.destroy(commandManager); getCommandManagers().remove(sessionUUID); } @Inject ApplicationCommandManager(final SessionManager sessionManager,
final MouseRequestLifecycle lifecycle,
final @Any ManagedInstance<RegistryAwareCommandManager> commandManagerInstances); @PostConstruct void init(); @Override void start(); @Override void rollback(); @Override void complete(); CommandResult<CanvasViolation> allow(final Command<AbstractCanvasHandler, CanvasViolation> command); CommandResult<CanvasViolation> execute(final Command<AbstractCanvasHandler, CanvasViolation> command); CommandResult<CanvasViolation> undo(); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); @PreDestroy void destroy(); }
|
ApplicationCommandManager implements SessionCommandManager<AbstractCanvasHandler> { void onSessionDestroyed(@Observes SessionDestroyedEvent event) { final String sessionUUID = event.getSessionUUID(); final RegistryAwareCommandManager commandManager = getCommandManagers().get(sessionUUID); commandManagerInstances.destroy(commandManager); getCommandManagers().remove(sessionUUID); } @Inject ApplicationCommandManager(final SessionManager sessionManager,
final MouseRequestLifecycle lifecycle,
final @Any ManagedInstance<RegistryAwareCommandManager> commandManagerInstances); @PostConstruct void init(); @Override void start(); @Override void rollback(); @Override void complete(); CommandResult<CanvasViolation> allow(final Command<AbstractCanvasHandler, CanvasViolation> command); CommandResult<CanvasViolation> execute(final Command<AbstractCanvasHandler, CanvasViolation> command); CommandResult<CanvasViolation> undo(); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); @PreDestroy void destroy(); }
|
@Test public void testDestroy() { tested.start(); tested.destroy(); assertTrue(tested.getCommandManagers().isEmpty()); verify(commandManagerInstances, times(1)).destroyAll(); }
|
@PreDestroy public void destroy() { getCommandManagers().clear(); commandManagerInstances.destroyAll(); }
|
ApplicationCommandManager implements SessionCommandManager<AbstractCanvasHandler> { @PreDestroy public void destroy() { getCommandManagers().clear(); commandManagerInstances.destroyAll(); } }
|
ApplicationCommandManager implements SessionCommandManager<AbstractCanvasHandler> { @PreDestroy public void destroy() { getCommandManagers().clear(); commandManagerInstances.destroyAll(); } @Inject ApplicationCommandManager(final SessionManager sessionManager,
final MouseRequestLifecycle lifecycle,
final @Any ManagedInstance<RegistryAwareCommandManager> commandManagerInstances); }
|
ApplicationCommandManager implements SessionCommandManager<AbstractCanvasHandler> { @PreDestroy public void destroy() { getCommandManagers().clear(); commandManagerInstances.destroyAll(); } @Inject ApplicationCommandManager(final SessionManager sessionManager,
final MouseRequestLifecycle lifecycle,
final @Any ManagedInstance<RegistryAwareCommandManager> commandManagerInstances); @PostConstruct void init(); @Override void start(); @Override void rollback(); @Override void complete(); CommandResult<CanvasViolation> allow(final Command<AbstractCanvasHandler, CanvasViolation> command); CommandResult<CanvasViolation> execute(final Command<AbstractCanvasHandler, CanvasViolation> command); CommandResult<CanvasViolation> undo(); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); @PreDestroy void destroy(); }
|
ApplicationCommandManager implements SessionCommandManager<AbstractCanvasHandler> { @PreDestroy public void destroy() { getCommandManagers().clear(); commandManagerInstances.destroyAll(); } @Inject ApplicationCommandManager(final SessionManager sessionManager,
final MouseRequestLifecycle lifecycle,
final @Any ManagedInstance<RegistryAwareCommandManager> commandManagerInstances); @PostConstruct void init(); @Override void start(); @Override void rollback(); @Override void complete(); CommandResult<CanvasViolation> allow(final Command<AbstractCanvasHandler, CanvasViolation> command); CommandResult<CanvasViolation> execute(final Command<AbstractCanvasHandler, CanvasViolation> command); CommandResult<CanvasViolation> undo(); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); @PreDestroy void destroy(); }
|
@Test public void testSetItemsUnknownImplementation() { view.setItems(singletonList(mock(HasListSelectorControl.ListSelectorItem.class))); verify(itemsContainer, never()).appendChild(any()); }
|
@Override public void setItems(final List<ListSelectorItem> items) { DOMUtil.removeAllChildren(itemsContainer); items.forEach(item -> makeListSelectorItemView(item).ifPresent(child -> itemsContainer.appendChild(child.getElement()))); }
|
ListSelectorViewImpl implements ListSelectorView { @Override public void setItems(final List<ListSelectorItem> items) { DOMUtil.removeAllChildren(itemsContainer); items.forEach(item -> makeListSelectorItemView(item).ifPresent(child -> itemsContainer.appendChild(child.getElement()))); } }
|
ListSelectorViewImpl implements ListSelectorView { @Override public void setItems(final List<ListSelectorItem> items) { DOMUtil.removeAllChildren(itemsContainer); items.forEach(item -> makeListSelectorItemView(item).ifPresent(child -> itemsContainer.appendChild(child.getElement()))); } ListSelectorViewImpl(); @Inject ListSelectorViewImpl(final UnorderedList itemsContainer,
final ManagedInstance<ListSelectorTextItemView> listSelectorTextItemViews,
final ManagedInstance<ListSelectorDividerItemView> listSelectorDividerItemViews,
final ManagedInstance<ListSelectorHeaderItemView> listSelectorHeaderItemViews); }
|
ListSelectorViewImpl implements ListSelectorView { @Override public void setItems(final List<ListSelectorItem> items) { DOMUtil.removeAllChildren(itemsContainer); items.forEach(item -> makeListSelectorItemView(item).ifPresent(child -> itemsContainer.appendChild(child.getElement()))); } ListSelectorViewImpl(); @Inject ListSelectorViewImpl(final UnorderedList itemsContainer,
final ManagedInstance<ListSelectorTextItemView> listSelectorTextItemViews,
final ManagedInstance<ListSelectorDividerItemView> listSelectorDividerItemViews,
final ManagedInstance<ListSelectorHeaderItemView> listSelectorHeaderItemViews); @Override void init(final Presenter presenter); @Override void setItems(final List<ListSelectorItem> items); @Override void show(final Optional<String> title); @Override void hide(); @Override void setOnClosedByKeyboardCallback(final Consumer<CanBeClosedByKeyboard> callback); }
|
ListSelectorViewImpl implements ListSelectorView { @Override public void setItems(final List<ListSelectorItem> items) { DOMUtil.removeAllChildren(itemsContainer); items.forEach(item -> makeListSelectorItemView(item).ifPresent(child -> itemsContainer.appendChild(child.getElement()))); } ListSelectorViewImpl(); @Inject ListSelectorViewImpl(final UnorderedList itemsContainer,
final ManagedInstance<ListSelectorTextItemView> listSelectorTextItemViews,
final ManagedInstance<ListSelectorDividerItemView> listSelectorDividerItemViews,
final ManagedInstance<ListSelectorHeaderItemView> listSelectorHeaderItemViews); @Override void init(final Presenter presenter); @Override void setItems(final List<ListSelectorItem> items); @Override void show(final Optional<String> title); @Override void hide(); @Override void setOnClosedByKeyboardCallback(final Consumer<CanBeClosedByKeyboard> callback); }
|
@Test @SuppressWarnings("unchecked") public void testExecute() { Object obj = mock(Object.class); CommandManager manager = mock(CommandManager.class); CommandResult expectedResult = mock(CommandResult.class); when(commandRegistry.isEmpty()).thenReturn(false); when(commandRegistry.peek()).thenReturn(command1); when(manager.execute(anyObject(), eq(command1))).thenReturn(expectedResult); CommandResult actualResult = tested.execute(obj, manager); assertEquals(expectedResult, actualResult); verify(manager).execute(eq(obj), eq(command1)); }
|
@SuppressWarnings("unchecked") public CommandResult<?> execute(final Object context, final CommandManager commandManager) { if (registry.isEmpty()) { return GraphCommandResultBuilder.SUCCESS; } final C last = registry.peek(); return commandManager.execute(context, last); }
|
RedoCommandHandler { @SuppressWarnings("unchecked") public CommandResult<?> execute(final Object context, final CommandManager commandManager) { if (registry.isEmpty()) { return GraphCommandResultBuilder.SUCCESS; } final C last = registry.peek(); return commandManager.execute(context, last); } }
|
RedoCommandHandler { @SuppressWarnings("unchecked") public CommandResult<?> execute(final Object context, final CommandManager commandManager) { if (registry.isEmpty()) { return GraphCommandResultBuilder.SUCCESS; } final C last = registry.peek(); return commandManager.execute(context, last); } protected RedoCommandHandler(); @Inject RedoCommandHandler(final DefaultRegistry<C> registry, final Event<RegisterChangedEvent> registerChangedEvent); }
|
RedoCommandHandler { @SuppressWarnings("unchecked") public CommandResult<?> execute(final Object context, final CommandManager commandManager) { if (registry.isEmpty()) { return GraphCommandResultBuilder.SUCCESS; } final C last = registry.peek(); return commandManager.execute(context, last); } protected RedoCommandHandler(); @Inject RedoCommandHandler(final DefaultRegistry<C> registry, final Event<RegisterChangedEvent> registerChangedEvent); boolean onUndoCommandExecuted(final C command); boolean onCommandExecuted(final C command); @SuppressWarnings("unchecked") CommandResult<?> execute(final Object context,
final CommandManager commandManager); void setSession(final ClientSession clientSession); boolean isEnabled(); void clear(); }
|
RedoCommandHandler { @SuppressWarnings("unchecked") public CommandResult<?> execute(final Object context, final CommandManager commandManager) { if (registry.isEmpty()) { return GraphCommandResultBuilder.SUCCESS; } final C last = registry.peek(); return commandManager.execute(context, last); } protected RedoCommandHandler(); @Inject RedoCommandHandler(final DefaultRegistry<C> registry, final Event<RegisterChangedEvent> registerChangedEvent); boolean onUndoCommandExecuted(final C command); boolean onCommandExecuted(final C command); @SuppressWarnings("unchecked") CommandResult<?> execute(final Object context,
final CommandManager commandManager); void setSession(final ClientSession clientSession); boolean isEnabled(); void clear(); }
|
@Test @SuppressWarnings("unchecked") public void testExecuteOnNull() { Object obj = mock(Object.class); CommandManager manager = mock(CommandManager.class); when(commandRegistry.isEmpty()).thenReturn(true); RedoCommandHandler tested = new RedoCommandHandler(commandRegistry, registerChangedEvent); assertEquals(GraphCommandResultBuilder.SUCCESS, tested.execute(obj, manager)); verify(manager, never()).execute(anyObject(), any(Command.class)); }
|
@SuppressWarnings("unchecked") public CommandResult<?> execute(final Object context, final CommandManager commandManager) { if (registry.isEmpty()) { return GraphCommandResultBuilder.SUCCESS; } final C last = registry.peek(); return commandManager.execute(context, last); }
|
RedoCommandHandler { @SuppressWarnings("unchecked") public CommandResult<?> execute(final Object context, final CommandManager commandManager) { if (registry.isEmpty()) { return GraphCommandResultBuilder.SUCCESS; } final C last = registry.peek(); return commandManager.execute(context, last); } }
|
RedoCommandHandler { @SuppressWarnings("unchecked") public CommandResult<?> execute(final Object context, final CommandManager commandManager) { if (registry.isEmpty()) { return GraphCommandResultBuilder.SUCCESS; } final C last = registry.peek(); return commandManager.execute(context, last); } protected RedoCommandHandler(); @Inject RedoCommandHandler(final DefaultRegistry<C> registry, final Event<RegisterChangedEvent> registerChangedEvent); }
|
RedoCommandHandler { @SuppressWarnings("unchecked") public CommandResult<?> execute(final Object context, final CommandManager commandManager) { if (registry.isEmpty()) { return GraphCommandResultBuilder.SUCCESS; } final C last = registry.peek(); return commandManager.execute(context, last); } protected RedoCommandHandler(); @Inject RedoCommandHandler(final DefaultRegistry<C> registry, final Event<RegisterChangedEvent> registerChangedEvent); boolean onUndoCommandExecuted(final C command); boolean onCommandExecuted(final C command); @SuppressWarnings("unchecked") CommandResult<?> execute(final Object context,
final CommandManager commandManager); void setSession(final ClientSession clientSession); boolean isEnabled(); void clear(); }
|
RedoCommandHandler { @SuppressWarnings("unchecked") public CommandResult<?> execute(final Object context, final CommandManager commandManager) { if (registry.isEmpty()) { return GraphCommandResultBuilder.SUCCESS; } final C last = registry.peek(); return commandManager.execute(context, last); } protected RedoCommandHandler(); @Inject RedoCommandHandler(final DefaultRegistry<C> registry, final Event<RegisterChangedEvent> registerChangedEvent); boolean onUndoCommandExecuted(final C command); boolean onCommandExecuted(final C command); @SuppressWarnings("unchecked") CommandResult<?> execute(final Object context,
final CommandManager commandManager); void setSession(final ClientSession clientSession); boolean isEnabled(); void clear(); }
|
@Test public void testSetSession() { ClientSession session = mock(ClientSession.class); tested.setSession(session); verify(commandRegistry, times(1)).setRegistryChangeListener(any()); }
|
public void setSession(final ClientSession clientSession) { this.registry.setRegistryChangeListener(() -> registerChangedEvent.fire(new RegisterChangedEvent(clientSession.getCanvasHandler()))); }
|
RedoCommandHandler { public void setSession(final ClientSession clientSession) { this.registry.setRegistryChangeListener(() -> registerChangedEvent.fire(new RegisterChangedEvent(clientSession.getCanvasHandler()))); } }
|
RedoCommandHandler { public void setSession(final ClientSession clientSession) { this.registry.setRegistryChangeListener(() -> registerChangedEvent.fire(new RegisterChangedEvent(clientSession.getCanvasHandler()))); } protected RedoCommandHandler(); @Inject RedoCommandHandler(final DefaultRegistry<C> registry, final Event<RegisterChangedEvent> registerChangedEvent); }
|
RedoCommandHandler { public void setSession(final ClientSession clientSession) { this.registry.setRegistryChangeListener(() -> registerChangedEvent.fire(new RegisterChangedEvent(clientSession.getCanvasHandler()))); } protected RedoCommandHandler(); @Inject RedoCommandHandler(final DefaultRegistry<C> registry, final Event<RegisterChangedEvent> registerChangedEvent); boolean onUndoCommandExecuted(final C command); boolean onCommandExecuted(final C command); @SuppressWarnings("unchecked") CommandResult<?> execute(final Object context,
final CommandManager commandManager); void setSession(final ClientSession clientSession); boolean isEnabled(); void clear(); }
|
RedoCommandHandler { public void setSession(final ClientSession clientSession) { this.registry.setRegistryChangeListener(() -> registerChangedEvent.fire(new RegisterChangedEvent(clientSession.getCanvasHandler()))); } protected RedoCommandHandler(); @Inject RedoCommandHandler(final DefaultRegistry<C> registry, final Event<RegisterChangedEvent> registerChangedEvent); boolean onUndoCommandExecuted(final C command); boolean onCommandExecuted(final C command); @SuppressWarnings("unchecked") CommandResult<?> execute(final Object context,
final CommandManager commandManager); void setSession(final ClientSession clientSession); boolean isEnabled(); void clear(); }
|
@Test public void testAllow() { tested.allow(COMMAND_SUCCESS1); verify(commandManager, times(1)).allow(eq(canvasHandler), eq(COMMAND_SUCCESS1)); verify(commandManager, never()).execute(any(), any()); verify(commandManager, never()).undo(any(), any()); verify(commandRegistry, never()).register(any()); verify(commandRegistry, never()).pop(); verify(commandRegistry, never()).peek(); verify(commandRegistry, never()).clear(); }
|
public CommandResult<CanvasViolation> allow(final Command<AbstractCanvasHandler, CanvasViolation> command) { return allow(getCanvasHandler(), command); }
|
RegistryAwareCommandManager implements SessionCommandManager<AbstractCanvasHandler> { public CommandResult<CanvasViolation> allow(final Command<AbstractCanvasHandler, CanvasViolation> command) { return allow(getCanvasHandler(), command); } }
|
RegistryAwareCommandManager implements SessionCommandManager<AbstractCanvasHandler> { public CommandResult<CanvasViolation> allow(final Command<AbstractCanvasHandler, CanvasViolation> command) { return allow(getCanvasHandler(), command); } RegistryAwareCommandManager(); }
|
RegistryAwareCommandManager implements SessionCommandManager<AbstractCanvasHandler> { public CommandResult<CanvasViolation> allow(final Command<AbstractCanvasHandler, CanvasViolation> command) { return allow(getCanvasHandler(), command); } RegistryAwareCommandManager(); @SuppressWarnings("unchecked") RegistryAwareCommandManager init(final ClientSession session); CommandResult<CanvasViolation> allow(final Command<AbstractCanvasHandler, CanvasViolation> command); CommandResult<CanvasViolation> execute(final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); CommandResult<CanvasViolation> undo(); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override void start(); @Override void rollback(); @Override void complete(); @PreDestroy void destroy(); }
|
RegistryAwareCommandManager implements SessionCommandManager<AbstractCanvasHandler> { public CommandResult<CanvasViolation> allow(final Command<AbstractCanvasHandler, CanvasViolation> command) { return allow(getCanvasHandler(), command); } RegistryAwareCommandManager(); @SuppressWarnings("unchecked") RegistryAwareCommandManager init(final ClientSession session); CommandResult<CanvasViolation> allow(final Command<AbstractCanvasHandler, CanvasViolation> command); CommandResult<CanvasViolation> execute(final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); CommandResult<CanvasViolation> undo(); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override void start(); @Override void rollback(); @Override void complete(); @PreDestroy void destroy(); }
|
@Test public void testExecute() { tested.execute(COMMAND_SUCCESS1); verify(commandManager, times(1)).execute(eq(canvasHandler), eq(COMMAND_SUCCESS1)); verify(commandManager, never()).allow(any(), any()); verify(commandManager, never()).undo(any(), any()); verify(commandRegistry, times(1)).register(any()); assertEquals(1, commandRegistry.getHistory().size()); assertEquals(COMMAND_SUCCESS1, commandRegistry.getHistory().get(0)); verify(commandRegistry, never()).pop(); verify(commandRegistry, never()).peek(); verify(commandRegistry, never()).clear(); }
|
public CommandResult<CanvasViolation> execute(final Command<AbstractCanvasHandler, CanvasViolation> command) { return execute(getCanvasHandler(), command); }
|
RegistryAwareCommandManager implements SessionCommandManager<AbstractCanvasHandler> { public CommandResult<CanvasViolation> execute(final Command<AbstractCanvasHandler, CanvasViolation> command) { return execute(getCanvasHandler(), command); } }
|
RegistryAwareCommandManager implements SessionCommandManager<AbstractCanvasHandler> { public CommandResult<CanvasViolation> execute(final Command<AbstractCanvasHandler, CanvasViolation> command) { return execute(getCanvasHandler(), command); } RegistryAwareCommandManager(); }
|
RegistryAwareCommandManager implements SessionCommandManager<AbstractCanvasHandler> { public CommandResult<CanvasViolation> execute(final Command<AbstractCanvasHandler, CanvasViolation> command) { return execute(getCanvasHandler(), command); } RegistryAwareCommandManager(); @SuppressWarnings("unchecked") RegistryAwareCommandManager init(final ClientSession session); CommandResult<CanvasViolation> allow(final Command<AbstractCanvasHandler, CanvasViolation> command); CommandResult<CanvasViolation> execute(final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); CommandResult<CanvasViolation> undo(); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override void start(); @Override void rollback(); @Override void complete(); @PreDestroy void destroy(); }
|
RegistryAwareCommandManager implements SessionCommandManager<AbstractCanvasHandler> { public CommandResult<CanvasViolation> execute(final Command<AbstractCanvasHandler, CanvasViolation> command) { return execute(getCanvasHandler(), command); } RegistryAwareCommandManager(); @SuppressWarnings("unchecked") RegistryAwareCommandManager init(final ClientSession session); CommandResult<CanvasViolation> allow(final Command<AbstractCanvasHandler, CanvasViolation> command); CommandResult<CanvasViolation> execute(final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); CommandResult<CanvasViolation> undo(); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override void start(); @Override void rollback(); @Override void complete(); @PreDestroy void destroy(); }
|
@Test public void testUndo() { commandRegistry.register(COMMAND_SUCCESS1); tested.undo(); verify(commandManager, times(1)).undo(eq(canvasHandler), eq(COMMAND_SUCCESS1)); verify(commandManager, never()).execute(any(), any()); verify(commandManager, never()).allow(any(), any()); verify(commandRegistry, times(1)).pop(); }
|
@Override public CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context) { final Command<AbstractCanvasHandler, CanvasViolation> lastEntry = getCommandRegistry() .map(Registry::pop) .orElse(null); if (null != lastEntry) { return undo(context, lastEntry); } return CanvasCommandResultBuilder.failed(); }
|
RegistryAwareCommandManager implements SessionCommandManager<AbstractCanvasHandler> { @Override public CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context) { final Command<AbstractCanvasHandler, CanvasViolation> lastEntry = getCommandRegistry() .map(Registry::pop) .orElse(null); if (null != lastEntry) { return undo(context, lastEntry); } return CanvasCommandResultBuilder.failed(); } }
|
RegistryAwareCommandManager implements SessionCommandManager<AbstractCanvasHandler> { @Override public CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context) { final Command<AbstractCanvasHandler, CanvasViolation> lastEntry = getCommandRegistry() .map(Registry::pop) .orElse(null); if (null != lastEntry) { return undo(context, lastEntry); } return CanvasCommandResultBuilder.failed(); } RegistryAwareCommandManager(); }
|
RegistryAwareCommandManager implements SessionCommandManager<AbstractCanvasHandler> { @Override public CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context) { final Command<AbstractCanvasHandler, CanvasViolation> lastEntry = getCommandRegistry() .map(Registry::pop) .orElse(null); if (null != lastEntry) { return undo(context, lastEntry); } return CanvasCommandResultBuilder.failed(); } RegistryAwareCommandManager(); @SuppressWarnings("unchecked") RegistryAwareCommandManager init(final ClientSession session); CommandResult<CanvasViolation> allow(final Command<AbstractCanvasHandler, CanvasViolation> command); CommandResult<CanvasViolation> execute(final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); CommandResult<CanvasViolation> undo(); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override void start(); @Override void rollback(); @Override void complete(); @PreDestroy void destroy(); }
|
RegistryAwareCommandManager implements SessionCommandManager<AbstractCanvasHandler> { @Override public CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context) { final Command<AbstractCanvasHandler, CanvasViolation> lastEntry = getCommandRegistry() .map(Registry::pop) .orElse(null); if (null != lastEntry) { return undo(context, lastEntry); } return CanvasCommandResultBuilder.failed(); } RegistryAwareCommandManager(); @SuppressWarnings("unchecked") RegistryAwareCommandManager init(final ClientSession session); CommandResult<CanvasViolation> allow(final Command<AbstractCanvasHandler, CanvasViolation> command); CommandResult<CanvasViolation> execute(final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context); CommandResult<CanvasViolation> undo(); @Override CommandResult<CanvasViolation> allow(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> execute(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override CommandResult<CanvasViolation> undo(final AbstractCanvasHandler context,
final Command<AbstractCanvasHandler, CanvasViolation> command); @Override void start(); @Override void rollback(); @Override void complete(); @PreDestroy void destroy(); }
|
@Test @SuppressWarnings("unchecked") public void testEvaluate() { StatefulGraphEvaluationState.StatefulContainmentState containmentState = new StatefulGraphEvaluationState.StatefulContainmentState(); when(state.getContainmentState()).thenReturn(containmentState); Element parent = new NodeImpl<>("parent"); Node child = new NodeImpl<>("child"); final NodeContainmentContext[] containmentContext = new NodeContainmentContext[1]; tested.evaluate(builder -> containmentContext[0] = builder.containment(parent, child)); verify(ruleManager, times(1)).evaluate(eq(ruleSet), eq(containmentContext[0])); assertEquals(parent, containmentState.getParent(child)); }
|
@Override public RuleViolations evaluate(final GraphEvaluationContext context) { ((AbstractGraphEvaluationContext) context).setState(this::getState); return StatefulGraphEvaluationContexts.evaluate(context, c -> ruleManager.evaluate(ruleSet, c)); }
|
QueueGraphExecutionContext extends AbstractGraphCommandExecutionContext { @Override public RuleViolations evaluate(final GraphEvaluationContext context) { ((AbstractGraphEvaluationContext) context).setState(this::getState); return StatefulGraphEvaluationContexts.evaluate(context, c -> ruleManager.evaluate(ruleSet, c)); } }
|
QueueGraphExecutionContext extends AbstractGraphCommandExecutionContext { @Override public RuleViolations evaluate(final GraphEvaluationContext context) { ((AbstractGraphEvaluationContext) context).setState(this::getState); return StatefulGraphEvaluationContexts.evaluate(context, c -> ruleManager.evaluate(ruleSet, c)); } QueueGraphExecutionContext(final DefinitionManager definitionManager,
final FactoryManager factoryManager,
final RuleManager ruleManager,
final Index<?, ?> graphIndex,
final RuleSet ruleSet); QueueGraphExecutionContext(final DefinitionManager definitionManager,
final FactoryManager factoryManager,
final RuleManager ruleManager,
final RuleEvaluationContextBuilder.StatefulGraphContextBuilder contextBuilder,
final Index<?, ?> graphIndex,
final RuleSet ruleSet); }
|
QueueGraphExecutionContext extends AbstractGraphCommandExecutionContext { @Override public RuleViolations evaluate(final GraphEvaluationContext context) { ((AbstractGraphEvaluationContext) context).setState(this::getState); return StatefulGraphEvaluationContexts.evaluate(context, c -> ruleManager.evaluate(ruleSet, c)); } QueueGraphExecutionContext(final DefinitionManager definitionManager,
final FactoryManager factoryManager,
final RuleManager ruleManager,
final Index<?, ?> graphIndex,
final RuleSet ruleSet); QueueGraphExecutionContext(final DefinitionManager definitionManager,
final FactoryManager factoryManager,
final RuleManager ruleManager,
final RuleEvaluationContextBuilder.StatefulGraphContextBuilder contextBuilder,
final Index<?, ?> graphIndex,
final RuleSet ruleSet); void clear(); @Override RuleViolations evaluate(final GraphEvaluationContext context); @Override RuleSet getRuleSet(); void addElement(final Element candidate); List<Element> getUpdatedElements(); void resetUpdatedElements(); }
|
QueueGraphExecutionContext extends AbstractGraphCommandExecutionContext { @Override public RuleViolations evaluate(final GraphEvaluationContext context) { ((AbstractGraphEvaluationContext) context).setState(this::getState); return StatefulGraphEvaluationContexts.evaluate(context, c -> ruleManager.evaluate(ruleSet, c)); } QueueGraphExecutionContext(final DefinitionManager definitionManager,
final FactoryManager factoryManager,
final RuleManager ruleManager,
final Index<?, ?> graphIndex,
final RuleSet ruleSet); QueueGraphExecutionContext(final DefinitionManager definitionManager,
final FactoryManager factoryManager,
final RuleManager ruleManager,
final RuleEvaluationContextBuilder.StatefulGraphContextBuilder contextBuilder,
final Index<?, ?> graphIndex,
final RuleSet ruleSet); void clear(); @Override RuleViolations evaluate(final GraphEvaluationContext context); @Override RuleSet getRuleSet(); void addElement(final Element candidate); List<Element> getUpdatedElements(); void resetUpdatedElements(); }
|
@Test public void testClear() { tested.clear(); verify(state, times(1)).clear(); }
|
public void clear() { getState().clear(); }
|
QueueGraphExecutionContext extends AbstractGraphCommandExecutionContext { public void clear() { getState().clear(); } }
|
QueueGraphExecutionContext extends AbstractGraphCommandExecutionContext { public void clear() { getState().clear(); } QueueGraphExecutionContext(final DefinitionManager definitionManager,
final FactoryManager factoryManager,
final RuleManager ruleManager,
final Index<?, ?> graphIndex,
final RuleSet ruleSet); QueueGraphExecutionContext(final DefinitionManager definitionManager,
final FactoryManager factoryManager,
final RuleManager ruleManager,
final RuleEvaluationContextBuilder.StatefulGraphContextBuilder contextBuilder,
final Index<?, ?> graphIndex,
final RuleSet ruleSet); }
|
QueueGraphExecutionContext extends AbstractGraphCommandExecutionContext { public void clear() { getState().clear(); } QueueGraphExecutionContext(final DefinitionManager definitionManager,
final FactoryManager factoryManager,
final RuleManager ruleManager,
final Index<?, ?> graphIndex,
final RuleSet ruleSet); QueueGraphExecutionContext(final DefinitionManager definitionManager,
final FactoryManager factoryManager,
final RuleManager ruleManager,
final RuleEvaluationContextBuilder.StatefulGraphContextBuilder contextBuilder,
final Index<?, ?> graphIndex,
final RuleSet ruleSet); void clear(); @Override RuleViolations evaluate(final GraphEvaluationContext context); @Override RuleSet getRuleSet(); void addElement(final Element candidate); List<Element> getUpdatedElements(); void resetUpdatedElements(); }
|
QueueGraphExecutionContext extends AbstractGraphCommandExecutionContext { public void clear() { getState().clear(); } QueueGraphExecutionContext(final DefinitionManager definitionManager,
final FactoryManager factoryManager,
final RuleManager ruleManager,
final Index<?, ?> graphIndex,
final RuleSet ruleSet); QueueGraphExecutionContext(final DefinitionManager definitionManager,
final FactoryManager factoryManager,
final RuleManager ruleManager,
final RuleEvaluationContextBuilder.StatefulGraphContextBuilder contextBuilder,
final Index<?, ?> graphIndex,
final RuleSet ruleSet); void clear(); @Override RuleViolations evaluate(final GraphEvaluationContext context); @Override RuleSet getRuleSet(); void addElement(final Element candidate); List<Element> getUpdatedElements(); void resetUpdatedElements(); }
|
@Test public void testAddElement() { Element node1 = new NodeImpl<>("parent"); tested.addElement(node1); assertEquals("Should be One Element in Updated Elements", 1, tested.getUpdatedElements().size()); }
|
public void addElement(final Element candidate) { updatedElements.add(candidate); }
|
QueueGraphExecutionContext extends AbstractGraphCommandExecutionContext { public void addElement(final Element candidate) { updatedElements.add(candidate); } }
|
QueueGraphExecutionContext extends AbstractGraphCommandExecutionContext { public void addElement(final Element candidate) { updatedElements.add(candidate); } QueueGraphExecutionContext(final DefinitionManager definitionManager,
final FactoryManager factoryManager,
final RuleManager ruleManager,
final Index<?, ?> graphIndex,
final RuleSet ruleSet); QueueGraphExecutionContext(final DefinitionManager definitionManager,
final FactoryManager factoryManager,
final RuleManager ruleManager,
final RuleEvaluationContextBuilder.StatefulGraphContextBuilder contextBuilder,
final Index<?, ?> graphIndex,
final RuleSet ruleSet); }
|
QueueGraphExecutionContext extends AbstractGraphCommandExecutionContext { public void addElement(final Element candidate) { updatedElements.add(candidate); } QueueGraphExecutionContext(final DefinitionManager definitionManager,
final FactoryManager factoryManager,
final RuleManager ruleManager,
final Index<?, ?> graphIndex,
final RuleSet ruleSet); QueueGraphExecutionContext(final DefinitionManager definitionManager,
final FactoryManager factoryManager,
final RuleManager ruleManager,
final RuleEvaluationContextBuilder.StatefulGraphContextBuilder contextBuilder,
final Index<?, ?> graphIndex,
final RuleSet ruleSet); void clear(); @Override RuleViolations evaluate(final GraphEvaluationContext context); @Override RuleSet getRuleSet(); void addElement(final Element candidate); List<Element> getUpdatedElements(); void resetUpdatedElements(); }
|
QueueGraphExecutionContext extends AbstractGraphCommandExecutionContext { public void addElement(final Element candidate) { updatedElements.add(candidate); } QueueGraphExecutionContext(final DefinitionManager definitionManager,
final FactoryManager factoryManager,
final RuleManager ruleManager,
final Index<?, ?> graphIndex,
final RuleSet ruleSet); QueueGraphExecutionContext(final DefinitionManager definitionManager,
final FactoryManager factoryManager,
final RuleManager ruleManager,
final RuleEvaluationContextBuilder.StatefulGraphContextBuilder contextBuilder,
final Index<?, ?> graphIndex,
final RuleSet ruleSet); void clear(); @Override RuleViolations evaluate(final GraphEvaluationContext context); @Override RuleSet getRuleSet(); void addElement(final Element candidate); List<Element> getUpdatedElements(); void resetUpdatedElements(); }
|
@Test public void testGetUpdatedElements() { Element node1 = new NodeImpl<>("parent"); tested.addElement(node1); assertEquals("node 1 should be returned from Updated Elements", node1, tested.getUpdatedElements().get(0)); }
|
public List<Element> getUpdatedElements() { return updatedElements; }
|
QueueGraphExecutionContext extends AbstractGraphCommandExecutionContext { public List<Element> getUpdatedElements() { return updatedElements; } }
|
QueueGraphExecutionContext extends AbstractGraphCommandExecutionContext { public List<Element> getUpdatedElements() { return updatedElements; } QueueGraphExecutionContext(final DefinitionManager definitionManager,
final FactoryManager factoryManager,
final RuleManager ruleManager,
final Index<?, ?> graphIndex,
final RuleSet ruleSet); QueueGraphExecutionContext(final DefinitionManager definitionManager,
final FactoryManager factoryManager,
final RuleManager ruleManager,
final RuleEvaluationContextBuilder.StatefulGraphContextBuilder contextBuilder,
final Index<?, ?> graphIndex,
final RuleSet ruleSet); }
|
QueueGraphExecutionContext extends AbstractGraphCommandExecutionContext { public List<Element> getUpdatedElements() { return updatedElements; } QueueGraphExecutionContext(final DefinitionManager definitionManager,
final FactoryManager factoryManager,
final RuleManager ruleManager,
final Index<?, ?> graphIndex,
final RuleSet ruleSet); QueueGraphExecutionContext(final DefinitionManager definitionManager,
final FactoryManager factoryManager,
final RuleManager ruleManager,
final RuleEvaluationContextBuilder.StatefulGraphContextBuilder contextBuilder,
final Index<?, ?> graphIndex,
final RuleSet ruleSet); void clear(); @Override RuleViolations evaluate(final GraphEvaluationContext context); @Override RuleSet getRuleSet(); void addElement(final Element candidate); List<Element> getUpdatedElements(); void resetUpdatedElements(); }
|
QueueGraphExecutionContext extends AbstractGraphCommandExecutionContext { public List<Element> getUpdatedElements() { return updatedElements; } QueueGraphExecutionContext(final DefinitionManager definitionManager,
final FactoryManager factoryManager,
final RuleManager ruleManager,
final Index<?, ?> graphIndex,
final RuleSet ruleSet); QueueGraphExecutionContext(final DefinitionManager definitionManager,
final FactoryManager factoryManager,
final RuleManager ruleManager,
final RuleEvaluationContextBuilder.StatefulGraphContextBuilder contextBuilder,
final Index<?, ?> graphIndex,
final RuleSet ruleSet); void clear(); @Override RuleViolations evaluate(final GraphEvaluationContext context); @Override RuleSet getRuleSet(); void addElement(final Element candidate); List<Element> getUpdatedElements(); void resetUpdatedElements(); }
|
@Test public void testShow() { view.show(Optional.empty()); verify(viewElementCSSClasses).add(OPEN); verify(viewElement).focus(); }
|
@Override public void show(final Optional<String> title) { getElement().getClassList().add(OPEN); schedule(() -> getElement().focus()); }
|
ListSelectorViewImpl implements ListSelectorView { @Override public void show(final Optional<String> title) { getElement().getClassList().add(OPEN); schedule(() -> getElement().focus()); } }
|
ListSelectorViewImpl implements ListSelectorView { @Override public void show(final Optional<String> title) { getElement().getClassList().add(OPEN); schedule(() -> getElement().focus()); } ListSelectorViewImpl(); @Inject ListSelectorViewImpl(final UnorderedList itemsContainer,
final ManagedInstance<ListSelectorTextItemView> listSelectorTextItemViews,
final ManagedInstance<ListSelectorDividerItemView> listSelectorDividerItemViews,
final ManagedInstance<ListSelectorHeaderItemView> listSelectorHeaderItemViews); }
|
ListSelectorViewImpl implements ListSelectorView { @Override public void show(final Optional<String> title) { getElement().getClassList().add(OPEN); schedule(() -> getElement().focus()); } ListSelectorViewImpl(); @Inject ListSelectorViewImpl(final UnorderedList itemsContainer,
final ManagedInstance<ListSelectorTextItemView> listSelectorTextItemViews,
final ManagedInstance<ListSelectorDividerItemView> listSelectorDividerItemViews,
final ManagedInstance<ListSelectorHeaderItemView> listSelectorHeaderItemViews); @Override void init(final Presenter presenter); @Override void setItems(final List<ListSelectorItem> items); @Override void show(final Optional<String> title); @Override void hide(); @Override void setOnClosedByKeyboardCallback(final Consumer<CanBeClosedByKeyboard> callback); }
|
ListSelectorViewImpl implements ListSelectorView { @Override public void show(final Optional<String> title) { getElement().getClassList().add(OPEN); schedule(() -> getElement().focus()); } ListSelectorViewImpl(); @Inject ListSelectorViewImpl(final UnorderedList itemsContainer,
final ManagedInstance<ListSelectorTextItemView> listSelectorTextItemViews,
final ManagedInstance<ListSelectorDividerItemView> listSelectorDividerItemViews,
final ManagedInstance<ListSelectorHeaderItemView> listSelectorHeaderItemViews); @Override void init(final Presenter presenter); @Override void setItems(final List<ListSelectorItem> items); @Override void show(final Optional<String> title); @Override void hide(); @Override void setOnClosedByKeyboardCallback(final Consumer<CanBeClosedByKeyboard> callback); }
|
@Test public void testResetUpdatedElements() { Element parent = new NodeImpl<>("parent"); tested.addElement(parent); assertEquals("Should be One Element in Updated Elements", 1, tested.getUpdatedElements().size()); tested.resetUpdatedElements(); assertEquals("Updated Elements should be empty", 0, tested.getUpdatedElements().size()); }
|
public void resetUpdatedElements() { updatedElements.clear(); }
|
QueueGraphExecutionContext extends AbstractGraphCommandExecutionContext { public void resetUpdatedElements() { updatedElements.clear(); } }
|
QueueGraphExecutionContext extends AbstractGraphCommandExecutionContext { public void resetUpdatedElements() { updatedElements.clear(); } QueueGraphExecutionContext(final DefinitionManager definitionManager,
final FactoryManager factoryManager,
final RuleManager ruleManager,
final Index<?, ?> graphIndex,
final RuleSet ruleSet); QueueGraphExecutionContext(final DefinitionManager definitionManager,
final FactoryManager factoryManager,
final RuleManager ruleManager,
final RuleEvaluationContextBuilder.StatefulGraphContextBuilder contextBuilder,
final Index<?, ?> graphIndex,
final RuleSet ruleSet); }
|
QueueGraphExecutionContext extends AbstractGraphCommandExecutionContext { public void resetUpdatedElements() { updatedElements.clear(); } QueueGraphExecutionContext(final DefinitionManager definitionManager,
final FactoryManager factoryManager,
final RuleManager ruleManager,
final Index<?, ?> graphIndex,
final RuleSet ruleSet); QueueGraphExecutionContext(final DefinitionManager definitionManager,
final FactoryManager factoryManager,
final RuleManager ruleManager,
final RuleEvaluationContextBuilder.StatefulGraphContextBuilder contextBuilder,
final Index<?, ?> graphIndex,
final RuleSet ruleSet); void clear(); @Override RuleViolations evaluate(final GraphEvaluationContext context); @Override RuleSet getRuleSet(); void addElement(final Element candidate); List<Element> getUpdatedElements(); void resetUpdatedElements(); }
|
QueueGraphExecutionContext extends AbstractGraphCommandExecutionContext { public void resetUpdatedElements() { updatedElements.clear(); } QueueGraphExecutionContext(final DefinitionManager definitionManager,
final FactoryManager factoryManager,
final RuleManager ruleManager,
final Index<?, ?> graphIndex,
final RuleSet ruleSet); QueueGraphExecutionContext(final DefinitionManager definitionManager,
final FactoryManager factoryManager,
final RuleManager ruleManager,
final RuleEvaluationContextBuilder.StatefulGraphContextBuilder contextBuilder,
final Index<?, ?> graphIndex,
final RuleSet ruleSet); void clear(); @Override RuleViolations evaluate(final GraphEvaluationContext context); @Override RuleSet getRuleSet(); void addElement(final Element candidate); List<Element> getUpdatedElements(); void resetUpdatedElements(); }
|
@Test public void handleErrorTest() { reset(clientRuntimeError); when(clientRuntimeError.getThrowable()).thenReturn(new DefinitionNotFoundException("Error", DEFINITION_ID)); diagramClientErrorHandler.handleError(clientRuntimeError, message -> Assert.assertEquals(ERROR_MESSAGE, message)); when(clientRuntimeError.getThrowable()).thenReturn(new RuntimeException()); when(clientRuntimeError.toString()).thenReturn("runtime"); diagramClientErrorHandler.handleError(clientRuntimeError, message -> Assert.assertEquals("runtime", message)); }
|
public void handleError(ClientRuntimeError error, Consumer<String> showError) { if (Objects.isNull(error)) { throw new RuntimeException("Error cannot be null"); } String message = null; if (error.getThrowable() instanceof DefinitionNotFoundException) { message = translationService.getValue(CoreTranslationMessages.DIAGRAM_LOAD_FAIL_UNSUPPORTED_ELEMENTS, ((DefinitionNotFoundException) error.getThrowable()).getDefinitionId()); } showError.accept(Objects.nonNull(message) ? message : error.toString()); }
|
DiagramClientErrorHandler extends ClientErrorHandler { public void handleError(ClientRuntimeError error, Consumer<String> showError) { if (Objects.isNull(error)) { throw new RuntimeException("Error cannot be null"); } String message = null; if (error.getThrowable() instanceof DefinitionNotFoundException) { message = translationService.getValue(CoreTranslationMessages.DIAGRAM_LOAD_FAIL_UNSUPPORTED_ELEMENTS, ((DefinitionNotFoundException) error.getThrowable()).getDefinitionId()); } showError.accept(Objects.nonNull(message) ? message : error.toString()); } }
|
DiagramClientErrorHandler extends ClientErrorHandler { public void handleError(ClientRuntimeError error, Consumer<String> showError) { if (Objects.isNull(error)) { throw new RuntimeException("Error cannot be null"); } String message = null; if (error.getThrowable() instanceof DefinitionNotFoundException) { message = translationService.getValue(CoreTranslationMessages.DIAGRAM_LOAD_FAIL_UNSUPPORTED_ELEMENTS, ((DefinitionNotFoundException) error.getThrowable()).getDefinitionId()); } showError.accept(Objects.nonNull(message) ? message : error.toString()); } @Inject DiagramClientErrorHandler(final ClientTranslationService translationService); }
|
DiagramClientErrorHandler extends ClientErrorHandler { public void handleError(ClientRuntimeError error, Consumer<String> showError) { if (Objects.isNull(error)) { throw new RuntimeException("Error cannot be null"); } String message = null; if (error.getThrowable() instanceof DefinitionNotFoundException) { message = translationService.getValue(CoreTranslationMessages.DIAGRAM_LOAD_FAIL_UNSUPPORTED_ELEMENTS, ((DefinitionNotFoundException) error.getThrowable()).getDefinitionId()); } showError.accept(Objects.nonNull(message) ? message : error.toString()); } @Inject DiagramClientErrorHandler(final ClientTranslationService translationService); void handleError(ClientRuntimeError error, Consumer<String> showError); }
|
DiagramClientErrorHandler extends ClientErrorHandler { public void handleError(ClientRuntimeError error, Consumer<String> showError) { if (Objects.isNull(error)) { throw new RuntimeException("Error cannot be null"); } String message = null; if (error.getThrowable() instanceof DefinitionNotFoundException) { message = translationService.getValue(CoreTranslationMessages.DIAGRAM_LOAD_FAIL_UNSUPPORTED_ELEMENTS, ((DefinitionNotFoundException) error.getThrowable()).getDefinitionId()); } showError.accept(Objects.nonNull(message) ? message : error.toString()); } @Inject DiagramClientErrorHandler(final ClientTranslationService translationService); void handleError(ClientRuntimeError error, Consumer<String> showError); }
|
@Test @SuppressWarnings("unchecked") public void testGet() { StunnerPreferences instance = tested.get(DEF_SET_ID, StunnerPreferences.class); verify(preferencesRegistries, times(1)).select(eq(qualifier)); assertEquals(preferences, instance); }
|
public <T> T get(final String definitionSetId, Class<T> preferenceType) { final Annotation qualifier = definitionUtils.getQualifier(definitionSetId); return get(qualifier, preferenceType); }
|
StunnerPreferencesRegistries { public <T> T get(final String definitionSetId, Class<T> preferenceType) { final Annotation qualifier = definitionUtils.getQualifier(definitionSetId); return get(qualifier, preferenceType); } }
|
StunnerPreferencesRegistries { public <T> T get(final String definitionSetId, Class<T> preferenceType) { final Annotation qualifier = definitionUtils.getQualifier(definitionSetId); return get(qualifier, preferenceType); } @Inject StunnerPreferencesRegistries(final DefinitionUtils definitionUtils,
final @Any ManagedInstance<StunnerPreferencesRegistry> preferencesRegistries); }
|
StunnerPreferencesRegistries { public <T> T get(final String definitionSetId, Class<T> preferenceType) { final Annotation qualifier = definitionUtils.getQualifier(definitionSetId); return get(qualifier, preferenceType); } @Inject StunnerPreferencesRegistries(final DefinitionUtils definitionUtils,
final @Any ManagedInstance<StunnerPreferencesRegistry> preferencesRegistries); T get(final String definitionSetId, Class<T> preferenceType); T get(final Annotation qualifier, Class<T> preferenceType); }
|
StunnerPreferencesRegistries { public <T> T get(final String definitionSetId, Class<T> preferenceType) { final Annotation qualifier = definitionUtils.getQualifier(definitionSetId); return get(qualifier, preferenceType); } @Inject StunnerPreferencesRegistries(final DefinitionUtils definitionUtils,
final @Any ManagedInstance<StunnerPreferencesRegistry> preferencesRegistries); T get(final String definitionSetId, Class<T> preferenceType); T get(final Annotation qualifier, Class<T> preferenceType); }
|
@Test @SuppressWarnings("unchecked") public void testGetTextPreferences() { StunnerTextPreferences instance = tested.get(DEF_SET_ID, StunnerTextPreferences.class); verify(preferencesRegistries, times(1)).select(eq(qualifier)); assertEquals(textPreferences, instance); }
|
public <T> T get(final String definitionSetId, Class<T> preferenceType) { final Annotation qualifier = definitionUtils.getQualifier(definitionSetId); return get(qualifier, preferenceType); }
|
StunnerPreferencesRegistries { public <T> T get(final String definitionSetId, Class<T> preferenceType) { final Annotation qualifier = definitionUtils.getQualifier(definitionSetId); return get(qualifier, preferenceType); } }
|
StunnerPreferencesRegistries { public <T> T get(final String definitionSetId, Class<T> preferenceType) { final Annotation qualifier = definitionUtils.getQualifier(definitionSetId); return get(qualifier, preferenceType); } @Inject StunnerPreferencesRegistries(final DefinitionUtils definitionUtils,
final @Any ManagedInstance<StunnerPreferencesRegistry> preferencesRegistries); }
|
StunnerPreferencesRegistries { public <T> T get(final String definitionSetId, Class<T> preferenceType) { final Annotation qualifier = definitionUtils.getQualifier(definitionSetId); return get(qualifier, preferenceType); } @Inject StunnerPreferencesRegistries(final DefinitionUtils definitionUtils,
final @Any ManagedInstance<StunnerPreferencesRegistry> preferencesRegistries); T get(final String definitionSetId, Class<T> preferenceType); T get(final Annotation qualifier, Class<T> preferenceType); }
|
StunnerPreferencesRegistries { public <T> T get(final String definitionSetId, Class<T> preferenceType) { final Annotation qualifier = definitionUtils.getQualifier(definitionSetId); return get(qualifier, preferenceType); } @Inject StunnerPreferencesRegistries(final DefinitionUtils definitionUtils,
final @Any ManagedInstance<StunnerPreferencesRegistry> preferencesRegistries); T get(final String definitionSetId, Class<T> preferenceType); T get(final Annotation qualifier, Class<T> preferenceType); }
|
@Test @SuppressWarnings("unchecked") public void testLoad() { final ParameterizedCommand<StunnerPreferences> loadCompleteCallback = mock(ParameterizedCommand.class); final ParameterizedCommand<Throwable> errorCallback = mock(ParameterizedCommand.class); final StunnerPreferences pre = mock(StunnerPreferences.class); doAnswer(invocation -> { ((ParameterizedCommand<StunnerPreferences>) invocation.getArguments()[0]).execute(pre); return null; }).when(preferences).load(any(ParameterizedCommand.class), any(ParameterizedCommand.class)); tested.load(metadata, loadCompleteCallback, errorCallback); verify(preferencesHolders, times(1)).select(eq(qualifier)); verify(loadCompleteCallback, times(1)).execute(eq(pre)); verify(errorCallback, never()).execute(any(Throwable.class)); verify(preferencesHolder, times(1)).set(eq(pre), eq(StunnerPreferences.class)); verify(preferencesHolder, times(1)).set(eq(textPreferences), eq(StunnerTextPreferences.class)); }
|
public void load(final Metadata metadata, final ParameterizedCommand<StunnerPreferences> loadCompleteCallback, final ParameterizedCommand<Throwable> errorCallback) { final String definitionSetId = metadata.getDefinitionSetId(); final Annotation qualifier = definitionUtils.getQualifier(definitionSetId); final StunnerPreferencesRegistryHolder holder = InstanceUtils.lookup(preferencesHolders, qualifier); preferences.load(prefs -> { holder.set(prefs, StunnerPreferences.class); holder.set(textPreferences, StunnerTextPreferences.class); loadCompleteCallback.execute(prefs); }, errorCallback); }
|
StunnerPreferencesRegistryLoader { public void load(final Metadata metadata, final ParameterizedCommand<StunnerPreferences> loadCompleteCallback, final ParameterizedCommand<Throwable> errorCallback) { final String definitionSetId = metadata.getDefinitionSetId(); final Annotation qualifier = definitionUtils.getQualifier(definitionSetId); final StunnerPreferencesRegistryHolder holder = InstanceUtils.lookup(preferencesHolders, qualifier); preferences.load(prefs -> { holder.set(prefs, StunnerPreferences.class); holder.set(textPreferences, StunnerTextPreferences.class); loadCompleteCallback.execute(prefs); }, errorCallback); } }
|
StunnerPreferencesRegistryLoader { public void load(final Metadata metadata, final ParameterizedCommand<StunnerPreferences> loadCompleteCallback, final ParameterizedCommand<Throwable> errorCallback) { final String definitionSetId = metadata.getDefinitionSetId(); final Annotation qualifier = definitionUtils.getQualifier(definitionSetId); final StunnerPreferencesRegistryHolder holder = InstanceUtils.lookup(preferencesHolders, qualifier); preferences.load(prefs -> { holder.set(prefs, StunnerPreferences.class); holder.set(textPreferences, StunnerTextPreferences.class); loadCompleteCallback.execute(prefs); }, errorCallback); } @Inject StunnerPreferencesRegistryLoader(final DefinitionUtils definitionUtils,
final @Any ManagedInstance<StunnerPreferencesRegistryHolder> preferencesHolders,
final StunnerPreferences preferences,
final StunnerTextPreferences textPreferences); }
|
StunnerPreferencesRegistryLoader { public void load(final Metadata metadata, final ParameterizedCommand<StunnerPreferences> loadCompleteCallback, final ParameterizedCommand<Throwable> errorCallback) { final String definitionSetId = metadata.getDefinitionSetId(); final Annotation qualifier = definitionUtils.getQualifier(definitionSetId); final StunnerPreferencesRegistryHolder holder = InstanceUtils.lookup(preferencesHolders, qualifier); preferences.load(prefs -> { holder.set(prefs, StunnerPreferences.class); holder.set(textPreferences, StunnerTextPreferences.class); loadCompleteCallback.execute(prefs); }, errorCallback); } @Inject StunnerPreferencesRegistryLoader(final DefinitionUtils definitionUtils,
final @Any ManagedInstance<StunnerPreferencesRegistryHolder> preferencesHolders,
final StunnerPreferences preferences,
final StunnerTextPreferences textPreferences); void load(final Metadata metadata,
final ParameterizedCommand<StunnerPreferences> loadCompleteCallback,
final ParameterizedCommand<Throwable> errorCallback); @PreDestroy void destroy(); }
|
StunnerPreferencesRegistryLoader { public void load(final Metadata metadata, final ParameterizedCommand<StunnerPreferences> loadCompleteCallback, final ParameterizedCommand<Throwable> errorCallback) { final String definitionSetId = metadata.getDefinitionSetId(); final Annotation qualifier = definitionUtils.getQualifier(definitionSetId); final StunnerPreferencesRegistryHolder holder = InstanceUtils.lookup(preferencesHolders, qualifier); preferences.load(prefs -> { holder.set(prefs, StunnerPreferences.class); holder.set(textPreferences, StunnerTextPreferences.class); loadCompleteCallback.execute(prefs); }, errorCallback); } @Inject StunnerPreferencesRegistryLoader(final DefinitionUtils definitionUtils,
final @Any ManagedInstance<StunnerPreferencesRegistryHolder> preferencesHolders,
final StunnerPreferences preferences,
final StunnerTextPreferences textPreferences); void load(final Metadata metadata,
final ParameterizedCommand<StunnerPreferences> loadCompleteCallback,
final ParameterizedCommand<Throwable> errorCallback); @PreDestroy void destroy(); }
|
@Test @SuppressWarnings("unchecked") public void testLoadError() { final ParameterizedCommand<StunnerPreferences> loadCompleteCallback = mock(ParameterizedCommand.class); final ParameterizedCommand<Throwable> errorCallback = mock(ParameterizedCommand.class); final Throwable errorInstance = mock(Throwable.class); doAnswer(new Answer() { @Override public Object answer(InvocationOnMock invocation) throws Throwable { ((ParameterizedCommand<Throwable>) invocation.getArguments()[1]).execute(errorInstance); return null; } }).when(preferences).load(any(ParameterizedCommand.class), any(ParameterizedCommand.class)); tested.load(metadata, loadCompleteCallback, errorCallback); verify(preferencesHolders, times(1)).select(eq(qualifier)); verify(errorCallback, times(1)).execute(eq(errorInstance)); verify(loadCompleteCallback, never()).execute(any(StunnerPreferences.class)); verify(preferencesHolder, never()).set(any(StunnerPreferences.class), eq(StunnerPreferences.class)); verify(preferencesHolder, never()).set(any(StunnerTextPreferences.class), eq(StunnerTextPreferences.class)); }
|
public void load(final Metadata metadata, final ParameterizedCommand<StunnerPreferences> loadCompleteCallback, final ParameterizedCommand<Throwable> errorCallback) { final String definitionSetId = metadata.getDefinitionSetId(); final Annotation qualifier = definitionUtils.getQualifier(definitionSetId); final StunnerPreferencesRegistryHolder holder = InstanceUtils.lookup(preferencesHolders, qualifier); preferences.load(prefs -> { holder.set(prefs, StunnerPreferences.class); holder.set(textPreferences, StunnerTextPreferences.class); loadCompleteCallback.execute(prefs); }, errorCallback); }
|
StunnerPreferencesRegistryLoader { public void load(final Metadata metadata, final ParameterizedCommand<StunnerPreferences> loadCompleteCallback, final ParameterizedCommand<Throwable> errorCallback) { final String definitionSetId = metadata.getDefinitionSetId(); final Annotation qualifier = definitionUtils.getQualifier(definitionSetId); final StunnerPreferencesRegistryHolder holder = InstanceUtils.lookup(preferencesHolders, qualifier); preferences.load(prefs -> { holder.set(prefs, StunnerPreferences.class); holder.set(textPreferences, StunnerTextPreferences.class); loadCompleteCallback.execute(prefs); }, errorCallback); } }
|
StunnerPreferencesRegistryLoader { public void load(final Metadata metadata, final ParameterizedCommand<StunnerPreferences> loadCompleteCallback, final ParameterizedCommand<Throwable> errorCallback) { final String definitionSetId = metadata.getDefinitionSetId(); final Annotation qualifier = definitionUtils.getQualifier(definitionSetId); final StunnerPreferencesRegistryHolder holder = InstanceUtils.lookup(preferencesHolders, qualifier); preferences.load(prefs -> { holder.set(prefs, StunnerPreferences.class); holder.set(textPreferences, StunnerTextPreferences.class); loadCompleteCallback.execute(prefs); }, errorCallback); } @Inject StunnerPreferencesRegistryLoader(final DefinitionUtils definitionUtils,
final @Any ManagedInstance<StunnerPreferencesRegistryHolder> preferencesHolders,
final StunnerPreferences preferences,
final StunnerTextPreferences textPreferences); }
|
StunnerPreferencesRegistryLoader { public void load(final Metadata metadata, final ParameterizedCommand<StunnerPreferences> loadCompleteCallback, final ParameterizedCommand<Throwable> errorCallback) { final String definitionSetId = metadata.getDefinitionSetId(); final Annotation qualifier = definitionUtils.getQualifier(definitionSetId); final StunnerPreferencesRegistryHolder holder = InstanceUtils.lookup(preferencesHolders, qualifier); preferences.load(prefs -> { holder.set(prefs, StunnerPreferences.class); holder.set(textPreferences, StunnerTextPreferences.class); loadCompleteCallback.execute(prefs); }, errorCallback); } @Inject StunnerPreferencesRegistryLoader(final DefinitionUtils definitionUtils,
final @Any ManagedInstance<StunnerPreferencesRegistryHolder> preferencesHolders,
final StunnerPreferences preferences,
final StunnerTextPreferences textPreferences); void load(final Metadata metadata,
final ParameterizedCommand<StunnerPreferences> loadCompleteCallback,
final ParameterizedCommand<Throwable> errorCallback); @PreDestroy void destroy(); }
|
StunnerPreferencesRegistryLoader { public void load(final Metadata metadata, final ParameterizedCommand<StunnerPreferences> loadCompleteCallback, final ParameterizedCommand<Throwable> errorCallback) { final String definitionSetId = metadata.getDefinitionSetId(); final Annotation qualifier = definitionUtils.getQualifier(definitionSetId); final StunnerPreferencesRegistryHolder holder = InstanceUtils.lookup(preferencesHolders, qualifier); preferences.load(prefs -> { holder.set(prefs, StunnerPreferences.class); holder.set(textPreferences, StunnerTextPreferences.class); loadCompleteCallback.execute(prefs); }, errorCallback); } @Inject StunnerPreferencesRegistryLoader(final DefinitionUtils definitionUtils,
final @Any ManagedInstance<StunnerPreferencesRegistryHolder> preferencesHolders,
final StunnerPreferences preferences,
final StunnerTextPreferences textPreferences); void load(final Metadata metadata,
final ParameterizedCommand<StunnerPreferences> loadCompleteCallback,
final ParameterizedCommand<Throwable> errorCallback); @PreDestroy void destroy(); }
|
@Test public void testDestroy() { tested.destroy(); verify(preferencesHolders, times(1)).destroyAll(); }
|
@PreDestroy public void destroy() { preferencesHolders.destroyAll(); }
|
StunnerPreferencesRegistryLoader { @PreDestroy public void destroy() { preferencesHolders.destroyAll(); } }
|
StunnerPreferencesRegistryLoader { @PreDestroy public void destroy() { preferencesHolders.destroyAll(); } @Inject StunnerPreferencesRegistryLoader(final DefinitionUtils definitionUtils,
final @Any ManagedInstance<StunnerPreferencesRegistryHolder> preferencesHolders,
final StunnerPreferences preferences,
final StunnerTextPreferences textPreferences); }
|
StunnerPreferencesRegistryLoader { @PreDestroy public void destroy() { preferencesHolders.destroyAll(); } @Inject StunnerPreferencesRegistryLoader(final DefinitionUtils definitionUtils,
final @Any ManagedInstance<StunnerPreferencesRegistryHolder> preferencesHolders,
final StunnerPreferences preferences,
final StunnerTextPreferences textPreferences); void load(final Metadata metadata,
final ParameterizedCommand<StunnerPreferences> loadCompleteCallback,
final ParameterizedCommand<Throwable> errorCallback); @PreDestroy void destroy(); }
|
StunnerPreferencesRegistryLoader { @PreDestroy public void destroy() { preferencesHolders.destroyAll(); } @Inject StunnerPreferencesRegistryLoader(final DefinitionUtils definitionUtils,
final @Any ManagedInstance<StunnerPreferencesRegistryHolder> preferencesHolders,
final StunnerPreferences preferences,
final StunnerTextPreferences textPreferences); void load(final Metadata metadata,
final ParameterizedCommand<StunnerPreferences> loadCompleteCallback,
final ParameterizedCommand<Throwable> errorCallback); @PreDestroy void destroy(); }
|
@Test public void testExportToJpg() { when(canvasExport.toImageData(eq(canvasHandler), any(CanvasURLExportSettings.class))).thenReturn(JPG_DATA_URI); tested.exportToJpg(canvasHandler, "file1"); final ArgumentCaptor<ImageDataUriContent> contentArgumentCaptor = ArgumentCaptor.forClass(ImageDataUriContent.class); verify(imageFileExport, times(1)).export(contentArgumentCaptor.capture(), eq("file1.jpg")); verify(pdfFileExport, never()).export(any(PdfDocument.class), anyString()); final ImageDataUriContent imageDataUriContent = contentArgumentCaptor.getValue(); assertEquals(JPG_DATA_URI, imageDataUriContent.getUri()); verify(clearSelectionEvent).fire(any(CanvasClearSelectionEvent.class)); }
|
public void exportToJpg(final AbstractCanvasHandler canvasHandler, final String fileName) { clearSelection(canvasHandler); exportImage(canvasHandler, CanvasExport.URLDataType.JPG, fileName); }
|
CanvasFileExport { public void exportToJpg(final AbstractCanvasHandler canvasHandler, final String fileName) { clearSelection(canvasHandler); exportImage(canvasHandler, CanvasExport.URLDataType.JPG, fileName); } }
|
CanvasFileExport { public void exportToJpg(final AbstractCanvasHandler canvasHandler, final String fileName) { clearSelection(canvasHandler); exportImage(canvasHandler, CanvasExport.URLDataType.JPG, fileName); } protected CanvasFileExport(); @Inject CanvasFileExport(final CanvasExport<AbstractCanvasHandler> canvasExport,
final FileExport<ImageDataUriContent> imageFileExport,
final FileExport<PdfDocument> pdfFileExport,
final FileExportsPreferences preferences,
final SvgFileExport svgFileExport,
final Event<CanvasClearSelectionEvent> clearSelectionEvent); }
|
CanvasFileExport { public void exportToJpg(final AbstractCanvasHandler canvasHandler, final String fileName) { clearSelection(canvasHandler); exportImage(canvasHandler, CanvasExport.URLDataType.JPG, fileName); } protected CanvasFileExport(); @Inject CanvasFileExport(final CanvasExport<AbstractCanvasHandler> canvasExport,
final FileExport<ImageDataUriContent> imageFileExport,
final FileExport<PdfDocument> pdfFileExport,
final FileExportsPreferences preferences,
final SvgFileExport svgFileExport,
final Event<CanvasClearSelectionEvent> clearSelectionEvent); void exportToSvg(final AbstractCanvasHandler canvasHandler,
final String fileName); String exportToSvg(final AbstractCanvasHandler canvasHandler); String exportToPng(final AbstractCanvasHandler canvasHandler); void exportToJpg(final AbstractCanvasHandler canvasHandler,
final String fileName); void exportToPng(final AbstractCanvasHandler canvasHandler,
final String fileName); void exportToPdf(final AbstractCanvasHandler canvasHandler,
final String fileName); }
|
CanvasFileExport { public void exportToJpg(final AbstractCanvasHandler canvasHandler, final String fileName) { clearSelection(canvasHandler); exportImage(canvasHandler, CanvasExport.URLDataType.JPG, fileName); } protected CanvasFileExport(); @Inject CanvasFileExport(final CanvasExport<AbstractCanvasHandler> canvasExport,
final FileExport<ImageDataUriContent> imageFileExport,
final FileExport<PdfDocument> pdfFileExport,
final FileExportsPreferences preferences,
final SvgFileExport svgFileExport,
final Event<CanvasClearSelectionEvent> clearSelectionEvent); void exportToSvg(final AbstractCanvasHandler canvasHandler,
final String fileName); String exportToSvg(final AbstractCanvasHandler canvasHandler); String exportToPng(final AbstractCanvasHandler canvasHandler); void exportToJpg(final AbstractCanvasHandler canvasHandler,
final String fileName); void exportToPng(final AbstractCanvasHandler canvasHandler,
final String fileName); void exportToPdf(final AbstractCanvasHandler canvasHandler,
final String fileName); }
|
@Test public void testExportToPng() { when(canvasExport.toImageData(eq(canvasHandler), any(CanvasURLExportSettings.class))).thenReturn(PNG_DATA_URI); tested.exportToPng(canvasHandler, "file1"); final ArgumentCaptor<ImageDataUriContent> contentArgumentCaptor = ArgumentCaptor.forClass(ImageDataUriContent.class); verify(imageFileExport, times(1)).export(contentArgumentCaptor.capture(), eq("file1.png")); verify(pdfFileExport, never()).export(any(PdfDocument.class), anyString()); final ImageDataUriContent imageDataUriContent = contentArgumentCaptor.getValue(); assertEquals(PNG_DATA_URI, imageDataUriContent.getUri()); verify(clearSelectionEvent).fire(any(CanvasClearSelectionEvent.class)); }
|
public String exportToPng(final AbstractCanvasHandler canvasHandler) { final CanvasURLExportSettings settings = CanvasURLExportSettings.build(CanvasExport.URLDataType.PNG); clearSelection(canvasHandler); return canvasExport.toImageData(canvasHandler, settings); }
|
CanvasFileExport { public String exportToPng(final AbstractCanvasHandler canvasHandler) { final CanvasURLExportSettings settings = CanvasURLExportSettings.build(CanvasExport.URLDataType.PNG); clearSelection(canvasHandler); return canvasExport.toImageData(canvasHandler, settings); } }
|
CanvasFileExport { public String exportToPng(final AbstractCanvasHandler canvasHandler) { final CanvasURLExportSettings settings = CanvasURLExportSettings.build(CanvasExport.URLDataType.PNG); clearSelection(canvasHandler); return canvasExport.toImageData(canvasHandler, settings); } protected CanvasFileExport(); @Inject CanvasFileExport(final CanvasExport<AbstractCanvasHandler> canvasExport,
final FileExport<ImageDataUriContent> imageFileExport,
final FileExport<PdfDocument> pdfFileExport,
final FileExportsPreferences preferences,
final SvgFileExport svgFileExport,
final Event<CanvasClearSelectionEvent> clearSelectionEvent); }
|
CanvasFileExport { public String exportToPng(final AbstractCanvasHandler canvasHandler) { final CanvasURLExportSettings settings = CanvasURLExportSettings.build(CanvasExport.URLDataType.PNG); clearSelection(canvasHandler); return canvasExport.toImageData(canvasHandler, settings); } protected CanvasFileExport(); @Inject CanvasFileExport(final CanvasExport<AbstractCanvasHandler> canvasExport,
final FileExport<ImageDataUriContent> imageFileExport,
final FileExport<PdfDocument> pdfFileExport,
final FileExportsPreferences preferences,
final SvgFileExport svgFileExport,
final Event<CanvasClearSelectionEvent> clearSelectionEvent); void exportToSvg(final AbstractCanvasHandler canvasHandler,
final String fileName); String exportToSvg(final AbstractCanvasHandler canvasHandler); String exportToPng(final AbstractCanvasHandler canvasHandler); void exportToJpg(final AbstractCanvasHandler canvasHandler,
final String fileName); void exportToPng(final AbstractCanvasHandler canvasHandler,
final String fileName); void exportToPdf(final AbstractCanvasHandler canvasHandler,
final String fileName); }
|
CanvasFileExport { public String exportToPng(final AbstractCanvasHandler canvasHandler) { final CanvasURLExportSettings settings = CanvasURLExportSettings.build(CanvasExport.URLDataType.PNG); clearSelection(canvasHandler); return canvasExport.toImageData(canvasHandler, settings); } protected CanvasFileExport(); @Inject CanvasFileExport(final CanvasExport<AbstractCanvasHandler> canvasExport,
final FileExport<ImageDataUriContent> imageFileExport,
final FileExport<PdfDocument> pdfFileExport,
final FileExportsPreferences preferences,
final SvgFileExport svgFileExport,
final Event<CanvasClearSelectionEvent> clearSelectionEvent); void exportToSvg(final AbstractCanvasHandler canvasHandler,
final String fileName); String exportToSvg(final AbstractCanvasHandler canvasHandler); String exportToPng(final AbstractCanvasHandler canvasHandler); void exportToJpg(final AbstractCanvasHandler canvasHandler,
final String fileName); void exportToPng(final AbstractCanvasHandler canvasHandler,
final String fileName); void exportToPdf(final AbstractCanvasHandler canvasHandler,
final String fileName); }
|
@Test public void testExportToPdf() { when(canvasExport.toImageData(eq(canvasHandler), any(CanvasURLExportSettings.class))).thenReturn(JPG_DATA_URI); verify(imageFileExport, never()).export(any(ImageDataUriContent.class), anyString()); tested.exportToPdf(canvasHandler, "file1"); verify(pdfFileExport, times(1)).export(any(PdfDocument.class), eq("file1.pdf")); verify(clearSelectionEvent).fire(any(CanvasClearSelectionEvent.class)); }
|
public void exportToPdf(final AbstractCanvasHandler canvasHandler, final String fileName) { clearSelection(canvasHandler); loadFileExportPreferences(prefs -> exportToPdf(canvasHandler, fileName, prefs.getPdfPreferences())); }
|
CanvasFileExport { public void exportToPdf(final AbstractCanvasHandler canvasHandler, final String fileName) { clearSelection(canvasHandler); loadFileExportPreferences(prefs -> exportToPdf(canvasHandler, fileName, prefs.getPdfPreferences())); } }
|
CanvasFileExport { public void exportToPdf(final AbstractCanvasHandler canvasHandler, final String fileName) { clearSelection(canvasHandler); loadFileExportPreferences(prefs -> exportToPdf(canvasHandler, fileName, prefs.getPdfPreferences())); } protected CanvasFileExport(); @Inject CanvasFileExport(final CanvasExport<AbstractCanvasHandler> canvasExport,
final FileExport<ImageDataUriContent> imageFileExport,
final FileExport<PdfDocument> pdfFileExport,
final FileExportsPreferences preferences,
final SvgFileExport svgFileExport,
final Event<CanvasClearSelectionEvent> clearSelectionEvent); }
|
CanvasFileExport { public void exportToPdf(final AbstractCanvasHandler canvasHandler, final String fileName) { clearSelection(canvasHandler); loadFileExportPreferences(prefs -> exportToPdf(canvasHandler, fileName, prefs.getPdfPreferences())); } protected CanvasFileExport(); @Inject CanvasFileExport(final CanvasExport<AbstractCanvasHandler> canvasExport,
final FileExport<ImageDataUriContent> imageFileExport,
final FileExport<PdfDocument> pdfFileExport,
final FileExportsPreferences preferences,
final SvgFileExport svgFileExport,
final Event<CanvasClearSelectionEvent> clearSelectionEvent); void exportToSvg(final AbstractCanvasHandler canvasHandler,
final String fileName); String exportToSvg(final AbstractCanvasHandler canvasHandler); String exportToPng(final AbstractCanvasHandler canvasHandler); void exportToJpg(final AbstractCanvasHandler canvasHandler,
final String fileName); void exportToPng(final AbstractCanvasHandler canvasHandler,
final String fileName); void exportToPdf(final AbstractCanvasHandler canvasHandler,
final String fileName); }
|
CanvasFileExport { public void exportToPdf(final AbstractCanvasHandler canvasHandler, final String fileName) { clearSelection(canvasHandler); loadFileExportPreferences(prefs -> exportToPdf(canvasHandler, fileName, prefs.getPdfPreferences())); } protected CanvasFileExport(); @Inject CanvasFileExport(final CanvasExport<AbstractCanvasHandler> canvasExport,
final FileExport<ImageDataUriContent> imageFileExport,
final FileExport<PdfDocument> pdfFileExport,
final FileExportsPreferences preferences,
final SvgFileExport svgFileExport,
final Event<CanvasClearSelectionEvent> clearSelectionEvent); void exportToSvg(final AbstractCanvasHandler canvasHandler,
final String fileName); String exportToSvg(final AbstractCanvasHandler canvasHandler); String exportToPng(final AbstractCanvasHandler canvasHandler); void exportToJpg(final AbstractCanvasHandler canvasHandler,
final String fileName); void exportToPng(final AbstractCanvasHandler canvasHandler,
final String fileName); void exportToPdf(final AbstractCanvasHandler canvasHandler,
final String fileName); }
|
@Test public void testHide() { view.hide(); verify(viewElementCSSClasses).remove(OPEN); }
|
@Override public void hide() { getElement().getClassList().remove(OPEN); }
|
ListSelectorViewImpl implements ListSelectorView { @Override public void hide() { getElement().getClassList().remove(OPEN); } }
|
ListSelectorViewImpl implements ListSelectorView { @Override public void hide() { getElement().getClassList().remove(OPEN); } ListSelectorViewImpl(); @Inject ListSelectorViewImpl(final UnorderedList itemsContainer,
final ManagedInstance<ListSelectorTextItemView> listSelectorTextItemViews,
final ManagedInstance<ListSelectorDividerItemView> listSelectorDividerItemViews,
final ManagedInstance<ListSelectorHeaderItemView> listSelectorHeaderItemViews); }
|
ListSelectorViewImpl implements ListSelectorView { @Override public void hide() { getElement().getClassList().remove(OPEN); } ListSelectorViewImpl(); @Inject ListSelectorViewImpl(final UnorderedList itemsContainer,
final ManagedInstance<ListSelectorTextItemView> listSelectorTextItemViews,
final ManagedInstance<ListSelectorDividerItemView> listSelectorDividerItemViews,
final ManagedInstance<ListSelectorHeaderItemView> listSelectorHeaderItemViews); @Override void init(final Presenter presenter); @Override void setItems(final List<ListSelectorItem> items); @Override void show(final Optional<String> title); @Override void hide(); @Override void setOnClosedByKeyboardCallback(final Consumer<CanBeClosedByKeyboard> callback); }
|
ListSelectorViewImpl implements ListSelectorView { @Override public void hide() { getElement().getClassList().remove(OPEN); } ListSelectorViewImpl(); @Inject ListSelectorViewImpl(final UnorderedList itemsContainer,
final ManagedInstance<ListSelectorTextItemView> listSelectorTextItemViews,
final ManagedInstance<ListSelectorDividerItemView> listSelectorDividerItemViews,
final ManagedInstance<ListSelectorHeaderItemView> listSelectorHeaderItemViews); @Override void init(final Presenter presenter); @Override void setItems(final List<ListSelectorItem> items); @Override void show(final Optional<String> title); @Override void hide(); @Override void setOnClosedByKeyboardCallback(final Consumer<CanBeClosedByKeyboard> callback); }
|
@Test public void testExportToSVG() { when(canvasExport.toContext2D(eq(canvasHandler), any(CanvasExportSettings.class))).thenReturn(context2D); tested.exportToSvg(canvasHandler, "file1"); verify(svgFileExport, times(1)).export(context2D, "file1.svg"); verify(clearSelectionEvent).fire(any(CanvasClearSelectionEvent.class)); }
|
public void exportToSvg(final AbstractCanvasHandler canvasHandler, final String fileName) { clearSelection(canvasHandler); final String fullFileName = fileName + "." + getFileExtension(CanvasExport.URLDataType.SVG); svgFileExport.export(canvasExport.toContext2D(canvasHandler, CanvasExportSettings.build()), fullFileName); }
|
CanvasFileExport { public void exportToSvg(final AbstractCanvasHandler canvasHandler, final String fileName) { clearSelection(canvasHandler); final String fullFileName = fileName + "." + getFileExtension(CanvasExport.URLDataType.SVG); svgFileExport.export(canvasExport.toContext2D(canvasHandler, CanvasExportSettings.build()), fullFileName); } }
|
CanvasFileExport { public void exportToSvg(final AbstractCanvasHandler canvasHandler, final String fileName) { clearSelection(canvasHandler); final String fullFileName = fileName + "." + getFileExtension(CanvasExport.URLDataType.SVG); svgFileExport.export(canvasExport.toContext2D(canvasHandler, CanvasExportSettings.build()), fullFileName); } protected CanvasFileExport(); @Inject CanvasFileExport(final CanvasExport<AbstractCanvasHandler> canvasExport,
final FileExport<ImageDataUriContent> imageFileExport,
final FileExport<PdfDocument> pdfFileExport,
final FileExportsPreferences preferences,
final SvgFileExport svgFileExport,
final Event<CanvasClearSelectionEvent> clearSelectionEvent); }
|
CanvasFileExport { public void exportToSvg(final AbstractCanvasHandler canvasHandler, final String fileName) { clearSelection(canvasHandler); final String fullFileName = fileName + "." + getFileExtension(CanvasExport.URLDataType.SVG); svgFileExport.export(canvasExport.toContext2D(canvasHandler, CanvasExportSettings.build()), fullFileName); } protected CanvasFileExport(); @Inject CanvasFileExport(final CanvasExport<AbstractCanvasHandler> canvasExport,
final FileExport<ImageDataUriContent> imageFileExport,
final FileExport<PdfDocument> pdfFileExport,
final FileExportsPreferences preferences,
final SvgFileExport svgFileExport,
final Event<CanvasClearSelectionEvent> clearSelectionEvent); void exportToSvg(final AbstractCanvasHandler canvasHandler,
final String fileName); String exportToSvg(final AbstractCanvasHandler canvasHandler); String exportToPng(final AbstractCanvasHandler canvasHandler); void exportToJpg(final AbstractCanvasHandler canvasHandler,
final String fileName); void exportToPng(final AbstractCanvasHandler canvasHandler,
final String fileName); void exportToPdf(final AbstractCanvasHandler canvasHandler,
final String fileName); }
|
CanvasFileExport { public void exportToSvg(final AbstractCanvasHandler canvasHandler, final String fileName) { clearSelection(canvasHandler); final String fullFileName = fileName + "." + getFileExtension(CanvasExport.URLDataType.SVG); svgFileExport.export(canvasExport.toContext2D(canvasHandler, CanvasExportSettings.build()), fullFileName); } protected CanvasFileExport(); @Inject CanvasFileExport(final CanvasExport<AbstractCanvasHandler> canvasExport,
final FileExport<ImageDataUriContent> imageFileExport,
final FileExport<PdfDocument> pdfFileExport,
final FileExportsPreferences preferences,
final SvgFileExport svgFileExport,
final Event<CanvasClearSelectionEvent> clearSelectionEvent); void exportToSvg(final AbstractCanvasHandler canvasHandler,
final String fileName); String exportToSvg(final AbstractCanvasHandler canvasHandler); String exportToPng(final AbstractCanvasHandler canvasHandler); void exportToJpg(final AbstractCanvasHandler canvasHandler,
final String fileName); void exportToPng(final AbstractCanvasHandler canvasHandler,
final String fileName); void exportToPdf(final AbstractCanvasHandler canvasHandler,
final String fileName); }
|
@Test public void testExportToPNG() { final String expectedImage = "image"; doNothing().when(tested).clearSelection(any()); when(canvasExport.toImageData(any(), any())).thenReturn(expectedImage); final String actualImage = tested.exportToPng(canvasHandler); verify(tested).clearSelection(canvasHandler); assertEquals(expectedImage, actualImage); }
|
public String exportToPng(final AbstractCanvasHandler canvasHandler) { final CanvasURLExportSettings settings = CanvasURLExportSettings.build(CanvasExport.URLDataType.PNG); clearSelection(canvasHandler); return canvasExport.toImageData(canvasHandler, settings); }
|
CanvasFileExport { public String exportToPng(final AbstractCanvasHandler canvasHandler) { final CanvasURLExportSettings settings = CanvasURLExportSettings.build(CanvasExport.URLDataType.PNG); clearSelection(canvasHandler); return canvasExport.toImageData(canvasHandler, settings); } }
|
CanvasFileExport { public String exportToPng(final AbstractCanvasHandler canvasHandler) { final CanvasURLExportSettings settings = CanvasURLExportSettings.build(CanvasExport.URLDataType.PNG); clearSelection(canvasHandler); return canvasExport.toImageData(canvasHandler, settings); } protected CanvasFileExport(); @Inject CanvasFileExport(final CanvasExport<AbstractCanvasHandler> canvasExport,
final FileExport<ImageDataUriContent> imageFileExport,
final FileExport<PdfDocument> pdfFileExport,
final FileExportsPreferences preferences,
final SvgFileExport svgFileExport,
final Event<CanvasClearSelectionEvent> clearSelectionEvent); }
|
CanvasFileExport { public String exportToPng(final AbstractCanvasHandler canvasHandler) { final CanvasURLExportSettings settings = CanvasURLExportSettings.build(CanvasExport.URLDataType.PNG); clearSelection(canvasHandler); return canvasExport.toImageData(canvasHandler, settings); } protected CanvasFileExport(); @Inject CanvasFileExport(final CanvasExport<AbstractCanvasHandler> canvasExport,
final FileExport<ImageDataUriContent> imageFileExport,
final FileExport<PdfDocument> pdfFileExport,
final FileExportsPreferences preferences,
final SvgFileExport svgFileExport,
final Event<CanvasClearSelectionEvent> clearSelectionEvent); void exportToSvg(final AbstractCanvasHandler canvasHandler,
final String fileName); String exportToSvg(final AbstractCanvasHandler canvasHandler); String exportToPng(final AbstractCanvasHandler canvasHandler); void exportToJpg(final AbstractCanvasHandler canvasHandler,
final String fileName); void exportToPng(final AbstractCanvasHandler canvasHandler,
final String fileName); void exportToPdf(final AbstractCanvasHandler canvasHandler,
final String fileName); }
|
CanvasFileExport { public String exportToPng(final AbstractCanvasHandler canvasHandler) { final CanvasURLExportSettings settings = CanvasURLExportSettings.build(CanvasExport.URLDataType.PNG); clearSelection(canvasHandler); return canvasExport.toImageData(canvasHandler, settings); } protected CanvasFileExport(); @Inject CanvasFileExport(final CanvasExport<AbstractCanvasHandler> canvasExport,
final FileExport<ImageDataUriContent> imageFileExport,
final FileExport<PdfDocument> pdfFileExport,
final FileExportsPreferences preferences,
final SvgFileExport svgFileExport,
final Event<CanvasClearSelectionEvent> clearSelectionEvent); void exportToSvg(final AbstractCanvasHandler canvasHandler,
final String fileName); String exportToSvg(final AbstractCanvasHandler canvasHandler); String exportToPng(final AbstractCanvasHandler canvasHandler); void exportToJpg(final AbstractCanvasHandler canvasHandler,
final String fileName); void exportToPng(final AbstractCanvasHandler canvasHandler,
final String fileName); void exportToPdf(final AbstractCanvasHandler canvasHandler,
final String fileName); }
|
@Test public void testUnhighLight() { tested.highLight(node1); tested.invalid(node2); tested.unhighLight(); verify(shape1, times(1)).applyState(eq(ShapeState.HIGHLIGHT)); verify(shape1, times(1)).applyState(eq(ShapeState.NONE)); verify(shape2, times(1)).applyState(eq(ShapeState.INVALID)); verify(shape2, times(1)).applyState(eq(ShapeState.NONE)); verify(canvasView, atLeastOnce()).setCursor(eq(AbstractCanvas.Cursors.MOVE)); }
|
public CanvasHighlight unhighLight() { if (!uuids.isEmpty()) { HashSet<String> copy = new HashSet<>(uuids); uuids.clear(); copy.forEach(uuid -> { final Shape shape = getShape(uuid); if (null != shape) { shape.applyState(ShapeState.NONE); } }); } setCursor(AbstractCanvas.Cursors.MOVE); return this; }
|
CanvasHighlight { public CanvasHighlight unhighLight() { if (!uuids.isEmpty()) { HashSet<String> copy = new HashSet<>(uuids); uuids.clear(); copy.forEach(uuid -> { final Shape shape = getShape(uuid); if (null != shape) { shape.applyState(ShapeState.NONE); } }); } setCursor(AbstractCanvas.Cursors.MOVE); return this; } }
|
CanvasHighlight { public CanvasHighlight unhighLight() { if (!uuids.isEmpty()) { HashSet<String> copy = new HashSet<>(uuids); uuids.clear(); copy.forEach(uuid -> { final Shape shape = getShape(uuid); if (null != shape) { shape.applyState(ShapeState.NONE); } }); } setCursor(AbstractCanvas.Cursors.MOVE); return this; } CanvasHighlight(); }
|
CanvasHighlight { public CanvasHighlight unhighLight() { if (!uuids.isEmpty()) { HashSet<String> copy = new HashSet<>(uuids); uuids.clear(); copy.forEach(uuid -> { final Shape shape = getShape(uuid); if (null != shape) { shape.applyState(ShapeState.NONE); } }); } setCursor(AbstractCanvas.Cursors.MOVE); return this; } CanvasHighlight(); CanvasHighlight setCanvasHandler(final AbstractCanvasHandler canvasHandler); CanvasHighlight highLight(final Element<?> node); CanvasHighlight invalid(final Element<?> node); CanvasHighlight invalid(final RuleViolations violations); CanvasHighlight invalid(final Iterable<? extends RuleViolation> violations); CanvasHighlight none(final Element<?> node); CanvasHighlight unhighLight(); void destroy(); }
|
CanvasHighlight { public CanvasHighlight unhighLight() { if (!uuids.isEmpty()) { HashSet<String> copy = new HashSet<>(uuids); uuids.clear(); copy.forEach(uuid -> { final Shape shape = getShape(uuid); if (null != shape) { shape.applyState(ShapeState.NONE); } }); } setCursor(AbstractCanvas.Cursors.MOVE); return this; } CanvasHighlight(); CanvasHighlight setCanvasHandler(final AbstractCanvasHandler canvasHandler); CanvasHighlight highLight(final Element<?> node); CanvasHighlight invalid(final Element<?> node); CanvasHighlight invalid(final RuleViolations violations); CanvasHighlight invalid(final Iterable<? extends RuleViolation> violations); CanvasHighlight none(final Element<?> node); CanvasHighlight unhighLight(); void destroy(); }
|
@Test public void testDestroy() { tested.highLight(node1); tested.invalid(node2); tested.destroy(); verify(shape1, times(1)).applyState(eq(ShapeState.HIGHLIGHT)); verify(shape1, times(0)).applyState(eq(ShapeState.NONE)); verify(shape2, times(1)).applyState(eq(ShapeState.INVALID)); verify(shape2, times(0)).applyState(eq(ShapeState.NONE)); verify(canvasView, atLeastOnce()).setCursor(eq(AbstractCanvas.Cursors.DEFAULT)); }
|
public void destroy() { setValidCursor(); this.uuids.clear(); this.canvasHandler = null; }
|
CanvasHighlight { public void destroy() { setValidCursor(); this.uuids.clear(); this.canvasHandler = null; } }
|
CanvasHighlight { public void destroy() { setValidCursor(); this.uuids.clear(); this.canvasHandler = null; } CanvasHighlight(); }
|
CanvasHighlight { public void destroy() { setValidCursor(); this.uuids.clear(); this.canvasHandler = null; } CanvasHighlight(); CanvasHighlight setCanvasHandler(final AbstractCanvasHandler canvasHandler); CanvasHighlight highLight(final Element<?> node); CanvasHighlight invalid(final Element<?> node); CanvasHighlight invalid(final RuleViolations violations); CanvasHighlight invalid(final Iterable<? extends RuleViolation> violations); CanvasHighlight none(final Element<?> node); CanvasHighlight unhighLight(); void destroy(); }
|
CanvasHighlight { public void destroy() { setValidCursor(); this.uuids.clear(); this.canvasHandler = null; } CanvasHighlight(); CanvasHighlight setCanvasHandler(final AbstractCanvasHandler canvasHandler); CanvasHighlight highLight(final Element<?> node); CanvasHighlight invalid(final Element<?> node); CanvasHighlight invalid(final RuleViolations violations); CanvasHighlight invalid(final Iterable<? extends RuleViolation> violations); CanvasHighlight none(final Element<?> node); CanvasHighlight unhighLight(); void destroy(); }
|
@Test public void isCanvasRootTrueTest() { when(diagram.getMetadata().getCanvasRootUUID()).thenReturn("canvas_root"); boolean isCanvasRoot = CanvasLayoutUtils.isCanvasRoot(diagram, parentCanvasRoot); assertTrue(isCanvasRoot); }
|
public static boolean isCanvasRoot(final Diagram diagram, final Element parent) { return null != parent && isCanvasRoot(diagram, parent.getUUID()); }
|
CanvasLayoutUtils { public static boolean isCanvasRoot(final Diagram diagram, final Element parent) { return null != parent && isCanvasRoot(diagram, parent.getUUID()); } }
|
CanvasLayoutUtils { public static boolean isCanvasRoot(final Diagram diagram, final Element parent) { return null != parent && isCanvasRoot(diagram, parent.getUUID()); } @Inject CanvasLayoutUtils(final GraphBoundsIndexer graphBoundsIndexer); }
|
CanvasLayoutUtils { public static boolean isCanvasRoot(final Diagram diagram, final Element parent) { return null != parent && isCanvasRoot(diagram, parent.getUUID()); } @Inject CanvasLayoutUtils(final GraphBoundsIndexer graphBoundsIndexer); static boolean isCanvasRoot(final Diagram diagram,
final Element parent); static boolean isCanvasRoot(final Diagram diagram,
final String pUUID); static int getPaddingX(); static int getPaddingY(); @PreDestroy void destroy(); @SuppressWarnings("unchecked") Point2D getNext(final AbstractCanvasHandler canvasHandler,
final Node<View<?>, Edge> root,
final Node<View<?>, Edge> newNode); @SuppressWarnings("unchecked") Point2D getNext(final AbstractCanvasHandler canvasHandler,
final Node<View<?>, Edge> root,
final double rootNodeWidth,
final double rootNodeHeight,
final double newNodeWidth,
final double newNodeHeight,
Point2D offset,
Point2D rootNodeCoordinates
); @SuppressWarnings("unchecked") static Element<? extends Definition<?>> getElement(final AbstractCanvasHandler canvasHandler,
final String uuid); static void fireElementSelectedEvent(final Event<CanvasSelectionEvent> selectionEvent,
final AbstractCanvasHandler canvasHandler,
final String uuid); }
|
CanvasLayoutUtils { public static boolean isCanvasRoot(final Diagram diagram, final Element parent) { return null != parent && isCanvasRoot(diagram, parent.getUUID()); } @Inject CanvasLayoutUtils(final GraphBoundsIndexer graphBoundsIndexer); static boolean isCanvasRoot(final Diagram diagram,
final Element parent); static boolean isCanvasRoot(final Diagram diagram,
final String pUUID); static int getPaddingX(); static int getPaddingY(); @PreDestroy void destroy(); @SuppressWarnings("unchecked") Point2D getNext(final AbstractCanvasHandler canvasHandler,
final Node<View<?>, Edge> root,
final Node<View<?>, Edge> newNode); @SuppressWarnings("unchecked") Point2D getNext(final AbstractCanvasHandler canvasHandler,
final Node<View<?>, Edge> root,
final double rootNodeWidth,
final double rootNodeHeight,
final double newNodeWidth,
final double newNodeHeight,
Point2D offset,
Point2D rootNodeCoordinates
); @SuppressWarnings("unchecked") static Element<? extends Definition<?>> getElement(final AbstractCanvasHandler canvasHandler,
final String uuid); static void fireElementSelectedEvent(final Event<CanvasSelectionEvent> selectionEvent,
final AbstractCanvasHandler canvasHandler,
final String uuid); }
|
@Test public void isCanvasRootFalseTest() { when(diagram.getMetadata().getCanvasRootUUID()).thenReturn("test"); boolean isCanvasRoot = CanvasLayoutUtils.isCanvasRoot(diagram, parentNotCanvasRoot); assertFalse(isCanvasRoot); }
|
public static boolean isCanvasRoot(final Diagram diagram, final Element parent) { return null != parent && isCanvasRoot(diagram, parent.getUUID()); }
|
CanvasLayoutUtils { public static boolean isCanvasRoot(final Diagram diagram, final Element parent) { return null != parent && isCanvasRoot(diagram, parent.getUUID()); } }
|
CanvasLayoutUtils { public static boolean isCanvasRoot(final Diagram diagram, final Element parent) { return null != parent && isCanvasRoot(diagram, parent.getUUID()); } @Inject CanvasLayoutUtils(final GraphBoundsIndexer graphBoundsIndexer); }
|
CanvasLayoutUtils { public static boolean isCanvasRoot(final Diagram diagram, final Element parent) { return null != parent && isCanvasRoot(diagram, parent.getUUID()); } @Inject CanvasLayoutUtils(final GraphBoundsIndexer graphBoundsIndexer); static boolean isCanvasRoot(final Diagram diagram,
final Element parent); static boolean isCanvasRoot(final Diagram diagram,
final String pUUID); static int getPaddingX(); static int getPaddingY(); @PreDestroy void destroy(); @SuppressWarnings("unchecked") Point2D getNext(final AbstractCanvasHandler canvasHandler,
final Node<View<?>, Edge> root,
final Node<View<?>, Edge> newNode); @SuppressWarnings("unchecked") Point2D getNext(final AbstractCanvasHandler canvasHandler,
final Node<View<?>, Edge> root,
final double rootNodeWidth,
final double rootNodeHeight,
final double newNodeWidth,
final double newNodeHeight,
Point2D offset,
Point2D rootNodeCoordinates
); @SuppressWarnings("unchecked") static Element<? extends Definition<?>> getElement(final AbstractCanvasHandler canvasHandler,
final String uuid); static void fireElementSelectedEvent(final Event<CanvasSelectionEvent> selectionEvent,
final AbstractCanvasHandler canvasHandler,
final String uuid); }
|
CanvasLayoutUtils { public static boolean isCanvasRoot(final Diagram diagram, final Element parent) { return null != parent && isCanvasRoot(diagram, parent.getUUID()); } @Inject CanvasLayoutUtils(final GraphBoundsIndexer graphBoundsIndexer); static boolean isCanvasRoot(final Diagram diagram,
final Element parent); static boolean isCanvasRoot(final Diagram diagram,
final String pUUID); static int getPaddingX(); static int getPaddingY(); @PreDestroy void destroy(); @SuppressWarnings("unchecked") Point2D getNext(final AbstractCanvasHandler canvasHandler,
final Node<View<?>, Edge> root,
final Node<View<?>, Edge> newNode); @SuppressWarnings("unchecked") Point2D getNext(final AbstractCanvasHandler canvasHandler,
final Node<View<?>, Edge> root,
final double rootNodeWidth,
final double rootNodeHeight,
final double newNodeWidth,
final double newNodeHeight,
Point2D offset,
Point2D rootNodeCoordinates
); @SuppressWarnings("unchecked") static Element<? extends Definition<?>> getElement(final AbstractCanvasHandler canvasHandler,
final String uuid); static void fireElementSelectedEvent(final Event<CanvasSelectionEvent> selectionEvent,
final AbstractCanvasHandler canvasHandler,
final String uuid); }
|
@Test public void isCanvasRootWithUuidTrueTest() { when(diagram.getMetadata().getCanvasRootUUID()).thenReturn("canvas_root"); boolean isCanvasRoot = CanvasLayoutUtils.isCanvasRoot(diagram, "canvas_root"); assertTrue(isCanvasRoot); }
|
public static boolean isCanvasRoot(final Diagram diagram, final Element parent) { return null != parent && isCanvasRoot(diagram, parent.getUUID()); }
|
CanvasLayoutUtils { public static boolean isCanvasRoot(final Diagram diagram, final Element parent) { return null != parent && isCanvasRoot(diagram, parent.getUUID()); } }
|
CanvasLayoutUtils { public static boolean isCanvasRoot(final Diagram diagram, final Element parent) { return null != parent && isCanvasRoot(diagram, parent.getUUID()); } @Inject CanvasLayoutUtils(final GraphBoundsIndexer graphBoundsIndexer); }
|
CanvasLayoutUtils { public static boolean isCanvasRoot(final Diagram diagram, final Element parent) { return null != parent && isCanvasRoot(diagram, parent.getUUID()); } @Inject CanvasLayoutUtils(final GraphBoundsIndexer graphBoundsIndexer); static boolean isCanvasRoot(final Diagram diagram,
final Element parent); static boolean isCanvasRoot(final Diagram diagram,
final String pUUID); static int getPaddingX(); static int getPaddingY(); @PreDestroy void destroy(); @SuppressWarnings("unchecked") Point2D getNext(final AbstractCanvasHandler canvasHandler,
final Node<View<?>, Edge> root,
final Node<View<?>, Edge> newNode); @SuppressWarnings("unchecked") Point2D getNext(final AbstractCanvasHandler canvasHandler,
final Node<View<?>, Edge> root,
final double rootNodeWidth,
final double rootNodeHeight,
final double newNodeWidth,
final double newNodeHeight,
Point2D offset,
Point2D rootNodeCoordinates
); @SuppressWarnings("unchecked") static Element<? extends Definition<?>> getElement(final AbstractCanvasHandler canvasHandler,
final String uuid); static void fireElementSelectedEvent(final Event<CanvasSelectionEvent> selectionEvent,
final AbstractCanvasHandler canvasHandler,
final String uuid); }
|
CanvasLayoutUtils { public static boolean isCanvasRoot(final Diagram diagram, final Element parent) { return null != parent && isCanvasRoot(diagram, parent.getUUID()); } @Inject CanvasLayoutUtils(final GraphBoundsIndexer graphBoundsIndexer); static boolean isCanvasRoot(final Diagram diagram,
final Element parent); static boolean isCanvasRoot(final Diagram diagram,
final String pUUID); static int getPaddingX(); static int getPaddingY(); @PreDestroy void destroy(); @SuppressWarnings("unchecked") Point2D getNext(final AbstractCanvasHandler canvasHandler,
final Node<View<?>, Edge> root,
final Node<View<?>, Edge> newNode); @SuppressWarnings("unchecked") Point2D getNext(final AbstractCanvasHandler canvasHandler,
final Node<View<?>, Edge> root,
final double rootNodeWidth,
final double rootNodeHeight,
final double newNodeWidth,
final double newNodeHeight,
Point2D offset,
Point2D rootNodeCoordinates
); @SuppressWarnings("unchecked") static Element<? extends Definition<?>> getElement(final AbstractCanvasHandler canvasHandler,
final String uuid); static void fireElementSelectedEvent(final Event<CanvasSelectionEvent> selectionEvent,
final AbstractCanvasHandler canvasHandler,
final String uuid); }
|
@Test public void isCanvasRootWithUuidFalseTest() { when(diagram.getMetadata().getCanvasRootUUID()).thenReturn("test"); boolean isCanvasRoot = CanvasLayoutUtils.isCanvasRoot(diagram, "canvas_root"); assertFalse(isCanvasRoot); }
|
public static boolean isCanvasRoot(final Diagram diagram, final Element parent) { return null != parent && isCanvasRoot(diagram, parent.getUUID()); }
|
CanvasLayoutUtils { public static boolean isCanvasRoot(final Diagram diagram, final Element parent) { return null != parent && isCanvasRoot(diagram, parent.getUUID()); } }
|
CanvasLayoutUtils { public static boolean isCanvasRoot(final Diagram diagram, final Element parent) { return null != parent && isCanvasRoot(diagram, parent.getUUID()); } @Inject CanvasLayoutUtils(final GraphBoundsIndexer graphBoundsIndexer); }
|
CanvasLayoutUtils { public static boolean isCanvasRoot(final Diagram diagram, final Element parent) { return null != parent && isCanvasRoot(diagram, parent.getUUID()); } @Inject CanvasLayoutUtils(final GraphBoundsIndexer graphBoundsIndexer); static boolean isCanvasRoot(final Diagram diagram,
final Element parent); static boolean isCanvasRoot(final Diagram diagram,
final String pUUID); static int getPaddingX(); static int getPaddingY(); @PreDestroy void destroy(); @SuppressWarnings("unchecked") Point2D getNext(final AbstractCanvasHandler canvasHandler,
final Node<View<?>, Edge> root,
final Node<View<?>, Edge> newNode); @SuppressWarnings("unchecked") Point2D getNext(final AbstractCanvasHandler canvasHandler,
final Node<View<?>, Edge> root,
final double rootNodeWidth,
final double rootNodeHeight,
final double newNodeWidth,
final double newNodeHeight,
Point2D offset,
Point2D rootNodeCoordinates
); @SuppressWarnings("unchecked") static Element<? extends Definition<?>> getElement(final AbstractCanvasHandler canvasHandler,
final String uuid); static void fireElementSelectedEvent(final Event<CanvasSelectionEvent> selectionEvent,
final AbstractCanvasHandler canvasHandler,
final String uuid); }
|
CanvasLayoutUtils { public static boolean isCanvasRoot(final Diagram diagram, final Element parent) { return null != parent && isCanvasRoot(diagram, parent.getUUID()); } @Inject CanvasLayoutUtils(final GraphBoundsIndexer graphBoundsIndexer); static boolean isCanvasRoot(final Diagram diagram,
final Element parent); static boolean isCanvasRoot(final Diagram diagram,
final String pUUID); static int getPaddingX(); static int getPaddingY(); @PreDestroy void destroy(); @SuppressWarnings("unchecked") Point2D getNext(final AbstractCanvasHandler canvasHandler,
final Node<View<?>, Edge> root,
final Node<View<?>, Edge> newNode); @SuppressWarnings("unchecked") Point2D getNext(final AbstractCanvasHandler canvasHandler,
final Node<View<?>, Edge> root,
final double rootNodeWidth,
final double rootNodeHeight,
final double newNodeWidth,
final double newNodeHeight,
Point2D offset,
Point2D rootNodeCoordinates
); @SuppressWarnings("unchecked") static Element<? extends Definition<?>> getElement(final AbstractCanvasHandler canvasHandler,
final String uuid); static void fireElementSelectedEvent(final Event<CanvasSelectionEvent> selectionEvent,
final AbstractCanvasHandler canvasHandler,
final String uuid); }
|
@Test @Ignore @SuppressWarnings("unchecked") public void getNextFromRoot() { Node node1 = mock(Node.class); Bounds boundsNode1 = Bounds.create(100d, 100d, 300d, 200d); View viewNode1 = mock(View.class); when(node1.getContent()).thenReturn(viewNode1); when(viewNode1.getBounds()).thenReturn(boundsNode1); Node node2 = mock(Node.class); Bounds boundsNode2 = Bounds.create(100d, 100d, 300d, 200d); View viewNode2 = mock(View.class); when(node2.getContent()).thenReturn(viewNode2); when(viewNode2.getBounds()).thenReturn(boundsNode2); Node nodeRoot = mock(Node.class); double rootWidth = 40d; double rootHeight = 40d; Bounds rootBounds = Bounds.create(0d, 0d, rootWidth, rootHeight); View rootView = mock(View.class); when(nodeRoot.getContent()).thenReturn(rootView); when(rootView.getBounds()).thenReturn(rootBounds); List<Node> nodes = new ArrayList<>(); List<Edge> edges = new ArrayList<>(); Edge edge = mock(Edge.class); edges.add(edge); when(nodeRoot.getOutEdges()).thenReturn(edges); when(edge.getTargetNode()).thenReturn(node1); when(nodeRoot.getContent()).thenReturn(rootView); nodes.add(nodeRoot); when(graph.nodes()).thenReturn(nodes); when(node2.getInEdges()).thenReturn(edges); when(nodeRoot.asNode()).thenReturn(nodeRoot); Point2D next = canvasLayoutUtils.getNext(canvasHandler, nodeRoot, node2); assertTrue(next.getX() > rootWidth); assertTrue(next.getY() > NEW_NODE_HEIGHT); }
|
@SuppressWarnings("unchecked") public Point2D getNext(final AbstractCanvasHandler canvasHandler, final Node<View<?>, Edge> root, final Node<View<?>, Edge> newNode) { final double[] rootBounds = getBoundCoordinates(root); final double[] rootSize = GraphUtils.getNodeSize(root.getContent()); final double[] newNodeSize = GraphUtils.getNodeSize(newNode.getContent()); Point2D[] offset = {new Point2D(PADDING_X, 0)}; Point2D[] parentOffset = {new Point2D(0, 0)}; double maxNodeY[] = {0}; if (root.getOutEdges().size() > 0) { root.getOutEdges().stream() .filter(e -> e.getContent() instanceof ViewConnector) .filter(e -> null != e.getTargetNode() && !e.getTargetNode().equals(newNode)) .forEach(n -> { final Node<View<?>, Edge> node = n.getTargetNode(); final Point2D nodePos = GraphUtils.getPosition(node.getContent()); final Point2D rootPos = GraphUtils.getPosition(root.getContent()); if (nodePos.getY() > maxNodeY[0]) { maxNodeY[0] = nodePos.getY(); final double[] nodeSize = GraphUtils.getNodeSize(node.getContent()); offset[0].setY(maxNodeY[0] + nodeSize[1] - rootPos.getY()); } }); offset[0].setY(offset[0].getY() + parentOffset[0].getY() + PADDING_Y); } else { offset[0].setY(parentOffset[0].getY() - (newNodeSize[1] - rootSize[1]) / 2); } offset[0].setX(offset[0].getX() + PADDING_X); final Point2D offsetCoordinates = new Point2D(offset[0].getX(), offset[0].getY()); final Point2D rootNodeCoordinates = new Point2D(rootBounds[0], rootBounds[1]); return getNext(canvasHandler, root, rootSize[0], rootSize[1], newNodeSize[0], newNodeSize[1], offsetCoordinates, rootNodeCoordinates ); }
|
CanvasLayoutUtils { @SuppressWarnings("unchecked") public Point2D getNext(final AbstractCanvasHandler canvasHandler, final Node<View<?>, Edge> root, final Node<View<?>, Edge> newNode) { final double[] rootBounds = getBoundCoordinates(root); final double[] rootSize = GraphUtils.getNodeSize(root.getContent()); final double[] newNodeSize = GraphUtils.getNodeSize(newNode.getContent()); Point2D[] offset = {new Point2D(PADDING_X, 0)}; Point2D[] parentOffset = {new Point2D(0, 0)}; double maxNodeY[] = {0}; if (root.getOutEdges().size() > 0) { root.getOutEdges().stream() .filter(e -> e.getContent() instanceof ViewConnector) .filter(e -> null != e.getTargetNode() && !e.getTargetNode().equals(newNode)) .forEach(n -> { final Node<View<?>, Edge> node = n.getTargetNode(); final Point2D nodePos = GraphUtils.getPosition(node.getContent()); final Point2D rootPos = GraphUtils.getPosition(root.getContent()); if (nodePos.getY() > maxNodeY[0]) { maxNodeY[0] = nodePos.getY(); final double[] nodeSize = GraphUtils.getNodeSize(node.getContent()); offset[0].setY(maxNodeY[0] + nodeSize[1] - rootPos.getY()); } }); offset[0].setY(offset[0].getY() + parentOffset[0].getY() + PADDING_Y); } else { offset[0].setY(parentOffset[0].getY() - (newNodeSize[1] - rootSize[1]) / 2); } offset[0].setX(offset[0].getX() + PADDING_X); final Point2D offsetCoordinates = new Point2D(offset[0].getX(), offset[0].getY()); final Point2D rootNodeCoordinates = new Point2D(rootBounds[0], rootBounds[1]); return getNext(canvasHandler, root, rootSize[0], rootSize[1], newNodeSize[0], newNodeSize[1], offsetCoordinates, rootNodeCoordinates ); } }
|
CanvasLayoutUtils { @SuppressWarnings("unchecked") public Point2D getNext(final AbstractCanvasHandler canvasHandler, final Node<View<?>, Edge> root, final Node<View<?>, Edge> newNode) { final double[] rootBounds = getBoundCoordinates(root); final double[] rootSize = GraphUtils.getNodeSize(root.getContent()); final double[] newNodeSize = GraphUtils.getNodeSize(newNode.getContent()); Point2D[] offset = {new Point2D(PADDING_X, 0)}; Point2D[] parentOffset = {new Point2D(0, 0)}; double maxNodeY[] = {0}; if (root.getOutEdges().size() > 0) { root.getOutEdges().stream() .filter(e -> e.getContent() instanceof ViewConnector) .filter(e -> null != e.getTargetNode() && !e.getTargetNode().equals(newNode)) .forEach(n -> { final Node<View<?>, Edge> node = n.getTargetNode(); final Point2D nodePos = GraphUtils.getPosition(node.getContent()); final Point2D rootPos = GraphUtils.getPosition(root.getContent()); if (nodePos.getY() > maxNodeY[0]) { maxNodeY[0] = nodePos.getY(); final double[] nodeSize = GraphUtils.getNodeSize(node.getContent()); offset[0].setY(maxNodeY[0] + nodeSize[1] - rootPos.getY()); } }); offset[0].setY(offset[0].getY() + parentOffset[0].getY() + PADDING_Y); } else { offset[0].setY(parentOffset[0].getY() - (newNodeSize[1] - rootSize[1]) / 2); } offset[0].setX(offset[0].getX() + PADDING_X); final Point2D offsetCoordinates = new Point2D(offset[0].getX(), offset[0].getY()); final Point2D rootNodeCoordinates = new Point2D(rootBounds[0], rootBounds[1]); return getNext(canvasHandler, root, rootSize[0], rootSize[1], newNodeSize[0], newNodeSize[1], offsetCoordinates, rootNodeCoordinates ); } @Inject CanvasLayoutUtils(final GraphBoundsIndexer graphBoundsIndexer); }
|
CanvasLayoutUtils { @SuppressWarnings("unchecked") public Point2D getNext(final AbstractCanvasHandler canvasHandler, final Node<View<?>, Edge> root, final Node<View<?>, Edge> newNode) { final double[] rootBounds = getBoundCoordinates(root); final double[] rootSize = GraphUtils.getNodeSize(root.getContent()); final double[] newNodeSize = GraphUtils.getNodeSize(newNode.getContent()); Point2D[] offset = {new Point2D(PADDING_X, 0)}; Point2D[] parentOffset = {new Point2D(0, 0)}; double maxNodeY[] = {0}; if (root.getOutEdges().size() > 0) { root.getOutEdges().stream() .filter(e -> e.getContent() instanceof ViewConnector) .filter(e -> null != e.getTargetNode() && !e.getTargetNode().equals(newNode)) .forEach(n -> { final Node<View<?>, Edge> node = n.getTargetNode(); final Point2D nodePos = GraphUtils.getPosition(node.getContent()); final Point2D rootPos = GraphUtils.getPosition(root.getContent()); if (nodePos.getY() > maxNodeY[0]) { maxNodeY[0] = nodePos.getY(); final double[] nodeSize = GraphUtils.getNodeSize(node.getContent()); offset[0].setY(maxNodeY[0] + nodeSize[1] - rootPos.getY()); } }); offset[0].setY(offset[0].getY() + parentOffset[0].getY() + PADDING_Y); } else { offset[0].setY(parentOffset[0].getY() - (newNodeSize[1] - rootSize[1]) / 2); } offset[0].setX(offset[0].getX() + PADDING_X); final Point2D offsetCoordinates = new Point2D(offset[0].getX(), offset[0].getY()); final Point2D rootNodeCoordinates = new Point2D(rootBounds[0], rootBounds[1]); return getNext(canvasHandler, root, rootSize[0], rootSize[1], newNodeSize[0], newNodeSize[1], offsetCoordinates, rootNodeCoordinates ); } @Inject CanvasLayoutUtils(final GraphBoundsIndexer graphBoundsIndexer); static boolean isCanvasRoot(final Diagram diagram,
final Element parent); static boolean isCanvasRoot(final Diagram diagram,
final String pUUID); static int getPaddingX(); static int getPaddingY(); @PreDestroy void destroy(); @SuppressWarnings("unchecked") Point2D getNext(final AbstractCanvasHandler canvasHandler,
final Node<View<?>, Edge> root,
final Node<View<?>, Edge> newNode); @SuppressWarnings("unchecked") Point2D getNext(final AbstractCanvasHandler canvasHandler,
final Node<View<?>, Edge> root,
final double rootNodeWidth,
final double rootNodeHeight,
final double newNodeWidth,
final double newNodeHeight,
Point2D offset,
Point2D rootNodeCoordinates
); @SuppressWarnings("unchecked") static Element<? extends Definition<?>> getElement(final AbstractCanvasHandler canvasHandler,
final String uuid); static void fireElementSelectedEvent(final Event<CanvasSelectionEvent> selectionEvent,
final AbstractCanvasHandler canvasHandler,
final String uuid); }
|
CanvasLayoutUtils { @SuppressWarnings("unchecked") public Point2D getNext(final AbstractCanvasHandler canvasHandler, final Node<View<?>, Edge> root, final Node<View<?>, Edge> newNode) { final double[] rootBounds = getBoundCoordinates(root); final double[] rootSize = GraphUtils.getNodeSize(root.getContent()); final double[] newNodeSize = GraphUtils.getNodeSize(newNode.getContent()); Point2D[] offset = {new Point2D(PADDING_X, 0)}; Point2D[] parentOffset = {new Point2D(0, 0)}; double maxNodeY[] = {0}; if (root.getOutEdges().size() > 0) { root.getOutEdges().stream() .filter(e -> e.getContent() instanceof ViewConnector) .filter(e -> null != e.getTargetNode() && !e.getTargetNode().equals(newNode)) .forEach(n -> { final Node<View<?>, Edge> node = n.getTargetNode(); final Point2D nodePos = GraphUtils.getPosition(node.getContent()); final Point2D rootPos = GraphUtils.getPosition(root.getContent()); if (nodePos.getY() > maxNodeY[0]) { maxNodeY[0] = nodePos.getY(); final double[] nodeSize = GraphUtils.getNodeSize(node.getContent()); offset[0].setY(maxNodeY[0] + nodeSize[1] - rootPos.getY()); } }); offset[0].setY(offset[0].getY() + parentOffset[0].getY() + PADDING_Y); } else { offset[0].setY(parentOffset[0].getY() - (newNodeSize[1] - rootSize[1]) / 2); } offset[0].setX(offset[0].getX() + PADDING_X); final Point2D offsetCoordinates = new Point2D(offset[0].getX(), offset[0].getY()); final Point2D rootNodeCoordinates = new Point2D(rootBounds[0], rootBounds[1]); return getNext(canvasHandler, root, rootSize[0], rootSize[1], newNodeSize[0], newNodeSize[1], offsetCoordinates, rootNodeCoordinates ); } @Inject CanvasLayoutUtils(final GraphBoundsIndexer graphBoundsIndexer); static boolean isCanvasRoot(final Diagram diagram,
final Element parent); static boolean isCanvasRoot(final Diagram diagram,
final String pUUID); static int getPaddingX(); static int getPaddingY(); @PreDestroy void destroy(); @SuppressWarnings("unchecked") Point2D getNext(final AbstractCanvasHandler canvasHandler,
final Node<View<?>, Edge> root,
final Node<View<?>, Edge> newNode); @SuppressWarnings("unchecked") Point2D getNext(final AbstractCanvasHandler canvasHandler,
final Node<View<?>, Edge> root,
final double rootNodeWidth,
final double rootNodeHeight,
final double newNodeWidth,
final double newNodeHeight,
Point2D offset,
Point2D rootNodeCoordinates
); @SuppressWarnings("unchecked") static Element<? extends Definition<?>> getElement(final AbstractCanvasHandler canvasHandler,
final String uuid); static void fireElementSelectedEvent(final Event<CanvasSelectionEvent> selectionEvent,
final AbstractCanvasHandler canvasHandler,
final String uuid); }
|
@Test public void testGetElementNullCanvasHandlerAndNullUUID() { when(abstractCanvasHandler.getGraphIndex()).thenReturn(graphIndex); assertNull(CanvasLayoutUtils.getElement(null, null)); }
|
@SuppressWarnings("unchecked") public static Element<? extends Definition<?>> getElement(final AbstractCanvasHandler canvasHandler, final String uuid) { if (Objects.isNull(canvasHandler) || Objects.isNull(uuid)) { return null; } final Index<?, ?> index = canvasHandler.getGraphIndex(); if (Objects.isNull(index)) { return null; } return index.get(uuid); }
|
CanvasLayoutUtils { @SuppressWarnings("unchecked") public static Element<? extends Definition<?>> getElement(final AbstractCanvasHandler canvasHandler, final String uuid) { if (Objects.isNull(canvasHandler) || Objects.isNull(uuid)) { return null; } final Index<?, ?> index = canvasHandler.getGraphIndex(); if (Objects.isNull(index)) { return null; } return index.get(uuid); } }
|
CanvasLayoutUtils { @SuppressWarnings("unchecked") public static Element<? extends Definition<?>> getElement(final AbstractCanvasHandler canvasHandler, final String uuid) { if (Objects.isNull(canvasHandler) || Objects.isNull(uuid)) { return null; } final Index<?, ?> index = canvasHandler.getGraphIndex(); if (Objects.isNull(index)) { return null; } return index.get(uuid); } @Inject CanvasLayoutUtils(final GraphBoundsIndexer graphBoundsIndexer); }
|
CanvasLayoutUtils { @SuppressWarnings("unchecked") public static Element<? extends Definition<?>> getElement(final AbstractCanvasHandler canvasHandler, final String uuid) { if (Objects.isNull(canvasHandler) || Objects.isNull(uuid)) { return null; } final Index<?, ?> index = canvasHandler.getGraphIndex(); if (Objects.isNull(index)) { return null; } return index.get(uuid); } @Inject CanvasLayoutUtils(final GraphBoundsIndexer graphBoundsIndexer); static boolean isCanvasRoot(final Diagram diagram,
final Element parent); static boolean isCanvasRoot(final Diagram diagram,
final String pUUID); static int getPaddingX(); static int getPaddingY(); @PreDestroy void destroy(); @SuppressWarnings("unchecked") Point2D getNext(final AbstractCanvasHandler canvasHandler,
final Node<View<?>, Edge> root,
final Node<View<?>, Edge> newNode); @SuppressWarnings("unchecked") Point2D getNext(final AbstractCanvasHandler canvasHandler,
final Node<View<?>, Edge> root,
final double rootNodeWidth,
final double rootNodeHeight,
final double newNodeWidth,
final double newNodeHeight,
Point2D offset,
Point2D rootNodeCoordinates
); @SuppressWarnings("unchecked") static Element<? extends Definition<?>> getElement(final AbstractCanvasHandler canvasHandler,
final String uuid); static void fireElementSelectedEvent(final Event<CanvasSelectionEvent> selectionEvent,
final AbstractCanvasHandler canvasHandler,
final String uuid); }
|
CanvasLayoutUtils { @SuppressWarnings("unchecked") public static Element<? extends Definition<?>> getElement(final AbstractCanvasHandler canvasHandler, final String uuid) { if (Objects.isNull(canvasHandler) || Objects.isNull(uuid)) { return null; } final Index<?, ?> index = canvasHandler.getGraphIndex(); if (Objects.isNull(index)) { return null; } return index.get(uuid); } @Inject CanvasLayoutUtils(final GraphBoundsIndexer graphBoundsIndexer); static boolean isCanvasRoot(final Diagram diagram,
final Element parent); static boolean isCanvasRoot(final Diagram diagram,
final String pUUID); static int getPaddingX(); static int getPaddingY(); @PreDestroy void destroy(); @SuppressWarnings("unchecked") Point2D getNext(final AbstractCanvasHandler canvasHandler,
final Node<View<?>, Edge> root,
final Node<View<?>, Edge> newNode); @SuppressWarnings("unchecked") Point2D getNext(final AbstractCanvasHandler canvasHandler,
final Node<View<?>, Edge> root,
final double rootNodeWidth,
final double rootNodeHeight,
final double newNodeWidth,
final double newNodeHeight,
Point2D offset,
Point2D rootNodeCoordinates
); @SuppressWarnings("unchecked") static Element<? extends Definition<?>> getElement(final AbstractCanvasHandler canvasHandler,
final String uuid); static void fireElementSelectedEvent(final Event<CanvasSelectionEvent> selectionEvent,
final AbstractCanvasHandler canvasHandler,
final String uuid); }
|
@Test public void testRegisterOnCloseHandler() { final EventListener<Event> onKeyDown = (e) -> {}; doReturn(onKeyDown).when(view).onKeyDown(); view.registerOnCloseHandler(); verify(viewElement).addEventListener(KEYDOWN, onKeyDown, false); }
|
void registerOnCloseHandler() { getElement().addEventListener(KEYDOWN, onKeyDown(), false); }
|
ListSelectorViewImpl implements ListSelectorView { void registerOnCloseHandler() { getElement().addEventListener(KEYDOWN, onKeyDown(), false); } }
|
ListSelectorViewImpl implements ListSelectorView { void registerOnCloseHandler() { getElement().addEventListener(KEYDOWN, onKeyDown(), false); } ListSelectorViewImpl(); @Inject ListSelectorViewImpl(final UnorderedList itemsContainer,
final ManagedInstance<ListSelectorTextItemView> listSelectorTextItemViews,
final ManagedInstance<ListSelectorDividerItemView> listSelectorDividerItemViews,
final ManagedInstance<ListSelectorHeaderItemView> listSelectorHeaderItemViews); }
|
ListSelectorViewImpl implements ListSelectorView { void registerOnCloseHandler() { getElement().addEventListener(KEYDOWN, onKeyDown(), false); } ListSelectorViewImpl(); @Inject ListSelectorViewImpl(final UnorderedList itemsContainer,
final ManagedInstance<ListSelectorTextItemView> listSelectorTextItemViews,
final ManagedInstance<ListSelectorDividerItemView> listSelectorDividerItemViews,
final ManagedInstance<ListSelectorHeaderItemView> listSelectorHeaderItemViews); @Override void init(final Presenter presenter); @Override void setItems(final List<ListSelectorItem> items); @Override void show(final Optional<String> title); @Override void hide(); @Override void setOnClosedByKeyboardCallback(final Consumer<CanBeClosedByKeyboard> callback); }
|
ListSelectorViewImpl implements ListSelectorView { void registerOnCloseHandler() { getElement().addEventListener(KEYDOWN, onKeyDown(), false); } ListSelectorViewImpl(); @Inject ListSelectorViewImpl(final UnorderedList itemsContainer,
final ManagedInstance<ListSelectorTextItemView> listSelectorTextItemViews,
final ManagedInstance<ListSelectorDividerItemView> listSelectorDividerItemViews,
final ManagedInstance<ListSelectorHeaderItemView> listSelectorHeaderItemViews); @Override void init(final Presenter presenter); @Override void setItems(final List<ListSelectorItem> items); @Override void show(final Optional<String> title); @Override void hide(); @Override void setOnClosedByKeyboardCallback(final Consumer<CanBeClosedByKeyboard> callback); }
|
@Test public void testGetImportedItemDefinitionsByNamespace() { final WorkspaceProject workspaceProject = mock(WorkspaceProject.class); final String modelName = "model1"; final String namespace = ": final Path path1 = makePath("../file1.dmn"); final Path path2 = makePath("../file2.dmn"); final Path path3 = makePath("../file3.dmn"); final Path path4 = makePath("../file4.dmn"); final InputStream inputStream1 = mock(InputStream.class); final InputStream inputStream2 = mock(InputStream.class); final InputStream inputStream3 = mock(InputStream.class); final InputStreamReader inputStreamReader1 = mock(InputStreamReader.class); final InputStreamReader inputStreamReader2 = mock(InputStreamReader.class); final InputStreamReader inputStreamReader3 = mock(InputStreamReader.class); final Definitions definitions1 = mock(Definitions.class); final Definitions definitions2 = mock(Definitions.class); final Definitions definitions3 = mock(Definitions.class); final ItemDefinition itemDefinition1 = mock(ItemDefinition.class); final ItemDefinition itemDefinition2 = mock(ItemDefinition.class); final List<Path> paths = asList(path1, path2, path3, path4); when(pathsHelper.getDMNModelsPaths(any())).thenReturn(paths); doReturn(Optional.of(inputStream1)).when(helper).loadPath(path1); doReturn(Optional.of(inputStream2)).when(helper).loadPath(path2); doReturn(Optional.of(inputStream3)).when(helper).loadPath(path3); doReturn(inputStreamReader1).when(helper).toInputStreamReader(inputStream1); doReturn(inputStreamReader2).when(helper).toInputStreamReader(inputStream2); doReturn(inputStreamReader3).when(helper).toInputStreamReader(inputStream3); doReturn(Optional.empty()).when(helper).loadPath(path4); when(marshaller.unmarshal(inputStreamReader1)).thenReturn(definitions1); when(marshaller.unmarshal(inputStreamReader2)).thenReturn(definitions2); when(marshaller.unmarshal(inputStreamReader3)).thenReturn(definitions3); when(definitions1.getNamespace()).thenReturn(": when(definitions2.getNamespace()).thenReturn(": when(definitions3.getNamespace()).thenReturn(": when(definitions1.getItemDefinition()).thenReturn(asList(itemDefinition1, itemDefinition2)); final List<ItemDefinition> actualItemDefinitions = helper.getImportedItemDefinitionsByNamespace(workspaceProject, modelName, namespace); final List<ItemDefinition> expectedItemDefinitions = asList(itemDefinition1, itemDefinition2); assertEquals(expectedItemDefinitions, actualItemDefinitions); }
|
@Override public List<ItemDefinition> getImportedItemDefinitionsByNamespace(final WorkspaceProject workspaceProject, final String modelName, final String namespace) { return findDefinitionsByNamespace(workspaceProject, namespace) .map(Definitions::getItemDefinition) .orElse(emptyList()); }
|
DMNMarshallerImportsHelperStandaloneImpl implements DMNMarshallerImportsHelperStandalone { @Override public List<ItemDefinition> getImportedItemDefinitionsByNamespace(final WorkspaceProject workspaceProject, final String modelName, final String namespace) { return findDefinitionsByNamespace(workspaceProject, namespace) .map(Definitions::getItemDefinition) .orElse(emptyList()); } }
|
DMNMarshallerImportsHelperStandaloneImpl implements DMNMarshallerImportsHelperStandalone { @Override public List<ItemDefinition> getImportedItemDefinitionsByNamespace(final WorkspaceProject workspaceProject, final String modelName, final String namespace) { return findDefinitionsByNamespace(workspaceProject, namespace) .map(Definitions::getItemDefinition) .orElse(emptyList()); } 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 List<ItemDefinition> getImportedItemDefinitionsByNamespace(final WorkspaceProject workspaceProject, final String modelName, final String namespace) { return findDefinitionsByNamespace(workspaceProject, namespace) .map(Definitions::getItemDefinition) .orElse(emptyList()); } 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 List<ItemDefinition> getImportedItemDefinitionsByNamespace(final WorkspaceProject workspaceProject, final String modelName, final String namespace) { return findDefinitionsByNamespace(workspaceProject, namespace) .map(Definitions::getItemDefinition) .orElse(emptyList()); } 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 testGetElementNullCanvasHandler() { when(abstractCanvasHandler.getGraphIndex()).thenReturn(graphIndex); assertNull(CanvasLayoutUtils.getElement(null, NODE_UUID)); }
|
@SuppressWarnings("unchecked") public static Element<? extends Definition<?>> getElement(final AbstractCanvasHandler canvasHandler, final String uuid) { if (Objects.isNull(canvasHandler) || Objects.isNull(uuid)) { return null; } final Index<?, ?> index = canvasHandler.getGraphIndex(); if (Objects.isNull(index)) { return null; } return index.get(uuid); }
|
CanvasLayoutUtils { @SuppressWarnings("unchecked") public static Element<? extends Definition<?>> getElement(final AbstractCanvasHandler canvasHandler, final String uuid) { if (Objects.isNull(canvasHandler) || Objects.isNull(uuid)) { return null; } final Index<?, ?> index = canvasHandler.getGraphIndex(); if (Objects.isNull(index)) { return null; } return index.get(uuid); } }
|
CanvasLayoutUtils { @SuppressWarnings("unchecked") public static Element<? extends Definition<?>> getElement(final AbstractCanvasHandler canvasHandler, final String uuid) { if (Objects.isNull(canvasHandler) || Objects.isNull(uuid)) { return null; } final Index<?, ?> index = canvasHandler.getGraphIndex(); if (Objects.isNull(index)) { return null; } return index.get(uuid); } @Inject CanvasLayoutUtils(final GraphBoundsIndexer graphBoundsIndexer); }
|
CanvasLayoutUtils { @SuppressWarnings("unchecked") public static Element<? extends Definition<?>> getElement(final AbstractCanvasHandler canvasHandler, final String uuid) { if (Objects.isNull(canvasHandler) || Objects.isNull(uuid)) { return null; } final Index<?, ?> index = canvasHandler.getGraphIndex(); if (Objects.isNull(index)) { return null; } return index.get(uuid); } @Inject CanvasLayoutUtils(final GraphBoundsIndexer graphBoundsIndexer); static boolean isCanvasRoot(final Diagram diagram,
final Element parent); static boolean isCanvasRoot(final Diagram diagram,
final String pUUID); static int getPaddingX(); static int getPaddingY(); @PreDestroy void destroy(); @SuppressWarnings("unchecked") Point2D getNext(final AbstractCanvasHandler canvasHandler,
final Node<View<?>, Edge> root,
final Node<View<?>, Edge> newNode); @SuppressWarnings("unchecked") Point2D getNext(final AbstractCanvasHandler canvasHandler,
final Node<View<?>, Edge> root,
final double rootNodeWidth,
final double rootNodeHeight,
final double newNodeWidth,
final double newNodeHeight,
Point2D offset,
Point2D rootNodeCoordinates
); @SuppressWarnings("unchecked") static Element<? extends Definition<?>> getElement(final AbstractCanvasHandler canvasHandler,
final String uuid); static void fireElementSelectedEvent(final Event<CanvasSelectionEvent> selectionEvent,
final AbstractCanvasHandler canvasHandler,
final String uuid); }
|
CanvasLayoutUtils { @SuppressWarnings("unchecked") public static Element<? extends Definition<?>> getElement(final AbstractCanvasHandler canvasHandler, final String uuid) { if (Objects.isNull(canvasHandler) || Objects.isNull(uuid)) { return null; } final Index<?, ?> index = canvasHandler.getGraphIndex(); if (Objects.isNull(index)) { return null; } return index.get(uuid); } @Inject CanvasLayoutUtils(final GraphBoundsIndexer graphBoundsIndexer); static boolean isCanvasRoot(final Diagram diagram,
final Element parent); static boolean isCanvasRoot(final Diagram diagram,
final String pUUID); static int getPaddingX(); static int getPaddingY(); @PreDestroy void destroy(); @SuppressWarnings("unchecked") Point2D getNext(final AbstractCanvasHandler canvasHandler,
final Node<View<?>, Edge> root,
final Node<View<?>, Edge> newNode); @SuppressWarnings("unchecked") Point2D getNext(final AbstractCanvasHandler canvasHandler,
final Node<View<?>, Edge> root,
final double rootNodeWidth,
final double rootNodeHeight,
final double newNodeWidth,
final double newNodeHeight,
Point2D offset,
Point2D rootNodeCoordinates
); @SuppressWarnings("unchecked") static Element<? extends Definition<?>> getElement(final AbstractCanvasHandler canvasHandler,
final String uuid); static void fireElementSelectedEvent(final Event<CanvasSelectionEvent> selectionEvent,
final AbstractCanvasHandler canvasHandler,
final String uuid); }
|
@Test public void testGetElementNullUUID() { when(abstractCanvasHandler.getGraphIndex()).thenReturn(graphIndex); assertNull(CanvasLayoutUtils.getElement(abstractCanvasHandler, null)); }
|
@SuppressWarnings("unchecked") public static Element<? extends Definition<?>> getElement(final AbstractCanvasHandler canvasHandler, final String uuid) { if (Objects.isNull(canvasHandler) || Objects.isNull(uuid)) { return null; } final Index<?, ?> index = canvasHandler.getGraphIndex(); if (Objects.isNull(index)) { return null; } return index.get(uuid); }
|
CanvasLayoutUtils { @SuppressWarnings("unchecked") public static Element<? extends Definition<?>> getElement(final AbstractCanvasHandler canvasHandler, final String uuid) { if (Objects.isNull(canvasHandler) || Objects.isNull(uuid)) { return null; } final Index<?, ?> index = canvasHandler.getGraphIndex(); if (Objects.isNull(index)) { return null; } return index.get(uuid); } }
|
CanvasLayoutUtils { @SuppressWarnings("unchecked") public static Element<? extends Definition<?>> getElement(final AbstractCanvasHandler canvasHandler, final String uuid) { if (Objects.isNull(canvasHandler) || Objects.isNull(uuid)) { return null; } final Index<?, ?> index = canvasHandler.getGraphIndex(); if (Objects.isNull(index)) { return null; } return index.get(uuid); } @Inject CanvasLayoutUtils(final GraphBoundsIndexer graphBoundsIndexer); }
|
CanvasLayoutUtils { @SuppressWarnings("unchecked") public static Element<? extends Definition<?>> getElement(final AbstractCanvasHandler canvasHandler, final String uuid) { if (Objects.isNull(canvasHandler) || Objects.isNull(uuid)) { return null; } final Index<?, ?> index = canvasHandler.getGraphIndex(); if (Objects.isNull(index)) { return null; } return index.get(uuid); } @Inject CanvasLayoutUtils(final GraphBoundsIndexer graphBoundsIndexer); static boolean isCanvasRoot(final Diagram diagram,
final Element parent); static boolean isCanvasRoot(final Diagram diagram,
final String pUUID); static int getPaddingX(); static int getPaddingY(); @PreDestroy void destroy(); @SuppressWarnings("unchecked") Point2D getNext(final AbstractCanvasHandler canvasHandler,
final Node<View<?>, Edge> root,
final Node<View<?>, Edge> newNode); @SuppressWarnings("unchecked") Point2D getNext(final AbstractCanvasHandler canvasHandler,
final Node<View<?>, Edge> root,
final double rootNodeWidth,
final double rootNodeHeight,
final double newNodeWidth,
final double newNodeHeight,
Point2D offset,
Point2D rootNodeCoordinates
); @SuppressWarnings("unchecked") static Element<? extends Definition<?>> getElement(final AbstractCanvasHandler canvasHandler,
final String uuid); static void fireElementSelectedEvent(final Event<CanvasSelectionEvent> selectionEvent,
final AbstractCanvasHandler canvasHandler,
final String uuid); }
|
CanvasLayoutUtils { @SuppressWarnings("unchecked") public static Element<? extends Definition<?>> getElement(final AbstractCanvasHandler canvasHandler, final String uuid) { if (Objects.isNull(canvasHandler) || Objects.isNull(uuid)) { return null; } final Index<?, ?> index = canvasHandler.getGraphIndex(); if (Objects.isNull(index)) { return null; } return index.get(uuid); } @Inject CanvasLayoutUtils(final GraphBoundsIndexer graphBoundsIndexer); static boolean isCanvasRoot(final Diagram diagram,
final Element parent); static boolean isCanvasRoot(final Diagram diagram,
final String pUUID); static int getPaddingX(); static int getPaddingY(); @PreDestroy void destroy(); @SuppressWarnings("unchecked") Point2D getNext(final AbstractCanvasHandler canvasHandler,
final Node<View<?>, Edge> root,
final Node<View<?>, Edge> newNode); @SuppressWarnings("unchecked") Point2D getNext(final AbstractCanvasHandler canvasHandler,
final Node<View<?>, Edge> root,
final double rootNodeWidth,
final double rootNodeHeight,
final double newNodeWidth,
final double newNodeHeight,
Point2D offset,
Point2D rootNodeCoordinates
); @SuppressWarnings("unchecked") static Element<? extends Definition<?>> getElement(final AbstractCanvasHandler canvasHandler,
final String uuid); static void fireElementSelectedEvent(final Event<CanvasSelectionEvent> selectionEvent,
final AbstractCanvasHandler canvasHandler,
final String uuid); }
|
@Test public void testGetElementWithNullIndex() { assertNull(CanvasLayoutUtils.getElement(abstractCanvasHandler, NODE_UUID)); }
|
@SuppressWarnings("unchecked") public static Element<? extends Definition<?>> getElement(final AbstractCanvasHandler canvasHandler, final String uuid) { if (Objects.isNull(canvasHandler) || Objects.isNull(uuid)) { return null; } final Index<?, ?> index = canvasHandler.getGraphIndex(); if (Objects.isNull(index)) { return null; } return index.get(uuid); }
|
CanvasLayoutUtils { @SuppressWarnings("unchecked") public static Element<? extends Definition<?>> getElement(final AbstractCanvasHandler canvasHandler, final String uuid) { if (Objects.isNull(canvasHandler) || Objects.isNull(uuid)) { return null; } final Index<?, ?> index = canvasHandler.getGraphIndex(); if (Objects.isNull(index)) { return null; } return index.get(uuid); } }
|
CanvasLayoutUtils { @SuppressWarnings("unchecked") public static Element<? extends Definition<?>> getElement(final AbstractCanvasHandler canvasHandler, final String uuid) { if (Objects.isNull(canvasHandler) || Objects.isNull(uuid)) { return null; } final Index<?, ?> index = canvasHandler.getGraphIndex(); if (Objects.isNull(index)) { return null; } return index.get(uuid); } @Inject CanvasLayoutUtils(final GraphBoundsIndexer graphBoundsIndexer); }
|
CanvasLayoutUtils { @SuppressWarnings("unchecked") public static Element<? extends Definition<?>> getElement(final AbstractCanvasHandler canvasHandler, final String uuid) { if (Objects.isNull(canvasHandler) || Objects.isNull(uuid)) { return null; } final Index<?, ?> index = canvasHandler.getGraphIndex(); if (Objects.isNull(index)) { return null; } return index.get(uuid); } @Inject CanvasLayoutUtils(final GraphBoundsIndexer graphBoundsIndexer); static boolean isCanvasRoot(final Diagram diagram,
final Element parent); static boolean isCanvasRoot(final Diagram diagram,
final String pUUID); static int getPaddingX(); static int getPaddingY(); @PreDestroy void destroy(); @SuppressWarnings("unchecked") Point2D getNext(final AbstractCanvasHandler canvasHandler,
final Node<View<?>, Edge> root,
final Node<View<?>, Edge> newNode); @SuppressWarnings("unchecked") Point2D getNext(final AbstractCanvasHandler canvasHandler,
final Node<View<?>, Edge> root,
final double rootNodeWidth,
final double rootNodeHeight,
final double newNodeWidth,
final double newNodeHeight,
Point2D offset,
Point2D rootNodeCoordinates
); @SuppressWarnings("unchecked") static Element<? extends Definition<?>> getElement(final AbstractCanvasHandler canvasHandler,
final String uuid); static void fireElementSelectedEvent(final Event<CanvasSelectionEvent> selectionEvent,
final AbstractCanvasHandler canvasHandler,
final String uuid); }
|
CanvasLayoutUtils { @SuppressWarnings("unchecked") public static Element<? extends Definition<?>> getElement(final AbstractCanvasHandler canvasHandler, final String uuid) { if (Objects.isNull(canvasHandler) || Objects.isNull(uuid)) { return null; } final Index<?, ?> index = canvasHandler.getGraphIndex(); if (Objects.isNull(index)) { return null; } return index.get(uuid); } @Inject CanvasLayoutUtils(final GraphBoundsIndexer graphBoundsIndexer); static boolean isCanvasRoot(final Diagram diagram,
final Element parent); static boolean isCanvasRoot(final Diagram diagram,
final String pUUID); static int getPaddingX(); static int getPaddingY(); @PreDestroy void destroy(); @SuppressWarnings("unchecked") Point2D getNext(final AbstractCanvasHandler canvasHandler,
final Node<View<?>, Edge> root,
final Node<View<?>, Edge> newNode); @SuppressWarnings("unchecked") Point2D getNext(final AbstractCanvasHandler canvasHandler,
final Node<View<?>, Edge> root,
final double rootNodeWidth,
final double rootNodeHeight,
final double newNodeWidth,
final double newNodeHeight,
Point2D offset,
Point2D rootNodeCoordinates
); @SuppressWarnings("unchecked") static Element<? extends Definition<?>> getElement(final AbstractCanvasHandler canvasHandler,
final String uuid); static void fireElementSelectedEvent(final Event<CanvasSelectionEvent> selectionEvent,
final AbstractCanvasHandler canvasHandler,
final String uuid); }
|
@Test public void testGetElement() { when(abstractCanvasHandler.getGraphIndex()).thenReturn(graphIndex); when(graphIndex.get(NODE_UUID)).thenReturn(nodeRoot); assertEquals(nodeRoot, CanvasLayoutUtils.getElement(abstractCanvasHandler, NODE_UUID)); }
|
@SuppressWarnings("unchecked") public static Element<? extends Definition<?>> getElement(final AbstractCanvasHandler canvasHandler, final String uuid) { if (Objects.isNull(canvasHandler) || Objects.isNull(uuid)) { return null; } final Index<?, ?> index = canvasHandler.getGraphIndex(); if (Objects.isNull(index)) { return null; } return index.get(uuid); }
|
CanvasLayoutUtils { @SuppressWarnings("unchecked") public static Element<? extends Definition<?>> getElement(final AbstractCanvasHandler canvasHandler, final String uuid) { if (Objects.isNull(canvasHandler) || Objects.isNull(uuid)) { return null; } final Index<?, ?> index = canvasHandler.getGraphIndex(); if (Objects.isNull(index)) { return null; } return index.get(uuid); } }
|
CanvasLayoutUtils { @SuppressWarnings("unchecked") public static Element<? extends Definition<?>> getElement(final AbstractCanvasHandler canvasHandler, final String uuid) { if (Objects.isNull(canvasHandler) || Objects.isNull(uuid)) { return null; } final Index<?, ?> index = canvasHandler.getGraphIndex(); if (Objects.isNull(index)) { return null; } return index.get(uuid); } @Inject CanvasLayoutUtils(final GraphBoundsIndexer graphBoundsIndexer); }
|
CanvasLayoutUtils { @SuppressWarnings("unchecked") public static Element<? extends Definition<?>> getElement(final AbstractCanvasHandler canvasHandler, final String uuid) { if (Objects.isNull(canvasHandler) || Objects.isNull(uuid)) { return null; } final Index<?, ?> index = canvasHandler.getGraphIndex(); if (Objects.isNull(index)) { return null; } return index.get(uuid); } @Inject CanvasLayoutUtils(final GraphBoundsIndexer graphBoundsIndexer); static boolean isCanvasRoot(final Diagram diagram,
final Element parent); static boolean isCanvasRoot(final Diagram diagram,
final String pUUID); static int getPaddingX(); static int getPaddingY(); @PreDestroy void destroy(); @SuppressWarnings("unchecked") Point2D getNext(final AbstractCanvasHandler canvasHandler,
final Node<View<?>, Edge> root,
final Node<View<?>, Edge> newNode); @SuppressWarnings("unchecked") Point2D getNext(final AbstractCanvasHandler canvasHandler,
final Node<View<?>, Edge> root,
final double rootNodeWidth,
final double rootNodeHeight,
final double newNodeWidth,
final double newNodeHeight,
Point2D offset,
Point2D rootNodeCoordinates
); @SuppressWarnings("unchecked") static Element<? extends Definition<?>> getElement(final AbstractCanvasHandler canvasHandler,
final String uuid); static void fireElementSelectedEvent(final Event<CanvasSelectionEvent> selectionEvent,
final AbstractCanvasHandler canvasHandler,
final String uuid); }
|
CanvasLayoutUtils { @SuppressWarnings("unchecked") public static Element<? extends Definition<?>> getElement(final AbstractCanvasHandler canvasHandler, final String uuid) { if (Objects.isNull(canvasHandler) || Objects.isNull(uuid)) { return null; } final Index<?, ?> index = canvasHandler.getGraphIndex(); if (Objects.isNull(index)) { return null; } return index.get(uuid); } @Inject CanvasLayoutUtils(final GraphBoundsIndexer graphBoundsIndexer); static boolean isCanvasRoot(final Diagram diagram,
final Element parent); static boolean isCanvasRoot(final Diagram diagram,
final String pUUID); static int getPaddingX(); static int getPaddingY(); @PreDestroy void destroy(); @SuppressWarnings("unchecked") Point2D getNext(final AbstractCanvasHandler canvasHandler,
final Node<View<?>, Edge> root,
final Node<View<?>, Edge> newNode); @SuppressWarnings("unchecked") Point2D getNext(final AbstractCanvasHandler canvasHandler,
final Node<View<?>, Edge> root,
final double rootNodeWidth,
final double rootNodeHeight,
final double newNodeWidth,
final double newNodeHeight,
Point2D offset,
Point2D rootNodeCoordinates
); @SuppressWarnings("unchecked") static Element<? extends Definition<?>> getElement(final AbstractCanvasHandler canvasHandler,
final String uuid); static void fireElementSelectedEvent(final Event<CanvasSelectionEvent> selectionEvent,
final AbstractCanvasHandler canvasHandler,
final String uuid); }
|
@Test @SuppressWarnings("unchecked") public void testAddChildShape() { tested.addChild(parentShape, childShape); verify(canvasView, times(1)).addChild(eq(parentShapeView), eq(childShapeView)); }
|
protected abstract void addChild(final Shape shape);
|
AbstractCanvas implements Canvas<Shape>,
HasEventHandlers<AbstractCanvas<V>, Shape<?>>,
HasCanvasListeners<CanvasShapeListener> { protected abstract void addChild(final Shape shape); }
|
AbstractCanvas implements Canvas<Shape>,
HasEventHandlers<AbstractCanvas<V>, Shape<?>>,
HasCanvasListeners<CanvasShapeListener> { protected abstract void addChild(final Shape shape); protected AbstractCanvas(final Event<CanvasClearEvent> canvasClearEvent,
final Event<CanvasShapeAddedEvent> canvasShapeAddedEvent,
final Event<CanvasShapeRemovedEvent> canvasShapeRemovedEvent,
final Event<CanvasDrawnEvent> canvasDrawnEvent,
final Event<CanvasFocusedEvent> canvasFocusedEvent); }
|
AbstractCanvas implements Canvas<Shape>,
HasEventHandlers<AbstractCanvas<V>, Shape<?>>,
HasCanvasListeners<CanvasShapeListener> { protected abstract void addChild(final Shape shape); protected AbstractCanvas(final Event<CanvasClearEvent> canvasClearEvent,
final Event<CanvasShapeAddedEvent> canvasShapeAddedEvent,
final Event<CanvasShapeRemovedEvent> canvasShapeRemovedEvent,
final Event<CanvasDrawnEvent> canvasDrawnEvent,
final Event<CanvasFocusedEvent> canvasFocusedEvent); abstract V getView(); AbstractCanvas<V> initialize(final CanvasPanel panel,
final CanvasSettings settings); @Override Collection<Shape> getShapes(); Shape getShape(final String uuid); @SuppressWarnings("unchecked") Canvas addChild(final Shape parent,
final Shape child); @SuppressWarnings("unchecked") Canvas deleteChild(final Shape parent,
final Shape child); @SuppressWarnings("unchecked") Canvas dock(final Shape parent,
final Shape child); @SuppressWarnings("unchecked") Canvas undock(final Shape target,
final Shape child); @Override Canvas addShape(final Shape shape); @Override Canvas deleteShape(final Shape shape); @SuppressWarnings("unchecked") Canvas addShapeIntoView(final Shape shape); @SuppressWarnings("unchecked") Canvas deleteShapeFromView(final Shape shape); AbstractCanvas clear(); Canvas setGrid(final CanvasGrid grid); CanvasGrid getGrid(); Point2D getAbsoluteLocation(); @Override Transform getTransform(); @Override void destroy(); @Override HasCanvasListeners<CanvasShapeListener> addRegistrationListener(final CanvasShapeListener instance); @Override HasCanvasListeners<CanvasShapeListener> removeRegistrationListener(final CanvasShapeListener instance); @Override HasCanvasListeners<CanvasShapeListener> clearRegistrationListeners(); @Override int getWidthPx(); @Override int getHeightPx(); @Override boolean equals(final Object o); @Override int hashCode(); }
|
AbstractCanvas implements Canvas<Shape>,
HasEventHandlers<AbstractCanvas<V>, Shape<?>>,
HasCanvasListeners<CanvasShapeListener> { protected abstract void addChild(final Shape shape); protected AbstractCanvas(final Event<CanvasClearEvent> canvasClearEvent,
final Event<CanvasShapeAddedEvent> canvasShapeAddedEvent,
final Event<CanvasShapeRemovedEvent> canvasShapeRemovedEvent,
final Event<CanvasDrawnEvent> canvasDrawnEvent,
final Event<CanvasFocusedEvent> canvasFocusedEvent); abstract V getView(); AbstractCanvas<V> initialize(final CanvasPanel panel,
final CanvasSettings settings); @Override Collection<Shape> getShapes(); Shape getShape(final String uuid); @SuppressWarnings("unchecked") Canvas addChild(final Shape parent,
final Shape child); @SuppressWarnings("unchecked") Canvas deleteChild(final Shape parent,
final Shape child); @SuppressWarnings("unchecked") Canvas dock(final Shape parent,
final Shape child); @SuppressWarnings("unchecked") Canvas undock(final Shape target,
final Shape child); @Override Canvas addShape(final Shape shape); @Override Canvas deleteShape(final Shape shape); @SuppressWarnings("unchecked") Canvas addShapeIntoView(final Shape shape); @SuppressWarnings("unchecked") Canvas deleteShapeFromView(final Shape shape); AbstractCanvas clear(); Canvas setGrid(final CanvasGrid grid); CanvasGrid getGrid(); Point2D getAbsoluteLocation(); @Override Transform getTransform(); @Override void destroy(); @Override HasCanvasListeners<CanvasShapeListener> addRegistrationListener(final CanvasShapeListener instance); @Override HasCanvasListeners<CanvasShapeListener> removeRegistrationListener(final CanvasShapeListener instance); @Override HasCanvasListeners<CanvasShapeListener> clearRegistrationListeners(); @Override int getWidthPx(); @Override int getHeightPx(); @Override boolean equals(final Object o); @Override int hashCode(); }
|
@Test @SuppressWarnings("unchecked") public void testDeleteChildShape() { tested.deleteChild(parentShape, childShape); verify(canvasView, times(1)).deleteChild(eq(parentShapeView), eq(childShapeView)); }
|
protected abstract void deleteChild(final Shape shape);
|
AbstractCanvas implements Canvas<Shape>,
HasEventHandlers<AbstractCanvas<V>, Shape<?>>,
HasCanvasListeners<CanvasShapeListener> { protected abstract void deleteChild(final Shape shape); }
|
AbstractCanvas implements Canvas<Shape>,
HasEventHandlers<AbstractCanvas<V>, Shape<?>>,
HasCanvasListeners<CanvasShapeListener> { protected abstract void deleteChild(final Shape shape); protected AbstractCanvas(final Event<CanvasClearEvent> canvasClearEvent,
final Event<CanvasShapeAddedEvent> canvasShapeAddedEvent,
final Event<CanvasShapeRemovedEvent> canvasShapeRemovedEvent,
final Event<CanvasDrawnEvent> canvasDrawnEvent,
final Event<CanvasFocusedEvent> canvasFocusedEvent); }
|
AbstractCanvas implements Canvas<Shape>,
HasEventHandlers<AbstractCanvas<V>, Shape<?>>,
HasCanvasListeners<CanvasShapeListener> { protected abstract void deleteChild(final Shape shape); protected AbstractCanvas(final Event<CanvasClearEvent> canvasClearEvent,
final Event<CanvasShapeAddedEvent> canvasShapeAddedEvent,
final Event<CanvasShapeRemovedEvent> canvasShapeRemovedEvent,
final Event<CanvasDrawnEvent> canvasDrawnEvent,
final Event<CanvasFocusedEvent> canvasFocusedEvent); abstract V getView(); AbstractCanvas<V> initialize(final CanvasPanel panel,
final CanvasSettings settings); @Override Collection<Shape> getShapes(); Shape getShape(final String uuid); @SuppressWarnings("unchecked") Canvas addChild(final Shape parent,
final Shape child); @SuppressWarnings("unchecked") Canvas deleteChild(final Shape parent,
final Shape child); @SuppressWarnings("unchecked") Canvas dock(final Shape parent,
final Shape child); @SuppressWarnings("unchecked") Canvas undock(final Shape target,
final Shape child); @Override Canvas addShape(final Shape shape); @Override Canvas deleteShape(final Shape shape); @SuppressWarnings("unchecked") Canvas addShapeIntoView(final Shape shape); @SuppressWarnings("unchecked") Canvas deleteShapeFromView(final Shape shape); AbstractCanvas clear(); Canvas setGrid(final CanvasGrid grid); CanvasGrid getGrid(); Point2D getAbsoluteLocation(); @Override Transform getTransform(); @Override void destroy(); @Override HasCanvasListeners<CanvasShapeListener> addRegistrationListener(final CanvasShapeListener instance); @Override HasCanvasListeners<CanvasShapeListener> removeRegistrationListener(final CanvasShapeListener instance); @Override HasCanvasListeners<CanvasShapeListener> clearRegistrationListeners(); @Override int getWidthPx(); @Override int getHeightPx(); @Override boolean equals(final Object o); @Override int hashCode(); }
|
AbstractCanvas implements Canvas<Shape>,
HasEventHandlers<AbstractCanvas<V>, Shape<?>>,
HasCanvasListeners<CanvasShapeListener> { protected abstract void deleteChild(final Shape shape); protected AbstractCanvas(final Event<CanvasClearEvent> canvasClearEvent,
final Event<CanvasShapeAddedEvent> canvasShapeAddedEvent,
final Event<CanvasShapeRemovedEvent> canvasShapeRemovedEvent,
final Event<CanvasDrawnEvent> canvasDrawnEvent,
final Event<CanvasFocusedEvent> canvasFocusedEvent); abstract V getView(); AbstractCanvas<V> initialize(final CanvasPanel panel,
final CanvasSettings settings); @Override Collection<Shape> getShapes(); Shape getShape(final String uuid); @SuppressWarnings("unchecked") Canvas addChild(final Shape parent,
final Shape child); @SuppressWarnings("unchecked") Canvas deleteChild(final Shape parent,
final Shape child); @SuppressWarnings("unchecked") Canvas dock(final Shape parent,
final Shape child); @SuppressWarnings("unchecked") Canvas undock(final Shape target,
final Shape child); @Override Canvas addShape(final Shape shape); @Override Canvas deleteShape(final Shape shape); @SuppressWarnings("unchecked") Canvas addShapeIntoView(final Shape shape); @SuppressWarnings("unchecked") Canvas deleteShapeFromView(final Shape shape); AbstractCanvas clear(); Canvas setGrid(final CanvasGrid grid); CanvasGrid getGrid(); Point2D getAbsoluteLocation(); @Override Transform getTransform(); @Override void destroy(); @Override HasCanvasListeners<CanvasShapeListener> addRegistrationListener(final CanvasShapeListener instance); @Override HasCanvasListeners<CanvasShapeListener> removeRegistrationListener(final CanvasShapeListener instance); @Override HasCanvasListeners<CanvasShapeListener> clearRegistrationListeners(); @Override int getWidthPx(); @Override int getHeightPx(); @Override boolean equals(final Object o); @Override int hashCode(); }
|
@Test @SuppressWarnings("unchecked") public void testDock() { tested.dock(parentShape, childShape); verify(canvasView, times(1)).dock(eq(parentShapeView), eq(childShapeView)); }
|
@SuppressWarnings("unchecked") public Canvas dock(final Shape parent, final Shape child) { getView().dock(parent.getShapeView(), child.getShapeView()); return this; }
|
AbstractCanvas implements Canvas<Shape>,
HasEventHandlers<AbstractCanvas<V>, Shape<?>>,
HasCanvasListeners<CanvasShapeListener> { @SuppressWarnings("unchecked") public Canvas dock(final Shape parent, final Shape child) { getView().dock(parent.getShapeView(), child.getShapeView()); return this; } }
|
AbstractCanvas implements Canvas<Shape>,
HasEventHandlers<AbstractCanvas<V>, Shape<?>>,
HasCanvasListeners<CanvasShapeListener> { @SuppressWarnings("unchecked") public Canvas dock(final Shape parent, final Shape child) { getView().dock(parent.getShapeView(), child.getShapeView()); return this; } protected AbstractCanvas(final Event<CanvasClearEvent> canvasClearEvent,
final Event<CanvasShapeAddedEvent> canvasShapeAddedEvent,
final Event<CanvasShapeRemovedEvent> canvasShapeRemovedEvent,
final Event<CanvasDrawnEvent> canvasDrawnEvent,
final Event<CanvasFocusedEvent> canvasFocusedEvent); }
|
AbstractCanvas implements Canvas<Shape>,
HasEventHandlers<AbstractCanvas<V>, Shape<?>>,
HasCanvasListeners<CanvasShapeListener> { @SuppressWarnings("unchecked") public Canvas dock(final Shape parent, final Shape child) { getView().dock(parent.getShapeView(), child.getShapeView()); return this; } protected AbstractCanvas(final Event<CanvasClearEvent> canvasClearEvent,
final Event<CanvasShapeAddedEvent> canvasShapeAddedEvent,
final Event<CanvasShapeRemovedEvent> canvasShapeRemovedEvent,
final Event<CanvasDrawnEvent> canvasDrawnEvent,
final Event<CanvasFocusedEvent> canvasFocusedEvent); abstract V getView(); AbstractCanvas<V> initialize(final CanvasPanel panel,
final CanvasSettings settings); @Override Collection<Shape> getShapes(); Shape getShape(final String uuid); @SuppressWarnings("unchecked") Canvas addChild(final Shape parent,
final Shape child); @SuppressWarnings("unchecked") Canvas deleteChild(final Shape parent,
final Shape child); @SuppressWarnings("unchecked") Canvas dock(final Shape parent,
final Shape child); @SuppressWarnings("unchecked") Canvas undock(final Shape target,
final Shape child); @Override Canvas addShape(final Shape shape); @Override Canvas deleteShape(final Shape shape); @SuppressWarnings("unchecked") Canvas addShapeIntoView(final Shape shape); @SuppressWarnings("unchecked") Canvas deleteShapeFromView(final Shape shape); AbstractCanvas clear(); Canvas setGrid(final CanvasGrid grid); CanvasGrid getGrid(); Point2D getAbsoluteLocation(); @Override Transform getTransform(); @Override void destroy(); @Override HasCanvasListeners<CanvasShapeListener> addRegistrationListener(final CanvasShapeListener instance); @Override HasCanvasListeners<CanvasShapeListener> removeRegistrationListener(final CanvasShapeListener instance); @Override HasCanvasListeners<CanvasShapeListener> clearRegistrationListeners(); @Override int getWidthPx(); @Override int getHeightPx(); @Override boolean equals(final Object o); @Override int hashCode(); }
|
AbstractCanvas implements Canvas<Shape>,
HasEventHandlers<AbstractCanvas<V>, Shape<?>>,
HasCanvasListeners<CanvasShapeListener> { @SuppressWarnings("unchecked") public Canvas dock(final Shape parent, final Shape child) { getView().dock(parent.getShapeView(), child.getShapeView()); return this; } protected AbstractCanvas(final Event<CanvasClearEvent> canvasClearEvent,
final Event<CanvasShapeAddedEvent> canvasShapeAddedEvent,
final Event<CanvasShapeRemovedEvent> canvasShapeRemovedEvent,
final Event<CanvasDrawnEvent> canvasDrawnEvent,
final Event<CanvasFocusedEvent> canvasFocusedEvent); abstract V getView(); AbstractCanvas<V> initialize(final CanvasPanel panel,
final CanvasSettings settings); @Override Collection<Shape> getShapes(); Shape getShape(final String uuid); @SuppressWarnings("unchecked") Canvas addChild(final Shape parent,
final Shape child); @SuppressWarnings("unchecked") Canvas deleteChild(final Shape parent,
final Shape child); @SuppressWarnings("unchecked") Canvas dock(final Shape parent,
final Shape child); @SuppressWarnings("unchecked") Canvas undock(final Shape target,
final Shape child); @Override Canvas addShape(final Shape shape); @Override Canvas deleteShape(final Shape shape); @SuppressWarnings("unchecked") Canvas addShapeIntoView(final Shape shape); @SuppressWarnings("unchecked") Canvas deleteShapeFromView(final Shape shape); AbstractCanvas clear(); Canvas setGrid(final CanvasGrid grid); CanvasGrid getGrid(); Point2D getAbsoluteLocation(); @Override Transform getTransform(); @Override void destroy(); @Override HasCanvasListeners<CanvasShapeListener> addRegistrationListener(final CanvasShapeListener instance); @Override HasCanvasListeners<CanvasShapeListener> removeRegistrationListener(final CanvasShapeListener instance); @Override HasCanvasListeners<CanvasShapeListener> clearRegistrationListeners(); @Override int getWidthPx(); @Override int getHeightPx(); @Override boolean equals(final Object o); @Override int hashCode(); }
|
@Test @SuppressWarnings("unchecked") public void testUndock() { tested.undock(parentShape, childShape); verify(canvasView, times(1)).undock(eq(parentShapeView), eq(childShapeView)); }
|
@SuppressWarnings("unchecked") public Canvas undock(final Shape target, final Shape child) { getView().undock(target.getShapeView(), child.getShapeView()); return this; }
|
AbstractCanvas implements Canvas<Shape>,
HasEventHandlers<AbstractCanvas<V>, Shape<?>>,
HasCanvasListeners<CanvasShapeListener> { @SuppressWarnings("unchecked") public Canvas undock(final Shape target, final Shape child) { getView().undock(target.getShapeView(), child.getShapeView()); return this; } }
|
AbstractCanvas implements Canvas<Shape>,
HasEventHandlers<AbstractCanvas<V>, Shape<?>>,
HasCanvasListeners<CanvasShapeListener> { @SuppressWarnings("unchecked") public Canvas undock(final Shape target, final Shape child) { getView().undock(target.getShapeView(), child.getShapeView()); return this; } protected AbstractCanvas(final Event<CanvasClearEvent> canvasClearEvent,
final Event<CanvasShapeAddedEvent> canvasShapeAddedEvent,
final Event<CanvasShapeRemovedEvent> canvasShapeRemovedEvent,
final Event<CanvasDrawnEvent> canvasDrawnEvent,
final Event<CanvasFocusedEvent> canvasFocusedEvent); }
|
AbstractCanvas implements Canvas<Shape>,
HasEventHandlers<AbstractCanvas<V>, Shape<?>>,
HasCanvasListeners<CanvasShapeListener> { @SuppressWarnings("unchecked") public Canvas undock(final Shape target, final Shape child) { getView().undock(target.getShapeView(), child.getShapeView()); return this; } protected AbstractCanvas(final Event<CanvasClearEvent> canvasClearEvent,
final Event<CanvasShapeAddedEvent> canvasShapeAddedEvent,
final Event<CanvasShapeRemovedEvent> canvasShapeRemovedEvent,
final Event<CanvasDrawnEvent> canvasDrawnEvent,
final Event<CanvasFocusedEvent> canvasFocusedEvent); abstract V getView(); AbstractCanvas<V> initialize(final CanvasPanel panel,
final CanvasSettings settings); @Override Collection<Shape> getShapes(); Shape getShape(final String uuid); @SuppressWarnings("unchecked") Canvas addChild(final Shape parent,
final Shape child); @SuppressWarnings("unchecked") Canvas deleteChild(final Shape parent,
final Shape child); @SuppressWarnings("unchecked") Canvas dock(final Shape parent,
final Shape child); @SuppressWarnings("unchecked") Canvas undock(final Shape target,
final Shape child); @Override Canvas addShape(final Shape shape); @Override Canvas deleteShape(final Shape shape); @SuppressWarnings("unchecked") Canvas addShapeIntoView(final Shape shape); @SuppressWarnings("unchecked") Canvas deleteShapeFromView(final Shape shape); AbstractCanvas clear(); Canvas setGrid(final CanvasGrid grid); CanvasGrid getGrid(); Point2D getAbsoluteLocation(); @Override Transform getTransform(); @Override void destroy(); @Override HasCanvasListeners<CanvasShapeListener> addRegistrationListener(final CanvasShapeListener instance); @Override HasCanvasListeners<CanvasShapeListener> removeRegistrationListener(final CanvasShapeListener instance); @Override HasCanvasListeners<CanvasShapeListener> clearRegistrationListeners(); @Override int getWidthPx(); @Override int getHeightPx(); @Override boolean equals(final Object o); @Override int hashCode(); }
|
AbstractCanvas implements Canvas<Shape>,
HasEventHandlers<AbstractCanvas<V>, Shape<?>>,
HasCanvasListeners<CanvasShapeListener> { @SuppressWarnings("unchecked") public Canvas undock(final Shape target, final Shape child) { getView().undock(target.getShapeView(), child.getShapeView()); return this; } protected AbstractCanvas(final Event<CanvasClearEvent> canvasClearEvent,
final Event<CanvasShapeAddedEvent> canvasShapeAddedEvent,
final Event<CanvasShapeRemovedEvent> canvasShapeRemovedEvent,
final Event<CanvasDrawnEvent> canvasDrawnEvent,
final Event<CanvasFocusedEvent> canvasFocusedEvent); abstract V getView(); AbstractCanvas<V> initialize(final CanvasPanel panel,
final CanvasSettings settings); @Override Collection<Shape> getShapes(); Shape getShape(final String uuid); @SuppressWarnings("unchecked") Canvas addChild(final Shape parent,
final Shape child); @SuppressWarnings("unchecked") Canvas deleteChild(final Shape parent,
final Shape child); @SuppressWarnings("unchecked") Canvas dock(final Shape parent,
final Shape child); @SuppressWarnings("unchecked") Canvas undock(final Shape target,
final Shape child); @Override Canvas addShape(final Shape shape); @Override Canvas deleteShape(final Shape shape); @SuppressWarnings("unchecked") Canvas addShapeIntoView(final Shape shape); @SuppressWarnings("unchecked") Canvas deleteShapeFromView(final Shape shape); AbstractCanvas clear(); Canvas setGrid(final CanvasGrid grid); CanvasGrid getGrid(); Point2D getAbsoluteLocation(); @Override Transform getTransform(); @Override void destroy(); @Override HasCanvasListeners<CanvasShapeListener> addRegistrationListener(final CanvasShapeListener instance); @Override HasCanvasListeners<CanvasShapeListener> removeRegistrationListener(final CanvasShapeListener instance); @Override HasCanvasListeners<CanvasShapeListener> clearRegistrationListeners(); @Override int getWidthPx(); @Override int getHeightPx(); @Override boolean equals(final Object o); @Override int hashCode(); }
|
@Test @SuppressWarnings("unchecked") public void testUndockToLayer() { tested.undock(parentShape, childShape); verify(canvasView, times(1)).undock(eq(parentShapeView), eq(childShapeView)); }
|
@SuppressWarnings("unchecked") public Canvas undock(final Shape target, final Shape child) { getView().undock(target.getShapeView(), child.getShapeView()); return this; }
|
AbstractCanvas implements Canvas<Shape>,
HasEventHandlers<AbstractCanvas<V>, Shape<?>>,
HasCanvasListeners<CanvasShapeListener> { @SuppressWarnings("unchecked") public Canvas undock(final Shape target, final Shape child) { getView().undock(target.getShapeView(), child.getShapeView()); return this; } }
|
AbstractCanvas implements Canvas<Shape>,
HasEventHandlers<AbstractCanvas<V>, Shape<?>>,
HasCanvasListeners<CanvasShapeListener> { @SuppressWarnings("unchecked") public Canvas undock(final Shape target, final Shape child) { getView().undock(target.getShapeView(), child.getShapeView()); return this; } protected AbstractCanvas(final Event<CanvasClearEvent> canvasClearEvent,
final Event<CanvasShapeAddedEvent> canvasShapeAddedEvent,
final Event<CanvasShapeRemovedEvent> canvasShapeRemovedEvent,
final Event<CanvasDrawnEvent> canvasDrawnEvent,
final Event<CanvasFocusedEvent> canvasFocusedEvent); }
|
AbstractCanvas implements Canvas<Shape>,
HasEventHandlers<AbstractCanvas<V>, Shape<?>>,
HasCanvasListeners<CanvasShapeListener> { @SuppressWarnings("unchecked") public Canvas undock(final Shape target, final Shape child) { getView().undock(target.getShapeView(), child.getShapeView()); return this; } protected AbstractCanvas(final Event<CanvasClearEvent> canvasClearEvent,
final Event<CanvasShapeAddedEvent> canvasShapeAddedEvent,
final Event<CanvasShapeRemovedEvent> canvasShapeRemovedEvent,
final Event<CanvasDrawnEvent> canvasDrawnEvent,
final Event<CanvasFocusedEvent> canvasFocusedEvent); abstract V getView(); AbstractCanvas<V> initialize(final CanvasPanel panel,
final CanvasSettings settings); @Override Collection<Shape> getShapes(); Shape getShape(final String uuid); @SuppressWarnings("unchecked") Canvas addChild(final Shape parent,
final Shape child); @SuppressWarnings("unchecked") Canvas deleteChild(final Shape parent,
final Shape child); @SuppressWarnings("unchecked") Canvas dock(final Shape parent,
final Shape child); @SuppressWarnings("unchecked") Canvas undock(final Shape target,
final Shape child); @Override Canvas addShape(final Shape shape); @Override Canvas deleteShape(final Shape shape); @SuppressWarnings("unchecked") Canvas addShapeIntoView(final Shape shape); @SuppressWarnings("unchecked") Canvas deleteShapeFromView(final Shape shape); AbstractCanvas clear(); Canvas setGrid(final CanvasGrid grid); CanvasGrid getGrid(); Point2D getAbsoluteLocation(); @Override Transform getTransform(); @Override void destroy(); @Override HasCanvasListeners<CanvasShapeListener> addRegistrationListener(final CanvasShapeListener instance); @Override HasCanvasListeners<CanvasShapeListener> removeRegistrationListener(final CanvasShapeListener instance); @Override HasCanvasListeners<CanvasShapeListener> clearRegistrationListeners(); @Override int getWidthPx(); @Override int getHeightPx(); @Override boolean equals(final Object o); @Override int hashCode(); }
|
AbstractCanvas implements Canvas<Shape>,
HasEventHandlers<AbstractCanvas<V>, Shape<?>>,
HasCanvasListeners<CanvasShapeListener> { @SuppressWarnings("unchecked") public Canvas undock(final Shape target, final Shape child) { getView().undock(target.getShapeView(), child.getShapeView()); return this; } protected AbstractCanvas(final Event<CanvasClearEvent> canvasClearEvent,
final Event<CanvasShapeAddedEvent> canvasShapeAddedEvent,
final Event<CanvasShapeRemovedEvent> canvasShapeRemovedEvent,
final Event<CanvasDrawnEvent> canvasDrawnEvent,
final Event<CanvasFocusedEvent> canvasFocusedEvent); abstract V getView(); AbstractCanvas<V> initialize(final CanvasPanel panel,
final CanvasSettings settings); @Override Collection<Shape> getShapes(); Shape getShape(final String uuid); @SuppressWarnings("unchecked") Canvas addChild(final Shape parent,
final Shape child); @SuppressWarnings("unchecked") Canvas deleteChild(final Shape parent,
final Shape child); @SuppressWarnings("unchecked") Canvas dock(final Shape parent,
final Shape child); @SuppressWarnings("unchecked") Canvas undock(final Shape target,
final Shape child); @Override Canvas addShape(final Shape shape); @Override Canvas deleteShape(final Shape shape); @SuppressWarnings("unchecked") Canvas addShapeIntoView(final Shape shape); @SuppressWarnings("unchecked") Canvas deleteShapeFromView(final Shape shape); AbstractCanvas clear(); Canvas setGrid(final CanvasGrid grid); CanvasGrid getGrid(); Point2D getAbsoluteLocation(); @Override Transform getTransform(); @Override void destroy(); @Override HasCanvasListeners<CanvasShapeListener> addRegistrationListener(final CanvasShapeListener instance); @Override HasCanvasListeners<CanvasShapeListener> removeRegistrationListener(final CanvasShapeListener instance); @Override HasCanvasListeners<CanvasShapeListener> clearRegistrationListeners(); @Override int getWidthPx(); @Override int getHeightPx(); @Override boolean equals(final Object o); @Override int hashCode(); }
|
@Test @SuppressWarnings("unchecked") public void testAddShape() { tested.addShape(parentShape); verify(canvasView, times(1)).add(eq(parentShapeView)); verify(parentShapeView, never()).setUUID(anyString()); assertEquals(1, tested.getShapes().size()); }
|
@Override public Canvas addShape(final Shape shape) { shapes.computeIfAbsent(shape.getUUID(), (v) -> { addShapeIntoView(shape); fireCanvasShapeAdded(shape); canvasShapeAddedEvent.fire(new CanvasShapeAddedEvent(this, shape)); return shape; }); return this; }
|
AbstractCanvas implements Canvas<Shape>,
HasEventHandlers<AbstractCanvas<V>, Shape<?>>,
HasCanvasListeners<CanvasShapeListener> { @Override public Canvas addShape(final Shape shape) { shapes.computeIfAbsent(shape.getUUID(), (v) -> { addShapeIntoView(shape); fireCanvasShapeAdded(shape); canvasShapeAddedEvent.fire(new CanvasShapeAddedEvent(this, shape)); return shape; }); return this; } }
|
AbstractCanvas implements Canvas<Shape>,
HasEventHandlers<AbstractCanvas<V>, Shape<?>>,
HasCanvasListeners<CanvasShapeListener> { @Override public Canvas addShape(final Shape shape) { shapes.computeIfAbsent(shape.getUUID(), (v) -> { addShapeIntoView(shape); fireCanvasShapeAdded(shape); canvasShapeAddedEvent.fire(new CanvasShapeAddedEvent(this, shape)); return shape; }); return this; } protected AbstractCanvas(final Event<CanvasClearEvent> canvasClearEvent,
final Event<CanvasShapeAddedEvent> canvasShapeAddedEvent,
final Event<CanvasShapeRemovedEvent> canvasShapeRemovedEvent,
final Event<CanvasDrawnEvent> canvasDrawnEvent,
final Event<CanvasFocusedEvent> canvasFocusedEvent); }
|
AbstractCanvas implements Canvas<Shape>,
HasEventHandlers<AbstractCanvas<V>, Shape<?>>,
HasCanvasListeners<CanvasShapeListener> { @Override public Canvas addShape(final Shape shape) { shapes.computeIfAbsent(shape.getUUID(), (v) -> { addShapeIntoView(shape); fireCanvasShapeAdded(shape); canvasShapeAddedEvent.fire(new CanvasShapeAddedEvent(this, shape)); return shape; }); return this; } protected AbstractCanvas(final Event<CanvasClearEvent> canvasClearEvent,
final Event<CanvasShapeAddedEvent> canvasShapeAddedEvent,
final Event<CanvasShapeRemovedEvent> canvasShapeRemovedEvent,
final Event<CanvasDrawnEvent> canvasDrawnEvent,
final Event<CanvasFocusedEvent> canvasFocusedEvent); abstract V getView(); AbstractCanvas<V> initialize(final CanvasPanel panel,
final CanvasSettings settings); @Override Collection<Shape> getShapes(); Shape getShape(final String uuid); @SuppressWarnings("unchecked") Canvas addChild(final Shape parent,
final Shape child); @SuppressWarnings("unchecked") Canvas deleteChild(final Shape parent,
final Shape child); @SuppressWarnings("unchecked") Canvas dock(final Shape parent,
final Shape child); @SuppressWarnings("unchecked") Canvas undock(final Shape target,
final Shape child); @Override Canvas addShape(final Shape shape); @Override Canvas deleteShape(final Shape shape); @SuppressWarnings("unchecked") Canvas addShapeIntoView(final Shape shape); @SuppressWarnings("unchecked") Canvas deleteShapeFromView(final Shape shape); AbstractCanvas clear(); Canvas setGrid(final CanvasGrid grid); CanvasGrid getGrid(); Point2D getAbsoluteLocation(); @Override Transform getTransform(); @Override void destroy(); @Override HasCanvasListeners<CanvasShapeListener> addRegistrationListener(final CanvasShapeListener instance); @Override HasCanvasListeners<CanvasShapeListener> removeRegistrationListener(final CanvasShapeListener instance); @Override HasCanvasListeners<CanvasShapeListener> clearRegistrationListeners(); @Override int getWidthPx(); @Override int getHeightPx(); @Override boolean equals(final Object o); @Override int hashCode(); }
|
AbstractCanvas implements Canvas<Shape>,
HasEventHandlers<AbstractCanvas<V>, Shape<?>>,
HasCanvasListeners<CanvasShapeListener> { @Override public Canvas addShape(final Shape shape) { shapes.computeIfAbsent(shape.getUUID(), (v) -> { addShapeIntoView(shape); fireCanvasShapeAdded(shape); canvasShapeAddedEvent.fire(new CanvasShapeAddedEvent(this, shape)); return shape; }); return this; } protected AbstractCanvas(final Event<CanvasClearEvent> canvasClearEvent,
final Event<CanvasShapeAddedEvent> canvasShapeAddedEvent,
final Event<CanvasShapeRemovedEvent> canvasShapeRemovedEvent,
final Event<CanvasDrawnEvent> canvasDrawnEvent,
final Event<CanvasFocusedEvent> canvasFocusedEvent); abstract V getView(); AbstractCanvas<V> initialize(final CanvasPanel panel,
final CanvasSettings settings); @Override Collection<Shape> getShapes(); Shape getShape(final String uuid); @SuppressWarnings("unchecked") Canvas addChild(final Shape parent,
final Shape child); @SuppressWarnings("unchecked") Canvas deleteChild(final Shape parent,
final Shape child); @SuppressWarnings("unchecked") Canvas dock(final Shape parent,
final Shape child); @SuppressWarnings("unchecked") Canvas undock(final Shape target,
final Shape child); @Override Canvas addShape(final Shape shape); @Override Canvas deleteShape(final Shape shape); @SuppressWarnings("unchecked") Canvas addShapeIntoView(final Shape shape); @SuppressWarnings("unchecked") Canvas deleteShapeFromView(final Shape shape); AbstractCanvas clear(); Canvas setGrid(final CanvasGrid grid); CanvasGrid getGrid(); Point2D getAbsoluteLocation(); @Override Transform getTransform(); @Override void destroy(); @Override HasCanvasListeners<CanvasShapeListener> addRegistrationListener(final CanvasShapeListener instance); @Override HasCanvasListeners<CanvasShapeListener> removeRegistrationListener(final CanvasShapeListener instance); @Override HasCanvasListeners<CanvasShapeListener> clearRegistrationListeners(); @Override int getWidthPx(); @Override int getHeightPx(); @Override boolean equals(final Object o); @Override int hashCode(); }
|
@Test public void testReturnFocusToPanel() { view.setOnClosedByKeyboardCallback(canBeClosedByKeyboardConsumer); view.returnFocusToPanel(); verify(canBeClosedByKeyboardConsumer).accept(view); }
|
void returnFocusToPanel() { closedByKeyboardCallback.ifPresent(c -> c.accept(this)); }
|
ListSelectorViewImpl implements ListSelectorView { void returnFocusToPanel() { closedByKeyboardCallback.ifPresent(c -> c.accept(this)); } }
|
ListSelectorViewImpl implements ListSelectorView { void returnFocusToPanel() { closedByKeyboardCallback.ifPresent(c -> c.accept(this)); } ListSelectorViewImpl(); @Inject ListSelectorViewImpl(final UnorderedList itemsContainer,
final ManagedInstance<ListSelectorTextItemView> listSelectorTextItemViews,
final ManagedInstance<ListSelectorDividerItemView> listSelectorDividerItemViews,
final ManagedInstance<ListSelectorHeaderItemView> listSelectorHeaderItemViews); }
|
ListSelectorViewImpl implements ListSelectorView { void returnFocusToPanel() { closedByKeyboardCallback.ifPresent(c -> c.accept(this)); } ListSelectorViewImpl(); @Inject ListSelectorViewImpl(final UnorderedList itemsContainer,
final ManagedInstance<ListSelectorTextItemView> listSelectorTextItemViews,
final ManagedInstance<ListSelectorDividerItemView> listSelectorDividerItemViews,
final ManagedInstance<ListSelectorHeaderItemView> listSelectorHeaderItemViews); @Override void init(final Presenter presenter); @Override void setItems(final List<ListSelectorItem> items); @Override void show(final Optional<String> title); @Override void hide(); @Override void setOnClosedByKeyboardCallback(final Consumer<CanBeClosedByKeyboard> callback); }
|
ListSelectorViewImpl implements ListSelectorView { void returnFocusToPanel() { closedByKeyboardCallback.ifPresent(c -> c.accept(this)); } ListSelectorViewImpl(); @Inject ListSelectorViewImpl(final UnorderedList itemsContainer,
final ManagedInstance<ListSelectorTextItemView> listSelectorTextItemViews,
final ManagedInstance<ListSelectorDividerItemView> listSelectorDividerItemViews,
final ManagedInstance<ListSelectorHeaderItemView> listSelectorHeaderItemViews); @Override void init(final Presenter presenter); @Override void setItems(final List<ListSelectorItem> items); @Override void show(final Optional<String> title); @Override void hide(); @Override void setOnClosedByKeyboardCallback(final Consumer<CanBeClosedByKeyboard> callback); }
|
@Test @SuppressWarnings("unchecked") public void testDeleteShape() { tested.shapes.put(parentShape.getUUID(), parentShape); tested.deleteShape(parentShape); verify(canvasView, times(1)).delete(eq(parentShapeView)); assertTrue(tested.getShapes().isEmpty()); }
|
@Override public Canvas deleteShape(final Shape shape) { deleteShapeFromView(shape); fireCanvasShapeRemoved(shape); shapes.remove(shape.getUUID()); canvasShapeRemovedEvent.fire(new CanvasShapeRemovedEvent(this, shape)); return this; }
|
AbstractCanvas implements Canvas<Shape>,
HasEventHandlers<AbstractCanvas<V>, Shape<?>>,
HasCanvasListeners<CanvasShapeListener> { @Override public Canvas deleteShape(final Shape shape) { deleteShapeFromView(shape); fireCanvasShapeRemoved(shape); shapes.remove(shape.getUUID()); canvasShapeRemovedEvent.fire(new CanvasShapeRemovedEvent(this, shape)); return this; } }
|
AbstractCanvas implements Canvas<Shape>,
HasEventHandlers<AbstractCanvas<V>, Shape<?>>,
HasCanvasListeners<CanvasShapeListener> { @Override public Canvas deleteShape(final Shape shape) { deleteShapeFromView(shape); fireCanvasShapeRemoved(shape); shapes.remove(shape.getUUID()); canvasShapeRemovedEvent.fire(new CanvasShapeRemovedEvent(this, shape)); return this; } protected AbstractCanvas(final Event<CanvasClearEvent> canvasClearEvent,
final Event<CanvasShapeAddedEvent> canvasShapeAddedEvent,
final Event<CanvasShapeRemovedEvent> canvasShapeRemovedEvent,
final Event<CanvasDrawnEvent> canvasDrawnEvent,
final Event<CanvasFocusedEvent> canvasFocusedEvent); }
|
AbstractCanvas implements Canvas<Shape>,
HasEventHandlers<AbstractCanvas<V>, Shape<?>>,
HasCanvasListeners<CanvasShapeListener> { @Override public Canvas deleteShape(final Shape shape) { deleteShapeFromView(shape); fireCanvasShapeRemoved(shape); shapes.remove(shape.getUUID()); canvasShapeRemovedEvent.fire(new CanvasShapeRemovedEvent(this, shape)); return this; } protected AbstractCanvas(final Event<CanvasClearEvent> canvasClearEvent,
final Event<CanvasShapeAddedEvent> canvasShapeAddedEvent,
final Event<CanvasShapeRemovedEvent> canvasShapeRemovedEvent,
final Event<CanvasDrawnEvent> canvasDrawnEvent,
final Event<CanvasFocusedEvent> canvasFocusedEvent); abstract V getView(); AbstractCanvas<V> initialize(final CanvasPanel panel,
final CanvasSettings settings); @Override Collection<Shape> getShapes(); Shape getShape(final String uuid); @SuppressWarnings("unchecked") Canvas addChild(final Shape parent,
final Shape child); @SuppressWarnings("unchecked") Canvas deleteChild(final Shape parent,
final Shape child); @SuppressWarnings("unchecked") Canvas dock(final Shape parent,
final Shape child); @SuppressWarnings("unchecked") Canvas undock(final Shape target,
final Shape child); @Override Canvas addShape(final Shape shape); @Override Canvas deleteShape(final Shape shape); @SuppressWarnings("unchecked") Canvas addShapeIntoView(final Shape shape); @SuppressWarnings("unchecked") Canvas deleteShapeFromView(final Shape shape); AbstractCanvas clear(); Canvas setGrid(final CanvasGrid grid); CanvasGrid getGrid(); Point2D getAbsoluteLocation(); @Override Transform getTransform(); @Override void destroy(); @Override HasCanvasListeners<CanvasShapeListener> addRegistrationListener(final CanvasShapeListener instance); @Override HasCanvasListeners<CanvasShapeListener> removeRegistrationListener(final CanvasShapeListener instance); @Override HasCanvasListeners<CanvasShapeListener> clearRegistrationListeners(); @Override int getWidthPx(); @Override int getHeightPx(); @Override boolean equals(final Object o); @Override int hashCode(); }
|
AbstractCanvas implements Canvas<Shape>,
HasEventHandlers<AbstractCanvas<V>, Shape<?>>,
HasCanvasListeners<CanvasShapeListener> { @Override public Canvas deleteShape(final Shape shape) { deleteShapeFromView(shape); fireCanvasShapeRemoved(shape); shapes.remove(shape.getUUID()); canvasShapeRemovedEvent.fire(new CanvasShapeRemovedEvent(this, shape)); return this; } protected AbstractCanvas(final Event<CanvasClearEvent> canvasClearEvent,
final Event<CanvasShapeAddedEvent> canvasShapeAddedEvent,
final Event<CanvasShapeRemovedEvent> canvasShapeRemovedEvent,
final Event<CanvasDrawnEvent> canvasDrawnEvent,
final Event<CanvasFocusedEvent> canvasFocusedEvent); abstract V getView(); AbstractCanvas<V> initialize(final CanvasPanel panel,
final CanvasSettings settings); @Override Collection<Shape> getShapes(); Shape getShape(final String uuid); @SuppressWarnings("unchecked") Canvas addChild(final Shape parent,
final Shape child); @SuppressWarnings("unchecked") Canvas deleteChild(final Shape parent,
final Shape child); @SuppressWarnings("unchecked") Canvas dock(final Shape parent,
final Shape child); @SuppressWarnings("unchecked") Canvas undock(final Shape target,
final Shape child); @Override Canvas addShape(final Shape shape); @Override Canvas deleteShape(final Shape shape); @SuppressWarnings("unchecked") Canvas addShapeIntoView(final Shape shape); @SuppressWarnings("unchecked") Canvas deleteShapeFromView(final Shape shape); AbstractCanvas clear(); Canvas setGrid(final CanvasGrid grid); CanvasGrid getGrid(); Point2D getAbsoluteLocation(); @Override Transform getTransform(); @Override void destroy(); @Override HasCanvasListeners<CanvasShapeListener> addRegistrationListener(final CanvasShapeListener instance); @Override HasCanvasListeners<CanvasShapeListener> removeRegistrationListener(final CanvasShapeListener instance); @Override HasCanvasListeners<CanvasShapeListener> clearRegistrationListeners(); @Override int getWidthPx(); @Override int getHeightPx(); @Override boolean equals(final Object o); @Override int hashCode(); }
|
@Test @SuppressWarnings("unchecked") public void testClear() { tested.shapes.put(parentShape.getUUID(), parentShape); tested.shapes.put(childShape.getUUID(), childShape); tested.clear(); verify(canvasView, times(1)).delete(eq(parentShapeView)); verify(canvasView, times(1)).delete(eq(childShapeView)); assertTrue(tested.getShapes().isEmpty()); verify(canvasView, times(1)).clear(); }
|
public AbstractCanvas clear() { return clear(true); }
|
AbstractCanvas implements Canvas<Shape>,
HasEventHandlers<AbstractCanvas<V>, Shape<?>>,
HasCanvasListeners<CanvasShapeListener> { public AbstractCanvas clear() { return clear(true); } }
|
AbstractCanvas implements Canvas<Shape>,
HasEventHandlers<AbstractCanvas<V>, Shape<?>>,
HasCanvasListeners<CanvasShapeListener> { public AbstractCanvas clear() { return clear(true); } protected AbstractCanvas(final Event<CanvasClearEvent> canvasClearEvent,
final Event<CanvasShapeAddedEvent> canvasShapeAddedEvent,
final Event<CanvasShapeRemovedEvent> canvasShapeRemovedEvent,
final Event<CanvasDrawnEvent> canvasDrawnEvent,
final Event<CanvasFocusedEvent> canvasFocusedEvent); }
|
AbstractCanvas implements Canvas<Shape>,
HasEventHandlers<AbstractCanvas<V>, Shape<?>>,
HasCanvasListeners<CanvasShapeListener> { public AbstractCanvas clear() { return clear(true); } protected AbstractCanvas(final Event<CanvasClearEvent> canvasClearEvent,
final Event<CanvasShapeAddedEvent> canvasShapeAddedEvent,
final Event<CanvasShapeRemovedEvent> canvasShapeRemovedEvent,
final Event<CanvasDrawnEvent> canvasDrawnEvent,
final Event<CanvasFocusedEvent> canvasFocusedEvent); abstract V getView(); AbstractCanvas<V> initialize(final CanvasPanel panel,
final CanvasSettings settings); @Override Collection<Shape> getShapes(); Shape getShape(final String uuid); @SuppressWarnings("unchecked") Canvas addChild(final Shape parent,
final Shape child); @SuppressWarnings("unchecked") Canvas deleteChild(final Shape parent,
final Shape child); @SuppressWarnings("unchecked") Canvas dock(final Shape parent,
final Shape child); @SuppressWarnings("unchecked") Canvas undock(final Shape target,
final Shape child); @Override Canvas addShape(final Shape shape); @Override Canvas deleteShape(final Shape shape); @SuppressWarnings("unchecked") Canvas addShapeIntoView(final Shape shape); @SuppressWarnings("unchecked") Canvas deleteShapeFromView(final Shape shape); AbstractCanvas clear(); Canvas setGrid(final CanvasGrid grid); CanvasGrid getGrid(); Point2D getAbsoluteLocation(); @Override Transform getTransform(); @Override void destroy(); @Override HasCanvasListeners<CanvasShapeListener> addRegistrationListener(final CanvasShapeListener instance); @Override HasCanvasListeners<CanvasShapeListener> removeRegistrationListener(final CanvasShapeListener instance); @Override HasCanvasListeners<CanvasShapeListener> clearRegistrationListeners(); @Override int getWidthPx(); @Override int getHeightPx(); @Override boolean equals(final Object o); @Override int hashCode(); }
|
AbstractCanvas implements Canvas<Shape>,
HasEventHandlers<AbstractCanvas<V>, Shape<?>>,
HasCanvasListeners<CanvasShapeListener> { public AbstractCanvas clear() { return clear(true); } protected AbstractCanvas(final Event<CanvasClearEvent> canvasClearEvent,
final Event<CanvasShapeAddedEvent> canvasShapeAddedEvent,
final Event<CanvasShapeRemovedEvent> canvasShapeRemovedEvent,
final Event<CanvasDrawnEvent> canvasDrawnEvent,
final Event<CanvasFocusedEvent> canvasFocusedEvent); abstract V getView(); AbstractCanvas<V> initialize(final CanvasPanel panel,
final CanvasSettings settings); @Override Collection<Shape> getShapes(); Shape getShape(final String uuid); @SuppressWarnings("unchecked") Canvas addChild(final Shape parent,
final Shape child); @SuppressWarnings("unchecked") Canvas deleteChild(final Shape parent,
final Shape child); @SuppressWarnings("unchecked") Canvas dock(final Shape parent,
final Shape child); @SuppressWarnings("unchecked") Canvas undock(final Shape target,
final Shape child); @Override Canvas addShape(final Shape shape); @Override Canvas deleteShape(final Shape shape); @SuppressWarnings("unchecked") Canvas addShapeIntoView(final Shape shape); @SuppressWarnings("unchecked") Canvas deleteShapeFromView(final Shape shape); AbstractCanvas clear(); Canvas setGrid(final CanvasGrid grid); CanvasGrid getGrid(); Point2D getAbsoluteLocation(); @Override Transform getTransform(); @Override void destroy(); @Override HasCanvasListeners<CanvasShapeListener> addRegistrationListener(final CanvasShapeListener instance); @Override HasCanvasListeners<CanvasShapeListener> removeRegistrationListener(final CanvasShapeListener instance); @Override HasCanvasListeners<CanvasShapeListener> clearRegistrationListeners(); @Override int getWidthPx(); @Override int getHeightPx(); @Override boolean equals(final Object o); @Override int hashCode(); }
|
@Test @SuppressWarnings("unchecked") public void testDestroy() { tested.shapes.put(parentShape.getUUID(), parentShape); tested.shapes.put(childShape.getUUID(), childShape); tested.destroy(); verify(canvasView, times(1)).delete(eq(parentShapeView)); verify(canvasView, times(1)).delete(eq(childShapeView)); assertTrue(tested.getShapes().isEmpty()); verify(canvasView, times(1)).destroy(); }
|
@Override public void destroy() { clear(false); listeners.clear(); getView().destroy(); }
|
AbstractCanvas implements Canvas<Shape>,
HasEventHandlers<AbstractCanvas<V>, Shape<?>>,
HasCanvasListeners<CanvasShapeListener> { @Override public void destroy() { clear(false); listeners.clear(); getView().destroy(); } }
|
AbstractCanvas implements Canvas<Shape>,
HasEventHandlers<AbstractCanvas<V>, Shape<?>>,
HasCanvasListeners<CanvasShapeListener> { @Override public void destroy() { clear(false); listeners.clear(); getView().destroy(); } protected AbstractCanvas(final Event<CanvasClearEvent> canvasClearEvent,
final Event<CanvasShapeAddedEvent> canvasShapeAddedEvent,
final Event<CanvasShapeRemovedEvent> canvasShapeRemovedEvent,
final Event<CanvasDrawnEvent> canvasDrawnEvent,
final Event<CanvasFocusedEvent> canvasFocusedEvent); }
|
AbstractCanvas implements Canvas<Shape>,
HasEventHandlers<AbstractCanvas<V>, Shape<?>>,
HasCanvasListeners<CanvasShapeListener> { @Override public void destroy() { clear(false); listeners.clear(); getView().destroy(); } protected AbstractCanvas(final Event<CanvasClearEvent> canvasClearEvent,
final Event<CanvasShapeAddedEvent> canvasShapeAddedEvent,
final Event<CanvasShapeRemovedEvent> canvasShapeRemovedEvent,
final Event<CanvasDrawnEvent> canvasDrawnEvent,
final Event<CanvasFocusedEvent> canvasFocusedEvent); abstract V getView(); AbstractCanvas<V> initialize(final CanvasPanel panel,
final CanvasSettings settings); @Override Collection<Shape> getShapes(); Shape getShape(final String uuid); @SuppressWarnings("unchecked") Canvas addChild(final Shape parent,
final Shape child); @SuppressWarnings("unchecked") Canvas deleteChild(final Shape parent,
final Shape child); @SuppressWarnings("unchecked") Canvas dock(final Shape parent,
final Shape child); @SuppressWarnings("unchecked") Canvas undock(final Shape target,
final Shape child); @Override Canvas addShape(final Shape shape); @Override Canvas deleteShape(final Shape shape); @SuppressWarnings("unchecked") Canvas addShapeIntoView(final Shape shape); @SuppressWarnings("unchecked") Canvas deleteShapeFromView(final Shape shape); AbstractCanvas clear(); Canvas setGrid(final CanvasGrid grid); CanvasGrid getGrid(); Point2D getAbsoluteLocation(); @Override Transform getTransform(); @Override void destroy(); @Override HasCanvasListeners<CanvasShapeListener> addRegistrationListener(final CanvasShapeListener instance); @Override HasCanvasListeners<CanvasShapeListener> removeRegistrationListener(final CanvasShapeListener instance); @Override HasCanvasListeners<CanvasShapeListener> clearRegistrationListeners(); @Override int getWidthPx(); @Override int getHeightPx(); @Override boolean equals(final Object o); @Override int hashCode(); }
|
AbstractCanvas implements Canvas<Shape>,
HasEventHandlers<AbstractCanvas<V>, Shape<?>>,
HasCanvasListeners<CanvasShapeListener> { @Override public void destroy() { clear(false); listeners.clear(); getView().destroy(); } protected AbstractCanvas(final Event<CanvasClearEvent> canvasClearEvent,
final Event<CanvasShapeAddedEvent> canvasShapeAddedEvent,
final Event<CanvasShapeRemovedEvent> canvasShapeRemovedEvent,
final Event<CanvasDrawnEvent> canvasDrawnEvent,
final Event<CanvasFocusedEvent> canvasFocusedEvent); abstract V getView(); AbstractCanvas<V> initialize(final CanvasPanel panel,
final CanvasSettings settings); @Override Collection<Shape> getShapes(); Shape getShape(final String uuid); @SuppressWarnings("unchecked") Canvas addChild(final Shape parent,
final Shape child); @SuppressWarnings("unchecked") Canvas deleteChild(final Shape parent,
final Shape child); @SuppressWarnings("unchecked") Canvas dock(final Shape parent,
final Shape child); @SuppressWarnings("unchecked") Canvas undock(final Shape target,
final Shape child); @Override Canvas addShape(final Shape shape); @Override Canvas deleteShape(final Shape shape); @SuppressWarnings("unchecked") Canvas addShapeIntoView(final Shape shape); @SuppressWarnings("unchecked") Canvas deleteShapeFromView(final Shape shape); AbstractCanvas clear(); Canvas setGrid(final CanvasGrid grid); CanvasGrid getGrid(); Point2D getAbsoluteLocation(); @Override Transform getTransform(); @Override void destroy(); @Override HasCanvasListeners<CanvasShapeListener> addRegistrationListener(final CanvasShapeListener instance); @Override HasCanvasListeners<CanvasShapeListener> removeRegistrationListener(final CanvasShapeListener instance); @Override HasCanvasListeners<CanvasShapeListener> clearRegistrationListeners(); @Override int getWidthPx(); @Override int getHeightPx(); @Override boolean equals(final Object o); @Override int hashCode(); }
|
@Test @SuppressWarnings("unchecked") public void testClearShapes() throws Exception { tested.shapes.put(parentShape.getUUID(), parentShape); tested.shapes.put(childShape.getUUID(), childShape); tested.clearShapes(); verify(canvasView, times(1)).delete(eq(parentShapeView)); verify(canvasView, times(1)).delete(eq(childShapeView)); assertTrue(tested.getShapes().isEmpty()); }
|
protected void clearShapes() { if (!shapes.isEmpty()) { shapes.values().stream().collect(Collectors.toList()).forEach(this::deleteShape); shapes.clear(); } }
|
AbstractCanvas implements Canvas<Shape>,
HasEventHandlers<AbstractCanvas<V>, Shape<?>>,
HasCanvasListeners<CanvasShapeListener> { protected void clearShapes() { if (!shapes.isEmpty()) { shapes.values().stream().collect(Collectors.toList()).forEach(this::deleteShape); shapes.clear(); } } }
|
AbstractCanvas implements Canvas<Shape>,
HasEventHandlers<AbstractCanvas<V>, Shape<?>>,
HasCanvasListeners<CanvasShapeListener> { protected void clearShapes() { if (!shapes.isEmpty()) { shapes.values().stream().collect(Collectors.toList()).forEach(this::deleteShape); shapes.clear(); } } protected AbstractCanvas(final Event<CanvasClearEvent> canvasClearEvent,
final Event<CanvasShapeAddedEvent> canvasShapeAddedEvent,
final Event<CanvasShapeRemovedEvent> canvasShapeRemovedEvent,
final Event<CanvasDrawnEvent> canvasDrawnEvent,
final Event<CanvasFocusedEvent> canvasFocusedEvent); }
|
AbstractCanvas implements Canvas<Shape>,
HasEventHandlers<AbstractCanvas<V>, Shape<?>>,
HasCanvasListeners<CanvasShapeListener> { protected void clearShapes() { if (!shapes.isEmpty()) { shapes.values().stream().collect(Collectors.toList()).forEach(this::deleteShape); shapes.clear(); } } protected AbstractCanvas(final Event<CanvasClearEvent> canvasClearEvent,
final Event<CanvasShapeAddedEvent> canvasShapeAddedEvent,
final Event<CanvasShapeRemovedEvent> canvasShapeRemovedEvent,
final Event<CanvasDrawnEvent> canvasDrawnEvent,
final Event<CanvasFocusedEvent> canvasFocusedEvent); abstract V getView(); AbstractCanvas<V> initialize(final CanvasPanel panel,
final CanvasSettings settings); @Override Collection<Shape> getShapes(); Shape getShape(final String uuid); @SuppressWarnings("unchecked") Canvas addChild(final Shape parent,
final Shape child); @SuppressWarnings("unchecked") Canvas deleteChild(final Shape parent,
final Shape child); @SuppressWarnings("unchecked") Canvas dock(final Shape parent,
final Shape child); @SuppressWarnings("unchecked") Canvas undock(final Shape target,
final Shape child); @Override Canvas addShape(final Shape shape); @Override Canvas deleteShape(final Shape shape); @SuppressWarnings("unchecked") Canvas addShapeIntoView(final Shape shape); @SuppressWarnings("unchecked") Canvas deleteShapeFromView(final Shape shape); AbstractCanvas clear(); Canvas setGrid(final CanvasGrid grid); CanvasGrid getGrid(); Point2D getAbsoluteLocation(); @Override Transform getTransform(); @Override void destroy(); @Override HasCanvasListeners<CanvasShapeListener> addRegistrationListener(final CanvasShapeListener instance); @Override HasCanvasListeners<CanvasShapeListener> removeRegistrationListener(final CanvasShapeListener instance); @Override HasCanvasListeners<CanvasShapeListener> clearRegistrationListeners(); @Override int getWidthPx(); @Override int getHeightPx(); @Override boolean equals(final Object o); @Override int hashCode(); }
|
AbstractCanvas implements Canvas<Shape>,
HasEventHandlers<AbstractCanvas<V>, Shape<?>>,
HasCanvasListeners<CanvasShapeListener> { protected void clearShapes() { if (!shapes.isEmpty()) { shapes.values().stream().collect(Collectors.toList()).forEach(this::deleteShape); shapes.clear(); } } protected AbstractCanvas(final Event<CanvasClearEvent> canvasClearEvent,
final Event<CanvasShapeAddedEvent> canvasShapeAddedEvent,
final Event<CanvasShapeRemovedEvent> canvasShapeRemovedEvent,
final Event<CanvasDrawnEvent> canvasDrawnEvent,
final Event<CanvasFocusedEvent> canvasFocusedEvent); abstract V getView(); AbstractCanvas<V> initialize(final CanvasPanel panel,
final CanvasSettings settings); @Override Collection<Shape> getShapes(); Shape getShape(final String uuid); @SuppressWarnings("unchecked") Canvas addChild(final Shape parent,
final Shape child); @SuppressWarnings("unchecked") Canvas deleteChild(final Shape parent,
final Shape child); @SuppressWarnings("unchecked") Canvas dock(final Shape parent,
final Shape child); @SuppressWarnings("unchecked") Canvas undock(final Shape target,
final Shape child); @Override Canvas addShape(final Shape shape); @Override Canvas deleteShape(final Shape shape); @SuppressWarnings("unchecked") Canvas addShapeIntoView(final Shape shape); @SuppressWarnings("unchecked") Canvas deleteShapeFromView(final Shape shape); AbstractCanvas clear(); Canvas setGrid(final CanvasGrid grid); CanvasGrid getGrid(); Point2D getAbsoluteLocation(); @Override Transform getTransform(); @Override void destroy(); @Override HasCanvasListeners<CanvasShapeListener> addRegistrationListener(final CanvasShapeListener instance); @Override HasCanvasListeners<CanvasShapeListener> removeRegistrationListener(final CanvasShapeListener instance); @Override HasCanvasListeners<CanvasShapeListener> clearRegistrationListeners(); @Override int getWidthPx(); @Override int getHeightPx(); @Override boolean equals(final Object o); @Override int hashCode(); }
|
@Test public void testRegisterElement() { tested.init(canvasHandler); assertFalse(isRegistered(element)); tested.register(element); assertTrue(isRegistered(element)); }
|
@Override public void register(final Element element) { if (!itemsRegistered().test(element.getUUID()) && element.getContent() instanceof View) { items.put(element.getUUID(), false); } }
|
MapSelectionControl extends AbstractCanvasHandlerControl<H> implements SelectionControl<H, Element>,
CanvasRegistrationControl<H, Element> { @Override public void register(final Element element) { if (!itemsRegistered().test(element.getUUID()) && element.getContent() instanceof View) { items.put(element.getUUID(), false); } } }
|
MapSelectionControl extends AbstractCanvasHandlerControl<H> implements SelectionControl<H, Element>,
CanvasRegistrationControl<H, Element> { @Override public void register(final Element element) { if (!itemsRegistered().test(element.getUUID()) && element.getContent() instanceof View) { items.put(element.getUUID(), false); } } MapSelectionControl(final Consumer<CanvasSelectionEvent> selectionEventConsumer,
final Consumer<CanvasClearSelectionEvent> clearSelectionEventConsumer); }
|
MapSelectionControl extends AbstractCanvasHandlerControl<H> implements SelectionControl<H, Element>,
CanvasRegistrationControl<H, Element> { @Override public void register(final Element element) { if (!itemsRegistered().test(element.getUUID()) && element.getContent() instanceof View) { items.put(element.getUUID(), false); } } 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 void register(final Element element) { if (!itemsRegistered().test(element.getUUID()) && element.getContent() instanceof View) { items.put(element.getUUID(), false); } } 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 testSelect() { tested.init(canvasHandler); tested.register(element); tested.select(element.getUUID()); assertEquals(1, tested.getSelectedItems().size()); assertEquals(ELEMENT_UUID, tested.getSelectedItems().iterator().next()); verify(shape, times(1)).applyState(eq(ShapeState.SELECTED)); verify(shape, never()).applyState(eq(ShapeState.NONE)); verify(shape, never()).applyState(eq(ShapeState.INVALID)); verify(shape, never()).applyState(eq(ShapeState.HIGHLIGHT)); verify(canvas, times(1)).focus(); final ArgumentCaptor<CanvasSelectionEvent> elementSelectedEventArgumentCaptor = ArgumentCaptor.forClass(CanvasSelectionEvent.class); verify(elementSelectedEvent, times(1)).fire(elementSelectedEventArgumentCaptor.capture()); final CanvasSelectionEvent event = elementSelectedEventArgumentCaptor.getValue(); assertEquals(1, event.getIdentifiers().size()); assertEquals(ELEMENT_UUID, event.getIdentifiers().iterator().next()); }
|
@Override public SelectionControl<H, Element> select(final String uuid) { return select(Collections.singletonList(uuid)); }
|
MapSelectionControl extends AbstractCanvasHandlerControl<H> implements SelectionControl<H, Element>,
CanvasRegistrationControl<H, Element> { @Override public SelectionControl<H, Element> select(final String uuid) { return select(Collections.singletonList(uuid)); } }
|
MapSelectionControl extends AbstractCanvasHandlerControl<H> implements SelectionControl<H, Element>,
CanvasRegistrationControl<H, Element> { @Override public SelectionControl<H, Element> select(final String uuid) { return select(Collections.singletonList(uuid)); } MapSelectionControl(final Consumer<CanvasSelectionEvent> selectionEventConsumer,
final Consumer<CanvasClearSelectionEvent> clearSelectionEventConsumer); }
|
MapSelectionControl extends AbstractCanvasHandlerControl<H> implements SelectionControl<H, Element>,
CanvasRegistrationControl<H, Element> { @Override public SelectionControl<H, Element> select(final String uuid) { return select(Collections.singletonList(uuid)); } 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 SelectionControl<H, Element> select(final String uuid) { return select(Collections.singletonList(uuid)); } 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 testDeselect() { tested.init(canvasHandler); tested.register(element); tested.select(element.getUUID()); tested.deselect(element.getUUID()); assertTrue(tested.getSelectedItems().isEmpty()); verify(shape, times(1)).applyState(eq(ShapeState.SELECTED)); verify(shape, times(1)).applyState(eq(ShapeState.NONE)); verify(shape, never()).applyState(eq(ShapeState.INVALID)); verify(shape, never()).applyState(eq(ShapeState.HIGHLIGHT)); }
|
@Override public SelectionControl<H, Element> deselect(final String uuid) { return deselect(Collections.singletonList(uuid)); }
|
MapSelectionControl extends AbstractCanvasHandlerControl<H> implements SelectionControl<H, Element>,
CanvasRegistrationControl<H, Element> { @Override public SelectionControl<H, Element> deselect(final String uuid) { return deselect(Collections.singletonList(uuid)); } }
|
MapSelectionControl extends AbstractCanvasHandlerControl<H> implements SelectionControl<H, Element>,
CanvasRegistrationControl<H, Element> { @Override public SelectionControl<H, Element> deselect(final String uuid) { return deselect(Collections.singletonList(uuid)); } MapSelectionControl(final Consumer<CanvasSelectionEvent> selectionEventConsumer,
final Consumer<CanvasClearSelectionEvent> clearSelectionEventConsumer); }
|
MapSelectionControl extends AbstractCanvasHandlerControl<H> implements SelectionControl<H, Element>,
CanvasRegistrationControl<H, Element> { @Override public SelectionControl<H, Element> deselect(final String uuid) { return deselect(Collections.singletonList(uuid)); } 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 SelectionControl<H, Element> deselect(final String uuid) { return deselect(Collections.singletonList(uuid)); } 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 testClearSelection() { tested.init(canvasHandler); tested.register(element); tested.select(element.getUUID()); tested.clearSelection(); assertTrue(tested.getSelectedItems().isEmpty()); verify(shape, times(1)).applyState(eq(ShapeState.SELECTED)); verify(shape, times(1)).applyState(eq(ShapeState.NONE)); verify(shape, never()).applyState(eq(ShapeState.INVALID)); verify(shape, never()).applyState(eq(ShapeState.HIGHLIGHT)); verify(clearSelectionEvent, times(1)).fire(any(CanvasClearSelectionEvent.class)); }
|
@Override public SelectionControl<H, Element> clearSelection() { return clearSelection(true); }
|
MapSelectionControl extends AbstractCanvasHandlerControl<H> implements SelectionControl<H, Element>,
CanvasRegistrationControl<H, Element> { @Override public SelectionControl<H, Element> clearSelection() { return clearSelection(true); } }
|
MapSelectionControl extends AbstractCanvasHandlerControl<H> implements SelectionControl<H, Element>,
CanvasRegistrationControl<H, Element> { @Override public SelectionControl<H, Element> clearSelection() { return clearSelection(true); } MapSelectionControl(final Consumer<CanvasSelectionEvent> selectionEventConsumer,
final Consumer<CanvasClearSelectionEvent> clearSelectionEventConsumer); }
|
MapSelectionControl extends AbstractCanvasHandlerControl<H> implements SelectionControl<H, Element>,
CanvasRegistrationControl<H, Element> { @Override public SelectionControl<H, Element> clearSelection() { return clearSelection(true); } 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 SelectionControl<H, Element> clearSelection() { return clearSelection(true); } 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 testGetSelectedItemDefinitionWithNoItemsSelected() { tested.init(canvasHandler); when(index.get(ROOT_UUID)).thenReturn(rootElement); final Optional<Object> selectedItemDefinition = tested.getSelectedItemDefinition(); assertTrue(selectedItemDefinition.isPresent()); assertEquals(rootElement, selectedItemDefinition.get()); }
|
@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 testGetSelectedItemDefinitionWithNoItemsSelectedAndNoDiagram() { tested.init(canvasHandler); when(canvasHandler.getDiagram()).thenReturn(null); final Optional<Object> selectedItemDefinition = tested.getSelectedItemDefinition(); assertFalse(selectedItemDefinition.isPresent()); }
|
@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 testGetElement() { final HTMLElement element = mock(HTMLElement.class); when(popover.getElement()).thenReturn(element); final HTMLElement actual = popover.getElement(); assertEquals(element, actual); }
|
@Override public HTMLElement getElement() { return view.getElement(); }
|
AbstractPopoverImpl implements HasCellEditorControls.Editor<B> { @Override public HTMLElement getElement() { return view.getElement(); } }
|
AbstractPopoverImpl implements HasCellEditorControls.Editor<B> { @Override public HTMLElement getElement() { return view.getElement(); } protected AbstractPopoverImpl(); protected AbstractPopoverImpl(final V view); }
|
AbstractPopoverImpl implements HasCellEditorControls.Editor<B> { @Override public HTMLElement getElement() { return view.getElement(); } 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 HTMLElement getElement() { return view.getElement(); } 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 testClear() { tested.init(canvasHandler); tested.register(element); tested.select(element.getUUID()); tested.clear(); assertTrue(tested.getSelectedItems().isEmpty()); verify(clearSelectionEvent, times(1)).fire(canvasClearSelectionEventCaptor.capture()); assertEquals(canvasHandler, canvasClearSelectionEventCaptor.getValue().getCanvasHandler()); }
|
@Override public void clear() { clearSelection(true); }
|
MapSelectionControl extends AbstractCanvasHandlerControl<H> implements SelectionControl<H, Element>,
CanvasRegistrationControl<H, Element> { @Override public void clear() { clearSelection(true); } }
|
MapSelectionControl extends AbstractCanvasHandlerControl<H> implements SelectionControl<H, Element>,
CanvasRegistrationControl<H, Element> { @Override public void clear() { clearSelection(true); } MapSelectionControl(final Consumer<CanvasSelectionEvent> selectionEventConsumer,
final Consumer<CanvasClearSelectionEvent> clearSelectionEventConsumer); }
|
MapSelectionControl extends AbstractCanvasHandlerControl<H> implements SelectionControl<H, Element>,
CanvasRegistrationControl<H, Element> { @Override public void clear() { clearSelection(true); } 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 void clear() { clearSelection(true); } 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(); }
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.