Repository: wicket-site Updated Branches: refs/heads/asf-site [created] 8cc72bade
http://git-wip-us.apache.org/repos/asf/wicket-site/blob/8cc72bad/learn/ides.md ---------------------------------------------------------------------- diff --git a/learn/ides.md b/learn/ides.md new file mode 100644 index 0000000..96d068e --- /dev/null +++ b/learn/ides.md @@ -0,0 +1,53 @@ +--- +layout: default +title: IDE Support for Wicket development +--- + +## Wicket Plugins ## + +For all leading IDE's support is under development. Here's a list of efforts +for the major IDE's. + +* Eclipse: [Qwickie](http://code.google.com/p/qwickie), [Wicket Source](https://github.com/42Lines/wicket-source/wiki) +* Netbeans: [NB Wicket Support](https://nbwicketsupport.dev.java.net/) +* IntelliJ IDEA: [Wicket Forge](http://wicketforge.googlecode.com/), [Wicket Source](https://github.com/armhold/wicket-source-intellij) + +These projects are not maintained or supported by the core Wicket team, but +by their respective development teams. + +## Setting up your IDE ## + +### Eclipse ### + +Taking Maven, project configuration files for Eclipse can be generated with: + +{% highlight console %} +mvn eclipse:eclipse +{% endhighlight %} + +Maven will add all the necessary JAR files to the project's classpath. Now the sources can be imported in Eclipse using the "Existing Projects into Workspace" wizard. + +If not already present the `M2_REPO` classpath variable has to point to your local Maven repository. +The repository is typically found in `C:\Documents and Settings\<username>\.m2\repo` or (for unix buffs) `~/.m2/repo`. It can be set within Eclipse (Preferences->Java->Build Path->Classpath Variables) or with the help of Maven: + +{% highlight console %} +mvn -Declipse.workspace=<path-to-eclipse-workspace> eclipse:add-maven-repo +{% endhighlight %} + +If you want to go along with the Wicket way of code formatting you should import the Wicket code format profile into your workspace (Preferences->Java->Code Style->Formatter), found in: + +{% highlight console %} +<path-to-eclipse-workspace>/wicket-core/EclipseCodeFormat.xml +{% endhighlight %} + +Finally configure the editor to automatically format all edited lines and organize imports on save (Preferences->Java->Editor->Save Actions). + +### NetBeans ### + +NetBeans comes with Maven integration. Further help can be found at their [Wiki](http://wiki.netbeans.org/MavenBestPractices "NetBeans Community Wiki") + +### IDEA ### + +IntelliJ IDEA comes with [Maven support](http://www.jetbrains.com/idea/webhelp/maven.html "IDEA Web Help") too. + +With the [Eclipse Code Formatter plugin](http://plugins.jetbrains.com/plugin/6546) the Wicket format profile can be used in IntelliJ IDEA too. Configure the IDE to prevent star imports (Settings->Code Style->Imports). http://git-wip-us.apache.org/repos/asf/wicket-site/blob/8cc72bad/learn/index.md ---------------------------------------------------------------------- diff --git a/learn/index.md b/learn/index.md new file mode 100644 index 0000000..bb619a7 --- /dev/null +++ b/learn/index.md @@ -0,0 +1,4 @@ +--- +layout: default +title: Learn more! +--- http://git-wip-us.apache.org/repos/asf/wicket-site/blob/8cc72bad/learn/projects/authroles.md ---------------------------------------------------------------------- diff --git a/learn/projects/authroles.md b/learn/projects/authroles.md new file mode 100644 index 0000000..0130e3b --- /dev/null +++ b/learn/projects/authroles.md @@ -0,0 +1,135 @@ +--- +layout: default +title: Wicket Auth/Roles +--- + +This is mostly a technology demonstration implementing authorization and +authentication for the Apache Wicket web framework. The project supplies roles +based authorization and some simple authentication components. + +## Contents ## + +* [Introduction](#introduction) +* [Example](#example) +* [Installing](#installing) + +## Introduction ## + +Wicket Auth/Roles is a simplistic but useful security extension to the Wicket +framework. It is intended to be simplistic and not to be confused with a +framework. If you find this library useful, great. If you need more than is +supplied by this library, either look at [alternative security +integrations](#alternatives) or copy these classes and modify them at will +(this project **is** [open source](http://www.apache.org/licenses/) after +all.) + +Like most if not all security solutions for Wicket, this project provides an +implementation for Wicket's `IAuthorizationStrategy`. When an authorization +strategy is installed in the security settings +(`WebApplication#getSecuritySettings`), Wicket will check for each component +(including pages) if instantiation is allowed and if rendering is allowed. + +For more documentation use the following links: + +* [Authentication API](http://wicket.apache.org/apidocs/1.5/org/apache/wicket/authentication/package-summary.html) +* [Authorization API](http://wicket.apache.org/apidocs/1.5/org/apache/wicket/authorization/package-summary.html) + +Note that for the instantiation check Wicket will invoke the constructor +hierarchy of your component, but will throw an exception if the authorization +check fails. + +### Authentication ### + +As a basis, you should extend your web application class from +`AuthenticatedWebApplication`. When you create your class you'll be asked to +override the following methods: + +* `newSession` - return a subclass of `AuthenticatedWebSession` +* `getSignInPageClass` - return the class for your login page (this one should + not require authentication, otherwise you'll create an infinite loop) + +Next you'll need to provide your custom session class-making it a subclass of +`AuthenticatedWebSession`. This class requires you to override the following +methods: + +* `authenticate` - called when the user needs to be authenticated using a + username and password +* `getRoles` - called after the users was authenticated and should provide the + roles associated with the authenticated user. + +You can use the provided `SignInPage`, which has been translated to a couple +of languages (see the source code for the actual translations), or roll your +own. When you roll your own, you can opt to use the provided `SignInPanel` +(which has been translated as well) so you don't have to create your own login +form. + +### Authorization ### + +Annotation for configuring what roles are allowed for instantiation the +annotated component or package. This annotation can be used for classes and +packages, and can be used like this: + +{% highlight java %} +// only users with role ADMIN are allowed to create instances of this page, whether it is +// either bookmarkable or not +@AuthorizeInstantiation("ADMIN") +public class AdminAnnotationsBookmarkablePage extends WebPage +{% endhighlight %} + +When someone who doesn't have the role ADMIN, Wicket will not allow the page +to be fully constructed and throw an authorization exception during the +construction of the page. This will result in an access denied page for the +user. + +Enablng the annotations for role based authorization is done by setting the +`WebApplication#getSecuritySettings` value to +`AnnotationsRoleAuthorizationStrategy`. Then you can use the auth/roles +provided authorization annotations. + +### Alternatives ### + +More elaborate security solutions exist in the following projects: + + * [Wicket Shiro](https://github.com/wicketstuff/core/tree/core-1.5.x/jdk-1.5-parent/shiro-security) - + integration between Apache Shiro and Wicket + * [Wicket Security](https://github.com/wicketstuff/core/tree/core-1.5.x/jdk-1.5-parent/wicket-security-parent) + - JAAS inspired, principal based security framework + +If other security solutions are available for Wicket, [let us +know](https://issues.apache.org/jira/browse/WICKET). + +## Example ## + +The Wicket Examples project contains a [complete +example](http://wicket-library.com/wicket-examples/authorization) of limiting +access to pages and components using roles based authorization. It also contains +an [authentication +example](http://wicket-library.com/wicket-examples/authentication). + +Click on the source links to see the related source code. + +## Installing ## + +Installing Wicket Auth/Roles can be done through adding a dependency in your +project's Maven pom, or by putting the wicket-auth-roles.jar and the required +dependencies in your projects classpath. + +### Using Maven ### + +Add the following dependency to your pom: + +{% highlight xml %} +<dependency> + <groupId>org.apache.wicket</groupId> + <artifactId>wicket-auth-roles</artifactId> + <version>{{site.wicket.version}}</version> +</dependency> +{% endhighlight %} + +### Required dependencies ### + +Wicket Auth/Roles requires the following jar files to be on your classpath: + + * Wicket + * Wicket Auth/Roles + http://git-wip-us.apache.org/repos/asf/wicket-site/blob/8cc72bad/learn/projects/datetime.md ---------------------------------------------------------------------- diff --git a/learn/projects/datetime.md b/learn/projects/datetime.md new file mode 100644 index 0000000..e0ca3a2 --- /dev/null +++ b/learn/projects/datetime.md @@ -0,0 +1,7 @@ +--- +layout: default +title: Wicket Date/Time +--- + +Waiting for someone to contribute some introductory documentation about this +project. See for an example the [Velocity project description](velocity.html). \ No newline at end of file http://git-wip-us.apache.org/repos/asf/wicket-site/blob/8cc72bad/learn/projects/devutils.md ---------------------------------------------------------------------- diff --git a/learn/projects/devutils.md b/learn/projects/devutils.md new file mode 100644 index 0000000..4699864 --- /dev/null +++ b/learn/projects/devutils.md @@ -0,0 +1,7 @@ +--- +layout: default +title: Wicket Dev Utils +--- + +Waiting for someone to contribute some introductory documentation about this +project. See for an example the [Velocity project description](velocity.html). \ No newline at end of file http://git-wip-us.apache.org/repos/asf/wicket-site/blob/8cc72bad/learn/projects/extensions.md ---------------------------------------------------------------------- diff --git a/learn/projects/extensions.md b/learn/projects/extensions.md new file mode 100644 index 0000000..f0bf143 --- /dev/null +++ b/learn/projects/extensions.md @@ -0,0 +1,7 @@ +--- +layout: default +title: Wicket Extensions +--- + +Waiting for someone to contribute some introductory documentation about this +project. See for an example the [Velocity project description](velocity.html). \ No newline at end of file http://git-wip-us.apache.org/repos/asf/wicket-site/blob/8cc72bad/learn/projects/guice.md ---------------------------------------------------------------------- diff --git a/learn/projects/guice.md b/learn/projects/guice.md new file mode 100644 index 0000000..717d789 --- /dev/null +++ b/learn/projects/guice.md @@ -0,0 +1,7 @@ +--- +layout: default +title: Wicket Guice +--- + +Waiting for someone to contribute some introductory documentation about this +project. See for an example the [Velocity project description](velocity.html). \ No newline at end of file http://git-wip-us.apache.org/repos/asf/wicket-site/blob/8cc72bad/learn/projects/index.md ---------------------------------------------------------------------- diff --git a/learn/projects/index.md b/learn/projects/index.md new file mode 100644 index 0000000..9c56e16 --- /dev/null +++ b/learn/projects/index.md @@ -0,0 +1,35 @@ +--- +layout: default +title: Wicket projects +--- + +The Wicket team provides more than a component oriented web framework, we +also provide additional projects that help you integrate with Java +technologies such as Spring, Guice and Velocity. Check each project below to +see if you can use it. + +* [Wicket Auth/Roles](authroles.html) - very basic security project enabling + annotation based authorization for two roles: user and admin. +* [Wicket Date/Time](datetime.html) - date components +* [Wicket Dev Utils](devutils.html) - utilities that improve developer + productivity by opening up the internals of your Wicket application right + inside the web UI. +* [Wicket Extensions](extensions.html) - additional components that are + beyond the scope of the core Wicket framework. Contains components such as + DataTable, MultiFileUpload, Rating component +* [Wicket JMX](jmx.html) - opens up the internals of Wicket through JMX beans + +* [Wicket IoC](ioc.html) - base services for the Guice and Spring integrations +* [Wicket integration for Guice](guice.html) - inject + [Guice](http://code.google.com/p/google-guice) managed services in a Wicket + compatible manner +* [Wicket integration for Spring](spring.html) - inject + [Spring](http://springsource.org) managed services in a Wicket compatible + manner + +Integrations with other template engines +---------------------------------------- + +* [Wicket integration for Apache Velocity](velocity.html) - use + [Velocity](http://velocity.apache.org) templates in your Wicket application + http://git-wip-us.apache.org/repos/asf/wicket-site/blob/8cc72bad/learn/projects/ioc.md ---------------------------------------------------------------------- diff --git a/learn/projects/ioc.md b/learn/projects/ioc.md new file mode 100644 index 0000000..50d4572 --- /dev/null +++ b/learn/projects/ioc.md @@ -0,0 +1,7 @@ +--- +layout: default +title: Wicket IoC +--- + +Waiting for someone to contribute some introductory documentation about this +project. See for an example the [Velocity project description](velocity.html). \ No newline at end of file http://git-wip-us.apache.org/repos/asf/wicket-site/blob/8cc72bad/learn/projects/jmx.md ---------------------------------------------------------------------- diff --git a/learn/projects/jmx.md b/learn/projects/jmx.md new file mode 100644 index 0000000..b6062c2 --- /dev/null +++ b/learn/projects/jmx.md @@ -0,0 +1,7 @@ +--- +layout: default +title: Wicket JMX +--- + +Waiting for someone to contribute some introductory documentation about this +project. See for an example the [Velocity project description](velocity.html). \ No newline at end of file http://git-wip-us.apache.org/repos/asf/wicket-site/blob/8cc72bad/learn/projects/spring.md ---------------------------------------------------------------------- diff --git a/learn/projects/spring.md b/learn/projects/spring.md new file mode 100644 index 0000000..9d09f06 --- /dev/null +++ b/learn/projects/spring.md @@ -0,0 +1,7 @@ +--- +layout: default +title: Wicket Spring +--- + +Waiting for someone to contribute some introductory documentation about this +project. See for an example the [Velocity project description](velocity.html). \ No newline at end of file http://git-wip-us.apache.org/repos/asf/wicket-site/blob/8cc72bad/learn/projects/velocity.md ---------------------------------------------------------------------- diff --git a/learn/projects/velocity.md b/learn/projects/velocity.md new file mode 100644 index 0000000..caab524 --- /dev/null +++ b/learn/projects/velocity.md @@ -0,0 +1,118 @@ +--- +layout: default +title: Wicket Velocity +--- + +Provides a specialized panel and some related utilities that enables users to +work with [Apache Velocity](http://velocity.apache.org) and [Apache +Wicket](http://wicket.apache.org). Particularly useful for simple CMS like +applications. + +## Contents ## + +* [Introduction](#introduction) +* [Example](#example) +* [Installing](#installing) + +## Introduction ## + +Velocity brings a templating language to your users. You can let them create +conditional markup, use loops and do all other things made possible by +Velocity. + +Velocity templates look like the following: + +{% highlight html %} +#set ($foo = "deoxyribonucleic acid") +#set ($bar = "ribonucleic acid") + +#if ($foo == $bar) + In this case it's clear they aren't equivalent. So... +#else + They are not equivalent and this will be the output. +#end +{% endhighlight %} + +Read +[more](http://velocity.apache.org/engine/releases/velocity-1.4/user-guide.html) +about the Velocity template language. + +This project allows you to use Velocity templates as a component within your +Wicket pages, and let them live next to Wicket components. A typical usecase +would be to enable your users to embed Velocity templates in your application +and using that as a type of portlet. + +The main component for the Veloticy/Wicket integration is the +[`VelocityPanel`](http://wicket.apache.org/docs/1.4/org/apache/wicket/velocity/markup/html/VelocityPanel.html). + +## Example ## + +Showing Hello, World using Velocity in a Wicket application, embedded in a +Wicket page. + +{% highlight html %} +<h2>This is a Velocity template</h2> + +<p>The secret message is: $message</p> +{% endhighlight %} + +In this template we want to replace the string `$message` with the text +"Hello, World!". `$message` is Velocity markup denoting a variable that is +taken from the context that is provided to the Velocity rendering engine. + +To use Velocity in your Wicket pages we provide a `VelocityPanel` which +enables you to generate parts of your page using Velocity markup. Adding the +panel to your Wicket page is shown in the following example: + +{% highlight java %} +public VelocityPage() { + HashMap<String, String> values = new HashMap<String, String>(); + values.put("message", "Hello, World!"); + Model<HashMap<String, String>> context = Model.of(values); + + UrlResourceStream template = new UrlResourceStream(getClass().getResource("test.html")); + add(VelocityPanel.forTemplateResource("velocityPanel", context, template)); +} +{% endhighlight %} + +`VelocityPanel.forTemplateResource` creates a `VelocityPanel` and sets up the +engine such that the context is merged with the template with each render. + +The markup of the page is quite simple: adding a VelocityPanel is as simple +as using a `div` and attaching a `wicket:identifier` to it. The following +example shows this. + +{% highlight html %} +<!DOCTYPE html> +<h1>This is a test page for Velocity</h1> +<div wicket:id="velocityPanel"></div> +{% endhighlight %} + +## Installing ## + +Installing Wicket Velocity can be done through adding a dependency in your +project's Maven pom, or by putting the wicket-velocity.jar and the required +dependencies in your projects classpath. + +### Using Maven ### + +Add the following dependency to your pom: + +{% highlight xml %} +<dependency> + <groupId>org.apache.wicket</groupId> + <artifactId>wicket-velocity</artifactId> + <version>{{site.wicket.version}}</version> +</dependency> +{% endhighlight %} + +### Required dependencies ### + +Wicket Velocity requires the following jar files to be on your classpath: + + * Wicket + * Wicket Velocity + * Apache Velocity + +Check the [Apache Velocity project](http://velocity.apache.org) to find out +which other dependencies you need. http://git-wip-us.apache.org/repos/asf/wicket-site/blob/8cc72bad/liveedit.sh ---------------------------------------------------------------------- diff --git a/liveedit.sh b/liveedit.sh new file mode 100755 index 0000000..f61d914 --- /dev/null +++ b/liveedit.sh @@ -0,0 +1,12 @@ +#!/bin/bash + +#workaround script for regenerating the site because jekyll completely wipes _site which causes problems for svn +echo Backing up .svn folders in _site +mkdir _tmp +tar cfT _tmp/archive.tar /dev/null +find _site -name ".svn"|xargs -I{} tar -rf _tmp/archive.tar {} +jekyll serve +echo Restoring .svn folders in _site +tar -xf _tmp/archive.tar +rm -rf _tmp + http://git-wip-us.apache.org/repos/asf/wicket-site/blob/8cc72bad/meet/blogs.md ---------------------------------------------------------------------- diff --git a/meet/blogs.md b/meet/blogs.md new file mode 100644 index 0000000..2030161 --- /dev/null +++ b/meet/blogs.md @@ -0,0 +1,34 @@ +--- +layout: default +title: Wicket related blogs +--- + +Any (open source) project exists solely because a community wants to support +it. The Wicket community consists of the users and developers. There are many +who want to share their experiences with Wicket and do so on the mailing +lists , on several online media portals (for example The ServerSide and +JavaLobby ), and on their blogs. + +Here is a list of regular Wicket bloggers, consisting of core contributers and enthusiastic users. + +* [Wicket in Action](http://wicketinaction.com/) - Igor Vaynberg, Martijn Dashorst +* [Chillenious!](http://chillenious.wordpress.com/) - Eelco Hillenius +* [Jonathan](http://codeact.wordpress.com/) - Jonathan Locke +* [Here be beasties](http://herebebeasties.com/) - Al Maw +* [Jeremy Thomerson](http://www.jeremythomerson.com/blog) - Jeremy Thomerson +* [Codierspiel](http://technically.us/code) - Nathan Hamblen (runs on Wicket) +* [Antwerkz](http://www.antwerkz.com/wp/) - Justin Lee +* [System Mobile](http://www.systemmobile.com/?cat=4) - Nick Heudecker +* [Geertjan](http://blogs.sun.com/geertjan) - Geertjan Wielenga +* [A Wicket Diary](http://martijndashorst.com/blog) - Martijn Dashorst +* [Wicket Praxis](http://www.wicket-praxis.de/blog/) - Michael Mosmann +* [Mystic Coders](http://mysticcoders.com/blog) - Andrew Lombardi +* [Wicket by Example](http://wicketbyexample.com/) - Community driven +* [Yes Wicket!](http://yeswicket.com/) - French Wicket blog + +## Get your blog listed! + +If you think your blog is missing, then please send a message to one of the +core contributors or the mailinglist. In the mean time you can add your blog +to our wiki's [special blog +page](https://cwiki.apache.org/confluence/display/WICKET/Wicket+Blogs). http://git-wip-us.apache.org/repos/asf/wicket-site/blob/8cc72bad/meet/buzz.md ---------------------------------------------------------------------- diff --git a/meet/buzz.md b/meet/buzz.md new file mode 100644 index 0000000..c4ff9ba --- /dev/null +++ b/meet/buzz.md @@ -0,0 +1,154 @@ +--- +layout: default +title: Wicket Buzz +--- + +Wicket has appeared in the press in a variety of industry trade magazines, +including Network World, ComputerWorld, IT World and Information Week. +Presentations on Wicket have been delivered by Wicket team members at JavaOne +in San Francisco, Javapolis and TheServerSide Java Symposium in Europe. The +following are quotes from reviewers and users of Wicket: + +> After working with JSF for almost a year, trying Wicket was like that +> movie scene where the clouds part and this big ray of light hits you +> in the face. I just had this feeling while JSF'ing that certain things +> were harder than they needed to be. Well, I was right, and the Wicket +> people figured it out. +> +> [Kevin Galligan](http://bigheadco.blogspot.com/2007/03/groovy-wicket.html) + +> Wicket (currently undergoing incubation with Apache) is a good +> example of a web framework which throws caution to the wind, and has +> absolutely no XML needed. We here at Mystic have a lot of love for +> Wicket and are actively developing several projects with it currently. +> +> [Mystic Coders](http://www.mysticcoders.com/blog/2007/03/13/the-rise-of-the-xml-backlash/) + + +> Writing a Wicket app is rather more like writing an event-based +> desktop application than a web application. +> +> [LShift](http://www.lshift.net/blog/2006/07/06/wicket) + +> "Wickedly Cool" - I actually managed to whip together a Wicket +> Application in a few days. It is entertaining to work with, adding +> shiny stuff is really easy while you can develop Java code and keep +> those last bits of hair you have saved for ripping out in a CSS +> nightmare that you hopefully after finding Wicket will not have to +> deal with. So I'd go out on a limb and say that Wicket == Rogaine for +> developers. +> +> [Joed](http://blogs.opennms.org/joed/?p=3) + +> "So is Wicket the one true MVC framework that a lot of us have been +> hunting for? At the moment, I tend to think so. \[...\] If you like Java +> you will really like Wicket." +> +> [Peter Thomas](http://ptrthomas.wordpress.com/2007/03/02/wicket-impressions-moving-from-spring-mvc-webflow/) + +> "I think its an awesome way to deal with this whole web UI framework +> mess. I am happy to see someone take a simple and clean approach to +> the whole problem, and come up with a transparent POJO solution. I +> like the direction the framework is going... Wicket is clean, simple +> and elegant." +> +> Comment on TheServerSide.com + +> "Last week I wrote an article about Wicket and I spent some time +> discovering and taming it. And I have to confess this: I love it. ... +> snip ... Wicket is not a framework, it's a candy bar. And everybody +> loves candy bars..." +> +> Comment made by Romain Guy + +> The issue that impressed me in the Wicket model is that "Wicket does +> not mix markup with Java code and adds no special syntax to your +> markup files." You reference Wicket identities as HTML attributes +> and define component properties in Java, which allows designers and +> programmers to work independently (within the obvious constraint of +> having common goals). There is no need for special tools. +> +> From a Network World editorial entitled "Nothing Sticky about Wicket" + +> In a recent blog post I asked for feedback on what Web frameworks +> folks are using. Well, I got quite a surprise: Wicket was the most +> often recommended framework in reader emails! +> +> From an About.com article entitled And the Winner is...Wicket + +> "I have used Wicket since last Fall for personal projects. I have 3 +> kids and a wife so my free-time is very limited. Given that, I had to +> be very picky about which framework I chose. I've been very impressed +> with how little hassle it has been to start creating powerful, +> reusable components and pages with Wicket even under rather severe +> time constraints." +> +> Comment on TheServerSide.com + +> "...after using web MVC frameworks for a couple of years, building +> ever more complex web applications, I moved to component based +> frameworks. Of these, I think Wicket is by far the best..." +> +> Comment on Manageability.org + +> "... Talk about a mind blowing experience, it literally took me ten +> minutes to have a sample application up and running! The Wicket API is +> very Swing like, which was a welcome change for me, and allowed for a +> very familiar development experience. There is even an extension that +> allows for direct use of a Swing TreeModel. There are so many things +> that I like about this framework ..." +> +> From a blog item by the Code Poet + +> "Wicket has a learning flat." +> +> Al Maw + +> JSF is Cool and young but Wicket is younger and even cooler. Have +> you tried wicket?. I am also building a large CRUD application for +> Job Exchange System in my country using Wicket + JPA + Stateless +> EJB3 + Glassfish (the latest promoted build of glassfish) and we are +> currently in testing phase and I am not having any serious headaches +> as things seems to be under control. All our forms are Ajax. We have +> several concurrent accesses and system is stable. I believe greatly in +> the Wicket Project especially for CRUD cases. +> +> [Dabar Aladejebi](http://www.javalobby.org/java/forums/t90719.html#92132195) + +> "focuses the development efforts in the right place, inside plain Java +> code" !! This was the winning ticket for me. The framework is truly +> amazing. I used ever dang framework in the book and can say that I'm +> most impressed with this one. +> +> [Anonymous on JavaGeek.org](http://javageek.org/2006/03/08/comparing_web_frameworks_wicket.html)-- [Anonymous on JavaGeek.org](http://javageek.org/2006/03/08/comparing_web_frameworks_wicket.html) + +> Shocking simplicity. Back to the roots. Thanks. +> +> [joozsa on JavaGeek.org](http://javageek.org/2006/03/08/comparing_web_frameworks_wicket.html) + +> Wicket as far as I am concerned is the way forward for web development +> in Java. A lot of creativity involved though especially with the loops +> but It makes Web Development so much fun. +> +> [Anonymous on JavaGeek.org](http://javageek.org/2006/03/08/comparing_web_frameworks_wicket.html) + +> "Wicket became my favorite framework in about a 24-hour period, and +> I think it has a very bright future. With most frameworks I see +> limitations, with Wicket I see possibilities. There's your platitude +> for the day :)" +> +> wicket-user mailing list + +> "Count me in... I've only been using Wicket for maybe 2 weeks or so, +> and I'm sold." +> +> Phillip Rhodes + +> Once I grasped the essence of Wicket, everything just started working +> so well. Damn you, Wicket, I said under my breath. I was really +> disappointed that I liked it so much. Damn you Wicket! Suddenly I +> loved all those Wicket developers, because I understood what they +> were trying to say. Web development can be simple, yet have unlimited +> power. +> +> Closet Wicket lover http://git-wip-us.apache.org/repos/asf/wicket-site/blob/8cc72bad/meet/features.md ---------------------------------------------------------------------- diff --git a/meet/features.md b/meet/features.md new file mode 100644 index 0000000..8402110 --- /dev/null +++ b/meet/features.md @@ -0,0 +1,124 @@ +--- +layout: default +title: Features +--- +## POJO Component Model ## + +Pages and Components in Wicket are real Java objects that support +encapsulation, inheritance and events. + +## Ease of Development ## + +Because Wicket is Java and HTML, you can leverage what you know about Java or +your favorite HTML editor to write Wicket applications. + +## Separation of Concerns ## + +Wicket does not mix markup with Java code and adds no special syntax to your +markup files. The worlds of HTML and Java are parallel and associated only by +Wicket ids, which are attributes in HTML and Component properties in Java. +Since Wicket HTML is just HTML and Wicket Java is just Java, coders and +designers can work independently to a large degree and without relying on any +special tools. + +## Secure ## + +Wicket is secure by default. URLs do not expose sensitive information and all +component paths are session-relative. Explicit steps must be taken to share +information between sessions. Furthermore URL encryption allows highly secure web sites. + +## Transparent, Scalable Clustering Support ## + +All Wicket applications will work on a cluster automatically and without +additional work. Once bottlenecks are understood, Wicket enables tuning of +page state replication. The next version of Wicket will support client-side +models for zero-state scalability. + +## Transparent Back Button Support ## + +Wicket supports configurable page version management. When users submit a +form or follow a link from a page they accessed with the back button in their +browser, Wicket is able to revert the page object to the state it was in when +the page was originally rendered. This means you can write web applications +that support the back button with very little work. + +## Multi-tab and multi-window support ## + +Wicket provides an easy way to write application that supports multi-window +and multi-tab usage allowing developer to react properly when users open new +browser window or tab + +## Reusable Components ## + +Reusable components in Wicket are particularly easy to create. Not only can +you extend existing components with the Java extends keyword, but you can +also create Panel components which associate a group of components as a +reusable unit. + +## Simple, Flexible, Localizable Form Validation ## + +It is trivial to write and use validators in Wicket. It is also quite easy to +customize and localize the display and content of validation error messages. + +## Typesafe Sessions ## + +Wicket eliminates the need to manage HttpSession attributes by hand. Page and +component objects are transparently stored in the session and your +application can create a custom session subclass with typesafe properties as +well. All objects stored in the session can automatically participate in +clustering replication. + +## Factory Customizable ## + +Wicket is very extensible. Most operations are customizable through factories +or factory methods. + +## Detachable Models ## + +Model objects in Wicket can be very lightweight in terms of memory and +network use in a cluster. When a model is used, it can "attach", populating +itself with information from persistent storage. When the model is no longer +in use, transient information can be reset, reducing the size of the object. + +## Border Components ## + +Wicket Border components enable the decoration of pages in a reusable +fashion. This is especially useful for inheritance of common navigational +structures or layout. + +## Support for All Basic HTML Features ## + +Wicket supports image tags, links, forms and everything else that you're used +to using in your web application development. + +## Programmatic Manipulation of Attributes ## + +Wicket Components can programmatically change any HTML tag attribute. + +## Automatic Conversions ## + +Once a Form validates, the model can be updated using Wicket converters. Most +ordinary conversions are built-in and it is easy to write new converters. + +## Dynamic Images ## + +Wicket makes image use, sharing and generation very easy. Dynamic images can +be created by simply implementing a paint method. + +## Pageable ListView ## + +ListViews in Wicket are extremely powerful. You can nest any kind of +component in a ListView row, even other ListViews. PageableListView supports +navigation links for large lists. + +## Tree Component ## + +Out of the box tree component for navigating and selecting nodes. + +## Localization ## + +HTML pages, images and resource strings can all be localized. + +## Examples ## + +Wicket has numerous examples showcasing all of the above features. http://git-wip-us.apache.org/repos/asf/wicket-site/blob/8cc72bad/meet/index.md ---------------------------------------------------------------------- diff --git a/meet/index.md b/meet/index.md new file mode 100644 index 0000000..b7a16ee --- /dev/null +++ b/meet/index.md @@ -0,0 +1,4 @@ +--- +layout: default +title: Meet Apache Wicket +--- http://git-wip-us.apache.org/repos/asf/wicket-site/blob/8cc72bad/meet/introduction.md ---------------------------------------------------------------------- diff --git a/meet/introduction.md b/meet/introduction.md new file mode 100644 index 0000000..512409c --- /dev/null +++ b/meet/introduction.md @@ -0,0 +1,296 @@ +--- +layout: default +title: Meet Apache Wicket +--- +By Jonathan Locke, original author of Wicket + +## Why Wicket? + +If you are looking to do web application programming in Java, you have a very +large number of choices these days. In fact, there are so many web +application frameworks now that it has become somewhat of a joke. One blog +site on the Internet poses the question: How many Java web frameworks can you +name? The answer they show looks like this: + +## Frameworks, Frameworks Everywhere + +<TABLE class="confluenceTable"><TBODY> +<TR> +<TD class="confluenceTd">Echo</TD> +<TD class="confluenceTd">Cocoon</TD> +<TD class="confluenceTd">Millstone</TD> +<TD class="confluenceTd">OXF</TD> +</TR> +<TR> +<TD class="confluenceTd">Struts</TD> +<TD class="confluenceTd">SOFIA</TD> +<TD class="confluenceTd">Tapestry</TD> +<TD class="confluenceTd">WebWork</TD> +</TR> +<TR> +<TD class="confluenceTd">RIFE</TD> +<TD class="confluenceTd">Spring MVC</TD> +<TD class="confluenceTd">Canyamo</TD> +<TD class="confluenceTd">Maverick</TD> +</TR> +<TR> +<TD class="confluenceTd">JPublish</TD> +<TD class="confluenceTd">JATO</TD> +<TD class="confluenceTd">Folium</TD> +<TD class="confluenceTd">Jucas</TD> +</TR> +<TR> +<TD class="confluenceTd">Verge</TD> +<TD class="confluenceTd">Niggle</TD> +<TD class="confluenceTd">Bishop</TD> +<TD class="confluenceTd">Barracuda</TD> +</TR> +<TR> +<TD class="confluenceTd">Action Framework</TD> +<TD class="confluenceTd">Shocks</TD> +<TD class="confluenceTd">TeaServlet</TD> +<TD class="confluenceTd">wingS</TD> +</TR> +<TR> +<TD class="confluenceTd">Expresso</TD> +<TD class="confluenceTd">Bento</TD> +<TD class="confluenceTd">jStatemachine</TD> +<TD class="confluenceTd">jZonic</TD> +</TR> +<TR> +<TD class="confluenceTd">OpenEmcee</TD> +<TD class="confluenceTd">Turbine</TD> +<TD class="confluenceTd">Scope</TD> +<TD class="confluenceTd">Warfare</TD> +</TR> +<TR> +<TD class="confluenceTd">JWAA</TD> +<TD class="confluenceTd">Jaffa</TD> +<TD class="confluenceTd">Jacquard</TD> +<TD class="confluenceTd">Macaw</TD> +</TR> +<TR> +<TD class="confluenceTd">Smile</TD> +<TD class="confluenceTd">MyFaces</TD> +<TD class="confluenceTd">Chiba</TD> +<TD class="confluenceTd">JBanana</TD> +</TR> +<TR> +<TD class="confluenceTd">Jeenius</TD> +<TD class="confluenceTd">JWarp</TD> +<TD class="confluenceTd">Genie</TD> +<TD class="confluenceTd">Melati</TD> +</TR> +<TR> +<TD class="confluenceTd">Dovetail</TD> +<TD class="confluenceTd">Cameleon</TD> +<TD class="confluenceTd">JFormular</TD> +<TD class="confluenceTd">Xoplon</TD> +</TR> +<TR> +<TD class="confluenceTd">Japple</TD> +<TD class="confluenceTd">Helma</TD> +<TD class="confluenceTd">Dinamica</TD> +<TD class="confluenceTd">WebOnSwing</TD> +</TR> +<TR> +<TD class="confluenceTd">Nacho</TD> +<TD class="confluenceTd">Cassandra</TD> +<TD class="confluenceTd">Baritus</TD> +<TD class="confluenceTd">Stripes</TD> +</TR> +<TR> +<TD class="confluenceTd">Click</TD> +<TD class="confluenceTd">GWT</TD> +<TD class="confluenceTd"> </TD> +<TD class="confluenceTd"> </TD> +</TR> +</TBODY></TABLE> + + +## Why "Reinvent the Wheel"? + +In light of this, you may be wondering "What good is another web application +framework?" Indeed. Why "re-invent the wheel?" One snappy comeback to that +old saw is: because this time we could make it rounder! + +But it was not simply a desire for higher quality that drove the creation of +Wicket. Even with so many options, there really is no web toolkit which fills +exactly the niche that Wicket fills. In fact, Wicket is quite unlike each of +the frameworks above. + +Wicket's closest cousins are probably Tapestry and Echo, but even there the +likeness is very shallow. Like Tapestry, Wicket uses a special HTML attribute +to denote components, enabling easy editing with ordinary HTML editors. Like +Echo, Wicket has a first-class component model. But Wicket applications are +not like applications written in either Tapestry or Echo, because in Wicket +you get the best of both worlds. You get the benefits of a first-class +component model and a non-intrusive approach to HTML. In many situations, +this combination may prove to be a significant development advantage. + +To understand why Wicket is so different, it may help to understand the +motivations that created it. + +## Motivations + +### Most existing web frameworks provide weak to non-existent support in managing server-side state ### + +This normally means lots of ad-hoc code in web applications dealing with the +gory mechanics of state management. While Wicket will not allow you to stop +thinking about server state, it goes a long ways towards making it easy and +often transparent to manage that state. + +In Wicket, all server side state is automatically managed. You will never +directly use an HttpSession object or similar wrapper to store state. +Instead, state is associated with components. Each server-side page component +holds a nested hierarchy of stateful components, where each component's model +is, in the end, a POJO (Plain Old Java Object). Wicket maintains a map of +these pages in each user's session. One purpose of this page map (and the +component hierarchy on each page) is to allow the framework to hide all +details of how your components and models are accessed. You deal with simple, +familiar Java objects and Wicket deals with things like URLs, session ids and +GET/POST requests. + +You will also find that this well-structured server state makes it very easy +to deal with the dreaded "back button problem". In fact, Wicket has a generic +and robust solution which can identify and expire browser-cached pages that +have become stale due to structural changes to the model of a component on +the page. + +Finally, Wicket has been designed to work with POJO persistence frameworks +such as JDO or Hibernate. This can make database driven web applications +quite easy to write. + +For many applications, it will be worth trading off the increased server load +of extra server-side state for decreased development costs, lower maintenance +costs, quicker time-to-market and generally higher quality software. The +basic observation here is that software is expensive and complex while +servers from companies like E-machines and Dell are relatively dirt cheap. + +In terms of efficiency versus productivity, perhaps Wicket is to JSP as Java +is to C. You can accomplish anything in Wicket in JSP. You may even do it +more efficiently in terms of memory or processor consumption. But it may take +you weeks or months longer to develop your application. And in the end, since +state management in JSP is ad-hoc, you are likely find security problems and +bugs popping up everywhere. Most of the other frameworks above will do only a +little more to help you. + +### Most existing frameworks require special HTML code + +JSP is by far the worst offender, allowing the embedding of Java code +directly in web pages, but to some degree almost all of the frameworks from +the list (except Tapestry) above introduce some kind of special syntax to +your HTML code. + +Special syntax is highly undesirable because it changes the nature of HTML +from the kind of pure-and-simple HTML markup that web designers are familiar +with, to some kind of special HTML. This special HTML can be more difficult +to preview, edit and understand. + +Wicket does not introduce any special syntax to HTML. Instead, it extends +HTML in a standards-compliant way via a Wicket namespace that is fully +compliant with the XHTML standard. This means that you can use Macromedia +Dreamweaver, Microsoft Front Page, Word, Adobe Go Live, or any other existing +HTML editor to work on your web pages and Wicket components. To accomplish +this, Wicket consistently uses a single id attribute in the Wicket namespace +("wicket:id") to mark HTML tags that should receive special treatment by the +toolkit. If you prefer not to render Wicket namespaced tags and attributes to +your end-users, Wicket has a simple setting to strip them all out, resulting +in ordinary, standards-compliant HTML. + +No "special sauce" in your HTML means designers can mock up pages that you +can use directly in development. Adding Java components to the HTML is as +simple as setting the component name attribute. And you can then give the +HTML back to your web designers knowing that they can change it with +confidence. + +Wicket, more than any other framework gives you a separation of concerns. Web +designers can work on the HTML with very little knowledge of the application +code (they cannot remove the component name tags and they cannot arbitrarily +change the nesting of components, but anything else goes). Likewise, coders +can work on the Java components that attach to the HTML without concerning +themselves with what a given page looks like. By not stepping on each other's +toes, everyone can get more work done. + +### Existing frameworks are not easy + +Most of the existing toolkits have poorly defined or non-existent object +models. In some cases, the model is defined using special XML syntaxes. The +syntaxes may be so cumbersome that special tools are required to manipulate +all the configuration information. Since these toolkits are not simple Java +libraries you may or may not be able to use your favorite IDE tools such as +editors, debuggers and compilers. + +Wicket is all about simplicity. There are no configuration files to learn in +Wicket. Wicket is a simple class library with a consistent approach to +component structure. In Wicket, your web applications will more closely +resemble a Swing application than a JSP application. If you know Java (and +especially if you know Swing), you already know a lot about Wicket. + +### Existing frameworks inhibit reusability + +Tapestry and JSF at least have component models that allow reuse, but you are +likely to find that it is not particularly trivial to do, at least when +compared with Wicket. Wicket has been explicitly designed to make it very, +very easy to create reusable components. It's surprisingly simple to extend +existing components and to make compound components such as a SignInPanel or +AddressForm. It is also relatively easy to create components that exploit new +features of browsers. Components in Wicket can be packaged up in JAR files +and reused by simply dropping them in your lib folder - no configuration +necessary! + +### Web programming should be fun! + +This is my most personal goal for writing Wicket . None of the existing +frameworks are appealing to me in terms of intuitiveness, quickness, ease of +development, etc. It is my hope that Wicket represents a significant step in +the direction of making web applications easy and fun to write. + +## Goals + +Coming from these motivations, the following goals for Wicket emerged: + +* EASY (SIMPLE / CONSISTENT / OBVIOUS) + * POJO-centric + * All code written in Java ala Swing + * Minimize "conceptual surface area" + * Avoid overuse of XML configuration files + * Fully solve back button problem + * Easy to create bookmarkable pages + * Maximum type safety and compile-time problem diagnosis + * Maximum diagnosis of run-time problems + * Minimum reliance on special tools + * Components, containers and conventions should be consistent + +* REUSABLE + * Components written in Wicket should be fully reusable + * Reusable components should be easily distributed in ordinary JAR files + +* NON-INTRUSIVE + * HTML or other markup not polluted with programming semantics + * Only one simple tagging construct in markup + * Compatible with any ordinary HTML editor + * Easy for graphics designers to recognize and avoid framework tagging + * Easy to add tagging back to HTML if designers accidentally remove it + +* SAFE + * Code is secure by default + * Only explicitly bookmarkable links can expose state in the page or URL + * All logic in Java with maximum type safety + * Easy to integrate with Java security + +* EFFICIENT / SCALABLE + * Efficient and lightweight, but not at the expense of other goals + * Clustering through sticky sessions preferred + * Clustering via session replication is easy to accomplish and easy to tune by working with detachable models. + +* COMPLETE + + * The Wicket team is committed to deliver a feature complete, ready-to-use + framework for developing Java web applications. The core framework was + written and contributed by the author of this introduction, Jonathan + Locke. The current team consists of a group of experienced programmers, + some of which were active on some of the other frameworks stated above, + and all of which have extensive experience building large scale Java web + applications. We eat our own dogfood, and will thus work on Wicket from a + framework user's perspective. http://git-wip-us.apache.org/repos/asf/wicket-site/blob/8cc72bad/meet/vision.md ---------------------------------------------------------------------- diff --git a/meet/vision.md b/meet/vision.md new file mode 100644 index 0000000..79628a9 --- /dev/null +++ b/meet/vision.md @@ -0,0 +1,60 @@ +--- +layout: default +title: The Wicket Vision +--- + +Designing and implementing any framework for use in the real world inevitably +involves compromises and some degree of complexity, and Wicket is no +exception. However, I believe you will find that Wicket is quite compact, +focused and powerful as a framework. If Wicket has these characteristics, it +is because it was designed to solve one very specific problem well: + +> enabling component-oriented, programmatic manipulation of markup + +Wicket does this and very little else, and that is a good thing. + +I once heard Josh Bloch talk about the power to weight ratio of an API. The +highest compliment anyone could make of Wicket would be to suggest that +Wicket has a lot of power and not much conceptual surface area. + +In art, negative space is the part that's not the subject. In music, negative +space is the rest. In software, negative space is all the code that you +managed to avoid writing. In all three disciplines, it's what separates what +is truly excellent from what is merely good. + +Following this metaphor, if Wicket is our foreground object, it is defined in +a negative sense by all the things that it is not (by the background). + +In other words, ideally, Wicket is a web UI framework that delegates as many +areas of responsibility as possible to other, more focused tools and +techniques. It recognizes that Hibernate is good at persistence; that Spring is +good at DI; that Java properties files are good for +localization; that sub-classing is good for creating component types; that +Dreamweaver is good at doing HTML layout; that Beans are good for structuring +properties; and so on. + +The more ways that Wicket can find to offload responsibilities (both now and +in the future), the less it will be. And thus, the more it will be. + +The difficulty moving forward with Wicket will be balancing all the +day-to-day needs people are going to be bringing up with this overall vision +of minimalism. There ultimately will be compromises, and the "trick" to +making the right compromises is simply to agonize over all the options for a +long time and then to only make the compromises that everyone agrees are +really essential to what Wicket needs to be and do. + +A big part of this process of agonizing is to act like doctors and "first, do +no harm". If some issue isn't sitting well with everyone yet, there's +probably a reason for that. So, maybe the near-term solution is to simply do +nothing and let people use the existing functionality until the limits to +that approach (as well as competing ideas) are better understood. + +It's easy to add features. It's often impossible to change or remove them. + +Given this, the Wicket approach to the overall problem of evolving while +keeping a high power to weight ratio will be partitioning off all +controversial new ideas in a "wicket-stuff" package until they are broadly +accepted. This way people can experiment and code away and check in lots of +stuff without affecting the main codebase with untested ideas. Then, when +ideas pan out to everyone's satisfaction, the leads of the +project will move them into the core. http://git-wip-us.apache.org/repos/asf/wicket-site/blob/8cc72bad/readme.md ---------------------------------------------------------------------- diff --git a/readme.md b/readme.md new file mode 100644 index 0000000..3fb6b8e --- /dev/null +++ b/readme.md @@ -0,0 +1,28 @@ +Wicket Site +=========== + +This is a project for tracking a new design for the Apache Wicket website. The +site is generated to static html using +[jekyll](http://github.com/mojombo/jekyll). + +If you want to see how it might look in the future, see the file +[wicketsite5.pdf](http://github.com/dashorst/wicket-site/raw/master/_design/wicketsite5.pdf +"Design document") + +If you want to see how it looks now, see the [generated +markup](http://github.com/dashorst/wicket-site/raw/master/_site/index.html). + +Running the site +---------------- + +Use (after installing jekyll) the following command to run jekyll in a server +mode: + + $ ./regenerate.sh + +This instructs jekyll to generate new output whenever something changes on +the filesystem, and serve those files to the default port (4000) on your box. + +Note that this script restores Subversion (`.svn`) subfolders +inside `_site`, which are erased when Jekyll is generating the content. + http://git-wip-us.apache.org/repos/asf/wicket-site/blob/8cc72bad/regenerate.sh ---------------------------------------------------------------------- diff --git a/regenerate.sh b/regenerate.sh new file mode 100755 index 0000000..85d8dac --- /dev/null +++ b/regenerate.sh @@ -0,0 +1,13 @@ +#!/bin/bash + +#workaround script for regenerating the site because jekyll completely wipes _site which causes problems for svn +echo Backing up .svn folders in _site +mkdir _tmp +tar cfT _tmp/archive.tar /dev/null +find _site -name ".svn"|xargs -I{} tar -rf _tmp/archive.tar {} +#jekyll +jekyll build +echo Restoring .svn folders in _site +tar -xf _tmp/archive.tar +rm -rf _tmp + http://git-wip-us.apache.org/repos/asf/wicket-site/blob/8cc72bad/start/download.md ---------------------------------------------------------------------- diff --git a/start/download.md b/start/download.md new file mode 100644 index 0000000..26bdf73 --- /dev/null +++ b/start/download.md @@ -0,0 +1,129 @@ +--- +layout: default +title: Download Wicket releases +--- + +Apache Wicket {{site.wicket.version}} is the current stable release. +Most users get Apache Wicket using [Apache Maven's dependency +management](#maven), which incidentally is the most convenient way of +obtaining the latest and greatest Wicket. + +## Download + +New projects should use [Wicket {{site.wicket.version}}](http://www.apache.org/dyn/closer.cgi/wicket/{{site.wicket.version}}) as their base. + + * **Latest stable release**: [{{site.wicket.version}}](http://www.apache.org/dyn/closer.cgi/wicket/{{site.wicket.version}}) + * **Latest 6.x release**: [{{site.wicket.version_60}}](http://www.apache.org/dyn/closer.cgi/wicket/{{site.wicket.version_60}}) + * **Latest 1.5.x release**: [{{site.wicket.version_15}}](http://www.apache.org/dyn/closer.cgi/wicket/{{site.wicket.version_15}}) + * **Latest 1.4.x release** (security updates only): [{{site.wicket.version_14}}](http://www.apache.org/dyn/closer.cgi/wicket/{{site.wicket.version_14}}) + * **Archived releases**: <http://archive.apache.org/dist/wicket> + +We recommend you [start](quickstart.html) with our latest stable release. + +### Developer releases + +If you like to live on the cutting edge and help development of Wicket +further along, you can try out the development milestone releases: + + * Latest **development milestone** release for 7.x: + [{{site.wicket.version_70}}](http://www.apache.org/dyn/closer.cgi/wicket/{{site.wicket.version_70}}) + +This release is not fit for production use yet: it is only intended for +developers of Wicket, or for people trying out our development +versions. API changes will occur between releases. + +### Requirements + +#### Java version + + * Apache Wicket 7.x requires JDK 7.0 or newer + * Apache Wicket 6.x requires JDK 6.0 or newer + * Apache Wicket 1.5.x requires JDK 1.5 or newer + * Apache Wicket 1.4.x requires JDK 1.5 or newer + +#### Mixing Wicket versions + +You cannot mix different Wicket versions in your project. You should +always use the artifacts from a particular release train. + +For example it is **NOT** possible to use Wicket Extensions 1.5 in a +Wicket 6 project. The same goes for 3rd party libraries: make sure you +always use a compatible version of your 3rd party library. + +#### Logging + +You cannot use Wicket without adding an SLF4J logging implementation to +your classpath. Most people use +[log4j](http://logging.apache.org/log4j). + +If you do, just include **slf4j-log4j12.jar** on your classpath to get +Wicket to use log4j too. If you want to use commons-logging or JDK14 +logging or something else, please see the [SLF4J +site](http://www.slf4j.org/faq.html) for more information. + + +## Migrating from earlier versions + +If you are migrating an existing application from earlier versions of +Wicket you may find our migration guides invaluable: + + * Migrating from [Wicket 1.2 to Wicket 1.3](https://cwiki.apache.org/confluence/display/WICKET/Migrating+to+Wicket+1.3) + * Migrating from [Wicket 1.3 to Wicket 1.4](https://cwiki.apache.org/confluence/display/WICKET/Migrating+to+Wicket+1.4) + * Migrating from [Wicket 1.4 to Wicket 1.5](https://cwiki.apache.org/confluence/display/WICKET/Migration+to+Wicket+1.5) + * Migrating from [Wicket 1.5 to Wicket 6.x](https://cwiki.apache.org/confluence/display/WICKET/Migration+to+Wicket+6.0) + * Migrating from [Wicket 6.x to Wicket 7.x](https://cwiki.apache.org/confluence/display/WICKET/Migration+to+Wicket+7.0) + +## Maven + +Add the following snippet to your Maven project descriptor (`pom.xml`): + +{% highlight xml %} +<dependency> + <groupId>org.apache.wicket</groupId> + <artifactId>wicket-core</artifactId> + <version>{{site.wicket.version}}</version> +</dependency> +{% endhighlight %} + +For the SLF4J log4j binding: + +{% highlight xml %} +<dependency> + <groupId>org.slf4j</groupId> + <artifactId>slf4j-log4j12</artifactId> + <version>1.6.4</version> +</dependency> +{% endhighlight %} + +## SNAPSHOTs and latest bleeding-edge code ## + +If you wish to build the latest code from scratch, master and branches +live in the Git repository: https://git-wip-us.apache.org/repos/asf/wicket.git + +Branches: + +* **7.x**: master +* **6.x**: wicket-6.x +* **1.5.x**: wicket-1.5.x +* **1.4.x**: wicket-1.4.x +* **1.3.x**: wicket-1.3.x +* **1.2.x**: wicket-1.2.x + +There's also a Maven 2 repository providing SNAPSHOTs available here: + +{% highlight xml %} +<repositories> + <repository> + <releases> + <enabled>false</enabled> + </releases> + <snapshots> + <enabled>true</enabled> + </snapshots> + <id>apache.snapshots</id> + <name>Apache Snapshot Repository</name> + <url>https://repository.apache.org/content/groups/snapshots</url> + <layout>default</layout> + </repository> +</repositories> +{% endhighlight %} http://git-wip-us.apache.org/repos/asf/wicket-site/blob/8cc72bad/start/index.md ---------------------------------------------------------------------- diff --git a/start/index.md b/start/index.md new file mode 100644 index 0000000..6b64a41 --- /dev/null +++ b/start/index.md @@ -0,0 +1,8 @@ +--- +layout: default +title: Get Started +--- + +* Start with Apache Wicket using the [quickstart](quickstart.html) +* [Download](download.html) the latest and greatest Wicket release +* Or use one of the available third party <a href="http://www.jweekend.com/dev/LegUp"; rel="nofollow">Maven archetypes</a> \ No newline at end of file http://git-wip-us.apache.org/repos/asf/wicket-site/blob/8cc72bad/start/installing.md ---------------------------------------------------------------------- diff --git a/start/installing.md b/start/installing.md new file mode 100644 index 0000000..5c1b057 --- /dev/null +++ b/start/installing.md @@ -0,0 +1,57 @@ +--- +layout: default +title: Installing Wicket +--- + +So you chose not to use one of the ready to use Maven archetypes, but rather +roll things on your own. While possible, it needs some close attention to +make things work properly. Most notable things you need to take care of are: + +* dependencies +* logging + +## Required dependencies to use Wicket + +While we are adamant users of Apache Maven and its build infrastructure, this +may not be to everyone's liking. However, if you wish to learn all about +which dependencies you need for your Wicket project, we ask you to learn to +read the POM file format and retrieve the required versions stated there. We +take great care to keep the POM files up to date with the latest and greatest +of each dependency. + +### Compilation & Testing ### + +At a minimum a vanilla Wicket application requires for compilation: + +* Java SDK 1.5 or newer +* servlet-api +* slf4j-api +* any slf4j implementation and dependencies necessary for that logging + provider +* junit if you build Wicket from source or want to use `WicketTester` to test + your pages and components + +### Runtime dependencies ### + +At a minimum a barebones Wicket application requires the following at runtime: + +* a servlet container (Apache Tomcat, Jetty) or any JEE container +* Java 5 runtime or newer +* slf4j-api and your slf4j implementation and required logging provider + dependencies. + +## Logging + +As of Wicket 1.3.0, Wicket uses the [SLF4J](http://www.slf4j.org/) project +for logging. SLF4J is similar to +[commons-logging](http://jakarta.apache.org/commons/logging/), in that it +allows libraries/frameworks like Wicket to avoid forcing a choice of logging +framework on their users. + +**You cannot use Wicket without adding an SLF4J logging implementation to +your classpath**. Most people use [log4j](http://logging.apache.org/log4j). +If you do, just include `slf4j-log4j12.jar` on your classpath to get Wicket +to use log4j too. If you want to use commons-logging or JDK14 logging or +something else, please see the [SLF4J site](http://www.slf4j.org/faq.html) +for more information. + http://git-wip-us.apache.org/repos/asf/wicket-site/blob/8cc72bad/start/quickstart.md ---------------------------------------------------------------------- diff --git a/start/quickstart.md b/start/quickstart.md new file mode 100644 index 0000000..61be2c4 --- /dev/null +++ b/start/quickstart.md @@ -0,0 +1,207 @@ +--- +layout: default +title: Create a Wicket Quickstart +--- + +There are two really good reasons to create a Wicket quickstart. The first is if +you just want to get started using Wicket quickly. The quickstart will set up a +ready-to-use project in under a minute (depending on your bandwidth). Another +great reason to create a quickstart is to accompany a bug report. If you report +a bug in JIRA or on the mailing list, the core developers may not be able to +recreate it easily. In most cases, you'll be told "please create a quickstart and +attach it to a JIRA issue". If you don't know how to do that, don't worry - just +follow the instructions below. (If you are submitting a quickstart for an issue +report, please be sure to read the subheading below - "Submitting a quickstart +for an issue report" + +Quickstarts are made from a Maven archetype. So, you will need to have +[Maven 2](http://maven.apache.org) installed and working (from the command line) +before following this. + +Creating a quickstart provides only a very basic starting point for your Wicket +project. If you are looking for examples of how to use Wicket and its various +features, please refer to the *wicket-example* projects instead! + +## Creating the project - with Maven + +To create your project, copy and paste the command line generated after +typing in the groupId, artifactId and version. + +<style> + #mvncmd { + padding-left: 25px; + } + #mvncmd label { + font-weight: bold; + width: 100px; + display: inline-block; + } + #mvncmd input, #mvncmd select, #mvncm span { width: 180px; margin-bottom: 5px;} + #mvncmd textarea { width: 400px; height: 100px; } + #mvncmd br { clear: left; } + #mvncmd div { clear:both; padding-left: 25px; vertical-align:top;} +</style> +<script type="text/javascript"> + function changeIt() + { + var groupId = document.getElementById("groupId").value; + var artifactId = document.getElementById("artifactId").value; + var version = document.getElementById("version").value; + var appserver = document.getElementById("appserver").value; + var cmd; + if(version.match(/^1\.[34]/)) + cmd = 'mvn archetype:create -DarchetypeGroupId=org.apache.wicket -DarchetypeArtifactId=wicket-archetype-quickstart -DarchetypeVersion=' + version + ' -DgroupId=' + groupId + ' -DartifactId=' + artifactId; + else + cmd = 'mvn archetype:generate -DarchetypeGroupId=org.apache.wicket -DarchetypeArtifactId=wicket-archetype-quickstart -DarchetypeVersion=' + version + ' -DgroupId=' + groupId + ' -DartifactId=' + artifactId; + + if (version.match(/.*SNAPSHOT/)) + cmd += ' -DarchetypeRepository=https://repository.apache.org/content/repositories/snapshots/'; + else + cmd += ' -DarchetypeRepository=https://repository.apache.org/'; + + if (appserver === 'wildfly') + cmd += ' -Dlog4j.properties=wildfly-doesnt-need-log4j.properties'; + + cmd += ' -DinteractiveMode=false'; + document.getElementById("cmdLine").value = cmd; + } +</script> +<div id="mvncmd"> + <div> + <label for="groupId" title="Base Package">GroupId:</label> + <input type="text" id="groupId" value="com.mycompany" onkeyup="changeIt();" /><span title="Base Package"> (?)</span><br/> + </div> + <div> + <label for="artifactId" title="Project Name">ArtifactId:</label> + <input type="text" id="artifactId" value="myproject" onkeyup="changeIt();" /><span title="Project Name"> (?)</span><br/> + </div> + <div> + <label for="version" title="Wicket Version">Version:</label> + <select id="version" onchange="changeIt();"> +{% for version in site.wicket.versions reversed %} + {% if version == site.wicket.version %} + <option value="{{version}}" selected="selected">{{version}}</option> + {% else %} + <option value="{{version}}">{{version}}</option> + {% endif %} +{% endfor %} + </select><span title="Wicket Version"> (?)</span> + </div> + <div> + <label for="appserver" title="Server to deploy on">Server:</label> + <select id="appserver" onchange="changeIt();"> + <option value="any" selected="selected">Any but Wild Fly</option> + <option value="wildfly" >Wild Fly (JBoss 8.x)</option> + </select><span title="Web/App Server"> (?)</span> + </div> + <div> + <label for="cmdLine" id="cmdLabel">Command Line:</label> + <textarea id="cmdLine" onfocus="this.select();"> + </textarea> + <script>changeIt();</script> + </div> + <br /> +</div> + +### Results + +This will produce the following project structure/files: + +<div style="margin-left: 3em; border: 1px solid black"> +<pre> + .\myproject + | pom.xml + | + \---src + +---main + | +---java + | | \---com + | | \---mycompany + | | HomePage.html + | | HomePage.java + | | WicketApplication.java + | | + | +---resources + | | log4j.properties + | | + | \---webapp + | \---WEB-INF + | web.xml + | + \---test + \---java + \---com + \---mycompany + Start.java +</pre> +</div> + +### Using Maven quickstart with a specific IDE + +Maven has an integration with many IDEs. If you want to use your new Maven-based +Wicket quickstart with your favorite IDE, see one of these instructions: + +#### Eclipse + +Change directory into the project that you just created. Now, run +`mvn eclipse:eclipse`. This will set up the .project, .settings, and .classpath +files that Eclipse requires. + +Note that your workspace will have to have the classpath variable M2_REPO set to point to the directory where your local Maven repository exists. You can see this page for how to do that with Eclipse: <http://maven.apache.org/plugins/maven-eclipse-plugin/usage.html> + +Now, in Eclipse, you can choose "File" (menu), then "Import", then "Existing project". +Navigate to the folder where your project exists and let Eclipse import it. The classpath should +be fully configured. + +Alternatively install the [m2eclipse](http://m2eclipse.codehaus.org/) or +[Eclipse IAM](http://www.eclipse.org/iam/) plugin and add the project +directly. + +#### IDEA #### + +From within IDEA, just use "File/Import Project", choose the project directory and specify that this is a Maven project. + +#### NetBeans #### + +To create a NetBeans project, just open the pom.xml directly. + +### More examples + +Many more information and examples can be found on our Wiki or +[here](http://www.ralfebert.de/blog/wicket/wicket_eclipse_setup/) + +## Using your new project + +Wicket quickstart projects include a file named Start.java. If you open this file in +your IDE (after configuring the project in your IDE), you can run it as a Java application. +It will run an embedded Jetty instance that will run your app on <http://localhost:8080> +Navigate your browser to that address to see your app running. + +### Using the Jetty Plugin + +The Jetty plugin is also enabled by default in the quickstart. If you are using Maven, +you can change directory into the project and run the "mvn jetty:run" command. This will +compile the project and deploy it to an embeded instance of the Jetty servlet engine, +which will run on port 8080, by default. As a result, once running, your application will be available at <http://localhost:8080>. + +See the [Jetty plugin](http://www.mortbay.org/maven-plugin/index.html) +documentation for configuration options, etc. + +## Submitting a quickstart for an issue report + +### Reproduce the problem + +Assuming you have followed the instructions above, the quickstart is now created and ready for you to develop. Now comes the "duplicate the problem" part. Try to create pages or components that reproduce the problem you were trying to report. You can run the Start.java class from your +IDE and go to <http://localhost:8080> to see your test application. If you run the Start.java class +in your IDE's debug mode, you should be able to attach breakpoints and have automatic class and +markup reloading. + +If you can't reproduce the problem - start looking at your own code. Keep adding pieces from +your code until either you reproduce the problem, or else you've found the bug in your own code. +A lot of times, you will find the bug in your code just by trying to create a quickstart that +demonstrates the bug in ours. + +### Clean up the quickstart and submit it + +Once you have reproduced the desired behavior in your quickstart, it would be best to make it as small as possible before submitting. The best way to do this is to run the "mvn clean" command from the project directory. Then zip (or tar and gzip) the whole directory up and submit the zip (or tgz) file. (The mvn clean command removes all of the compiled classes and generated artifacts, generally in your "target" directory, leaving only the actual source.) + http://git-wip-us.apache.org/repos/asf/wicket-site/blob/8cc72bad/start/userguide.md ---------------------------------------------------------------------- diff --git a/start/userguide.md b/start/userguide.md new file mode 100644 index 0000000..1a6ece0 --- /dev/null +++ b/start/userguide.md @@ -0,0 +1,12 @@ +--- +layout: default +title: Wicket User Guide +--- + +The user guide has been written using the doc engine from Grails project and is available in the following formats: + +* [HTML](http://ci.apache.org/projects/wicket/guide/6.x/) +* [HTML (single page)](http://ci.apache.org/projects/wicket/guide/6.x/guide/single.html) +* [PDF](http://ci.apache.org/projects/wicket/guide/6.x/guide/single.pdf) + +For more details about the format used to write the guide and to know how to contrinute, see [the relative chapter](http://ci.apache.org/projects/wicket/guide/6.x/guide/contributing.html).
