public String getItemName(PerspectiveActivity p) { return getItemName(p.getIdentifier()); }
@Override public void execute() { currentPerspectivePlaceRequest = placeRequest; currentPerspective = perspective; if (perspective.isTransient()) { //Transient Perspectives are not saved and hence cannot be loaded doAfterFetch.execute(perspective.getDefaultPerspectiveLayout()); } else { wbServices.loadPerspective(perspective.getIdentifier(), new ParameterizedCommand<PerspectiveDefinition>() { @Override public void execute(final PerspectiveDefinition response) { if (isAValidDefinition(response)) { doAfterFetch.execute(response); } else { doAfterFetch.execute(perspective.getDefaultPerspectiveLayout()); } } }); } }
@Override public void execute() { if ( currentPerspective != null ) { final PlaceRequest pr = new ForcedPlaceRequest( currentPerspective.getIdentifier(), currentPerspective.getPlace().getParameters() ); placeManager.goTo( pr ); } } } );
@Override public void savePerspectiveState(Command doWhenFinished) { if (currentPerspective != null && !currentPerspective.isTransient()) { wbServices.save(currentPerspective.getIdentifier(), livePerspectiveDef, doWhenFinished); } else { doWhenFinished.execute(); } }
@Override public void execute(PerspectiveDefinition perspectiveDef) { perspectiveChangeEvent.fire(new PerspectiveChange(placeRequest, perspectiveDef, currentPerspective.getMenus(), currentPerspective.getIdentifier())); doWhenFinished.execute(perspectiveDef); } }
@Test public void testSetupEnableDisableContextMenuItem() { final Menus contextMenus = MenuFactory.newSimpleItem(NAME).endMenu().build(); final PerspectiveActivity activity = mock(PerspectiveActivity.class); final PlaceRequest placeRequest = mock(PlaceRequest.class); when(activity.getIdentifier()).thenReturn(PERSPECTIVE_ID); when(activity.getMenus()).thenReturn(contextMenus); when(activity.isType(ActivityResourceType.PERSPECTIVE.name())).thenReturn(true); when(authzManager.authorize(contextMenus.getItems().get(0), identity)).thenReturn(true); when(activityManager.getActivity(placeRequest)).thenReturn(activity); presenter.onPerspectiveChange(new PerspectiveChange(placeRequest, null, contextMenus, PERSPECTIVE_ID)); verify(view).enableContextMenuItem(anyString(), eq(true)); contextMenus.getItems().get(0).setEnabled(true); verify(view, times(2)).enableContextMenuItem(anyString(), eq(true)); contextMenus.getItems().get(0).setEnabled(false); verify(view).enableContextMenuItem(anyString(), eq(false)); }
@Test public void testSwitchingFromPerspectiveToSelf() throws Exception { PerspectiveActivity ozPerspectiveActivity = mock(PerspectiveActivity.class); PlaceRequest ozPerspectivePlace = new DefaultPlaceRequest("oz_perspective"); PerspectiveDefinition ozPerspectiveDef = new PerspectiveDefinitionImpl(); when(activityManager.getActivities(ozPerspectivePlace)) .thenReturn(singleton((Activity) ozPerspectiveActivity)); when(ozPerspectiveActivity.getDefaultPerspectiveLayout()).thenReturn(ozPerspectiveDef); when(ozPerspectiveActivity.getPlace()).thenReturn(ozPerspectivePlace); when(ozPerspectiveActivity.isType(ActivityResourceType.PERSPECTIVE.name())).thenReturn(true); when(ozPerspectiveActivity.getIdentifier()).thenReturn("oz_perspective"); // we'll pretend we started in oz when(perspectiveManager.getCurrentPerspective()).thenReturn(ozPerspectiveActivity); final BiParameterizedCommand<Command, PlaceRequest> closeChain = mock(BiParameterizedCommand.class); placeManager.registerPerspectiveCloseChain("oz_perspective", closeChain); placeManager.goTo(ozPerspectivePlace); verify(closeChain, never()).execute(any(), any()); // verify no side effects (should stay put) verify(ozPerspectiveActivity, never()).onOpen(); verify(perspectiveManager, never()).savePerspectiveState(any(Command.class)); verify(perspectiveManager, never()) .switchToPerspective(any(PlaceRequest.class), any(PerspectiveActivity.class), any(ParameterizedCommand.class)); }
@Test public void testSwitchingPerspectives() throws Exception { PerspectiveActivity ozPerspectiveActivity = mock(PerspectiveActivity.class); PlaceRequest ozPerspectivePlace = new DefaultPlaceRequest("oz_perspective"); PerspectiveDefinition ozPerspectiveDef = new PerspectiveDefinitionImpl(); when(activityManager.getActivities(ozPerspectivePlace)) .thenReturn(singleton((Activity) ozPerspectiveActivity)); when(ozPerspectiveActivity.getDefaultPerspectiveLayout()).thenReturn(ozPerspectiveDef); when(ozPerspectiveActivity.getPlace()).thenReturn(ozPerspectivePlace); when(ozPerspectiveActivity.isType(ActivityResourceType.PERSPECTIVE.name())).thenReturn(true); when(kansasActivity.isType(ActivityResourceType.SCREEN.name())).thenReturn(true); // we'll pretend we started in kansas PerspectiveActivity kansasPerspectiveActivity = mock(PerspectiveActivity.class); when(perspectiveManager.getCurrentPerspective()).thenReturn(kansasPerspectiveActivity); placeManager.goTo(ozPerspectivePlace); // verify proper shutdown of kansasPerspective and its contents InOrder inOrder = inOrder(activityManager, kansasPerspectiveActivity, kansasActivity, workbenchLayout); // shut down the screens first inOrder.verify(kansasActivity).onClose(); inOrder.verify(activityManager).destroyActivity(kansasActivity); // then the perspective inOrder.verify(kansasPerspectiveActivity).onClose(); inOrder.verify(activityManager).destroyActivity(kansasPerspectiveActivity); inOrder.verify(workbenchLayout).onResize(); }
@Test public void goToDefaultPerspective() throws Exception { when(perspectiveActivity1.isDefault()).thenReturn(true); when(perspectiveActivity2.isDefault()).thenReturn(false); workbench.startIfNotBlocked(); verify(placeManager).goTo(new DefaultPlaceRequest(perspectiveActivity1.getIdentifier())); }
public List<MenuItem> getPerspectivesMenuItems() { final List<MenuItem> perspectives = new ArrayList<>(); for (final PerspectiveActivity perspective : getPerspectiveActivities()) { final String name = perspective.getDefaultPerspectiveLayout().getName(); final MenuItem item = newSimpleItem(name).perspective(perspective.getIdentifier()).endMenu().build().getItems().get(0); perspectives.add(item); } return perspectives; }
@Override public PlaceStatus getStatus(final PlaceRequest place) { PerspectiveActivity currentPerspective = perspectiveManager.getCurrentPerspective(); if (currentPerspective != null && currentPerspective.getPlace().equals(place)) { return PlaceStatus.OPEN; } return resolveExistingParts(place) != null ? PlaceStatus.OPEN : PlaceStatus.CLOSE; }
final PerspectiveDefinition perspectiveDef = new PerspectiveDefinitionImpl( SimpleWorkbenchPanelPresenter.class.getName()); when(perspectiveActivity.getDefaultPerspectiveLayout()).thenReturn(perspectiveDef); when(activityManager.getActivities(perspectivePlace)) .thenReturn(singleton((Activity) perspectiveActivity)); when(perspectiveActivity.isType(ActivityResourceType.PERSPECTIVE.name())).thenReturn(true); when(splashScreenActivity.isType(ActivityResourceType.SPLASH.name())).thenReturn(true); never()).onStartup(any(PlaceRequest.class)); verify(perspectiveActivity).onOpen(); assertEquals(PlaceStatus.OPEN, placeManager.getStatus(perspectivePlace));
@Test public void testPerspectiveChangeEvent() { final Menus menus = MenuFactory.newSimpleItem(NAME).perspective(PERSPECTIVE_ID).endMenu().build(); final PlaceRequest placeRequest = new DefaultPlaceRequest(PERSPECTIVE_ID); final PerspectiveActivity perspectiveActivity = mock(PerspectiveActivity.class); final PerspectiveChange perspectiveChange = new PerspectiveChange(placeRequest, null, null, PERSPECTIVE_ID); when(perspectiveActivity.getPlace()).thenReturn(placeRequest); when(perspectiveActivity.isType(ActivityResourceType.PERSPECTIVE.name())).thenReturn(true); when(authzManager.authorize(any(Resource.class), eq(identity))).thenReturn(true); presenter.addMenus(menus); presenter.onPerspectiveChange(perspectiveChange); verify(view).selectMenuItem(PERSPECTIVE_ID); }
@Test public void shouldDestroyAllOldPanelsWhenSwitchingRoot() throws Exception { PerspectiveDefinition fooPerspectiveDef = new PerspectiveDefinitionImpl(MultiListWorkbenchPanelPresenter.class.getName()); PanelDefinition rootPanel = fooPerspectiveDef.getRoot(); PanelDefinition fooPanel = new PanelDefinitionImpl(SimpleWorkbenchPanelPresenter.class.getName()); PanelDefinition fooChildPanel = new PanelDefinitionImpl(SimpleWorkbenchPanelPresenter.class.getName()); PanelDefinition barPanel = new PanelDefinitionImpl(SimpleWorkbenchPanelPresenter.class.getName()); PanelDefinition bazPanel = new PanelDefinitionImpl(SimpleWorkbenchPanelPresenter.class.getName()); rootPanel.appendChild(fooPanel); rootPanel.appendChild(barPanel); rootPanel.appendChild(bazPanel); fooPanel.appendChild(fooChildPanel); PerspectiveActivity fooPerspective = mock(PerspectiveActivity.class); when(fooPerspective.getDefaultPerspectiveLayout()).thenReturn(fooPerspectiveDef); when(fooPerspective.isTransient()).thenReturn(true); perspectiveManager.switchToPerspective(pr, fooPerspective, doWhenFinished); perspectiveManager.switchToPerspective(pr, oz, doWhenFinished); verify(panelManager).removeWorkbenchPanel(fooPanel); verify(panelManager).removeWorkbenchPanel(fooChildPanel); verify(panelManager).removeWorkbenchPanel(barPanel); verify(panelManager).removeWorkbenchPanel(bazPanel); verify(panelManager, never()).removeWorkbenchPanel(rootPanel); }
@Override default String getName() { return getDefaultPerspectiveLayout().getName(); }
public PerspectiveActivity getDefaultPerspective() { for (SyncBeanDef beanDef : activityBeansCache.getPerspectiveActivities()) { PerspectiveActivity p = (PerspectiveActivity) beanDef.getInstance(); if (p.isDefault()) { return p; } } return null; }
private void switchToPerspective(final PlaceRequest place, final PerspectiveActivity newPerspectiveActivity, final ParameterizedCommand<PerspectiveDefinition> closeOldPerspectiveOpenPartsAndExecuteChainedCallback) { if (closeAllCurrentPanels()) { closeAllSplashScreens(); addSplashScreenFor(place); perspectiveManager.switchToPerspective(place, newPerspectiveActivity, closeOldPerspectiveOpenPartsAndExecuteChainedCallback); } else { // some panels didn't want to close, so not going to launch new perspective. clean up its activity. try { newPerspectiveActivity.onClose(); } catch (Exception ex) { lifecycleErrorHandler.handle(newPerspectiveActivity, LifecyclePhase.OPEN, ex); } existingWorkbenchActivities.remove(newPerspectiveActivity.getPlace()); activityManager.destroyActivity(newPerspectiveActivity); } }
@SuppressWarnings("unchecked") @Test public void shouldNotLoadNewTransientPerspectiveState() throws Exception { when(oz.isTransient()).thenReturn(true); perspectiveManager.switchToPerspective(pr, oz, doWhenFinished); verify(wbServices, never()).loadPerspective(eq("oz_perspective"), any(ParameterizedCommand.class)); }
@Override protected void addPerspectiveMenus(final PerspectiveActivity perspective) { final Menus menus = perspective.getMenus(); super.addMenus(menus); } }
@Test public void testAddContextMenuWithoutPermission() { final Menus contextMenus = MenuFactory.newSimpleItem(NAME).endMenu().build(); final PerspectiveActivity activity = mock(PerspectiveActivity.class); final PlaceRequest placeRequest = mock(PlaceRequest.class); when(activity.getIdentifier()).thenReturn(PERSPECTIVE_ID); when(activity.getMenus()).thenReturn(contextMenus); when(activity.isType(ActivityResourceType.PERSPECTIVE.name())).thenReturn(true); when(authzManager.authorize(contextMenus.getItems().get(0), identity)).thenReturn(false); when(activityManager.getActivity(placeRequest)).thenReturn(activity); presenter.onPerspectiveChange(new PerspectiveChange(placeRequest, null, contextMenus, PERSPECTIVE_ID)); verify(authzManager).authorize(contextMenus.getItems().get(0), identity); verify(view).clearContextMenu(); verify(view, never()).addContextMenuItem(anyString(), anyString(), anyString(), anyString(), any(Command.class), any(MenuPosition.class)); }