How to use

PerspectiveManager

in

org.uberfire.client.mvp

public String getPerspectiveId() {
  return perspectiveManager.getCurrentPerspective().getIdentifier();
}

final PerspectiveActivity oldPerspectiveActivity = perspectiveManager.getCurrentPerspective();
if (oldPerspectiveActivity != null && place.equals(oldPerspectiveActivity.getPlace())) {
  return;
perspectiveManager.savePerspectiveState(new Command() {
  @Override
  public void execute() {

@Override
public void execute() {
  perspectiveManager.savePerspectiveState(() -> {
    placeManager.closePlace(perspectiveManager.getCurrentPerspectivePlaceRequest(),
                () -> doRedirect(getRedirectURL()));
  });
  // request.logout() happens as part of the redirected logout.jsp
}

private void refreshPerspective() {
  final PerspectiveActivity currentPerspective = perspectiveManager.getCurrentPerspective();
  perspectiveManager.removePerspectiveStates( new org.uberfire.mvp.Command() {
    @Override
    public void execute() {
      if ( currentPerspective != null ) {
        final PlaceRequest pr = new ForcedPlaceRequest( currentPerspective.getIdentifier(),
                                currentPerspective.getPlace().getParameters() );
        placeManager.goTo( pr );
      }
    }
  } );
}

@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));
}

/**
 * Tests the basics of launching a perspective. We call it "empty" because this perspective doesn't have any panels
 * or parts in its definition.
 */
@Test
public void testLaunchingEmptyPerspective() 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);
  placeManager.goTo(ozPerspectivePlace);
  // verify perspective changed to oz
  verify(perspectiveManager).savePerspectiveState(any(Command.class));
  verify(perspectiveManager).switchToPerspective(any(PlaceRequest.class),
                          eq(ozPerspectiveActivity),
                          any(ParameterizedCommand.class));
  verify(ozPerspectiveActivity).onOpen();
  assertEquals(PlaceStatus.OPEN,
         placeManager.getStatus(ozPerspectivePlace));
  assertTrue(placeManager.getActivePlaceRequests().contains(ozPerspectivePlace));
  assertEquals(ozPerspectiveActivity,
         placeManager.getActivity(ozPerspectivePlace));
  verify(workbenchLayout).onResize();
}

@Test
public void logoutCommandTest() {
  final DefaultWorkbenchFeaturesMenusHelper.LogoutCommand logoutCommand = spy(menusHelper.new LogoutCommand());
  logoutCommand.execute();
  verify(perspectiveManager).savePerspectiveState(any(Command.class));
}

private void buildPerspectiveContext() {
  final ContextDefinition contextDefinition = perspectiveManager.getLivePerspectiveDefinition().getContextDefinition();
  final ContextDisplayMode contextDisplayMode = perspectiveManager.getLivePerspectiveDefinition().getContextDisplayMode();
  if (contextDefinition != null && contextDisplayMode == SHOW) {
    final ContextActivity activity = activityManager.getActivity(ContextActivity.class,
                                   contextDefinition.getPlace());
    if (activity != null) {
      perspectiveContext = activity;
    }
  }
}

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);
  }
}

@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));
}

  @Override
  public void onClick(ClickEvent event) {
    if (Window.confirm(CommonConstants.INSTANCE.PromptResetPerspectives())) {
      final PerspectiveActivity currentPerspective = perspectiveManager.getCurrentPerspective();
      perspectiveManager.removePerspectiveStates(new Command() {
        @Override
        public void execute() {
          if (currentPerspective != null) {
            //Use ForcedPlaceRequest to force re-loading of the current Perspective
            final PlaceRequest pr = new ForcedPlaceRequest(currentPerspective.getIdentifier(),
                                    currentPerspective.getPlace().getParameters());
            placeManager.goTo(pr);
          }
        }
      });
    }
  }
});

verify(perspectiveManager).savePerspectiveState(any(Command.class));
verify(perspectiveManager).switchToPerspective(any(PlaceRequest.class),
                        eq(ozPerspectiveActivity),
                        any(ParameterizedCommand.class));

protected Command getSaveCloneCommand(final DisplayerEditorPopup displayerEditor) {
  return () -> {
    perspectiveCoordinator.editOff();
    beanManager.destroyBean(displayerEditor);
    PanelDefinition panelDefinition = panelManager.getPanelForPlace(placeRequest);
    placeManager.goTo(createPlaceRequest(displayerEditor.getDisplayerSettings()), panelDefinition);
    perspectiveManager.savePerspectiveState(() -> {});
  };
}

@Before
public void setUp() {
  when(mockPerspectiveManager.getLivePerspectiveDefinition()).thenReturn(panelManagerPerspectiveDefinition);
  panelManagerPerspectiveDefinition.setContextDefinition(perspectiveContextDefinition);
  when(mockActivityManager.getActivity(ContextActivity.class,
                     perspectiveContextDefinition.getPlace())).thenReturn(perspectiveContextActivity);
  when(mockPartView.getPresenter()).thenReturn(mockPartPresenter);
  when(mockPartPresenter.getDefinition()).thenReturn(partPresenterPartDefinition);
}

public String getPerspectiveId() {
  return perspectiveManager.getCurrentPerspective().getIdentifier();
}

when(defaultPerspective.isType(any(String.class)))
    .thenReturn(true);
when(perspectiveManager.getCurrentPerspective())
    .thenReturn(defaultPerspective);
    return null;
}).when(perspectiveManager).switchToPerspective(any(PlaceRequest.class),
                        any(PerspectiveActivity.class),
                        any(ParameterizedCommand.class));
    return null;
}).when(perspectiveManager).savePerspectiveState(any(Command.class));
doReturn(new DefaultPlaceRequest("lastPlaceRequest"))
    .when(defaultPerspective).getPlace();
doReturn(defaultPerspective).when(perspectiveManager)
    .getCurrentPerspective();

/**
 * Tests the basics of launching a perspective. We call it "empty" because this perspective doesn't have any panels
 * or parts in its definition.
 */
@Test
public void testLaunchingEmptyPerspective() 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);
  placeManager.goTo(ozPerspectivePlace);
  // verify perspective changed to oz
  verify(perspectiveManager).savePerspectiveState(any(Command.class));
  verify(perspectiveManager).switchToPerspective(any(PlaceRequest.class),
                          eq(ozPerspectiveActivity),
                          any(ParameterizedCommand.class));
  verify(ozPerspectiveActivity).onOpen();
  assertEquals(PlaceStatus.OPEN,
         placeManager.getStatus(ozPerspectivePlace));
  assertTrue(placeManager.getActivePlaceRequests().contains(ozPerspectivePlace));
  assertEquals(ozPerspectiveActivity,
         placeManager.getActivity(ozPerspectivePlace));
  verify(workbenchLayout).onResize();
}

protected Command getSaveCloneCommand(final DisplayerEditorPopup displayerEditor) {
  return () -> {
    perspectiveCoordinator.editOff();
    beanManager.destroyBean(displayerEditor);
    PanelDefinition panelDefinition = panelManager.getPanelForPlace(placeRequest);
    placeManager.goTo(createPlaceRequest(displayerEditor.getDisplayerSettings()), panelDefinition);
    perspectiveManager.savePerspectiveState(() -> {});
  };
}

public void logoutCommandRedirectIncludesLocaleTest() throws Throwable {
  final PlaceRequest currentPerspective = mock(PlaceRequest.class);
  doReturn(currentPerspective).when(perspectiveManager).getCurrentPerspectivePlaceRequest();
  final ArgumentCaptor<String> redirectURLCaptor = ArgumentCaptor.forClass(String.class);
  verify(perspectiveManager).savePerspectiveState(postSaveStateCommandCaptor.capture());

@Before
public void setUp() {
  when(mockPerspectiveManager.getLivePerspectiveDefinition()).thenReturn(panelManagerPerspectiveDefinition);
  panelManagerPerspectiveDefinition.setContextDefinition(perspectiveContextDefinition);
  when(mockActivityManager.getActivity(ContextActivity.class,
                     perspectiveContextDefinition.getPlace())).thenReturn(perspectiveContextActivity);
  when(mockPartView.getPresenter()).thenReturn(mockPartPresenter);
  when(mockPartPresenter.getDefinition()).thenReturn(partPresenterPartDefinition);
}