You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@wicket.apache.org by mg...@apache.org on 2015/05/09 08:58:24 UTC
[02/28] wicket-site git commit: Initial commit. Moving the site from
svnpubsub (https://svn.apache.org/repos/asf/wicket/common/site/trunk) to
gitpubsub (https://git-wip-us.apache.org/repos/asf/wicket-site.git)
http://git-wip-us.apache.org/repos/asf/wicket-site/blob/8cc72bad/js/zeroclipboard/ZeroClipboard10.as
----------------------------------------------------------------------
diff --git a/js/zeroclipboard/ZeroClipboard10.as b/js/zeroclipboard/ZeroClipboard10.as
new file mode 100644
index 0000000..7b07a6a
--- /dev/null
+++ b/js/zeroclipboard/ZeroClipboard10.as
@@ -0,0 +1 @@
+package {
// Simple Set Clipboard System
// Author: Joseph Huckaby
import flash.display.Stage;
import flash.display.Sprite;
import flash.desktop.Clipboard;
import flash.desktop.ClipboardFormats;
import flash.desktop.ClipboardTransferMode;
import flash.display.LoaderInfo;
import flash.display.StageScaleMode;
import flash.events.*;
import flash.display.StageAlign;
import flash.display.StageScaleMode;
import flash.external.ExternalInterface;
import flash.system.Security;
import flash.utils.*;
import flash.system.System;
public class ZeroClipboard10 extends Sprite {
private var id:String = '';
private var button:Sprite;
private var clipText:String = '';
public function ZeroClipboard10() {
// constructor, setup event listeners and external interfaces
stage.scaleMode = StageScaleMode.EXACT_FIT;
flash.system.Security.allowDomain("*");
// import flashvars
var flashvars:Object = LoaderInfo( this.root.loaderInfo ).parameters;
id = fl
ashvars.id;
// invisible button covers entire stage
button = new Sprite();
button.buttonMode = true;
button.useHandCursor = true;
button.graphics.beginFill(0xCCFF00);
button.graphics.drawRect(0, 0, Math.floor(flashvars.width), Math.floor(flashvars.height));
button.alpha = 0.0;
addChild(button);
button.addEventListener(MouseEvent.CLICK, clickHandler);
button.addEventListener(MouseEvent.MOUSE_OVER, function(event:Event) {
ExternalInterface.call( 'ZeroClipboard.dispatch', id, 'mouseOver', null );
} );
button.addEventListener(MouseEvent.MOUSE_OUT, function(event:Event) {
ExternalInterface.call( 'ZeroClipboard.dispatch', id, 'mouseOut', null );
} );
button.addEventListener(MouseEvent.MOUSE_DOWN, function(event:Event) {
ExternalInterface.call( 'ZeroClipboard.dispatch', id, 'mouseDown', null );
} );
button.addEventListener(MouseEvent.MOUSE_UP, function(event:Event) {
ExternalInterface.call( 'ZeroClipboard.dispatch', id
, 'mouseUp', null );
} );
// external functions
ExternalInterface.addCallback("setHandCursor", setHandCursor);
ExternalInterface.addCallback("setText", setText);
// signal to the browser that we are ready
ExternalInterface.call( 'ZeroClipboard.dispatch', id, 'load', null );
}
public function setText(newText) {
// set the maximum number of files allowed
clipText = newText;
}
public function setHandCursor(enabled:Boolean) {
// control whether the hand cursor is shown on rollover (true)
// or the default arrow cursor (false)
button.useHandCursor = enabled;
}
private function clickHandler(event:Event):void {
// user click copies text to clipboard
// as of flash player 10, this MUST happen from an in-movie flash click event
Clipboard.generalClipboard.clear();
Clipboard.generalClipboard.setData(ClipboardFormats.TEXT_FORMAT, clipText);
Clipboard.generalClipboard.setData(ClipboardFormats.HTML_FORMAT, clipText);
ExternalInterface.call( 'ZeroClipboard.dispatch', id, 'complete', clipText );
}
}
}
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/wicket-site/blob/8cc72bad/js/zeroclipboard/ZeroClipboard10.fla
----------------------------------------------------------------------
diff --git a/js/zeroclipboard/ZeroClipboard10.fla b/js/zeroclipboard/ZeroClipboard10.fla
new file mode 100755
index 0000000..b98b5b9
Binary files /dev/null and b/js/zeroclipboard/ZeroClipboard10.fla differ
http://git-wip-us.apache.org/repos/asf/wicket-site/blob/8cc72bad/js/zeroclipboard/ZeroClipboard10.swf
----------------------------------------------------------------------
diff --git a/js/zeroclipboard/ZeroClipboard10.swf b/js/zeroclipboard/ZeroClipboard10.swf
new file mode 100644
index 0000000..bfed97f
Binary files /dev/null and b/js/zeroclipboard/ZeroClipboard10.swf differ
http://git-wip-us.apache.org/repos/asf/wicket-site/blob/8cc72bad/js/zeroclipboard/test.html
----------------------------------------------------------------------
diff --git a/js/zeroclipboard/test.html b/js/zeroclipboard/test.html
new file mode 100755
index 0000000..a6da39e
--- /dev/null
+++ b/js/zeroclipboard/test.html
@@ -0,0 +1,76 @@
+<html>
+<head>
+ <title>Zero Clipboard Test</title>
+ <style type="text/css">
+ body { font-family:arial,sans-serif; font-size:9pt; }
+
+ .my_clip_button { width:150px; text-align:center; border:1px solid black; background-color:#ccc; margin:10px; padding:10px; cursor:default; font-size:9pt; }
+ .my_clip_button.hover { background-color:#eee; }
+ .my_clip_button.active { background-color:#aaa; }
+ </style>
+ <script type="text/javascript" src="ZeroClipboard.js"></script>
+ <script language="JavaScript">
+ var clip = null;
+
+ function $(id) { return document.getElementById(id); }
+
+ function init() {
+ clip = new ZeroClipboard.Client();
+ clip.setHandCursor( true );
+
+ clip.addEventListener('load', function (client) {
+ debugstr("Flash movie loaded and ready.");
+ });
+
+ clip.addEventListener('mouseOver', function (client) {
+ // update the text on mouse over
+ clip.setText( $('fe_text').value );
+ });
+
+ clip.addEventListener('complete', function (client, text) {
+ debugstr("Copied text to clipboard: " + text );
+ });
+
+ clip.glue( 'd_clip_button', 'd_clip_container' );
+ }
+
+ function debugstr(msg) {
+ var p = document.createElement('p');
+ p.innerHTML = msg;
+ $('d_debug').appendChild(p);
+ }
+ </script>
+</head>
+<body onLoad="init()">
+ <h1>Zero Clipboard Test</h1>
+ <p><script>document.write("Your browser: " + navigator.userAgent);</script></p>
+ <table width="100%">
+ <tr>
+ <td width="50%" valign="top">
+ <!-- Upload Form -->
+ <table>
+ <tr>
+ <td align="right"><b>Text:</b></td>
+ <td align="left"><textarea id="fe_text" cols=50 rows=5 onChange="clip.setText(this.value)">Copy me!</textarea></td>
+ </tr>
+ </table>
+ <br/>
+ <div id="d_clip_container" style="position:relative">
+ <div id="d_clip_button" class="my_clip_button"><b>Copy To Clipboard...</b></div>
+ </div>
+ </td>
+ <td width="50%" valign="top">
+ <!-- Debug Console -->
+ <div id="d_debug" style="border:1px solid #aaa; padding: 10px; font-size:9pt;">
+ <h3>Debug Console:</h3>
+ </div>
+ </td>
+ </tr>
+ </table>
+
+ <br/><br/>
+ You can paste text here if you want, to make sure it worked:<br/>
+ <textarea id="testarea" cols=50 rows=10></textarea><br/>
+ <input type=button value="Clear Test Area" onClick="$('testarea').value = '';"/>
+</body>
+</html>
http://git-wip-us.apache.org/repos/asf/wicket-site/blob/8cc72bad/learn/books/awc.md
----------------------------------------------------------------------
diff --git a/learn/books/awc.md b/learn/books/awc.md
new file mode 100644
index 0000000..37e3c5b
--- /dev/null
+++ b/learn/books/awc.md
@@ -0,0 +1,87 @@
+---
+layout: default
+title: Books — Apache Wicket Cookbook
+---
+
+## Description ##
+
+Apache Wicket is one of the most famous Java web application frameworks. Wicket simplifies web development and makes it fun. Are you bored of going through countless pages of theory to find out how to get your web development done? With this book in hand, you don't need to go through hundreds of pages to figure out how you will actually build a web application. You will get practical solutions to your common everyday development tasks to pace up your development activities.
+
+Apache Wicket Cookbook provides you with information that gets your problems solved quickly without beating around the bush. This book is perfect for you if you are ready to take the next step from tutorials and step into the practical world. It will take you beyond the basics of using Apache Wicket and show you how to leverage Wicket's advanced features to create simpler and more maintainable solutions to what at first may seem complex problems.
+
+You will learn how to integrate with client-side technologies such as JavaScript libraries or Flash components, which will help you to build your application faster. You will discover how to use Wicket paradigms to factor out commonly used code into custom Components, which will reduce the maintenance cost of your application, and how to leverage the existing Wicket Components to make your own code simpler.
+
+A straightforward Cookbook with highly focused practical recipes to make your web application development easier with the Wicket web framework
+
+## What you will learn from this book ##
+
+* Leverage Wicket to implement a wide variety of both simple and advanced use cases in a narrative that gets straight to the point
+* Make forms work in the crazy world of the Web by learning the ways of Wicket's form processing
+* Simplify localizing your Wicket applications
+* Take the boring out of your forms by discovering how to improve the user experience while simplifying your code at the same time
+* Leverage the built-in Table component to make displaying tabular data a snap
+* Think Wicket's Borders are not very useful? Learn to use them in unexpected places to simplify things
+* See how to integrate with Flash components and create interactive charts at the same time
+* Web 1.0 too boring? Learn how to tame Wicket's AJAX support and bring your application into Web 2.0
+* Simplify your security code by learning various security techniques
+* An application cannot be built with Wicket alone; see how to make it play nice with other frameworks
+
+## Approach ##
+
+This is a hands-on practical guide to a large variety of topics and use cases. This book tries to use real-world examples when possible, but is not afraid to come up with a contrived pretext if it makes explaining the problem simpler. Unlike a lot of other books, this one does not try to maintain a continuous theme from chapter to chapter, such as demonstrating solutions on the same fictional application; doing so would be almost impossible given the wide variety of recipes presented here. Instead, this book concentrates on focused problems users are likely to encounter and shows clear solutions in a step-by-step manner. This book tries to teach by example and is not afraid to show a lot of code because, after all, it is for coders.
+
+## Who this book is written for ##
+
+This book is for current users of the Apache Wicket framework; it is not an introduction to Wicket that will bore you with tons of theory. You are expected to have built or maintained a simple Wicket application in the past and to be looking to learn new and better ways of using Wicket. If you are ready to take your Wicket skills to the next level this book is for you.
+
+## About the author ##
+
+Igor Vaynberg is a software architect with more than ten years of experience in the software field. His liking for computers was sparked when his parents got him a Sinclair Z80 when he was but ten years old. Since then he has worked with companies both large and small building modular and scalable web applications. Igor's main interest is finding ways to simplify the development of complex user interfaces required by modern web applications. Igor is a committer for the Apache Wicket framework, the aim of which is to simplify the programming model as well as reintroduce OOP to the web UI tier. In his AFK time he enjoys snowboarding with his beautiful wife and playing with his amazing children.
+
+
+## Book details ##
+
+<table>
+ <tr>
+ <th>Title</th>
+ <td>Apache Wicket Cookbook</td>
+ </tr>
+ <tr>
+ <th>Author</th>
+ <td>Igor Vaynberg</td>
+ </tr>
+ <tr>
+ <th>Version covered</th>
+ <td>Wicket 1.4, but most material is applicable to Wicket 1.5</td>
+ </tr>
+ <tr>
+ <th>Publisher URL</th>
+ <td><a href="http://www.packtpub.com/apache-wicket-cookbook/book">Apache Wicket Cookbook</a></td>
+ </tr>
+ <tr>
+ <th>Paperback</th>
+ <td>312 pages</td>
+ </tr>
+ <tr>
+ <th>Date</th>
+ <td>March, 2011</td>
+ </tr>
+ <tr>
+ <th>Language</th>
+ <td>English</td>
+ </tr>
+ <tr>
+ <th>ISBN-10</th>
+ <td>1849511608</td>
+ </tr>
+ <tr>
+ <th>ISBN-13</th>
+ <td>978-1-84951-160-5</td>
+ </tr>
+ <tr>
+ <th>Buy</th>
+ <td><a href="http://www.packtpub.com/apache-wicket-cookbook/book">PACKT Publishing</a></td>
+ </tr>
+</table>
+
+
http://git-wip-us.apache.org/repos/asf/wicket-site/blob/8cc72bad/learn/books/awc.png
----------------------------------------------------------------------
diff --git a/learn/books/awc.png b/learn/books/awc.png
new file mode 100644
index 0000000..d1114a3
Binary files /dev/null and b/learn/books/awc.png differ
http://git-wip-us.apache.org/repos/asf/wicket-site/blob/8cc72bad/learn/books/ewdww.md
----------------------------------------------------------------------
diff --git a/learn/books/ewdww.md b/learn/books/ewdww.md
new file mode 100644
index 0000000..e83a8fd
--- /dev/null
+++ b/learn/books/ewdww.md
@@ -0,0 +1,86 @@
+---
+layout: default
+title: Books — Enjoying Web Development with Wicket
+---
+
+Enjoying Web Development with Wicket is written by Kent Tong and is self
+published.
+
+## Description ##
+
+If you'd like to create AJAX web-based applications easily, then this book is
+for you. More importantly, it shows you how to do that with joy and feel good
+about your own work! You don't need to know servlet or JSP while your
+productivity will be much higher than using servlet or JSP directly. This is
+possible because we're going to use a library called Wicket that makes
+complicated stuff simple and elegant.
+
+How does it do that? First, it allows the web designer to work on the static
+contents and design of a page while allowing the developer to work on the
+dynamic contents of that page without stepping on each other's toes; Second,
+it allows developers to work with high level concepts such as objects and
+properties instead of HTTP URLs, query parameters or HTML string values;
+Third, it comes with powerful components such as calendar, tree and data grid
+and it allows you to create your own components for reuse in your own project.
+
+However, don't take our word for it! This book will quickly walk you through
+real world use cases to show you how to use Wicket and leave it up to you to
+judge.
+
+## About the author ##
+
+Kent Ka Iok Tong is the manager of the IT department of the Macau Productivity
+and Technology Transfer Center. With a Master degree in Computer Science from
+the New South Wales University, Sydney, Australia and having won the "Macao
+Programming Competition (Open Category)" in 1992, Mr. Tong has been involved
+in professional software development, training and project management since
+1993. He is the author of several popular books on web technologies including
+Developing Web Services with Apache CXF and Axis2. He has also created an open
+source project "Wicket Page Test" for unit testing Wicket pages.
+
+## Book details ##
+
+<table>
+ <tr>
+ <th>Title</th>
+ <td>Enjoying Web Development with Wicket (2nd edition)</td>
+ </tr>
+ <tr>
+ <th>Author</th>
+ <td>Kent Tong</td>
+ </tr>
+ <tr>
+ <th>Version covered</th>
+ <td>Wicket 1.4</td>
+ </tr>
+ <tr>
+ <th>URL</th>
+ <td><a href="http://www.agileskills2.org/EWDW/">Enjoying Web Development with Wicket</a></td>
+ </tr>
+ <tr>
+ <th>Paperback</th>
+ <td>~358 pages</td>
+ </tr>
+ <tr>
+ <th>Date</th>
+ <td>April, 2010</td>
+ </tr>
+ <tr>
+ <th>Language</th>
+ <td>English</td>
+ </tr>
+ <tr>
+ <th>ISBN-10</th>
+ <td>0557522463</td>
+ </tr>
+ <tr>
+ <th>ISBN-13</th>
+ <td>978-0557522460</td>
+ </tr>
+ <tr>
+ <th>Buy</th>
+ <td><a href="http://www.agileskills2.org/EWDW/">AgileSkills</a></td>
+ </tr>
+</table>
+
+
http://git-wip-us.apache.org/repos/asf/wicket-site/blob/8cc72bad/learn/books/ewdww.png
----------------------------------------------------------------------
diff --git a/learn/books/ewdww.png b/learn/books/ewdww.png
new file mode 100644
index 0000000..76b96bc
Binary files /dev/null and b/learn/books/ewdww.png differ
http://git-wip-us.apache.org/repos/asf/wicket-site/blob/8cc72bad/learn/books/index.md
----------------------------------------------------------------------
diff --git a/learn/books/index.md b/learn/books/index.md
new file mode 100644
index 0000000..b544f13
--- /dev/null
+++ b/learn/books/index.md
@@ -0,0 +1,17 @@
+---
+layout: default
+title: Books about Wicket
+---
+
+Several books have been written about Apache Wicket, 5 in English, 2 in German
+and 1 in Japanese. Click on a cover to learn more about each book.
+
+<a href="awc.html"><img src="awc.png" height="300px" alt="Apache Wicket Cookbook cover" title="Apache Wicket Cookbook" /></a>
+<a href="wia.html"><img src="wia.png" height="300px" alt="Wicket in Action cover" title="Wicket in Action" /></a>
+<a href="koda.html"><img src="koda.jpg" height="300px" alt=" Komponentenbasiert und objektorientiert - das alternative Java-Webframework cover" title=" Komponentenbasiert und objektorientiert- das alternative Java-Webframework" /></a>
+<a href="ewdww.html"><img src="ewdww.png" height="300px" alt="Enjoying Web Development with Wicket cover" title="Enjoying Web Development with Wicket" /></a>
+<a href="prowicket.html"><img src="prowicket.png" height="300px" alt="Pro Wicket cover" title="Pro Wicket" /></a>
+<a href="paxisbuchwicket.html"><img src="praxisbuchwicket.png" height="300px" alt="Praxisbuch Wicket cover" title="Praxisbuch Wicket" /></a>
+<a href="kwij.html"><img src="kwij.png" height="300px" alt="Wicket: Komponentenbasierte Webanwendungen in Java cover" title="Wicket: Komponentenbasierte Webanwendungen in Java" /></a>
+<a href="wicket-jp.html"><img src="wicket-jp.png" height="300px" alt="Wicket Japanese cover" title="Wicket Japanese" /></a>
+
http://git-wip-us.apache.org/repos/asf/wicket-site/blob/8cc72bad/learn/books/koda.jpg
----------------------------------------------------------------------
diff --git a/learn/books/koda.jpg b/learn/books/koda.jpg
new file mode 100644
index 0000000..d75d330
Binary files /dev/null and b/learn/books/koda.jpg differ
http://git-wip-us.apache.org/repos/asf/wicket-site/blob/8cc72bad/learn/books/koda.md
----------------------------------------------------------------------
diff --git a/learn/books/koda.md b/learn/books/koda.md
new file mode 100644
index 0000000..f4a855e
--- /dev/null
+++ b/learn/books/koda.md
@@ -0,0 +1,49 @@
+---
+layout: default
+title: Books — Komponentenbasiert und objektorientiert - das alternative Java-Webframework
+lang: de
+---
+
+## Description ##
+
+Apache Wicket ist ein komponentbasiertes Webframework, das sich in den
+letzten Jahren zu einem der beliebtesten Vertreter seiner Gattung
+gemausert hat. Man könnte diese Beliebtheit mit der einfachen
+Integration von Ajax oder der rigorosen Trennung von Markup und Logik
+erklären. Aber was Wicket wirklich über die Masse konkurrierender
+Frameworks erhebt, sind der Verzicht auf eine eigene Markup-Sprache
+und das objektorientierte Programmiermodell. Dadurch rücken Java und
+seine Sprachmittel stark in den Vordergrund. Das ermöglicht es
+erfahrenen Entwicklern, sehr schnell in die Kernkonzepte von Wicket
+einzusteigen und auch komplexeste Anwendungen umzusetzen.
+
+Ziel dieses Buchs ist es, die grundlegenden Konzepte von Wicket zu
+vermitteln und im weiteren Verlauf auf fortgeschrittene Aspekte
+einzugehen. Hierzu wird eine Beispielanwendung entwickelt und Schritt
+für Schritt erweitert. Anhand detaillierte Codebeispiele werden
+Sachverhalte wie der Wicket Request Cycle, Models, Validierung und
+JUnit Testing erklärt. Des Weiteren werden Themen wie
+Deplyoment-Szenarien (JEE6, Spring, ...) , jQuery-Integration und
+Performance-Tuning in separaten Kapiteln behandelt. Durch Studium
+dieses Buchs soll ein Entwickler befähigt werden, skalierbare,
+wartbare Webanwendungen in Wicket zu bauen, und er soll lernen,
+eigene, wiederverwendbare Komponenten zu entwickeln und fremde
+Komponenten zu erweitern.
+Zielgruppe
+Entwickler mit soliden Java-Kenntnissen und einem Grundverständnis der
+wichtigen Webtechnologien wie HTML und CSS
+
+## About the author ##
+
+Jochen Mader hat über zehn Jahre Erfahrung im Bereich Architektur und
+Entwicklung. Derzeit ist er bei der Senacor Technologies AG für
+verschiedene Wicket-Projekte als Technical Lead verantwortlich.
+
+## Book details ##
+
+Titel Wicket: Komponentenbasiert und objektorientiert- das alternative Java-Webframework
+Autor Jochen Mader
+Verlag Software + Support, 2012
+ISBN 3868020810, 9783868020816
+Länge 219 Seiten
+
http://git-wip-us.apache.org/repos/asf/wicket-site/blob/8cc72bad/learn/books/kwij.md
----------------------------------------------------------------------
diff --git a/learn/books/kwij.md b/learn/books/kwij.md
new file mode 100644
index 0000000..918c91f
--- /dev/null
+++ b/learn/books/kwij.md
@@ -0,0 +1,71 @@
+---
+layout: default
+title: Books — Wicket - Komponentenbasierte Webanwendungen in Java
+lang: de
+---
+
+The book was written by Roland Förther, Carl-Eric Menzel and Olaf Siefart. It
+was published by dpunkt.verlag in December 2009.
+
+## Description ##
+
+Wicket ist ein neuer Typ Webframework für die Java-Welt: Java als Sprache
+rückt hier wieder in den Mittelpunkt und an die Stelle von deklarativer,
+XML-lastiger Programmierung tritt natürliche objektorientierte Entwicklung.
+Typische Probleme wie Codeduplizierung, aufwendige Ajax-Integration und
+kompliziertes Testen werden durch leicht zu erstellende und wiederverwendbare
+Komponenten radikal vereinfacht. Dieses Buch bietet Java-Entwicklern eine
+praxisorientierte Einführung in Wicket und zeigt, wie die Entwicklung von
+Webanwendungen in Java beschleunigt werden kann und wieder Spaß macht. Dazu
+werden die zugrunde liegenden Konzepte umfassend erklärt und anhand einer
+konkreten Beispielanwendung veranschaulicht, die im Laufe der Kapitel Schritt
+für Schritt entwickelt wird. Nach der Lektüre des Buches sind Sie in der Lage,
+professionelle Webanwendungen mit Wicket zu schreiben, Komponenten für die
+eigenen Bedürfnisse anzupassen oder sie in neue Komponenten zusammenzufassen.
+Sie erfahren zudem, wie Webanwendungen unter Einsatz von Wicket
+architektonisch sauber aufgebaut werden können. Umsteiger von anderen
+Webframeworks wie JSF und Struts lernen die wichtigsten Unterschiede zu Wicket
+kennen und werden in die Lage versetzt, bestehende Java-Webanwendungen
+schrittweise nach Wicket zu migrieren.
+
+Aus dem Inhalt:
+
+* Aufbau einer Wicket-Anwendung
+* Wicket-Komponenten (von Basiskomponenten bis zu selbst definierten Komponenten)
+* Anbindung von Anwendungslogik
+* Wicket und Ajax
+* Testen von Wicket-Anwendungen
+* Weiterführende Themen wie Lokalisierung, Versionierung, Migration
+
+Zielgruppe:
+
+Webentwickler Java-Entwickler Softwarearchitekten
+
+## About the author ##
+
+Roland Förther ist Chief Developer bei der Senacor Technologies AG in
+Nürnberg. Seine Arbeitsschwerpunkte sind u.a. Client-Anwendungen in C unter
+Unix/X11 sowie in Java/Swing, Webanwendungen in Java/Struts und Ruby on Rails.
+Er studierte Informatik an der Friedrich-Alexander-Universität in Erlangen.
+
+Carl-Eric Menzel arbeitet als Senior Developer bei der Senacor Technologies
+AG. Er beschäftigt sich dort mit den Themen Middleware-Entwicklung im
+Java-Enterprise-Bereich, Java-Webanwendungen sowie Usability. Er studierte
+Informatik an der FH Furtwangen.
+
+Olaf Siefart ist Chief Developer bei der Senacor Technologies AG, wo er mit
+J2EE-Applikationen und Client-Architekturen (Webanwendungen) arbeitet. Er
+absolvierte sein Studium der Informatik an der Universität Marburg.
+
+## Book details ##
+
+Title Wicket: Komponentenbasierte Webanwendungen in Java
+Author Roland Förther, Carl-Eric Menzel and Olaf Siefart
+Version covered Wicket 1.4
+URL Wicket: Komponentenbasierte Webanwendungen in Java
+Hardcover 350 pages
+Publisher dpunkt
+Date December, 2009
+Language German
+ISBN-13 978-3-89864-569-0
+Buy dpunkt Amazon
http://git-wip-us.apache.org/repos/asf/wicket-site/blob/8cc72bad/learn/books/kwij.png
----------------------------------------------------------------------
diff --git a/learn/books/kwij.png b/learn/books/kwij.png
new file mode 100644
index 0000000..32df342
Binary files /dev/null and b/learn/books/kwij.png differ
http://git-wip-us.apache.org/repos/asf/wicket-site/blob/8cc72bad/learn/books/praxisbuchwicket.md
----------------------------------------------------------------------
diff --git a/learn/books/praxisbuchwicket.md b/learn/books/praxisbuchwicket.md
new file mode 100644
index 0000000..0f31975
--- /dev/null
+++ b/learn/books/praxisbuchwicket.md
@@ -0,0 +1,59 @@
+---
+layout: default
+title: Books — Praxisbuch Wicket
+lang: de
+---
+
+Praxisbuch Wicket, written by by Michael Mosmann. It was published by Hanser
+Fachbuch in September 2009.
+
+## Description ##
+
+DER SCHNELLE WEG ZU WEB 2.0
+
+Erfahren Sie, welch mächtige Unterstützung Wicket Java-Programmierern bei der
+Entwicklung von Web-2.0-Anwendungen bietet Folgen Sie Schritt für Schritt den
+praxisnahen Beispielen und erleben Sie, wie eine Anwendung mit Wicket
+entsteht. Nutzen Sie die praxiserprobten Lösungen dafür, die Entwicklung Ihrer
+Anwendungen zu vereinfachen und zu beschleunigen. Im Internet: Laufend
+aktuelle Informationen zu Wicket finden Sie auf der Website zu diesem Buch
+www.wicket-praxis.de Wicket ist ein mächtiges Framework für die Entwicklung
+von Web-2.0-Anwendungen, die auf Java basieren. Es bietet eine einfache
+Integration von AJAX, ohne dass Sie sich mit XML oder JavaScript
+auseinandersetzen müssen, und erleichtert Ihnen die Wiederverwendung, weil es
+konsequent komponentenorientiert arbeitet.
+
+In diesem Buch erfahren Sie, wie Wicket Sie bei der Entwicklung von
+Web-2.0-Anwendungen unterstützt und welche Vorteile es bietet. Der Autor
+entwickelt gemeinsam mit Ihnen eine komplette Anwendung, erklärt unterwegs die
+wesentlichen Konzepte von Wicket und zeigt elegante, praxiserprobte Lösungen
+u.a. für Aufgabenstellungen wie suchmaschinenoptimierte Seiten oder
+Applikationen mit Desktop-Charakter.
+
+Das umfangreiche Kapitel "Wicket in der Praxis" bietet Ihnen eine Reihe von
+effektiven Lösungsvorschlägen für typische Aufgabenstellungen.
+
+Aus dem Inhalt: Die Grundstruktur aufsetzen und mit Leben füllen - Die
+Wicket-Architektur - Modelle - Komponenten - Basiskomponenten - Listen und
+Tabellen - Formulare - Sessions und Security - Wicket in der Praxis -
+Fehlersuche
+
+## About the author ##
+
+Michael Mosmann has more than 10 years of Java experience, especially with web
+based b2c application.
+
+## Book details ##
+
+Title Praxisbuch Wicket: Professionelle Web-2.0-Anwendungen entwickeln
+Author Michael Mosmann
+Version covered Wicket 1.4
+URL Praxisbuch Wicket
+Hardcover 312 pages
+Publisher Hanser
+Date September 1, 2009
+Language German
+ISBN-10 3446419098
+ISBN-13 978-3446419094
+Buy Amazon Hanser
+
http://git-wip-us.apache.org/repos/asf/wicket-site/blob/8cc72bad/learn/books/praxisbuchwicket.png
----------------------------------------------------------------------
diff --git a/learn/books/praxisbuchwicket.png b/learn/books/praxisbuchwicket.png
new file mode 100644
index 0000000..149b641
Binary files /dev/null and b/learn/books/praxisbuchwicket.png differ
http://git-wip-us.apache.org/repos/asf/wicket-site/blob/8cc72bad/learn/books/prowicket.md
----------------------------------------------------------------------
diff --git a/learn/books/prowicket.md b/learn/books/prowicket.md
new file mode 100644
index 0000000..26854a9
--- /dev/null
+++ b/learn/books/prowicket.md
@@ -0,0 +1,56 @@
+---
+layout: default
+title: Books — Pro Wicket
+---
+
+Pro Wicket, written by by Karthik Gurumurthy, is the first book about Wicket,
+and covers Wicket 1.2. It was published by Apress in September 2006.
+
+## Description ##
+
+Wicket is an open source, component-oriented (POJOs-based), lightweight Java
+web application development framework that brings the Java Swing event-based
+programming model to web development. Wicket pages can be mocked up,
+previewed, and later revised using standard WYSIWYG HTML design tools.
+
+Wicket provides stateful components, thereby improving productivity. It has an
+architecture and rich component suite that aims to bring back the object
+orientation and, more importantly, the fun that is missing from the Java web
+development space. With the impending 1.2 release, Wicket is set for wider
+adoption.
+
+Pro Wicket gets you up and running quickly with this framework. You'll learn
+how to configure Wicket, then gradually gain exposure to the "Wicket way" of
+addressing web development requirements. You'll want to pick up a copy because
+it
+
+Is the first book to cover the Wicket framework with Spring integration and
+Ajax features Demonstrates all major wicket capabilities through simple
+examples Covers important aspects like Wicket-Spring integration and Ajax
+support
+
+## About the author ##
+
+Karthik Gurumurthy has been associated with the IT industry for more than six
+years now and has employed open source libraries to solve business problems.
+Karthik also has the experience of having documented a popular open source
+project: XDoclet2. He has been having a great time with Wicket since day one
+of adoption and would like to let others know how Wicket succeeds in bringing
+back the fun that has been missing in the Java web development space. He also
+contributed to the Wicket project through the Wicket-Spring integration module
+using Jakarta Commons Attributes.
+
+## Book details ##
+
+Title Pro Wicket
+Author Karthik Gurumurthy
+Version covered Wicket 1.2
+URL Pro Wicket
+Hardcover 328 pages
+Publisher Apress
+Date September 7, 2006
+Language English
+ISBN-10 1590597222
+ISBN-13 978-1590597224
+Buy Amazon Apress
+
http://git-wip-us.apache.org/repos/asf/wicket-site/blob/8cc72bad/learn/books/prowicket.png
----------------------------------------------------------------------
diff --git a/learn/books/prowicket.png b/learn/books/prowicket.png
new file mode 100644
index 0000000..e9eb729
Binary files /dev/null and b/learn/books/prowicket.png differ
http://git-wip-us.apache.org/repos/asf/wicket-site/blob/8cc72bad/learn/books/wia.md
----------------------------------------------------------------------
diff --git a/learn/books/wia.md b/learn/books/wia.md
new file mode 100644
index 0000000..d140e70
--- /dev/null
+++ b/learn/books/wia.md
@@ -0,0 +1,43 @@
+---
+layout: default
+title: Wicket in Action
+---
+
+Wicket in Action is written by Martijn Dashorst and Eelco Hillenius and is
+published by Manning. The book is currently in the final stages of production
+and will soon be available as a hard copy. Early access to the manuscript is
+available from the publishers site.
+
+### Description ###
+
+There are dozens of Java frameworks out there, but most of them require you to
+learn special coding techniques and new, often rigid, patterns of development.
+Wicket is different. As a component-based Web application framework, Wicket
+lets you build maintainable enterprise-grade web applications using the power
+of plain old Java objects (POJOs), HTML, Ajax, Spring, Hibernate and Maven.
+Wicket automatically manages state at the component level, which means no more
+awkward HTTPSession objects. Its elegant programming model enables you to
+write rich web applications quickly.
+
+Wicket in Action is the authoritative, comprehensive guide for Java developers
+building Wicket-based Web applications. This book starts with an introduction
+to Wicket's structure and components, and moves quickly into examples of
+Wicket at work. Written by two of the project's earliest and most
+authoritative experts, this book shows you both the "how-to" and the "why" of
+Wicket. As you move through the book, you'll learn to use and customize Wicket
+components, how to interact with other technologies like Spring and Hibernate,
+and how to build rich, Ajax-driven features into your applications.
+
+### Authors ###
+
+Martijn Dashorst is a software engineer with over 10 years of experience in
+software development. He has been actively involved in the Wicket project
+since it was open sourced, and has presented Wicket as a speaker at numerous
+conferences, including JavaOne and JavaPolis.
+
+Eelco Hillenius is an experienced software developer who has been part of
+Wicket's core team almost from the start. He works for Teachscape where he
+helping to build the next elearning platform. A Dutch native, he currently
+lives in Seattle.
+
+### Book details ###
http://git-wip-us.apache.org/repos/asf/wicket-site/blob/8cc72bad/learn/books/wia.png
----------------------------------------------------------------------
diff --git a/learn/books/wia.png b/learn/books/wia.png
new file mode 100644
index 0000000..65e206c
Binary files /dev/null and b/learn/books/wia.png differ
http://git-wip-us.apache.org/repos/asf/wicket-site/blob/8cc72bad/learn/books/wicket-jp.md
----------------------------------------------------------------------
diff --git a/learn/books/wicket-jp.md b/learn/books/wicket-jp.md
new file mode 100644
index 0000000..d80cdc4
--- /dev/null
+++ b/learn/books/wicket-jp.md
@@ -0,0 +1,31 @@
+---
+layout: default
+title: Thorough use of open source Web application development Wicket
+---
+
+** NB. This page has been automatically translated as the Wicket developers
+are unable to speak or read Japanese. Better translations are welcome!
+
+This is the only book in Japanese covering Apache Wicket. It discusses Wicket
+1.4.
+
+## Description ##
+
+After all just Java and HTML. To complex applications using Ajax, XML created
+without light. Recover the object-oriented server-side. Apache Wicket 1.4-RC2
+support.
+
+## About the author ##
+
+Yano Tsutomu Born in Osaka in 1973. He joined the system development company,
+is currently working as a freelance programmer and retired. In 2008 Wicket
+User Group "Wicket-ja" up and, to the present (this data is published at the
+time was that this book was published.)
+
+## Book details ##
+
+Paperback: 431 pages
+Publisher: Hidekazu system (2009/03)
+ISBN-10: 4798022217
+ISBN-13: 978-4798022215
+Release Date: 2009/03
http://git-wip-us.apache.org/repos/asf/wicket-site/blob/8cc72bad/learn/books/wicket-jp.png
----------------------------------------------------------------------
diff --git a/learn/books/wicket-jp.png b/learn/books/wicket-jp.png
new file mode 100644
index 0000000..9c7cc9f
Binary files /dev/null and b/learn/books/wicket-jp.png differ
http://git-wip-us.apache.org/repos/asf/wicket-site/blob/8cc72bad/learn/examples/ajaxcounter.md
----------------------------------------------------------------------
diff --git a/learn/examples/ajaxcounter.md b/learn/examples/ajaxcounter.md
new file mode 100644
index 0000000..503fb6d
--- /dev/null
+++ b/learn/examples/ajaxcounter.md
@@ -0,0 +1,176 @@
+---
+layout: default
+title: Ajax Counter
+---
+
+This example shows you how to use Wicket's Ajax behaviors and components by
+building a simple counter that updates through Ajax link clicks.
+
+In all the Wicket examples, you have to put all files in the same package
+directory. This means putting the markup files and the java files next to one
+another. It is possible to alter this behavior, but that is beyond the scope
+of this example. The only exception is the obligatory `web.xml` file which
+should reside in the `WEB-INF/` directory of your web application root
+folder.
+
+In this example we assume you already have read and understood the other
+examples which give you information on the structure and nature of Wicket
+applications. Specifically read and understand the [Hello, World
+example](helloworld.html).
+
+## Counter page
+
+First we'll create a page that just counts the number of times a link has been clicked. In the following markup you'll see a link and a label.
+
+{% highlight html %}
+<html>
+<head></head>
+<body>
+ <a href="#" wicket:id="link">click me</a>
+ <p>
+ Counter: <span wicket:id="counter">nr of times</span>
+ </p>
+</body>
+</html>
+{% endhighlight %}
+
+The link component will refresh the page and the label will replace the text
+'nr of times' with the count. Take a look at the following Java file to see
+how it works on the Java side:
+
+{% highlight java %}
+package wicket.quickstart;
+
+import wicket.Component;
+import wicket.markup.html.basic.Label;
+import wicket.markup.html.link.Link;
+import wicket.model.Model;
+
+public class Index extends QuickStartPage {
+ public Index() {
+ Model<Integer> model = new Model<Integer>() {
+ private int counter = 0;
+
+ public Integer getObject() {
+ return counter++;
+ }
+ };
+ add(new Link("link") {
+ public void onClick() {
+ // do nothing.
+ }
+ });
+ add(new Label<Integer>("counter", model));
+ }
+}
+{% endhighlight %}
+
+In this class we created a `Model` subclass that increases its counter
+everytime the `getObject` method gets called, and returns its value. We set
+this model on the label component, so that each time the label gets rendered
+the counter gets increased.
+
+The link doesn't do anything, just listen to the requests and update the
+page. If you run this code in your application (download the Quickstart
+project and copy/paste the code in the homepage for a quick experience).
+
+The page gets fully refreshed with each link click. That is not very web 2.0,
+so let's make it more modern by adding some Ajax stuff.
+
+## Adding Ajax
+
+To make this a more modern UI we'll have to change a couple of things. First
+we need to make the link an Ajax link. Wicket provides several types of Ajax
+links, but the best one for our purposes is the `AjaxFallbackLink`, as it
+provides a fallback to a normal request in case no Ajax is available.
+
+{% highlight java %}
+package wicket.quickstart;
+
+import wicket.Component;
+import wicket.ajax.AjaxRequestTarget;
+import wicket.ajax.markup.html.AjaxFallbackLink;
+import wicket.markup.html.basic.Label;
+import wicket.model.Model;
+
+public class Index extends QuickStartPage {
+ public Index() {
+ Model<Integer> model = new Model<Integer>() {
+ private int counter = 0;
+
+ public Integer getObject() {
+ return counter++;
+ }
+ };
+ add(new AjaxFallbackLink("link") {
+ public void onClick(AjaxRequestTarget target) {
+ // add the components that need to be updated to
+ // the target
+ }
+ });
+ add(new Label<Integer>("counter", model));
+ }
+}
+{% endhighlight %}
+
+As you can see, the `Link` has been replaced with the `AjaxFallbackLink`, and the
+`onClick` method now takes a new argument: the `AjaxRequestTarget`. If you want a
+component to be updated in the Ajax request, you'll have to add them to the
+target. So let's alter the file to make it possible to add the label to the
+request target.
+
+{% highlight java %}
+package wicket.quickstart;
+
+import wicket.Component;
+import wicket.ajax.AjaxRequestTarget;
+import wicket.ajax.markup.html.AjaxFallbackLink;
+import wicket.markup.html.basic.Label;
+import wicket.model.Model;
+
+public class Index extends QuickStartPage {
+ public Index() {
+ Model<Integer> model = new Model<Integer>() {
+ private int counter = 0;
+
+ public Integer getObject() {
+ return counter++;
+ }
+ };
+ final Label<Integer> label = new Label<Integer>("counter", model);
+ label.setOutputMarkupId(true);
+ add(new AjaxFallbackLink("link") {
+ public void onClick(AjaxRequestTarget target) {
+ if (target != null) {
+ // target is only available in an Ajax request
+ target.addComponent(label);
+ }
+ }
+ });
+ add(label);
+ }
+}
+{% endhighlight %}
+
+We've moved the instantiation of the label to the beginning of the page
+constructor and made a local, final variable. This way we can reference the
+label in the event handler of the link component.
+
+We also had to call `setOutputMarkupId(true)` on the label to be able to
+update the component when the request is returned to the client browser. If
+we don't, Wicket will not know how to update the markup in the client.
+
+If you put this code into your page's class, then you'll have a working Ajax
+updating counter.
+
+## Summary
+
+Working with Ajax and Wicket using the standard Wicket libraries doesn't
+require a degree in JavaScript. Even better, you don't necessarily need to
+update your markup file to work with Ajax. In this (simple) example we were
+able to add Ajax behavior to the page without touching the markup file.
+
+The most important lesson here is that in order to update components using
+Ajax is that you need to add those components to the `AjaxRequestTarget` and
+that the components that are to be updated in that request, should have
+`setOutputMarkupId(true)`.
http://git-wip-us.apache.org/repos/asf/wicket-site/blob/8cc72bad/learn/examples/dropdownchoice.md
----------------------------------------------------------------------
diff --git a/learn/examples/dropdownchoice.md b/learn/examples/dropdownchoice.md
new file mode 100644
index 0000000..7ec969a
--- /dev/null
+++ b/learn/examples/dropdownchoice.md
@@ -0,0 +1,178 @@
+---
+layout: default
+title: Using the DropDownChoice component
+---
+
+One of the most problematic components for beginners of Wicket is the
+`DropDownChoice` component. In this example we will work the component to
+give a little more insight into its workings. This example requires that you
+have some understanding of the Wicket component model (nothing fancy though,
+but you might want to read the other examples first), and the Model concept
+used in Wicket (you can read more on models
+[here](https://cwiki.apache.org/confluence/display/WICKET/Working+with+Wicket+models)).
+
+## The example domain
+
+The `DropDownChoice` component is typically used _inside_ a form. This
+example will expand on that usage. The component is particularly designed to
+work with objects. So let's say we have a list of people and we want to
+select the manager of an employee.
+
+{% highlight java %}
+public class Person {
+ private Long id;
+ private String name;
+ private Person managedBy;
+
+ // ... insert getters and setters
+
+ /**
+ * Used to display the person.
+ */
+ public String toString() {
+ return name;
+ }
+
+ /**
+ * Gets the list of possible managers from the database.
+ */
+ public static List<Person> getManagers() {
+ // gets the managers from the database
+ }
+}
+{% endhighlight %}
+
+## The assign manager page
+
+Next we want to create a page where we assign a manager to an employee. This
+is how the page would look like in HTML:
+
+{% highlight html %}
+<html>
+<body>
+<form wicket:id="form">
+<h1>Assign manager</h1>
+<table>
+<tr>
+ <th>Name</th>
+ <td wicket:id="name">Some employee</td>
+</tr>
+<tr>
+ <th>Managed by</th>
+ <td><select wicket:id="managedBy">
+ <option>Some Person</option>
+ <option>Some Other Person</option>
+ </select>
+ </td>
+</tr>
+<tr><td colspan="2"><input type="submit" value="Save"/></td></tr>
+</table>
+</form>
+</body>
+</html>
+{% endhighlight %}
+
+This page has three components:
+
+* a form (needed to process the input),
+* a label (to show the name of the employee) and
+* a select box for picking the manager.
+
+We will focus on the select box, because that will be our `DropDownChoice`.
+The `<option>` tags are there for preview, our component will replace them
+with the generated choices.
+
+Let's see how the page looks like from the Java side:
+
+{% highlight java %}
+public class AssignManagerPage extends WebPage {
+ public AssignManagerPage(Person employee) {
+ Form form = new Form("form");
+ add(form);
+ form.add(new Label("name", new PropertyModel<String>(employee, "name")));
+
+ DropDownChoice<Person> ddc =
+ new DropDownChoice<Person>("name",
+ new PropertyModel<Person>(employee, "managedBy"),
+ new LoadableDetachableModel<List<Person>>() {
+ @Override
+ protected Object load() {
+ return Person.getManagers();
+ }
+ }
+ );
+ form.add(ddc));
+ }
+}
+{% endhighlight %}
+
+In this example you see that we add the `DropDownChoice` to the form, and
+provide it with 3 parameters. The first is the component identifier. The
+second is the item that needs to be updated, in this case the `managedBy`
+field of the `employee`. The third parameter is a `LoadableDetachableModel`
+that retrieves the list of available choices.
+
+Note that the `DropDownChoice` component has many constructors, and that you
+need to read the JavaDoc documentation to pick the right one for you.
+
+This generates (basically) the following markup when the list of managers is
+Kyle Brovlovski, Stan Marsh, Eric Cartman, and Kenny McCormick:
+
+{% highlight html %}
+<tr>
+ <th>Managed by</th>
+ <td>
+ <select wicket:id="managedBy" name="managedBy">
+ <option selected="selected" value="">Choose one</option>
+ <option value="0">Kyle Brovlovski</option>
+ <option value="1">Stan Marsh</option>
+ <option value="2">Eric Cartman</option>
+ <option value="3">Kenny McCormick</option>
+ </select>
+ </td>
+</tr>
+{% endhighlight %}
+
+As you can see from this markup is that Wicket added the items of the
+managers list and numbered the values of the options. These are the indices
+of the items in the list. If the order of the list can change between
+requests, _or_ if the list itself can change, then please use an
+`IChoiceRenderer`.
+
+## Selecting a choice
+
+Now if a user selects a value and submits the form, Wicket will assign the
+manager to the employee (the `PropertyModel` takes care of that). The
+following list shows what basically happens:
+
+1. create new Employee, with `null` for its manager
+2. create AssignManagerPage with the employee
+3. render page, selected value is `"Choose one"`
+4. user selects "Eric Cartman" and submits form
+5. Wicket assigns manager "Eric Cartman" to `managedBy` field of the employee
+
+So there is no need for getting or setting the value from the drop down
+component: Wicket binds directly to your domain objects if you use the
+correct models.
+
+## Selecting a default choice
+
+If you want to select a default value for the manager, then all you need to
+do is assign the default manager to the employee and Wicket will take care of
+the rest:
+
+{% highlight java %}
+// some add new employee code
+Employee manager = Employee.get("Eric Cartman"); // gets a manager
+Employee newEmployee = new Employee();
+newEmployee.setManagedBy(manager);
+
+setResponsePage(new AssignManagerPage(newEmployee));
+{% endhighlight %}
+
+## Summary
+
+This concludes the (small) example of using a `DropDownChoice` component
+correctly. The ideas behind Wicket are perfectly reflected in this component:
+work with your domain objects, bind them to your components and get on with
+the rest of your application.
http://git-wip-us.apache.org/repos/asf/wicket-site/blob/8cc72bad/learn/examples/guestbook.md
----------------------------------------------------------------------
diff --git a/learn/examples/guestbook.md b/learn/examples/guestbook.md
new file mode 100644
index 0000000..e975ab1
--- /dev/null
+++ b/learn/examples/guestbook.md
@@ -0,0 +1,273 @@
+---
+layout: default
+title: Guestbook
+---
+
+The GuestBook application allows users to enter comments that appear on a
+page like a weblog. Drawing the list of comments is very easy with the Wicket
+`ListView` component. This example also gives an impression of what form
+handling is like.
+
+
+
+As with all examples, you have to put all files in the same package
+directory. This means putting the markup files and the java files next to one
+another. It is possible to alter this behavior, but that is beyond the scope
+of this example.
+
+## Comment.java ##
+
+The Comment POJO model is very straightforward:
+
+{% highlight java %}
+package org.apache.wicket.examples.guestbook;
+
+import java.util.Date;
+import org.apache.wicket.IClusterable;
+
+public class Comment implements IClusterable {
+ private String text;
+ private Date date = new Date();
+
+ public Comment() {
+ }
+
+ public Comment(final Comment comment) {
+ this.text = comment.text;
+ this.date = comment.date;
+ }
+
+ public String getText() {
+ return text;
+ }
+
+ public void setText(String text) {
+ this.text = text;
+ }
+
+ public Date getDate() {
+ return date;
+ }
+
+ public void setDate(Date date) {
+ this.date = date;
+ }
+
+ public String toString() {
+ return "[Comment date = " + date + ", text = " + text + "]";
+ }
+}
+{% endhighlight %}
+
+
+## GuestBook.java ##
+
+In the file `GuestBook.java` we have put the Java component code for the
+guestbook page. This is the homepage for the guestbook application. The page
+consists of a form for entering new items to the guestbook and a list of
+repeating markup for showing the guestbook entries.
+
+The `GuestBook` constructor adds a `CommentForm` and a `ListView` of
+the comments. Notice how the model is passed in as the second argument to the
+`ListView` constructor.
+
+Then as the view renders, the `populateItem` method is called passing in a
+`ListItem` container for the current row in the list.
+
+The implementation below obtains the `Comment` POJO from the list item and
+adds label components for the date and text of the `Comment`. This is all
+accomplished in just a few lines of code.
+
+{% highlight java %}
+package org.apache.wicket.examples.guestbook;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Date;
+import java.util.List;
+
+import org.apache.commons.lang.StringUtils;
+import org.apache.wicket.examples.WicketExamplePage;
+import org.apache.wicket.markup.html.basic.Label;
+import org.apache.wicket.markup.html.basic.MultiLineLabel;
+import org.apache.wicket.markup.html.form.Form;
+import org.apache.wicket.markup.html.form.TextArea;
+import org.apache.wicket.markup.html.form.TextField;
+import org.apache.wicket.markup.html.list.ListItem;
+import org.apache.wicket.markup.html.list.PropertyListView;
+import org.apache.wicket.model.CompoundPropertyModel;
+import org.apache.wicket.util.value.ValueMap;
+
+
+public final class GuestBook extends WicketExamplePage {
+ /** A global list of all comments from all users across all sessions */
+ private static final List<Comment> commentList = Collections.synchronizedList(new ArrayList<Comment>());
+
+ /**
+ * Constructor that is invoked when page is invoked without a session.
+ */
+ public GuestBook() {
+ // Add comment form
+ add(new CommentForm("commentForm"));
+
+ // Add commentListView of existing comments
+ add(new PropertyListView<Comment>("comments", commentList) {
+ @Override
+ public void populateItem(final ListItem<Comment> listItem) {
+ listItem.add(new Label("date"));
+ listItem.add(new MultiLineLabel("text"));
+ }
+ }).setVersioned(false);
+ }
+
+ /**
+ * A form that allows a user to add a comment.
+ */
+ public final class CommentForm extends Form<ValueMap> {
+ public CommentForm(final String id) {
+ // Construct form with no validation listener
+ super(id, new CompoundPropertyModel<ValueMap>(new ValueMap()));
+
+ // this is just to make the unit test happy
+ setMarkupId("commentForm");
+
+ // Add text entry widget
+ add(new TextArea<String>("text").setType(String.class));
+
+ // Add simple automated spam prevention measure.
+ add(new TextField<String>("comment").setType(String.class));
+ }
+
+ /**
+ * Show the resulting valid edit
+ */
+ @Override
+ public final void onSubmit() {
+ ValueMap values = getModelObject();
+
+ // check if the honey pot is filled
+ if (StringUtils.isNotBlank((String)values.get("comment"))) {
+ error("Caught a spammer!!!");
+ return;
+ }
+ // Construct a copy of the edited comment
+ Comment comment = new Comment();
+
+ // Set date of comment to add
+ comment.setDate(new Date());
+ comment.setText((String)values.get("text"));
+ commentList.add(0, comment);
+
+ // Clear out the text component
+ values.put("text", "");
+ }
+ }
+
+ /**
+ * Clears the comments.
+ */
+ public static void clear() {
+ commentList.clear();
+ }
+}
+{% endhighlight %}
+
+When the `CommentForm` is submitted, the `onSubmit()` method is called.
+Notice that nothing gets the value of the `TextArea` that was added in the
+`CommentForm` constructor. This is because the comment is the model and the
+third parameter to the `TextArea` constructor specified the property of the
+model to update. So all `onSubmit()` has to do is create a new comment from
+the model that was updated and add it to the comment list. When the page
+redraws, the new list will be rendered.
+
+We use a synchronized list as our shared static model used by `commentListView`
+(`commentList`) to ensure that it is only updated by one thread at a time.
+Remember, this is a multi-user application with a shared model!
+
+Finally, you may notice the call to `commentListView.modelChanged()`. This
+informs the list view that its model has been modified. In more advanced
+usage scenarios, this would allow Wicket to expire stale pages accessed with
+the browser's back button.
+
+## GuestBook.html ##
+
+In the HTML below, notice the way that the `TextArea` component is being
+nested inside the `CommentForm`. Wicket is able to keep everything straight
+because the Java `Component.add()` calls have to result in the same nesting
+structure as the HTML.
+
+Finally, notice the `<wicket:remove>` block. This is simply markup that is
+there for previewing purposes only. When the page renders, it is stripped
+out.
+
+{% highlight html %}
+<html xmlns:wicket="http://wicket.apache.org/">
+<head>
+ <title>Wicket Examples - guestbook</title>
+ <link rel="stylesheet" type="text/css" href="style.css"/>
+</head>
+<body>
+ <span wicket:id="mainNavigation"/>
+
+ <form wicket:id="commentForm">
+ Add your comment here:
+ <p>
+ <textarea wicket:id="text">This is a comment</textarea>
+ <input type="text" wicket:id="comment" class="nospam" onfocus="getElementById('formsubmit').focus();"/>
+ <p>
+ <input type="submit" value="Submit" id="formsubmit"/>
+ </form>
+ <p/>
+ <span wicket:id="comments">
+ <p>
+ <span wicket:id="date">1/1/2004</span><br>
+ <span wicket:id="text">Comment text goes here.</span>
+ </p>
+ </span>
+ <wicket:remove>
+ <p>
+ 1/2/2004<br/>
+ More comment text here.
+ </p>
+ </wicket:remove>
+</body>
+</html>
+{% endhighlight %}
+
+## GuestBookApplication.java ##
+
+For completeness, we've included the `GuestBookApplication` class, and as a
+final treat the modifications to the `web.xml` file.
+
+{% highlight java %}
+package org.apache.wicket.examples.guestbook;
+
+import org.apache.wicket.Page;
+import org.apache.wicket.examples.WicketExampleApplication;
+
+public class GuestBookApplication extends WicketExampleApplication {
+ public GuestBookApplication() {
+ }
+
+ @Override
+ public Class< ? extends Page> getHomePage() {
+ return GuestBook.class;
+ }
+}
+{% endhighlight %}
+
+## web.xml ##
+
+Add the following two sections (servlet and servlet-mapping) to your web.xml
+file for running this application.
+
+{% highlight xml %}
+<filter>
+ <filter-name>GuestBookApplication</filter-name>
+ <filter-class>org.apache.wicket.protocol.http.WicketFilter</filter-class>
+ <init-param>
+ <param-name>applicationClassName</param-name>
+ <param-value>org.apache.wicket.examples.guestbook.GuestBookApplication</param-value>
+ </init-param>
+</filter>
+{% endhighlight %}
http://git-wip-us.apache.org/repos/asf/wicket-site/blob/8cc72bad/learn/examples/guestbook.png
----------------------------------------------------------------------
diff --git a/learn/examples/guestbook.png b/learn/examples/guestbook.png
new file mode 100644
index 0000000..76669da
Binary files /dev/null and b/learn/examples/guestbook.png differ
http://git-wip-us.apache.org/repos/asf/wicket-site/blob/8cc72bad/learn/examples/helloworld.md
----------------------------------------------------------------------
diff --git a/learn/examples/helloworld.md b/learn/examples/helloworld.md
new file mode 100644
index 0000000..cf387a7
--- /dev/null
+++ b/learn/examples/helloworld.md
@@ -0,0 +1,145 @@
+---
+layout: default
+title: Hello World!
+category: learnmore
+---
+
+HelloWorld demonstrates the basic structure of a web application in Wicket. A
+Label component is used to display a message on the home page for the
+application.
+
+In all the Wicket examples, you have to put all files in the same package
+directory. This means putting the markup files and the java files next to one
+another. It is possible to alter this behavior, but that is beyond the scope
+of this example. The only exception is the obligatory web.xml file which
+should reside in the WEB-INF/ directory of your web application root folder.
+
+If you wish to start building this example, you may want to take a look at the
+Wicket Quickstart project, which provides a quick way of getting up and
+running without having to figure things out yourself. The Quickstart project
+contains the necessary build files (Ant and Maven), libraries, minimal set of
+Java and markup files and an embedded Jetty server to run your application
+without having to go through the whole build-deploy cycle.
+
+### HelloWorldApplication.java ###
+
+Each Wicket application is defined by an Application object. This object
+defines what the home page is, and allows for some configuration.
+
+{% highlight java %}
+import org.apache.wicket.protocol.http.WebApplication;
+
+public class HelloWorldApplication extends WebApplication {
+ public HelloWorldApplication() {
+ }
+
+ /**
+ * @see org.apache.wicket.Application#getHomePage()
+ */
+ @Override
+ public Class getHomePage() {
+ return HelloWorld.class;
+ }
+}
+{% endhighlight %}
+
+Here you can see that we define `wicket.examples.helloworld.HelloWorld` to be
+our home page. When the base URL of our application is requested, the markup
+rendered by the HelloWorld page is returned.
+
+### HelloWorld.java ###
+
+{% highlight java %}
+import org.apache.wicket.markup.html.WebPage;
+import org.apache.wicket.markup.html.basic.Label;
+
+public class HelloWorld extends WebPage {
+ public HelloWorld() {
+ add(new Label("message", "Hello World!"));
+ }
+}
+{% endhighlight %}
+
+The Label is constructed using two parameters:
+
+1. "message"
+
+2. "Hello World!"
+
+The first parameter is the component identifier, which Wicket uses to identify
+the `Label` component in your HTML markup. The second parameter is the message
+which the `Label` should render.
+
+### HelloWorld.html ###
+
+The HTML file that defines our Hello World functionality is as follows:
+
+{% highlight html %}
+<html>
+<body>
+ <span wicket:id="message">Message goes here</span>
+</body>
+</html>
+{% endhighlight %}
+
+In this file, you see two elements that need some attention:
+
+* the component declaration `<span wicket:id="message">`
+
+* the text `Message goes here`
+
+The component declaration consists of the Wicket identifier `wicket:id` and the
+component identifier `message`. The component identifier should be the same as
+the name of the component you defined in your `WebPage`. The text between
+the `<span>` tags is removed when the component renders its message. The final
+content of the component is determined by your Java code.
+
+### web.xml ###
+
+In order to deploy our HelloWorld program, we need to make our application
+known to the application server by means of the web.xml file.
+
+{% highlight xml %}
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE web-app
+ PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
+ "http://java.sun.com/dtd/web-app_2_3.dtd">
+
+<web-app>
+ <display-name>Wicket Examples</display-name>
+ <filter>
+ <filter-name>HelloWorldApplication</filter-name>
+ <filter-class>org.apache.wicket.protocol.http.WicketFilter</filter-class>
+ <init-param>
+ <param-name>applicationClassName</param-name>
+ <param-value>org.apache.wicket.examples.helloworld.HelloWorldApplication</param-value>
+ </init-param>
+ </filter>
+ <filter-mapping>
+ <filter-name>HelloWorldApplication</filter-name>
+ <url-pattern>/*</url-pattern>
+ </filter-mapping>
+</web-app>
+{% endhighlight %}
+
+In this definition you see the Wicket filter defined, which handles all
+requests. In order to let Wicket know which application is available, only the
+applicationClassName filter parameter is needed.
+
+Also, notice the url-mapping to /\*. The Wicket filter will only process
+requests that are Wicket requests. If a request is not Wicket related, the
+filter will pass the request on to the chain. This ensures that (static)
+resources outside the realm of the Wicket application, such as style sheets,
+JavaScript files, images and so forth will be served by the container.
+
+## Ready to deploy ##
+
+That's it. No more configuration necessary! All you need to do now is to
+deploy the web application into your favorite application server. Point your
+browser to the url: `http://<servername>/<warfilename>/`, substituting
+servername and warfilename to the appropriate values, such as
+http://localhost:8080/helloworld/.
+
+As you can see: no superfluous XML configuration files are needed to enable a
+Wicket application. Only the markup (HTML) files, the Java class files and the
+required web.xml were needed to create this application.
http://git-wip-us.apache.org/repos/asf/wicket-site/blob/8cc72bad/learn/examples/index.md
----------------------------------------------------------------------
diff --git a/learn/examples/index.md b/learn/examples/index.md
new file mode 100644
index 0000000..7916ca5
--- /dev/null
+++ b/learn/examples/index.md
@@ -0,0 +1,26 @@
+---
+layout: default
+title: A Quick Tour of Wicket
+---
+Nothing says more about a development technology than a few simple examples.
+After all, how hard should it be to do something easy? The examples below
+should speak for themselves in demonstrating how easy it is to get things done
+in Wicket when compared to other frameworks. You will discover that Wicket's
+component-oriented structure and its "low touch" approach to HTML is quite
+inviting.
+
+You can see these examples and many more in [live
+action](http://www.wicket-library.com/wicket-examples-6.0.x) without having to install anything.
+
+* [Hello World!](helloworld.html) - Everybody's favorite example
+* [Navomatic](navomatic.html) - Automatic navigation using Borders and Links
+* [GuestBook](guestbook.html) - A tiny blogger demonstrating ListViews and
+ Forms
+* [Using DropDownChoice](dropdownchoice.html) - A short example explaining the
+ DropDownChoice component
+* [Markup Inheritance](markupinheritance.html) - A short example explaining
+ markup inheritance
+* [Ajax Counter](ajaxcounter.html) - A short example explaining Wicket's Ajax
+ features building a counter.
+* [Using Fragments](usingfragments.html) - A short example explaining Wicket's
+ fragments feature. Fragments are a type of inline panels.
http://git-wip-us.apache.org/repos/asf/wicket-site/blob/8cc72bad/learn/examples/markupinheritance.md
----------------------------------------------------------------------
diff --git a/learn/examples/markupinheritance.md b/learn/examples/markupinheritance.md
new file mode 100644
index 0000000..79bdffd
--- /dev/null
+++ b/learn/examples/markupinheritance.md
@@ -0,0 +1,235 @@
+---
+layout: default
+title: Creating layouts using markup inheritance
+---
+
+This markup inheritance example show you how to create reusable page layouts
+and panel layouts.
+
+[Watch the Screencast](http://wicket.apache.org/screencasts/ApacheWicket_MarkupInheritence.avi)
+
+In all the Wicket examples, you have to put all files in the same package
+directory. This means putting the markup files and the java files next to one
+another. It is possible to alter this behavior, but that is beyond the scope
+of this example. The only exception is the obligatory `web.xml` file which
+should reside in the `WEB-INF/` directory of your web application root
+folder.
+
+In this example we assume you already have read and understood the other
+examples which give you information on the structure and nature of Wicket
+applications. Specifically read and understand the [Hello, World
+example](helloworld.html).
+
+## Page layout
+
+In the next figure we show a standard strategy for laying out a page. A
+standard header, the main content body and a standard footer.
+
+
+
+In Wicket you can achieve this using different strategies. This article
+focuses on one strategy: markup inheritance.
+
+## What is markup inheritance?
+
+In Java you can extend classes. This same concept has been fitted into the
+markup parsing of Java. Markup containers that have files associated (page
+and panels) can inherit the markup of their super containers.
+
+This is done using two special Wicket tags: `<wicket:child>` and
+`<wicket:extend>`. In the super markup you define where the child markup
+should be put, and in the sub markup you delineate where the child markup
+starts and ends.
+
+{% highlight html %}
+<html>
+ <head></head>
+ <body>
+ This is in the super markup.<br>
+ <wicket:child />
+ This is in the super markup.<br>
+ </body>
+</html>
+{% endhighlight %}
+
+In this markup you see two sentences that surround the `<wicket:child>` tag.
+All markup in this file will remain when a sub class of this page is created,
+only the `<wicket:child>` tag will be replaced with the child markup. So if we
+look at the following markup:
+
+{% highlight html %}
+<html>
+<head></head>
+<body>
+ This is in de child markup.<br>
+ <wicket:extend>
+ This is in the child markup.<br>
+ </wicket:extend>
+ This is in the child markup.<br>
+</body>
+</html>
+{% endhighlight %}
+
+we can see the markup that should be included in the parent. Only the markup
+between the `<wicket:extend>` tags is included in the final page. Take a look
+at the following markup which is the final markup when you would use this in
+a Wicket application.
+
+{% highlight html %}
+<html>
+<head></head>
+<body>
+ This is in the super markup.<br>
+ <wicket:child><wicket:extend>
+ This is in the child markup.<br>
+ </wicket:extend></wicket:child>
+ This is in the super markup.<br>
+</body>
+</html>
+{% endhighlight %}
+
+Here you can see that the `<wicket:child />` tag has been expanded, and its
+contents filled with exactly the markup between the `<wicket:extend>` tags.
+If you want to get rid of the special Wicket tags, you can disable that on
+the markup settings
+([IMarkupSettings](http://wicketframework.org/api/wicket/settings/IMarkupSettings)).
+
+## Implementing the BasePage
+
+Now that we have seen the basics for markup inheritance, we can take a
+look at the example at hand. Let's first create the base page.
+
+{% highlight java %}
+package wicket.quickstart;
+
+import wicket.markup.html.WebPage;
+import wicket.markup.html.basic.Label;
+import wicket.markup.html.link.BookmarkablePageLink;
+
+public abstract class BasePage extends WebPage {
+ public BasePage() {
+ add(new BookmarkablePageLink("page1", Page1.class));
+ add(new BookmarkablePageLink("page2", Page2.class));
+ add(new Label("footer", "This is in the footer"));
+ }
+}
+{% endhighlight %}
+
+The two links should go into the header, and the footer in the footer of the
+page. Note that the abstract keyword isn't required, but considered a good
+practise. Now let's take a look at the markup for the BasePage
+
+{% highlight html %}
+<html>
+<head></head>
+<body>
+<div id="header">
+ <a href="#" wicket:id="page1">Page1</a>
+ <a href="#" wicket:id="page2">Page2</a>
+</div>
+<div id="body">
+<wicket:child />
+</div>
+<div id="footer">
+ <span wicket:id="footer"></span>
+</div>
+</body>
+</html>
+{% endhighlight %}
+
+In this markup file you see the specific basic layout: we have 3 div
+elements:
+
+1. `<div id="header">...</div>`
+2. `<div id="body">...</div>`
+3. `<div id="footer">...</div>`
+
+Note that these aren't Wicket components, just plain markup. We could have
+made them components, such as a `Panel` but for brevity we keep it this way.
+Now that we have the `BasePage` finished, we can implement the two subclasses
+to finish this example.
+
+## Implementing the sub pages
+
+We need to build two pages: `Page1` and `Page2`. Each page needs its own
+markup file and Java class. Let's first implement `Page1`.
+
+{% highlight java %}
+package wicket.quickstart;
+
+import wicket.markup.html.basic.Label;
+
+public class Page1 extends BasePage {
+ public Page1() {
+ add(new Label("label1", "This is in the subclass Page1"));
+ }
+}
+{% endhighlight %}
+
+In this example you see that we add a new label component to the page:
+`label1`. This component is only available for `Page1`, as such `Page2` can
+define its own component hierarchy. Let's take a look at the markup for
+`Page1`:
+
+{% highlight java %}
+<html>
+<head></head>
+<body>
+<wicket:extend>
+ <h1>Page1</h1>
+ <span wicket:id="label1"></span>
+</wicket:extend>
+</body>
+</html>
+{% endhighlight %}
+
+Here you see that we added the `Label` component in the markup between the
+`<wicket:extend>` tags. If we were to add the component outside those tags,
+Wicket will not be able to render the component in the final page.
+
+Now, let's do the same for `Page2`.
+
+{% highlight java %}
+package wicket.quickstart;
+
+import wicket.markup.html.basic.Label;
+
+public class Page2 extends BasePage {
+ public Page2() {
+ add(new Label("label2", "This is in the subclass Page2"));
+ }
+}
+{% endhighlight %}
+
+{% highlight html %}
+<html>
+<head></head>
+<body>
+<wicket:extend>
+ <h1>Page2</h1>
+ <span wicket:id="label2"></span>
+</wicket:extend>
+</body>
+</html>
+{% endhighlight %}
+
+In `Page2` you see that we have a different component structure (`label2`
+instead of `label1`), and as such that the pages are quite different.
+
+If you paste this code into a Wicket quickstart application, you can see it
+immediately working (don't forget to set the homepage to `Page1` or `Page2`).
+
+## Conclusion
+
+With markup inheritance you can get a standard layout for your application
+without too much hassle. It follows the natural inheritance strategy for Java
+code and makes encapsulation of your component hierarchy possible.
+
+In this example we haven't touched on the other possible features of markup
+inheritance:
+
+* contributing to the `<head>` section from your sub pages
+* multiple layers of inheritance (this just works)
+* markup inheritance used with `Panel` components
+
+However, this example should get you up and running.
http://git-wip-us.apache.org/repos/asf/wicket-site/blob/8cc72bad/learn/examples/markupinheritance1.png
----------------------------------------------------------------------
diff --git a/learn/examples/markupinheritance1.png b/learn/examples/markupinheritance1.png
new file mode 100644
index 0000000..0c240da
Binary files /dev/null and b/learn/examples/markupinheritance1.png differ
http://git-wip-us.apache.org/repos/asf/wicket-site/blob/8cc72bad/learn/examples/navomatic.md
----------------------------------------------------------------------
diff --git a/learn/examples/navomatic.md b/learn/examples/navomatic.md
new file mode 100644
index 0000000..98a3da0
--- /dev/null
+++ b/learn/examples/navomatic.md
@@ -0,0 +1,268 @@
+---
+layout: default
+title: Navomatic
+category: learnmore
+---
+
+The Navomatic application shows the use of border components and links to
+create a navigation component that can easily be dropped into any web page.
+
+In all the Wicket examples, you have to put all files in the same package
+directory. This means putting the markup files and the java files next to one
+another. It is possible to alter this behavior, but that is beyond the scope
+of this example. The only exception is the obligatory web.xml file which
+should reside in the WEB-INF/ directory of your web application root folder.
+
+The link in the navigation to the current page is automatically turned into
+italic text to indicate to the user what page they are on. The first screen
+capture shows the Page1 page with the Page1 link in italics.
+
+
+
+When you click on the Page2 link, you get the following screen.
+
+
+
+As you can see, Page1 has no special style anymore, and Page2 is now displayed
+in italics. Also the message box shows that we are viewing Page2 instead of
+Page1.
+
+## Navigation component ##
+
+To create a reusable navigation component we are going to use a
+`org.apache.wicket.markup.html.border.Border` component. From the Border
+Javadoc:
+
+> A border component has associated markup which is drawn and determines
+> placement of any markup and/or components nested within the border
+> component.
+
+The portion of the border's associated markup file which is to be used in
+rendering the border is denoted by a `<wicket:border>` tag. The children of the
+border component instance are then inserted into this markup, replacing the
+first `<wicket:body/>` tag in the border's associated markup.
+
+For example, here is markup for a simple Border subclass, a usage of that
+border, and the markup which would be output on rendering:
+
+### Border markup ###
+
+{% highlight html %}
+<html>
+<body>
+ <wicket:border>
+ First <wicket:body/> Last
+ </wicket:border>
+</body>
+</html>
+{% endhighlight %}
+
+### Border usage ###
+
+{% highlight html %}
+<html>
+<body>
+ <span wicket:id = "myBorder">
+ Middle
+ </span>
+</body>
+</html>
+{% endhighlight %}
+
+### Rendered markup ###
+
+{% highlight html %}
+<html>
+<body>
+ First Middle Last
+</body>
+</html>
+{% endhighlight %}
+
+
+In other words, the markup around the `<wicket:body/>` tag in the border
+component is sort of "wrapped around" the body of the `<span>` tag where the
+border is used. This seems simple in this example, but keep in mind that
+nested components and even nested borders can appear anywhere in either markup
+file. This can be used to create quite complex effects with relatively little
+code.
+
+### NavomaticApplication.java ###
+
+Just as in the Hello World! example, we need to define our application. In
+this case, we set Page1 to be our home page.
+
+{% highlight java %}
+package org.apache.wicket.examples.navomatic;
+
+import org.apache.wicket.protocol.http.WebApplication;
+
+public class NavomaticApplication extends WebApplication {
+ public NavomaticApplication() {
+ }
+
+ public Class getHomePage() {
+ return Page1.class;
+ }
+}
+{% endhighlight %}
+
+### Page1.java ###
+
+The Page1 Java and HTML files look like this:
+
+{% highlight java %}
+package wicket.examples.navomatic;
+
+import org.apache.wicket.markup.html.WebPage;
+
+public class Page1 extends WebPage {
+ public Page1() {
+ add(new NavomaticBorder("navomaticBorder"));
+ }
+}
+{% endhighlight %}
+
+### Page1.html ###
+
+{% highlight html %}
+<html>
+<body>
+ <span wicket:id = "navomaticBorder">
+ You are viewing Page1
+ </span>
+</body>
+</html>
+{% endhighlight %}
+
+Notice that the NavomaticBorder component is attached to the `<span>` tag
+because the name of the component in the Java code is "navomaticBorder" and
+the `<span>` tag's wicket:id attribute is set to "navomaticBorder". Because the
+two names match, Wicket associates the NavomaticBorder Java component with the
+`<span>` tag.
+
+### Page2.java ###
+
+The Page2 Java and HTML files look almost identical (and we'll omit the
+sources for Page3 altogether because it follows the same pattern):
+
+{% highlight java %}
+public class Page2 extends WebPage {
+ public Page2() {
+ add(new NavomaticBorder("navomaticBorder"));
+ }
+}
+{% endhighlight %}
+
+
+### Page2.html ###
+
+{% highlight html %}
+<html>
+<body>
+ <span wicket:id = "navomaticBorder">
+ You are viewing Page2
+ </span>
+</body>
+</html>
+{% endhighlight %}
+
+### NavomaticBorder.java ###
+
+So how does NavomaticBorder work? Glad you asked. The Java code below simply
+adds the two BoxBorder components you see. These components are nested borders
+which each draw a thin black line around their contents. The rest of the magic
+is in the NavomaticBorder markup.
+
+{% highlight java %}
+package wicket.examples.navomatic;
+
+import org.apache.wicket.markup.html.border.Border;
+import org.apache.wicket.markup.html.border.BoxBorder;
+
+public class NavomaticBorder extends Border {
+ public NavomaticBorder(final String componentName) {
+ super(componentName);
+
+ addToBorder(new BoxBorder("navigationBorder"));
+ addToBorder(new BoxBorder("bodyBorder"));
+ }
+}
+{% endhighlight %}
+
+### NavomaticBorder.html ###
+
+{% highlight html %}
+<html>
+<body>
+ <wicket:border>
+ <p>
+ <table>
+ <tr>
+ <td>
+ <span wicket:id = "navigationBorder">
+ <b>Navigation Links</b>
+ <p>
+ <wicket:link>
+ <a href = "Page1.html">Page1</a><br/>
+ <a href = "Page2.html">Page2</a><br/>
+ <a href = "Page3.html">Page3</a>
+ </wicket:link>
+ </p>
+ </span>
+ </td>
+ <td>
+ <span wicket:id = "bodyBorder">
+ <wicket:body/>
+ </span>
+ </td>
+ </tr>
+ </table>
+ </p>
+ </wicket:border>
+ </body>
+</html>
+{% endhighlight %}
+
+Notice that the markup above encloses the entire contents of the markup file's
+`<body>` with a `<wicket:border>` tag, as we described earlier. This lets the
+NavomaticBorder know how much of its markup to use when it wraps itself around
+the markup it finds in the context where it is used. Notice also the
+`<wicket:body/>` marker which designates where to put whatever is found inside
+the tag at the use context.
+
+Next, notice that the navigation links and the border's `<wicket:body/>` are
+both enclosed in `<span>` tags which have wicket:id attributes that associate
+those tags with the BoxBorder components added in the NavomaticBorder
+constructor. These nested border components will each draw a thin black line
+around their contents.
+
+Finally, the `<wicket:link>` tag is used to mark the links in the navigation
+as automatic links. Ordinarily, you would need to create link components and
+attach them to your page manually, but anchor links that are marked as
+automatic are parsed and hooked up to link components for you, as appropriate.
+The italicizing behavior is also automatic. Since Wicket knows which page is
+current, it removes the anchor link tag for any link that points to the
+current page (since the link would be useless) and italicizes the link text.
+
+### web.xml ###
+
+In order to get this application up and running, we need to register the
+application with the Wicket servlet in the web.xml file. The following
+sections need to be added to the web.xml in the WEB-INF folder.
+
+{% highlight xml %}
+<servlet>
+ <servlet-name>NavomaticApplication</servlet-name>
+ <servlet-class>org.apache.wicket.protocol.http.WicketServlet</servlet-class>
+ <init-param>
+ <param-name>applicationClassName</param-name>
+ <param-value>wicket.examples.navomatic.NavomaticApplication</param-value>
+ </init-param>
+ <load-on-startup>1</load-on-startup>
+</servlet>
+<servlet-mapping>
+ <servlet-name>NavomaticApplication</servlet-name>
+ <url-pattern>/app/*</url-pattern>
+</servlet-mapping>
+{% endhighlight %}
http://git-wip-us.apache.org/repos/asf/wicket-site/blob/8cc72bad/learn/examples/navomatic1.png
----------------------------------------------------------------------
diff --git a/learn/examples/navomatic1.png b/learn/examples/navomatic1.png
new file mode 100644
index 0000000..ba9d761
Binary files /dev/null and b/learn/examples/navomatic1.png differ
http://git-wip-us.apache.org/repos/asf/wicket-site/blob/8cc72bad/learn/examples/navomatic2.png
----------------------------------------------------------------------
diff --git a/learn/examples/navomatic2.png b/learn/examples/navomatic2.png
new file mode 100644
index 0000000..e540d69
Binary files /dev/null and b/learn/examples/navomatic2.png differ
http://git-wip-us.apache.org/repos/asf/wicket-site/blob/8cc72bad/learn/examples/usingfragments.md
----------------------------------------------------------------------
diff --git a/learn/examples/usingfragments.md b/learn/examples/usingfragments.md
new file mode 100644
index 0000000..e1d3447
--- /dev/null
+++ b/learn/examples/usingfragments.md
@@ -0,0 +1,136 @@
+---
+layout: default
+title: Using Fragments
+---
+
+This example shows you how to use fragments (Wicket 1.2 feature) to lessen
+the burden on extra markup files. Fragments are 'inline panels' and are a
+quick way of using panel type components in pages without having to create a
+`Panel` markup file and class.
+
+In all the Wicket examples, you have to put all files in the same package
+directory. This means putting the markup files and the java files next to one
+another. It is possible to alter this behavior, but that is beyond the scope
+of this example. The only exception is the obligatory `web.xml` file which
+should reside in the `WEB-INF/` directory of your web application root
+folder.
+
+In this example we assume you already have read and understood the other
+examples which give you information on the structure and nature of Wicket
+applications. Specifically read and understand the [Hello, World
+example](helloworld.html).
+
+## Creating a Fragment
+
+First things first, let's create a page that we can add our fragments to. We
+will add a Loop that will repeat markup and choose a different Fragment for
+each item in the loop.
+
+{% highlight html %}
+<html>
+<head></head>
+<body>
+ <ul>
+ <li wicket:id="list"><span wicket:id="panel"></span></li>
+ </ul>
+ <wicket:fragment wicket:id="fragment1">panel 1</wicket:fragment>
+ <wicket:fragment wicket:id="fragment2">panel 2</wicket:fragment>
+</body>
+</html>
+{% endhighlight %}
+
+As you can see in this markup file, we already took care of adding the
+fragment markup to the page in the `<wicket:fragment>` tags. Each fragment
+can contain its own markup and components. Those components need to be added
+to the Fragment instance in the Java file, just as you would do with a panel
+and web markup container.
+
+{% highlight java %}
+package wicket.quickstart;
+
+import wicket.markup.html.list.Loop;
+import wicket.markup.html.panel.Fragment;
+
+public class Index extends QuickStartPage {
+ public Index() {
+ Loop loop = new Loop("list", 5) {
+ protected void populateItem(LoopItem item) {
+ String fragmentId = "fragment" + (item.getIteration() % 2 + 1);
+ item.add(new Fragment("panel", fragmentId, Index.this));
+ }
+ };
+ add(loop);
+ }
+}
+{% endhighlight %}
+
+The Loop will render 5 items, and the `populateItem` method will be called
+for each item. In each item we construct a fragment identifier that
+corresponds to the identifier in the `<wicket:fragment>`. The `Fragment`
+constructor takes the identifier of the markup it needs to attach to, and the
+fragment identifier telling it where to find the specific markup in the file.
+
+## Adding components to fragments
+
+In the previous example we just showed different markup for each fragment,
+but you can add components to the fragments as well. Let's add a label to
+fragment 1.
+
+{% highlight html %}
+<html>
+<head></head>
+<body>
+ <ul>
+ <li wicket:id="list"><span wicket:id="panel"></span></li>
+ </ul>
+ <wicket:fragment wicket:id="fragment1">panel 1 <span wicket:id="label"></span></wicket:fragment>
+ <wicket:fragment wicket:id="fragment2">panel 2</wicket:fragment>
+</body>
+</html>
+{% endhighlight %}
+
+In order to add the component to the first fragment we'll introduce a
+subclass for fragment one to encapsulate the component.
+
+{% highlight java %}
+package wicket.quickstart;
+
+import wicket.markup.html.basic.Label;
+import wicket.markup.html.list.Loop;
+import wicket.markup.html.panel.Fragment;
+
+public class Index extends QuickStartPage {
+ public class Fragment1 extends Fragment {
+ public Fragment1(String id, String markupId) {
+ super(id, markupId, Index.this);
+ add(new Label("label", "Hello, World!"));
+ }
+ }
+
+ public Index() {
+ Loop loop = new Loop("list", 5) {
+ protected void populateItem(LoopItem item) {
+ int index = (item.getIteration() % 2 + 1);
+ String fragmentId = "fragment" + index;
+ if (index == 1) {
+ item.add(new Fragment1("panel", fragmentId));
+ } else {
+ item.add(new Fragment("panel", fragmentId, Index.this));
+ }
+ }
+ };
+ add(loop);
+ }
+}
+{% endhighlight %}
+
+The class `Fragment1` adds the label to itself. In the loop's `populateItem`
+we alternate the fragments type between `Fragment` and `Fragment1`. This
+means that in the final page on one line you'll see `"panel 1 Hello, World!"`
+and on the other line just `"panel 2"`.
+
+## Summary
+
+Fragments make a quick way to add encapsulated components without having to
+resort to setting the visibility flag on a markup container. For fragments we
+introduced a new Wicket tag: `<wicket:fragment>`.