This basically means that you can filter your component expression by if a component is visible, enabled, or both. The following is an example of what can now be done:

"one1[enabled=true]:two1[enabled=true]"
"one1[visible=true and enabled = true]:
                 two1[visible=true & enabled=true]"
"**[visible=true]"

As before the code is available on the london wicket google code project, under an apache 2 licence. Due to the additional functionality I have bumped up the version number to 0.2.0, so you will need to update you pom to reflect this.

This lead me to think that maybe there could be an easier way for getting at components, using * to represent any child component at a given level, and ** to represent any child component at any level.

Doing this would mean that you could re-write this:

“panel1:innerpanel1:form1:textfield1”

as

“*:*:form1:textfield1”

or

“**:form:textfield1”

or even

“**:textfield1”

Then I got thinking that I would be pretty simple to place type restrictions on the results, so you could set the following expression:

“**” and type restriction of TextField

to get all TextField component on the page or

“panel1:**” and type restriction of ListView

to get all ListView components which are children of the panel1 component.

To use component expressions I created 4 static methods

• public static Component findComponent(Component parent,
   String expression)

• public static Component findComponent(Component parent,
   String expression,Class<? extends Component>typeRestriction)

• public static List findAllComponents(Component parent,
   String expression)

• public static List findAllComponents(Component parent,
   String expression, Class<? extends Component> typeRestriction)

The code is checked into the london wicket google code repository, and you can include it as a dependency to your project by adding the following to your pom.xml

<repositories>
	<repository>
		<id>londonwicket</id>
		<url>http://londonwicket.googlecode.com/svn/repo</url>
		<releases>
			<enabled>true</enabled>
		</releases>
		<snapshots>
			<enabled>true</enabled>
		</snapshots>
	</repository>
</repositories>

<dependency>
	<groupId>com.googlecode.londonwicket</groupId>
	<artifactId>wicket-component-expressions</artifactId>
	<version>0.1.0</version>
</dependency>

There are tests to cover all the different cases I could think of. Any comments, bug fixes, or improvements would be more than welcome.

LegUp is a collection of free, open source (Apache 2 licensed) Maven 2 archetypes, and a web based configuration tool provided by jWeekend.  It allows you to choose from different combinations of popular Java technologies (Apache Wicket, Spring, Google Guice, JPA, Hibernate, Warp Persist) to allow you to get up and running quickly and easily.  Up and running means that will have a simple application running within a minute of starting.

Currently the following archetypes are available:

• Spring 2.5 with a JDBC database layer
• Spring 2.5 with a JPA 1.0 database layer
• Apache Wicket 1.4 and Google Guice 1.0
• Apache Wicket 1.4, Google Guice 1.0, Warp Persist 1.0 and Hibernate 3
• Apache Wicket 1.4, Google Guice 1.0, Warp Persist 1.0 and JPA 1.0
• Apache Wicket 1.4, Spring 2.5 and JPA 1.0

Example for a project with Wicket, Spring and JPA

mvn eclipse:eclipse

The code will now automatically configure your application to use the correct page store, with a default of 100 pages history per page map.  If you need to override this value then you can override the the newSessionStore method in your WebApplication class, as in the previous version (see this post).

So in most cases all you need to do to use wicket with terracotta is include the tim in your terracotta configuration like so.

<module name="tim-wicket-1.3" version="1.1.3"/>

The next thing i’m going to be working on is wicket 1.4 support, which I should get finished before wicket 1.4 goes live.

yay, woo, this will make me spend loads of money

</sarcasm>

So the government reduces VAT by 2.5 percent.  So for every £1000 I spend, I will save a whole £25.

And for that privilage I will get to pay higher taxes in a years time, probably for the next 10 years.

Cant say im convinced.

I’m just waiting for all those systems with a hard coded figure of 17.5% for VAT not being able to handle the change, it could be Y2K all over again.

I decided to use the terracotta maven plugin, which means that you dont need to download anything, maven will do it all for you.

Simply extract the zip file and run

mvn tc:run

Then point your browser at http://localhost:8080/simple-wicket or http://localhost:8081/simple-wicket to see it in action.

You can read more about the terracotta maven plugin on this url

Edit:

I have corrected the typo pointed out to me. Just goes to show that you should test your code in a different user account to the one you have multiple versions of the same project installed in your local maven repo.

You can download the source code here simple-wicket1.zip

Instead i’m going to say that regardless of your requirements, there surely must already be at least one framework that meets practically all of them.  So given that what you want already exists, why go and build it yourself anyway?  Or can they not use google?

But suppose that you do build your own framework, this means that out of all existing frameworks, none meet your requirements (or you can’t use google).  From this we can deduce that you have quite specialized requirements (or you are less computer literate than a 10 year old), meaning that your requirements probably won’t be shared by many other people, so why oh why do you then take your poorly documented, highly specialized code and thrust it upon the world?

We aren’t interested that you can build an entire app that says hello world with one command, or that you have a slightly different method of hacking together java, html, ajax in a ‘really cool way’.

</rant>

The new terracotta wicket-tim is out!

Any wicket and terracotta users will know that the previous wicket-tim had issues under heavy load, which is why some months ago I set about creating something better, with lots of help from the wicket community, especially Stefan Fussenegger, we created a new in-memory page map which can cope with high load.

To use this you will need to add the wicket-tim to your classpath, if you are using maven then add this to your pom.xml file:

	org.terracotta.modules
	tim-wicket
	1.1.1

And follow the installation instructions.

In your tc-config.xml you will need to include the wicket-tim module, you can find instructions on how to do this here and here.

Then in your wicket application class you need to use the new page map:

public ISessionStore newSessionStore() {
     return new SecondLevelCacheSessionStore(this,
       new TerracottaPageStore(100));
}

The 100 in the page store parameter is the number of pages (or versions of pages) of history to keep inthe page map, and can be set to anything you feel is appropriate.

The page map is stored in the httpsession so you will need to make sure that httpsession clustering is working correctly.  If you are using tomcat then terracotta should do this automatically.

Feedback and bug reports are welcome, particularity about the user configurable number of pages history.  If we remove this then it will be possible to use byte-code instrumentation to automatically add in the TerracottaPageStore, meaning that the wicket-tim wont need adding onto your application build path.

Richard

The text reads:

As the saying goes ‘Clear as mud’, surely ‘Check this box to receive junk mail’ is sooo much clearer?

London Wicket User Group

Begins: Wed, 01 Oct 2008 at 8:30 PM

Ends: Wed, 01 Oct 2008 at 9:00 PM

Entry fee: Free

Location:

Google UK, 76, Buckingham Palace Road

Belgrave House

London SW1W 9TQ

Link: Register

Tags: lwgu, wicket