A–Z index

Every Wicket class the guide explains, and every page by title.

Classes

Interfaces are sorted without their leading I, so IModel is under M.

A

AbstractAesGcmCryptScheme: Encryption in Wicket
AbstractAjaxTimerBehavior: Write Ajax handlers as lambdas Ajax behaviors
AbstractAuthenticatedWebSession: Log users in
AbstractChoice: Translate the options of a choice
AbstractCryptFactory: Encryption in Wicket
AbstractCspHeaderItem: Header items
AbstractDefaultAjaxBehavior: Change how an Ajax request is sent Wrap a JavaScript widget in a component Ajax behaviors How Wicket Ajax works
AbstractErrorPage: Handle exceptions and show error pages
AbstractFormValidator: Validators and converters
AbstractLink: Link to a page
AbstractPropertyModel: Model classes
AbstractRepeater: Repeaters
AbstractResource: Generate a resource in code How Wicket serves resources
AbstractSingleSelectChoice: Translate the options of a choice
AbstractVeilBehavior: Block the page while a request runs
AccessDeniedPage: Handle exceptions and show error pages
AesGcmCryptScheme: Encryption in Wicket
AesGcmSivCryptScheme: Encryption in Wicket
AjaxButton: Update a page with Ajax Ajax components Form components
AjaxCallListener: React to Ajax requests in JavaScript Ajax behaviors
AjaxChannel: Change how an Ajax request is sent
AjaxCheckBox: Ajax components
AjaxClientInfoBehavior: Ajax behaviors
AjaxDisableComponentListener: Show that a request is running Ajax behaviors
AjaxDownloadBehavior: Ajax behaviors
AjaxEditableLabel: Ajax components
AjaxEventBehavior: Write Ajax handlers as lambdas Ajax behaviors
AjaxFallbackButton: Ajax components Form components
AjaxFallbackDefaultDataTable: Page through data Ajax components Repeaters
AjaxFallbackLink: Use Ajax on stateless pages Ajax components
AjaxFileDropBehavior: Ajax behaviors
AjaxFormChoiceComponentUpdatingBehavior: Ajax behaviors
AjaxFormComponentUpdatingBehavior: Write Ajax handlers as lambdas Combine fields into one form component Use Ajax on stateless pages Ajax behaviors
AjaxFormSubmitBehavior: Write Ajax handlers as lambdas Ajax behaviors
AjaxFormValidatingBehavior: Ajax behaviors
AjaxIndicatorAppender: Show that a request is running Ajax behaviors
AjaxLazyLoadPanel: Ajax components
AjaxLink: Update a page with Ajax Update components with Ajax Ajax components
AjaxListPanel: Ajax components
AjaxNewWindowNotifyingBehavior: Ajax behaviors
AjaxPagingNavigator: Page through data Ajax components Repeaters
AjaxRequestAttributes: React to Ajax requests in JavaScript Change how an Ajax request is sent How Wicket Ajax works
AjaxRequestHandler: How Wicket Ajax works
AjaxRequestTarget: Update a page with Ajax Update components with Ajax Glossary How Wicket Ajax works
AjaxRequestTarget.IListener: Change how an Ajax request is sent
AjaxSelfUpdatingTimerBehavior: Update a page with Ajax Ajax behaviors
AjaxSubmitLink: Use Ajax on stateless pages Ajax components Form components
AjaxTabbedPanel: Ajax components
AnnotationsRoleAuthorizationStrategy: Restrict access by role
Application: Switch between development and deployment mode Configure a module with an initializer Share a resource across the application Application settings Glossary Request processing
ApplicationContextMock: Test with Spring
ApplicationKeyCryptFactory: Encrypt URLs Encryption in Wicket
ApplicationMBean: Inspect and change settings with JMX
ApplicationSettings: Handle exceptions and show error pages Application settings
ApplicationSettingsMBean: Inspect and change settings with JMX
AsynchronousPageStore: How pages are stored
AttributeAppender: Change a tag's attributes
AttributeModifier: Change a tag's attributes
Audio: Serve files from your Java packages
AuthenticatedWebApplication: Log users in Wicket modules
AuthenticatedWebSession: Log users in
AuthorizeAction: Restrict access by role
AuthorizeActions: Restrict access by role
AuthorizeInstantiation: Restrict access by role
AuthorizeInstantiations: Restrict access by role
AuthorizeResource: Restrict access by role
AutoCompleteBehavior: Ajax behaviors
AutoCompleteTextField: Ajax components
AutoLabelResolver: Wicket tags and attributes
AutoLabelTextResolver: Wicket tags and attributes
AutoLinkResolver: Turn plain links into page links with wicket:link Wicket tags and attributes
IAjaxCallListener: React to Ajax requests in JavaScript
IAjaxIndicatorAware: Show that a request is running
IAuthorizationStrategy: Restrict access by role How Wicket keeps applications secure

B

BaseWebSocketBehavior: WebSocket JavaScript API
BaseWicketTester: Test pages and components WicketTester
BeanValidationConfiguration: Validate with Bean Validation
Behavior: Add behavior to a component with a Behavior Change a tag's attributes Use more than one model in a component Handle a callback URL with IRequestListener Component lifecycle Glossary
BookmarkableMapper: Request mappers
BookmarkablePageLink: Give every page the same layout Link to a page Keep a page stateless Use links on stateless pages
Border: Wrap content with a Border Glossary Wicket tags and attributes
BorderBehavior: Wrap content with a Border
Broadcast: Send events between components
BufferedResponseMapper: Request mappers Redirects after a request
BundleStringResourceLoader: Load texts from your own source
Button: Use more than one submit button Form components
ByteArrayResource: Generate a resource in code

C

CachingPageStore: How pages are stored
CachingResourceStreamLocator: Customize where resources are loaded from
CallbackParameter: Wrap a JavaScript widget in a component
CdiConfiguration: Inject CDI beans Inject with JSR-330 annotations
ChainingModel: Chain models Model classes
Check: Use checkboxes and radio buttons Form components
CheckBox: Use checkboxes and radio buttons Form components
CheckBoxMultipleChoice: Use checkboxes and radio buttons Translate the options of a choice Form components
CheckboxMultipleChoiceSelector: Use checkboxes and radio buttons
CheckBoxSelector: Use checkboxes and radio buttons
CheckGroup: Use checkboxes and radio buttons Form components
CheckGroupSelector: Use checkboxes and radio buttons
ChoiceRenderer: Let the user pick from a list
ClassAttributeModifier: Change a tag's attributes
ClassPathResourceFinder: Customize where resources are loaded from
ClassStringResourceLoader: Where Wicket looks for texts
CollectionModel: Model classes
Component: Translate component texts Give a component a markup id Use more than one model in a component Render a component without its tag Handle a callback URL with IRequestListener Show, hide or disable a component Component lifecycle Glossary How Wicket localizes Best practices How Wicket keeps applications secure Why component-oriented
ComponentDetachableModel: Model classes
ComponentModel: Model classes
ComponentPropertyModel: Model classes
ComponentRenderer: Test markup
ComponentResolvers: How markup becomes components
ComponentStringResourceLoader: Where Wicket looks for texts
ComponentTag: Add behavior to a component with a Behavior
CompositeCssCompressor: Minify and compress CSS and JavaScript
CompositeJavaScriptCompressor: Minify and compress CSS and JavaScript
CompoundPropertyModel: Chain models Show images from an external URL Bind components to a JavaBean Glossary Model classes
CompoundRequestMapper: Request mappers
CompoundValidator: Validators and converters
ConcatResourceBundleReference: Combine resources into one bundle
ConnectedMessage: Push updates over a WebSocket
ContentDisposition: Generate a resource in code
ContentSecurityPolicySettings: Configure the Content Security Policy Application settings Security headers and external checks How Wicket keeps applications secure
ContextImage: Use files from the web application root
ContextRelativeResource: Use files from the web application root
ContextRelativeResourceReference: Use files from the web application root
ConversationalComponent: Inject CDI beans
ConversationPropagation: Inject CDI beans
ConversionException: Convert input to your types
ConverterLocator: Convert input to your types Validators and converters
CreditCardValidator: Validators and converters
CrossOrigin: Show images from an external URL
CrossOriginEmbedderPolicyConfiguration: Isolate the page with COOP and COEP
CrossOriginEmbedderPolicyRequestCycleListener: Isolate the page with COOP and COEP
CrossOriginOpenerPolicyConfiguration: Isolate the page with COOP and COEP
CrossOriginOpenerPolicyRequestCycleListener: Isolate the page with COOP and COEP
CryptingPageStore: Configure the page store Encryption in Wicket How pages are stored
CryptoMapper: Protect against cross-site request forgery Encrypt URLs Encryption in Wicket Request mappers How Wicket keeps applications secure
CSPDirective: Configure the Content Security Policy
CSPDirectiveSrcValue: Configure the Content Security Policy
CSPHeaderConfiguration: Configure the Content Security Policy
CssContentHeaderItem: Header items
CssHeaderItem: Add CSS and JavaScript to a page Use files from the web application root Header items
CssReferenceHeaderItem: Header items
CssResourceReference: Add CSS and JavaScript to a page Combine resources into one bundle
CssUrlReferenceHeaderItem: Header items
CssUrlReplacer: Minify and compress CSS and JavaScript
IChoiceRenderer: Let the user pick from a list
IColumn: Repeaters
IComponentAssignedModel: Model classes
IComponentAwareHeaderContributor: React to Ajax requests in JavaScript
IComponentInheritedModel: Bind components to a JavaBean Model classes
IComponentInitializationListener: Component lifecycle
IComponentInstantiationListener: Component lifecycle Best practices
IComponentOnAfterRenderListener: Component lifecycle
IComponentOnBeforeRenderListener: Component lifecycle
IComponentOnConfigureListener: Component lifecycle
IComponentResolver: How markup becomes components
IConverter: Convert input to your types Glossary Validators and converters How a form is processed
IConverterLocator: Convert input to your types
ICrypt: Encryption in Wicket
ICryptFactory: Encrypt URLs Encryption in Wicket
ICryptScheme: Encryption in Wicket
ICssCompressor: Minify and compress CSS and JavaScript

D

DataGridView: Repeaters
DataTable: Repeaters
DataView: Page through data Repeaters
DateTextField: Form components
DateValidator: Validators and converters
DebugBar: Configure the page store Wicket modules
DebugSettings: Application settings
DebugSettingsMBean: Inspect and change settings with JMX
DefaultDataTable: Page through data Repeaters
DefaultExceptionMapper: Handle exceptions and show error pages
DefaultItemReuseStrategy: Control how items are reused with RefreshingView
DefaultJavaScriptCompressor: Minify and compress CSS and JavaScript
DefaultMapperContext: Give pages readable URLs Request mappers
DefaultMarkupIdGenerator: Give a component a markup id
DefaultPageManagerProvider: Configure the page store How pages are stored
DiskPageStore: How pages are stored
DropDownChoice: Let the user pick from a list Translate the options of a choice Form components
DynamicImageResource: Generate a resource in code
IDataProvider: Page through data Repeaters
IDetachable: Load data once per request with detachable models Use more than one model in a component Model classes Models and component data

E

EmailAddressValidator: Validators and converters
EmailTextField: Form components
Enclosure: Hide surrounding markup with wicket:enclosure Wicket tags and attributes
EnclosureContainer: Hide surrounding markup with wicket:enclosure Wicket tags and attributes
EnumChoiceRenderer: Let the user pick from a list Translate the options of a choice
EqualInputValidator: Validators and converters
EqualPasswordInputValidator: Validate input and show errors Validators and converters
ExceptionErrorPage: Handle exceptions and show error pages
ExceptionSettings: Handle exceptions and show error pages Render a component without its tag Application settings
ExternalImage: Show images from an external URL
ExternalLink: Link to another site
ExternalSource: Show images from an external URL
IEvent: Send events between components
IEventDispatcher: Send events between components
IEventSink: Send events between components
IEventSource: Send events between components
IExceptionMapper: Handle exceptions and show error pages Request processing

F

FeedbackPanel: Build a form that saves data Validate input and show errors Form components Glossary
FetchMetadataResourceIsolationPolicy: Protect against cross-site request forgery
FilePageStore: Configure the page store
FilesSelectedBehavior: Ajax behaviors
FileSystemJarPathService: Serve files with NIO
FileSystemPathService: Serve files with NIO
FileSystemResource: Serve files with NIO
FileSystemResourceReference: Serve files with NIO
FileUpload: Upload files
FileUploadField: Upload files Form components
FileUploadToResourceField: Ajax components Form components
FilteredHeaderItem: Put JavaScript at the end of the body Header items
FilteringHeaderResponse: Put JavaScript at the end of the body Header items
Form: Build a form that saves data Nest forms Build a stateless form Upload files Form components Glossary How a form is processed
FormComponent: Convert input to your types Combine fields into one form component Validate input and show errors Form components How a form is processed
FormComponentLabel: Form components
FormComponentPanel: Combine fields into one form component Form components
FormComponentUpdatingBehavior: Chain models
FormTester: Test a page with WicketTester Test forms WicketTester
Fragment: Swap markup with fragments Glossary Wicket tags and attributes
FrameworkSettings: Application settings
IFormSubmitter: Use more than one submit button How a form is processed
IFormSubmittingComponent: Use more than one submit button
IFormValidator: Validators and converters How a form is processed

G

GenericBaseModel: Model classes
GenericPanel: Build a reusable panel Model classes
GenericWebPage: Model classes
GridView: Repeaters
GroupedDropDownChoice: Let the user pick from a list Form components
GuiceComponentInjector: Inject with JSR-330 annotations

H

HeaderItem: Declare dependencies between resources Glossary Header items
HeaderResponseContainer: Put JavaScript at the end of the body
HeaderResponseDecoratorCollection: Put JavaScript at the end of the body Header items
HiddenField: Form components
HomePageMapper: Request mappers
HtmlHeaderResolver: Wicket tags and attributes
HtmlImportHeaderItem: Header items
HttpsConfig: Require HTTPS
HttpsMapper: Require HTTPS Request mappers
IHeaderContributor: Add CSS and JavaScript to a page Header items
IHeaderResponse: Add behavior to a component with a Behavior Add CSS and JavaScript to a page Header items How Wicket serves resources
IHeaderResponseDecorator: Put JavaScript at the end of the body

I

IInitializer: Configure a module with an initializer
IItemReuseStrategy: Control how items are reused with RefreshingView Repeaters
Image: Serve files from your Java packages
ImageButton: Form components
IndicatingAjaxButton: Show that a request is running Write Ajax handlers as lambdas Ajax components
IndicatingAjaxFallbackLink: Show that a request is running
IndicatingAjaxLink: Show that a request is running Ajax components
InitializerStringResourceLoader: Where Wicket looks for texts
Injector: Inject Spring beans
InlineEnclosure: Hide surrounding markup with wicket:enclosure Wicket tags and attributes
InlineImage: Serve files from your Java packages
InMemoryPageStore: Configure the page store
InSessionPageStore: Configure the page store How pages are stored
InternalErrorPage: Handle exceptions and show error pages
Item: Control how items are reused with RefreshingView

J

IJavaScriptCompressor: Minify and compress CSS and JavaScript
JavaEEComponentInjector: Inject EJBs
JavaScriptBrowserProcessedContentType: Header items
JavaScriptContentHeaderItem: Header items
JavaScriptDataBlockType: Header items
JavaScriptDeferHeaderResponse: Header items
JavaScriptFilteredIntoFooterHeaderResponse: Put JavaScript at the end of the body Header items
JavaScriptHeaderItem: Add CSS and JavaScript to a page Use files from the web application root Header items
JavaScriptLibrarySettings: Run Ajax without jQuery Wrap a JavaScript widget in a component Declare dependencies between resources Application settings
JavaScriptReferenceHeaderItem: Header items
JavaScriptReferenceType: Header items
JavaScriptResourceReference: Add CSS and JavaScript to a page Wrap a JavaScript widget in a component Combine resources into one bundle
JavaScriptUrlReferenceHeaderItem: Header items
JavaxWebSocketFilter: Push updates over a WebSocket How native WebSockets work
JQueryPluginResourceReference: Declare dependencies between resources
JQueryResourceReference: Declare dependencies between resources

K

KeyInSessionCryptFactory: Encrypt URLs Encryption in Wicket

L

Label: Build your first application
LambdaChoiceRenderer: Let the user pick from a list
LambdaColumn: Page through data
LambdaModel: Build a form that saves data Chain models Read and write data with lambda models Glossary Model classes
Link: Build your first application Link to a page
ListChoice: Select several values Form components
ListDataProvider: Page through data
ListenerRequestHandler: Handle a callback URL with IRequestListener
ListItem: Show a list with ListView
ListModel: Model classes
ListMultipleChoice: Select several values Form components
ListView: Build a form that saves data Show a list with ListView Glossary Repeaters
LoadableDetachableModel: Load data once per request with detachable models Use more than one model in a component Glossary Model classes Models and component data Best practices
LocalDateTextField: Form components
LocalDateTimeField: Form components
LocalDateTimeTextField: Form components
Localizer: Load texts from your own source Where Wicket looks for texts How Wicket localizes
LocalTimeTextField: Form components
LocalVeilBehavior: Block the page while a request runs
Loop: Show a list with ListView Repeaters

M

IMapperContext: Give pages readable URLs Request mappers
IMarkupCacheKeyProvider: Generate markup from code
IMarkupFilter: How markup becomes components
IMarkupIdGenerator: Give a component a markup id
IMarkupResourceStreamProvider: Generate markup from code
IModel: Read and write data with lambda models Glossary Model classes Models and component data Best practices
IModelComparator: Model classes
MapModel: Model classes
MarkupCache: How markup becomes components
MarkupContainer: Add components without repeating the markup hierarchy Component lifecycle Markup inheritance Why component-oriented
MarkupFactory: Generate markup from code How markup becomes components
MarkupParser: How markup becomes components
MarkupSettings: Give a component a markup id Turn plain links into page links with wicket:link Application settings Wicket tags and attributes
MarkupSettingsMBean: Inspect and change settings with JMX
MaskConverter: Validators and converters
MetaDataHeaderItem: Header items
MetaDataKey: Keep data in the session
MetaDataRoleAuthorizationStrategy: Restrict access by role
MockHttpServletResponse: Test pages and components
ModalDialog: Ajax components
Model: Model classes Models and component data
ModelIteratorAdapter: Control how items are reused with RefreshingView
MountedMapper: Give pages readable URLs Request mappers
MultiFileUploadField: Upload files Form components

N

NestedStringResourceLoader: Load texts from your own source
NestedTree: Ajax components Repeaters
NoCrypt: Encryption in Wicket
NoCryptFactory: Encryption in Wicket
NonContextual: Inject CDI beans
NoOpTextCompressor: Minify and compress CSS and JavaScript
NumberTextField: Form components

O

IObjectClassAwareModel: Model classes
IOnComponentTagListener: Component lifecycle
OnChangeAjaxBehavior: Write Ajax handlers as lambdas Ajax behaviors
OnDomReadyHeaderItem: Add CSS and JavaScript to a page Wrap a JavaScript widget in a component Header items
OnEventHeaderItem: Configure the Content Security Policy Header items
OnLoadHeaderItem: Header items
OriginResourceIsolationPolicy: Protect against cross-site request forgery

P

IPackageResourceGuard: Control which package resources are served
IPageable: Repeaters
IPageFactory: How pages are stored
IPageManager: How pages are stored
IPageParametersEncoder: Request mappers
IPageProvider: How pages are stored
IPageStore: How pages are stored
IPartialPageRequestHandler: Update components with Ajax How Wicket Ajax works
IPropertyReflectionAwareModel: Model classes
PackageMapper: Give pages readable URLs Request mappers
PackageResourceGuard: Control which package resources are served
PackageResourceReference: Serve files from your Java packages How Wicket serves resources
PackageStringResourceLoader: Load texts from your own source Where Wicket looks for texts
Page: Keep a page stateless Glossary Stateful and stateless pages
PageableListView: Repeaters
PageExpiredErrorPage: Handle exceptions and show error pages
PageExpiredException: Stateful and stateless pages
PageHeaderItem: Control the order of header items Header items
PageIdKey: Test WebSocket behaviors
PageInstanceMapper: Request mappers
PageParameters: Give a resource a URL Pass parameters to a page Glossary
PageParametersEncoder: Request mappers
PageReference: Stateful and stateless pages
PageSettings: Application settings How markup becomes components Stateful and stateless pages
PageVeilBehavior: Block the page while a request runs
PagingNavigator: Page through data Repeaters
Palette: Select several values Form components
Panel: Give every page the same layout Build a reusable panel Glossary Wicket tags and attributes Best practices Markup inheritance
PasswordTextField: Form components
Path: Customize where resources are loaded from
PatternValidator: Validators and converters
Picture: Show images from an external URL Serve files from your Java packages
PriorityFirstComparator: Control the order of header items
PriorityHeaderItem: Control the order of header items Header items
PropertiesFactory: Where Wicket looks for texts
Property: Validate with Bean Validation
PropertyListView: Show a list with ListView Repeaters
PropertyModel: Bind components to a JavaBean Model classes
PropertyValidator: Validate with Bean Validation

Q

IQueueRegion: Add components without repeating the markup hierarchy

R

IRequestCycleListener: Handle exceptions and show error pages Request processing Security headers and external checks Best practices What happens during a request
IRequestCycleProvider: Request processing
IRequestHandler: Request processing What happens during a request
IRequestListener: Handle a callback URL with IRequestListener
IRequestMapper: Glossary Request mappers Request processing What happens during a request
IResource: Generate a resource in code Glossary How Wicket serves resources
IResourceFinder: Customize where resources are loaded from
IResourceIsolationPolicy: Protect against cross-site request forgery
IResourceStreamLocator: Customize where resources are loaded from
Radio: Use checkboxes and radio buttons Form components
RadioChoice: Use checkboxes and radio buttons Translate the options of a choice Form components
RadioGroup: Use checkboxes and radio buttons Form components
RangeTextField: Form components
RangeValidator: Validators and converters
RedirectPolicy: Redirects after a request
RedirectToUrlException: Link to another site
RefreshingView: Control how items are reused with RefreshingView Repeaters
RenderStrategy: Redirects after a request
RepeatingView: Repeat markup with RepeatingView Repeaters
ReportCSPViolationMapper: Configure the Content Security Policy
Request: Request processing
RequestCycle: Glossary Request processing What happens during a request
RequestCycleSettings: Application settings Redirects after a request
RequestLoggerMBean: Inspect and change settings with JMX
RequestLoggerSettings: Application settings
RequestPageStore: How pages are stored
RequiredTextField: Form components
RequireHttps: Require HTTPS
ResourceAggregator: Header items How Wicket serves resources
ResourceBundles: Combine resources into one bundle
ResourceIsolationRequestCycleListener: Protect against cross-site request forgery How Wicket keeps applications secure
ResourceLink: Generate a resource in code Give a resource a URL Share a resource across the application
ResourceMapper: Give a resource a URL Request mappers
ResourceModel: Translate component texts Put model values into translated texts Model classes
ResourceReference: Generate a resource in code Give a resource a URL Declare dependencies between resources Glossary How Wicket serves resources
ResourceReferenceMapper: Request mappers
ResourceReferenceRegistry: How Wicket serves resources
ResourceResponse: Generate a resource in code
ResourceSettings: Minify and compress CSS and JavaScript Load texts from your own source Control the order of header items Control which package resources are served Customize where resources are loaded from Where Wicket looks for texts Application settings
ResourceStreamLocator: Customize where resources are loaded from
Response: Request processing
RestartResponseAtInterceptPageException: Log users in
Result: WicketTester
ReuseIfModelsEqualStrategy: Control how items are reused with RefreshingView
RoleAuthorizationStrategy: Restrict access by role
Roles: Restrict access by role
RuntimeConfigurationType: Switch between development and deployment mode Application settings

S

ISerializer: How pages are stored
ISessionListener: Keep data in the session
ISortableDataProvider: Repeaters
IStringResourceLoader: Load texts from your own source Where Wicket looks for texts How Wicket localizes
Scheme: Require HTTPS
SchemeCrypt: Encryption in Wicket
SecurePackageResourceGuard: Control which package resources are served
SecuritySettings: Configure the page store Isolate the page with COOP and COEP Encrypt URLs Application settings Encryption in Wicket Security headers and external checks
Select: Select several values Form components
SelectOptions: Select several values Form components
SerializingPageStore: How pages are stored
ServletWebRequest: Request processing
ServletWebResponse: Request processing
Session: Translate component texts Keep data in the session Glossary Request processing How Wicket localizes
SessionCountListener: Measure with Wicket metrics
SetModel: Model classes
SharedResourceReference: Share a resource across the application
SharedResources: Share a resource across the application
SortableDataProvider: Page through data
Source: Serve files from your Java packages
SpringBean: Inject Spring beans Test with Spring
SpringComponentInjector: Inject with JSR-330 annotations Inject Spring beans Test with Spring Wicket modules
SpringWebApplicationFactory: Inject Spring beans
StatelessChecker: Keep a page stateless
StatelessComponent: Keep a page stateless
StatelessForm: Keep a page stateless Use Ajax on stateless pages Build a stateless form Form components
StatelessLink: Keep a page stateless Use links on stateless pages
StoreSettings: Configure the page store Application settings
StringHeaderItem: Header items
StringResourceModel: Put model values into translated texts Model classes
StringResourceStream: Generate markup from code
StringValidator: Build a form that saves data Validate input and show errors Validators and converters
StringValue: Pass parameters to a page
StyleAttributeModifier: Change a tag's attributes
SubmitLink: Use more than one submit button Form components
SubresourceHeaderResponse: Header items
SystemMapper: Request mappers

T

TableTree: Ajax components Repeaters
TagTester: Test markup WicketTester
TextArea: Build a form that saves data Form components
TextField: Build a form that saves data Form components
TextRequestHandler: Handle a callback URL with IRequestListener
ThrottlingSettings: Change how an Ajax request is sent
TimeField: Form components
TransparentWebMarkupContainer: Group components with WebMarkupContainer

U

UploadProgressBar: Upload files Ajax components Form components
UrlPathPageParametersEncoder: Give pages readable URLs Request mappers
UrlResourceReference: Declare dependencies between resources
UrlTextField: Form components
UrlValidator: Validators and converters
UsernamePasswordPage: Log users in
UsernamePasswordPanel: Log users in

V

IValidator: Validate input and show errors Glossary Validators and converters How a form is processed
ValidationError: Validate input and show errors Validators and converters
ValidatorStringResourceLoader: Where Wicket looks for texts
VelocityPanel: Wicket modules
Video: Serve files with NIO Serve files from your Java packages

W

IWebSocketConnectionRegistry: How native WebSockets work
IWebSocketPushMessage: Test WebSocket behaviors Push updates over a WebSocket How native WebSockets work
IWrapModel: Model classes
WebApplication: Build your first application Create a project from the quickstart archetype Switch between development and deployment mode Give pages readable URLs Give a resource a URL Combine resources into one bundle Application settings Request mappers Request processing
WebApplicationPath: Customize where resources are loaded from
WebMarkupContainer: Update a page with Ajax Group components with WebMarkupContainer Repeat markup with RepeatingView Show, hide or disable a component
WebPage: Build your first application Give every page the same layout Security headers and external checks Markup inheritance Why component-oriented
WebPageRenderer: Redirects after a request
WebRequest: Request processing
WebResponse: Request processing Security headers and external checks
WebSession: Keep data in the session Best practices
WebSocketAwareResourceIsolationRequestCycleListener: Protect against cross-site request forgery
WebSocketBehavior: Push updates over a WebSocket Wicket modules WebSocket JavaScript API How native WebSockets work
WebSocketConnectionOriginFilter: Protect against cross-site request forgery
WebSocketPushBroadcaster: Push updates over a WebSocket How native WebSockets work
WebSocketPushPayload: Push updates over a WebSocket
WebSocketRequestHandler: Push updates over a WebSocket How native WebSockets work
WebSocketResource: Push updates over a WebSocket How native WebSockets work
WebSocketSettings: Push updates over a WebSocket WebSocket JavaScript API
WebSocketTester: Test WebSocket behaviors
WicketAjaxJQueryResourceReference: Run Ajax without jQuery
WicketAjaxResourceReference: Run Ajax without jQuery
WicketContainerResolver: Wicket tags and attributes
WicketFilter: Create a project from the quickstart archetype Application settings Request processing What happens during a request
WicketLinkTagHandler: Turn plain links into page links with wicket:link
WicketMessageResolver: Wicket tags and attributes
WicketMetrics: Measure with Wicket metrics
WicketMetricsSettings: Measure with Wicket metrics
WicketServlet: Application settings
WicketTagIdentifier: How markup becomes components
WicketTestCase: WicketTester
WicketTester: Test a page with WicketTester Create a project from the quickstart archetype Test forms Test markup Test pages and components Test WebSocket behaviors Test with Spring Glossary Maven dependencies Wicket modules WicketTester
WicketTesterExtension: WicketTester
WicketWebSocketJQueryResourceReference: WebSocket JavaScript API
WriteCallback: Generate a resource in code

X

XForwardedRequestWrapperFactory: Require HTTPS

Z

ZonedDateTimeField: Form components

Pages

Add behavior to a component with a Behavior How-to Write a Behavior that changes a component's tag, adds markup around it or contributes CSS and JavaScript, and reuse it on any kind of component.
Add components without repeating the markup hierarchy How-to Queue components on a page or panel and let Wicket put each one in the right container by following the nesting in the markup.
Add CSS and JavaScript to a page How-to Let a component or behavior add its stylesheets, script files and start-up code to the page header with renderHead and header items.
Ajax behaviors Reference The Ajax behaviors and call listeners in wicket-core and wicket-extensions, the callback each one calls and its lambda factory method.
Ajax components Reference The Ajax components in wicket-core and wicket-extensions, what each does and which callback you override.
Application settings Reference How a Wicket application is started and configured, the settings objects with their main options and defaults, and what development and deployment mode change.
Best practices Explanation The habits that keep a Wicket application easy to change and to test, each with the reason it follows from how Wicket works.
Bind components to a JavaBean How-to Read and write bean properties with PropertyModel, and let form fields find their property by id with CompoundPropertyModel.
Block the page while a request runs How-toWicket 11+ Cover the page or one component with a veil during Ajax requests, so a second click cannot send the same request twice.
Build a form that saves data Tutorial Add a guestbook page with a form that validates its input, saves entries and lists them, and shows errors and a confirmation.
Build a reusable panel How-to Package a piece of user interface as a Panel, a Java class with its own HTML file, and use it on any page as often as you need.
Build a stateless form How-to Use StatelessForm so a page with a form stays stateless, never expires and does not create a session until it must.
Build your first application Tutorial Generate a project from the quickstart, run it, and build a home page with a label, a click counter and a link to a second page.
Chain models How-to Wrap one model in another so that a form, a panel or a label always works on the object the inner model currently holds.
Change a tag's attributes How-to Set, append to or remove an attribute of a component's tag from Java, with a fixed value or one that follows a model.
Change how an Ajax request is sent How-to Override updateAjaxAttributes to throttle requests, send them as POST, pass extra parameters, drop outdated ones or stop the browser's default action.
Combine fields into one form component How-to Build a FormComponentPanel that shows several inputs but converts, validates and stores them as one value.
Combine resources into one bundle How-to Serve several package stylesheets or scripts as one file with ResourceBundles, and replace a resource throughout the application with addResourceReplacement.
Component lifecycle Reference The stages a component goes through and every hook method Wicket calls on it, in order, with who calls it and when.
Configure a module with an initializer How-to Let a jar configure every Wicket application it is added to, with an IInitializer registered through the Java ServiceLoader.
Configure the Content Security Policy How-to Work with the strict Content Security Policy Wicket sends by default, allow extra sources, report violations, and move inline scripts and styles out of the markup.
Configure the page store How-to Change how much page history Wicket keeps per session and where, encrypt stored pages, or replace the disk store with another store.
Control how items are reused with RefreshingView How-to Build repeater items from models you supply, and keep an item's components across renders as long as its model stays in the list.
Control the order of header items How-to Put a header item first with PriorityHeaderItem, let the page's own items come before those of its components, and fix where Wicket inserts items with wicket:header-items.
Control which package resources are served How-to Allow or block files on the classpath that browsers may request as package resources, with patterns on SecurePackageResourceGuard.
Convert input to your types How-to Tell a field which type its input becomes, write a converter for your own type and register it for one field or the whole application.
Create a project from the quickstart archetype How-to Generate a ready-to-run Wicket project with Maven, know what is in it, and open it in your IDE.
Customize where resources are loaded from How-to Make Wicket find markup, properties and package files in a folder of the web application or the file system by adding resource finders.
Declare dependencies between resources How-to Make a script or stylesheet pull in the libraries it needs by overriding getDependencies, so Wicket always renders them first and only once.
Encrypt URLs How-toWicket 11+ Hide class names and component paths behind encrypted URLs with CryptoMapper, and choose where the key lives so that stateless pages keep working.
Encryption in Wicket ReferenceWicket 11+ The crypt API behind encrypted URLs, the encrypted page store and upload tokens; its schemes, key factories, settings and ciphertext format.
Form components Reference Every form, input, choice, upload and submit component in wicket-core and wicket-extensions, with the markup tag it needs and the type of its model.
Generate a resource in code How-to Build files on request, such as a CSV export, a PDF or an image, by extending AbstractResource or writing a lambda, and offer them for download with ResourceLink.
Generate markup from code How-to Give a panel or page markup built in Java instead of an HTML file, and control whether Wicket caches it.
Give a component a markup id How-to Render the HTML id attribute of a component so JavaScript, CSS, labels and Ajax can find it, and choose or generate the id yourself.
Give a resource a URL How-to Mount a resource reference on a path of your choice with mountResource, read path and query parameters in the resource, and link to the mounted URL.
Give every page the same layout Tutorial Move the header, navigation and footer of your application into a base page and two panels, so every page shares one layout.
Give pages readable URLs How-to Mount pages on paths of your choice, put page parameters in path segments with placeholders, and mount a whole package at once.
Glossary Reference Plain-English definitions of the Wicket terms used in this guide, each compared with what other web frameworks call it.
Group components with WebMarkupContainer How-to Attach a plain HTML element to a container component so you can hide, disable, style or repaint a group of components as one.
Handle a callback URL with IRequestListener How-to Let a component or behavior answer requests to a URL of its own, read parameters from the request, and respond with the page or anything else.
Handle exceptions and show error pages How-to Replace Wicket's error pages, choose what users see after an unexpected exception, and map your own exceptions and HTTP errors to pages.
Header items Reference Every header item type with its factory methods, the tag it renders and where it ends up, the rendering order, Ajax behaviour and the header response decorators.
Hide surrounding markup with wicket:enclosure How-to Hide a caption, label or table row together with the component it describes, without a container component in Java.
How a form is processed Explanation The order in which Wicket checks, converts, validates and stores submitted input, and why a form updates all its models or none.
How markup becomes components Explanation How Wicket loads, parses and caches markup, and how Wicket tags turn into auto components that you never add yourself.
How native WebSockets work Explanation How Wicket connects a page to a WebSocket, routes messages to components, pushes updates from other threads, and what that means for sessions and locking.
How pages are stored Explanation How Wicket finds the page for a request, and the chain of stores that keeps stateful pages in the request, the session and on disk.
How Wicket Ajax works Explanation What happens between a click in the browser and the updated components on the page, and why components need a markup id.
How Wicket keeps applications secure Explanation What Wicket defends against by default (escaping, a strict CSP, stateful URLs and encryption) and what it leaves to your application and your deployment.
How Wicket localizes Explanation Where the locale of a page comes from, why texts live in properties files next to the components that use them, and why the page can override its panels.
How Wicket serves resources Explanation What resources and resource references are, why components carry their own CSS and JavaScript, and how Wicket gives every file a cacheable URL.
Inject CDI beans How-to Configure wicket-cdi so pages, components, behaviors and the session get CDI beans with @Inject, and choose beans that survive serialization.
Inject EJBs How-to Inject session beans, JNDI resources and persistence units into Wicket components with @EJB, @Resource and @PersistenceUnit, through WicketStuff's javaee-inject module.
Inject Spring beans How-to Inject beans from a Spring application context into pages, components, behaviors and other objects with @SpringBean.
Inject with JSR-330 annotations How-to Use the standard @Inject and @Named annotations instead of @SpringBean, with the Spring, Guice and CDI integrations.
Inspect and change settings with JMX How-to Add wicket-jmx to see a running application's settings and session counts in JConsole, clear the markup cache, and change some settings without a restart.
Isolate the page with COOP and COEP How-to Set the Cross-Origin-Opener-Policy and Cross-Origin-Embedder-Policy headers, which Wicket sends by default, to isolate your pages from other origins.
Keep a page stateless How-to Build a page that Wicket does not store in the session, find the component that makes it stateful, and guard it with a test.
Keep data in the session How-to Store per-user data in a typed Wicket session, in session attributes or as metadata, control when the session is created, and end it on logout.
Keep preview markup out of the output How-to Leave sample content in your HTML files so they look complete in a browser or design tool, and make sure Wicket never sends it.
Let the user pick from a list How-to Show a drop-down list with DropDownChoice, render objects and enums as options, and control the empty "Choose One" option.
Link to a page How-to Navigate to another page with a Link that runs code on the server first, or with a BookmarkablePageLink that points straight at the page.
Link to another site How-to Render a link to a URL outside your application with ExternalLink, build the URL from a model, and redirect to another site from code.
Load data once per request with detachable models How-to Keep only an id in the page and load the entity fresh in every request with LoadableDetachableModel.
Load texts from your own source How-to Add a string resource loader that reads texts from a database or an existing Java ResourceBundle, and change the chain of loaders Wicket searches.
Log users in How-to Add a sign-in page with wicket-auth-roles, send anonymous users there when a page needs a signed-in user, and sign them out again.
Markup inheritance Explanation How a page or panel subclass inherits its parent's HTML along with its Java code, how wicket:child and wicket:extend merge the two, and when panels are the better tool.
Maven dependencies Reference The Maven dependencies, versions, scopes and build settings a Wicket project needs, for Wicket 10 and Wicket 11.
Measure with Wicket metrics How-to Count requests and time component creation, rendering and model loading with the experimental wicket-metrics module, AspectJ and Dropwizard Metrics.
Minify and compress CSS and JavaScript How-to Serve pre-minified .min files, strip JavaScript in deployment mode, plug in your own CSS or JavaScript compressor, and rewrite URLs inside stylesheets with CssUrlReplacer.
Model classes Reference Every model class and model interface in wicket-core, the default methods of IModel, the factory methods and the component methods that work with models.
Models and component data Explanation Why a component reads its data through a model, what happens to that data between requests, and why wrapping an entity in Model goes wrong.
Nest forms How-to Put a form inside another form, submit and validate the inner form on its own, and decide which forms take part in a submit.
Page through data How-to Load one page of rows at a time with an IDataProvider, show them in a DataView or DataTable, and let users move between pages.
Pass parameters to a page How-to Put values in the URL of a page with PageParameters, read them in the page constructor and convert them to the types you need.
Protect against cross-site request forgery How-to Refuse link clicks, form submits and Ajax calls that another site makes on behalf of your users, with ResourceIsolationRequestCycleListener.
Push updates over a WebSocket How-to Set up wicket-native-websocket, handle messages from the browser and push component updates to a page from a background thread.
Put JavaScript at the end of the body How-to Render all script header items in a container just before the closing body tag with JavaScriptFilteredIntoFooterHeaderResponse and HeaderResponseContainer.
Put model values into translated texts How-to Show translated texts through ResourceModel and StringResourceModel, fill in property values and MessageFormat parameters, and choose the key from the data.
React to Ajax requests in JavaScript How-to Run your own JavaScript before, during and after Ajax requests, for one component with a call listener or for the whole page with global events.
Read and write data with lambda models How-to Use lambdas, method references and the default methods of IModel to show computed values and bind components to properties without strings.
Redirects after a request Explanation Why Wicket answers a form submit or link click with a redirect, how the three render strategies differ, and what that means for stateless pages and clusters.
Render a component without its tag How-to Leave out a component's own HTML tag and render only its content, and know what stops working when you do.
Repeat markup with RepeatingView How-to Render a tag once for every child you add in code, for menus, button bars and other short lists you build in the constructor.
Repeaters Reference The repeaters of wicket-core and wicket-extensions compared, what each needs and when it re-creates items, plus data providers, navigators and table parts.
Request mappers Reference The request mappers that turn URLs into request handlers and back, the mount methods of WebApplication, and the syntax of mount paths.
Request processing Reference The objects that serve a request, the steps of RequestCycle in order, the request cycle listener hooks, and the request handlers Wicket ships.
Require HTTPS How-to Serve pages over HTTPS with HttpsMapper and @RequireHttps, and set up the container so redirects and absolute URLs use the right host.
Restrict access by role How-to Allow pages, components, actions and resources only for users with a given role, with annotations on classes and packages or in code.
Run Ajax without jQuery How-toWicket 11+ Switch the application to Wicket's plain JavaScript Ajax implementation, so pages no longer download jQuery.
Run on Apache Karaf How-to Install Wicket in Apache Karaf or another OSGi container with the Karaf feature that every Wicket release publishes.
Security headers and external checks Reference The response headers that scanners such as Mozilla Observatory check, which of them Wicket sends by default, and the Wicket API or hook that sets each one.
Select several values How-to Let the user select several values from a list with ListMultipleChoice, or move them between two lists with Palette.
Send events between components How-to Let a component notify others on the page without holding references to them, with send(), onEvent() and a payload class.
Serve files from your Java packages How-to Keep images, media and other files next to the component that uses them and serve them with PackageResourceReference, from Java or from markup.
Serve files with NIO How-to Serve files from the file system or from inside a ZIP archive through java.nio.file.Path with FileSystemResourceReference and FileSystemResource, including byte ranges for media.
Share a resource across the application How-to Register a resource once under an application-wide key with getSharedResources and refer to it from any component with SharedResourceReference.
Show a list with ListView How-to Render markup for every element of a java.util.List, keep form input in the rows, and avoid the pitfalls of index-based items.
Show images from an external URL How-to Render img and source tags whose URL comes from a model with ExternalImage and ExternalSource, for images on another server or a CDN.
Show that a request is running How-to Show a busy indicator while an Ajax request runs, with the indicating components, your own component or your own spinner element.
Show, hide or disable a component How-to Hide a component or make it read-only depending on the state of your application, and decide that state once per request in onConfigure.
Stateful and stateless pages Explanation Why Wicket keeps pages between requests, how page versions serve the back button, and what a stateless page gives up and gains.
Swap markup with fragments How-to Keep small alternative pieces of markup inside a page or panel and choose in Java which one to show, without a panel class for each.
Switch between development and deployment mode How-to Run Wicket in deployment mode on production servers, with a system property, a web.xml parameter or code, and check which mode is active.
Test a page with WicketTester Tutorial Write JUnit tests that render your pages, click links, submit the guestbook form and check Ajax updates, without a browser or a server.
Test forms How-to Fill in fields, pick options, upload files and submit a form in a unit test with FormTester, then check the feedback messages and the model.
Test markup How-to Find tags in the rendered output with TagTester and check their attributes and content, render a component to a string, or compare a page with an expected file.
Test pages and components How-to Render pages and single components in a unit test, click links, fire Ajax events and check what they render, with WicketTester and JUnit.
Test WebSocket behaviors How-to Send messages to a page's WebSocket behavior and check what it pushes back with WebSocketTester, without a servlet container.
Test with Spring How-to Test pages that use @SpringBean with WicketTester, either with mock beans in an ApplicationContextMock or against a real Spring test context.
Translate component texts How-to Move the texts of a page or panel into properties files, show them with wicket:message or from Java, and let the user switch the language.
Translate the options of a choice How-to Show translated options in a DropDownChoice, RadioChoice or other choice component, translate enum values, and change the "Choose One" text.
Turn plain links into page links with wicket:link How-to Write ordinary anchors to page files in the markup and let wicket:link turn them into links to bookmarkable pages, without Java code.
Update a page with Ajax Tutorial Make the click counter and the guestbook form update only the parts of the page that change, open the form without a reload, and refresh the guestbook every ten seconds.
Update components with Ajax How-to Re-render components, show hidden ones, refresh lists and run JavaScript in response to an Ajax request.
Upload files How-to Let users upload one or more files with FileUploadField, limit their size and number, and show upload progress.
Use Ajax on stateless pages How-to Make Ajax components and behaviors stateless with getStatelessHint, so a page such as a login page keeps working without a stored page instance.
Use checkboxes and radio buttons How-to Bind a checkbox to a boolean, let the user tick several options or pick one with radio buttons, and add a "select all" checkbox.
Use files from the web application root How-to Add stylesheets, scripts and images that live in the web application folder, such as src/main/webapp, to your pages with ContextRelativeResourceReference and ContextImage.
Use links on stateless pages How-to Handle clicks on a stateless page with StatelessLink and keep the state the click needs in page parameters, because every click builds a new page.
Use more than one model in a component How-to Detach the extra models a component, behavior or custom model keeps in its fields, so their data is not stored with the page.
Use more than one submit button How-to Give a form several buttons that each run their own code, pick the button for the Enter key, and add a Cancel button that skips validation.
Validate input and show errors How-to Make fields required, check their values with validators, show the error messages and change their text.
Validate with Bean Validation How-to Check form input against the Jakarta Bean Validation annotations on your domain classes with the wicket-bean-validation module.
Validators and converters Reference The built-in validators, form validators and converters, with their message keys, the variables in their messages and their default texts.
WebSocket JavaScript API Reference The Wicket.WebSocket functions and the events your JavaScript can subscribe to on a page with a WebSocket behavior.
What happens during a request Explanation How Wicket turns an HTTP request into a request handler, runs it, and cleans up afterwards, and why it is built that way.
Where Wicket looks for texts Reference The exact order in which Wicket searches resource bundles for a key, the file names it tries, and the settings that change the search.
Why component-oriented Explanation What a component-oriented framework does differently from request-based MVC frameworks, what Wicket gains from it, and what it costs.
Wicket modules Reference The artifacts Wicket is released as, what each one contains, which Wicket modules it depends on, and which you need for testing and tooling.
Wicket tags and attributes Reference Every tag and attribute in the wicket namespace, what it does, which attributes it takes, with a minimal example of each.
WicketStuff Reference The community modules of the WicketStuff project, what each one adds to Wicket, and how to add one to a Maven build.
WicketTester Reference The methods of WicketTester, grouped by purpose, with FormTester, TagTester and the JUnit helpers of the wicket-tester module.
Wrap a JavaScript widget in a component How-to Package a JavaScript library with a component, initialize it with the component's markup id, keep it working after Ajax updates and call back to the server.
Wrap content with a Border How-to Write the markup that goes around content once, as a Border, and wrap any part of a page in it while the page keeps its own components.
Write Ajax handlers as lambdas How-to Create Ajax behaviors from lambdas with their static factory methods instead of anonymous subclasses, and do the same for Ajax links and buttons.