Package org.apache.wicket

The core Wicket package.

See: Description

Interface Summary

Interface	Description
IApplicationListener	Application lifecycle listener
IBehaviorInstantiationListener	Allows applications to intercept behavior instantiation
IComponentAwareEventSink	A specialization of IEventSink that adds component as an additional parameter to the IComponentAwareEventSink.onEvent(Component, IEvent) method.
IConverterLocator	Locates the proper converter instance for a given type.
IDetachListener	Listens to Component.detach() calls.
IEventDispatcher	Delivers an event to a component.
IGenericComponent<T,C extends IGenericComponent<? super T,?>>	An interface for all components with type-safe accessors and mutators for the model and its object.
IInitializer	Initializes something when application loads.
IMarkupIdGenerator	Generates markup ids for components
IPageFactory	A factory class that creates Pages.
IPageManagerProvider
IPageRendererProvider	Interface for Function<RenderPageRequestHandler, PageRenderer>
IQueueRegion	Demarcates components that act as a root can dequeue children.
IRequestCycleProvider	Provides instances of RequestCycle objects
IRequestListener	Interface to be implemented by Components or Behaviors that listen for requests from the client browser.
IResourceFactory	A factory which creates resources for a given specification string.
ISessionListener	Session listener
IWicketInternalException	A marker interface for exceptions which are recommended to be handled by the framework

Class Summary

Class	Description
Application	Base class for all Wicket applications.
ApplicationListenerCollection	ListenerCollection for IApplicationListeners
AttributeModifier	This class allows a tag attribute of a component to be modified dynamically with a value obtained from a model object.
BehaviorInstantiationListenerCollection	ListenerCollection for IBehaviorInstantiationListeners
ClassAttributeModifier	An AttributeModifier specialized in managing the CSS class attribute
Component	Component serves as the highest level abstract base class for all components.
ConverterLocator	Implementation of IConverterLocator interface, which locates converters for a given type.
DefaultExceptionMapper	If an exception is thrown when a page is being rendered this mapper will decide which error page to show depending on the exception type and application configuration
DefaultMapperContext	Wicket's default implementation for the mapper context
DefaultMarkupIdGenerator	An implementation of IMarkupIdGenerator that uses the Session to generate sequence numbers for the component markup ids.
DefaultPageManagerProvider	IPageManagerProvider implementation that creates new instance of IPageManager that persists the pages in DiskDataStore
DequeueContext	Context for component dequeueing.
DequeueContext.Bookmark	A bookmark for the DequeueContext stack
Initializer	Initializer for components in wicket core library.
Localizer	A utility class that encapsulates all of the localization related functionality in a way that it can be accessed by all areas of the framework in a consistent way.
MarkupContainer	A MarkupContainer holds a map of child components.
MetaDataEntry<T>	Class used for holding meta data entries.
MetaDataKey<T>	A key to a piece of metadata associated with a Component, Session or Application at runtime.
Page	Abstract base class for pages.
PageReference	Unique identifier of a page instance
RequestListenerInterface	Deprecated This class is not used by the framework anymore.
ResourceBundles	Contains all resource bundles that are registered in the application.
Session	Holds information about a user session, including some fixed number of most recent pages (and all their nested component information).
SessionListenerCollection	ListenerCollection for ISessionListeners
SharedResources	Class which holds shared resources.
StyleAttributeModifier	An AttributeModifier specialized in managing the CSS style attribute
SystemMapper	Mapper that encapsulates mappers that are necessary for Wicket to function.
SystemMapper.HomePageProvider<C extends Page>
SystemMapper.ParentFolderPlaceholderProvider
ThreadContext	Holds thread local state for Wicket data.
UrlResourceReferenceMapper	A request mapper that is used to create Url out of UrlResourceReference.

Enum Summary

Enum	Description
AttributeModifier.MarkerValue	Special attribute value markers.
ChildToDequeueType
DequeueTagAction
RuntimeConfigurationType

Exception Summary

Exception	Description
NonResettingRestartException	Causes Wicket to interrupt current request processing and immediately respond with the specified page.
RestartResponseAtInterceptPageException	Causes Wicket to interrupt current request processing and immediately redirect to an intercept page.
RestartResponseException	Causes Wicket to interrupt current request processing and immediately respond with the specified page.
WicketRuntimeException	Generic runtime exception subclass thrown by Wicket.

Package org.apache.wicket Description

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

• wicket.Application / wicket.protocol.http.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.
• wicket.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.
• wicket.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.
• wicket.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.
• wicket.MarkupContainer - You will need to study MarkupContainer carefully as this class contains all the logic for creating and maintaining component hierarchies.
• wicket.Page / wicket.markup.html.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.
• wicket.PageParameters - A simple wrapper for query string parameters.
• wicket.Session / wicket.protocol.http.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.