getRequestCycleSettings().setGatherExtendedBrowserInfo(true);

This method works via a redirect to the BrowserInfoPage and finally it goes to your ‘original’ page. Because of this it is possible that you see the BrowserInfoPage very shortly especially on slow computers/browsers or internet connections. But what if you don’t want this and only want to know whether Javascript is enabled? Please read on…

When the page is rendered it does a call(back) to Wicket. If this callback is possible then we can assume Javascipt is enabled.

How to setup?

e.g. Login.java (Page)

final WebClientInfo clientInfo = (WebClientInfo) WebRequestCycle.get().getClientInfo();
final AbstractDefaultAjaxBehavior behavior = new AbstractDefaultAjaxBehavior()
   @Override
   protected void respond(final AjaxRequestTarget target) {
        if (target != null) {
            clientInfo.getProperties().setJavaEnabled(true);
        }
   }
};
add(behavior);

Label jsEnabledScript = new Label("jsEnabledScript", "wicketAjaxGet('"+ behavior.getCallbackUrl() +"', function() { }, function() { });");
jsEnabledScript.setEscapeModelStrings(false); // do not HTML escape JavaScript code
add(jsEnabledScript);

And in your HTML

<script type="text/javascript" wicket:id="jsEnabledScript"></script>

How to use?

final WebClientInfo clientInfo = (WebClientInfo) WebRequestCycle.get().getClientInfo();
boolean javascriptEnabled = clientInfo.getProperties().isJavaEnabled();

Keep in mind that all Wicket validations will be validated, so we have to take care of the FeedbackPanel (refreshing) as well.

Example:

/**
	 * {@inheritDoc}
	 */
	@Override
	protected WebMarkupContainer newLink(String linkId, final int index) {

			return new AjaxSubmitLink(linkId, m_form) {

			@Override
			protected void onSubmit(AjaxRequestTarget target, Form<?> form) {
				setSelectedTab(index);
				if (target != null) {
					target.addComponent(TabbedComponent.this);
				}
				onAjaxUpdate(target);
			}

			@Override
			protected void onError(AjaxRequestTarget target, Form<?> form) {
				target.addComponent(((FeedbackAware) getPage()).getFeedbackPanel());
			}
		};
	}

See also my other blog about the AjaxTabbedPanel and LazyLoading

What I want to achieve is that an AjaxIndicator (loading image) will be shown on the place were the actual panel will come till it is completely loaded. Especially when you have a lot of components to render this can be handy. See image below.

Example

My solution was to create a class (AbstractLazyLoadTab) on top of the AbstractTab (implements ITab) which will take care of this. It will use the AjaxLazyLoadPanel.

public abstract class AbstractLazyLoadTab extends AbstractTab {
         //removed some lines

	@Override
	public Panel getPanel(String panelId) {
		return new AjaxLazyLoadPanel(panelId){

			private static final long serialVersionUID = 1L;

			@Override
			public Component getLazyLoadComponent(String markupId) {
				return getLazyLoadPanel(final String markupId);
			}
		};
	}

        public abstract Panel getLazyLoadPanel(final String markupId);
}

Now you can use this class as you normally would do when you use AbstractTab.

When your page (or components higher in the hierarchy) implements IAjaxIndicatorAware to show another loading layer it is possible that you now have two loading layers on top of each other. One on the tab and one which will e.g. block the whole page. To avoid that I created an other class which extends the AjaxTabbedPanel and implements the IAjaxIndicatorAware interface.

public class TabbedComponent extends AjaxTabbedPanel implements IAjaxIndicatorAware{
         //removed some lines
        @Override
	public String getAjaxIndicatorMarkupId() {
		//Our tab will take care of the loading layer, so return null.
		return null;
	}
}

Now you can use the classes like this:

  List<ITab> tabs=new ArrayList<ITab>();
    tabs.add(new AbstractLazyLoadTab(new Model("first tab")) {
        public Panel getLazyLoadPanel(String panelId) {
           return new TabPanel1(panelId);
        }
    });

    add(new TabbedComponent("tabs", tabs)

Another solution

If you prefer to have a waiting icon on the right side of the tab itself, you can override the newLink method of AjaxTabbedPanel and use the IndicatingAjaxFallbackLink instead of the AjaxFallbackLink. You will probably have to add the following code to your css file.

span.wicket-ajax-indicator {
float: left;
}

More information about this solution please click here

The example below shows you how to enable the requestLogger when the application is started in “Development” mode.

//Check if we are not in deployment mode.
if (!DEPLOYMENT.equalsIgnoreCase(getConfigurationType())) {

  //Get the logger
  IRequestLoggerSettings reqLogger = Application.get().getRequestLoggerSettings();

  //Enable the logger
  reqLogger.setRequestLoggerEnabled(true);

  /**
  * Set the window of all the requests that is kept in memory for viewing. Default is 2000, You
  * can set this to 0 then only Sessions data is recorded (number of request, total time, latest
  * size)
  */
  reqLogger.setRequestsWindowSize(3000);
}

If you want to log everything to a specific rolling file you can add the following lines to your log4j.properties file. It will create a file for you with a max. size of 10MB. All Wicket requests will be logged into this file and not in the ‘general’ log.

log4j.category.org.apache.wicket.protocol.http.RequestLogger = info,reqLogger
log4j.additivity.org.apache.wicket.protocol.http.RequestLogger=false
log4j.appender.reqLogger=org.apache.log4j.RollingFileAppender
log4j.appender.reqLogger.File=D:/logs/wicketRequestLogger.txt
log4j.appender.reqLogger.MaxFileSize=10MB
log4j.appender.reqLogger.MaxBackupIndex=10
log4j.appender.reqLogger.layout=org.apache.log4j.PatternLayout
log4j.appender.reqLogger.layout.ConversionPattern=%d %-5p - %-26.26c{1} - %m\n

Example logging:
2009-04-08 16:18:32,878 INFO – RequestLogger-
time=687,
event=Interface[target:Login$LoginForm(bodyTag:loginForm),
page: eu.company.desktop.wicket.ui.login.Login(0),
interface: IFormSubmitListener.onFormSubmitted],
response=org.apache.wicket.request.target.basic.RedirectRequestTarget@1c82b58,
sessionid=C488C8A534D1D853FD1F7A80C5647A52.jvm1,
sessionsize=16239,
sessionstart=Wed Apr 08 14:18:23 GMT 2009,
requests=12,
totaltime=3499,
activerequests=1,
maxmem=532M,
total=163M,
used=93M

That’s it.

Disclaimer: The requestLogger is very powerfull. I just started experimenting with it, so I don’t know all ins and outs yet.

public HomePage(final PageParameters parameters) {

Form form = new Form("form", new CompoundPropertyModel(this));
add(form);

TextField tf = new TextField("doubleValue");
tf.setType(Double.class);
tf.setRequired(true);
form.add(tf);
form.add(new Button("bt1") {
 private static final long serialVersionUID = -1179492663996608643L;

 @Override
 public void onSubmit() {
  super.onSubmit();

  System.out.println("Form submitted");
}});

add(new FeedbackPanel("feedback").setOutputMarkupId(true));
}

public double getDoubleValue(){
 return m_value;
}

public void setDoubleValue(double value) {
 m_value = value;
} 

Please note the setType(Double.class) (line 7). This will prevent the user to submit the form when no double is filled in. Simply it doesn’t goes into the onSubmit() method. By default it will use the String type. This type will also be used when updating the model for this component.  

A shorter notation (instead of line 6 and 7):

TextField tf = new TextField("doubleValue", Double.class);

Corresponding HTML:

<form wicket:id="form">
<input type="text" wicket:id="tf1"/>
<input type="submit" wicket:id="bt1"/>
</form>
<div wicket:id="feedback"/>

1. JVM Argument
2. Servlet/filter initialization parameter
3. Context initialization paramater.

1. JVM Argument

Add the property -Dwicket.configuration=deployment to your JVM Arguments. This one is very usefull when you want to switch on your local system to deployment mode (during development), because you don’t have to change files, only local settings. This property will be checked first so you can override the servlet/filter or context settings.

2. Servlet/filter

Example:

<filter>
...
 <init-param>
  <param-name>configuration</param-name>
  <param-value>deployment</param-value>
 </init-param>
...
</filter>

3. Context

Example:

<context-param>
 <param-name>configuration</param-name>
 <param-value>deployment</param-value>
</context-param>

1. Software

Download the latest stable versions from the following websites.

• JDK (http://java.sun.com/javase/downloads/)
• Maven2 (http://maven.apache.org/download.html)
• Eclipse  (http://www.eclipse.org/downloads/)

2. Maven2

1. Unzip the downloaded file to a location of your choice. e.g “D:\Programming\apache-maven-2.0.9\”
2. Create a M2_HOME system variable
   - Press WinKey + Pause or go to Settings -> Control Panel -> System. Now a System Properties dialog will appear. Go to Advanced -> Environment Variables. 
   - Press New and create a new system variable with name M2_HOME and value D:\Programming\apache-maven-2.0.9 Press OK
3.  M2_HOME is added to the system variables. In the same list you’ll find  a “Path” variable. Edit this variable and add %M2_HOME%\bin; to the end of the list.  
   Make sure that there is also a JAVA_HOME system variable pointing to your JDK and the value %JAVA_HOME%\bin;  in your path variable.
4. Close all dialogs and go to the command line by pressing WinKey + R or Start -> Run and type cmd.exe, press Enter.
5. On the commandline type mvn --version press Enter and if everything is configured correct you will see Maven’s version number. 
   If it is not working properly close the command line by typing exit Enter and re-open the command line (see step 4).
   

   Output Maven

3. Maven2 Repository

By default Maven will create a local repository (.m2/repository) in your $user folder. If you want to specify the location of the local repository, create a file in $user/.m2/ called “settings.xml”. This file should contain the following lines. Change path if needed.

<settings>
<localRepository>d:\programming\repository</localRepository>
</settings>

4. Archetype (Creating the project)

1. On the commandline go to your workspace directory e.g. “D:\Programming\Workspaces” by typing d: Enter and afterwards cd Programming\Workspaces Enter.
2. Type mvn archetype:create -DarchetypeGroupId=org.apache.wicket -DarchetypeArtifactId=wicket-archetype-quickstart -DarchetypeVersion=1.3.5 -DgroupId=com.mycompany -DartifactId=myproject and press Enter.
   This will download all dependencies which are necessary and create a Maven2 project structure. It will create a directory with the name “myproject” in your workspaces directory and some Wicket quickstart files (in package “com.mycompany”). It will use Wicket version 1.3.5. You can change those properties to your needs!
    

 5. Run Wicket’s Quickstart project

1. When everything is downloaded succesfull go to your project directory (“D:\Programming\Workspaces\myProject”) 
   

   Maven Archetype created successfull

    

2. Type mvn jetty:run and wait till it is completely started. The first time it will take some time.
3. Open your favourite browser and browse to http://localhost:8080/myproject
4. Now you will see a Wicket page.

6. Eclipse (optional)

1. If you want to play around with the quickstart project. You have to import the project in your IDE. Before doing this you have to go to your project directory and type mvn eclipse:eclipse -DdownloadSources=true press Enter
   This will create some files for you to import the project in Eclipse.
2. Open Eclipse, go to File -> Import
3. Go to General -> Existing Projects in Workspace
4. Press Browse and point to your project directory. Press Finish.
5. Now the project will be loaded in Eclipse and is ready for you to make changes.

7. Software used for this article

• JDK 1.6.0
• Maven 2.0.9
• Eclipse 3.4.0
• Windows XP / Vista