The framework is reasonably smart about the back button for instance, it crawls up the nesting stack to find the appropriate page flow when you execute an action from the browser's history.

Upon return, you can use Symbolic Navigation (above) to get back to a recent page, or to rerun a recent action. You can pass data to them, and receive data when they return. Nested page flows define entry points and exit points, and are analogous to method invocations. in general, to further break up your application into separate (and in many cases reusable) pieces.show the user information that will be useful in the current page flow (e.g., help screens can be easily implemented as nested page flows) and.show an alternate view of data represented in the current page flow.allow the user to correct errors or supply additional information en route to executing a desired action.gather data from the user, for use in the current page flow.Nesting is useful when you want to do one of the following tasks: At its heart, nesting is a way of pushing aside the current page flow temporarily and transferring control to another (nested) page flow with the intention of coming back to the original one. Nested Page FlowsĪn entire page flow can be inserted, or 'nested', inside of another page flow. This allows you to write generic actions (in base classes and in shared flows) that can navigate symbolically, rather than absolutely. On an as-needed basis, Page Flow tracks the most recently-shown views (along with the data used to initialize them), as well as the most recently-run action. (This feature isn't currently completely hooked up in Ti.) Symbolic Navigation The feature is useful for accessing shared state, to provide actions/exception-handlers for shared user interface (e.g., menu bars, page headers), and when you cannot change your controller class hierarchy. Shared Flow provides another way to make actions, exception handlers, *and state* available to multiple page flows. When you extend a controller class you inherit/merge its configuration (annotations) as well as everything else you would inherit normally. Page Flow inheritance provides a way to share actions, exception handlers, configuration, etc. 'Target scopes' are the foundation for multiple page flows living in the same session – in portlets or in multiple browser windows/frames. The storage location (user session by default) is pluggable. This behavior can be configured per-page flow, but using auto-cleanup helps keep your session small, and focused on the task at hand.Ĭontroller classes are driven through a lifecycle, with callbacks for create/before-action/after-action/destroy. By default, the state is automatically cleaned up when the user leaves the page flow to enter another one. Methods within the class – particularly action methods and exception handlers – have access to the member state.

While the user is in the page flow, the controller instance simply stores the flow-related state in member variables. When a user enters a page flow (by hitting an URL in the page flow's URL space), an instance of the page flow's controller class is created. This is like modules in Struts Classic, but it goes beyond breaking up the config. Modular Page FlowsĪn application can have multiple page flows within it, allowing you to break it up into separate, self-contained chunks of flow. See StrutsTi ControllerMock, or actual running samples at wars/samples/src/java/pageflow in the tree ('maven dist' at the root will build wars that you can deploy). are all defined in a single Java class: the page flow 'controller' class that drives a piece of your web application. Navigation, exception handling, validation, etc. Some features brought in with Beehive Page Flow Declarative Programmingĭeclarative programming model using Java 5 annotations.

Primefaces change stack menu location