Package org.apache.wicket

Class Page

    • Constructor Detail

      • Page

        protected Page()
        Constructor.

      • Page

        protected Page​(PageParameters parameters)
        The PageParameters parameter will be stored in this page and then those parameters will be used to create stateless links to this bookmarkable page.
        Parameters:
        parameters - externally passed parameters
        See Also:
        PageParameters

    • Method Detail

      • componentRendered

        public final void componentRendered​(Component component)
        Adds a component to the set of rendered components.
        Parameters:
        component - The component that was rendered

      • onConfigure

        protected void onConfigure()
        Description copied from class: Component
        Called on all components before any component is rendered. This method should be used to configure such things as visibility and enabled flags.

        Overrides must call super.onConfigure(), usually before any other code

        NOTE: Component hierarchy should not be modified inside this method, instead it should be done in Component.onBeforeRender()

        NOTE: Why this method is preferrable to directly overriding Component.isVisible() and Component.isEnabled()? Because those methods are called multiple times even for processing of a single request. If they contain expensive logic they can slow down the response time of the entire page. Further, overriding those methods directly on form components may lead to inconsistent or unexpected state depending on when those methods are called in the form processing workflow. It is a better practice to push changes to state rather than pull.

        NOTE: If component's visibility or another property depends on another component you may call other.configure() followed by other.isVisible() as mentioned in Component.configure() javadoc.

        NOTE: Why should Component.onBeforeRender() not be used for this? Because if a component's visibility is controlled inside Component.onBeforeRender(), once invisible the component will never become visible again.

        Overrides:
        onConfigure in class Component

      • setFreezePageId

        public boolean setFreezePageId​(boolean freeze)
        Sets whether or not the page is allowed to change its page id. Implementations of this interface usually change their page id once a change to the data structure is made and historical record of the current state needs to be kept (usually to be accessible via the back button). Keeping a historical record is usually achieved by simply incrementing the page id to the next unique number, so when the implementation is stored it is done so in a new slot. This method is useful when for some reason we do not want the implementation to change its page id under any circumstances. One concrete example is an AJAX request. Suppose the page with id 10 was written out with callbacks pointing to id 10. Suppose that the user executed some AJAX callbacks which have changed the page id to 15. Now, the user clicks a non-AJAX link that was never updated by an AJAX update and still points to id 10 - which causes the state of the page to be rolled back - which is usually undesirable as all changes made to the page by AJAX requests are lost. So, instead, whatever is invoking the execution of the AJAX request on the page can use this method to tell the page to not update its page id thereby solving the problem.
        Specified by:
        setFreezePageId in interface IManageablePage
        Returns:
        previous state

      • dirty

        public void dirty​(boolean isInitialization)
        Mark this page as modified in the session. If versioning is supported then a new version of the page will be stored in page store
        Parameters:
        isInitialization - a flag whether this is a page instantiation

      • onInitialize

        protected void onInitialize()
        Description copied from class: Component
        This method is meant to be used as an alternative to initialize components. Usually the component's constructor is used for this task, but sometimes a component cannot be initialized in isolation, it may need to access its parent component or its markup in order to fully initialize. This method is invoked once per component's lifecycle when a path exists from this component to the Page thus providing the component with an atomic callback when the component's environment is built out.

        Overrides must call super#Component.onInitialize(). Usually this should be the first thing an override does, much like a constructor.

        Parent containers are guaranteed to be initialized before their children

        It is safe to use Component.getPage() in this method

        NOTE:The timing of this call is not precise, the contract is that it is called sometime before Component.onBeforeRender().

        Overrides:
        onInitialize in class MarkupContainer

      • getAutoIndex

        public final int getAutoIndex()
        THIS METHOD IS NOT PART OF THE WICKET PUBLIC API. DO NOT CALL IT. Get a page unique number, which will be increased with each call.
        Returns:
        A page unique number

      • getStatelessHint

        public final boolean getStatelessHint()
        Returns whether the page should try to be stateless. To be stateless, getStatelessHint() of every component on page (and it's behavior) must return true and the page must be bookmarkable.
        Overrides:
        getStatelessHint in class Component
        Returns:
        whether the component can be stateless
        See Also:
        Component.getStatelessHint()

      • isBookmarkable

        public boolean isBookmarkable()
        Bookmarkable page can be instantiated using a bookmarkable URL.
        Specified by:
        isBookmarkable in interface IRequestablePage
        Returns:
        Returns true if the page is bookmarkable.

      • isErrorPage

        public boolean isErrorPage()
        Override this method and return true if your page is used to display Wicket errors. This can help the framework prevent infinite failure loops.
        Returns:
        True if this page is intended to display an error to the end user.

      • isPageStateless

        public final boolean isPageStateless()
        Gets whether the page is stateless. Components on stateless page must not render any stateful urls, and components on stateful page must not render any stateless urls. Stateful urls are urls, which refer to a certain (current) page instance.
        Specified by:
        isPageStateless in interface IManageablePage
        Returns:
        Whether this page is stateless

      • setNumericId

        public final void setNumericId​(int id)
        THIS METHOD IS NOT PART OF THE WICKET PUBLIC API. DO NOT CALL. Set the id for this Page. This method is called by PageMap when a Page is added because the id, which is assigned by PageMap, is not known until this time.
        Parameters:
        id - The id

      • setStatelessHint

        public final Page setStatelessHint​(boolean value)
        Sets whether the page should try to be stateless. To be stateless, getStatelessHint() of every component on page (and it's behavior) must return true and the page must be bookmarkable.
        Parameters:
        value - whether the page should try to be stateless

      • componentChanged

        protected void componentChanged​(Component component,
                                MarkupContainer parent)
        This method will be called for all components that are changed on the page So also auto components or components that are not versioned. If the parent is given that it was a remove or add from that parent of the given component. else it was just a internal property change of that component.
        Parameters:
        component -
        parent -

      • onBeforeRender

        protected void onBeforeRender()
        Description copied from class: Component
        Called on all visible components before any component is rendered.

        NOTE: If you override this, you *must* call super.onBeforeRender() within your implementation. Because this method is responsible for cascading Component.onBeforeRender() call to its children it is strongly recommended that super call is made at the end of the override.

        Changes to the component tree can be made only before calling super.onBeforeRender().
        Overrides:
        onBeforeRender in class Component
        See Also:
        MarkupContainer.addOrReplace(Component...)

      • onAfterRender

        protected void onAfterRender()
        Description copied from class: Component
        Called immediately after a component and all its children have been rendered, regardless of any exception.
        Overrides:
        onAfterRender in class Component

      • onDetach

        protected void onDetach()
        Description copied from class: Component
        Called to allow a component to detach resources after use. Overrides of this method MUST call the super implementation, the most logical place to do this is the last line of the override method.
        Overrides:
        onDetach in class MarkupContainer

      • getMarkupType

        public MarkupType getMarkupType()
        Description copied from class: MarkupContainer
        Get the type of associated markup for this component. The markup type for a component is independent of whether or not the component actually has an associated markup resource file (which is determined at runtime).
        Overrides:
        getMarkupType in class MarkupContainer
        Returns:
        The type of associated markup for this component (for example, "html", "wml" or "vxml"). If there is no markup type for a component, null may be returned, but this means that no markup can be loaded for the class. Null is also returned if the component, or any of its parents, has not been added to a Page.

      • getRenderCount

        public int getRenderCount()
        Description copied from interface: IRequestablePage
        Returns the number of times this page has been rendered. The number will be appended to request listener links in order to prevent invoking listeners from staled page version.

        For example, the same page might have been rendered in two separate tabs. Page render doesn't change page id, but it can modify component hierarchy. Request listeners on such page should only work in tab where the page was rendered most recently.

        Specified by:
        getRenderCount in interface IRequestablePage
        Returns:
        render count

      • setWasCreatedBookmarkable

        public final void setWasCreatedBookmarkable​(boolean wasCreatedBookmarkable)
        THIS METHOD IS NOT PART OF WICKET API. DO NOT USE! Sets the flag that determines whether or not this page was created using one of its bookmarkable constructors
        Parameters:
        wasCreatedBookmarkable -

      • wasRendered

        public final boolean wasRendered​(Component component)
        THIS METHOD IS NOT PART OF THE WICKET PUBLIC API. DO NOT CALL.
        Parameters:
        component -
        Returns:
        if this component was render in this page