Custom resource loading change
Migrating to Wicket 1.3
API changes
Repeaters
The repeaters package has moved from wicket-extensions into core. The package name has been changed from wicket.extensions.markup.html.repeater to wicket.markup.repeater. Notice that only DataView and backing classes have moved, the higher level components such as the DataTable are still in wicket-extensions. Also notice that the names of classes have not changed so it should be a simple matter of ctrl-shift-o in your eclipse project to relink to the new classes.
DatePicker
the DatePicker component has been removed from the wicket-extensions package. It now lives as a separate project on http://wicket-stuff.sf.net/wicket-contrib-datepicker![]()
. If you require the datepicker to be present in your code, and don't want to use the new date picker component, then add the following depenency to your maven project (or download the distribution from sourceforge):
<dependency>
<groupId>wicket-stuff</groupId>
<artifactId>wicket-contrib-datepicker</artifactId>
<version>1.2</version>
</dependency>
ISessionStore
ISessionStore had the following changes:
String getSessionId(Request request); -> String getSessionId(Request request, boolean create);
+ void onBeginRequest(Request request);
+ void onEndRequest(Request request);
+ PageMap createPageMap(String name, Session session);
By default, the creation of lasting sessions is deferred until actually needed. As long no lasting session is yet created and users are accessing stateless pages, a temporary session object is used for the current request.
Button
AjaxSubmitButton and AjaxSubmitLink now extend Button and Button extends IFormSubmittingComponent. As a result of this, method onSubmit changed from protected to public
IHeaderContributor
void renderHead(final Response response); -> void renderHead(final IHeaderResponse response);
This resulted in a couple of cascading changes, like methods onRenderHeadContribution and onRenderHeadInitContribution not being used anymore. Note that the filtering of duplicate contributions is now part of IHeaderResponse.
A common fix is this:
protected void onRenderHeadInitContribution(Response response) {
writeJsReference(response, AUTOCOMPLETE_JS);
}
should be converted to:
public void renderHead(IHeaderResponse response) {
super.renderHead(response);
response.renderJavascriptReference(AUTOCOMPLETE_JS);
}
or for instance code like
protected String getImplementationId() {
return "ArchiveActions";
}
protected void onRenderHeadContribution(Response response) {
if (!isComplete()) {
response.write("<script>");
response.write(getCallbackScript().toString());
response.write("</script>");
}
}
would be rewritten like
public void renderHead(IHeaderResponse response) {
if (!isComplete()) {
response.renderJavascript(getCallbackScript(), "ArchiveActions");
}
}
ISessionFactory
Session newSession() -> Session newSession(Request)
WicketServlet -> WicketFilter
In Wicket 2.0 and 1.3 we now prefer using a Filter instead of a Servlet. This allows you to map your application to the root of your context and still let the container serve resources.
If you use a URL pattern in your filter mapping, you need to specify that also as an init-param to the WicketFilter.
<filter>
<filter-name>StatelessApplication</filter-name>
<filter-class>wicket.protocol.http.WicketFilter</filter-class>
<init-param>
<param-name>applicationClassName</param-name>
<param-value>wicket.examples.stateless.StatelessApplication</param-value>
</init-param>
<init-param>
<param-name>filterPath</param-name>
<param-value>stateless</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>StatelessApplication</filter-name>
<url-pattern>/stateless/*</url-pattern>
</filter-mapping>
FormComponent.IVisitor
Things have been refactored into interfaces here. If you previously implemented this directly, extend FormComponent.AbstractVisitor instead, and rename your formComponent() implementation to onFormComponent().
ClientProperties
wicket.protocol.http.ClientProperties was taken from the Echo2 project that uses a license which is incompatible with ASL2. It has therefore been rewritten and the usage of it has also changed.
Instead of:
WebClientInfo clientInfo = (WebClientInfo) Session.get().getClientInfo();
ClientProperties properties = clientInfo.getProperties();
System.out.println(properties.get(ClientProperties.BROWSER_INTERNET_EXPLORER));
You now say:
WebClientInfo clientInfo = (WebClientInfo) Session.get().getClientInfo();
ClientProperties properties = clientInfo.getProperties();
System.out.println(properties.isBrowserInternetExplorer());
Application settings
Application#getSettings is now private (so you can't call nor override that anymore), and the getXxxSettings are now overridable in case you want to do fancy stuff like creating a session-dependent settings object. Methods getApplicationPages and getApplicationSettings from component are now removed in favor of the getXxxSettings methods in Application.
Setting get/setDefaultLocale is removed and is does not have a replacement.
Custom Sessions
Session's constructor signature is now:
protected Session(Application application, Request request)
The locale is not set right after construction in WebApplication, but rather in the constructor using the passed in request. You can now 'fix' the session's locale by setting it in it's constructor.
H4. Custom resource loading
In Wicket 1.2 you could override method newMarkupResourceStream from MarkupContainer to provide a custom resource stream for loading the component's markup. The new way of letting markup containers provide custom markup is to let them implement interface IMarkupResourceStreamProvider and implement it's method getMarkupResourceStream. Additionally, a new feature is that you can provide your own markup cache key, which is used in the MarkupCache class. The only real use case for that is to let a markup container return a cache key that is null, in which case the resource won't be cached, causing Wicket to get call getMarkupResourceStream everytime the component's markup is requested. A use case for that is when you have dynamic markup (e.g. from a database) that is request/ session dependent. To achieve this, let your markup container also implement IMarkupCacheKeyProvider and let method getCacheKey return null.
