/** * Default construtor. * <p> * With this constructor, {@link #init(UI, NavigationStateManager, ViewDisplay)} method is not called, since * navigator initialization is delegated to subclasses. * </p> */ public DefaultViewNavigator() { super(); this.actuator = new NavigatorActuator<>(this); }
@Override public String getCurrentViewName() { return actuator.getCurrentViewName(); }
/** * Check if a default View is available * @return <code>true</code> if a default View is available */ protected boolean isDefaultViewAvailable() { return getDefaultViewName() != null; }
/** * Check if given <code>view</code> is volatile, i.e. not to be tracked in navigation history * @param view View to check * @return <code>true</code> if given <code>view</code> is volatile */ protected boolean isVolatile(View view) { if (view != null) { return isVolatile(getViewConfiguration(view.getClass())); } return false; }
if (getDefaultViewDisplay() == null) { LOGGER.warn("No ViewDisplay is bound to this Navigator! Check ViewNavigator init and setup."); final ViewConfiguration viewConfiguration = getViewConfiguration(view.getClass()); if (viewConfiguration != null && viewConfiguration.isSubView()) { parentViewName = viewConfiguration.getParentViewName(); navigateToState(viewConfiguration, parentViewName); } catch (Exception e) { throw new ViewNavigationException(parentViewName, e); if (parentViewName.equals(getCurrentViewName())) { throw new ViewNavigationException(buildNavigationState(viewName, parameters), "Declared parent view name " + parentViewName + " of sub view " + viewName + " is not a SubViewContainer"); viewName, parameters, getViewWindow(buildNavigationState(viewName, parameters))); String navigationState = buildNavigationState(viewName, parameters); if (viewConfiguration != null && viewConfiguration.isForceInWindow()) { Window window = buildViewWindow(navigationState, view, viewName, viewConfiguration, null); viewWindows.put(navigationState, new WeakReference<>(window)); showInWindow = window; navigateToView(viewConfiguration, view, viewName, parameters, navigationState);
final String navigationState = buildNavigationState(viewName, parameters); view = getView(navigationState); } catch (Exception e) { throw new ViewNavigationException(viewName, e); final ViewConfiguration viewConfiguration = getViewConfiguration(view.getClass()); Window window = buildViewWindow(navigationState, view, viewName, viewConfiguration, windowConfiguration); viewWindows.put(navigationState, new WeakReference<>(window)); showInWindow = window; navigateTo(navigationState); } catch (Exception e) { throw new ViewNavigationException(viewName, e);
public void preAfterViewChange(ViewChangeEvent event) { // fire OnShow on new view if (event.getNewView() != null) { ViewConfiguration configuration = getViewConfiguration(event.getNewView().getClass()); if (configuration != null) { ViewNavigationUtils.fireViewOnShow(event.getNewView(), configuration, DefaultViewNavigatorChangeEvent.create(event, navigator, getViewWindow(buildNavigationState(event.getViewName(), event.getParameters()))), false); } else { LOGGER.warn("Failed to obtain ViewConfiguration for view class " + event.getOldView().getClass() + ": OnShow methods firing skipped"); } } }
/** * Navigate to given View using concrete {@link Navigator}. * <p> * Authentication check using {@link Authenticate} annotation is performed before the actual view navigation. * </p> * @param viewConfiguration View configuration. If <code>null</code> the view configuration is obtained using * {@link #getViewConfiguration(Class)} * @param view View instance * @param viewName View name * @param parameters View parameters * @param navigationState Full navigation state */ private void navigateToView(ViewConfiguration viewConfiguration, View view, String viewName, String parameters, String navigationState) { ViewConfiguration cfg = (viewConfiguration != null) ? viewConfiguration : (view != null) ? getViewConfiguration(view.getClass()) : null; // check authentication if (checkAuthentication(navigationState, cfg)) { navigator.navigateToView(view, viewName, parameters); } else { // track view in history to allow backward navigation if (!isVolatile(cfg)) { trackInHistory(navigationState); } } }
if (getActuator().getDefaultViewName() == null) { getActuator().setDefaultViewName(viewName); LOGGER.info("Configured default view " + type.getName() + " with name: " + viewName); if (!actuator.getViewClassProvider(viewProvider).isPresent()) { final SpringViewClassProvider springViewClassProvider = new SpringViewClassProvider( applicationContext);
/** * Navigate to default View, if available * @throws ViewNavigationException Navigation error */ public void navigateToDefault() throws ViewNavigationException { // close any Window displayed View closeAllViewWindows(); // default view String viewName = getDefaultViewName(); if (viewName == null) { throw new ViewNavigationException(null, "No default view name defined"); } try { navigateToState(null, getDefaultViewName()); } catch (Exception e) { throw new ViewNavigationException(viewName, e); } }
/** * Navigate to previous View, if available * @return true if back navigation succeded * @throws ViewNavigationException Navigation error */ public boolean navigateBack() throws ViewNavigationException { return navigateBack(null, null); }
@Override public void navigateTo(String navigationState) { actuator.navigateTo(navigationState); }
/** * Get the {@link ViewConfiguration} which corresponds to the {@link View} represented by the given * <code>navigationState</code>, if available. * @param navigationState Navigation state * @return Optional {@link ViewConfiguration} */ public Optional<ViewConfiguration> getViewConfiguration(String navigationState) { ViewProvider viewProvider = getViewProvider(navigationState); if (viewProvider != null) { String viewName = viewProvider.getViewName(navigationState); if (viewName != null) { ViewProvider vp = (viewProvider instanceof ViewProviderAdapter) ? ((ViewProviderAdapter) viewProvider).getWrappedProvider() : viewProvider; ViewClassProvider viewClassProvider = viewClassProviders.get(vp); if (viewClassProvider != null) { return viewClassProvider.getViewClass(viewName).map(viewClass -> getViewConfiguration(viewClass)); } } } return Optional.empty(); }
@Override public Window navigateInWindow(String viewName, Consumer<ViewWindowConfigurator> windowConfiguration, Map<String, Object> parameters) throws ViewNavigationException { return actuator.navigateInWindow(viewName, windowConfiguration, parameters); }
@Override public void navigateTo(String viewName, Map<String, Object> parameters) throws ViewNavigationException { try { navigateTo(actuator.buildNavigationState(viewName, parameters)); } catch (Exception e) { throw new ViewNavigationException(viewName, e); } }
@Override protected void init(UI ui, NavigationStateManager stateManager, ViewDisplay display) { super.init(ui, stateManager, actuator.initNavigator(ui, display)); }
@Override public ViewConfiguration getViewConfiguration(Class<? extends View> viewClass) { return actuator.getViewConfiguration(viewClass); }
@Override public void addProvider(ViewProvider provider) { super.addProvider(actuator.addViewProvider(provider)); }
final String navigationState = buildNavigationState(event.getViewName(), event.getParameters()); ViewConfiguration configuration = getViewConfiguration(event.getOldView().getClass()); if (configuration != null) { ViewNavigationUtils.fireViewOnLeave(event.getOldView(), configuration, ViewConfiguration configuration = getViewConfiguration(event.getNewView().getClass()); if (configuration != null) { ViewNavigationUtils.setViewParameters(event.getNewView(), configuration, event.getParameters(), null); DefaultViewNavigatorChangeEvent.create(event, navigator, getViewWindow(navigationState)), true);
@Override public boolean navigateBack() throws ViewNavigationException { return actuator.navigateBack(); }