Enjoy!

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

select this_.id as ID113_4_ ........ from INCOMINGMESSAGE ... where this_.STATUS=? and this_.FOO=?

Now turn on some extra logging (log4j.properties):

log4j.logger.org.hibernate.type = trace, console

Now you’ll see some extra information like the type (StringType / EnumType / etc.) and the value:

select this_.id as ID113_4_ ........ from INCOMINGMESSAGE ... where this_.STATUS=? and this_.FOO=?
DEBUG org.hibernate.type.EnumType  - Binding 'UNHANDLED' to parameter: 1
DEBUG org.hibernate.type.StringType  - Binding 'Bar' to parameter: 2

Note: When your application uses big queries then you’ll get a lot of extra logging\!

X-Spam-Status: No, score=0.001 required=5
In case of spam:
X-Spam-Status: Yes, score=16.401 required=5

If the score is above 5, the X-Spam-Status flag is set to Yes. In your email application like Microsoft Outlook you can create a rule to check for this status and remove (or move) those emails.

Lets see how we can do this:

1. Open Outlook
2. Go to Tools, Rules and Alerts
3. New Rule…
4. Start from a blank rule
5. Check messages after they arrive
6. Check With specific words in the message header
7. Click on specific words and enter “X-Spam-Status: Yes” (without qoutes)
8. Press Add, OK and Next
9. Choose what you want to do with the message(s). E.g. delete it
10. Press OK and Finish

How can you see the mail headers?

Go to your mail box, select an email, right click and select Options. On the bottom of the popup you’ll see the headers.

Note: I used in this case Microsoft Outlook 2003. This won’t work in Microsoft Mail!

Source: Synology.com

When you need to debug your application it is not very usefull to use the compressed one but in production it really is. To switch very easy from the compressed version to the ‘normal’ version and the other way around you can create a static variable where you define the location of the JavaScript file. Use the static variable to add the file to your page/header. Now you can switch versions (normal/compressed) by changing the static variable (in only one file).

JQuery.java:

public static final String JQUERY_BASE = "base/jquery-1.2.6.min.js";

(Wicket) Page:

add(HeaderContributor.forJavaScript(JQuery.class, JQuery.JQUERY_BASE));