Package wicket

The core Wicket package.

See:
Description

Interface Summary

Component.IVisitor	Generic component visitor interface for component traversals.
IClassResolver	An interface to code which finds classes.
IComponentResolver	ApplicationSettings maintains a list of IComponentResolvers.
IComponentResolverMarker	This is just a marker interface which may only be used in combination with IComponentResolver.
IComponentValueComparator	Implementation of this interface can be used in the Component.getComparator() for testing the current value of the components model data with the new value that is given.
IInitializer	Initializes something when application loads
IPageFactory	A factory class that creates Pages.
IPageVersionManager	Interface to code that manages versions of a Page.
IRedirectListener	Request listener called on page redirects.
IRequestCycleFactory	Factory for creating request cycles for a session.
IRequestListener	Base interface for all interfaces that listen for requests from the client browser.
IResourceFactory	A factory which creates resources for a given specification string.
IResourceListener	Listens for requests regarding resources.
ISessionFactory	A factory interface used by Applications to create Sessions.
IValidatorResourceKeyFactory	Factory for creating resource keys for validator error messages
PageMap.IVisitor	Visitor interface for visiting pages
Session.IVisitor	Visitor interface for visiting page maps

Class Summary

AjaxHandler	Abstract class for handling Ajax roundtrips.
Application	Base class for all Wicket applications.
ApplicationPages	Holder for specifying Wicket page classes that have special meaning to an application, such as an application's home page and any error display pages.
ApplicationPages.HomePageRenderStrategy	Enumerated type for different ways of handling the rendering/ redirecting of the homepage.
ApplicationSettings	Contains application settings as property values.
ApplicationSettings.RenderStrategy	Enumerated type for different ways of handling the render part of requests.
ApplicationSettings.UnexpectedExceptionDisplay	Enumerated type for different ways of displaying unexpected exceptions.
AttributeModifier	This class allows a tag attribute of a component to be modified dynamically with a value obtained from a model object.
AutoComponentResolver	<wicket:component class="myApp.MyTable" key=value> tags may be used to add Wicket components (e.g.
AutoLinkResolver	The AutoLinkResolver is responsible to handle automatic link resolution.
Component	Component serves as the highest level abstract base class for all components.
DefaultClassResolver	Resolves a class by using the classloader that loaded this class.
DefaultPageFactory	A factory that constructs Pages.
DefaultValidatorResourceKeyFactory	Default implementation of IValidatorResourceKeyFactory.
Initializer	Initializer for components in wicket core library.
Localizer	Utility class that encapsulates all of the localization related functionality in a way that is can be accessed by all areas of the framework in a consistent way.
MarkupContainer	A MarkupContainer holds a map of child components.
MarkupInheritanceResolver	Detect <wicket:extend> and <wicket:child> tags, which are silently ignored, because they have already been processed.
Page	Abstract base class for pages.
PageMap	THIS CLASS IS NOT PART OF THE WICKET PUBLIC API.
PageParameters	A typesafe abstraction and container for parameters to a requested page.
PageState	A record of state for a Page which can be used to reproduce the original Page at a later time when getPage() is called.
Request	Base class for page request implementations allowing access to request parameters.
RequestCycle	THIS CLASS IS DELIBERATELY NOT INSTANTIABLE BY FRAMEWORK CLIENTS AND IS NOT INTENDED TO BE SUBCLASSED BY FRAMEWORK CLIENTS.
Resource	A Resource is something that implements IResourceListener and provides a getResource() method which returns the raw IResource to be rendered back to the client browser.
ResourceReference	ResourceReference is essentially a reference to an actual resource which is shared through the Application.
Response	Abstract base class for different implementations of response writing.
Session	Holds information about a user session, including some fixed number of most recent pages (and all their nested component information).
SharedResources	Class which holds shared resources.
WicketMessageResolver	This is a tag resolver which handles <wicket:message attr="myKey">Default Text</wicket:message>.
WicketMessageResolver.MyLabel	A Label with expands open-close tags to open-body-close if required

Exception Summary

ApplicationFactoryCreationException	Thrown when the IWebApplicationFactory cannot be created for some reason.
WicketRuntimeException	Generic runtime exception subclass thrown by wicket.

Package wicket Description

The core Wicket package. The key core classes you will need to learn to do basic Wicket programming are:

• Application / WebApplication - Subclass WebApplication to create your application. Set your home page with Application.getPages().setHomePage(MyHomePage.class). Configure Wicket for deployment with Application.getSettings().configure("deployment"). Substitute "development" to get default settings for a development environment.
• Component - You will need to carefully study this class as Component is very central to Wicket. There are a large number of convenience methods in Component and, naturally, every component in Wicket is a subclass of Component, so all these methods are available to all Components.
• IRequestCycleFactory - If you are working with a persistence framework such as Hibernate or JDO, you may need to implement a request cycle factory in order to open a persistence session at the beginning of a request and close the session at the end of the request.
• ISessionFactory - For all but the most trivial applications, you will need to create your own session factory. Your implementation of this interface will generally be quite simple, generally just returning a new instance of your own application-specific subclass of WebSession.
• MarkupContainer - You will need to study MarkupContainer carefully as this class contains all the logic for creating and maintaining component hierarchies.
• Page / WebPage - Every page in your wicket application will extend WebPage (or some other subclass of Page if you are writing something other than a web application). There are a number of important methods in Page and you should be familiar with all of them.
• PageParameters - A simple wrapper for query string parameters.
• Session / WebSession - It is particularly important to understand Session if you are doing clustering, but even for a very basic application you will want to create your own subclass of WebSession using a session factory so that you can store any session properties in a typesafe way. Note that since Pages are first class objects with models of their own, it is likely or at least possible that you will not have many session properties.